@selesai/code 0.13.9 → 0.13.11

package/dist/modes/rpc/rpc-mode.js

@@ -12,19 +12,23 @@
  */
 import * as crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
-import { chmodSync, copyFileSync, existsSync, unlinkSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { generateHandoff } from "../../core/handoff.js";
 import { buildGitCommandPrompt } from "../../core/git-command.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
+import { SessionManager } from "../../core/session-manager.js";
+import { resolveModelScope } from "../../core/model-resolver.js";
+import { refreshModelCatalogs } from "../interactive/model-catalog-refresh.js";
 import { flushRawStdout, takeOverStdout, waitForRawStdoutBackpressure, writeRawStdout, } from "../../core/output-guard.js";
 import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../../core/trust-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { createSyntheticSourceInfo } from "../../core/source-info.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
-import { VERSION, getAgentDir, getBundledDefaultsDir, getShareViewerUrl } from "../../config.js";
+import { parseFrontmatter } from "../../utils/frontmatter.js";
+import { VERSION, CONFIG_DIR_NAME, getAgentDir, getBundledDefaultsDir, getShareViewerUrl } from "../../config.js";
 import { openBrowser } from "../../utils/open-browser.js";
 import { theme } from "../interactive/theme/theme.js";
 import { getAvailableThemesWithPaths, setRegisteredThemes } from "../interactive/theme/theme.js";
@@ -89,6 +93,8 @@ export async function runRpcMode(runtimeHost) {
     };
     // Pending extension UI requests waiting for response
     const pendingExtensionRequests = new Map();
+    // Prompts buffered while compacting (queueWhileCompacting) — flushed after compaction_end.
+    const compactionPromptQueue = [];
     // Shutdown request flag
     let shutdownRequested = false;
     let shuttingDown = false;
@@ -159,14 +165,34 @@ export async function runRpcMode(runtimeHost) {
                 statusText: text,
             });
         },
-        setWorkingMessage(_message) {
-            // Working message not supported in RPC mode - requires TUI loader access
+        setWorkingMessage(message) {
+            // Fire and forget - host renders the working loader row
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "working",
+                ...(message !== undefined ? { message } : {}),
+            });
         },
-        setWorkingVisible(_visible) {
-            // Working visibility not supported in RPC mode - requires TUI loader access
+        setWorkingVisible(visible) {
+            // Fire and forget - host shows/hides the working loader row
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "working",
+                visible,
+            });
         },
