@veewo/claw 0.2.2 → 0.2.3

package/README.md

@@ -1,83 +1,83 @@
-# @veewo/claw
-
-`@veewo/claw` is the CLI entrypoint for running the `.claw` workflow in a project.
-
-It gives agents and developers a concrete way to plan work, recall project knowledge, deposit truth and ADR notes, and close rounds out cleanly instead of leaving project state scattered across transient chats.
-
-## What the CLI is for
-
-- initialize and normalize the `.claw` project surface
-- run project-scoped planning and task lifecycle commands
-- index and query project documentation recall
-- support truth ingestion and closeout flows
-
-## Install
-
-```bash
-npm install -g @veewo/claw
-```
-
-After installing the CLI, project search still needs one-time setup inside each `.claw` project:
-
-1. Run `claw context` so `.claw/project.json` is normalized and the default local embedding config is present.
-2. Run `claw search index --refresh` once so the local embedding model can be downloaded or reused and the first vector index can be built.
-
-Then run:
-
-```bash
-claw init
-claw search index --refresh
-claw search "existing truth or ADR topic"
-claw plan create --title "My task" --goal "Define the first task"
-claw plan create "My templated task" --template default --goal "Route through the default template"
-claw plan create "Ephemeral harness" --scope session --goal "Use plan and Goal workflows without project deposition"
-```
-
-`claw plan create` uses explicit `--template` first, otherwise the project's configured `defaultPlanTemplate`, and finally falls back to the built-in `default` template. You can select a template explicitly with `claw plan create "<title>" --template <name>` or `claw plan create --template <name> --title "<title>"`.
-
-New project tasks are grouped under `.claw/tasks/YYYY-MM-DD/`. On the first `claw context` call of each local calendar day, claw performs a lock-protected maintenance pass: it clears `.claw/runtime/tmp/` (and removes legacy `.claw/tmp/`), moves date-scoped task folders from before yesterday into the archive even when old plans have no `completedAt`, archives legacy flat tasks by `plan.updatedAt` (falling back to the plan file timestamp), applies `maxTasksToKeep` to archived tasks, removes bindings to plans no longer under active tasks, and sweeps expired session workflows. This is lazy maintenance, not a background scheduler.
-
-`--scope session` stores the workflow in a user-level directory keyed by the platform session id, so it works without a project `.claw` directory and recovers across cwd changes. It preserves plan/task/subplan/Goal behavior while disabling project knowledge capture, memory/GitNexus refresh, and project retention. Use `claw session clean` for the current session or `claw session clean --expired` for the seven-day TTL sweep.
-
-Projects can add reusable templates directly under `.claw/templates` with `.json`, `.js`, `.mjs`, or `.cjs` files. Put `defaultPlanTemplate` in `.claw/project.json` for a shared team default, or in `.claw/project-override.json` for a local personal override.
-
-When `.claw/project.json` has `planning: true`, the default `default` template seeds one planning task in `process.discussing`. It loads the effective `externalPlanningSkill`, falling back to `claw-kit:planning`, and stays open while the requirements and proposed solution are discussed and confirmed with the user. Use `plan start` when execution tasks remain; when planning itself resolves the request, complete task 1 and close the plan.
-
-When `planning: false`, `claw plan create` seeds the smallest executable plan directly in `process.active`.
-
-## Workflow shape
-
-In a typical round, the CLI helps land this loop in a project:
-
-`plan` -> `search and recall` -> `execute` -> `deposit truth / ADR` -> `close out`
-
-That project-level plan structure helps agents carry longer-running work more cleanly than leaving the task in loose chat state alone.
-
-Codex startup workflow should rely on the session hook or startup recovery path instead of treating any extra manual recovery step as required after plan creation.
-
-## Search and recall
-
-`claw search` is the project recall command for `.claw` memory, truth, ADR, and declared markdown docs. Use it for retained project context rather than code search.
-
-When a task needs deeper code investigation or relationship tracing, GitNexus can complement this workflow, but it is optional rather than required for using `claw` itself.
-
-Typical setup:
-
-```bash
-claw context
-claw search index --refresh
-```
-
-If you need deeper backup detail on config or recall behavior, use the adapter reference notes in [packages/codex-adapter/references/project-config-reference.md](../codex-adapter/references/project-config-reference.md) or [packages/opencode-adapter/references/project-config-reference.md](../opencode-adapter/references/project-config-reference.md).
-
-## Configuration
-
-If you need backup `.claw/project.json` detail, start with the adapter reference notes above and use [docs/project-json-reference.md](../../docs/project-json-reference.md) only for deeper canonical detail.
-
-`claw-kit` also stays usable alongside other harnesses or external skills, so the CLI does not assume a single host or investigation surface.
-
-The config model is team-friendly as well: `.claw/project.json` carries the shared canonical workflow, while `.claw/project-override.json` leaves room for personal runtime preferences.
-
-## Repository
-
-- [claw-kit](https://github.com/chanyuenpang/claw-kit)
+# @veewo/claw
+
+`@veewo/claw` is the CLI entrypoint for running the `.claw` workflow in a project.
+
+It gives agents and developers a concrete way to plan work, recall project knowledge, deposit truth and ADR notes, and close rounds out cleanly instead of leaving project state scattered across transient chats.
+
+## What the CLI is for
+
+- initialize and normalize the `.claw` project surface
+- run project-scoped planning and task lifecycle commands
+- index and query project documentation recall
+- support truth ingestion and closeout flows
+
+## Install
+
+```bash
+npm install -g @veewo/claw
+```
+
+After installing the CLI, project search still needs one-time setup inside each `.claw` project:
+
+1. Run `claw context` so `.claw/project.json` is normalized and the default local embedding config is present.
+2. Run `claw search index --refresh` once so the local embedding model can be downloaded or reused and the first vector index can be built.
+
+Then run:
+
+```bash
+claw init
+claw search index --refresh
+claw search "existing truth or ADR topic"
+claw plan create --title "My task" --goal "Define the first task"
+claw plan create "My templated task" --template default --goal "Route through the default template"
+claw plan create "Ephemeral harness" --scope session --goal "Use plan and Goal workflows without project deposition"
+```
+
+`claw plan create` uses explicit `--template` first, otherwise the project's configured `defaultPlanTemplate`, and finally falls back to the built-in `default` template. You can select a template explicitly with `claw plan create "<title>" --template <name>` or `claw plan create --template <name> --title "<title>"`.
+
+New project tasks are grouped under `.claw/tasks/YYYY-MM-DD/`. On the first `claw context` call of each local calendar day, claw performs a lock-protected maintenance pass: it removes expired entries from `.claw/runtime/tmp/`, removes workflow task directories that exceed the task TTL even when incomplete, moves eligible date-scoped task folders into the archive, applies `maxTasksToKeep` and archive TTL, removes expired or invalid bindings, and sweeps expired session workflows. This is lazy maintenance, not a background scheduler.
+
+`--scope session` stores the workflow in a user-level directory keyed by the platform session id, so it works without a project `.claw` directory and recovers across cwd changes. It preserves plan/task/subplan/Goal behavior while disabling project knowledge capture, memory/GitNexus refresh, and project retention. Use `claw session clean` for the current session or `claw session clean --expired` for the seven-day TTL sweep.
+
+Projects can add reusable templates directly under `.claw/templates` with `.json`, `.js`, `.mjs`, or `.cjs` files. Put `defaultPlanTemplate` in `.claw/project.json` for a shared team default, or in `.claw/project-override.json` for a local personal override.
+
+When `.claw/project.json` has `planning: true`, the default `default` template seeds one planning task in `process.discussing`. It loads the effective `externalPlanningSkill`, falling back to `claw-kit:planning`, and stays open while the requirements and proposed solution are discussed and confirmed with the user. Use `plan start` when execution tasks remain; when planning itself resolves the request, complete task 1 and close the plan.
+
+When `planning: false`, `claw plan create` seeds the smallest executable plan directly in `process.active`.
+
+## Workflow shape
+
+In a typical round, the CLI helps land this loop in a project:
+
+`plan` -> `search and recall` -> `execute` -> `deposit truth / ADR` -> `close out`
+
+That project-level plan structure helps agents carry longer-running work more cleanly than leaving the task in loose chat state alone.
+
+Codex startup workflow should rely on the session hook or startup recovery path instead of treating any extra manual recovery step as required after plan creation.
+
+## Search and recall
+
+`claw search` is the project recall command for `.claw` memory, truth, ADR, and declared markdown docs. Use it for retained project context rather than code search.
+
+When a task needs deeper code investigation or relationship tracing, GitNexus can complement this workflow, but it is optional rather than required for using `claw` itself.
+
+Typical setup:
+
+```bash
+claw context
+claw search index --refresh
+```
+
+If you need deeper backup detail on config or recall behavior, use the adapter reference notes in [packages/codex-adapter/references/project-config-reference.md](../codex-adapter/references/project-config-reference.md) or [packages/opencode-adapter/references/project-config-reference.md](../opencode-adapter/references/project-config-reference.md).
+
+## Configuration
+
+If you need backup `.claw/project.json` detail, start with the adapter reference notes above and use [docs/project-json-reference.md](../../docs/project-json-reference.md) only for deeper canonical detail.
+
+`claw-kit` also stays usable alongside other harnesses or external skills, so the CLI does not assume a single host or investigation surface.
+
+The config model is team-friendly as well: `.claw/project.json` carries the shared canonical workflow, while `.claw/project-override.json` leaves room for personal runtime preferences.
+
+## Repository
+
+- [claw-kit](https://github.com/chanyuenpang/claw-kit)

package/dist/cli.js

@@ -394,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);
@@ -527,6 +549,15 @@ async function main() {
             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;
@@ -717,8 +748,6 @@ async function runPlan(args, effectiveHost) {
                 && effectiveWriter?.executionPolicy === "subagent"
                 && result.knowledgeFinalizeId)
                 ? buildKnowledgeDispatch({
-                    projectRoot: project.projectRoot,
-                    taskName: result.taskName,
                     finalizeId: result.knowledgeFinalizeId,
                     writer: effectiveWriter,
                 })
@@ -820,8 +849,6 @@ async function runPlan(args, effectiveHost) {
                 && effectiveWriter?.executionPolicy === "subagent"
                 && result.knowledgeFinalizeId)
                 ? buildKnowledgeDispatch({
-                    projectRoot: project.projectRoot,
-                    taskName: result.taskName,
                     finalizeId: result.knowledgeFinalizeId,
                     writer: effectiveWriter,
                 })
@@ -1057,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;
@@ -1068,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 } : {}),
         };
     }
