@mjasnikovs/pi-task 0.39.2 → 0.39.4

package/dist/task/run-final-gate.js

@@ -1,7 +1,7 @@
 import { AutofixLedger } from './autofix-ledger.js';
 import { describeDebt, recordDebt } from './accept-debt.js';
 import { cancelCheckpoint } from './cancel-points.js';
-import { SessionUI } from '../remote/bridge.js';
+import { SessionUI, notifyBoth, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, yoloFinalGateChoice, YOLO_STAMP } from './yolo.js';
 import { ignoredWriteTrailLine, ignoredWriteDebtReason } from './write-guard.js';
 import { readOwnedRequirements } from './requirements.js';
@@ -76,7 +76,7 @@ export async function runFinalGateStage(active, deps, p) {
     // Set when the gate finished having observed NOTHING dynamic. Declared out here so
     // the run-completion announcement can say so.
     let unobservedNote = null;
-    active.ui.notify(`${id}: running final integration gate…`, 'info');
+    notifyBoth(active, `${id}: running final integration gate…`, 'info');
     // Run-level gate trail on the parent task file — same durable auditability
     // contract as the per-task `## gates` records.
     const recGate = async (line) => {
@@ -111,7 +111,7 @@ export async function runFinalGateStage(active, deps, p) {
         unobservedNote = fin.unobserved;
         await recGate(`final-gate: UNOBSERVED — ${fin.reason.slice(0, 300)}`);
         await carryDebt(fin.unobserved);
-        active.ui.notify(`${id}: the final integration gate observed NOTHING dynamic — `
+        notifyRun(active, `${id}: the final integration gate observed NOTHING dynamic — `
             + 'the run completed on static checks alone. Nothing verified '
             + 'that the assembled product builds, boots or works.', 'warning');
     }
@@ -132,7 +132,7 @@ export async function runFinalGateStage(active, deps, p) {
         for (const d of debts) {
             await recGate(`defect STILL OPEN — ${d.taskId || '(unknown task)'}: ${describeDebt(d)}: ${d.reason.slice(0, 240)}${d.conflict ? ` [CONFLICTING CLAIM — ${d.conflict}]` : ''}`);
         }
-        active.ui.notify(`${id}: ${debts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
+        notifyRun(active, `${id}: ${debts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
     };
     // What was REPORTED, so a post-autofix re-derivation can be compared against it
     // rather than blindly re-printed.
@@ -149,7 +149,7 @@ export async function runFinalGateStage(active, deps, p) {
             + ` ${(o.pending ?? []).join(', ')}]`);
     }
     if (unclaimed.length > 0) {
-        active.ui.notify(`${id}: ${unclaimed.length} authoritative design requirement(s) ended the run`
+        notifyRun(active, `${id}: ${unclaimed.length} authoritative design requirement(s) ended the run`
             + ' owned by NO task — the task they were mapped to could not touch the'
             + ' file, and nothing else claimed it. See the gate trail.', 'warning');
     }
@@ -315,7 +315,7 @@ export async function runFinalGateStage(active, deps, p) {
             // commit — the ACCEPT is a decision about the FAILING gate, never an
             // instruction to throw away work.
             await commitStranded('accepted');
-            active.ui.notify(`${id}: final integration gate FAIL accepted by user — completing.`
+            notifyRun(active, `${id}: final integration gate FAIL accepted by user — completing.`
                 + (ledger.stranded().length > 0 ?
                     ` ${ledger.stranded().length} uncommitted fix-pass change(s) committed separately.`
                     : ''), 'warning');
@@ -324,7 +324,7 @@ export async function runFinalGateStage(active, deps, p) {
         if (choice.action === 'autofix' && canAutofix) {
             const attempt = ledger.attempt();
             await recGate(`final-gate: user chose AUTOFIX (attempt ${attempt}/${MAX_FINAL_GATE_AUTOFIX})`);
-            active.ui.notify(`${id}: final-gate autofix (${attempt}/${MAX_FINAL_GATE_AUTOFIX}) — bounded fix pass, then the gate re-runs…`, 'info');
+            notifyRun(active, `${id}: final-gate autofix (${attempt}/${MAX_FINAL_GATE_AUTOFIX}) — bounded fix pass, then the gate re-runs…`, 'info');
             const seed = choice.guidance ? `${fin.reason}\n\nUser guidance: ${choice.guidance}` : fin.reason;
             const fix = await deps.finalGateFix(active, cwd, seed, [...ledger.ignoredWrites()]);
             // IGNORED-PATH WRITES. The pass wrote file(s) git ignores, so
@@ -355,7 +355,7 @@ export async function runFinalGateStage(active, deps, p) {
                     await carryDebt(fix.unobserved);
                 }
                 await recGate(`final-gate: autofix ${fix.unobserved ? 'ended UNOBSERVED' : 'converged'} — ${fix.reason.slice(0, 200)}`);
-                active.ui.notify(`${id}: final integration gate ${fix.unobserved ? 'is UNOBSERVED' : 'PASSES'} after autofix — ${fix.reason.slice(0, 140)}`, fix.unobserved ? 'warning' : 'info');
+                notifyRun(active, `${id}: final integration gate ${fix.unobserved ? 'is UNOBSERVED' : 'PASSES'} after autofix — ${fix.reason.slice(0, 140)}`, fix.unobserved ? 'warning' : 'info');
                 // The gate's own outcome, WHOLE, with this door's reason on it.
                 // Rebuilding it as a two-key literal would drop `openDebts` and
                 // `observedFailures` from the value entirely.
@@ -380,7 +380,7 @@ export async function runFinalGateStage(active, deps, p) {
                 await recGate(`final-gate: autofix attempt ${attempt} left ${ledger.stranded().length} `
                     + `uncommitted change(s) — ${ledger.stranded().slice(0, 8).join(', ')}`);
             }
-            active.ui.notify(`${id}: final-gate autofix did not converge — ${fix.reason.slice(0, 140)}`, 'warning');
+            notifyRun(active, `${id}: final-gate autofix did not converge — ${fix.reason.slice(0, 140)}`, 'warning');
             // NON-PROGRESS CLASSIFIER. An attempt that changed the tree, re-ran the
             // gate, and got back the SAME ranked-first failure as the previous such
             // attempt is evidence about the CHECK, not about the fix — a check that
@@ -396,7 +396,7 @@ export async function runFinalGateStage(active, deps, p) {
                 await recGate(`final-gate: check DEMOTED to UNOBSERVED after ${attempt} tree-changing `
                     + `attempts returned an identical failure — carried as debt (origin final-gate) `
                     + `and re-checked by the next run's gate: ${verdict.detail.slice(0, 240)}`);
-                active.ui.notify(`${id}: final-gate check is unfalsifiable in this environment — carried as debt; `
+                notifyRun(active, `${id}: final-gate check is unfalsifiable in this environment — carried as debt; `
                     + 'the remaining checks decide convergence.', 'warning');
             }
             // Convergence on the REMAINING checks: a demoted signature no longer counts
@@ -409,7 +409,7 @@ export async function runFinalGateStage(active, deps, p) {
                     const converged = `converged on all remaining checks; ${ledger.demotedCount()} check(s) `
                         + 'carried as UNOBSERVED debt (unfalsifiable in this environment)';
                     await recGate(`final-gate: ${converged}`);
-                    active.ui.notify(`${id}: final integration gate converged — ${converged}.`, 'warning');
+                    notifyRun(active, `${id}: final integration gate converged — ${converged}.`, 'warning');
                     // The gate's own outcome, with this door's reason on it — the
                     // whole value, so `openDebts` survives the assignment.
                     fin = { ...fix.gate, ok: true, reason: converged };

package/dist/task/task-gates.js

@@ -1,6 +1,6 @@
 import { verifyFailClass } from './verify-work.js';
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
-import { SessionUI } from '../remote/bridge.js';
+import { SessionUI, notifyBoth, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, yoloVerifyResolution, YOLO_STAMP } from './yolo.js';
 import { extractFailingCommand, findRepairCandidate, summariseDefect } from './root-cause-repair.js';
 import { attributeEnforceFailure } from './enforce-attribution.js';
@@ -92,7 +92,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
     // accept-override leaves this false → enforce runs flag-only.
     let verifyCleanPass = false;
     if (deps.verify) {
-        active.ui.notify(`${p.tag}: verifying "${p.title}"…`, 'info');
+        notifyBoth(active, `${p.tag}: verifying "${p.title}"…`, 'info');
         let verified = await deps.verify(active, p.cwd, p.title, p.taskId);
         await rec(verdictLine(verified));
         // A FAIL no longer dead-stops. When the research recommends AUTOFIX, pi
@@ -122,7 +122,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             const failClass = verifyFailClass(verified);
             if (!lintFixAttempted && deps.lintFix && failClass === 'repo-health') {
                 lintFixAttempted = true;
-                active.ui.notify(`${p.tag}: static findings on "${p.title}" — attempting bounded lint fix…`, 'info');
+                notifyRun(active, `${p.tag}: static findings on "${p.title}" — attempting bounded lint fix…`, 'info');
                 const fix = await deps.lintFix(active, p.cwd, p.title, p.taskId, failReason);
                 await rec(`lint-fix: ${fix.ok ?
                     `applied${fix.reason ? ` (${fix.reason})` : ''} — re-verifying`
@@ -239,7 +239,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                     `resolution: auto-AUTOFIX (${YOLO_STAMP} rescue — judge recommended ACCEPT with the unattended `
                         + `budget unspent; one attempt, ${autoFixCount}/${MAX_AUTO_AUTOFIX})`
                     : `resolution: auto-AUTOFIX (recommended, unattended ${autoFixCount}/${MAX_AUTO_AUTOFIX})`);
-                active.ui.notify(`${p.tag}: verify FAIL on "${p.title}" — auto-fixing (${yoloRescueNow ? `${YOLO_STAMP} one attempt before accepting` : 'recommended'}, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
+                notifyRun(active, `${p.tag}: verify FAIL on "${p.title}" — auto-fixing (${yoloRescueNow ? `${YOLO_STAMP} one attempt before accepting` : 'recommended'}, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
                 choice = { action: 'autofix' };
             }
             else {
@@ -286,7 +286,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                         // recording must never break the gate sequence
                     }
                 }
-                active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.${byYolo ? ` ${YOLO_STAMP}` : ''}`, 'warning');
+                notifyRun(active, `${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.${byYolo ? ` ${YOLO_STAMP}` : ''}`, 'warning');
                 break;
             }
             // AUTOFIX: re-run the implementation turn with the failure (and any typed
@@ -302,7 +302,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             if (!autoFixNow && !yoloRescueNow) {
                 await rec('resolution: user chose AUTOFIX — re-running the implementation turn');
             }
-            active.ui.notify(`${p.tag}: autofixing "${p.title}"…`, 'info');
+            notifyBoth(active, `${p.tag}: autofixing "${p.title}"…`, 'info');
             const diagnosis = (recOutcome.recommend === 'autofix'
                 && recOutcome.rationale.length > 0
                 && recOutcome.rationale !== failReason) ?
@@ -396,7 +396,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 const reverted = await deps.revertFrozenPaths(p.cwd, frozen);
                 if (reverted.length > 0) {
                     await rec(`enforce: frozen-path write DENIED — reverted ${reverted.length} spec-frozen file(s) the edit pass modified: ${reverted.join(', ')}`);
-                    active.ui.notify(`${p.tag}: guideline edits on "${p.title}" touched spec-frozen path(s) (${reverted.join(', ').slice(0, 120)}) — reverted before commit.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline edits on "${p.title}" touched spec-frozen path(s) (${reverted.join(', ').slice(0, 120)}) — reverted before commit.`, 'warning');
                 }
             }
         }
@@ -408,7 +408,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
         const editsMade = mode === 'edit' && deps.dirty ? await deps.dirty(p.cwd) : undefined;
         await rec(`enforce(${mode}): ${verdict.ok ? `clean${verdict.reason ? ` (${verdict.reason})` : ''}` : (verdict.reason ?? 'not clean')}${editsMade ? ' — edits in tree' : ''}`);
         if (!verdict.ok) {
-            active.ui.notify(`${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
+            notifyRun(active, `${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
         }
         // PRE-COMMIT health gate on enforce edits: an edit pass that breaks the
         // repo's own lint would otherwise burn a commit, a model re-verify and a
@@ -443,7 +443,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 else {
                     await rec(`enforce: edits REGRESSED repo health pre-commit (${after.reason}) — no discard available, left uncommitted${outputTail}`);
                 }
-                active.ui.notify(`${p.tag}: guideline edits on "${p.title}" regressed repo health (${after.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
+                notifyRun(active, `${p.tag}: guideline edits on "${p.title}" regressed repo health (${after.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
             }
             else if (!after.ok) {
                 // Failing both before and after → not enforce's fault. Keep the edits;
@@ -512,7 +512,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 if (!after.ok && rootCause) {
                     await rec(`enforce: re-verify FAILED (${afterReason.slice(0, 200)}) but the failure is attributed to a PRE-EXISTING defect in \`${rootCause.file}\` `
                         + `(${rootCause.owner}'s file, untouched by the ENFORCE COMMIT whose fate this differential decides) — edits KEPT, not reverted; repair task queued`);
-                    active.ui.notify(`${p.tag}: guideline fixes on "${p.title}" re-verified red on a pre-existing defect in ${rootCause.file} (${rootCause.owner}'s file) — keeping the fixes, queued a repair task.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline fixes on "${p.title}" re-verified red on a pre-existing defect in ${rootCause.file} (${rootCause.owner}'s file) — keeping the fixes, queued a repair task.`, 'warning');
                 }
                 else if (!after.ok && attribution?.verdict === 'keep') {
                     // KEEP, mechanically justified: every file the failing check named
@@ -547,7 +547,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                             // queueing a repair must never break the gate sequence
                         }
                     }
-                    active.ui.notify(`${p.tag}: guideline fixes on "${p.title}" re-verified red on ${attribution.file ?? 'a file'} — outside the enforce diff, so keeping the fixes and recording the defect.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline fixes on "${p.title}" re-verified red on ${attribution.file ?? 'a file'} — outside the enforce diff, so keeping the fixes and recording the defect.`, 'warning');
                 }
                 else if (!after.ok) {
                     if (deps.revert)
@@ -567,11 +567,11 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                     // gate re-checks and surfaces it (static-class auto-closes if a
                     // later task fixed the statics; otherwise it stays open).
                     await deps.recordDebt?.(p.cwd, p.taskId, after.reason ?? 'enforce re-verify failed', 'enforce-revert');
-                    active.ui.notify(`${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
                 }
                 else {
                     await rec('enforce: fixes committed — re-verify PASS, kept');
-                    active.ui.notify(`${p.tag}: committed guideline fixes for "${p.title}".`, 'info');
+                    notifyRun(active, `${p.tag}: committed guideline fixes for "${p.title}".`, 'info');
                 }
             }
             else {
@@ -651,7 +651,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 + `${commit.excluded.slice(0, 8).join(', ')}`
                 + `${commit.excluded.length > 8 ? `, +${commit.excluded.length - 8} more` : ''}`);
         }
-        active.ui.notify(`${p.tag}: committed "${p.title}".`, 'info');
+        notifyBoth(active, `${p.tag}: committed "${p.title}".`, 'info');
     }
     else {
         await rec(`commit: skipped (${commit.reason ?? 'unknown'})`);
@@ -661,9 +661,15 @@ export async function runGatesForTask(ctxIn, deps, p) {
         // warnings to show for it. "blocked" is the unmerged-index refusal
         // (gitCommitAll) — the same severity: nothing can commit until it's resolved.
         const gitFailure = /^git (commit|add) (failed|blocked)/.test(commit.reason ?? '');
-        active.ui.notify(gitFailure ?
+        const line = gitFailure ?
             `${p.tag}: COMMIT FAILED (${commit.reason}) — enforce and revert guards are disabled for this task.`
-            : `${p.tag}: not committed (${commit.reason ?? 'unknown'}) — continuing.`, gitFailure ? 'error' : 'warning');
+            : `${p.tag}: not committed (${commit.reason ?? 'unknown'}) — continuing.`;
+        // A git failure means the whole task ran unguarded. A remote user cannot
+        // infer that from the widget, and a toast is gone before they look.
+        if (gitFailure)
+            notifyRun(active, line, 'error');
+        else
+            notifyBoth(active, line, 'warning');
     }
     await runEnforcePass(active, deps, p, rec, routeRootCause, { cleanPass, commit });
     return { kind: 'done', ctx: active };

package/dist/task/widget.js

@@ -115,8 +115,6 @@ export function buildWidgetData(s) {
 }
 // ─── Widget lifecycle ────────────────────────────────────────────────────────
 export function startWidget(ctx, getState) {
-    if (!ctx.hasUI)
-        return () => { };
     // pi's `ctx.ui` getter calls `runner.assertActive()`, which THROWS once the
     // ctx goes stale (/reload, session replacement) — so the theme read belongs
     // INSIDE the guard, not one line above it. render() runs from a timer, and a
@@ -128,7 +126,12 @@ export function startWidget(ctx, getState) {
         if (stale)
             return;
         const s = getState();
-        const plain = s ? buildWidgetLines(s, undefined) : undefined; // un-themed for the wire; needs no ctx
+        // The wire half FIRST, and unguarded: it needs no ctx, so gating it on a
+        // local terminal that may not exist would leave a headless host's browser
+        // with no phase, no progress and no failure flash.
+        setTaskWidget(s ? buildWidgetLines(s, undefined) : undefined, s ? buildWidgetData(s) : null);
+        if (!ctx.hasUI)
+            return;
         try {
             const lines = s ? buildWidgetLines(s, ctx.ui.theme) : undefined;
             ctx.ui.setWidget(WIDGET_KEY, lines);
@@ -136,9 +139,7 @@ export function startWidget(ctx, getState) {
         catch {
             stale = true;
             clearInterval(timer);
-            return;
         }
-        setTaskWidget(plain, s ? buildWidgetData(s) : null);
     };
     // The timer is created BEFORE the first render so `timer` is always bound
     // when render's catch reaches for it. Calling render() first instead would
@@ -208,16 +209,15 @@ export function buildAutoLoaderData(s) {
  * (returns a no-op disposer) when there's no UI.
  */
 export function startAutoLoader(ctx, getState) {
-    if (!ctx.hasUI)
-        return () => { };
-    // Same staleness hazard as startWidget: the theme read must sit inside the
-    // guard, and a stale ctx stops the timer rather than throwing every tick.
+    // Same staleness hazard as startWidget, and the same wire-half-first order.
     let stale = false;
     const render = () => {
         if (stale)
             return;
         const s = getState();
-        const plain = s ? buildAutoLoaderLines(s, undefined) : undefined; // needs no ctx
+        setTaskWidget(s ? buildAutoLoaderLines(s, undefined) : undefined, s ? buildAutoLoaderData(s) : null);
+        if (!ctx.hasUI)
+            return;
         try {
             const lines = s ? buildAutoLoaderLines(s, ctx.ui.theme) : undefined;
             ctx.ui.setWidget(AUTO_WIDGET_KEY, lines);
@@ -225,9 +225,7 @@ export function startAutoLoader(ctx, getState) {
         catch {
             stale = true;
             clearInterval(timer);
-            return;
         }
-        setTaskWidget(plain, s ? buildAutoLoaderData(s) : null);
     };
     // The timer is created BEFORE the first render so `timer` is always bound
     // when render's catch reaches for it. Calling render() first instead would
@@ -277,40 +275,33 @@ export function buildImplData(s) {
     return d;
 }
 export function flashTerminalWidget(ctx, state, taskId, reason) {
-    if (!ctx.hasUI)
-        return;
-    // Same staleness hazard as the render timers: bail rather than throw.
-    let theme;
-    try {
-        theme = ctx.ui.theme;
-    }
-    catch {
-        return;
-    }
-    let line;
-    let clearMs;
-    if (state === 'cancelled') {
-        line = theme.fg('warning', `⚠ ${taskId} cancelled`);
-        clearMs = NOTIFY_CLEAR_MS;
-    }
-    else {
-        line = theme.fg('error', `✘ ${taskId} failed${reason ? ': ' + reason : ''}`);
-        clearMs = FAIL_CLEAR_MS;
-    }
     const plainLine = state === 'cancelled' ?
         `⚠ ${taskId} cancelled`
         : `✘ ${taskId} failed${reason ? ': ' + reason : ''}`;
-    try {
-        ctx.ui.setWidget(WIDGET_KEY, [line]);
-        setTaskWidget([plainLine]);
-    }
-    catch {
-        /* stale ctx */
+    const clearMs = state === 'cancelled' ? NOTIFY_CLEAR_MS : FAIL_CLEAR_MS;
+    setTaskWidget([plainLine]);
+    // The wire half is already done, so a missing or stale local ctx no longer
+    // costs the browser the flash as well. Same staleness hazard as the render
+    // timers: bail rather than throw.
+    if (ctx.hasUI) {
+        try {
+            const theme = ctx.ui.theme;
+            const tint = state === 'cancelled' ? 'warning' : 'error';
+            ctx.ui.setWidget(WIDGET_KEY, [theme.fg(tint, plainLine)]);
+        }
+        catch {
+            /* stale ctx */
+        }
     }
     setTimeout(() => {
+        // Wire first, for the same reason as the flash above: a ctx that went
+        // stale in the meantime would otherwise leave the browser showing the
+        // flash for the rest of the session.
+        setTaskWidget(undefined);
+        if (!ctx.hasUI)
+            return;
         try {
             ctx.ui.setWidget(WIDGET_KEY, undefined);
-            setTaskWidget(undefined);
         }
         catch {
             /* stale ctx */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.39.2",
+    "version": "0.39.4",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",