-        setWorkingIndicator(_options) {
-            // Working indicator customization not supported in RPC mode - requires TUI loader access
+        setWorkingIndicator(options) {
+            // Fire and forget - host customizes the working indicator. Custom frames only
+            // affect the normal streaming loader; compaction/retry keep built-in styling.
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "working",
+                ...(options?.frames !== undefined ? { frames: options.frames } : {}),
+                ...(options?.intervalMs !== undefined ? { intervalMs: options.intervalMs } : {}),
+            });
         },
         setHiddenThinkingLabel(_label) {
             // Hidden thinking label not supported in RPC mode - requires TUI message rendering access
@@ -318,6 +344,30 @@ export async function runRpcMode(runtimeHost) {
             if (event.type === "agent_settled") {
                 void checkShutdownRequested();
             }
+            if (event.type === "compaction_end" && compactionPromptQueue.length > 0) {
+                // TUI flushCompactionQueue parity: replay buffered prompts after compaction finishes.
+                // Completed compaction replays in-order (extension commands via prompt, rest by
+                // their original streaming behavior); aborted compaction discards the buffer.
+                if (event.aborted || event.errorMessage) {
+                    compactionPromptQueue.length = 0;
+                    return;
+                }
+                const queued = compactionPromptQueue.splice(0);
+                void (async () => {
+                    for (const item of queued) {
+                        try {
+                            await session.prompt(item.message, {
+                                images: item.images,
+                                streamingBehavior: item.streamingBehavior,
+                                source: "rpc",
+                            });
+                        }
+                        catch {
+                            // Replay failures surface through agent error handling; do not kill the stream.
+                        }
+                    }
+                })();
+            }
         });
         unsubscribeBackpressure = session.agent.subscribe(async () => {
             await waitForRawStdoutBackpressure();
@@ -350,6 +400,21 @@ export async function runRpcMode(runtimeHost) {
                 // Start prompt handling immediately, but emit the authoritative response only after
                 // prompt preflight succeeds. Queued and immediately handled prompts also count as success.
                 let preflightSucceeded = false;
+                // During compaction: either buffer and auto-send after compaction_end (TUI parity),
+                // or fail fast with a clear error when the caller did not opt in.
+                if (session.isCompacting) {
+                    if (!command.queueWhileCompacting) {
+                        return error(id, "prompt", "Agent is compacting; set queueWhileCompacting:true to buffer this prompt and send it after compaction, or wait for compaction_end.");
+                    }
+                    const queued = {
+                        message: command.message,
+                        images: command.images,
+                        streamingBehavior: command.streamingBehavior,
+                    };
+                    output(success(id, "prompt")); // accepted into the buffer
+                    compactionPromptQueue.push(queued);
+                    return undefined;
+                }
                 void session
                     .prompt(command.message, {
                     images: command.images,
@@ -378,6 +443,10 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "follow_up");
             }
             case "abort": {
+                // TUI Esc parity: cancel in-flight branch summarization and compaction as well,
+                // not just the active agent turn (session.abort() alone covers retry + agent).
+                session.abortBranchSummary();
+                session.abortCompaction();
                 await session.abort();
                 return success(id, "abort");
             }
@@ -468,13 +537,22 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "set_model", model);
             }
             case "cycle_model": {
-                const result = await session.cycleModel();
+                const result = await session.cycleModel(command.direction ?? "forward");
                 if (!result) {
                     return success(id, "cycle_model", null);
                 }
                 return success(id, "cycle_model", result);
             }
             case "get_available_models": {
+                if (command.refresh) {
+                    // TUI parity: refresh model catalogs before listing (shared coordinator).
+                    try {
+                        await refreshModelCatalogs(session.modelRuntime, AbortSignal.timeout(15_000));
+                    }
+                    catch {
+                        // Fall back to the current snapshot if the network refresh fails.
+                    }
+                }
                 const models = await session.modelRuntime.getAvailable();
                 return success(id, "get_available_models", { models });
             }
@@ -580,7 +658,7 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "get_session_stats", stats);
             }
             case "export_html": {
-                const path = await session.exportToHtml(command.outputPath);
+                const path = await session.exportToHtml(command.outputPath, { themeName: command.themeName });
                 return success(id, "export_html", { path });
             }
             case "switch_session": {
@@ -644,6 +722,145 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "set_session_name");
             }
             // =================================================================
