@phyzess/pappra 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/cli/commands/docs.js

@@ -1,5 +1,5 @@
-import { discoverWorkspace } from '../../workspace/discover.js';
 import { resolveWorkspaceRoot } from '../../workspace/resolve.js';
+import { scanDiscoveredDocuments } from '../../knowledge/scan.js';
 import { formatDiagnostic } from '../../schemas/diagnostics.js';
 import { docsArchiveReportSchema, docsCheckReportSchema, docsListReportSchema, } from '../../schemas/document.js';
 import { KnowledgeService, } from '../../knowledge/index.js';
@@ -10,96 +10,32 @@ export const docsUsage = 'pappra docs <list|check|archive|scan> [options]\n' +
     '  scan   [--apply] [--json]\n\n' +
     'scan registers documents discovered under the configured knowledge sources; without\n' +
     '--apply it only reports the candidates.';
-function classifyScanKind(path) {
-    const lower = path.toLowerCase();
-    if (lower.endsWith('agents.md') || lower.endsWith('claude.md'))
-        return 'rule';
-    if (lower.includes('/research/'))
-        return 'research';
-    if (lower.includes('/adr/') || lower.includes('decision'))
-        return 'decision';
-    if (lower.includes('review') || lower.includes('retro'))
-        return 'review';
-    if (lower.includes('plan'))
-        return 'plan';
-    return 'architecture';
-}
 async function runDocsScan(options, output, root) {
-    const discovery = await discoverWorkspace(root);
-    const config = discovery.config;
-    if (config === null) {
-        return invalidArguments(output, options.json, 'docs scan requires a valid .pappra/workspace.json; run pappra init first.');
-    }
-    const service = new KnowledgeService(root);
-    const listed = await service.list({ includePrivate: true });
-    const registered = new Set(listed.records.flatMap((record) => record.location.kind === 'workspace' ? [record.location.path] : []));
-    const sources = config.knowledge.sources;
-    const visibility = config.knowledge.taskVisibility === 'shared' ? 'shareable' : 'private';
-    const candidates = (discovery.documents ?? []).flatMap((document) => {
-        const path = document.workspaceRelativePath;
-        if (path === null)
-            return [];
-        if (!sources.some((source) => path === source || path.startsWith(`${source}/`))) {
-            return [];
-        }
-        if (registered.has(path))
-            return [];
-        return [{ path, kind: classifyScanKind(path), visibility }];
-    });
+    const result = await scanDiscoveredDocuments(root, { apply: options.apply });
+    if ('message' in result) {
+        return invalidArguments(output, options.json, result.message);
+    }
     if (!options.apply) {
         if (options.json) {
-            output.stdout(`${JSON.stringify({
-                ok: true,
-                schema: 'pappra/docs-scan/1',
-                mode: 'plan',
-                workspaceRoot: root,
-                candidates,
-                registered: registered.size,
-                nextActions: [
-                    'Rerun with --apply to register these documents in the knowledge catalog.',
-                ],
-            })}\n`);
+            output.stdout(`${JSON.stringify(result)}\n`);
         }
         else {
-            output.stdout(`Scan candidates: ${candidates.length}\n`);
-            for (const candidate of candidates) {
+            output.stdout(`Scan candidates: ${result.candidates.length}\n`);
+            for (const candidate of result.candidates) {
                 output.stdout(`  ${candidate.kind}  ${candidate.path}\n`);
             }
             output.stdout('Plan only; rerun with --apply to register them.\n');
         }
         return 0;
     }
-    const registeredNow = [];
-    const diagnostics = [];
-    for (const candidate of candidates) {
-        const result = await service.register({
-            location: { kind: 'workspace', path: candidate.path },
-            kind: candidate.kind,
-            maturity: 'draft',
-            owner: 'human',
-            visibility: candidate.visibility,
-        });
-        diagnostics.push(...result.diagnostics);
-        if (result.ok)
-            registeredNow.push(result.record);
-    }
-    const ok = diagnostics.every((entry) => entry.severity !== 'error');
     if (options.json) {
-        output.stdout(`${JSON.stringify({
-            ok,
-            schema: 'pappra/docs-scan/1',
-            mode: 'apply',
-            workspaceRoot: root,
-            registered: registeredNow,
-            skipped: candidates.length - registeredNow.length,
-            diagnostics,
-        })}\n`);
+        output.stdout(`${JSON.stringify(result)}\n`);
     }
     else {
-        output.stdout(`Registered ${registeredNow.length} document(s).\n`);
-        printDiagnostics(output, diagnostics);
+        output.stdout(`Registered ${result.registered.length} document(s).\n`);
+        printDiagnostics(output, result.diagnostics);
     }
-    return ok ? 0 : 1;
+    return result.ok ? 0 : 1;
 }
 function printDiagnostics(output, diagnostics) {
     for (const diagnostic of diagnostics) {

package/dist/cli/commands/host.d.ts

@@ -4,11 +4,13 @@ export declare const hostUsage: string;
 export interface HostCommandOptions {
     readonly cwd: string;
     readonly json: boolean;
-    readonly action: 'detect' | 'describe' | 'plan' | 'install' | 'verify' | 'bundle' | null;
+    readonly action: 'detect' | 'describe' | 'plan' | 'install' | 'verify' | 'bundle' | 'mcp' | 'probe' | null;
     readonly host: HostName | null;
     readonly hostRoot: string | null;
     readonly hostVersion: string | null;
     readonly apply: boolean;
+    readonly force: boolean;
+    readonly subAction: string | null;
     readonly out: string | null;
     readonly mode: 'project-settings' | 'plugin' | null;
     readonly marketplace: boolean;

package/dist/cli/commands/host.js

@@ -2,9 +2,11 @@ import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { HostIntegrationService } from '../../hosts/integration/service.js';
 import { exportHostPluginBundle } from '../../hosts/integration/bundle-export.js';
+import { applyHostMcp, planHostMcp, verifyHostMcp, } from '../../app/host-mcp.js';
+import { probeHost } from '../../app/host-probe.js';
 import { HOST_SUPPORT, isSupportedVersion, } from '../../hosts/integration/support.js';
 import { getPackageInfo } from '../../package-info.js';
-export const hostUsage = 'pappra host <detect|describe|plan|install|verify|bundle> --host <pi|codex|claude>\n' +
+export const hostUsage = 'pappra host <detect|describe|plan|install|verify|bundle|mcp> --host <pi|codex|claude>\n' +
     '  [--host-root <dir>] [--host-version <version>] [--out <dir>]\n' +
     '  [--mode project-settings|plugin] [--apply] [--json]\n' +
     '\n' +
@@ -80,6 +82,58 @@ export async function runHostCommand(options, output) {
             ? {}
             : { hostVersion: options.hostVersion }),
     };
+    if (options.action === 'mcp') {
+        if (options.subAction !== 'plan' &&
+            options.subAction !== 'install' &&
+            options.subAction !== 'verify') {
+            output.stderr('pappra host mcp requires plan, install, or verify.\n');
+            return 2;
+        }
+        const mcpPlan = await planHostMcp(options.host, options.cwd);
+        const result = options.subAction === 'verify'
+            ? await verifyHostMcp(mcpPlan)
+            : options.subAction === 'install' && options.apply
+                ? await applyHostMcp(mcpPlan, { force: options.force })
+                : {
+                    ...mcpPlan,
+                    applied: false,
+                    verified: false,
+                    detail: null,
+                };
+        if (options.json) {
+            output.stdout(`${JSON.stringify({ schema: 'pappra/host-mcp/1', ...result })}\n`);
+        }
+        else {
+            output.stdout(`Host ${result.host} MCP: ${result.state}\n`);
+            if (result.target !== null)
+                output.stdout(`  target: ${result.target}\n`);
+            if (result.command !== null) {
+                output.stdout(`  command: ${result.command.join(' ')}\n`);
+            }
+            output.stdout(`  ${result.message}\n`);
+            if (result.detail !== null)
+                output.stdout(`  detail: ${result.detail}\n`);
+            if (options.subAction === 'install' && !options.apply) {
+                output.stdout('  plan only; rerun with --apply to write it.\n');
+            }
+        }
+        return result.verified || (!options.apply && options.subAction !== 'verify')
+            ? 0
+            : 1;
+    }
+    if (options.action === 'probe') {
+        const result = probeHost(options.host);
+        if (options.json) {
+            output.stdout(`${JSON.stringify({ schema: 'pappra/host-probe/1', ...result })}\n`);
+        }
+        else {
+            output.stdout(`Host ${result.host} probe: ${result.ok ? 'ok' : 'failed'}\n`);
+            output.stdout(`  version: ${result.version ?? '(missing)'} / pinned ${result.pinnedVersion}\n`);
+            output.stdout(`  protocol: ${result.protocol}\n`);
+            output.stdout(`  ${result.message}\n`);
+        }
+        return result.ok ? 0 : 1;
+    }
     if (options.action === 'detect' || options.action === 'describe') {
         const capabilities = service.describe(options.host);
         if (options.json) {

package/dist/cli/commands/mcp.d.ts

@@ -0,0 +1,8 @@
+import type { CliOutput } from '../output.js';
+export declare const mcpUsage: string;
+export interface McpCommandOptions {
+    readonly cwd: string;
+    readonly root: string | null;
+    readonly json: boolean;
+}
+export declare function runMcpCommand(options: McpCommandOptions, output: CliOutput): Promise<number>;

package/dist/cli/commands/mcp.js

@@ -0,0 +1,13 @@
+import { runMcpServer } from '../../mcp/server.js';
+export const mcpUsage = 'pappra mcp [--root <dir>] [--json]\n\n' +
+    'Starts the Pappra MCP server on stdio for the selected workspace. The server exposes\n' +
+    'read-only tools (workspace_status, resume, docs_list, docs_check, code_status,\n' +
+    'code_query, runtime_status). stdout carries MCP JSON-RPC; use --help outside a host.';
+export async function runMcpCommand(options, output) {
+    const root = options.root ?? options.cwd;
+    if (options.json) {
+        output.stderr('pappra mcp: --json is not used; the server speaks MCP JSON-RPC on stdout.\n');
+    }
+    await runMcpServer(root);
+    return 0;
+}

package/dist/cli/commands/task.d.ts

@@ -0,0 +1,10 @@
+import type { CliOutput } from '../output.js';
+export declare const taskUsage: string;
+export interface TaskCommandOptions {
+    readonly cwd: string;
+    readonly action: 'pin' | 'unpin' | 'show' | null;
+    readonly taskId: string | null;
+    readonly autoResume: boolean;
+    readonly json: boolean;
+}
+export declare function runTaskCommand(options: TaskCommandOptions, output: CliOutput): Promise<number>;

package/dist/cli/commands/task.js

@@ -0,0 +1,76 @@
+import { resolveWorkspaceRoot } from '../../workspace/resolve.js';
+import { pinTask, readAutoResume, readTaskPin, setAutoResume, unpinTask, } from '../../app/task-pin.js';
+export const taskUsage = 'pappra task <pin|unpin|show> [taskId] [--auto-resume] [--json]\n\n' +
+    'pin records the current task in .pappra/local/current-task. Hooks inject a resume\n' +
+    'packet only when the workspace continuity.autoResume switch is on (--auto-resume).';
+function failure(output, options, message) {
+    if (options.json) {
+        output.stdout(`${JSON.stringify({ ok: false, code: 'task_invalid', message })}\n`);
+    }
+    else {
+        output.stderr(`pappra task: ${message}\n`);
+    }
+    return 2;
+}
+export async function runTaskCommand(options, output) {
+    const resolution = await resolveWorkspaceRoot({ startPath: options.cwd });
+    const root = resolution.root;
+    if (root === null) {
+        return failure(output, options, 'task requires a registered Pappra workspace above the current directory.');
+    }
+    if (options.action === 'pin') {
+        if (options.taskId === null) {
+            return failure(output, options, 'task pin requires a task id.');
+        }
+        const pinned = await pinTask(root, options.taskId);
+        if ('message' in pinned) {
+            return failure(output, options, pinned.message);
+        }
+        if (options.autoResume) {
+            const switched = await setAutoResume(root, true);
+            if ('message' in switched) {
+                return failure(output, options, switched.message);
+            }
+        }
+        const report = {
+            ok: true,
+            action: 'pin',
+            task: pinned.taskId,
+            autoResume: options.autoResume ? true : await readAutoResume(root),
+        };
+        output.stdout(options.json
+            ? `${JSON.stringify(report)}\n`
+            : `Pinned task ${report.task}; autoResume ${report.autoResume ? 'on' : 'off'}.\n`);
+        return 0;
+    }
+    if (options.action === 'unpin') {
+        await unpinTask(root);
+        const report = { ok: true, action: 'unpin' };
+        output.stdout(options.json
+            ? `${JSON.stringify(report)}\n`
+            : 'Task pin removed; autoResume stays unchanged.\n');
+        return 0;
+    }
+    if (options.action === 'show') {
+        const pin = await readTaskPin(root);
+        const report = {
+            ok: true,
+            action: 'show',
+            pin,
+            autoResume: await readAutoResume(root),
+        };
+        output.stdout(options.json
+            ? `${JSON.stringify(report)}\n`
+            : pin === null
+                ? `No task pin; autoResume ${report.autoResume ? 'on' : 'off'}.\n`
+                : `Pinned task ${pin.taskId} at ${pin.pinnedAt}; autoResume ${report.autoResume ? 'on' : 'off'}.\n`);
+        return 0;
+    }
+    if (options.json) {
+        output.stdout(`${JSON.stringify({ commands: ['pin', 'unpin', 'show'], usage: taskUsage })}\n`);
+    }
+    else {
+        output.stdout(taskUsage);
+    }
+    return 0;
+}

package/dist/cli/run.js

@@ -2,6 +2,8 @@ import { parseArgs } from 'node:util';
 import { getPackageInfo } from '../package-info.js';
 import { initUsage, runInitCommand } from './commands/init.js';
 import { onboardUsage, runOnboardCommand } from './commands/onboard.js';
+import { mcpUsage, runMcpCommand } from './commands/mcp.js';
+import { taskUsage, runTaskCommand } from './commands/task.js';
 import { doctorUsage, runDoctorCommand } from './commands/doctor.js';
 import { docsUsage, runDocsCommand } from './commands/docs.js';
 import { checkpointUsage, resumeUsage, runCheckpointCommand, runResumeCommand, } from './commands/continuity.js';
@@ -26,6 +28,7 @@ function parseOptions(args) {
             'apply-host': { type: 'boolean' },
             'dry-run': { type: 'boolean' },
             'print-handoff': { type: 'boolean' },
+            'auto-resume': { type: 'boolean' },
             from: { type: 'string' },
             tarball: { type: 'string' },
             out: { type: 'string' },
@@ -79,6 +82,25 @@ function parseOptions(args) {
         throw new Error('Use either --help or --version, not both.');
     }
     const command = positionals[0] ?? null;
+    if (command === 'task') {
+        if (positionals.length > 3) {
+            throw new Error('task accepts one action and an optional task id.');
+        }
+        return {
+            values,
+            command,
+            docsAction: null,
+            docsArgument: null,
+            codeAction: null,
+            hostAction: null,
+            hostSubAction: null,
+            collaborationAction: null,
+            resumeTaskId: null,
+            runtimeAction: null,
+            taskAction: positionals[1] ?? null,
+            taskArgument: positionals[2] ?? null,
+        };
+    }
     if (command === 'docs') {
         if (positionals.length > 3) {
             throw new Error('Unknown command; docs accepts one action and one argument.');
@@ -90,9 +112,12 @@ function parseOptions(args) {
             docsAction: positionals[1] ?? null,
             docsArgument: positionals[2] ?? null,
             hostAction: null,
+            hostSubAction: null,
             collaborationAction: null,
             resumeTaskId: null,
             runtimeAction: null,
+            taskAction: null,
+            taskArgument: null,
         };
     }
     if (command === 'resume') {
@@ -106,9 +131,12 @@ function parseOptions(args) {
             docsArgument: null,
             codeAction: null,
             hostAction: null,
+            hostSubAction: null,
             collaborationAction: null,
             resumeTaskId: positionals[1] ?? null,
             runtimeAction: null,
+            taskAction: null,
+            taskArgument: null,
         };
     }
     if (command === 'code') {
@@ -122,14 +150,17 @@ function parseOptions(args) {
             docsArgument: null,
             codeAction: positionals[1] ?? null,
             hostAction: null,
+            hostSubAction: null,
             collaborationAction: null,
             resumeTaskId: null,
             runtimeAction: null,
+            taskAction: null,
+            taskArgument: null,
         };
     }
     if (command === 'host') {
-        if (positionals.length > 2) {
-            throw new Error('host accepts one action: detect, describe, plan, install, or verify.');
+        if (positionals.length > 3) {
+            throw new Error('host accepts one action and an optional mcp sub-action.');
         }
         return {
             values,
@@ -138,9 +169,12 @@ function parseOptions(args) {
             docsArgument: null,
             codeAction: null,
             hostAction: positionals[1] ?? null,
+            hostSubAction: positionals[2] ?? null,
             collaborationAction: null,
             resumeTaskId: null,
             runtimeAction: null,
+            taskAction: null,
+            taskArgument: null,
         };
     }
     if (command === 'runtime') {
@@ -154,9 +188,12 @@ function parseOptions(args) {
             docsArgument: null,
             codeAction: null,
             hostAction: null,
+            hostSubAction: null,
             collaborationAction: null,
             resumeTaskId: null,
             runtimeAction: positionals[1] ?? null,
+            taskAction: null,
+            taskArgument: null,
         };
     }
     if (command === 'collab') {
@@ -170,9 +207,12 @@ function parseOptions(args) {
             docsArgument: null,
             codeAction: null,
             hostAction: null,
+            hostSubAction: null,
             collaborationAction: positionals[1] ?? null,
             resumeTaskId: null,
             runtimeAction: null,
+            taskAction: null,
+            taskArgument: null,
         };
     }
     if (positionals.length > 1) {
@@ -221,6 +261,8 @@ function hasContinuityOptions(values, includeSession = true) {
         (includeSession && values.session !== undefined));
 }
 const globalUsage = 'pappra [--help | --version] [--json]\n' +
+    'pappra task <pin|unpin|show> [taskId] [--auto-resume] [--json]\n' +
+    'pappra mcp [--root <dir>] [--help]\n' +
     'pappra onboard [--root <dir>] [--config <file>] [--hosts <list>] [--yes]\n' +
     '               [--apply-host] [--dry-run] [--print-handoff] [--json]\n' +
     'pappra init [--config <file> | --yes] [--apply] [--json] [--print-choices]\n' +
@@ -243,7 +285,7 @@ export async function runCli(args, output) {
         failure(output, jsonRequested, 'invalid_arguments', error);
         return 2;
     }
-    const { values, command, docsAction, docsArgument, codeAction, hostAction, collaborationAction, resumeTaskId, runtimeAction, } = parsed;
+    const { values, command, docsAction, docsArgument, codeAction, hostAction, collaborationAction, resumeTaskId, runtimeAction, hostSubAction, taskAction, taskArgument, } = parsed;
     const json = values.json === true;
     const applyRequested = values.apply === true;
     if (command !== 'init' &&
@@ -258,6 +300,10 @@ export async function runCli(args, output) {
         failure(output, json, 'invalid_arguments', '--yes is only valid for init and onboard.');
         return 2;
     }
+    if (command !== 'task' && values['auto-resume'] === true) {
+        failure(output, json, 'invalid_arguments', '--auto-resume is only valid for task pin.');
+        return 2;
+    }
     if (command !== 'onboard' &&
         (values.hosts !== undefined ||
             values['apply-host'] === true ||
@@ -297,6 +343,7 @@ export async function runCli(args, output) {
         return 2;
     }
     if (command !== 'runtime' &&
+        command !== 'host' &&
         (values.from !== undefined ||
             values.tarball !== undefined ||
             values.bind === true ||
@@ -416,6 +463,85 @@ export async function runCli(args, output) {
             json,
         }, output);
     }
+    if (command === 'task') {
+        const action = taskAction === 'pin' || taskAction === 'unpin' || taskAction === 'show'
+            ? taskAction
+            : null;
+        if (values.config !== undefined ||
+            values.apply === true ||
+            values.yes === true ||
+            values['install-runtime'] === true ||
+            values['runtime-tarball'] !== undefined ||
+            values['runtime-version'] !== undefined ||
+            values.host !== undefined ||
+            values.repo !== undefined ||
+            values.kind !== undefined ||
+            values.query !== undefined ||
+            values.root !== undefined ||
+            hasContinuityOptions(values)) {
+            failure(output, json, 'invalid_arguments', 'task accepts pin|unpin|show, an optional task id, --auto-resume, --help, and --json.');
+            return 2;
+        }
+        if (values.help) {
+            if (json) {
+                output.stdout(`${JSON.stringify({ ...info, commands: ['task'], usage: taskUsage })}\n`);
+            }
+            else {
+                output.stdout(taskUsage);
+            }
+            return 0;
+        }
+        if (values.version) {
+            failure(output, json, 'invalid_arguments', '--version cannot be combined with task.');
+            return 2;
+        }
+        return runTaskCommand({
+            cwd: process.cwd(),
+            action,
+            taskId: taskArgument ?? null,
+            autoResume: values['auto-resume'] === true,
+            json,
+        }, output);
+    }
+    if (command === 'mcp') {
+        if (values.config !== undefined ||
+            values.apply === true ||
+            values.yes === true ||
+            values['install-runtime'] === true ||
+            values['runtime-tarball'] !== undefined ||
+            values['runtime-version'] !== undefined ||
+            values['include-private'] === true ||
+            values['include-archived'] === true ||
+            values['apply-host'] === true ||
+            values['dry-run'] === true ||
+            values['print-handoff'] === true ||
+            values.hosts !== undefined ||
+            values.repo !== undefined ||
+            values.kind !== undefined ||
+            values.query !== undefined ||
+            values.limit !== undefined ||
+            values['max-bytes'] !== undefined ||
+            values.rebuild === true ||
+            values.host !== undefined ||
+            hasContinuityOptions(values)) {
+            failure(output, json, 'invalid_arguments', 'mcp accepts only --root, --help, and --json.');
+            return 2;
+        }
+        if (values.help) {
+            if (json) {
+                output.stdout(`${JSON.stringify({ ...info, commands: ['mcp'], usage: mcpUsage })}\n`);
+            }
+            else {
+                output.stdout(mcpUsage);
+            }
+            return 0;
+        }
+        if (values.version) {
+            failure(output, json, 'invalid_arguments', '--version cannot be combined with mcp.');
+            return 2;
+        }
+        return runMcpCommand({ cwd: process.cwd(), root: values.root ?? null, json }, output);
+    }
     if (command === 'onboard') {
         if (values.apply === true ||
             values['install-runtime'] === true ||
@@ -723,6 +849,8 @@ export async function runCli(args, output) {
             'install',
             'verify',
             'bundle',
+            'mcp',
+            'probe',
         ];
         const action = allowedActions.find((item) => item === hostAction) ?? null;
         const parsedHost = hostNameSchema.safeParse(values.host);
@@ -742,7 +870,7 @@ export async function runCli(args, output) {
             values['max-bytes'] !== undefined ||
             values.rebuild === true ||
             hasContinuityOptions(values) ||
-            (values.apply === true && action !== 'install') ||
+            (values.apply === true && action !== 'install' && action !== 'mcp') ||
             (values.mode !== undefined && action !== 'install') ||
             (values.marketplace === true && action !== 'bundle') ||
             (values.scope !== undefined &&
@@ -772,6 +900,8 @@ export async function runCli(args, output) {
             hostRoot: values['host-root'] ?? null,
             hostVersion: values['host-version'] ?? null,
             apply: values.apply === true,
+            force: values.force === true,
+            subAction: hostSubAction ?? null,
             out: values.out ?? null,
             mode: values.mode === 'project-settings' || values.mode === 'plugin'
                 ? values.mode

package/dist/hosts/integration/hook.js

@@ -10,6 +10,7 @@ import { resolveWorkspaceRoot } from '../../workspace/resolve.js';
 import { inspectMachineConfig, loadWorkspaceConfig, } from '../../workspace/config.js';
 import { CheckpointService } from '../../continuity/service.js';
 import { ensureStatePathBoundary } from '../../install/ownership.js';
+import { readAutoResume, readTaskPin } from '../../app/task-pin.js';
 import { nativeEventFor } from './support.js';
 const DEFAULT_MAX_INPUT_BYTES = 1024 * 1024;
 const DEFAULT_DEADLINE_MS = 1000;
@@ -489,7 +490,9 @@ export async function runHostHook(input, options = {}) {
         dev: directoryAfter.stats.dev,
         ino: directoryAfter.stats.ino,
     };
-    const context = await boundedAdvisory(root, value.event, value.taskId, workspaceRead.value.name);
+    const pinnedTask = await readTaskPin(root);
+    const autoResume = pinnedTask !== null && (await readAutoResume(root));
+    const context = await boundedAdvisory(root, value.event, value.taskId ?? (autoResume ? pinnedTask.taskId : null), workspaceRead.value.name);
     if (clock() - started > deadline) {
         return result({
             ok: false,