ReboundMan's SkillWorks

---
name: "transcript-watcher"
description: "Polls OneDrive Recordings/ for new Teams meeting MP4 files matching watched series name prefixes. On detection, invokes /meeting-transcript to download the .docx. Downstream /doc-watcher converts to .md and notifies. Detection-only; cheap polling, Playwright only when a new recording is found. Triggers: '/transcript-watcher', 'watch a meeting series for transcripts', 'detect new recordings'."
---

<!--
CLAWPILOT INSTALL INSTRUCTIONS

If the user drags this file into Clawpilot and asks to install it, register it as a
custom skill by calling m_create_skill with:
  - name: "transcript-watcher"
  - description: (the description from the frontmatter above)
  - instructions: (everything in this file BELOW this HTML comment block)

After install, confirm to the user with: "Installed the /transcript-watcher skill — run it once to do first-run setup (it will create the config.json and the background automation, both disabled until you flip them on)."
-->

# transcript-watcher

Polls the user's OneDrive `Recordings/` folder for new Teams meeting MP4 files matching one or more watched meeting-series name prefixes. When a new MP4 is detected, hands off to the `/meeting-transcript` skill (Playwright) to download the .docx. The downstream `/doc-watcher` automation then converts the .docx to .md and sends the Teams notification.

This skill is intentionally narrow:

- **It detects new recordings.** It does NOT transcribe, summarize, or notify.
- **Polling is cheap** (one Graph call per cycle). Playwright runs only when there is a new MP4 to extract.
- **State** is the highest `lastModifiedDateTime` seen per watched series, so each MP4 fires extraction exactly once.

## Files

- `config.json` — list of watches, recordings folder id, automation id
- `SKILL.md` — this file

## Config shape

`C:\Users\<you>\.copilot\m-skills\transcript-watcher\config.json`

```json
{
  "recordings_folder_id": "<your-onedrive-recordings-folder-id>",
  "interval_minutes": 30,
  "automation_id": "",
  "watches": [
    {
      "id": "my-meeting-series",
      "display_name": "My Meeting Series",
      "name_prefix": "My Meeting Series",
      "chat_id": "19:meeting_<your-chat-id>@thread.v2",
      "last_seen_modified": "2026-01-01T00:00:00Z"
    }
  ]
}
```

- `recordings_folder_id` — OneDrive folder id for `Documents/Recordings`. Stable per user; reuse across watches.
- `interval_minutes` — polling cadence (15 / 30 / 60).
- `automation_id` — populated after `m_create_automation`.
- `watches[].name_prefix` — the literal filename prefix Stream uses. Format is `<Meeting Subject>-YYYYMMDD_HHMMSSUTC-Meeting Recording.mp4`. Match by `name.startswith(name_prefix + "-")`.
- `watches[].chat_id` — meeting chat id; passed to `/meeting-transcript` so it knows which chat to open.
- `watches[].last_seen_modified` — ISO 8601 UTC timestamp. Only files with `lastModifiedDateTime > last_seen_modified` are treated as new.

## When the user invokes `/transcript-watcher`

Read `config.json` via `view`. If it does not exist → **first-run setup** (section A). Otherwise → **poll cycle** (section B).

If the user explicitly says "dry run", "test", or "what would fire", run section B with the **dry-run flag** (do NOT invoke `/meeting-transcript`, do NOT update state — only report what would be triggered).

## A. First-run setup

Collect via `m_ask_user`:

1. **Meeting display name** for this watch (e.g. "Weekly Standup"). Use this as the `name_prefix`.
2. **Polling interval** — 15 / 30 / 60 (default 30).

Then auto-derive:

1. **Recordings folder id**: list OneDrive root via `m365_list_files(limit=50)` and find the entry named `Recordings`. If not found in the first page, page until found, or ask the user to provide a path.
2. **Chat id**: `m365_search_chats(query=display_name, limit=5)`. If exactly one result, use it. If multiple, surface them via `m_ask_user` and let the user pick.
3. **Baseline `last_seen_modified`**: list the Recordings folder (`m365_list_files(folderId=recordings_folder_id, orderBy="lastModifiedDateTime desc", limit=20)`), filter to items starting with `name_prefix + "-"`, take the max `modified`. If no matching files exist, set baseline to the current UTC time. This prevents history from re-firing.

