@cspeach/cli 0.7.1 → 0.9.0

package/dist/repl.js

@@ -37,6 +37,7 @@ import { slashCompleter } from './repl/slash-completer.js';
 import { openSlashPicker, isExactSlashMatch } from './repl/slash-picker.js';
 import { openAtPicker, pendingAtTokenPrefix } from './repl/at-picker.js';
 import { atCompleter } from './repl/at-completer.js';
+import { isPlanResumeCommand } from './commands/plan-resume.js';
 /**
  * Pre-fill the readline buffer with `text`, cursor at end, and trigger
  * a redraw. Bypasses rl.write() — which simulates per-character
@@ -640,13 +641,20 @@ export async function runRepl(opts) {
                 chunkEmitter.emit('chunk', chalk.dim(`\n↪ Rerouting "${preview}" → /${rr.skill}\n`));
                 if (rr.warning)
                     chunkEmitter.emit('chunk', chalk.dim(`  (${rr.warning})\n`));
-                await runTurn({
-                    provider,
-                    userMessage: rr.prompt,
-                    skill: rr.skill,
-                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
-                    chunkEmitter,
-                });
+                const { turnStatusEmitter: rerouteStatus } = await import('./ui/turn-status-emitter.js');
+                rerouteStatus.start(`/${rr.skill}`);
+                try {
+                    await runTurn({
+                        provider,
+                        userMessage: rr.prompt,
+                        skill: rr.skill,
+                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                        chunkEmitter,
+                    });
+                }
+                finally {
+                    rerouteStatus.stop();
+                }
                 return;
             }
             // /new — clear any "awaiting skill answer" state so the next prompt
@@ -673,7 +681,9 @@ export async function runRepl(opts) {
             //   - `@ZCL_ORDER explain this`: stored as `explain this` — @OBJECT
             //     context is lost on reroute, acceptable v0.3.1 limitation
             session.lastUserPrompt = parsed.prompt;
-            const prompt = parsed.prompt;
+            // `let`, not `const` — the B3 plan-resume interception below rewrites
+            // the prompt with the prepared bounded phase context before runTurn.
+            let prompt = parsed.prompt;
             const extractedObject = parsed.object ?? null;
             const previousSkill = session.skill;
             const previousObject = session.last_object ?? null;
@@ -715,6 +725,12 @@ export async function runRepl(opts) {
                             last_skill: session.last_skill ?? null,
                             last_object: extractedObject ?? session.last_object ?? null,
                         });
+                        if (c.offline) {
+                            // Remote classify failed twice — local-rules fallback fired.
+                            // Tell the user so they know the picker preselection came
+                            // from regex, not the LLM, and surface the real cause.
+                            chunkEmitter.emit('chunk', chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]\n`));
+                        }
                         const decision = decideRouting(c);
                         // 2026-05-17 — pass the just-used skill so the picker can
                         // default cursor to it (one-Enter "continue" UX for follow-up
@@ -759,7 +775,7 @@ export async function runRepl(opts) {
             // consume model tokens, so we intercept here AFTER skill resolution
             // but BEFORE runTurn. The body lives in `prompt` (post-parseShortcut),
             // e.g. `--status @./foo.cspeach.json`.
-            if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate') &&
+            if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate' || skill === 'abap-plan') &&
                 /(^|\s)--status(\s|$)/.test(prompt)) {
                 try {
                     const files = prompt
@@ -779,6 +795,42 @@ export async function runRepl(opts) {
                 session.last_object = extractedObject ?? previousObject ?? null;
                 return;
             }
+            // B3 (2026-06-06) — `/abap-plan --resume @plan-file`. Token-free
+            // pre-work (load envelope, pick next eligible phase, print the
+            // tracker board, inline the phase's rule files) happens in
+            // preparePlanResume; terminal states (plan complete / all blocked)
+            // print and end the turn without any model call. When a phase IS
+            // eligible, the prepared bounded prompt replaces the user prompt
+            // and falls through to runTurn below — with suppressSaveHook so
+            // the new-envelope save hook stays quiet; finishPlanResume then
+            // persists the version-N+1 REVISION after the turn.
+            let planResume = null;
+            let planResumeMsgStart = 0;
+            if (skill === 'abap-plan' && /(^|\s)--resume(\s|$)/.test(prompt)) {
+                try {
+                    const { preparePlanResume } = await import('./commands/plan-resume.js');
+                    planResume = await preparePlanResume({
+                        body: prompt,
+                        cwd: process.cwd(),
+                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                    });
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[--resume] ${err.message}\n`));
+                }
+                if (!planResume) {
+                    session.last_skill = previousSkill ?? null;
+                    session.last_object = extractedObject ?? previousObject ?? null;
+                    return;
+                }
+                planResumeMsgStart = session.messages.length;
+                prompt = planResume.llmPrompt;
+            }
+            // 2026-06-08 — manifest-on-interrupt. Set true once the mid-turn
+            // onPlanManifest hook has persisted the revision, so the post-turn
+            // finishPlanResume below doesn't write it a second time.
+            let planSavedEarly = false;
+            const planResumeForHook = planResume;
             // Phase A** wiring fix (2026-05-16) — snapshot pre-turn counters so
             // pushPostTurnStatus can compute per-turn deltas. The classic-mode
             // turn loop has its own equivalent below; both paths now call the
@@ -792,6 +844,11 @@ export async function runRepl(opts) {
             // the signal we thread into runTurn.
             currentTurnAbort = new AbortController();
             interruptCount = 0;
+            // 2026-06-07 — persistent status row lifecycle. Started here (not in
+            // loop.ts) so the try/finally GUARANTEES the row clears even when the
+            // turn throws; loop.ts only narrates activity changes in between.
+            const { turnStatusEmitter } = await import('./ui/turn-status-emitter.js');
+            turnStatusEmitter.start(`/${skill}`);
             try {
                 await runTurn({
                     provider,
@@ -800,6 +857,27 @@ export async function runRepl(opts) {
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     chunkEmitter,
                     signal: currentTurnAbort.signal,
+                    suppressSaveHook: planResume !== null,
+                    // Persist the plan revision the instant its manifest is finalised
+                    // (before the continuation modal) so a Ctrl+C can't lose the phase.
+                    onPlanManifest: planResumeForHook
+                        ? async (assistantText) => {
+                            try {
+                                const { finishPlanResume } = await import('./commands/plan-resume.js');
+                                await finishPlanResume({
+                                    prepared: planResumeForHook,
+                                    messages: session.messages,
+                                    messagesStart: planResumeMsgStart,
+                                    log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                                    textOverride: assistantText,
+                                });
+                                planSavedEarly = true;
+                            }
+                            catch (err) {
+                                chunkEmitter.emit('chunk', chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
+                            }
+                        }
+                        : undefined,
                 });
             }
             catch (err) {
@@ -811,8 +889,31 @@ export async function runRepl(opts) {
                 });
             }
             finally {
+                turnStatusEmitter.stop();
                 currentTurnAbort = null;
             }
+            // B3 — persist the plan revision from the resume turn's manifest
+            // block (runs even after a turn error: partial assistant content is
+            // already in session.messages, and a phase may have written real SAP
+            // objects whose status must not be lost). FALLBACK path: skipped when
+            // the mid-turn onPlanManifest hook already saved it (manifest-on-
+            // interrupt, 2026-06-08). Still runs when no manifest was streamed —
+            // e.g. the turn errored before emitting one — so behaviour is unchanged
+            // for the no-manifest case.
+            if (planResume && !planSavedEarly) {
+                try {
+                    const { finishPlanResume } = await import('./commands/plan-resume.js');
+                    await finishPlanResume({
+                        prepared: planResume,
+                        messages: session.messages,
+                        messagesStart: planResumeMsgStart,
+                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                    });
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
+                }
+            }
             pushPostTurnStatus({ session, selectedAlias, snapshot: turnSnapshot, chunkEmitter });
             session.last_skill = previousSkill ?? null;
             session.last_object = extractedObject ?? previousObject ?? null;
@@ -824,7 +925,18 @@ export async function runRepl(opts) {
             const dispatched = pendingDispatchAccessor.get();
             if (dispatched) {
                 pendingDispatchAccessor.set(null);
-                chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${dispatched}\n`));
+                // Auto-fire next phase: a plan resume rebuilds its bounded prompt from
+                // the envelope, so clear the finished phase's transcript first — the
+                // next phase then costs exactly what a manual fresh resume costs.
+                // (The phase is already saved via manifest-on-interrupt, so nothing is
+                // lost; prior prose is mirrored to ~/.cspeach/streams/.)
+                if (isPlanResumeCommand(dispatched)) {
+                    session.messages = [];
+                    chunkEmitter.emit('chunk', chalk.dim('↪ Auto-running next phase in fresh context\n'));
+                }
+                else {
+                    chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${dispatched}\n`));
+                }
                 // Schedule on next tick so the current handleSubmit's promise
                 // resolves cleanly before the next one starts. Recursion via
                 // setImmediate keeps the call stack flat across long chains.
@@ -868,11 +980,19 @@ export async function runRepl(opts) {
             writeMode: cfg.write_mode,
             onInterrupt,
         }), {
-            // Critical: without this Ink calls process.exit() on Ctrl+C and
-            // kills the CLI before our onInterrupt handler can decide what
-            // to do. We want to make that decision ourselves (abort turn
-            // vs exit at idle).
+            // exitOnCtrlC: false — Ink would otherwise call process.exit()
+            // on Ctrl+C before onInterrupt can decide whether to abort the
+            // in-flight turn or exit cleanly.
             exitOnCtrlC: false,
+            // W2.1 (2026-05-18) — patchConsole intercepts console.log /
+            // console.error / console.warn from inside ANY code that runs
+            // while Ink owns the frame, routes them above the Ink render
+            // region as Static-committed scrollback rather than corrupting
+            // the live frame. CC uses this (12 hits in v0.2.9 source).
+            // Removes a whole class of "console.log ate my frame" bugs and
+            // lets us delete the 6 manual chunkEmitter routings we added
+            // in commit 349ff75.
+            patchConsole: true,
         });
         await donePromise;
         unmount();
@@ -1150,7 +1270,13 @@ export async function runRepl(opts) {
         const dispatchedCmd = pendingDispatchAccessor.get();
         if (dispatchedCmd) {
             pendingDispatchAccessor.set(null);
-            console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
+            if (isPlanResumeCommand(dispatchedCmd)) {
+                session.messages = [];
+                console.log(chalk.dim('↪ Auto-running next phase in fresh context'));
+            }
+            else {
+                console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
+            }
             line = dispatchedCmd;
         }
         else {
@@ -1499,7 +1625,9 @@ export async function runRepl(opts) {
         //   - `@ZCL_ORDER explain this`: stored as `explain this` — @OBJECT
         //     context is lost on reroute, acceptable v0.3.1 limitation
         session.lastUserPrompt = parsed.prompt;
-        const prompt = parsed.prompt;
+        // `let`, not `const` — the B3 plan-resume interception below rewrites
+        // the prompt with the prepared bounded phase context before runTurn.
+        let prompt = parsed.prompt;
         const extractedObject = parsed.object ?? null;
         const previousSkill = session.skill; // snapshot before this turn dispatches
         const previousObject = session.last_object ?? null; // carries from two turns ago
@@ -1536,6 +1664,9 @@ export async function runRepl(opts) {
                         last_skill: session.last_skill ?? null,
                         last_object: extractedObject ?? session.last_object ?? null,
                     });
+                    if (c.offline) {
+                        console.log(chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
+                    }
                     const decision = decideRouting(c);
                     // 2026-05-17 — pass the just-used skill so the picker can
                     // default cursor to it. session.skill = immediately-previous
@@ -1584,7 +1715,7 @@ export async function runRepl(opts) {
         // /abap-design, and /abap-estimate (renderer in projects/status.ts is
         // type-agnostic). Intercept after skill resolution, before runTurn. The
         // prompt body (post-parseShortcut) looks like `--status @./foo.cspeach.json`.
-        if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate') &&
+        if ((skill === 'abap-spec-gap' || skill === 'abap-design' || skill === 'abap-estimate' || skill === 'abap-plan') &&
             /(^|\s)--status(\s|$)/.test(prompt)) {
             try {
                 const files = prompt
@@ -1604,6 +1735,38 @@ export async function runRepl(opts) {
             session.last_object = extractedObject ?? previousObject ?? null;
             continue;
         }
+        // B3 (2026-06-06) — `/abap-plan --resume @plan-file` (classic-mode
+        // mirror of the Ink path above; see that block for the full design
+        // note). Token-free pre-work; terminal states end the turn with no
+        // model call; otherwise the prepared bounded prompt falls through to
+        // runTurn with suppressSaveHook, and finishPlanResume persists the
+        // envelope revision after the turn.
+        let planResume = null;
+        let planResumeMsgStart = 0;
+        if (skill === 'abap-plan' && /(^|\s)--resume(\s|$)/.test(prompt)) {
+            try {
+                const { preparePlanResume } = await import('./commands/plan-resume.js');
+                planResume = await preparePlanResume({
+                    body: prompt,
+                    cwd: process.cwd(),
+                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                });
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[--resume] ${err.message}\n`));
+            }
+            if (!planResume) {
+                session.last_skill = previousSkill ?? null;
+                session.last_object = extractedObject ?? previousObject ?? null;
+                continue;
+            }
+            planResumeMsgStart = session.messages.length;
+            prompt = planResume.llmPrompt;
+        }
+        // 2026-06-08 — manifest-on-interrupt (classic path). See the Ink path for
+        // the full rationale; persist the revision mid-turn so a Ctrl+C can't lose it.
+        let planSavedEarly = false;
+        const planResumeForHook = planResume;
         const turnStart = Date.now();
         // H1 — `session.usage` is session-LIFETIME (initialised once in
         // newSession, saved across turns). The footer's "this turn" label was
@@ -1658,6 +1821,25 @@ export async function runRepl(opts) {
                 skill: skill,
                 ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                 signal: turnAbort.signal,
+                suppressSaveHook: planResume !== null,
+                onPlanManifest: planResumeForHook
+                    ? async (assistantText) => {
+                        try {
+                            const { finishPlanResume } = await import('./commands/plan-resume.js');
+                            await finishPlanResume({
+                                prepared: planResumeForHook,
+                                messages: session.messages,
+                                messagesStart: planResumeMsgStart,
+                                log: (...lines) => lines.forEach((l) => console.log(l)),
+                                textOverride: assistantText,
+                            });
+                            planSavedEarly = true;
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
+                        }
+                    }
+                    : undefined,
             });
         }
         catch (err) {
@@ -1677,6 +1859,23 @@ export async function runRepl(opts) {
             rl.removeListener('SIGINT', onSigint);
             turnInProgress = false;
         }
+        // B3 — persist the plan revision from the resume turn's manifest block.
+        // FALLBACK: skipped when the mid-turn onPlanManifest hook already saved it
+        // (manifest-on-interrupt, 2026-06-08); still runs when no manifest streamed.
+        if (planResume && !planSavedEarly) {
+            try {
+                const { finishPlanResume } = await import('./commands/plan-resume.js');
+                await finishPlanResume({
+                    prepared: planResume,
+                    messages: session.messages,
+                    messagesStart: planResumeMsgStart,
+                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                });
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
+            }
+        }
         // Status footer after each turn.
         // tool_result messages also have role:'user' but content is an array —
         // filter them out so we count actual user prompts, not tool rounds.

package/dist/router/classifier.js

@@ -1,19 +1,85 @@
 import { loadConfig } from '../config/loader.js';
 import { getStore } from '../auth/api-key.js';
+import { classify as classifyLocal } from '../classifier/client.js';
+// 8s — sized to cover the observed Fly cold-start (~3.2s on the 2026-05-20
+// probe) plus headroom for a slow network. Tighter values risk timing out
+// legitimate cold-start hits and burning the retry budget on the same.
+const FETCH_TIMEOUT_MS = 8000;
+// 250ms — long enough for a half-open TCP/keep-alive socket to be fully
+// torn down before we try again, short enough that the user doesn't feel
+// the retry as a hang.
+const RETRY_DELAY_MS = 250;
+/**
+ * Extract the real failure cause from a Node fetch / undici error. Node's
+ * native fetch surfaces `TypeError: fetch failed` and hides the actual
+ * layer on `err.cause` (UND_ERR_*, ENOTFOUND, ECONNRESET, ETIMEDOUT, TLS
+ * handshake aborts, etc.). This lets future failure messages name the
+ * actual layer so we can tell DNS vs TLS vs socket-reset vs Fly cold start.
+ */
+function extractCause(err) {
+    const e = err;
+    if (e.cause) {
+        return `${e.cause.code ?? e.cause.errno ?? 'unknown'}${e.cause.message ? `: ${e.cause.message}` : ''}`;
+    }
+    return e.message;
+}
+async function tryFetchOnce(proxyUrl, key, prompt, context) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    try {
+        return await fetch(`${proxyUrl}/v1/classify`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${key}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ prompt, context }),
+            signal: ctrl.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 export async function classifyPrompt(prompt, context) {
     const cfg = await loadConfig();
     const store = await getStore();
     const key = await store.get();
     if (!key)
         throw new Error('no_api_key');
-    const r = await fetch(`${cfg.proxy_url}/v1/classify`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${key}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ prompt, context }),
-    });
+    let r;
+    let lastErr;
+    // Two attempts total: the second masks the common case of a stale
+    // keep-alive socket reused against a just-cold-suspended Fly machine
+    // (2026-05-20 probe showed first-hit cold = 3.2s, warm = 460ms — the
+    // half-open socket fails fast at the transport layer, then a fresh
+    // connection succeeds). HTTP-level failures (non-2xx) do NOT retry —
+    // they bubble through as before.
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            r = await tryFetchOnce(cfg.proxy_url, key, prompt, context);
+            break;
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt === 0)
+                await new Promise((res) => setTimeout(res, RETRY_DELAY_MS));
+        }
+    }
+    if (!r) {
+        // Both attempts failed at the transport layer. Degrade to the bundled
+        // local rules so the user's turn is NOT dropped — they still get a
+        // coaching picker (confidence 0.3 < 0.60 = picker decision), and the
+        // REPL surfaces an offline hint with the real cause.
+        const skill = classifyLocal(prompt) ?? 'abap-radar';
+        return {
+            skill,
+            confidence: 0.3,
+            alternates: [],
+            offline: true,
+            transport_error: lastErr ? extractCause(lastErr) : 'unknown',
+        };
+    }
     if (!r.ok)
         throw new Error(`classifier HTTP ${r.status}`);
     return (await r.json());

