@bubblebrain-ai/bubble 0.0.37 → 0.0.39

package/dist/main.js

@@ -18,6 +18,9 @@ import { createRoutableModelIndex, createRoutingSnapshotAccessor } from "./agent
 import { buildModelRoutingPrompt } from "./prompt/routing.js";
 import { SkillRegistry } from "./skills/registry.js";
 import { buildToolPromptOptions, createAllTools } from "./tools/index.js";
+import { getProcessManager } from "./tasks/manager.js";
+import { PromotionChannel } from "./tasks/promotion.js";
+import { PrintRunCollector, formatPrintJson, formatPrintJsonError } from "./print-output.js";
 import { FileStateTracker } from "./tools/file-state.js";
 import { GoalStore } from "./goal/store.js";
 import { PermissionAwareApprovalController } from "./approval/controller.js";
@@ -165,6 +168,13 @@ async function main() {
     // Shared between the goal tool (model-facing update_goal) and the
     // TUI's auto-continuation engine / status-line indicator.
     const goalStore = new GoalStore();
+    // Background tasks are TUI-only (design §2.0): print mode exits (and reaps)
+    // right after the single run, so a backgrounded command would be killed
+    // immediately after the model was told it started. Feishu/desktop hosts
+    // never reach this call site and stay off until they wire wake seams.
+    const processManager = getProcessManager();
+    const allowBackgroundTasks = !printMode;
+    const promotionChannel = new PromotionChannel();
     const tools = createAllTools(args.cwd, skillRegistry, {
         todoStore,
         planController,
@@ -174,6 +184,9 @@ async function main() {
         lspService,
         fileStateTracker,
         goalStore,
+        processManager,
+        allowBackgroundTasks,
+        promotionChannel,
         // Lazy: sessionManager is resolved after tools are created.
         checkpoints: () => sessionManager?.getCheckpoints(),
     });
@@ -222,6 +235,9 @@ async function main() {
         }
     };
     const shutdownSidecars = async () => {
+        // Signal path (design §2.2b layer 2): kill-only, no escalation wait —
+        // the process is about to exit and shutdownRuntime never runs here.
+        processManager.reapTasksSync();
         await Promise.allSettled([shutdownMcp(), shutdownExternalRuntime()]);
     };
     process.once("SIGINT", () => { void shutdownSidecars().then(() => process.exit(130)); });
@@ -433,6 +449,15 @@ async function main() {
         externalHooks: hookController,
     });
     agentRef = agent;