+            // Tree navigation
+            // =================================================================
+            case "navigate_tree": {
+                if (session.isStreaming) {
+                    return error(id, "navigate_tree", "Wait for the current response to finish before navigating the session tree.");
+                }
+                try {
+                    const result = await session.navigateTree(command.targetId, {
+                        summarize: command.summarize,
+                        customInstructions: command.customInstructions,
+                        replaceInstructions: command.replaceInstructions,
+                        label: command.label,
+                    });
+                    return success(id, "navigate_tree", {
+                        editorText: result.editorText,
+                        cancelled: result.cancelled,
+                        aborted: result.aborted,
+                        summaryEntry: result.summaryEntry ?? null,
+                    });
+                }
+                catch (navigationError) {
+                    return error(id, "navigate_tree", navigationError instanceof Error ? navigationError.message : String(navigationError));
+                }
+            }
+            // =================================================================
+            // Session discovery / management
+            // =================================================================
+            case "list_sessions": {
+                try {
+                    const sessionManager = session.sessionManager;
+                    const isAll = command.scope === "all";
+                    const source = isAll
+                        ? sessionManager.usesDefaultSessionDir()
+                            ? await SessionManager.listAll()
+                            : await SessionManager.listAll(sessionManager.getSessionDir())
+                        : await SessionManager.list(sessionManager.getCwd(), sessionManager.getSessionDir());
+                    const sessions = source.map((info) => ({
+                        path: info.path,
+                        id: info.id,
+                        cwd: info.cwd,
+                        name: info.name,
+                        parentSessionPath: info.parentSessionPath,
+                        created: Number.isNaN(info.created.getTime()) ? new Date(0).toISOString() : info.created.toISOString(),
+                        modified: Number.isNaN(info.modified.getTime()) ? new Date(0).toISOString() : info.modified.toISOString(),
+                        messageCount: info.messageCount,
+                        firstMessage: info.firstMessage,
+                    }));
+                    return success(id, "list_sessions", { sessions });
+                }
+                catch (listError) {
+                    return error(id, "list_sessions", listError instanceof Error ? listError.message : String(listError));
+                }
+            }
+            case "rename_session": {
+                const name = command.name.trim();
+                if (!name) {
+                    return error(id, "rename_session", "Session name cannot be empty");
+                }
+                if (!existsSync(command.path)) {
+                    return error(id, "rename_session", `Session file not found: ${command.path}`);
+                }
+                try {
+                    const target = SessionManager.open(command.path);
+                    target.appendSessionInfo(name);
+                    return success(id, "rename_session", { path: command.path, name });
+                }
+                catch (renameError) {
+                    return error(id, "rename_session", renameError instanceof Error ? renameError.message : String(renameError));
+                }
+            }
+            case "delete_session": {
+                if (command.path === session.sessionFile) {
+                    return error(id, "delete_session", "Cannot delete the currently active session.");
+                }
+                if (!existsSync(command.path)) {
+                    return error(id, "delete_session", `Session file not found: ${command.path}`);
+                }
+                try {
+                    // trash-CLI-first with unlink fallback (identical to the TUI session selector).
+                    const trashArgs = command.path.startsWith("-") ? ["--", command.path] : [command.path];
+                    const trashResult = spawnSync("trash", trashArgs, { encoding: "utf-8" });
+                    if (trashResult.status === 0 || !existsSync(command.path)) {
+                        return success(id, "delete_session", { path: command.path, method: "trash" });
+                    }
+                    unlinkSync(command.path);
+                    return success(id, "delete_session", { path: command.path, method: "unlink" });
+                }
+                catch (deleteError) {
+                    return error(id, "delete_session", deleteError instanceof Error ? deleteError.message : String(deleteError));
+                }
+            }
+            // =================================================================
+            // Session-only scoped models (ephemeral, not persisted)
+            // =================================================================
+            case "set_session_models": {
+                try {
+                    if (command.reorder !== undefined && command.reorder.length > 0) {
+                        // Reorder-only path: rebuild scope from the reordered pattern list.
+                        const scoped = await resolveModelScope(command.reorder, session.modelRuntime);
+                        session.setScopedModels(scoped.map((sm) => ({ model: sm.model, thinkingLevel: sm.thinkingLevel })));
+                        return success(id, "set_session_models", {
+                            enabled: scoped.map((sm) => `${sm.model.provider}/${sm.model.id}`),
+                            models: scoped.map((sm) => sm.model),
+                        });
+                    }
+                    if (command.enabled === undefined) {
+                        return error(id, "set_session_models", "Provide either enabled or reorder.");
+                    }
+                    if (command.enabled.length === 0) {
+                        session.setScopedModels([]);
+                        return success(id, "set_session_models", { enabled: [], models: [] });
+                    }
+                    const patterns = command.enabled;
+                    const allModels = await session.modelRuntime.getAvailable();
+                    const allModelIds = new Set(allModels.map((model) => `${model.provider}/${model.id}`));
+                    const allEnabled = patterns.every((pattern) => allModelIds.has(pattern));
+                    if (allEnabled) {
+                        // Every enabled id resolves to a concrete model: build scope directly.
+                        const enabledSet = new Set(patterns);
+                        const scopedModels = allModels.filter((model) => enabledSet.has(`${model.provider}/${model.id}`));
+                        session.setScopedModels(scopedModels.map((model) => ({ model })));
+                        return success(id, "set_session_models", {
+                            enabled: scopedModels.map((model) => `${model.provider}/${model.id}`),
+                            models: scopedModels,
+                        });
+                    }
+                    // Patterns contain a scope/wildcard (e.g. "anthropic/*"): resolve against the registry.
+                    const scoped = await resolveModelScope(patterns, session.modelRuntime);
+                    session.setScopedModels(scoped.map((sm) => ({ model: sm.model, thinkingLevel: sm.thinkingLevel })));
+                    return success(id, "set_session_models", {
+                        enabled: scoped.map((sm) => `${sm.model.provider}/${sm.model.id}`),
+                        models: scoped.map((sm) => sm.model),
+                    });
+                }
+                catch (scopeError) {
+                    return error(id, "set_session_models", scopeError instanceof Error ? scopeError.message : String(scopeError));
+                }
+            }
+            // =================================================================
             // Messages
             // =================================================================
             case "get_messages": {
@@ -684,6 +901,57 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "get_commands", { commands });
             }
             // =================================================================