@@ -1084,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) {
@@ -1104,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),
@@ -1152,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 = {};
@@ -1441,6 +1504,7 @@ async function runInternalKnowledgeCapture(args, effectiveHost) {
     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;
@@ -1453,6 +1517,7 @@ async function runInternalKnowledgeCapture(args, effectiveHost) {
             turnId,
             message,
             host: effectiveHost === "cindy" ? "cindy" : effectiveHost,
+            taskConclusions,
         });
         printJson(result);
     }
@@ -1583,6 +1648,86 @@ 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 queued = readKnowledgeFinalizationJob(jobPath);
@@ -1640,8 +1785,6 @@ async function runInternalKnowledgeFinalize(args) {
 async function runKnowledgeDelegateForJob(running) {
     const dispatch = buildKnowledgeDelegateDispatch({
         policy: "background",
-        projectRoot: running.projectRoot,
-        taskName: running.taskName,
         finalizeId: running.finalizeId,
         writer: running.writer,
     });
@@ -1770,7 +1913,7 @@ async function runSessionStartHook(effectiveHost) {
     try {
         const context = await runContextCommand([], hookCwd, ownerSessionKey, effectiveHost);
         const contextProject = asJsonRecord(context.project);
-        const retryableJobs = contextProject?.scope !== "session" && !context.error
+        const retryableJobs = effectiveHost !== "cindy" && contextProject?.scope !== "session" && !context.error
             ? listRetryableKnowledgeFinalizationJobs(resolveProjectContext(hookCwd))
             : [];
         if (contextProject?.scope !== "session"
@@ -1795,7 +1938,6 @@ async function runSessionStartHook(effectiveHost) {
             hookSpecificOutput: {
                 hookEventName: "SessionStart",
                 additionalContext,
-                ...(effectiveHost === "cindy" ? { knowledgeJobs: retryableJobs } : {}),
             },
         })}\n`);
     }
@@ -1829,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);
@@ -1869,10 +2026,10 @@ function safeResolveTempDir() {
     }
 }
 function buildSessionStartAdditionalContext(context, sessionCwd, effectiveHost) {
+    const versionSyncPrompt = buildVersionSyncPrompt(context);
     if (effectiveHost === "cindy") {
-        return buildCindySessionStartContext(context, sessionCwd);
+        return buildCindySessionStartContext(context, sessionCwd, versionSyncPrompt);
     }
-    const versionSyncPrompt = buildVersionSyncPrompt(context);
     const searchGuidance = buildContextSearchGuidance(context);
     const runtimeErrorPrompt = buildCodexRuntimeErrorPrompt(context);
     const activeWorkflow = context.activeWorkflow;
@@ -1909,37 +2066,42 @@ function buildSessionStartAdditionalContext(context, sessionCwd, effectiveHost)
 }
 /**
  * Cindy Agents use the Ghost Tool gateway, not shell commands or Host actions.
- * Keep startup recovery to the actionable plan snapshot only; the worker owns
- * session identity, host selection, and any future Goal projection.
+ * 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) {
+function buildCindySessionStartContext(context, sessionCwd, versionSyncPrompt) {
     const activeWorkflow = asJsonRecord(context.activeWorkflow);
     if (activeWorkflow) {
-        const taskName = typeof activeWorkflow.taskName === "string" ? activeWorkflow.taskName.trim() : "current task";
-        const planStatus = typeof activeWorkflow.planStatus === "string" ? activeWorkflow.planStatus.trim() : "unknown";
-        const planSummary = typeof activeWorkflow.planSummary === "string" ? activeWorkflow.planSummary.trim() : "";
-        const nextTask = asJsonRecord(activeWorkflow.workflowGuidance)?.nextTask;
-        const nextTaskTitle = asJsonRecord(nextTask)?.title;
-        const lines = [
-            "claw-kit recovered a Cindy workflow.",
-            `- task: ${taskName}`,
-            `- plan status: ${planStatus}`,
-            ...(planSummary ? [`- plan summary: ${planSummary}`] : []),
-            ...(typeof nextTaskTitle === "string" && nextTaskTitle.trim() ? [`- next task: ${nextTaskTitle.trim()}`] : []),
-            "Use the claw-kit Ghost tools to inspect or advance this workflow. Do not run claw shell commands or manage host/session/Goal state yourself.",
-        ];
-        return lines.join("\n");
+        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()
-        : path.basename(String(project.projectRoot ?? sessionCwd ?? "project"));
-    return [
-        `claw-kit is ready for the Cindy workspace: ${projectName}.`,
-        "Use the claw-kit Ghost tools when this work needs a plan; do not invoke claw shell commands directly.",
+        : 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);