package/dist/skill-catalog.js

@@ -1,8 +1,8 @@
 /**
  * Static skill catalog for CSPeach CLI v0.2.
  *
- * STALENESS RISK (spec §3.3): This constant is hardcoded against the 33 skills
- * in .claude/skills/ as of 2026-04-19. It will drift if skills are added or
+ * STALENESS RISK (spec §3.3): This constant is hardcoded against the 34 skills
+ * in .claude/skills/ as of 2026-06-06 (abap-plan added). It will drift if skills are added or
  * removed. At Plan 4b kickoff decision the build-time generation option
  * (scripts/generate-skill-catalog.ts reads SKILL.md frontmatter) or runtime
  * fetch (/v1/skills endpoint) will be chosen to replace this file. Until then,
@@ -219,4 +219,10 @@ export const SKILL_CATALOG = [
         description: 'Effort estimation for ABAP tickets — component breakdown with hour ranges (optimistic / realistic / pessimistic) + risk adjustments',
         whenToUse: `pick this for hour ranges + risk adjustments on a confirmed object list (step 3 of 3 — needs /abap-design first; high uncertainty without it)`,
     },
+    {
+        name: 'abap-plan',
+        category: 'Pre-Coding',
+        description: 'Multi-session project plan — phase envelope holds state across sessions; create from a goal or spec-gap file, resume one bounded phase per session',
+        whenToUse: `pick this when the work spans multiple sessions or components (not /abap-design — that's one design in one session; plan calls design per phase)`,
+    },
 ];

package/dist/tools/subagent/agent_run.js

@@ -124,6 +124,13 @@ export async function agentRunHandler(args, ctx) {
     // Increment depth env var BEFORE the child runs; restore after.
     const priorDepth = process.env.CSPEACH_AGENT_DEPTH;
     process.env.CSPEACH_AGENT_DEPTH = String(depth + 1);
+    // W2.5 — when read_only is set, build a tool filter that drops every
+    // mutating tool from the subagent's tool list. Saves tokens on the
+    // sub-agent invocation (smaller tools array = less input cost) AND
+    // hard-prevents accidental writes from the subagent.
+    const toolFilter = args.read_only
+        ? (t) => !t.isMutating
+        : undefined;
     try {
         await runTurn({
             provider: ctx.provider,
@@ -132,6 +139,7 @@ export async function agentRunHandler(args, ctx) {
             ctx: childCtx,
             chunkEmitter: nullSinkEmitter,
             maxTokensOverride,
+            toolFilter,
         });
     }
     catch (err) {
@@ -179,6 +187,10 @@ registerTool({
                 type: 'number',
                 description: 'Optional per-call cap. Default 100000, hard cap 200000.',
             },
+            read_only: {
+                type: 'boolean',
+                description: 'When true, the subagent only sees read-only tools (no sap_set_source, no file-write, no shell_exec, etc.). Use this for research / analysis subagents that should not make changes — e.g. spawning a subagent to read code, run greps, or summarise findings. Smaller tools array = lower per-call cost; also a hard guard against accidental writes.',
+            },
         },
         required: ['skill', 'task'],
     },