kushi-agents 4.4.4 → 4.7.4

package/plugin/skills/pull-email/SKILL.md

@@ -19,7 +19,7 @@ Pulls **email** evidence in two shapes per `snapshot-vs-stream.instructions.md`:
 - **snapshot/** — (none — emails ARE events, no snapshot)
 - **stream/** — messages with full body, sender, recipients, attachments, reply chain — grouped by thread
 
-Thoroughness per `evidence-thoroughness.instructions.md`; runtime detector + auto-retry + paste-prompt per `thoroughness-detector.instructions.md`. Citations per `citation-ledger.instructions.md`. Side-by-side mutable hints written immediately on discovery per `side-by-side-config.instructions.md`.
+Thoroughness per `evidence-thoroughness.instructions.md`; runtime detector + auto-retry + paste-prompt per `evidence-thoroughness.instructions.md`. Citations per `citation-ledger.instructions.md`. Side-by-side mutable hints written immediately on discovery per `side-by-side-config.instructions.md`.
 
 ## Inputs
 
@@ -190,3 +190,13 @@ The pre-Step-C anti-summary doctrine + the Step-C AI Narrative Summary per threa
 - Enumeration step (Step A) failed → write `_index/<date>_message-index.md` with failure marker, log to run-log errors, do NOT proceed to per-message loop.
 - Per-message fetch failed → record marker, continue.
 - All paths failed → write evidence file with `❌ all paths failed` marker, log to run-log errors, continue with rest of run.
+
+## References (v4.4.7)
+
+- Name → ID resolution follows ..\..\instructions\fuzzy-disambiguation.instructions.md (universal fuzzy contract).
+- After this pull completes, the per-source verification gate runs: ..\..\instructions\per-source-verification-gate.instructions.md (retry once, then write FOLLOW-UPS.md).
+
+
+## Issue Recovery
+
+When this skill exposes a reusable defect (auth pattern, doctrine gap, layout mismatch), apply the [Issue Recovery Rule](../../instructions/issue-recovery.instructions.md): fix the smallest correct repo-owned artifact first, prefer durable fixes over per-run workarounds, then re-run the narrowest failed check. Do NOT use memory as a substitute for correcting the workflow surface.

package/plugin/skills/pull-loop/README.md

@@ -0,0 +1,64 @@
+# pull-loop runner
+
+Pulls Microsoft Loop evidence (workspaces + pages) using Playwright with the persisted M365 profile. WorkIQ is used for discovery + page-edit stream; Playwright is the PRIMARY body-capture path.
+
+See `SKILL.md` for the full doctrine.
+
+## One-time setup
+
+Loop reuses the OneNote-for-Web Playwright profile. If you've already run the OneNote bootstrap, you're done.
+
+```pwsh
+cd <kushi-repo-root>
+node plugin/skills/pull-onenote/runner.mjs --bootstrap
+```
+
+The bootstrap signs you into OneNote-for-Web and visits SharePoint surfaces — the same profile cookies authenticate Loop-for-Web.
+
+## Pre-flight (check reachability)
+
+```pwsh
+cd <kushi-repo-root>
+node plugin/skills/pull-loop/runner.mjs --preflight
+```
+
+Exits `0` on success, `3` on auth-required (re-run the OneNote bootstrap).
+
+## Per-workspace run (recommended — use the wrapper)
+
+```pwsh
+cd <kushi-repo-root>
+node plugin/skills/pull-loop/write-snapshot.mjs `
+  --project "<project>" `
+  --workspace-url "https://<tenant>.loop.microsoft.com/loop/p/<workspaceId>/_workspace" `
+  --engagement-root "<engagement-root>" `
+  --alias <your-alias>
+```
+
+The wrapper enumerates registered pages, scrapes each, writes the canonical snapshot layout, upserts `m365-mutable.json#knownSections.<project>.loop.workspaces[].loop_pages[]`, and emits a run report.
+
+## Per-page run
+
+```pwsh
+node plugin/skills/pull-loop/runner.mjs `
+  --project "<project>" `
+  --page-url "https://<tenant>.loop.microsoft.com/loop/p/<workspaceId>/<pageId>"
+```
+
+## Output structure
+
+```
+<engagement-root>/<project>/Evidence/<alias>/loop/
+├── snapshot/
+│   └── <workspace-slug>/
+│       ├── _workspace.md
+│       └── <page-slug>.md
+└── refresh-reports/
+    └── <timestamp>_loop.md
+```
+
+## Notes
+
+- **Profile location.** v4.6.0+ writes to `~/.kushi/playwright-profile/m365/`. Older installs at `~/.kushi/playwright-profile/onenote/` are still read as a fallback.
+- **Synthesized URLs are forbidden.** Only canonical Loop URLs (observed in WorkIQ responses or registered during setup) may be passed to the runner. See `plugin/learnings/loop.md`.
+- **Standalone Loop components** embedded in Teams/OneNote/Email are captured by their host source's pull skill, NOT by `pull-loop`.

package/plugin/skills/pull-loop/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: "pull-loop"
+version: "1.0.0"
+description: "Pull Microsoft Loop evidence (snapshot: full page bodies; stream: page-edit events). Workspaces + pages are registered during setup per loop-bootstrap-discovery.instructions.md. Browser-scrape (Playwright with persisted M365 profile) is the PRIMARY capture path because fluid-framework page bodies are not reliably returned by Graph/Search. WorkIQ remains the fallback when the profile is auth-expired AND is used for discovery + page-edit metadata. Reuses the OneNote-for-Web Playwright profile."
+---
+
+# Skill: pull-loop
+
+> **Doctrine contracts** — This skill operates under the standard pull-* doctrine set:
+> - `verbatim-by-default.instructions.md` — full page bodies by default; no preview-grade pulls.
+> - `m365-id-registry.instructions.md` — discover-once / consume-deterministically (workspaceId + pageId schema).
+> - `loop-bootstrap-discovery.instructions.md` — workspace/page registration shape + flow.
+> - `capture-learnings.instructions.md` — every Loop-specific fix logs to `plugin/learnings/loop.md`.
+> - `cleanup-on-resolution.instructions.md` — when a page resolves, all stale `unresolved` / `page-body-unavailable` markers are upgraded in the same turn.
+> - `run-reports.instructions.md` — every refresh writes a per-user report under `Evidence/<alias>/refresh-reports/`.
+> - `evidence-thoroughness.instructions.md` — runtime detector + auto-retry; partial body = failure not "ok".
+> - `evidence-layout-canonical.instructions.md` — all artifacts under `<project>/Evidence/<alias>/loop/{snapshot,stream}/`.
+> - `per-source-verification-gate.instructions.md` — gate §2 loop row + §2a canonical kind.
+> - `issue-recovery.instructions.md` — apply when discovery or capture exposes a doctrine gap.
+
+Pulls **loop** evidence in two shapes per `snapshot-vs-stream.instructions.md`:
+
+- **snapshot/** — full Loop page bodies — one file per registered page with `lastModified` + verbatim body
+- **stream/** — page-edit events (who edited what, when) since last watermark — one file per ISO week in the window
+
+Standalone Loop components embedded in Teams/OneNote/Email are NOT captured here — they are captured by their host source's pull skill to avoid double-counting. See `loop-bootstrap-discovery.instructions.md` §Surface model.
+
+## Tools (in order)
+
+1. **Playwright (browser-scrape, persisted M365 profile)** — PRIMARY. Drives Loop-for-Web to render each registered page and read the verbatim body. Profile at `~/.kushi/playwright-profile/m365/` (falls back to `~/.kushi/playwright-profile/onenote/` for older installs — both are valid M365-wide profiles). Implementation: `plugin/skills/pull-loop/runner.mjs`.
+2. **WorkIQ** — FALLBACK for body capture when Playwright profile is auth-expired (`auth-required`). PRIMARY for the **stream** shape (page-edit metadata) and for discovery during setup. Always cite `m365-id-registry` doctrine when invoking.
+3. **Host (m365_*)** — not used. Graph Loop API is preview-only and incomplete; do not call directly.
+
+## Canonical CLI invocations
+
+### Bootstrap (one-time per machine)
+
+Loop reuses the OneNote Playwright profile. Run the OneNote bootstrap if you haven't already:
+
+```pwsh
+cd <kushi-repo-root>
+node plugin/skills/pull-onenote/runner.mjs --bootstrap
+```
+
+The bootstrap signs you into OneNote-for-Web, then visits SharePoint surfaces. The same profile authenticates Loop-for-Web — no separate Loop bootstrap is needed.
+
+### Pre-flight (check profile + reachability)
+
+```pwsh
+cd <kushi-repo-root>
+node plugin/skills/pull-loop/runner.mjs --preflight
+```
+
+Exits `0` on success, `3` on `auth-required` (re-run the OneNote bootstrap).
+
+### Scrape a workspace (production)
+
+Use the wrapper, not the bare runner. The wrapper writes the snapshot in the canonical layout, upserts the per-user mutable registry, and emits a run report:
+
+```pwsh
+cd <kushi-repo-root>
+node plugin/skills/pull-loop/write-snapshot.mjs `
+  --project "<project>" `
+  --workspace-url "<workspace-url-from-m365-mutable.json>" `
+  --engagement-root "<engagement-root>" `
+  --alias <your-alias>
+```
+
+The wrapper:
+
+1. Loads `m365-mutable.json#knownSections.<project>.loop` for the workspace.
+2. Enumerates registered `loop_pages[]`.
+3. Invokes `runner.mjs` once per page (or once per workspace with `--titles` filter for partial runs).
+4. Writes snapshot files at canonical paths.
+5. Upserts each `loop_pages[].last_status` + `last_captured_at` + `captured_via`.
+6. Emits `refresh-reports/<timestamp>_loop.md`.
+
+## Output structure (per `evidence-layout-canonical.instructions.md`)
+
+```
+<engagement-root>/<project>/Evidence/<alias>/loop/
+├── snapshot/
+│   ├── <workspace-slug>/
+│   │   ├── _workspace.md                                <- workspace metadata (title, owner, page list)
+│   │   ├── <page-slug>.md                               <- one per page; verbatim body
+│   │   └── ...
+│   └── _index.md                                        <- workspaces enumerated this run
+└── stream/
+    └── YYYY-MM-DD_loop-stream.md                        <- per-ISO-week page-edit events
+```
+
+Every artifact carries the frontmatter required by `per-source-verification-gate.instructions.md` §2a:
+
+```yaml
+---
+source: loop
+project: <project>
+workspace_id: <id>
+page_id: <id>
+captured_at: <ISO-8601>
+captured_via: playwright | workiq
+evidence_source_kind: page-body | page-body-unavailable | tree-only
+---
+```
+
+`evidence_source_kind` values (canonical → fallbacks):
+
+- `page-body` — Playwright rendered the page and the full body was captured. **Canonical.**
+- `page-body-unavailable` — Playwright reached the page but body was empty / fluid container did not render (page is a stub or component-only). Coverage notes MUST explain.
+- `tree-only` — Only workspace metadata + page-list was captured (no page bodies). Used when WorkIQ-only path runs because Playwright auth is expired.
+
+## Pre-flight gates (run before EVERY scrape)
+
+Per `loop-bootstrap-discovery.instructions.md`:
+
+| Pre-flight | Failure action |
+|---|---|
+| **A. Workspaces registered** for the resolved project | Refuse to run. Instruct user to run `@Kushi setup --reconfigure`. |
+| **B. Pages registered** OR `loop_pages_status: to-be-enumerated` | Run page enumeration via WorkIQ first; on enumerate-fail, write FOLLOW-UPS.md per the gate. |
+| **C. Playwright profile exists** at `~/.kushi/playwright-profile/m365/` or `.../onenote/` | Refuse; instruct: `node plugin/skills/pull-onenote/runner.mjs --bootstrap`. |
+| **D. URLs are canonical** (matches Loop URL grammar; not synthesized) | Refuse + log to learnings/loop.md per `issue-recovery.instructions.md`. |
+
+## Verification gate (per `per-source-verification-gate.instructions.md`)
+
+After every `pull-loop` run, the gate verifies:
+
+- Snapshot shape: at least one `snapshot/<workspace-slug>/<page-slug>.md` ≥ 200 bytes per registered page, OR a documented `page-body-unavailable` annotation in coverage notes.
+- Stream shape: `stream/YYYY-MM-DD_loop-stream.md` covers every ISO week in the run window OR is `.empty` with reason.
+- Registry consistency: every `loop_pages[].last_status` was updated this run (no stale `unresolved` from previous runs unless the page truly remains unresolved).
+- `evidence_source_kind` annotation present on every written artifact.
+- Citation: spot-check 3 random assertions per `citation-ledger.instructions.md`.
+
+## Boundary contract
+
+Per `loop-bootstrap-discovery.instructions.md` §Boundary:
+
+```yaml
+# <project>/integrations.yml
+boundaries:
+  loop:
+    workspace_ids: []      # REQUIRED — empty = source disabled (never silently widens)
+    page_ids: []           # optional — pin specific pages
+    include_components: false
+```
+
+## How users invoke this
+
+Direct invocation is uncommon — this skill is normally dispatched by:
+
+- `@Kushi bootstrap <project>` (full per-source loop)
+- `@Kushi refresh <project>` (per-source loop)
+- `@Kushi aggregate <project>` (pull-only loop)
+
+Direct:
+
+```text
+@Kushi pull loop <project>
+@Kushi pull loop <project> last 14 days
+```
+
+## What this skill never does
+
+- Never captures standalone Loop components from Teams/OneNote/Email — those belong to their host source (avoids double-counting).
+- Never falls back to Graph (Loop Graph API is preview-only and incomplete) — see `deferred-retry-on-workiq-fail.instructions.md`.
+- Never synthesizes a `pageUrl` from `workspaceId + pageId` — only URLs observed in WorkIQ responses or registered during setup are valid. See `issue-recovery.instructions.md` for why (mirrors OneNote learnings).
+- Never sends outbound messages.
+- Never reads/writes outside the resolved project's folder.
+
+## References
+
+- `../../instructions/loop-bootstrap-discovery.instructions.md` — workspace/page registration.
+- `../../instructions/per-source-verification-gate.instructions.md` — gate §2 + §2a.
+- `../../instructions/fuzzy-disambiguation.instructions.md` — workspace title → ID resolution.
+- `../../instructions/issue-recovery.instructions.md` — Issue Recovery Rule applies when discovery or capture exposes a doctrine gap; fix the smallest correct repo-owned artifact first; never use memory as a substitute.
+- `../../learnings/loop.md` — Loop-specific fixes accumulated across runs.
+- `docs/concepts/loop-source.md` — user-facing companion doc.
+
+## Issue Recovery
+
+When this skill exposes a reusable defect (auth pattern, doctrine gap, layout mismatch), apply the [Issue Recovery Rule](../../instructions/issue-recovery.instructions.md): fix the smallest correct repo-owned artifact first, prefer durable fixes over per-run workarounds, then re-run the narrowest failed check. Do NOT use memory as a substitute for correcting the workflow surface.

package/plugin/skills/pull-loop/runner.mjs

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+// pull-loop runner — browser-scrape via Playwright with the persisted M365 profile.
+// Per pull-loop SKILL.md v1.0.0 (kushi v4.6.0).
+//
+// Usage:
+//   node runner.mjs --preflight                                            # check reachability; exits 0/3
+//   node runner.mjs --project <p> --workspace-url <url>                    # enumerate + fetch all pages
+//   node runner.mjs --project <p> --page-url <url>                         # fetch a single page
+//   node runner.mjs --project <p> --workspace-url <url> --titles "a,b"     # partial filter by page title
+//   node runner.mjs --project <p> --workspace-url <url> --headless         # scheduled / unattended
+//
+// Output is a single JSON object on stdout:
+//   {
+//     project, workspaceUrl,
+//     pages: [{ pageId, pageUrl, pageTitle, last_status, captured_via, body, bodyLen, capturedAt, evidence_source_kind }],
+//     runStatus: 'ok' | 'auth-required' | 'workspace-unavailable' | 'partial',
+//     authRequiredCount, exitedEarly, preflight: { ok, reason?, detail? }
+//   }
+//
+// runStatus 'workspace-unavailable' means Loop-for-Web itself failed to render. The driver
+// MUST surface it as a clear diagnostic and skip the run rather than retry blindly.
+//
+// The driver is responsible for:
+//   - merging per-page records into m365-mutable.json#knownSections.<projectKey>.loop.workspaces[].loop_pages[]
+//   - writing snapshot pages/*.md
+//   - writing the run report
+
+import { chromium } from 'playwright';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import process from 'node:process';
+
+const args = Object.fromEntries(
+  process.argv.slice(2).reduce((acc, cur, idx, arr) => {
+    if (cur.startsWith('--')) {
+      const key = cur.replace(/^--/, '');
+      const next = arr[idx + 1];
+      acc.push([key, next && !next.startsWith('--') ? next : true]);
+    }
+    return acc;
+  }, [])
+);
+
+// Profile resolution: prefer the M365-wide profile; fall back to the OneNote profile
+// (which is M365-wide in older installs).
+function resolveProfileDir() {
+  const m365 = path.join(os.homedir(), '.kushi', 'playwright-profile', 'm365');
+  const onenote = path.join(os.homedir(), '.kushi', 'playwright-profile', 'onenote');
+  if (fs.existsSync(m365)) return m365;
+  if (fs.existsSync(onenote)) return onenote;
+  return m365; // default for fresh installs (will be created on first bootstrap)
+}
+
+const PROFILE_DIR = resolveProfileDir();
+const HEADLESS = !!args.headless;
+const PREFLIGHT = !!args.preflight;
+const PROJECT = args.project || null;
+const WORKSPACE_URL = args['workspace-url'] || null;
+const PAGE_URL = args['page-url'] || null;
+const TITLES_FILTER = args.titles ? String(args.titles).split(',').map(s => s.trim()).filter(Boolean) : null;
+const TIMEOUT_MS = parseInt(args.timeout || '60000', 10);
+const SETTLE_MS = parseInt(args.settle || '3000', 10);
+const PREFLIGHT_TIMEOUT_MS = parseInt(args['preflight-timeout'] || '25000', 10);
+
+if (!PREFLIGHT && !PROJECT) {
+  console.error('Usage: --project <name> (--workspace-url <url> | --page-url <url>) [--headless] [--titles "t1,t2"]');
+  console.error('       --preflight   (check Loop-for-Web is reachable; exits 0/3)');
+  process.exit(2);
+}
+if (!PREFLIGHT && !WORKSPACE_URL && !PAGE_URL) {
+  console.error('Either --workspace-url or --page-url is required.');
+  process.exit(2);
+}
+
+// Loop URL grammar — per loop-bootstrap-discovery.instructions.md §Surface model.
+// We accept canonical Loop URLs only; synthesized URLs (constructed from IDs) are FORBIDDEN.
+function isCanonicalLoopUrl(u) {
+  if (!u) return false;
+  try {
+    const url = new URL(u);
+    const host = url.hostname.toLowerCase();
+    if (!host.endsWith('.loop.microsoft.com') && host !== 'loop.cloud.microsoft' && !host.endsWith('.fluidpreview.office.net')) {
+      return false;
+    }
+    return true;
+  } catch { return false; }
+}
+
+async function waitForAuthOrLoopShell(page, timeoutMs) {
+  // Loop-for-Web renders inside an iframe with role=main or a #fluid-container surface.
+  // We detect either Loop chrome rendering (success) or an Office sign-in redirect (auth-required).
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const url = page.url();
+    if (/login\.microsoftonline\.com|login\.live\.com|login\.cloud\.microsoft/.test(url)) {
+      return { ok: false, reason: 'auth-required', detail: `redirected to ${url}` };
+    }
+    const hasShell = await page.evaluate(() => {
+      return !!(document.querySelector('[role="main"]') ||
+                document.querySelector('#fluid-container') ||
+                document.querySelector('[data-automationid="loop-page"]') ||
+                document.querySelector('[class*="LoopPage"]'));
+    }).catch(() => false);
+    if (hasShell) return { ok: true };
+    await page.waitForTimeout(500);
+  }
+  return { ok: false, reason: 'render-timeout', detail: `no Loop shell in ${timeoutMs}ms` };
+}
+
+async function extractPageBody(page) {
+  // Loop pages render rich content as a Fluent UI surface. Body extraction strategy:
+  //   1. Prefer [data-automationid="loop-page-body"] or the main editor surface.
+  //   2. Fall back to [role="main"] textContent.
+  //   3. Capture the title from <h1> or document.title.
+  await page.waitForTimeout(SETTLE_MS);
+  return await page.evaluate(() => {
+    function textOf(el) {
+      if (!el) return '';
+      return (el.innerText || el.textContent || '').replace(/\u00a0/g, ' ').trim();
+    }
+    const candidates = [
+      document.querySelector('[data-automationid="loop-page-body"]'),
+      document.querySelector('[data-automationid="loop-page"]'),
+      document.querySelector('[class*="LoopPageBody"]'),
+      document.querySelector('[role="main"]')
+    ].filter(Boolean);
+    const bodyEl = candidates[0] || document.body;
+    const title = textOf(document.querySelector('h1')) || document.title || '';
+    const body = textOf(bodyEl);
+    return { title, body, bodyLen: body.length };
+  });
+}
+
+async function enumeratePages(page) {
+  // From a workspace _workspace surface, extract the page list (titles + URLs).
+  await page.waitForTimeout(SETTLE_MS);
+  return await page.evaluate(() => {
+    const links = Array.from(document.querySelectorAll('a[href*="/loop/p/"]'));
+    const out = [];
+    const seen = new Set();
+    for (const a of links) {
+      const href = a.href;
+      if (seen.has(href)) continue;
+      seen.add(href);
+      // Skip the _workspace surface itself.
+      if (/\/_workspace(\?|$)/.test(href)) continue;
+      const title = (a.innerText || a.textContent || '').trim();
+      out.push({ pageUrl: href, pageTitle: title });
+    }
+    return out;
+  });
+}
+
+(async () => {
+  let context;
+  try {
+    context = await chromium.launchPersistentContext(PROFILE_DIR, {
+      headless: HEADLESS,
+      viewport: { width: 1400, height: 900 }
+    });
+  } catch (e) {
+    console.log(JSON.stringify({
+      project: PROJECT, workspaceUrl: WORKSPACE_URL, pageUrl: PAGE_URL,
+      pages: [], runStatus: 'auth-required',
+      preflight: { ok: false, reason: 'profile-launch-failed', detail: String(e?.message || e) }
+    }));
+    process.exit(3);
+  }
+
+  const page = await context.newPage();
+
+  if (PREFLIGHT) {
+    try {
+      await page.goto('https://loop.microsoft.com/', { timeout: PREFLIGHT_TIMEOUT_MS });
+      const shell = await waitForAuthOrLoopShell(page, PREFLIGHT_TIMEOUT_MS);
+      console.log(JSON.stringify({ preflight: shell, runStatus: shell.ok ? 'ok' : 'auth-required' }));
+      await context.close();
+      process.exit(shell.ok ? 0 : 3);
+    } catch (e) {
+      console.log(JSON.stringify({ preflight: { ok: false, reason: 'navigate-failed', detail: String(e?.message || e) }, runStatus: 'auth-required' }));
+      await context.close();
+      process.exit(3);
+    }
+  }
+
+  // Body capture path
+  if (PAGE_URL) {
+    if (!isCanonicalLoopUrl(PAGE_URL)) {
+      console.log(JSON.stringify({ project: PROJECT, pages: [], runStatus: 'partial', preflight: { ok: false, reason: 'non-canonical-url', detail: PAGE_URL } }));
+      await context.close(); process.exit(2);
+    }
+    try {
+      await page.goto(PAGE_URL, { timeout: TIMEOUT_MS });
+      const shell = await waitForAuthOrLoopShell(page, TIMEOUT_MS);
+      if (!shell.ok) {
+        console.log(JSON.stringify({ project: PROJECT, pageUrl: PAGE_URL, pages: [], runStatus: shell.reason === 'auth-required' ? 'auth-required' : 'workspace-unavailable', preflight: shell }));
+        await context.close(); process.exit(shell.reason === 'auth-required' ? 3 : 4);
+      }
+      const extracted = await extractPageBody(page);
+      const evidence_source_kind = extracted.bodyLen > 0 ? 'page-body' : 'page-body-unavailable';
+      console.log(JSON.stringify({
+        project: PROJECT, pageUrl: PAGE_URL,
+        pages: [{ pageUrl: PAGE_URL, pageTitle: extracted.title, body: extracted.body, bodyLen: extracted.bodyLen, last_status: extracted.bodyLen > 0 ? 'ok' : 'page-body-unavailable', captured_via: 'playwright', capturedAt: new Date().toISOString(), evidence_source_kind }],
+        runStatus: extracted.bodyLen > 0 ? 'ok' : 'partial'
+      }));
+      await context.close(); process.exit(0);
+    } catch (e) {
+      console.log(JSON.stringify({ project: PROJECT, pageUrl: PAGE_URL, pages: [], runStatus: 'workspace-unavailable', preflight: { ok: false, reason: 'navigate-failed', detail: String(e?.message || e) } }));
+      await context.close(); process.exit(4);
+    }
+  }
+
+  // Workspace enumerate + fetch all pages
+  if (!isCanonicalLoopUrl(WORKSPACE_URL)) {
+    console.log(JSON.stringify({ project: PROJECT, workspaceUrl: WORKSPACE_URL, pages: [], runStatus: 'partial', preflight: { ok: false, reason: 'non-canonical-url', detail: WORKSPACE_URL } }));
+    await context.close(); process.exit(2);
+  }
+
+  try {
+    await page.goto(WORKSPACE_URL, { timeout: TIMEOUT_MS });
+    const shell = await waitForAuthOrLoopShell(page, TIMEOUT_MS);
+    if (!shell.ok) {
+      console.log(JSON.stringify({ project: PROJECT, workspaceUrl: WORKSPACE_URL, pages: [], runStatus: shell.reason === 'auth-required' ? 'auth-required' : 'workspace-unavailable', preflight: shell }));
+      await context.close(); process.exit(shell.reason === 'auth-required' ? 3 : 4);
+    }
+    const found = await enumeratePages(page);
+    const filtered = TITLES_FILTER ? found.filter(p => TITLES_FILTER.some(t => p.pageTitle.toLowerCase().includes(t.toLowerCase()))) : found;
+    const out = [];
+    let authRequiredCount = 0;
+    for (const p of filtered) {
+      try {
+        await page.goto(p.pageUrl, { timeout: TIMEOUT_MS });
+        const ps = await waitForAuthOrLoopShell(page, Math.min(TIMEOUT_MS, 30000));
+        if (!ps.ok) {
+          if (ps.reason === 'auth-required') authRequiredCount += 1;
+          out.push({ pageUrl: p.pageUrl, pageTitle: p.pageTitle, body: '', bodyLen: 0, last_status: ps.reason, captured_via: 'playwright', capturedAt: new Date().toISOString(), evidence_source_kind: 'page-body-unavailable' });
+          continue;
+        }
+        const ext = await extractPageBody(page);
+        out.push({
+          pageUrl: p.pageUrl, pageTitle: ext.title || p.pageTitle,
+          body: ext.body, bodyLen: ext.bodyLen,
+          last_status: ext.bodyLen > 0 ? 'ok' : 'page-body-unavailable',
+          captured_via: 'playwright',
+          capturedAt: new Date().toISOString(),
+          evidence_source_kind: ext.bodyLen > 0 ? 'page-body' : 'page-body-unavailable'
+        });
+      } catch (e) {
+        out.push({ pageUrl: p.pageUrl, pageTitle: p.pageTitle, body: '', bodyLen: 0, last_status: 'fetch-error', captured_via: 'playwright', capturedAt: new Date().toISOString(), evidence_source_kind: 'page-body-unavailable', error: String(e?.message || e) });
+      }
+    }
+    const okCount = out.filter(p => p.last_status === 'ok').length;
+    const runStatus = authRequiredCount > 0 ? 'partial' : (okCount === out.length && out.length > 0 ? 'ok' : (okCount > 0 ? 'partial' : 'workspace-unavailable'));
+    console.log(JSON.stringify({ project: PROJECT, workspaceUrl: WORKSPACE_URL, pages: out, runStatus, authRequiredCount }));
+    await context.close(); process.exit(0);
+  } catch (e) {
+    console.log(JSON.stringify({ project: PROJECT, workspaceUrl: WORKSPACE_URL, pages: [], runStatus: 'workspace-unavailable', preflight: { ok: false, reason: 'navigate-failed', detail: String(e?.message || e) } }));
+    await context.close(); process.exit(4);
+  }
+})();