+    if (allowBackgroundTasks) {
+        // Reminder bridge (design §2.3a): list() is owner-filtered at call time so
+        // the reminder never leaks another session's tasks after a switch.
+        agent.backgroundTasks = {
+            list: () => processManager.listTasks(agent.getSessionID()),
+            version: () => processManager.getTaskStateVersion(),
+            outputTail: (id) => processManager.taskOutputTail(id, 2000),
+        };
+    }
     if (sessionManager) {
         sessionTitleUpdater = createSessionTitleUpdater({
             sessionManager,
@@ -486,6 +511,8 @@ async function main() {
             shutdownMcp(),
             shutdownExternalRuntime(),
             lspService.shutdown(),
+            // Graceful task reaping (design §2.2b layer 1): SIGTERM → SIGKILL.
+            processManager.shutdownTasks(),
         ]);
         for (const result of results) {
             if (result.status === "rejected") {
@@ -526,7 +553,8 @@ async function main() {
                 agent.injectModeReminder();
             }
             agent.injectDeferredToolsReminder();
-            console.log(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
+            // JSON print mode reserves stdout for the single result object.
+            (args.outputFormat === "json" ? console.error : console.log)(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
         }
     }
     try {
@@ -542,33 +570,70 @@ async function main() {
                 console.error(chalk.red("Error: No prompt provided."));
                 process.exit(1);
             }
-            let printedTurnText = false;
-            for await (const event of agent.run(prompt, args.cwd)) {
-                traceEvent("print_agent_event", summarizeAgentEventForTrace(event));
-                if (event.type === "turn_start") {
-                    printedTurnText = false;
-                }
-                else if (event.type === "provider_retry") {
-                    // The stream died mid-response and the agent re-issues the whole
-                    // request. Text already on stdout cannot be un-printed, so at least
-                    // separate the retried response and say what happened.
-                    if (printedTurnText)
-                        process.stdout.write("\n");
-                    console.error(chalk.yellow(`[Stream interrupted; retrying (${event.attempt}/${event.maxAttempts}) — the partial text above is superseded by the retried response]`));
-                }
-                else if (event.type === "text_delta") {
-                    printedTurnText = true;
-                    process.stdout.write(event.content);
+            // JSON mode (benchmark/CI adapters): stdout carries exactly ONE JSON
+            // object; streaming text and tool logs move to stderr-silence. Plain
+            // mode is byte-for-byte the previous behavior.
+            const jsonOutput = args.outputFormat === "json";
+            const collector = new PrintRunCollector();
+            const printSessionId = sessionManager
+                ? basename(sessionManager.getSessionFile())
+                : undefined;
+            try {
+                let printedTurnText = false;
+                for await (const event of agent.run(prompt, args.cwd)) {
+                    traceEvent("print_agent_event", summarizeAgentEventForTrace(event));
+                    collector.onEvent(event);
+                    if (jsonOutput) {
+                        if (event.type === "provider_retry") {
+                            console.error(chalk.yellow(`[Stream interrupted; retrying (${event.attempt}/${event.maxAttempts})]`));
+                        }
+                        continue;
+                    }
+                    if (event.type === "turn_start") {
+                        printedTurnText = false;
+                    }
+                    else if (event.type === "provider_retry") {
+                        // The stream died mid-response and the agent re-issues the whole
+                        // request. Text already on stdout cannot be un-printed, so at least
+                        // separate the retried response and say what happened.
+                        if (printedTurnText)
+                            process.stdout.write("\n");
+                        console.error(chalk.yellow(`[Stream interrupted; retrying (${event.attempt}/${event.maxAttempts}) — the partial text above is superseded by the retried response]`));
+                    }
+                    else if (event.type === "text_delta") {
+                        printedTurnText = true;
+                        process.stdout.write(event.content);
+                    }
+                    else if (event.type === "tool_start") {
+                        console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+                    }
+                    else if (event.type === "tool_end") {
+                        const color = event.result.isError ? chalk.red : chalk.dim;
+                        console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+                    }
                 }
-                else if (event.type === "tool_start") {
-                    console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+                if (jsonOutput) {
+                    process.stdout.write(formatPrintJson({
+                        summary: collector.summary(),
+                        sessionId: printSessionId,
+                    }) + "\n");
                 }
-                else if (event.type === "tool_end") {
-                    const color = event.result.isError ? chalk.red : chalk.dim;
-                    console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+                else {
+                    console.log();
                 }
             }
-            console.log();
+            catch (error) {
+                if (!jsonOutput)
+                    throw error;
+                // Structured failure: adapters distinguish agent errors from crashes
+                // by the JSON error object + non-zero exit.
+                process.stdout.write(formatPrintJsonError({
+                    message: error instanceof Error ? error.message : String(error),
+                    summary: collector.summary(),
+                    sessionId: printSessionId,
+                }) + "\n");
+                process.exitCode = 1;
+            }
             return;
         }
         const themeConfig = userConfig.getTheme();
@@ -653,6 +718,9 @@ async function main() {
             runMemoryCompaction,
             runMemorySummary,
             runMemoryRefresh,
+            processManager,
+            tasksAutoResume: userConfig.getTasksAutoResume(),
+            promotionChannel,
         };
         // Grok Subscription is a first-class interactive provider target. Manager
         // construction is deliberately lazy: it does not inspect, spawn, or reach

package/dist/orchestrator/default-hooks.js

@@ -5,8 +5,11 @@ import { ExecutionGovernor } from "../agent/execution-governor.js";
 import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
 import { buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
-import { orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
+import { largeImplementationTaskReminder, orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
+import { resolve as resolvePath } from "node:path";
+import { traceEvent } from "../debug-trace.js";
+import { builtinAgentProfiles, discoverAgentProfiles, hasWriteWorktreeProfile } from "../agent/profiles.js";
 import { buildSubagentLifecycleReminder } from "../agent/subagent-lifecycle-reminder.js";
 export function createDefaultHooks() {
     return [
@@ -33,6 +36,9 @@ export function createDefaultHooks() {
                 const orchestrationReminder = orchestrationRequestReminder(ctx.input, ctx.agent.hasToolAvailable("run_workflow"));
                 if (orchestrationReminder) {
                     ctx.queueReminder(orchestrationReminder);
+                    // The large-change checkpoint must not re-offer spawn_agent in a
+                    // turn where this reminder just forbade it (design §3).
+                    ctx.state.orchestrationReminderSent = true;
                 }
                 // User named a configured model ("gpt 5.6 sol"): resolve it against
                 // the routable catalog and hand over the exact id at the decision
@@ -53,6 +59,14 @@ export function createDefaultHooks() {
                     ctx.state.workflowPhase = "investigate";
                     ctx.state.workflowKey = "";
                 }
+                // Background-task truth at turn start: completions that landed while
+                // the agent was idle (or during another session's turn) reach the
+                // model here; the same state-change gate prevents duplicates with the
+                // beforeContinuation emission (background-tasks design §2.3a).
+                const backgroundTaskReminder = ctx.agent.consumeBackgroundTaskReminder?.();
+                if (backgroundTaskReminder) {
+                    ctx.queueReminder(backgroundTaskReminder);
+                }
                 for (const reminder of ctx.state.governor.consumePendingReminders()) {
                     ctx.queueReminder(reminder);
                 }
@@ -89,6 +103,12 @@ export function createDefaultHooks() {
                 const toolCall = { ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) };
                 ctx.replaceToolCall(toolCall);
                 ctx.state.governor?.beforeToolCall(toolCall);
+                // Large-change checkpoint (large-task-delegation design §1): the
+                // first mutation of the turn is the decision point — exploration is
+                // over, nothing has been edited yet.
+                if (isMutationTool(toolCall.name)) {
+                    maybeQueueLargeTaskNudge(ctx);
+                }
                 const blockedResult = ctx.state.discoveryBarrier?.beforeToolCall(toolCall);
                 if (blockedResult)
                     ctx.blockToolCall(blockedResult);
@@ -145,6 +165,18 @@ export function createDefaultHooks() {
                 // dedup do the work.
                 if (isCodeWriteResult(ctx.toolCall, ctx.result)) {
                     markCodeChanged(ctx.state);
+                    ctx.state.appliedEditCount = (ctx.state.appliedEditCount ?? 0) + 1;
+                }
+                // Large-task breadth evidence (design §1): only files actually READ.
+                // Search results contribute nothing — one glob returns up to 100
+                // match paths and would saturate any threshold instantly (review
+                // blocker). Bash-parsed reads (cat/head/sed -n) carry relative
+                // paths, so resolve against cwd before dedup.
+                if (!ctx.result.isError && ctx.result.metadata?.kind === "read") {
+                    const path = typeof ctx.result.metadata.path === "string" ? ctx.result.metadata.path : undefined;
+                    if (path) {
+                        (ctx.state.exploredFiles ??= new Set()).add(resolvePath(ctx.cwd, path));
+                    }
                 }
                 // Removed: active verification tracking. The previous design nagged the
                 // model every turn until it ran a recognised verification command, and
@@ -167,6 +199,14 @@ export function createDefaultHooks() {
                         ctx.queueReminder(reminder);
                     }
                 }
+                // Background-task truth: state-change gated inside the agent (a task
+                // started/finished/killed since the last emission), so a mid-turn
+                // completion reaches the model without stacking per-call duplicates
+                // (background-tasks design §2.3a).
+                const taskReminder = ctx.agent.consumeBackgroundTaskReminder?.();
+                if (taskReminder) {
+                    ctx.queueReminder(taskReminder);
+                }
                 // Routing detector note (model-routing design §6): rides the same
                 // channel as the lifecycle reminder, once per session. Consuming also
                 // closes the per-fan-out counting window.
@@ -190,6 +230,59 @@ export function createDefaultHooks() {
 function markCodeChanged(state) {
     state.codeChanged = true;
 }
+// Large-task delegation checkpoint (large-task-delegation design §1-3).
+const BREADTH_FILES = 8;
+const BREADTH_FILES_WITH_PLAN = 5;
+const BREADTH_TODOS = 6;
+function maybeQueueLargeTaskNudge(ctx) {
+    // Evaluated exactly once per turn, at the first mutation — fired or not
+    // (mid-implementation re-detection is out of scope by design §4).
+    if (ctx.state.largeTaskCheckpointDone)
+        return;
+    ctx.state.largeTaskCheckpointDone = true;
+    const agent = ctx.agent;
+    const taskType = ctx.state.taskType;
+    const exploredFiles = ctx.state.exploredFiles?.size ?? 0;
+    const pendingTodos = agent.getTodos?.()
+        ?.filter((todo) => todo.status === "pending" || todo.status === "in_progress").length ?? 0;
+    const threshold = pendingTodos >= BREADTH_TODOS ? BREADTH_FILES_WITH_PLAN : BREADTH_FILES;
+    // Gate order: cheap checks first; the profile discovery (filesystem) runs
+    // only when everything else already passed.
+    const suppressedBy = agent.largeTaskNudgeConsumed ? "session_latch"
+        : (taskType === "code_review" || taskType === "security_investigation") ? "task_type"
+            : !agent.hasToolAvailable("spawn_agent") ? "no_spawn_tool"
+                : (agent.activeSubAgentCount?.() ?? 0) > 0 ? "active_children"
+                    : agent.hasRunningWorkflow?.() ? "running_workflow"
+                        : exploredFiles < threshold ? "below_threshold"
+                            : !writeWorktreeSurfaceAvailable(ctx.cwd) ? "no_write_profile"
+                                : undefined;
+    traceEvent("delegation_detector", {
+        fired: suppressedBy === undefined,
+        exploredFiles,
+        pendingTodos,
+        threshold,
+        taskType: taskType ?? "unknown",
+        ...(suppressedBy ? { suppressedBy } : {}),
+    });
+    if (suppressedBy !== undefined)
+        return;
+    agent.largeTaskNudgeConsumed = true;
+    ctx.queueReminder(largeImplementationTaskReminder({
+        exploredFiles,
+        pendingTodos,
+        appliedEdits: ctx.state.appliedEditCount ?? 0,
+        orchestrationRequested: ctx.state.orchestrationReminderSent === true,
+    }));
+}
+function writeWorktreeSurfaceAvailable(cwd) {
+    try {
+        const discovered = discoverAgentProfiles(cwd, "both").profiles;
+        return hasWriteWorktreeProfile([...builtinAgentProfiles(), ...discovered]);
+    }
+    catch {
+        return hasWriteWorktreeProfile(builtinAgentProfiles());
+    }
+}
 function isCodeWriteResult(_toolCall, result) {
     if (result.isError || result.status === "blocked" || result.status === "cancelled" || result.status === "command_error") {
         return false;

package/dist/orchestrator/hooks.d.ts

@@ -26,6 +26,13 @@ export interface TurnHookState {
         total: number;
         spent: number;
     };
+    exploredFiles?: Set<string>;
+    /** Checkpoint evaluated at the first mutation — once per turn, fired or not. */
+    largeTaskCheckpointDone?: boolean;
+    /** Successful mutations this turn; rendered as K in the nudge wording. */
+    appliedEditCount?: number;
+    /** orchestrationRequestReminder fired: the nudge offers only run_workflow. */
+    orchestrationReminderSent?: boolean;
 }
 export interface TurnHookContext {
     agent: Agent;

package/dist/print-output.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Structured output for print mode (`-p --output-format json`).
+ *
+ * Built for benchmark/CI adapters (Pier, terminal-bench): stdout carries
+ * exactly one JSON object; all human-facing noise goes to stderr. Field
+ * names follow the grok-build/Claude Code convention (text, stopReason,
+ * sessionId, usage.{input_tokens,...}, num_turns) so existing harness
+ * adapters port with minimal changes.
+ */
+import type { AgentEvent } from "./types.js";
+export type PrintOutputFormat = "plain" | "json";
+export declare function parseOutputFormat(raw: string | undefined): PrintOutputFormat | undefined;
+export interface PrintUsageSummary {
+    input_tokens: number;
+    cache_read_input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    total_tokens: number;
+}
+export interface PrintRunSummary {
+    /** Final answer: the last turn's streamed text. */
+    text: string;
+    num_turns: number;
+    num_tool_calls: number;
+    usage: PrintUsageSummary;
+    /**
+     * False when no turn carried provider usage (some endpoints — notably the
+     * Grok subscription proxy — omit it): zeros then mean "not reported",
+     * not "free". Mirrors the goal engine's markTokenUsageUnavailable and
+     * grok-build's usage_is_incomplete convention.
+     */
+    usage_reported: boolean;
+}
+export declare class PrintRunCollector {
+    private turnText;
+    private lastTurnText;
+    private turns;
+    private toolCalls;
+    private usageReported;
+    private readonly usage;
+    onEvent(event: AgentEvent): void;
+    private addUsage;
+    summary(): PrintRunSummary;
+}
+export declare function formatPrintJson(input: {
+    summary: PrintRunSummary;
+    sessionId?: string;
+    stopReason?: "end_turn" | "error" | "cancelled";
+}): string;
+export declare function formatPrintJsonError(input: {
+    message: string;
+    summary?: PrintRunSummary;
+    sessionId?: string;
+}): string;

package/dist/print-output.js

@@ -0,0 +1,103 @@
+/**
+ * Structured output for print mode (`-p --output-format json`).
+ *
+ * Built for benchmark/CI adapters (Pier, terminal-bench): stdout carries
+ * exactly one JSON object; all human-facing noise goes to stderr. Field
+ * names follow the grok-build/Claude Code convention (text, stopReason,
+ * sessionId, usage.{input_tokens,...}, num_turns) so existing harness
+ * adapters port with minimal changes.
+ */
+export function parseOutputFormat(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (raw === "plain" || raw === "json")
+        return raw;
+    return undefined;
+}
+export class PrintRunCollector {
+    turnText = "";
+    lastTurnText = "";
+    turns = 0;
+    toolCalls = 0;
+    usageReported = false;
+    usage = {
+        input_tokens: 0,
+        cache_read_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_tokens: 0,
+        total_tokens: 0,
+    };
+    onEvent(event) {
+        switch (event.type) {
+            case "turn_start":
+                this.turns += 1;
+                this.turnText = "";
+                break;
+            case "text_delta":
+                this.turnText += event.content;
+                break;
+            case "provider_retry":
+                // The retried response supersedes the partial text.
+                this.turnText = "";
+                break;
+            case "tool_start":
+                this.toolCalls += 1;
+                break;
+            case "turn_end":
+                // Usage reaches AgentEvent only on turn_end (the stream-level
+                // "usage" chunk is aggregated into it by the agent loop).
+                if (this.turnText.trim())
+                    this.lastTurnText = this.turnText;
+                if (event.usage)
+                    this.addUsage(event.usage);
+                break;
+            default:
+                break;
+        }
+    }
+    addUsage(usage) {
+        this.usageReported = true;
+        this.usage.input_tokens += usage.promptTokens ?? 0;
+        this.usage.cache_read_input_tokens += usage.promptCacheHitTokens ?? 0;
+        this.usage.output_tokens += usage.completionTokens ?? 0;
+        this.usage.reasoning_tokens += usage.reasoningTokens ?? 0;
+        this.usage.total_tokens += usage.totalTokens
+            ?? ((usage.promptTokens ?? 0) + (usage.completionTokens ?? 0));
+    }
+    summary() {
+        return {
+            text: (this.lastTurnText || this.turnText).trim(),
+            num_turns: this.turns,
+            num_tool_calls: this.toolCalls,
+            usage: { ...this.usage },
+            usage_reported: this.usageReported,
+        };
+    }
+}
+export function formatPrintJson(input) {
+    return JSON.stringify({
+        text: input.summary.text,
+        stopReason: input.stopReason ?? "end_turn",
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        num_turns: input.summary.num_turns,
+        num_tool_calls: input.summary.num_tool_calls,
+        usage: input.summary.usage,
+        usage_reported: input.summary.usage_reported,
+    });
+}
+export function formatPrintJsonError(input) {
+    return JSON.stringify({
+        type: "error",
+        message: input.message,
+        stopReason: "error",
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        ...(input.summary
+            ? {
+                text: input.summary.text,
+                num_turns: input.summary.num_turns,
+                num_tool_calls: input.summary.num_tool_calls,
+                usage: input.summary.usage,
+            }
+            : {}),
+    });
+}

package/dist/prompt/delegation.js

@@ -51,9 +51,12 @@ earlier work lives in an existing subagent, prefer send_input to resume it
 over spawning a fresh one.
 
 Do NOT delegate when:
-- The task requires editing files or running state-changing commands.
-  Built-in subagents are read-only; do edits and writes yourself unless a
-  write-capable (write_worktree) profile is explicitly available.
+- The edits are ENTANGLED — shared state, one file feeding the next, order
+  matters. Write delegation exists (the builtin "implementer" profile runs
+  in an isolated git worktree), but it only pays off for INDEPENDENT edit
+  groups with disjoint file sets. Worktree children fork from the last
+  commit and the parent reviews/applies their changes afterward; entangled
+  work through that contract only adds merge risk — do it yourself.
 - The task takes one or two tool calls (reading a single file, looking up one
   definition). The handoff overhead costs more than the task.
 - Doing it well depends on conversation context (preferences the user stated

package/dist/prompt/task-reminders.d.ts

@@ -23,4 +23,21 @@ export declare function reminderForTaskType(taskType: TaskType, options?: TaskRe
  * this, 2026-07-12 live case). Silent on no match: zero standing noise.
  */
 export declare function userNamedModelReminder(input: string | import("../types.js").ContentPart[], routableModels: RoutableModelEntry[] | undefined, canSpawn: boolean): string | undefined;
+/**
+ * Large-change checkpoint (large-task-delegation design §3): injected once
+ * per session at the first mutation of a broad turn. Carries the routing
+ * decision criteria (independent vs entangled) and the real worktree
+ * mechanics (children fork from the last commit; disjoint file sets) —
+ * never a command. The "smallest coherent edit" clause is lifted verbatim
+ * from the implementation-workflow reminder so the two compose.
+ */
+export interface LargeTaskReminderInput {
+    exploredFiles: number;
+    pendingTodos: number;
+    /** Mutations already applied this turn (the current batch lands regardless). */
+    appliedEdits: number;
+    /** orchestrationRequestReminder fired this turn: only offer run_workflow. */
+    orchestrationRequested: boolean;
+}
+export declare function largeImplementationTaskReminder(input: LargeTaskReminderInput): string;
 export declare function orchestrationRequestReminder(input: string | import("../types.js").ContentPart[], canRunWorkflow: boolean): string | undefined;

package/dist/prompt/task-reminders.js

@@ -119,6 +119,21 @@ export function userNamedModelReminder(input, routableModels, canSpawn) {
         "Use these exact ids in spawn_agent / run_workflow `model` params; do not retype model ids from memory.",
     ].join("\n");
 }
+export function largeImplementationTaskReminder(input) {
+    const plan = input.pendingTodos > 0 ? ` (plan: ${input.pendingTodos} open todo items)` : "";
+    const applied = input.appliedEdits > 0
+        ? ` ${input.appliedEdits} edit${input.appliedEdits === 1 ? "" : "s"} from your current batch will land regardless.`
+        : "";
+    const mechanism = input.orchestrationRequested
+        ? "one run_workflow script (the user asked for a coordinated workflow — keep everything in it)"
+        : "write_worktree subagents (spawn_agent with the implementer profile) or one run_workflow script";
+    return wrapInSystemReminder(`
+Large-change checkpoint: you have read ${input.exploredFiles} files this turn${plan} and are starting to edit.${applied}
+- If the REMAINING edits form INDEPENDENT groups (per-module, per-file, same shape repeated), split them across ${mechanism}. Assign each child a DISJOINT file set; keep shared files (types, registries, exports) for yourself. Children fork from the last COMMIT — commit your applied edits first, or fold them into the child briefings. Each child still makes the smallest coherent edit for its group.
+- If the edits are ENTANGLED (shared state, one file feeding the next, order matters), delegation only adds merge risk — proceed yourself.
+- Work already small enough to finish directly: just finish it.
+`);
+}
 const ORCHESTRATION_REQUEST = /\b(?:workflows?|orchestrat\w*|agent[ -]?teams?|fan[ -]?out)\b|工作流|编排|(?:智能体|代理|agent)\s*(?:团队|小队)/i;
 export function orchestrationRequestReminder(input, canRunWorkflow) {
     if (!canRunWorkflow)

package/dist/session-types.d.ts

@@ -31,7 +31,7 @@ export interface SessionMetadata {
      */
     externalRuntime?: ExternalRuntimeSessionMetadata;
 }
-export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "runtime_switch" | "conversation_clear";
+export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "runtime_switch" | "conversation_clear" | "task_started" | "task_finished" | "task_killed";
 interface BaseSessionLogEntry {
     id: string;
     timestamp: number;