@veewo/claw 0.1.99 → 0.2.3

package/dist/cli.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
-import { buildDirectWorkflowGuidance, DEFAULT_MAX_TASKS_TO_KEEP, checkProjectProtocol, ClawError, buildPlanWorkflowGuidance, shouldUsePlanHostIntegration, buildMemoryIndex, buildSessionStartDefaultPrompt, buildSessionStartRecoveredPrompt, editPlan, ensureProjectProtocol, enforceTaskRetention, findTaskDirectory, runDailyMaintenance, ingestTruth, initProject, getTemplateTaskDoneChoices, resolvePlanTemplateFile, resolveProjectContext, resolveWorkflowProjectContext, resolveSessionWorkflowContext, deleteSessionWorkflow, sweepExpiredSessionWorkflows, resolveSessionBoundPlan, resolveContext, resolveSeedPlanTemplate, searchMemoryAsync, warmProjectMemoryEmbedding, showPlan, createSubplan, switchTask, tryCaptureKnowledgeStop, claimKnowledgeFinalizationJob, changedKnowledgeMarkdownPaths, listRetryableKnowledgeFinalizationJobs, governChangedKnowledgeMarkdown, normalizeTruthMarkdownEncoding, recordKnowledgeFinalizationResult, snapshotKnowledgeMarkdown, writeKnowledgeFinalizationJob, unbindSession, writePlan, } from "@veewo/claw-core";
+import { buildDirectWorkflowGuidance, buildKnowledgeDelegateDispatch, buildKnowledgeAssignmentTemplate, buildKnowledgeWriterAssignments, DEFAULT_MAX_TASKS_TO_KEEP, checkProjectProtocol, ClawError, buildPlanWorkflowGuidance, shouldUsePlanHostIntegration, buildMemoryIndex, buildSessionStartDefaultPrompt, buildSessionStartRecoveredPrompt, editPlan, ensureProjectProtocol, enforceTaskRetention, findTaskDirectory, runDailyMaintenance, ingestTruth, initProject, getTemplateTaskDoneChoices, resolvePlanTemplateFile, resolvePlanEffectiveConfig, resolveProjectContext, resolveWorkflowProjectContext, resolveSessionWorkflowContext, deleteSessionWorkflow, sweepExpiredSessionWorkflows, resolveSessionBoundPlan, resolveContext, resolveSeedPlanTemplate, searchMemoryAsync, warmProjectMemoryEmbedding, showPlan, createSubplan, switchTask, tryCaptureKnowledgeStop, claimKnowledgeFinalizationJob, doneKnowledgeFinalizationJob, readKnowledgeFinalizationJob, waitForKnowledgeFinalizationJobReady, listRetryableKnowledgeFinalizationJobs, normalizeTruthMarkdownEncoding, recordKnowledgeFinalizationResult, unbindSession, writePlan, } from "@veewo/claw-core";
 import { buildCodexDriverEnvelope } from "./codex-driver.js";
 import { checkCodexRuntime, resolveCodexSdkEntryPath } from "./codex-runtime.js";
 import { extractLatestFinalAssistantMessage, extractTaskDoneConclusions, } from "./codex-transcript.js";
@@ -25,6 +25,7 @@ const TOP_LEVEL_COMMANDS = [
     { name: "subplan create [options]", summary: "Create a subplan nested under a parent task item." },
     { name: "switch-task --from <task> --to <task>", summary: "Switch the active task, carrying inherited context." },
     { name: "search [<query>] [options]", summary: "Recall project memory, truth, ADR, and declared docs." },
+    { name: "knowledge <subcommand> [options]", summary: "Knowledge finalization lifecycle: wait, claim, done." },
     { name: "truth ingest [options]", summary: "Ingest a truth document under .claw/truth." },
     { name: "hook <event-name>", summary: "Emit host hook output (e.g. SessionStart)." },
 ];
@@ -311,6 +312,43 @@ const COMMAND_HELP = {
             },
         },
     },
