@cortexkit/opencode-magic-context 0.42.6 → 0.43.0

package/src/config/schema/magic-context.test.ts

@@ -191,12 +191,20 @@ describe("MagicContextConfigSchema", () => {
             expect(result.dreamer?.tasks.retrospective.schedule).toBe("0 5 * * *");
         });
 
-        it("defaults classify-memories and retrospective on daily in dreamer task metadata", () => {
-            const result = MagicContextConfigSchema.parse({
+        it("defaults retrospective to a 30-day source window and accepts an override", () => {
+            const defaults = MagicContextConfigSchema.parse({
                 dreamer: { opencode: { model: "x/y" } },
             });
-            expect(result.dreamer?.tasks["classify-memories"].schedule).toBe("0 6 * * *");
-            expect(result.dreamer?.tasks.retrospective.schedule).toBe("0 5 * * *");
+            expect(defaults.dreamer?.tasks["classify-memories"].schedule).toBe("0 6 * * *");
+            expect(defaults.dreamer?.tasks.retrospective.schedule).toBe("0 5 * * *");
+            expect(defaults.dreamer?.tasks.retrospective.recency_days).toBe(30);
+
+            const overridden = MagicContextConfigSchema.parse({
+                dreamer: {
+                    tasks: { retrospective: { schedule: "0 5 * * *", recency_days: 14 } },
+                },
+            });
+            expect(overridden.dreamer?.tasks.retrospective.recency_days).toBe(14);
         });
 
         it("parses both transform modes", () => {
@@ -449,7 +457,7 @@ describe("MagicContextConfigSchema", () => {
                     migrated_execution: ["model", "fallback_models", "variant", "thinking_level"],
                 },
                 task: {
-                    retained: ["schedule", "promotion_threshold"],
+                    retained: ["schedule", "promotion_threshold", "recency_days"],
                     migrated_execution: [
                         "model",
                         "fallback_models",

package/src/config/schema/magic-context.ts

@@ -156,7 +156,7 @@ export const PER_HARNESS_MIGRATION_INVENTORY = {
         migrated_execution: ["model", "fallback_models", "variant", "thinking_level"],
     },
     task: {
-        retained: ["schedule", "promotion_threshold"],
+        retained: ["schedule", "promotion_threshold", "recency_days"],
         migrated_execution: [
             "model",
             "fallback_models",
@@ -512,6 +512,15 @@ const ReviewUserMemoriesTaskConfigSchema = DreamTaskBaseConfigSchema.extend({
 const PromotePrimersTaskConfigSchema = DreamTaskBaseConfigSchema.extend({
     promotion_threshold: PrimerPromotionThresholdSchema,
 });
+const RetrospectiveTaskConfigSchema = DreamTaskBaseConfigSchema.extend({
+    recency_days: z
+        .number()
+        .int()
+        .min(1)
+        .max(3650)
+        .default(30)
+        .describe("retrospective: collect source messages from only the most recent N days"),
+});
 export type DreamTaskConfig = z.infer<typeof DreamTaskConfigSchema>;
 
 /** Default schedule per task. Preserves v1 behavior: verify runs nightly;
@@ -566,12 +575,22 @@ export const DreamTasksSchema = z
         "classify-memories": DreamTaskBaseConfigSchema.default(() =>
             DreamTaskBaseConfigSchema.parse(defaultTaskConfig("classify-memories")),
         ),
-        retrospective: DreamTaskBaseConfigSchema.default(() =>
-            DreamTaskBaseConfigSchema.parse(defaultTaskConfig("retrospective")),
-        ),
-        "maintain-docs": DreamTaskBaseConfigSchema.default(() =>
-            DreamTaskBaseConfigSchema.parse(defaultTaskConfig("maintain-docs")),
+        retrospective: RetrospectiveTaskConfigSchema.default(() =>
+            RetrospectiveTaskConfigSchema.parse(defaultTaskConfig("retrospective")),
         ),
+        "maintain-docs": DreamTaskBaseConfigSchema.extend({
+            max_tokens: z
+                .number()
+                .int()
+                .positive()
+                .default(12000)
+                .describe(
+                    "Maximum combined token count of proposed ARCHITECTURE.md and STRUCTURE.md",
+                ),
+        }).default(() => ({
+            ...DreamTaskBaseConfigSchema.parse(defaultTaskConfig("maintain-docs")),
+            max_tokens: 12000,
+        })),
         "evaluate-smart-notes": DreamTaskBaseConfigSchema.default(() =>
             DreamTaskBaseConfigSchema.parse(defaultTaskConfig("evaluate-smart-notes")),
         ),
@@ -925,7 +944,7 @@ export interface MagicContextConfig {
      *  Graduated from `experimental.temporal_awareness`; default: true. */
     temporal_awareness: boolean;
     /** Debug: when true, keep the child sessions Magic Context spawns for its
-     *  own subagents (historian, dreamer, memory-migration) instead
+     *  own subagents (historian, dreamer) instead
      *  of deleting them on success. For short-term inspection/data collection;
      *  kept sessions accumulate until manually cleared. Default false. */
     keep_subagents: boolean;
@@ -1195,7 +1214,9 @@ export const MagicContextConfigSchema = z
             .number()
             .min(60_000)
             .default(DEFAULT_HISTORIAN_TIMEOUT_MS)
-            .describe("Timeout for each historian prompt call in milliseconds (default: 600000)"),
+            .describe(
+                "Timeout for each historian prompt call in both TypeScript and Rust transform modes, in milliseconds (default: 600000)",
+            ),
         commit_cluster_trigger: z
             .object({
                 enabled: z
@@ -1311,7 +1332,7 @@ export const MagicContextConfigSchema = z
             .boolean()
             .default(false)
             .describe(
-                "Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect.",
+                "Debug: keep every settled Magic Context child session instead of deleting it after success: historian, all Dreamer tasks, smart-note evaluation and compilation, user-memory review, and memory migration. Kept Dreamer children can contain memory-pool text and user messages from other sessions of the same operator; their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect. On OpenCode 2, one hidden session holds many runs; it is kept once any of its runs settled, and only a Dreamer session none of whose runs settled is still deleted.",
             ),
         debug_rpc: z
             .boolean()
@@ -1331,7 +1352,7 @@ export const MagicContextConfigSchema = z
                     .boolean()
                     .default(true)
                     .describe(
-                        "When false, Magic Context stops managing the context window and keeps its knowledge layer: memory and docs/user-profile/key-files injection through additive m[0]/m[1], raw-message FTS indexing, dreamer, notes, ctx_search, ctx_expand, ctx_memory, and /ctx-embed remain available. MC's historian/compartment preparation, tagging, markers, pruning, folding, drops, strips, splicing, synthetic context-management todos, temporal markers, nudges, and fail-closed blocking stop; ctx_expand remains a knowledge-surface tool. fail_closed_blocking is inert: a transform failure passes the input messages through without blocking or cancelling. This setting does not enable native compaction: OpenCode's compaction.auto / compaction.prune or Pi's equivalent owns the window, or nothing does. MC's compaction.enabled in magic-context.jsonc is distinct from OpenCode's compaction.auto / compaction.prune in opencode.jsonc; they are different files and different owners. On the first turn after disabling, a long session may trigger one native compaction cycle; MC removes only its own marker boundary, leaves native boundaries and stored compartments intact, and does no pre-trimming mitigation. Marker cleanup is lazy per session, so an unresumed session is cleaned when it is next resumed. If compaction is enabled again, run /ctx-wrapup when the historian is runnable to catch up. OpenCode peer verification against v1.18.4 confirms native compaction covers child sessions: subagents receive additive memory/docs injection and no MC reclaim in this mode, so keep subagent tasks small or leave compaction.enabled on for long subagent runs. This is boot-resolved and requires a process restart; project-tier compaction.enabled is stripped so a cloned repository cannot disable the user's setting. The sidebar reports raw usage as Context: <pct>% · native compaction or Context: <pct>% · no active compaction and does not show an MC execute-threshold fill. /ctx-wrapup, /ctx-recomp, /ctx-flush, and /ctx-session-upgrade refuse without context-management side effects; /ctx-embed remains functional. Raw content hidden by a native boundary before Magic Context's first pass is not retroactively indexed.",
+                        "When false, Magic Context stops managing the context window and keeps its knowledge layer: memory and docs/user-profile/key-files injection through additive m[0]/m[1], raw-message FTS indexing, dreamer, notes, ctx_search, ctx_expand, ctx_memory, and /ctx-embed remain available. MC's historian/compartment preparation, tagging, markers, pruning, folding, drops, strips, splicing, synthetic context-management todos, temporal markers, nudges, and fail-closed blocking stop; ctx_expand remains a knowledge-surface tool. fail_closed_blocking is inert: a transform failure passes the input messages through without blocking or cancelling. This setting does not enable native compaction: OpenCode's compaction.auto / compaction.prune or Pi's equivalent owns the window, or nothing does. MC's compaction.enabled in magic-context.jsonc is distinct from OpenCode's compaction.auto / compaction.prune in opencode.jsonc; they are different files and different owners. On the first turn after disabling, a long session may trigger one native compaction cycle; MC removes only its own marker boundary, leaves native boundaries and stored compartments intact, and does no pre-trimming mitigation. Marker cleanup is lazy per session, so an unresumed session is cleaned when it is next resumed. If compaction is enabled again, run /ctx-wrapup when the historian is runnable to catch up. OpenCode peer verification against v1.18.4 confirms native compaction covers child sessions: subagents receive additive memory/docs injection and no MC reclaim in this mode, so keep subagent tasks small or leave compaction.enabled on for long subagent runs. This is boot-resolved and requires a process restart; project-tier compaction.enabled is stripped so a cloned repository cannot disable the user's setting. The sidebar reports raw usage as Context: <pct>% · native compaction or Context: <pct>% · no active compaction and does not show an MC execute-threshold fill. /ctx-wrapup, /ctx-recomp, and /ctx-flush refuse without context-management side effects; /ctx-embed remains functional. Raw content hidden by a native boundary before Magic Context's first pass is not retroactively indexed.",
                     ),
             })
             .default({ enabled: true })
@@ -1490,6 +1511,76 @@ export const MagicContextConfigSchema = z
         };
     });
 
+/** Settings whose fresh values can be used by later agent runs without changing rendered prompt bytes. */
+export const LIVE_RELOAD_CONFIG_PATHS = [
+    "mural.model",
+    "toast_duration_ms",
+    "historian.opencode.model",
+    "historian.opencode.fallback_models",
+    "historian.opencode.variant",
+    "historian.pi.model",
+    "historian.pi.fallback_models",
+    "historian.pi.thinking_level",
+    "historian.omp.model",
+    "historian.omp.fallback_models",
+    "historian.omp.thinking_level",
+    "historian.two_pass",
+    "historian_timeout_ms",
+    "commit_cluster_trigger.enabled",
+    "commit_cluster_trigger.min_clusters",
+    "memory.auto_promote",
+    "dreamer.opencode.model",
+    "dreamer.opencode.fallback_models",
+    "dreamer.opencode.variant",
+    "dreamer.opencode.tasks",
+    "dreamer.pi.model",
+    "dreamer.pi.fallback_models",
+    "dreamer.pi.thinking_level",
+    "dreamer.pi.tasks",
+    "dreamer.omp.model",
+    "dreamer.omp.fallback_models",
+    "dreamer.omp.thinking_level",
+    "dreamer.omp.tasks",
+    "dreamer.tasks.map-memories.schedule",
+    "dreamer.tasks.verify.schedule",
+    "dreamer.tasks.verify-broad.schedule",
+    "dreamer.tasks.curate.schedule",
+    "dreamer.tasks.compress-cues.schedule",
+    "dreamer.tasks.classify-memories.schedule",
+    "dreamer.tasks.retrospective.schedule",
+    "dreamer.tasks.retrospective.recency_days",
+    "dreamer.tasks.maintain-docs.schedule",
+    "dreamer.tasks.evaluate-smart-notes.schedule",
+    "dreamer.tasks.review-user-memories.schedule",
+    "dreamer.tasks.review-user-memories.promotion_threshold",
+    "dreamer.tasks.promote-primers.schedule",
+    "dreamer.tasks.promote-primers.promotion_threshold",
+    "dreamer.tasks.refresh-primers.schedule",
+    "memory.git_commit_indexing.enabled",
+    "memory.git_commit_indexing.since_days",
+    "memory.git_commit_indexing.max_commits",
+] as const;
+
+// Mark the input schema nodes, not their parsed defaults, so the JSON schema,
+// runtime projection, docs and dashboard all share one policy source.
+for (const path of LIVE_RELOAD_CONFIG_PATHS) {
+    let node: z.ZodType = MagicContextConfigSchema._def.in as z.ZodType;
+    for (const part of path.split(".")) {
+        while (
+            node instanceof z.ZodOptional ||
+            node instanceof z.ZodDefault ||
+            node instanceof z.ZodNullable
+        ) {
+            node = node.unwrap() as z.ZodType;
+        }
+        if (!(node instanceof z.ZodObject) || !(part in node.shape)) {
+            throw new Error(`Unknown live config path: ${path}`);
+        }
+        node = node.shape[part] as z.ZodType;
+    }
+    z.globalRegistry.add(node, { ...node.meta(), "x-mc-live-reload": true });
+}
+
 /**
  * Derived default protected_tokens formula:
  * clamp(round(0.05 × usableSoft), min(16000, round(0.08 × usableSoft)), 64000)

package/src/features/magic-context/dreamer/task-registry.ts

@@ -29,25 +29,102 @@ export const CANONICAL_DREAM_TASKS = [
 
 export type DreamTaskName = (typeof CANONICAL_DREAM_TASKS)[number];
 
-export const DREAM_TASK_CAPABILITIES: Record<DreamTaskName, { requiresTools: boolean }> = {
+/**
+ * How a Dreamer task reaches its result, which is what decides whether a host
+ * without a tool loop can run it:
+ *  - "tool-loop": the task drives an agent that must call tools between model
+ *    turns (reading files, searching, writing memories through `ctx_memory`).
+ *  - "single-shot": one or more no-tool completions whose entire answer is the
+ *    returned text. Any transport that can deliver a prompt and return text runs
+ *    these, including a hidden completion carrier.
+ *  - "host-only": no model call at all. The task is database work done in this
+ *    process, so it needs no completion transport whatsoever.
+ */
+export type DreamTaskTransport = "tool-loop" | "single-shot" | "host-only";
+
+export interface DreamTaskCapability {
+    /** True only when the task cannot finish without a tool loop. */
+    requiresTools: boolean;
+    transport: DreamTaskTransport;
+    /**
+     * What the tool loop is needed FOR, as one clause a user can read. Present
+     * only on tool-loop tasks, where it becomes the named per-task reason shown
+     * when a host refuses the task instead of a single anonymous "filtered" list.
+     */
+    toolLoopPurpose?: string;
+}
+
+export const DREAM_TASK_CAPABILITIES: Record<DreamTaskName, DreamTaskCapability> = {
     // A single manifest is not a tool-free task: mapping and verification need
     // read-only tools to inspect backing code before they can change memory state.
-    "map-memories": { requiresTools: true },
-    verify: { requiresTools: true },
-    "verify-broad": { requiresTools: true },
-    curate: { requiresTools: true },
+    "map-memories": {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs read-only file tools to locate the code each memory describes",
+    },
+    verify: {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs read-only file tools to re-check each memory against the code",
+    },
+    "verify-broad": {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs read-only file tools to re-check each memory against the code",
+    },
+    curate: {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs the ctx_memory tool to apply its merge and archive decisions",
+    },
     // mural/compress-cues.ts is a zero-tool transform; its child transport
     // still needs substitution before the generate executor can dispatch it.
-    "compress-cues": { requiresTools: false },
-    "classify-memories": { requiresTools: false },
-    retrospective: { requiresTools: true },
-    "maintain-docs": { requiresTools: true },
-    "evaluate-smart-notes": { requiresTools: true },
-    "review-user-memories": { requiresTools: true },
-    "promote-primers": { requiresTools: true },
-    "refresh-primers": { requiresTools: true },
+    "compress-cues": { requiresTools: false, transport: "single-shot" },
+    "classify-memories": { requiresTools: false, transport: "single-shot" },
+    retrospective: {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs search tools to investigate the friction it finds in past sessions",
+    },
+    "maintain-docs": {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs file read and write tools to update project documentation",
+    },
+    // The evaluator is a no-tool compiler plus a no-tool confirmation prompt; the
+    // generated check runs in the local capability sandbox, never as model tools.
+    "evaluate-smart-notes": { requiresTools: false, transport: "single-shot" },
+    // The reviewer reads candidate text and answers with JSON; the host applies it.
+    "review-user-memories": { requiresTools: false, transport: "single-shot" },
+    // Promotion clusters existing candidates and writes rows. It calls no model.
+    "promote-primers": { requiresTools: false, transport: "host-only" },
+    "refresh-primers": {
+        requiresTools: true,
+        transport: "tool-loop",
+        toolLoopPurpose: "needs read-only investigation tools to answer each standing question",
+    },
 };
 
+/** Tasks a host without a tool loop cannot run, in canonical order. */
+export function toolLoopDreamTasks(): DreamTaskName[] {
+    return CANONICAL_DREAM_TASKS.filter((task) => DREAM_TASK_CAPABILITIES[task].requiresTools);
+}
+
+/**
+ * One line per refused task, naming the task, the stable code and what the tool
+ * loop is needed for. A user reading /ctx-dream or /ctx-status output should be
+ * able to tell which specific task is unavailable and why, rather than seeing a
+ * single anonymous "unsupported" list.
+ */
+export function formatUnsupportedDreamTasks(tasks: readonly DreamTaskName[], code: string): string {
+    return tasks
+        .map((task) => {
+            const purpose = DREAM_TASK_CAPABILITIES[task].toolLoopPurpose;
+            return `- ${task}: unavailable on this host (${code})${purpose ? ` — ${purpose}` : ""}`;
+        })
+        .join("\n");
+}
+
 /** Cheap, read-only work counts for one Dreamer task. */
 export interface DreamTaskBacklog {
     /** Items selected by the task's current backlog predicate. */
@@ -78,6 +155,53 @@ export function formatDreamTaskBacklogs(
         .join("\n");
 }
 
+/** One dreamer task whose last scheduled run failed. */
+export interface DreamTaskFailureState {
+    task: string;
+    /** The scheduler's recorded failure text. */
+    error: string;
+    /** Epoch ms of the last run that SUCCEEDED, or null if none ever has. A failed run
+     *  never advances `last_run_at`, so this says how long the task has been stuck, not
+     *  when it last failed — the scheduler keeps no failure timestamp. */
+    lastSucceededAt: number | null;
+    /** Consecutive retries queued so far; reset once the retry cap pushes the task to
+     *  its next cron slot, so a long-running failure oscillates rather than climbs. */
+    retryCount: number;
+}
+
+/** How much of a scheduler failure message a status line carries before eliding. */
+const FAILURE_TEXT_BUDGET = 180;
+
+function sinceLabel(lastSucceededAt: number | null, now: number): string {
+    if (lastSucceededAt === null || lastSucceededAt <= 0) return "never succeeded";
+    const hours = Math.max(0, Math.floor((now - lastSucceededAt) / 3_600_000));
+    if (hours < 1) return "last succeeded under an hour ago";
+    if (hours < 48) return `last succeeded ${hours}h ago`;
+    return `last succeeded ${Math.floor(hours / 24)}d ago`;
+}
+
+/**
+ * One line per failing task, shared by the status surfaces.
+ *
+ * The elapsed time is measured from the last SUCCESS, not the last failure: a failed
+ * run deliberately does not advance `last_run_at`, so that is the only timestamp the
+ * scheduler keeps and "stuck since" is what a reader needs anyway.
+ */
+export function formatDreamTaskFailures(
+    failures: readonly DreamTaskFailureState[],
+    now: number = Date.now(),
+): string {
+    return failures
+        .map((failure) => {
+            const error =
+                failure.error.length > FAILURE_TEXT_BUDGET
+                    ? `${failure.error.slice(0, FAILURE_TEXT_BUDGET)}…`
+                    : failure.error;
+            return `- ${failure.task}: failing (${sinceLabel(failure.lastSucceededAt, now)}) — ${error}`;
+        })
+        .join("\n");
+}
+
 /** Process-local progress for the task currently applying a run chunk. */
 export interface DreamTaskProgress {
     task: DreamTaskName;

package/src/shared/assistant-message-extractor.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test";
+import { hasLengthCappedOutput } from "./assistant-message-extractor";
+
+describe("hasLengthCappedOutput", () => {
+    test("detects OpenCode assistant info.finish", () => {
+        expect(hasLengthCappedOutput([{ info: { role: "assistant", finish: "length" } }])).toBe(
+            true,
+        );
+    });
+
+    test("detects OpenCode step-finish reason", () => {
+        expect(
+            hasLengthCappedOutput([{ parts: [{ type: "step-finish", reason: "length" }] }]),
+        ).toBe(true);
+        expect(hasLengthCappedOutput({ type: "text", reason: "length" })).toBe(false);
+    });
+
+    test("detects Pi stopReason length", () => {
+        expect(hasLengthCappedOutput({ role: "assistant", stopReason: "length" })).toBe(true);
+    });
+});

package/src/shared/assistant-message-extractor.ts

@@ -3,6 +3,8 @@ type MessageTime = { created?: number };
 type MessageInfo = {
     role?: string;
     time?: MessageTime;
+    error?: unknown;
+    finish?: string;
 };
 
 type MessagePart = {
@@ -15,6 +17,11 @@ type SessionMessage = {
     parts?: unknown;
 };
 
+export interface AssistantFailure {
+    error: unknown;
+    finish: string | null;
+}
+
 import { isRecord } from "./record-type-guard";
 
 function asSessionMessage(value: unknown): SessionMessage | null {
@@ -33,6 +40,15 @@ function asSessionMessage(value: unknown): SessionMessage | null {
                                     : undefined,
                         }
                       : undefined,
+                  error: info.error,
+                  finish:
+                      typeof info.finish === "string"
+                          ? info.finish
+                          : typeof info.finish_reason === "string"
+                            ? info.finish_reason
+                            : typeof info.finishReason === "string"
+                              ? info.finishReason
+                              : undefined,
               }
             : undefined,
         parts,
@@ -54,16 +70,20 @@ function getTextParts(message: SessionMessage): MessagePart[] {
         .filter((part) => part.type === "text" && Boolean(part.text));
 }
 
-export function extractLatestAssistantText(messages: unknown): string | null {
+function getLatestAssistantMessage(messages: unknown): SessionMessage | null {
     if (!Array.isArray(messages) || messages.length === 0) return null;
 
-    const assistantMessages = messages
-        .map(asSessionMessage)
-        .filter((message): message is SessionMessage => message !== null)
-        .filter((message) => message.info?.role === "assistant")
-        .sort((a, b) => getCreatedTime(b) - getCreatedTime(a));
+    return (
+        messages
+            .map(asSessionMessage)
+            .filter((message): message is SessionMessage => message !== null)
+            .filter((message) => message.info?.role === "assistant")
+            .sort((a, b) => getCreatedTime(b) - getCreatedTime(a))[0] ?? null
+    );
+}
 
-    const latest = assistantMessages[0];
+export function extractLatestAssistantText(messages: unknown): string | null {
+    const latest = getLatestAssistantMessage(messages);
     if (!latest) return null;
 
     return (
@@ -73,12 +93,27 @@ export function extractLatestAssistantText(messages: unknown): string | null {
     );
 }
 
+/** Return an error persisted on the newest assistant row, including its settlement reason. */
+export function extractLatestAssistantFailure(messages: unknown): AssistantFailure | null {
+    const latest = getLatestAssistantMessage(messages);
+    if (!latest || latest.info?.error === undefined || latest.info.error === null) return null;
+    return {
+        error: latest.info.error,
+        finish: latest.info.finish ?? null,
+    };
+}
+
 export function hasLengthCappedOutput(value: unknown): boolean {
     if (Array.isArray(value)) return value.some((item) => hasLengthCappedOutput(item));
     if (!isRecord(value)) return false;
 
     if (value.length_capped === true || value.lengthCapped === true) return true;
-    const finishReason = value.finish_reason ?? value.finishReason;
+    const finishReason =
+        value.finish_reason ??
+        value.finishReason ??
+        value.finish ??
+        (value.type === "step-finish" ? value.reason : undefined) ??
+        value.stopReason;
     if (typeof finishReason === "string") {
         const normalized = finishReason.toLowerCase();
         if (

package/src/shared/child-session-teardown.test.ts

@@ -73,7 +73,22 @@ describe("teardownChildSession", () => {
         expect(fixture.archived).toEqual([]);
     });
 
-    test("keeps a settled ordinary child but deletes a settled privacy child under keep_subagents", async () => {
+    test("deletes a settled privacy child when keep_subagents is false", async () => {
+        const fixture = teardownFixture();
+        await teardownChildSession({
+            client: fixture.client,
+            sessionId: "settled-private",
+            promptSettled: true,
+            privacySensitive: true,
+            context: "private",
+            log: (message) => fixture.messages.push(message),
+        });
+
+        expect(fixture.deleted).toEqual(["settled-private"]);
+        expect(fixture.archived).toEqual([]);
+    });
+
+    test("keeps both settled ordinary and privacy children under keep_subagents", async () => {
         setKeepSubagents(true);
         const ordinary = teardownFixture();
         await teardownChildSession({
@@ -89,13 +104,33 @@ describe("teardownChildSession", () => {
         const privacy = teardownFixture();
         await teardownChildSession({
             client: privacy.client,
-            sessionId: "deleted-private",
+            sessionId: "kept-private",
             promptSettled: true,
             privacySensitive: true,
             context: "private",
             log: (message) => privacy.messages.push(message),
         });
-        expect(privacy.deleted).toEqual(["deleted-private"]);
+        expect(privacy.deleted).toEqual([]);
+    });
+
+    test("leaves an unsettled privacy child to the sweep regardless of keep_subagents", async () => {
+        for (const keepSubagents of [false, true]) {
+            setKeepSubagents(keepSubagents);
+            const fixture = teardownFixture();
+            const sessionId = `unsettled-private-${keepSubagents}`;
+            await teardownChildSession({
+                client: fixture.client,
+                sessionId,
+                sessionDirectory: "/repo",
+                promptSettled: false,
+                privacySensitive: true,
+                context: "private",
+                log: (message) => fixture.messages.push(message),
+            });
+
+            expect(fixture.deleted).toEqual([]);
+            expect(fixture.archived).toEqual([sessionId]);
+        }
     });
 
     test("archives an unsettled child before logging, leaves it intact, then the age gate reaps it", async () => {

package/src/shared/child-session-teardown.ts

@@ -35,8 +35,7 @@ export interface TeardownChildSessionArgs {
  * endpoint, although its generated TypeScript body type does not yet expose time.
  */
 export async function teardownChildSession(args: TeardownChildSessionArgs): Promise<void> {
-    const { client, sessionId, sessionDirectory, promptSettled, privacySensitive, context, log } =
-        args;
+    const { client, sessionId, sessionDirectory, promptSettled, context, log } = args;
     if (!sessionId) return;
 
     const request: ChildSessionRequest = {
@@ -44,7 +43,8 @@ export async function teardownChildSession(args: TeardownChildSessionArgs): Prom
         ...(sessionDirectory ? { query: { directory: sessionDirectory } } : {}),
     };
 
-    if (promptSettled && (privacySensitive || !shouldKeepSubagents())) {
+    // Retention keeps every settled child; only unsettled children go to the age-gated sweep.
+    if (promptSettled && !shouldKeepSubagents()) {
         await client.session.delete(request).catch((error: unknown) => {
             log(`${context}: session cleanup failed: ${String(error)}`);
         });