+            // Skills (resolved catalog + raw toggle patterns)
+            // =================================================================
+            case "get_skills": {
+                const resolvedSkills = session.resourceLoader.getResolvedSkills();
+                const agentDir = getAgentDir();
+                const cwd = session.sessionManager.getCwd();
+                const skills = [];
+                // Mirror the TUI skill-toggle resolution (buildSkillToggleItems):
+                // name/pattern from the SKILL.md parent dir, scope from resource metadata,
+                // enabled per isEnabledByOverrides via the resource loader.
+                for (const resource of resolvedSkills) {
+                    const pathStr = resource.path;
+                    const isSkillFile = basename(pathStr) === "SKILL.md";
+                    const name = isSkillFile ? basename(dirname(pathStr)) : basename(pathStr);
+                    const scope = resource.metadata.scope === "project" ? "project" : "user";
+                    const baseDir = resource.metadata.baseDir ??
+                        (scope === "project" ? join(cwd, CONFIG_DIR_NAME) : agentDir);
+                    const pattern = relative(baseDir, pathStr) || name;
+                    let frontmatterName;
+                    let description;
+                    try {
+                        const raw = readFileSync(pathStr, "utf-8");
+                        const { frontmatter } = parseFrontmatter(raw);
+                        if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
+                            frontmatterName = frontmatter.name.trim();
+                        }
+                        if (typeof frontmatter.description === "string" && frontmatter.description.trim()) {
+                            description = frontmatter.description.trim();
+                        }
+                    }
+                    catch {
+                        // Unreadable skill file: keep path-derived name, no description.
+                    }
+                    skills.push({
+                        name: frontmatterName ?? name,
+                        description,
+                        scope: scope === "project" ? "project" : "global",
+                        pattern,
+                        enabled: resource.enabled,
+                    });
+                }
+                skills.sort((a, b) => a.name.localeCompare(b.name));
+                // Raw global+project merged settings.skills patterns so the caller can
+                // round-trip the exact write shape via set_settings + reload.
+                const patterns = [
+                    ...(session.settingsManager.getGlobalSettings().skills ?? []),
+                    ...(session.settingsManager.getProjectSettings().skills ?? []),
+                ];
+                return success(id, "get_skills", { skills, patterns });
+            }
+            // =================================================================
             // Settings
             // =================================================================
             case "get_settings": {
@@ -1079,7 +1347,7 @@ export async function runRpcMode(runtimeHost) {
                         return error(id, "share_gist", "GitHub CLI is not logged in. Run 'gh auth login' first.");
                     }
                     const tmpFile = join(tmpdir(), `selesai-session-${crypto.randomUUID()}.html`);
-                    await session.exportToHtml(tmpFile);
+                    await session.exportToHtml(tmpFile, { themeName: command.themeName });
                     const result = spawnSync("gh", ["gist", "create", "--public=false", tmpFile], { encoding: "utf-8" });
                     try {
                         unlinkSync(tmpFile);

package/dist/modes/rpc/rpc-types.d.ts

@@ -11,7 +11,7 @@ import type { KeybindingsConfig } from "../../core/keybindings.ts";
 import type { Settings, SettingsScope } from "../../core/settings-manager.ts";
 import type { BashResult } from "../../core/bash-executor.ts";
 import type { CompactionResult } from "../../core/compaction/index.ts";
-import type { SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
+import type { BranchSummaryEntry, SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
 import type { SourceInfo } from "../../core/source-info.ts";
 import type { ChangelogEntry } from "../../utils/changelog.ts";
 export type RpcCommand = {
@@ -20,6 +20,8 @@ export type RpcCommand = {
     message: string;
     images?: ImageContent[];
     streamingBehavior?: "steer" | "followUp";
+    /** Buffer the prompt during compaction and auto-send it after compaction_end (mirrors TUI compaction queue). */
+    queueWhileCompacting?: boolean;
 } | {
     id?: string;
     type: "steer";
@@ -55,9 +57,11 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "cycle_model";
+    direction?: "forward" | "backward";
 } | {
     id?: string;
     type: "get_available_models";
+    refresh?: boolean;
 } | {
     id?: string;
     type: "set_thinking_level";
@@ -119,6 +123,7 @@ export type RpcCommand = {
     id?: string;
     type: "export_html";
     outputPath?: string;
+    themeName?: string;
 } | {
     id?: string;
     type: "switch_session";
@@ -187,6 +192,32 @@ export type RpcCommand = {
     id?: string;
     type: "import_jsonl";
     path: string;
+} | {
+    id?: string;
+    type: "navigate_tree";
+    targetId: string;
+    summarize?: boolean;
+    customInstructions?: string;
+    replaceInstructions?: boolean;
+    label?: string;
+} | {
+    id?: string;
+    type: "list_sessions";
+    scope?: "current" | "all";
+} | {
+    id?: string;
+    type: "rename_session";
+    path: string;
+    name: string;
+} | {
+    id?: string;
+    type: "delete_session";
+    path: string;
+} | {
+    id?: string;
+    type: "set_session_models";
+    enabled?: string[];
+    reorder?: string[];
 } | {
     id?: string;
     type: "git";
@@ -219,12 +250,16 @@ export type RpcCommand = {
     id?: string;
     type: "share_gist";
     public?: boolean;
+    themeName?: string;
 } | {
     id?: string;
     type: "get_messages";
 } | {
     id?: string;
     type: "get_commands";
+} | {
+    id?: string;
+    type: "get_skills";
 };
 /** A command available for invocation via prompt */
 export interface RpcSlashCommand {
@@ -239,6 +274,31 @@ export interface RpcSlashCommand {
     /** True for interactive-TUI-only builtins that cannot be invoked via prompt */
     interactiveOnly?: boolean;
 }
+/** A resolved skill in the get_skills catalog (mirrors the TUI skill-toggle resolution). */
+export interface RpcSkillInfo {
+    /** Skill name (frontmatter name, falling back to the SKILL.md parent directory name). */
+    name: string;
+    /** Skill description from frontmatter. */
+    description?: string;
+    /** "global" for user-level skills, "project" for project-level skills. */
+    scope: "global" | "project";
+    /** Toggle pattern relative to the skill base dir (same shape the TUI writes to settings.skills). */
+    pattern: string;
+    /** Resolved enabled state per isEnabledByOverrides semantics. */
+    enabled: boolean;
+}
+/** Session listing entry (SessionInfo with transcript text stripped). */
+export interface RpcSessionInfo {
+    path: string;
+    id: string;
+    cwd: string;
+    name?: string;
+    parentSessionPath?: string;
+    created: string;
+    modified: string;
+    messageCount: number;
+    firstMessage: string;
+}
 export interface RpcSessionState {
     model?: Model<any>;
     thinkingLevel: ThinkingLevel;
@@ -511,6 +571,15 @@ export type RpcResponse = {
     data: {
         commands: RpcSlashCommand[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_skills";
+    success: true;
+    data: {
+        skills: RpcSkillInfo[];
+        patterns: string[];
+    };
 } | {
     id?: string;
     type: "response";
@@ -601,6 +670,52 @@ export type RpcResponse = {
     data: {
         sessionPath: string;
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "navigate_tree";
+    success: true;
+    data: {
+        editorText?: string;
+        cancelled: boolean;
+        aborted?: boolean;
+        summaryEntry?: BranchSummaryEntry | null;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "list_sessions";
+    success: true;
+    data: {
+        sessions: RpcSessionInfo[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "rename_session";
+    success: true;
+    data: {
+        path: string;
+        name: string;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "delete_session";
+    success: true;
+    data: {
+        path: string;
+        method: "trash" | "unlink";
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_session_models";
+    success: true;
+    data: {
+        enabled: string[];
+        models: Model<any>[];
+    };
 } | {
     id?: string;
     type: "response";
@@ -753,6 +868,18 @@ export type RpcExtensionUIRequest = {
     id: string;
     method: "set_editor_text";
     text: string;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "working";
+    /** Working/loading message shown during streaming. Omit to restore the default. */
+    message?: string;
+    /** Show or hide the built-in working loader row during streaming. */
+    visible?: boolean;
+    /** Custom animation frames for the normal streaming loader. Empty array hides the indicator; omit to restore the default spinner. */
+    frames?: string[];
+    /** Frame interval in milliseconds for animated indicators. */
+    intervalMs?: number;
 };
 /** Response to an extension UI request */
 export type RpcExtensionUIResponse = {

package/dist/skills/improve-codebase/SKILL.md

@@ -29,7 +29,7 @@ Your goal:
 
 ### 1. Explore the context
 
-Call the subagent tool with `{ agent: "explorer", task: "..." }` (do not pass a model) when possible.
+Call the subagent tool with `{ agent: "scout", task: "..." }` (do not pass a model) when possible.
 
 If the context is partial:
 - Infer surrounding architecture cautiously

package/dist/skills/planger/SKILL.md

@@ -52,7 +52,7 @@ Choose the lowest-complexity solution that works.
 
 ## Reuse Before Build
 
-Before creating anything new (use explorer agent):
+Before creating anything new (use scout agent):
 
 - Search for existing implementations
 - Search for existing utilities

package/dist/skills/workflow/SKILL.md

@@ -22,12 +22,11 @@ Read `../pi-subagents/SKILL.md` and its references to pick builtin/custom agents
 
 | Subtask | Agent |
 | --- | --- |
-| Codebase recon / find seams | `scout` or `explorer` |
+| Codebase recon / find seams | `scout` |
 | External/uncertain research | `researcher` |
-| Implementation planning | `architect` |
-| Scoped implementation | `worker` or `builder` |
-| Independent review | `reviewer` or `commentator` |
-| Parent-synthesized fixes | `worker` |
+| Scoped implementation | `worker` or `delegate` |
+| Independent review | `reviewer` |
+| Material architecture/product tradeoffs | `oracle` or Council Mode |
 
 For material architecture/product tradeoffs, resolve them first with an `oracle` or Council Mode before implementation.
 
@@ -52,21 +51,16 @@ const scout = await runs.run("scout", {
   agent: "scout",
   task: "Find the code seams, existing helpers, and constraints involved. Do not edit."
 });
-const plan = await runs.run("plan", {
-  agent: "architect",
-  reads: [scout.outputReference],
-  task: "Plan the change from the scout findings. Return files, order, checks, non-goals."
-});
 const worker = await runs.run("implement", {
   agent: "worker",
-  reads: [plan.outputReference],
-  task: "Implement the approved plan. Return changed files, checks run, residual risks, decisions needing approval."
+  reads: [scout.outputReference],
+  task: "Implement the requested change from the scout findings. Return changed files, checks run, residual risks, decisions needing approval."
 });
 const reviews = await runs.all([
-  { key: "correctness", agent: "reviewer", reads: [plan.outputReference, worker.outputReference], task: "Inspect the current diff for correctness and regressions. Do not edit." },
-  { key: "simplicity", agent: "reviewer", reads: [plan.outputReference, worker.outputReference], task: "Inspect the current diff for unnecessary complexity. Do not edit." }
+  { key: "correctness", agent: "reviewer", reads: [scout.outputReference, worker.outputReference], task: "Inspect the current diff for correctness and regressions. Do not edit." },
+  { key: "simplicity", agent: "reviewer", reads: [scout.outputReference, worker.outputReference], task: "Inspect the current diff for unnecessary complexity. Do not edit." }
 ]);
-return { plan: plan.outputReference, worker: worker.outputReference, reviews: reviews.map((result) => result.outputReference) };
+return { worker: worker.outputReference, reviews: reviews.map((result) => result.outputReference) };
 ```
 
 ### Parallel independent subtasks