+    knowledge: {
+        usage: ["{script} knowledge <subcommand> [options]"],
+        description: "Session-bound lifecycle commands for a queued knowledge finalization job.",
+        subcommands: {
+            wait: {
+                usage: ["{script} knowledge wait --project-root <path> --finalize-id <id> [--timeout-ms <n>]"],
+                description: "Wait for Stop capture to create a knowledge finalization job. This command does not create or inspect session bindings.",
+                summary: "Wait until the finalization job exists.",
+                options: [
+                    { flag: "--project-root <path>", detail: "(required) Project that owns the pending finalization." },
+                    { flag: "--finalize-id <id>", detail: "(required) Stable finalization id returned by plan done." },
+                    { flag: "--timeout-ms <n>", detail: "Maximum wait in milliseconds (default 300000)." },
+                ],
+            },
+            claim: {
+                usage: ["{script} knowledge claim --job <path>"],
+                description: "Claim a queued or retryable job after its executor session has been bound.",
+                summary: "Claim a session-bound finalization job.",
+                options: [{ flag: "--job <path>", detail: "(required) Finalization job JSON path." }],
+            },
+            done: {
+                usage: [
+                    "{script} knowledge done --job <path> --claim-token <token> --status succeeded --result <text>",
+                    "{script} knowledge done --job <path> --claim-token <token> --status failed --error <text>",
+                ],
+                description: "Persist the terminal result for a claimed knowledge finalization job.",
+                summary: "Complete a claimed finalization job.",
+                options: [
+                    { flag: "--job <path>", detail: "(required) Finalization job JSON path." },
+                    { flag: "--claim-token <token>", detail: "(required) Token returned by knowledge claim." },
+                    { flag: "--status succeeded|failed", detail: "(required) Terminal execution status." },
+                    { flag: "--result <text>", detail: "Required when status is succeeded." },
+                    { flag: "--error <text>", detail: "Required when status is failed." },
+                ],
+            },
+        },
+    },
     truth: {
         usage: ["{script} truth <subcommand> [options]"],
         description: "Truth document ingestion under .claw/truth.",
@@ -356,6 +394,28 @@ const COMMAND_HELP = {
         description: "Internal: warms the configured local persistent embedding session after context recovery without delaying SessionStart.",
         options: [{ flag: "--cwd <dir>", detail: "(required) Project root." }],
     },
+    "internal-daily-maintenance": {
+        usage: ["{script} internal-daily-maintenance --cwd <dir> [--session-key <key>] [--session-only]"],
+        description: "Internal: runs the lock-protected daily cleanup asynchronously after context recovery.",
+        options: [
+            { flag: "--cwd <dir>", detail: "(required) Current workspace directory." },
+            { flag: "--session-key <key>", detail: "Optional owner session key used for session workflow maintenance." },
+            { flag: "--session-only", detail: "Only maintain the session workflow; do not touch project tasks." },
+        ],
+    },
+    "internal-knowledge-sweep": {
+        usage: ["{script} internal-knowledge-sweep --cwd <dir>"],
+        description: "Internal: discovers retryable knowledge jobs and launches their detached finalizers.",
+        options: [{ flag: "--cwd <dir>", detail: "(required) Project root." }],
+    },
+    "internal-background-maintenance": {
+        usage: ["{script} internal-background-maintenance --cwd <dir> [--session-key <key>]"],
+        description: "Internal: runs non-blocking cleanup, embedding warmup, and knowledge job discovery in one worker.",
+        options: [
+            { flag: "--cwd <dir>", detail: "(required) Current workspace directory." },
+            { flag: "--session-key <key>", detail: "Optional owner session key used for session workflow maintenance." },
+        ],
+    },
 };
 async function main() {
     const args = process.argv.slice(2);
@@ -453,6 +513,9 @@ async function main() {
             case "search":
                 await runSearch(args);
                 return;
+            case "knowledge":
+                runKnowledge(args);
+                return;
             case "direct":
                 runDirect(args, effectiveHost);
                 return;
@@ -471,9 +534,30 @@ async function main() {
             case "internal-knowledge-finalize":
                 await runInternalKnowledgeFinalize(args);
                 return;
+            case "internal-knowledge-capture":
+                await runInternalKnowledgeCapture(args, effectiveHost);
+                return;
+            case "internal-knowledge-complete":
+                runInternalKnowledgeComplete(args);
+                return;
+            case "internal-knowledge-claim":
+                runInternalKnowledgeClaim(args);
+                return;
+            case "internal-knowledge-fail":
+                runInternalKnowledgeFail(args);
+                return;
             case "internal-embedding-warmup":
                 await runInternalEmbeddingWarmup(args);
                 return;
+            case "internal-daily-maintenance":
+                runInternalDailyMaintenance(args);
+                return;
+            case "internal-knowledge-sweep":
+                runInternalKnowledgeSweep(args);
+                return;
+            case "internal-background-maintenance":
+                await runInternalBackgroundMaintenance(args);
+                return;
             default:
                 printTopLevelUsage();
                 process.exitCode = 1;
@@ -513,6 +597,87 @@ function runSession(args) {
         removed: deleteSessionWorkflow(ownerSessionKey),
     });
 }
+function runKnowledge(args) {
+    const subcommand = args.shift();
+    switch (subcommand) {
+        case "wait": {
+            const projectRoot = path.resolve(readRequiredFlag(args, "--project-root"));
+            const finalizeId = readRequiredFlag(args, "--finalize-id");
+            const timeoutMs = readOptionalNumber(args, "--timeout-ms") ?? 300_000;
+            assertNoRemainingArgs(args, "knowledge wait");
+            const { jobPath, job } = waitForKnowledgeFinalizationJobReady({
+                project: resolveProjectContext(projectRoot),
+                finalizeId,
+                timeoutMs,
+            });
+            printJson({
+                ok: true,
+                command: "knowledge.wait",
+                finalizeId: job.finalizeId,
+                status: job.status,
+                jobPath,
+            });
+            return;
+        }
+        case "claim": {
+            const jobPath = readRequiredFlag(args, "--job");
+            assertNoRemainingArgs(args, "knowledge claim");
+            const job = claimKnowledgeFinalizationJob(jobPath);
+            const assignments = job ? buildKnowledgeWriterAssignments(job) : [];
+            const templatePath = job
+                ? path.join(path.dirname(jobPath), `${job.finalizeId}.assignments.json`)
+                : undefined;
+            if (job && templatePath) {
+                fs.writeFileSync(templatePath, `${JSON.stringify(buildKnowledgeAssignmentTemplate({
+                    assignments,
+                    finalizeId: job.finalizeId,
+                    version: CLI_VERSION,
+                }), null, 2)}\n`, "utf-8");
+            }
+            printJson({
+                ok: true,
+                command: "knowledge.claim",
+                claimed: Boolean(job),
+                ...(job ? {
+                    finalizeId: job.finalizeId,
+                    claimToken: job.claimToken,
+                    projectRoot: job.projectRoot,
+                    writer: job.writer ?? null,
+                    planPath: job.planPath,
+                    reportPath: job.reportPath,
+                    assignments,
+                    templatePath,
+                } : {}),
+            });
+            return;
+        }
+        case "done": {
+            const jobPath = readRequiredFlag(args, "--job");
+            const claimToken = readRequiredFlag(args, "--claim-token");
+            const status = readRequiredFlag(args, "--status");
+            const result = readOptionalFlag(args, "--result");
+            const error = readOptionalFlag(args, "--error");
+            assertNoRemainingArgs(args, "knowledge done");
+            if (status === "succeeded") {
+                if (result === undefined) {
+                    throw new ClawError("PROJECT_CONFIG_INVALID", "knowledge done --status succeeded requires --result.");
+                }
+                completeKnowledgeFinalizationJob(jobPath, result, claimToken);
+                return;
+            }
+            if (status === "failed") {
+                if (!error) {
+                    throw new ClawError("PROJECT_CONFIG_INVALID", "knowledge done --status failed requires --error.");
+                }
+                failKnowledgeFinalizationJob(jobPath, error, claimToken);
+                return;
+            }
+            throw new ClawError("PROJECT_CONFIG_INVALID", `Unsupported knowledge done status "${status}".`);
+        }
+        default:
+            throw new ClawError("PROJECT_CONFIG_INVALID", `Unknown knowledge subcommand "${subcommand ?? ""}".`);
+    }
+}
 async function runPlan(args, effectiveHost) {
     const subcommand = args.shift();
     switch (subcommand) {
@@ -551,6 +716,19 @@ async function runPlan(args, effectiveHost) {
             }
             const ownerSessionKey = resolveOwnerSessionKey() ?? undefined;
             const entersEndState = requestsPlanEndState(operations);
+            const current = entersEndState
+                ? showPlan({ cwd: process.cwd(), ...target, ownerSessionKey })
+                : undefined;
+            const project = entersEndState ? tryResolveHookProject(process.cwd()) : null;
+            const effectiveWriter = current && project
+                ? resolvePlanEffectiveConfig(project.projectConfig, current.plan)?.knowledgeWriter
+                : undefined;
+            if (current
+                && !current.plan.parentPlan
+                && effectiveWriter?.executionPolicy === "subagent"
+                && effectiveHost !== "codex") {
+                throw new ClawError("PROJECT_CONFIG_INVALID", 'knowledgeWriter.executionPolicy "subagent" is supported only by the Codex host.', { host: effectiveHost ?? null });
+            }
             const queuePlanEndFinalization = entersEndState
                 ? preparePlanEndFinalization(process.cwd(), ownerSessionKey)
                 : undefined;
@@ -563,7 +741,18 @@ async function runPlan(args, effectiveHost) {
                 ownerSessionKey,
             });
             const completionRefresh = queuePlanEndFinalization?.(result.taskName);
-            printJson(compactPlanCommandResult("plan.edit", result, effectiveHost, completionRefresh));
+            const knowledgeDispatch = (current
+                && project
+                && effectiveHost === "codex"
+                && !current.plan.parentPlan
+                && effectiveWriter?.executionPolicy === "subagent"
+                && result.knowledgeFinalizeId)
+                ? buildKnowledgeDispatch({
+                    finalizeId: result.knowledgeFinalizeId,
+                    writer: effectiveWriter,
+                })
+                : undefined;
+            printJson(compactPlanCommandResult("plan.edit", result, effectiveHost, completionRefresh, false, knowledgeDispatch));
             if (result.operationChain?.status === "partial")
                 process.exitCode = 1;
             return;
@@ -631,6 +820,20 @@ async function runPlan(args, effectiveHost) {
             const target = readPlanMutationTarget(args);
             assertNoRemainingArgs(args, "plan done");
             const ownerSessionKey = resolveOwnerSessionKey() ?? undefined;
+            const current = showPlan({
+                cwd: process.cwd(),
+                ...target,
+                ownerSessionKey,
+            });
+            const project = tryResolveHookProject(process.cwd());
+            const effectiveWriter = project
+                ? resolvePlanEffectiveConfig(project.projectConfig, current.plan)?.knowledgeWriter
+                : undefined;
+            if (!current.plan.parentPlan
+                && effectiveWriter?.executionPolicy === "subagent"
+                && effectiveHost !== "codex") {
+                throw new ClawError("PROJECT_CONFIG_INVALID", 'knowledgeWriter.executionPolicy "subagent" is supported only by the Codex host.', { host: effectiveHost ?? null });
+            }
             const queuePlanEndFinalization = preparePlanEndFinalization(process.cwd(), ownerSessionKey);
             const result = await editPlan({
                 cwd: process.cwd(),
@@ -641,7 +844,16 @@ async function runPlan(args, effectiveHost) {
                 ownerSessionKey,
             });
             const completionRefresh = queuePlanEndFinalization?.(result.taskName);
-            printJson(compactPlanCommandResult("plan.done", result, effectiveHost, completionRefresh));
+            const knowledgeDispatch = (effectiveHost === "codex"
+                && !current.plan.parentPlan
+                && effectiveWriter?.executionPolicy === "subagent"
+                && result.knowledgeFinalizeId)
+                ? buildKnowledgeDispatch({
+                    finalizeId: result.knowledgeFinalizeId,
+                    writer: effectiveWriter,
+                })
+                : undefined;
+            printJson(compactPlanCommandResult("plan.done", result, effectiveHost, completionRefresh, false, knowledgeDispatch));
             return;
         }
         case "show": {
@@ -872,7 +1084,15 @@ async function runContextCommand(args, cwd = process.cwd(), ownerSessionKey = re
     let fixedPaths = [];
     const sessionProject = resolveSessionWorkflowContext(ownerSessionKey ?? undefined);
     if (sessionProject) {
-        const maintenance = runDailyMaintenance(sessionProject, { excludeSessionKey: ownerSessionKey ?? undefined, includeProject: false });
+        const maintenance = effectiveHost
+            ? null
+            : runDailyMaintenance(sessionProject, {
+                excludeSessionKey: ownerSessionKey ?? undefined,
+                includeProject: false,
+            });
+        if (effectiveHost) {
+            launchDailyMaintenance(cwd, ownerSessionKey, true);
+        }
         const activeWorkflow = !taskName && ownerSessionKey
             ? await tryResolveActiveWorkflowSnapshot(cwd, ownerSessionKey, effectiveHost)
             : null;
@@ -883,7 +1103,7 @@ async function runContextCommand(args, cwd = process.cwd(), ownerSessionKey = re
         return {
             project: sessionProject,
             ...(activeWorkflow ? { activeWorkflow } : {}),
-            ...(maintenance.ran ? { maintenance } : {}),
+            ...(maintenance?.ran ? { maintenance } : {}),
             ...(codexRuntimeError ? { error: codexRuntimeError } : {}),
         };
     }
@@ -899,7 +1119,13 @@ async function runContextCommand(args, cwd = process.cwd(), ownerSessionKey = re
         initProject({ cwd, version: CLI_VERSION });
         initialized = true;
     }
-    const maintenance = runDailyMaintenance(resolveProjectContext(cwd), { excludeSessionKey: ownerSessionKey ?? undefined });
+    const project = resolveProjectContext(cwd);
+    const maintenance = effectiveHost
+        ? null
+        : runDailyMaintenance(project, { excludeSessionKey: ownerSessionKey ?? undefined });
+    if (effectiveHost) {
+        launchDailyMaintenance(cwd, ownerSessionKey, false);
+    }
     let resolved = resolveContext(cwd, taskName);
     const versionSync = syncProjectVersionWithCli(cwd, resolved.project);
     if (versionSync.projectVersionUpdated) {
@@ -919,7 +1145,7 @@ async function runContextCommand(args, cwd = process.cwd(), ownerSessionKey = re
     launchProjectEmbeddingWarmup(resolved.project);
     return {
         ...resolved,
-        ...(maintenance.ran ? { maintenance } : {}),
+        ...(maintenance?.ran ? { maintenance } : {}),
         ...(activeWorkflow ? { activeWorkflow } : {}),
         ...(codexRuntimeError ? { error: codexRuntimeError } : {}),
         protocolCheck: checkProjectProtocol(cwd),
@@ -967,6 +1193,28 @@ function launchProjectEmbeddingWarmup(project) {
         // Context recovery is authoritative; embedding warmup is fail-open latency work.
     }
 }
+function launchDailyMaintenance(cwd, ownerSessionKey, sessionOnly) {
+    const args = [resolveCliEntryPath(), "internal-daily-maintenance", "--cwd", cwd];
+    if (ownerSessionKey) {
+        args.push("--session-key", ownerSessionKey);
+    }
+    if (sessionOnly) {
+        args.push("--session-only");
+    }
+    try {
+        const child = spawn(process.execPath, args, {
+            cwd,
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+            env: withoutInvocationHost(),
+        });
+        child.unref();
+    }
+    catch {
+        // Context recovery is authoritative; daily cleanup is fail-open latency work.
+    }
+}
 function buildPublicContextOutput(context) {
     const project = asJsonRecord(context.project);
     const output = {};
@@ -1198,6 +1446,11 @@ async function runHook(args, effectiveHost) {
     });
 }
 async function runStopHook(effectiveHost) {
+    // Cindy owns task-completion closeout in its Host worker path. The CLI sidecar
+    // must not enqueue a job that it cannot execute with a Cindy session runner.
+    if (effectiveHost === "cindy") {
+        return;
+    }
     if (process.env.CLAW_KNOWLEDGE_FINALIZER === "1") {
         return;
     }
@@ -1226,14 +1479,166 @@ async function runStopHook(effectiveHost) {
             host: effectiveHost,
             taskConclusions: transcriptPath ? extractTaskDoneConclusions(transcriptPath, turnId) : [],
         });
-        if (result.ok && result.jobPath && process.env.CLAW_KNOWLEDGE_FINALIZER_DISABLE_LAUNCH !== "1") {
+        // Current named hosts own their runner in their adapters.  Keep the CLI
+        // launcher only for jobs written by pre-adapter releases with no host.
+        if (result.ok && result.jobPath && !effectiveHost && process.env.CLAW_KNOWLEDGE_FINALIZER_DISABLE_LAUNCH !== "1") {
             launchKnowledgeFinalizationWorker(result.jobPath, project.projectRoot);
         }
+        if (process.env.CLAW_KNOWLEDGE_CAPTURE_RESULT === "1") {
+            printJson(result);
+        }
     }
     catch {
         // Knowledge capture is a fail-open sidecar and must never block Stop.
     }
 }
+/**
+ * Machine-facing report capture for hosts whose final-message hook is owned by
+ * the adapter rather than by the CLI.  Unlike `hook auto-doc`, this only
+ * persists the report/job hand-off; it never chooses or launches a writer.
+ */
+async function runInternalKnowledgeCapture(args, effectiveHost) {
+    assertNoRemainingArgs(args, "internal-knowledge-capture");
+    const payload = await readStdinJson();
+    const hookCwd = resolveHookCwd(payload);
+    const sessionId = resolveOwnerSessionKey(payload);
+    const turnId = readHookString(payload, "turn_id");
+    const message = readHookString(payload, "message");
+    const taskConclusions = readHookTaskConclusions(payload, turnId);
+    if (!hookCwd || !sessionId || !turnId || !message || !containsClawDir(hookCwd)) {
+        printJson({ ok: true, captured: false });
+        return;
+    }
+    try {
+        const project = resolveProjectContext(hookCwd);
+        const result = tryCaptureKnowledgeStop({
+            project,
+            sessionId,
+            turnId,
+            message,
+            host: effectiveHost === "cindy" ? "cindy" : effectiveHost,
+            taskConclusions,
+        });
+        printJson(result);
+    }
+    catch (error) {
+        // Capture is a non-blocking sidecar.  Return structured failure so the
+        // owning adapter can surface/retry it without affecting the assistant turn.
+        printJson({ ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+/** Record a successful adapter-owned writer run without invoking a host SDK. */
+function runInternalKnowledgeComplete(args) {
+    const jobPath = readRequiredFlag(args, "--job");
+    const result = readRequiredFlag(args, "--result");
+    assertNoRemainingArgs(args, "internal-knowledge-complete");
+    const running = ensureLegacyKnowledgeClaim(jobPath);
+    if (!running?.claimToken) {
+        printJson({ ok: true, completed: false, reason: "job is not claimable" });
+        return;
+    }
+    completeKnowledgeFinalizationJob(jobPath, result, running.claimToken);
+}
+function runInternalKnowledgeClaim(args) {
+    const jobPath = readRequiredFlag(args, "--job");
+    assertNoRemainingArgs(args, "internal-knowledge-claim");
+    const job = ensureLegacyKnowledgeClaim(jobPath);
+    printJson({
+        ok: true,
+        claimed: Boolean(job),
+        ...(job ? {
+            finalizeId: job.finalizeId,
+            claimToken: job.claimToken,
+        } : {}),
+    });
+}
+function runInternalKnowledgeFail(args) {
+    const jobPath = readRequiredFlag(args, "--job");
+    const message = readRequiredFlag(args, "--message");
+    assertNoRemainingArgs(args, "internal-knowledge-fail");
+    const job = ensureLegacyKnowledgeClaim(jobPath);
+    if (!job?.claimToken) {
+        printJson({ ok: true, failed: false, reason: "job is not claimable" });
+        return;
+    }
+    failKnowledgeFinalizationJob(jobPath, message, job.claimToken);
+}
+function ensureLegacyKnowledgeClaim(jobPath) {
+    const job = readKnowledgeFinalizationJob(jobPath);
+    if (job.status === "succeeded" || job.status === "failed" && job.attempts >= 3) {
+        return null;
+    }
+    if (job.status === "running") {
+        return job;
+    }
+    return claimKnowledgeFinalizationJob(jobPath);
+}
+function completeKnowledgeFinalizationJob(jobPath, result, claimToken) {
+    const running = readKnowledgeFinalizationJob(jobPath);
+    if (running.status === "succeeded") {
+        const terminal = doneKnowledgeFinalizationJob({
+            jobPath,
+            claimToken,
+            status: "succeeded",
+            result,
+        });
+        removeKnowledgeAssignmentTemplate(jobPath, running.finalizeId);
+        printJson({ ok: true, completed: true, alreadyDone: terminal.alreadyDone, finalizeId: running.finalizeId });
+        return;
+    }
+    if (running.status !== "running") {
+        throw new Error("Knowledge finalization job must be claimed before successful completion.");
+    }
+    if (running.claimToken !== claimToken) {
+        throw new Error("Knowledge finalization completion does not match the active claim.");
+    }
+    const project = resolveProjectContext(running.projectRoot);
+    const finishedAt = new Date().toISOString();
+    const truthEncoding = normalizeTruthMarkdownEncoding(project);
+    recordKnowledgeFinalizationResult(project, running.reportPath, {
+        schemaVersion: 1,
+        entryType: "knowledge_finalization",
+        finalizeId: running.finalizeId,
+        taskName: running.taskName,
+        recordedAt: finishedAt,
+        status: "succeeded",
+        result,
+        attempts: running.attempts,
+        ...(running.host !== undefined ? { host: running.host } : {}),
+        truthEncoding,
+    });
+    const terminal = doneKnowledgeFinalizationJob({
+        jobPath,
+        claimToken,
+        status: "succeeded",
+        result,
+        finishedAt,
+        patch: { truthEncoding },
+    });
+    removeKnowledgeAssignmentTemplate(jobPath, running.finalizeId);
+    queueCompletionRefresh({
+        cwd: running.projectRoot,
+        taskName: running.taskName,
+        includeTaskRetention: false,
+        includeTaskMemory: false,
+        statusLabel: `knowledge-${running.finalizeId.slice(0, 12)}`,
+        skipGitNexusRefresh: true,
+    });
+    printJson({ ok: true, completed: true, alreadyDone: terminal.alreadyDone, finalizeId: running.finalizeId });
+}
+function failKnowledgeFinalizationJob(jobPath, message, claimToken) {
+    const terminal = doneKnowledgeFinalizationJob({
+        jobPath,
+        claimToken,
+        status: "failed",
+        error: message,
+    });
+    removeKnowledgeAssignmentTemplate(jobPath, terminal.job.finalizeId);
+    printJson({ ok: true, failed: true, alreadyDone: terminal.alreadyDone, finalizeId: terminal.job.finalizeId });
+}
+function removeKnowledgeAssignmentTemplate(jobPath, finalizeId) {
+    fs.rmSync(path.join(path.dirname(jobPath), `${finalizeId}.assignments.json`), { force: true });
+}
 async function runInternalEmbeddingWarmup(args) {
     const cwd = readRequiredFlag(args, "--cwd");
     assertNoRemainingArgs(args, "internal-embedding-warmup");
@@ -1243,112 +1648,156 @@ async function runInternalEmbeddingWarmup(args) {
         ...await warmProjectMemoryEmbedding({ cwd }),
     });
 }
+function runInternalDailyMaintenance(args) {
+    const cwd = readRequiredFlag(args, "--cwd");
+    const sessionKey = readOptionalFlag(args, "--session-key");
+    const sessionOnly = readBooleanFlag(args, "--session-only");
+    assertNoRemainingArgs(args, "internal-daily-maintenance");
+    const project = sessionOnly
+        ? (sessionKey ? resolveSessionWorkflowContext(sessionKey) : null)
+        : resolveProjectContext(cwd);
+    if (!project) {
+        printJson({ command: "internal-daily-maintenance", ok: true, ran: false, skipped: true });
+        return;
+    }
+    printJson({
+        command: "internal-daily-maintenance",
+        ok: true,
+        ...runDailyMaintenance(project, {
+            excludeSessionKey: sessionKey ?? undefined,
+            includeProject: !sessionOnly,
+        }),
+    });
+}
+function runInternalKnowledgeSweep(args) {
+    const cwd = readRequiredFlag(args, "--cwd");
+    assertNoRemainingArgs(args, "internal-knowledge-sweep");
+    const project = tryResolveHookProject(cwd);
+    if (!project) {
+        printJson({ command: "internal-knowledge-sweep", ok: true, launched: 0, skipped: true });
+        return;
+    }
+    const jobs = listRetryableKnowledgeFinalizationJobs(project);
+    let launched = 0;
+    for (const jobPath of jobs) {
+        try {
+            launchKnowledgeFinalizationWorker(jobPath, project.projectRoot);
+            launched += 1;
+        }
+        catch {
+            // A later background sweep can retry a job that could not be launched.
+        }
+    }
+    printJson({ command: "internal-knowledge-sweep", ok: true, discovered: jobs.length, launched });
+}
+async function runInternalBackgroundMaintenance(args) {
+    const cwd = readRequiredFlag(args, "--cwd");
+    const sessionKey = readOptionalFlag(args, "--session-key");
+    assertNoRemainingArgs(args, "internal-background-maintenance");
+    const sessionProject = sessionKey ? resolveSessionWorkflowContext(sessionKey) : null;
+    const project = sessionProject ? null : tryResolveHookProject(cwd);
+    let maintenance = { ran: false, skipped: true };
+    if (sessionProject) {
+        maintenance = runDailyMaintenance(sessionProject, { excludeSessionKey: sessionKey ?? undefined, includeProject: false });
+    }
+    else if (project) {
+        maintenance = runDailyMaintenance(project, { excludeSessionKey: sessionKey ?? undefined });
+    }
+    let embedding = { warmed: false, reason: "skipped" };
+    try {
+        embedding = await warmProjectMemoryEmbedding({ cwd });
+    }
+    catch (error) {
+        embedding = { warmed: false, reason: "failed", error: error instanceof Error ? error.message : String(error) };
+    }
+    let discovered = 0;
+    let launched = 0;
+    const knowledgeProject = project ?? sessionProject;
+    if (knowledgeProject) {
+        const jobs = listRetryableKnowledgeFinalizationJobs(knowledgeProject);
+        discovered = jobs.length;
+        for (const jobPath of jobs) {
+            try {
+                launchKnowledgeFinalizationWorker(jobPath, knowledgeProject.projectRoot);
+                launched += 1;
+            }
+            catch {
+                // A later background sweep can retry a job that could not be launched.
+            }
+        }
+    }
+    printJson({ command: "internal-background-maintenance", ok: true, maintenance, embedding, discovered, launched });
+}
 async function runInternalKnowledgeFinalize(args) {
     const jobPath = readRequiredFlag(args, "--job");
-    const running = claimKnowledgeFinalizationJob(jobPath);
-    if (!running) {
+    const queued = readKnowledgeFinalizationJob(jobPath);
+    assertNoRemainingArgs(args, "internal-knowledge-finalize");
+    if ((queued.writer?.executionPolicy ?? "background") !== "background") {
         return;
     }
     try {
-        const project = resolveProjectContext(running.projectRoot);
-        const useBuiltInAutomation = usesBuiltInKnowledgeWriter(running);
-        const knowledgeBefore = snapshotKnowledgeMarkdown(project.truthDir);
-        const writerRun = await runKnowledgeWriterForJob(running);
-        const knowledgeGovernance = useBuiltInAutomation
-            ? governChangedKnowledgeMarkdown({
-                truthDir: project.truthDir,
-                before: knowledgeBefore,
-                datedSectionsToKeep: running.writer?.datedSectionsToKeep ?? 6,
-            })
-            : undefined;
-        const truthEncoding = normalizeTruthMarkdownEncoding(project);
-        const changedKnowledgePaths = changedKnowledgeMarkdownPaths(knowledgeBefore, snapshotKnowledgeMarkdown(project.truthDir));
-        queueCompletionRefresh({
-            cwd: running.projectRoot,
-            taskName: running.taskName,
-            includeTaskRetention: false,
-            includeTaskMemory: false,
-            statusLabel: `knowledge-${running.finalizeId.slice(0, 12)}`,
-            skipGitNexusRefresh: true,
-        });
-        const finishedAt = new Date().toISOString();
-        recordKnowledgeFinalizationResult(project, running.reportPath, {
-            schemaVersion: 1,
-            entryType: "knowledge_finalization",
-            finalizeId: running.finalizeId,
-            taskName: running.taskName,
-            recordedAt: finishedAt,
-            status: "succeeded",
-            result: writerRun.finalResponse,
-            attempts: running.attempts,
-            ...(running.host !== undefined ? { host: running.host } : {}),
+        const writerRun = await runKnowledgeDelegateForJob(queued);
+        const terminal = readKnowledgeFinalizationJob(jobPath);
+        if (terminal.status !== "succeeded" && terminal.status !== "failed") {
+            throw new Error("Knowledge delegate returned without acknowledging a terminal result.");
+        }
+        if (writerRun.threadId) {
+            assertCompletedKnowledgeWriterSession(writerRun.threadId);
+        }
+        printJson({
+            ok: terminal.status === "succeeded",
+            command: "internal-knowledge-finalize",
+            finalizeId: terminal.finalizeId,
+            status: terminal.status,
             ...(writerRun.threadId ? { threadId: writerRun.threadId } : {}),
-            ...(knowledgeGovernance ? { knowledgeGovernance } : {}),
-            truthEncoding,
-        });
-        writeKnowledgeFinalizationJob(jobPath, {
-            ...running,
-            status: "succeeded",
-            finishedAt,
-            ...(writerRun.threadId ? { sdkThreadId: writerRun.threadId } : {}),
-            ...(writerRun.threadIds ? { sdkThreadIds: writerRun.threadIds } : {}),
-            finalResponse: writerRun.finalResponse,
-            ...(knowledgeGovernance ? { knowledgeGovernance } : {}),
-            truthEncoding,
         });
     }
     catch (error) {
-        const failed = {
-            ...running,
-            status: "failed",
-            finishedAt: new Date().toISOString(),
-            error: { message: error instanceof Error ? error.message : String(error) },
-        };
-        writeKnowledgeFinalizationJob(jobPath, failed);
+        const message = error instanceof Error ? error.message : String(error);
+        let failed = readKnowledgeFinalizationJob(jobPath);
+        if (failed.status === "running" && failed.claimToken) {
+            failed = doneKnowledgeFinalizationJob({
+                jobPath,
+                claimToken: failed.claimToken,
+                status: "failed",
+                error: message,
+            }).job;
+        }
+        else if (failed.status === "queued") {
+            const supervisorClaim = claimKnowledgeFinalizationJob(jobPath);
+            if (supervisorClaim?.claimToken) {
+                failed = doneKnowledgeFinalizationJob({
+                    jobPath,
+                    claimToken: supervisorClaim.claimToken,
+                    status: "failed",
+                    error: message,
+                }).job;
+            }
+        }
+        if (failed.status === "failed") {
+            removeKnowledgeAssignmentTemplate(jobPath, failed.finalizeId);
+        }
         if (failed.attempts < 3 && process.env.CLAW_KNOWLEDGE_FINALIZER_DISABLE_RETRY !== "1") {
             launchKnowledgeFinalizationWorker(jobPath, failed.projectRoot);
         }
     }
 }
-const BUILT_IN_KNOWLEDGE_WRITER_SKILL = "claw-kit:knowledge-writer";
-/**
- * Pick the host-aware finalization runner. The opencode host never assumes a Codex SDK
- * runtime is installed and runs the writer through `opencode run`; the Codex host and
- * legacy jobs without a host field keep using the versioned Codex SDK runtime.
- */
-async function runKnowledgeWriterForJob(running) {
-    const skills = resolveKnowledgeWriterSkills(running);
-    const results = [];
-    for (const skill of skills) {
-        if (running.host === "opencode") {
-            const result = runOpencodeKnowledgeWriter({
-                prompt: buildKnowledgeWriterPrompt(running, skill),
-                projectRoot: running.projectRoot,
-                writer: running.writer ?? null,
-            });
-            if (isBuiltInKnowledgeWriterSkill(skill)) {
-                assertCompletedKnowledgeWriterSession(result.threadId ?? null);
-            }
-            results.push({
-                finalResponse: result.finalResponse,
-                ...(result.threadId ? { threadId: result.threadId } : {}),
-            });
-            continue;
-        }
-        if (running.host !== undefined && running.host !== null && running.host !== "codex") {
-            throw new Error(`Unsupported knowledge finalization job host "${String(running.host)}".`);
-        }
-        results.push(await runCodexSdkWriter(running, skill));
+async function runKnowledgeDelegateForJob(running) {
+    const dispatch = buildKnowledgeDelegateDispatch({
+        policy: "background",
+        finalizeId: running.finalizeId,
+        writer: running.writer,
+    });
+    if (running.host === "opencode") {
+        return runOpencodeKnowledgeWriter({
+            prompt: dispatch.prompt,
+            projectRoot: running.projectRoot,
+            writer: running.writer ?? null,
+        });
+    }
+    if (running.host !== undefined && running.host !== null && running.host !== "codex") {
+        throw new Error(`Unsupported knowledge finalization job host "${String(running.host)}".`);
     }
-    const threadIds = results.flatMap((result) => result.threadId ? [result.threadId] : []);
-    const last = results.at(-1);
-    return {
-        finalResponse: results.map((result) => result.finalResponse).join("\n\n"),
-        ...(last?.threadId ? { threadId: last.threadId } : {}),
-        ...(threadIds.length > 0 ? { threadIds } : {}),
-    };
-}
-async function runCodexSdkWriter(running, skill) {
     const sdk = await import(pathToFileURL(resolveCodexSdkEntryPath()).href);
     const Codex = sdk.Codex;
     const codex = new Codex({
@@ -1368,10 +1817,7 @@ async function runCodexSdkWriter(running, skill) {
             ? { modelReasoningEffort: writer.reasoningEffort }
             : {}),
     });
-    const turn = await thread.run(buildKnowledgeWriterPrompt(running, skill));
-    if (isBuiltInKnowledgeWriterSkill(skill)) {
-        assertCompletedKnowledgeWriterSession(thread.id);
-    }
+    const turn = await thread.run(dispatch.prompt);
     return {
         finalResponse: turn.finalResponse,
         ...(thread.id ? { threadId: thread.id } : {}),
@@ -1416,28 +1862,11 @@ function knowledgeFinalizerEnvironment() {
         }
     }
     env.CLAW_KNOWLEDGE_FINALIZER = "1";
+    delete env.CLAW_SESSION_ID;
+    delete env.CODEX_THREAD_ID;
+    delete env.CODEX_SESSION_ID;
     return env;
 }
-function buildKnowledgeWriterPrompt(job, writerSkill) {
-    return [
-        `Apply the ${writerSkill} skill's documentation-governance rules to the supplied materials and update the governed project documentation. Work unattended; do not request review or confirmation. Use task status to distinguish completed work from pending or blocked intent, and never present requirements or intentions as results. Skip and report ambiguous or unsafe changes.`,
-        "Materials:",
-        `- ${job.planPath}`,
-        `- ${job.reportPath}`,
-        `Finalization id: ${job.finalizeId}`,
-        "Interpret inputs by content, regardless of filename or schema. Do not reference or link to the supplied materials in governed documentation; they are transient and will be destroyed after finalization. Do not modify inputs, delegate, reimplement, or rerun tests.",
-    ].join("\n");
-}
-function resolveKnowledgeWriterSkills(job) {
-    const configured = job.writer?.externalSkills?.map((skill) => skill.trim()).filter(Boolean);
-    return configured && configured.length > 0 ? configured : [BUILT_IN_KNOWLEDGE_WRITER_SKILL];
-}
-function isBuiltInKnowledgeWriterSkill(skill) {
-    return skill === BUILT_IN_KNOWLEDGE_WRITER_SKILL;
-}
-function usesBuiltInKnowledgeWriter(job) {
-    return resolveKnowledgeWriterSkills(job).every(isBuiltInKnowledgeWriterSkill);
-}
 function launchKnowledgeFinalizationWorker(jobPath, cwd) {
     if (process.platform === "win32") {
         const launcherScript = [
@@ -1484,11 +1913,15 @@ async function runSessionStartHook(effectiveHost) {
     try {
         const context = await runContextCommand([], hookCwd, ownerSessionKey, effectiveHost);
         const contextProject = asJsonRecord(context.project);
+        const retryableJobs = effectiveHost !== "cindy" && contextProject?.scope !== "session" && !context.error
+            ? listRetryableKnowledgeFinalizationJobs(resolveProjectContext(hookCwd))
+            : [];
         if (contextProject?.scope !== "session"
             && !context.error
+            && effectiveHost !== "cindy"
             && process.env.CLAW_KNOWLEDGE_FINALIZER_DISABLE_LAUNCH !== "1") {
             const project = resolveProjectContext(hookCwd);
-            for (const jobPath of listRetryableKnowledgeFinalizationJobs(project)) {
+            for (const jobPath of retryableJobs) {
                 try {
                     launchKnowledgeFinalizationWorker(jobPath, project.projectRoot);
                 }
@@ -1538,6 +1971,21 @@ function readHookString(payload, key) {
     const value = payload[key];
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function readHookTaskConclusions(payload, turnId) {
+    if (!turnId || !payload || typeof payload !== "object")
+        return [];
+    const value = payload.task_conclusions;
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object")
+            return [];
+        const message = item.message;
+        return typeof message === "string" && message.trim()
+            ? [{ turnId, message: message.trim() }]
+            : [];
+    });
+}
 function containsClawDir(cwd) {
     try {
         const startDir = path.resolve(cwd);
@@ -1579,6 +2027,9 @@ function safeResolveTempDir() {
 }
 function buildSessionStartAdditionalContext(context, sessionCwd, effectiveHost) {
     const versionSyncPrompt = buildVersionSyncPrompt(context);
+    if (effectiveHost === "cindy") {
+        return buildCindySessionStartContext(context, sessionCwd, versionSyncPrompt);
+    }
     const searchGuidance = buildContextSearchGuidance(context);
     const runtimeErrorPrompt = buildCodexRuntimeErrorPrompt(context);
     const activeWorkflow = context.activeWorkflow;
@@ -1613,6 +2064,45 @@ function buildSessionStartAdditionalContext(context, sessionCwd, effectiveHost)
     const promptWithSearch = searchGuidance ? `${promptWithVersion}\n${searchGuidance}` : promptWithVersion;
     return runtimeErrorPrompt ? `${runtimeErrorPrompt}\n\n${promptWithSearch}` : promptWithSearch;
 }
+/**
+ * Cindy Agents use the Ghost Tool gateway, not shell commands or Host actions.
+ * Match the Codex session-start wording and structure. Cindy's static entry
+ * prompt supplies the shared skill and guidance lines; this dynamic context
+ * supplies project identity or a recovered workflow snapshot. Goal Mode is
+ * intentionally omitted because Cindy does not expose that Host surface.
+ */
+function buildCindySessionStartContext(context, sessionCwd, versionSyncPrompt) {
+    const activeWorkflow = asJsonRecord(context.activeWorkflow);
+    if (activeWorkflow) {
+        return stripCindyGoalModeLines(buildRecoveredWorkflowAdditionalContext(activeWorkflow, versionSyncPrompt));
+    }
+    const project = asJsonRecord(context.project);
+    if (!project)
+        return null;
+    const projectName = typeof project.projectName === "string" && project.projectName.trim()
+        ? project.projectName.trim()
+        : typeof project.projectId === "string" && project.projectId.trim()
+            ? project.projectId.trim()
+            : path.basename(String(project.projectRoot ?? sessionCwd ?? "project"));
+    const projectRoot = typeof project.projectRoot === "string" ? project.projectRoot : sessionCwd;
+    const projectId = typeof project.projectId === "string" ? project.projectId : projectName;
+    const clawDir = typeof project.clawDir === "string" ? project.clawDir : path.join(projectRoot, ".claw");
+    const prompt = [
+        `This session started inside a .claw project: ${projectName} (${projectId}).`,
+        `.claw directory: ${clawDir}`,
+    ].join("\n");
+    if (!versionSyncPrompt)
+        return prompt;
+    return versionSyncPrompt.placement === "prefix"
+        ? `${versionSyncPrompt.lines.join("\n")}\n${prompt}`
+        : `${prompt}\n${versionSyncPrompt.lines.join("\n")}`;
+}
+function stripCindyGoalModeLines(prompt) {
+    return prompt
+        .split("\n")
+        .filter((line) => !/goal mode/i.test(line))
+        .join("\n");
+}
 function buildCodexRuntimeErrorPrompt(context) {
     const error = asJsonRecord(context.error);
     if (error?.code !== "CODEX_SDK_RUNTIME_MISSING") {
@@ -1674,8 +2164,9 @@ function buildVersionSyncPrompt(context) {
         return {
             placement: "suffix",
             lines: [
-                `Before anything else, a newer claw-kit version was detected: local CLI ${cliVersion}, published latest ${latestPublishedVersion}.`,
-                `First action: use ${updateSkill} to update the claw-kit CLI and the current host plugin surface before continuing any other work.`,
+                `A newer claw-kit version is available: installed CLI ${cliVersion}, published latest ${latestPublishedVersion}.`,
+                "Tell the user in their language that the current claw-kit installation is out of date and must be updated before they can continue using claw-kit. Ask whether they want to update now, then wait for their answer.",
+                `After the user confirms, use ${updateSkill} to update the claw-kit CLI and the current host plugin surface, then continue the original task.`,
             ],
         };
     }
@@ -1820,6 +2311,7 @@ async function runSubplan(args, effectiveHost) {
 }
 function resolveOwnerSessionKey(payload) {
     const envCandidates = [
+        process.env.CLAW_SESSION_ID,
         process.env.CODEX_THREAD_ID,
         process.env.CODEX_SESSION_ID,
     ];
@@ -1880,13 +2372,20 @@ function readJson(filePath) {
 function stripBom(content) {
     return content.charCodeAt(0) === 0xfeff ? content.slice(1) : content;
 }
-function compactPlanCommandResult(command, result, effectiveHost, completionRefresh, forceProjectionSync = false) {
+function buildKnowledgeDispatch(input) {
+    return buildKnowledgeDelegateDispatch({
+        policy: "subagent",
+        ...input,
+    });
+}
+function compactPlanCommandResult(command, result, effectiveHost, completionRefresh, forceProjectionSync = false, knowledgeDispatch) {
     const archivedPlanPath = completionRefresh?.taskRetention.archivedCurrentTask?.taskName === result.taskName &&
         completionRefresh.taskRetention.archivedCurrentTask.archivedPlanPath
         ? completionRefresh.taskRetention.archivedCurrentTask.archivedPlanPath
         : undefined;
     const resolvedPlanPath = archivedPlanPath ?? result.planPath;
     const codexResult = effectiveHost === "codex";
+    const cindyResult = effectiveHost === "cindy";
     const hostActions = codexResult ? buildHostActions(result, { forceProjectionSync, actionIdPrefix: command === "plan.sync" ? `plan.sync:${createHash("sha256").update(result.planPath).digest("hex").slice(0, 16)}` : undefined }) : [];
     const nextsteps = codexResult
         && result.planStatus === "end.completed"
@@ -1917,16 +2416,17 @@ function compactPlanCommandResult(command, result, effectiveHost, completionRefr
         ...(archivedPlanPath ? { archivedPlanPath } : {}),
         planStatus: result.planStatus,
         ...(achievement ? { achievement } : {}),
+        ...(knowledgeDispatch ? { knowledgeDispatch } : {}),
         ...(!codexResult && result.previousPlanStatus ? { previousPlanStatus: result.previousPlanStatus } : {}),
         ...(hostActions.length ? { hostActions } : {}),
         ...(!codexResult && result.changedTaskIds?.length ? { changedTaskIds: result.changedTaskIds } : {}),
         ...(!codexResult && result.appendedTaskIds?.length ? { appendedTaskIds: result.appendedTaskIds } : {}),
         ...(codexResult ? { stage: result.workflowGuidance.stage } : {}),
-        ...(!codexResult || result.planStatus === "end.completed"
+        ...((!codexResult && !cindyResult) || result.planStatus === "end.completed" && !cindyResult
             ? { nextsteps }
             : {}),
         ...(result.workflowGuidance.nextTask ? { nextTask: result.workflowGuidance.nextTask } : {}),
-        ...(result.workflowGuidance.notes?.trim() && !codexResult
+        ...(result.workflowGuidance.notes?.trim() && !codexResult && !cindyResult
             ? { notes: result.workflowGuidance.notes }
             : {}),
         ...(result.workflowGuidance.commandHints?.length
@@ -1941,9 +2441,13 @@ function compactPlanCommandResult(command, result, effectiveHost, completionRefr
                 failedOperation: result.operationChain.failedOperation,
             }
             : {}),
-        ...(!codexResult && result.workflowGuidance.goalMode ? { goalMode: result.workflowGuidance.goalMode } : {}),
-        ...(!codexResult && result.workflowGuidance.goalTool ? { goalTool: result.workflowGuidance.goalTool } : {}),
+        ...(!codexResult && !cindyResult && result.workflowGuidance.goalMode ? { goalMode: result.workflowGuidance.goalMode } : {}),
+        ...(!codexResult && !cindyResult && result.workflowGuidance.goalTool ? { goalTool: result.workflowGuidance.goalTool } : {}),
         ...(includePlan && result.plan ? { plan: result.plan } : {}),
+        // Cindy's Ghost card is a Host-owned projection.  It needs the
+        // canonical task list to render its expandable Todo view, but that
+        // view stays out of Agent guidance in the Cindy adapter.
+        ...(cindyResult ? { planView: result.planView } : {}),
         ...(result.planReview
             ? {
                 planReview: {
@@ -3305,7 +3809,7 @@ function printTopLevelUsage() {
         "Global flags:",
         "  -h, --help     Show help (use `claw help <command>` for command details).",
         "  -v, --version  Print the CLI version.",
-        "  --host <host>   Select host-specific output projection (codex or opencode).",
+        "  --host <host>   Select host-specific output projection (codex, opencode, or cindy).",
         "",
         "Run `claw help <command>` or `claw help <command> <subcommand>` for detailed help.",
     ];