Write `config.json` via `create`.

Then create the automation via `m_create_automation`:

```
name: transcript-watcher
schedule: every <interval_minutes> minutes
prompt: (the section B prompt verbatim — see "Automation prompt" at the bottom)
enabled: false   # important: leave OFF until the user explicitly enables it
```

Save the returned automation id back into `config.json`.

Tell the user: "Watcher configured but NOT activated. Run `/transcript-watcher` to dry-run, or say `enable transcript watcher` to flip it on."

## B. Poll cycle

For each `watch` in `config.json.watches`:

1. `m365_list_files(folderId=config.recordings_folder_id, orderBy="lastModifiedDateTime desc", limit=20)`
2. Filter the returned items in memory to those where:
   - `name` starts with `watch.name_prefix + "-"`
   - `mimeType` is `video/mp4` (or filename ends with `.mp4`)
   - `modified` (ISO timestamp) is strictly greater than `watch.last_seen_modified`
3. Sort the matches by `modified` ascending (so we process oldest-first; that way if extraction crashes mid-batch the state advance is monotonic).
4. For each new MP4:
   - **Dry run:** just report `{watch_id, filename, modified}` and continue. Do NOT invoke the transcript skill. Do NOT update state.
   - **Live run:** Invoke `/meeting-transcript` with the meeting **chat-id** and let it handle the recording-start-time lookup from the chat thread (see meeting-transcript SKILL.md Step 3). The meeting-transcript skill already names the output `<slug>-<date>-<HHMM>.docx` and drops it in the configured transcripts folder, which doc-watcher is already watching. We do not need to pass a filename — just the chat id.
   - After successful invocation, update `watch.last_seen_modified = file.modified` and persist `config.json` immediately (don't batch state updates — crash-safety).
5. If no matching new files for any watch: stay completely silent (no Teams ping, no chat output). The automation runs every 30 min and we don't want noise.

## C. Reconfigure

- "add watch <name>" → run setup steps 1 + auto-derive chat id + baseline for that watch, append to `watches[]`.
- "remove watch <id>" → drop that entry.
- "enable transcript watcher" → `m_update_automation(id=automation_id, enabled=true)`.
- "disable transcript watcher" → `m_update_automation(id=automation_id, enabled=false)`.
- "change interval to <n>" → update config + `m_update_automation(schedule="every <n> minutes")`.

## D. Failure modes (handle defensively)

- `/meeting-transcript` extraction fails (Stream not ready, Playwright timeout, transcript not yet processed) → do NOT advance `last_seen_modified`. Report the error in chat (or via Teams DM if running from automation) so the user knows. Next poll will retry.
- Two new MP4s in a single meeting (Teams sometimes splits recordings on reconnect) → process each one. The chat-thread "Meeting started at ..." will identify each occurrence's start time correctly, so filenames won't collide.
- Multiple watches share `name_prefix` collisions (e.g. "Sync" matches several series) → require name prefixes that are unique. The skill does not de-collide; the user must pick distinct prefixes.

## Automation prompt

When creating the automation in section A, pass this as the prompt:

```
Run /transcript-watcher in poll-cycle mode. Do not prompt the user. If any new MP4 is found, invoke /meeting-transcript with the watch's chat_id for each new file, then persist the updated last_seen_modified to C:\Users\<you>\.copilot\m-skills\transcript-watcher\config.json. If no new files, stay completely silent — no Teams message, no chat output. If /meeting-transcript fails for any file, do NOT advance last_seen_modified for that file and send a single Teams DM via m_send_teams_message: "transcript-watcher: extraction failed for <filename> (<error>). Will retry next cycle. Sent on your behalf by Clawpilot 🤖"
```

## Privacy

Meeting recordings + transcripts are sensitive. This skill never sends transcript content to chat or Teams; it only triggers the existing downstream skills, which already follow the user's notification preferences.

---
name: "meeting-transcript"
description: "Download the transcript of a recorded Teams meeting from its meeting chat. Resolves the chat to its online meeting and saves the transcript (.docx by default, .vtt optional) to a local folder. Triggers: 'get the transcript', 'download the meeting transcript', 'transcript for this meeting', or pasting a Teams meeting chat link and asking for the transcript."
---

<!--
CLAWPILOT INSTALL INSTRUCTIONS

If the user drags this file into Clawpilot and asks to install it, register it as a
custom skill by calling m_create_skill with:
  - name: "meeting-transcript"
  - description: (the description from the frontmatter above)
  - instructions: (everything in this file BELOW this HTML comment block)

Before first use, the user MUST replace the two {{...}} placeholders in the
Configuration section below with their own values. After install, confirm with:
"Installed the /meeting-transcript skill — open SKILL.md and fill in DEFAULT_OUTPUT_DIR
and TENANT_ID before first invoking it."
-->

# meeting-transcript

Download the full transcript of a recorded Teams meeting as a `.docx` (default) or `.vtt` by automating the Stream Transcript pane's native Download button.

> **Before first use:** open this file and replace the two `{{...}}` placeholders in the **Configuration** section below with your own values. Everything else works out of the box.

## Configuration (fill these in before first use)

- **`{{DEFAULT_OUTPUT_DIR}}`** — Absolute path to the folder where transcripts should be saved by default. Example: `C:\Users\<you>\Documents\MeetingTranscripts\`. The skill will create it if it doesn't exist.
- **`{{TENANT_ID}}`** — Your Microsoft 365 tenant GUID (the value Teams uses in `?tenantId=...` URLs). Find it at <https://portal.azure.com> → Microsoft Entra ID → Overview → Tenant ID, or by opening any Teams deep link in your browser and copying the `tenantId` query parameter.

## When to use
- User asks for the transcript / notes of a recorded Teams meeting they pasted a link, subject, or chat to.
- User wants the raw text of what was said in a past Teams call.
- Invoked programmatically by `/transcript-watcher` when a new MP4 lands in OneDrive Recordings.

## Inputs
- A Teams meeting link (`/meet/...`, `/l/meetup-join/...`, or `/l/chat/...`), OR
- A meeting subject (e.g. "Weekly Standup"), OR
- A chat ID (`19:meeting_<...>@thread.v2`).
- Optional format override: `vtt` (default is `docx`).
- Optional output directory override (default: `{{DEFAULT_OUTPUT_DIR}}`).

## Defaults (and how to override)

- **Default output directory:** `{{DEFAULT_OUTPUT_DIR}}`
  - If the user specifies a different directory at invocation time (e.g. "save it to my Desktop", "put it in Projects/Foo"), use that and create it if missing (`New-Item -ItemType Directory -Force`).
- **Default format:** `.docx` — always use "Download as .docx" unless the user explicitly says they want `.vtt` (e.g. "give me the vtt", "I need the captions file", "with timestamps as vtt"). For `.vtt`, click `Download as .vtt` instead.
- **Filename:** `<meeting-slug>-<YYYY-MM-DD>-<HHMM>.<ext>` where **both `<YYYY-MM-DD>` and `<HHMM>` come from the *recording start time*** — i.e. the "Meeting started at ..." line in the chat thread, in the user's local timezone. 24-hour, no colon. Example: a recording that started today at 8:31 AM local becomes `weekly-standup-2026-05-23-0831.docx`.

## CRITICAL: Timestamp source

**ALWAYS use the recording start time from the chat thread's "Meeting started at H:MM AM/PM" line. NEVER use the Recap picker's combobox label.**

The Recap picker (the "Select the meeting by time" dropdown) shows the **scheduled** occurrence the transcript was associated with — e.g. it may say "Friday, May 22, 2026 6:15 PM - 6:30 PM" even when the actual recording was started early at 8:31 AM today. The scheduled time is **wrong** for filename purposes. The user wants the time the recording actually started, which is only visible in the chat thread.

If you accidentally proceeded past Step 3 without capturing the recording start time, **go back to the chat thread and capture it before saving the file**.

## The verified flow

The Transcript pane uses **virtualization** — DOM scraping is unreliable for anything longer than ~3 minutes. Always automate the native Download button.

### Step 1: Find the chat
- If user gave a subject: `m365_search_chats query="<subject>"` → grab the `id` field (`19:meeting_<...>@thread.v2`).
- If user gave a `/l/chat/<id>/...` URL, extract `<id>` from the URL.
- URL-encode the chat ID (`:` → `%3A`, `@` → `%40`, or `encodeURIComponent`).

### Step 2: Open the chat (signed-in Teams web surface)
- Navigate to: `https://teams.microsoft.com/l/chat/<encoded-id>/0?tenantId={{TENANT_ID}}`
- If "Choose how to open" appears, click "Use the web app instead".
- If that page goes blank, navigate directly to `https://teams.cloud.microsoft/v2/#/l/chat/<encoded-id>/0?tenantId={{TENANT_ID}}`.
- Wait ~8 s for the chat thread to load.

### Step 3 (CRITICAL): Capture recording date AND start time from the chat thread

**Do this BEFORE clicking the Transcript button.** Once you navigate away to the Recap surface you lose easy access to the chat thread's "Meeting started" lines.

Scroll to the bottom of the chat thread, then extract the visually-lowest "Meeting started at ..." entry. Teams formats it three ways depending on recency:
- `Meeting started at 5/12 5:54 PM` — explicit M/D (older than ~1 week)
- `Meeting started at Monday 12:14 PM` — day name (within the last week)
- `Meeting started at 8:31 AM` — bare time (today)

You must resolve all three into a concrete `{date: YYYY-MM-DD, hhmm: HHMM}` in the user's local timezone. Use the system clock for "today" and the most-recent-past occurrence for day names.

```js
async (page) => {
  await page.evaluate(() => {
    const btns = Array.from(document.querySelectorAll('button'))
      .filter(b => /^Transcript$/i.test((b.textContent||'').trim()));
    if (btns.length) btns[btns.length-1].scrollIntoView({block:'end'});
  });
  await page.waitForTimeout(1500);

  return await page.evaluate(() => {
    const all = Array.from(document.querySelectorAll('div, span, li'))
      .filter(el => {
        const t = (el.textContent||'').trim();
        return /Meeting started at /i.test(t) && t.length < 200;
      })
      .map(el => ({y: el.getBoundingClientRect().top, text: (el.textContent||'').trim()}));
    all.sort((a,b)=> b.y - a.y);
    for (const c of all) {
      const after = c.text.replace(/^.*Meeting started at\s+/i, '').replace(/Meeting started.*$/i, '').trim();
      const mDate = after.match(/^(\d{1,2})\/(\d{1,2})\s+(\d{1,2}):(\d{2})\s*(AM|PM)/i);
      const mDay  = after.match(/^(Sun|Mon|Tue|Wed|Thu|Fri|Sat)[a-z]*\s+(\d{1,2}):(\d{2})\s*(AM|PM)/i);
      const mTime = after.match(/^(\d{1,2}):(\d{2})\s*(AM|PM)/i);
      if (mDate || mDay || mTime) {
        return {
          raw: after.substring(0, 60),
          mDate: mDate && {month: +mDate[1], day: +mDate[2], hr: +mDate[3], min: mDate[4], ampm: mDate[5].toUpperCase()},
          mDay:  mDay  && {dayName: mDay[1], hr: +mDay[2], min: mDay[3], ampm: mDay[4].toUpperCase()},
          mTime: !mDate && !mDay && mTime && {hr: +mTime[1], min: mTime[2], ampm: mTime[3].toUpperCase()}
        };
      }
    }
    return null;
  });
}
```

Then resolve to `{date, hhmm}` in PowerShell or JS using the system clock:
- **Case A (mDate):** assume current year; if M/D > today, subtract 1 year.
- **Case B (mDay):** walk back from today to find the most recent matching weekday (could be today).
- **Case C (mTime):** date = today.

Convert hr+AM/PM to 24-hour, then `HHMM = sprintf("%02d%s", h24, min)`.

**Verified mappings (PT, May 2026):**
- `Meeting started at 8:31 AM` on Sat 5/23 → `date=2026-05-23, hhmm=0831`
- `Meeting started at Thursday 10:25 AM` viewed on Sat 5/23 → `date=2026-05-21, hhmm=1025`
- `Meeting started at 5/12 5:54 PM` viewed in 2026 → `date=2026-05-12, hhmm=1754`

### Step 4: Open the Transcript pane

Click the **last** `Transcript` button in the chat thread (one button per recorded occurrence; last = most recent):

```js
const buttons = Array.from(document.querySelectorAll('button'))
  .filter(b => /^Transcript$/i.test((b.textContent||'').trim()));
buttons[buttons.length-1].click();
```

This routes to the Stream playback surface with the Transcript pane open in a right-hand iframe at `microsoft-my.sharepoint.com/.../xplatplugins.aspx`. Wait ~6 s for the iframe to load.

**DO NOT trust the Recap picker's combobox label** ("Select the meeting by time") — it shows the *scheduled* occurrence the recording is filed under, which can differ from the actual recording start. If the picker label and the chat-thread "Meeting started" line disagree, the chat thread wins.

### Step 5: Click Download → "Download as .docx" (or .vtt if requested)

```js
async (page, format = 'docx') => {
  const tFrame = page.frames().find(f => f.url().includes('xplatplugins.aspx'));
  if (!tFrame) throw new Error('Transcript iframe not found - wait longer for load');

  await tFrame.getByRole('button', {name: 'Download'}).click();
  await page.waitForTimeout(500);

  const menuLabel = format === 'vtt' ? /Download as \.vtt/ : /Download as \.docx/;

  const [download] = await Promise.all([
    page.waitForEvent('download', {timeout: 30000}),
    tFrame.getByRole('menuitem', {name: menuLabel}).click()
  ]);

  return download;
}
```

### Step 6: Save with `<slug>-<YYYY-MM-DD>-<HHMM>.<ext>`

```powershell
$dir = "<override or {{DEFAULT_OUTPUT_DIR}}>"
New-Item -ItemType Directory -Force -Path $dir | Out-Null
$slug = "<kebab-case of meeting subject>"
$date = "<YYYY-MM-DD from Step 3 — recording date>"
$hhmm = "<HHMM from Step 3 — recording start time, NOT scheduled time>"
$ext  = "docx"
$path = Join-Path $dir "$slug-$date-$hhmm.$ext"
# In Playwright: await download.saveAs(path)
```

Example final names (all use *recording* start time, never scheduled time):
- `weekly-standup-2026-05-23-0831.docx` — recording started today at 8:31 AM (regardless of when the meeting was scheduled)
- `weekly-standup-2026-05-21-1025.docx` — recording started Thu 5/21 at 10:25 AM

### Step 7 (REQUIRED): Verify the file, then close the Playwright browser

After `download.saveAs(path)` resolves, confirm the file actually landed before tearing down the browser. Then close Playwright so the Edge window does not stay open.

```powershell
$f = Get-Item -LiteralPath $path -ErrorAction Stop
if ($f.Length -lt 1000) { throw "Downloaded file is suspiciously small ($($f.Length) bytes) - keeping browser open for inspection" }
```

Only if the file exists AND is a plausible size (>1 KB), call `playwright-browser_close` to shut down the browser. If verification fails, leave the browser open and surface the error to the user — do NOT close it on failure, because the user may need to retry from the current page state.

```
playwright-browser_close   # one tool call, no args
```

This is required for every invocation of the skill, including automated/background runs (e.g. when called from `/transcript-watcher`). A leftover Edge window using the Playwright user-data-dir profile will block the next Playwright session and require manual cleanup.

### Fallback time source

If Step 3 finds no "Meeting started at" line at all:
1. Look for any "Meeting started:" text inside the most recent meeting *card* (it usually shows the start time too).
2. Ask the user via `m_ask_user`: "What time did the meeting actually start (local time)?"
3. **NEVER** use the Recap picker's scheduled time. **NEVER** use UTC time from the .docx metadata.

## Pitfalls

- **TIMESTAMP SOURCE:** The Recap picker shows scheduled occurrence time, not recording start time. Always pull the time from the chat thread's "Meeting started at ..." line.
- **Short `/meet/<id>?p=...` URLs** cannot be resolved via Graph `JoinWebUrl` filter. Use the meeting subject or chat link instead.
- **Navigating to `/meet/<id>` from a fresh browser context** lands on the anonymous join launcher. Always navigate via `/l/chat/...`.
- **The Recap-tab occurrence picker** can lag by 15+ minutes after a recording ends. The chat-thread Transcript button is faster and lets you grab the recording start time before navigating away.
- **DON'T scrape the transcript DOM** for anything longer than ~3 minutes. Virtualization will silently truncate. Always use the native Download button.
- **The Download submenu lives inside the xplatplugins.aspx iframe.** Playwright's `getByRole` reaches into it. Raw `evaluate` + manual focus/keyboard fails.
- **Wire `page.waitForEvent('download')` BEFORE the menu-item click**, using `Promise.all`. Setting it up after misses the event.
- **OneDrive does NOT auto-export the transcript .docx.** Only the `.mp4` recording auto-saves. This skill IS the export.
- **The chat may contain multiple meeting occurrences.** Grab the LAST `Transcript` button AND the visually-lowest "Meeting started at ..." line — they correspond.

## Privacy
Transcripts often contain confidential meeting content. Save locally only. Never auto-forward, summarize externally, or send to chat without explicit user OK.

## Output
Report to user: meeting subject, **recording start date + time (local)**, file path, file size, and offer to extract text or summarize. If the recap picker's scheduled time differed from the recording start time, mention that too so the user knows the filename reflects the actual start. Mention that the Playwright browser has been closed (or, on failure, that it was left open for inspection).

## Method A (Graph API, currently unavailable in most tenants)
`GET /me/onlineMeetings/{id}/transcripts/{tid}/content` would be cleanest but requires `OnlineMeetings.Read` + `OnlineMeetingTranscript.Read.All` (admin consent required). If your tenant grants these scopes to your Clawpilot token, prefer Graph; otherwise use the Playwright flow above.

---
name: "doc-watcher"
description: "Watches a folder for new documents (default *.docx) and saves a plain-text .md copy of each one using Word COM (headless). Originals are never modified or deleted. Sends a Teams DM when new files are converted. On first run, prompts for folder/pattern/interval and creates a background automation. Triggers: '/doc-watcher', 'watch this folder for docx', 'convert docx to markdown automatically'."
---

<!--
CLAWPILOT INSTALL INSTRUCTIONS

If the user drags this file into Clawpilot and asks to install it, register it as a
custom skill by calling m_create_skill with:
  - name: "doc-watcher"
  - description: (the description from the frontmatter above)
  - instructions: (everything in this file BELOW this HTML comment block)

After install, also place convert.py next to SKILL.md in the skill folder
(C:\Users\<you>\.copilot\m-skills\doc-watcher\convert.py). Confirm to the user with:
"Installed the /doc-watcher skill — invoke it to run first-run setup. It will create
config.json and a background automation, then convert any new .docx files in the
watched folder on every tick."
-->

# doc-watcher

Watches a folder for new documents (default `*.docx`) and saves a plain-text `.md` copy of each one. Originals are never modified or deleted.

This is **stage 4 of the [Teams Transcript Pipeline](../teams-transcript-pipeline/)** suite — but it's intentionally generic. Point it at any folder with any glob pattern and it'll convert Word documents to clean UTF-8 markdown using Word COM.

When the user invokes `/doc-watcher`, follow this flow.

## 1. Load config

Config path: `C:\Users\<you>\.copilot\m-skills\doc-watcher\config.json`

Shape:
```json
{
  "folder": "C:\\path\\to\\watch",
  "pattern": "*.docx",
  "out_dir": "",
  "interval_minutes": 30,
  "automation_id": ""
}
```

- `folder` — folder to watch (required)
- `pattern` — one or more globs separated by `;` (default `*.docx`)
- `out_dir` — empty string means write `.md` next to each source file
- `interval_minutes` — polling cadence for the background automation
- `automation_id` — populated after the automation is created

Read `config.json` via the `view` tool. If it does not exist, do first-run setup.

## 2. First-run setup (only when config.json is missing)

Use `m_ask_user` to collect:

1. **Folder** to watch.
2. **Pattern** — default `*.docx`. Accept multiple globs joined by `;` (e.g. `*.docx;*.rtf`).
3. **Output folder** — default empty (write `.md` next to originals).
4. **Frequency** — default 30 minutes. Offer 15 / 30 / 60.

Write the config with the `create` tool. Then create the background automation via `m_create_automation` with the prompt shown in section 5.

Save the returned automation id back into `config.json`.

## 3. Run the converter

Execute (use the values from `config.json`):

```powershell
python "C:\Users\<you>\.copilot\m-skills\doc-watcher\convert.py" `
  --folder "<folder>" `
  --pattern "<pattern>" `
  --state  "C:\Users\<you>\.copilot\m-skills\doc-watcher\state.json"
```

Add `--out "<out_dir>"` only if `out_dir` is non-empty. Add `--all` only if the user explicitly asks to reconvert everything.

The script:
- Hydrates OneDrive cloud-only files by copying to a temp location.
- Uses Word COM (via `pywin32`) to open `.doc`, `.docx`, `.docm`, `.rtf`, `.odt` and save them as Unicode text. Plain text files (`.txt`, `.md`) pass through.
- Skips files already listed in `state.json` so each run only converts new arrivals.
- Prints a JSON summary to stdout: `processed`, `skipped`, `errors`.

## 4. Notify

After the converter finishes, parse its JSON output.

**If `processed` is non-empty OR `errors` is non-empty**, ALWAYS send a Teams notification via `m_send_teams_message`. Format:

```
doc-watcher converted N new file(s) in <folder>:
- <filename1>
- <filename2>
(errors, if any, with filename + error)
Sent on your behalf by Clawpilot 🤖
```

Use just the basename of each file, not the full path. Do this whether the run was manual (user invoked `/doc-watcher`) or from the scheduled automation.

If both `processed` and `errors` are empty:
- Manual run: tell the user in chat that nothing new was found.
- Automation run: stay completely silent (no Teams message, no chat output).

Also summarize results in the chat when the user invoked the skill manually.

## 5. Automation prompt

When creating or updating the automation, use this prompt:

```
Run the doc-watcher converter silently. Read C:\Users\<you>\.copilot\m-skills\doc-watcher\config.json and execute:
python "C:\Users\<you>\.copilot\m-skills\doc-watcher\convert.py" --folder "<folder>" --pattern "<pattern>" --out "<out_dir>" --state "C:\Users\<you>\.copilot\m-skills\doc-watcher\state.json"
(omit --out if out_dir is empty). Parse the JSON output. If the "processed" list is non-empty OR "errors" is non-empty, call m_send_teams_message with:

"doc-watcher converted N new file(s) in <folder>:
- <basename>
- <basename>
(errors, if any, with filename + error)
Sent on your behalf by Clawpilot 🤖"

If both processed and errors are empty, do nothing and stay silent. Never prompt the user.
```

## 6. Reconfigure

If the user asks to change folder, pattern, frequency, or output:
- Update `config.json` accordingly.
- If `interval_minutes` changed, call `m_update_automation(id=automation_id, schedule="every <new> minutes")`.
- If the user asks to stop watching, call `m_update_automation(id=automation_id, enabled=false)`.

## Dependencies

Python 3.12+ with `pywin32`. Microsoft Word must be installed (used in headless `Visible=False` mode).

---
name: "reaction-tracker"
description: "Track who reacted to a specific Teams chat message with a specific emoji. Returns name + email for each responder and saves a CSV. Repeatable for any message/emoji combo. Triggers: 'who reacted with X', 'track reactions', 'lobster list', 'reaction tracker', or pasting a Teams message link and asking who reacted."
---

<!--
CLAWPILOT INSTALL INSTRUCTIONS

If the user drags this file into Clawpilot and asks to install it, register it as a
custom skill by calling m_create_skill with:
  - name: "reaction-tracker"
  - description: (the description from the frontmatter above)
  - instructions: (everything in this file BELOW this HTML comment block)

After install, confirm to the user with: "Installed the /reaction-tracker skill — invoke it with a Teams message link and an emoji."
-->

## Reaction Tracker Skill

Track which Teams chat members reacted to a specific message with a specific emoji. Returns a list of name + email and writes a CSV file. Reusable for any chat message and any reaction emoji.

### Inputs to gather from the user

Required:
1. **Teams message** — accepted as any of:
   - A Teams message permalink (URL of the form `https://teams.microsoft.com/l/message/<encoded-chatId>/<messageId>?...`)
   - An explicit `chatId` (e.g. `19:...@thread.v2`) plus `messageId` (numeric timestamp string)
2. **Reaction emoji** — the exact emoji to count, e.g. `🦞`, `❤️`, `👍`, `🎉`. Match strictly — only this emoji counts.

Optional:
3. **Output filename** — defaults to `reaction-tracker-<emoji-name>-<messageId>.csv` in the current workspace.

If any required input is missing, ASK the user before proceeding. Do not guess.

### Parsing a Teams message URL

URL format: `https://teams.microsoft.com/l/message/{encodedChatId}/{messageId}?...`
- `encodedChatId` is URL-encoded; decode `%3A` → `:` and `%40` → `@`. Result looks like `19:xxxx@thread.v2`.
- `messageId` is the path segment after the chat id (a numeric string).

### Execution steps

1. **Parse** the chatId and messageId from the inputs.

2. **Locate the message and its reactions**:
   - Call `m365_list_chat_messages` with `chatId` and a reasonable `limit` (start with 50).
   - The tool output is large — save and `grep`/parse for the messageId.
   - If the message isn't in the first page, increase `limit` (max 50 per call) and use `skipToken` from the paging metadata to fetch additional pages until found.
   - Once found, extract the `reactions` array. Each entry has shape: `{"reactionType":"🦞","createdDateTime":"...","userId":"<aad-guid>","userIdentityType":"aadUser"}`.

3. **Filter** reactions where `reactionType` equals the target emoji exactly (case-sensitive Unicode match). Collect the set of `userId` values and their `createdDateTime`.

4. **Resolve userIds to name + email**:
   - Call `m365_get_chat` with the same `chatId`. The response includes a `members` array; each member has `userId`, `displayName`, and `email`.
   - For each reacting `userId`, look up the matching member to get `displayName` and `email`.
   - If a reacting `userId` is NOT in the members list (rare — guest or removed user), record them as `name=Unknown, email=<userId>` and note it in the summary.

5. **Write a CSV** to the current workspace directory (use the OneDrive Clawpilot folder path):
   - Columns: `name,email,userId,reactedAt`
   - Sort by `reactedAt` ascending.
   - Default filename: `reaction-tracker-<safeEmoji>-<messageId>.csv` where `safeEmoji` is a short name like `lobster`, `heart`, `thumbsup` (ask or pick a sensible label from the emoji).

6. **Report to the user**:
   - Total count of reactors matching the emoji.
   - The list of names (and emails if asked).
   - The saved CSV path.
   - If there are reactions with OTHER emojis on the same message, mention the breakdown briefly (e.g. "Also saw 3 ❤️ and 1 👍 — not counted").

### Re-running

This skill is idempotent — running it again produces a refreshed snapshot. If the same output file exists, overwrite it (the snapshot is the latest truth). Mention to the user that they can re-run anytime to capture new reactions.

### Edge cases

- **Message not found in recent history**: page back further. If still not found after several pages, ask the user to confirm the chatId / messageId.
- **Zero reactions matching emoji**: write an empty CSV with just the header and report "No one has reacted with <emoji> yet."
- **The user hasn't posted yet**: explain that the message must exist before tracking can start, and offer to run again once they've posted.
- **Emoji normalization**: Some emojis have variation selectors (e.g. `❤️` is `❤` + U+FE0F). Match the raw `reactionType` string as returned by Graph; if no matches, try the alternate form once.

### Privacy

This is the user's own chat data. Saving the CSV locally is fine. Do NOT send the list to anyone else or post it back into the Teams chat unless the user explicitly asks.