claude-overnight 1.25.49 → 1.50.1

package/dist/cli/plan-phase.js

@@ -8,9 +8,12 @@ import { RunDisplay } from "../ui/ui.js";
 import { renderSummary } from "../ui/summary.js";
 import { isCursorProxyProvider } from "../providers/index.js";
 import { readMdDir, saveRunState } from "../state/state.js";
+import { computeRepoFingerprint } from "../skills/scribe.js";
 import { selectKey, ask, showPlan, makeProgressLog, isJWTAuthError } from "./cli.js";
+import { renderPrompt } from "../prompts/load.js";
 export async function runPlanPhase(input) {
     const { objective, noTTY, flex, budget, concurrency, cwd, plannerModel, workerModel, fastModel, plannerProvider, workerProvider, fastProvider, usageCap, allowExtraUsage, extraUsageBudget, useWorktrees, mergeStrategy, agentTimeoutMs, runDir, designDir, previousKnowledge, envForModel, coachedOriginal, coachedAt, } = input;
+    const repoFingerprint = computeRepoFingerprint(cwd);
     let tasks = [];
     let thinkingHistory;
     let thinkingUsed = 0, thinkingCost = 0, thinkingIn = 0, thinkingOut = 0, thinkingTools = 0;
@@ -36,6 +39,7 @@ export async function runPlanPhase(input) {
                 phase: "planning",
                 startedAt: new Date().toISOString(),
                 cwd,
+                repoFingerprint,
             });
         }
         catch { }
@@ -96,7 +100,14 @@ export async function runPlanPhase(input) {
                         let answer = "";
                         const plannerEnv = envForModel(plannerModel);
                         for await (const msg of query({
-                            prompt: `You're planning work for: "${objective}"\n\nThemes identified:\n${themes.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n\nUser question: ${question}`,
+                            prompt: renderPrompt("60_runtime/60-3_plan-chat", {
+                                variant: "THEMES",
+                                vars: {
+                                    objective,
+                                    themesList: themes.map((t, i) => `${i + 1}. ${t}`).join("\n"),
+                                    question,
+                                },
+                            }),
                             options: { cwd, model: plannerModel, permissionMode: "bypassPermissions", allowDangerouslySkipPermissions: true, persistSession: false, ...(plannerEnv && { env: plannerEnv }) },
                         })) {
                             if (msg.type === "result" && msg.subtype === "success")
@@ -169,6 +180,7 @@ export async function runPlanPhase(input) {
                             phase: "planning",
                             startedAt: new Date().toISOString(),
                             cwd,
+                            repoFingerprint,
                             coachedObjective: coachedOriginal,
                             coachedAt,
                         });
@@ -204,7 +216,7 @@ export async function runPlanPhase(input) {
             const taskFile = join(runDir, "tasks.json");
             if (designs) {
                 const orchBudget = Math.min(50, Math.max(concurrency, Math.ceil(((budget ?? 10) - thinkingUsed) * 0.5)));
-                const flexNote = `This is wave 1 of an adaptive multi-wave run (total budget: ${(budget ?? 10) - thinkingUsed}). Plan the highest-impact foundational work first. Future waves will iterate based on what's learned.`;
+                const flexNote = renderPrompt("_shared/flex-note", { vars: { remainingBudget: (budget ?? 10) - thinkingUsed } });
                 console.log(chalk.cyan(`\n  ◆ Orchestrating plan...\n`));
                 tasks = await orchestrate(objective, designs, cwd, plannerModel, workerModel, orchBudget, concurrency, makeProgressLog(), flexNote, taskFile);
                 process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${tasks.length} tasks`)}\n\n`);
@@ -218,7 +230,7 @@ export async function runPlanPhase(input) {
         }
         else {
             const waveBudget = flex ? Math.min(50, Math.max(concurrency, Math.ceil((budget ?? 10) * 0.5))) : budget;
-            const flexNote = flex ? `This is wave 1 of an adaptive multi-wave run (total budget: ${budget}). Plan the highest-impact foundational work first. Future waves will iterate, polish, and expand based on what's learned.` : undefined;
+            const flexNote = flex ? renderPrompt("_shared/flex-note", { vars: { remainingBudget: budget ?? 10 } }) : undefined;
             console.log(chalk.cyan(`\n  ◆ Planning${flex ? " wave 1" : ""}...\n`));
             tasks = await planTasks(objective, cwd, plannerModel, workerModel, waveBudget, concurrency, makeProgressLog(), flexNote);
             process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${tasks.length} tasks`)}${flex ? chalk.dim(` · wave 1`) : ""}\n\n`);
@@ -256,7 +268,14 @@ export async function runPlanPhase(input) {
                             let answer = "";
                             const plannerEnv = envForModel(plannerModel);
                             for await (const msg of query({
-                                prompt: `You planned these tasks for the objective "${objective}":\n${tasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n")}\n\nUser question: ${question}`,
+                                prompt: renderPrompt("60_runtime/60-3_plan-chat", {
+                                    variant: "TASKS",
+                                    vars: {
+                                        objective,
+                                        tasksList: tasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n"),
+                                        question,
+                                    },
+                                }),
                                 options: { cwd, model: plannerModel, permissionMode: "bypassPermissions", allowDangerouslySkipPermissions: true, persistSession: false, ...(plannerEnv && { env: plannerEnv }) },
                             })) {
                                 if (msg.type === "result" && msg.subtype === "success")

package/dist/cli/resume.js

@@ -8,6 +8,7 @@ import { setTranscriptRunDir } from "../core/transcripts.js";
 import { wrap } from "../ui/primitives.js";
 import { makeProgressLog, selectKey } from "./cli.js";
 import { editRunSettings } from "./settings.js";
+import { renderPrompt } from "../prompts/load.js";
 export function countTasksInFile(path) {
     try {
         const parsed = JSON.parse(readFileSync(path, "utf-8"));
@@ -276,7 +277,7 @@ export async function detectResume(input) {
                     else {
                         const remainingBudget = Math.max(resumeState.concurrency, resumeState.budget - resumeState.accCompleted);
                         const orchBudget = Math.min(50, Math.max(resumeState.concurrency, Math.ceil(remainingBudget * 0.5)));
-                        const flexNote = `This is wave 1 of an adaptive multi-wave run (total budget: ${remainingBudget}). Plan the highest-impact foundational work first. Future waves will iterate based on what's learned.`;
+                        const flexNote = renderPrompt("_shared/flex-note", { vars: { remainingBudget } });
                         console.log(chalk.cyan(`\n  ◆ Re-orchestrating plan from existing designs...\n`));
                         process.stdout.write("\x1B[?25l");
                         // Route transcripts into the resumed run so this call's events

package/dist/core/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.25.49";
+export declare const VERSION = "1.50.1";

package/dist/core/_version.js

@@ -1,2 +1,2 @@
 // Auto-generated by build — do not edit manually.
-export const VERSION = "1.25.49";
+export const VERSION = "1.50.1";

package/dist/core/fingerprint.d.ts

@@ -0,0 +1,2 @@
+/** SHA-256 of git remote URL (or realpath fallback), first 12 chars. */
+export declare function computeRepoFingerprint(cwd: string): string;

package/dist/core/fingerprint.js

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { execSync } from "node:child_process";
+/** SHA-256 of git remote URL (or realpath fallback), first 12 chars. */
+export function computeRepoFingerprint(cwd) {
+    try {
+        const remote = execSync("git -C " + JSON.stringify(cwd) + " config --get remote.origin.url", {
+            stdio: ["ignore", "pipe", "ignore"],
+        }).toString().trim();
+        if (remote)
+            return createHash("sha256").update(remote).digest("hex").slice(0, 12);
+    }
+    catch { }
+    try {
+        return createHash("sha256").update(realpathSync(cwd)).digest("hex").slice(0, 12);
+    }
+    catch {
+        return "000000000000";
+    }
+}

package/dist/core/stall-guard.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from "events";
+export type StallType = "thinking" | "action" | "betweenTool";
+export interface StallThresholds {
+    thinking: number;
+    action: number;
+    betweenTool: number;
+}
+/** Minimal sink — StreamSink satisfies this; planner passes an inline stub. */
+export interface StallGuardSink {
+    lastByteAt: number;
+    /** Empty string disables the transcript-bus subscription (planner mode). */
+    streamId: string;
+    finished: boolean;
+    path?: string;
+}
+export type FallbackProviderFn = (model: string | undefined) => Record<string, string> | undefined;
+export declare class StallError extends Error {
+    readonly elapsedMs: number;
+    readonly thresholdMs: number;
+    readonly activityType: StallType;
+    readonly salvagedText?: string | undefined;
+    constructor(elapsedMs: number, thresholdMs: number, activityType: StallType, salvagedText?: string | undefined);
+}
+export declare function isStallError(err: unknown): err is StallError;
+export declare class StallGuard extends EventEmitter {
+    readonly thresholds: StallThresholds;
+    private _sink;
+    private _abort;
+    private _interval?;
+    private _stopped;
+    private _unsub?;
+    private _salvagedText?;
+    private _assembledDelta;
+    private _lastActivityType;
+    constructor(sink: StallGuardSink, abortController: AbortController, thresholds?: Partial<StallThresholds>);
+    private _onEvent;
+    private _tick;
+    get salvagedText(): string | undefined;
+    stop(): void;
+}
+export declare class StallMonitor extends EventEmitter {
+    private static _instance?;
+    private _active;
+    private _peakActive;
+    private _outageActive;
+    private _fallbackProvider?;
+    static get instance(): StallMonitor;
+    static reset(): void;
+    setFallbackProvider(fn: FallbackProviderFn): void;
+    getFallbackEnv(model: string | undefined): Record<string, string> | undefined;
+    get outageActive(): boolean;
+    resetOutage(): void;
+    get activeCount(): number;
+    register(guard: StallGuard): void;
+    unregister(guard: StallGuard): void;
+    private _onStall;
+    requestRotation(guard?: StallGuard): void;
+}
+export declare function buildStallResumePrompt(salvaged: string | undefined, fallback?: string): string;
+export interface RunWithStallRotationOpts {
+    run: (isResume: boolean, prompt: string, env: Record<string, string> | undefined) => Promise<void>;
+    initialPrompt: string;
+    initialIsResume: boolean;
+    initialEnv: Record<string, string> | undefined;
+    resolveFallbackEnv: () => Record<string, string> | undefined;
+    log: (text: string) => void;
+    defaultResumePrompt?: string;
+    isAborted?: () => boolean;
+    maxRetries?: number;
+}
+export declare function runWithStallRotation(opts: RunWithStallRotationOpts): Promise<void>;

package/dist/core/stall-guard.js

@@ -0,0 +1,188 @@
+import { EventEmitter } from "events";
+import { onStreamEvent } from "./transcripts.js";
+const DEFAULT_THRESHOLDS = {
+    thinking: 30_000,
+    action: 60_000,
+    betweenTool: 45_000,
+};
+const TICK_MS = 5_000;
+const PROVIDER_WINDOW_MS = 15_000;
+/** ~300 tokens @ 4 chars/token. Below this, salvage isn't worth a resume prompt. */
+const MIN_SALVAGE_CHARS = 1200;
+export class StallError extends Error {
+    elapsedMs;
+    thresholdMs;
+    activityType;
+    salvagedText;
+    constructor(elapsedMs, thresholdMs, activityType, salvagedText) {
+        super(`StallGuard: ${activityType} stalled after ${Math.round(elapsedMs / 1000)}s (threshold ${Math.round(thresholdMs / 1000)}s)`);
+        this.elapsedMs = elapsedMs;
+        this.thresholdMs = thresholdMs;
+        this.activityType = activityType;
+        this.salvagedText = salvagedText;
+        this.name = "StallError";
+    }
+}
+export function isStallError(err) {
+    return err instanceof StallError;
+}
+function classifyType(t) {
+    if (t === "user" || t === "tool_result")
+        return "betweenTool";
+    if (t === "tool_use" || t === "tool_call")
+        return "action";
+    return "thinking";
+}
+export class StallGuard extends EventEmitter {
+    thresholds;
+    _sink;
+    _abort;
+    _interval;
+    _stopped = false;
+    _unsub;
+    _salvagedText;
+    _assembledDelta = "";
+    _lastActivityType = "thinking";
+    constructor(sink, abortController, thresholds = {}) {
+        super();
+        this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+        this._sink = sink;
+        this._abort = abortController;
+        if (sink.streamId) {
+            this._unsub = onStreamEvent(sink.streamId, (evt) => this._onEvent(evt));
+        }
+        this._interval = setInterval(() => this._tick(), TICK_MS);
+        StallMonitor.instance.register(this);
+    }
+    _onEvent(evt) {
+        this._lastActivityType = classifyType(evt.type);
+        const payload = evt.payload;
+        if (payload?.type === "assistant" && typeof payload.delta === "string") {
+            this._assembledDelta += payload.delta;
+        }
+    }
+    _tick() {
+        if (this._stopped || this._sink.finished)
+            return;
+        const kind = this._lastActivityType;
+        const threshold = this.thresholds[kind];
+        const elapsed = Date.now() - this._sink.lastByteAt;
+        if (elapsed < threshold)
+            return;
+        if (this._assembledDelta.length >= MIN_SALVAGE_CHARS)
+            this._salvagedText = this._assembledDelta;
+        const error = new StallError(elapsed, threshold, kind, this._salvagedText);
+        this.emit("stall", error);
+        this._abort.abort(error);
+        this.stop();
+    }
+    get salvagedText() { return this._salvagedText; }
+    stop() {
+        if (this._stopped)
+            return;
+        this._stopped = true;
+        if (this._interval)
+            clearInterval(this._interval);
+        this._unsub?.();
+        StallMonitor.instance.unregister(this);
+    }
+}
+export class StallMonitor extends EventEmitter {
+    static _instance;
+    _active = new Map();
+    _peakActive = 0;
+    _outageActive = false;
+    _fallbackProvider;
+    static get instance() {
+        if (!StallMonitor._instance)
+            StallMonitor._instance = new StallMonitor();
+        return StallMonitor._instance;
+    }
+    static reset() { StallMonitor._instance = undefined; }
+    setFallbackProvider(fn) { this._fallbackProvider = fn; }
+    getFallbackEnv(model) {
+        return this._fallbackProvider?.(model);
+    }
+    get outageActive() { return this._outageActive; }
+    resetOutage() { this._outageActive = false; }
+    get activeCount() { return this._active.size; }
+    register(guard) {
+        guard.on("stall", () => this._onStall(guard));
+        this._active.set(guard, 0);
+        if (this._active.size > this._peakActive)
+            this._peakActive = this._active.size;
+    }
+    unregister(guard) { this._active.delete(guard); }
+    _onStall(guard) {
+        this._active.set(guard, Date.now());
+        if (this._outageActive || this._peakActive === 0)
+            return;
+        const now = Date.now();
+        let stalled = 0;
+        for (const t of this._active.values())
+            if (t > 0 && now - t <= PROVIDER_WINDOW_MS)
+                stalled++;
+        if (stalled >= Math.ceil(this._peakActive / 2)) {
+            this._outageActive = true;
+            this.emit("provider_outage", { count: stalled, total: this._peakActive });
+            this.emit("rotate_provider", { reason: "outage", stallCount: stalled, totalGuards: this._peakActive });
+        }
+    }
+    requestRotation(guard) {
+        const stalled = guard && this._active.get(guard) ? 1 : 0;
+        this.emit("rotate_provider", { reason: "exhausted", stallCount: stalled, totalGuards: this._peakActive });
+    }
+}
+export function buildStallResumePrompt(salvaged, fallback = "Continue. Complete the task.") {
+    return salvaged
+        ? `Continue from where you left off. Here is what was already written:\n\n${salvaged.slice(0, 4000)}`
+        : fallback;
+}
+export async function runWithStallRotation(opts) {
+    let prompt = opts.initialPrompt;
+    let isResume = opts.initialIsResume;
+    let env = opts.initialEnv;
+    let attempt = 0;
+    const maxRetries = opts.maxRetries ?? 2;
+    const monitor = StallMonitor.instance;
+    while (true) {
+        try {
+            await opts.run(isResume, prompt, env);
+            return;
+        }
+        catch (err) {
+            if (!isStallError(err) || opts.isAborted?.())
+                throw err;
+            const stall = err;
+            const elapsedS = Math.round(stall.elapsedMs / 1000);
+            if (monitor.outageActive) {
+                env = opts.resolveFallbackEnv();
+                opts.log(`Provider outage — rotating to fallback (stall at ${elapsedS}s)`);
+                prompt = buildStallResumePrompt(stall.salvagedText, opts.defaultResumePrompt);
+                isResume = true;
+                continue;
+            }
+            if (attempt < maxRetries) {
+                attempt++;
+                const backoffMs = Math.min(30_000, 2000 * 4 ** (attempt - 1)) * (0.5 + Math.random());
+                opts.log(`Stall at ${elapsedS}s — retry ${attempt}/${maxRetries} in ${Math.round(backoffMs / 1000)}s`);
+                await new Promise(r => setTimeout(r, backoffMs));
+                prompt = buildStallResumePrompt(stall.salvagedText, opts.defaultResumePrompt);
+                isResume = true;
+                monitor.emit("retry", { attempt, maxAttempts: maxRetries, elapsed: stall.elapsedMs });
+                continue;
+            }
+            const fallback = opts.resolveFallbackEnv();
+            if (fallback && env !== fallback) {
+                monitor.requestRotation();
+                env = fallback;
+                opts.log(`Stall retries exhausted — rotating to fallback provider`);
+                prompt = buildStallResumePrompt(stall.salvagedText, opts.defaultResumePrompt);
+                isResume = true;
+                attempt = 0;
+                continue;
+            }
+            throw err;
+        }
+    }
+}

package/dist/core/transcripts.d.ts

@@ -1,5 +1,30 @@
 export declare function setTranscriptRunDir(dir: string | undefined): void;
 export declare function getTranscriptRunDir(): string | undefined;
 export declare function transcriptPath(name: string): string | undefined;
-/** Append a single event; log to stderr once per name on failure (C5). */
 export declare function writeTranscriptEvent(name: string, event: Record<string, unknown>): void;
+export interface TranscriptEvent {
+    t: number;
+    type: string;
+    payload: Record<string, unknown>;
+    meta?: {
+        streamId?: string;
+        agentId?: number;
+    };
+}
+type StreamListener = (evt: TranscriptEvent) => void;
+export declare function onStreamEvent(streamId: string, fn: StreamListener): () => void;
+export declare class StreamSink {
+    readonly streamId: string;
+    readonly agentId?: number;
+    lastByteAt: number;
+    eventCount: number;
+    finished: boolean;
+    private _path;
+    constructor(streamId: string, agentId?: number);
+    append(msg: {
+        type: string;
+    } & Record<string, unknown>): void;
+    markFinished(): void;
+    get path(): string | undefined;
+}
+export {};

package/dist/core/transcripts.js

@@ -1,19 +1,9 @@
 import { appendFileSync, mkdirSync } from "fs";
 import { dirname, join } from "path";
 /**
- * Crash-safe NDJSON transcripts for planner/steering queries.
- *
- * Each query writes to `<runDir>/transcripts/<name>.ndjson`  -- one JSON object
- * per line, so partial writes survive crashes. Multiple invocations of the same
- * name append with a `session_start` marker separating them.
- *
- * Why NDJSON:
- *   - append-only → no read-modify-write race under parallel waves
- *   - one line per event → `tail -f` works; a killed process never leaves
- *     the file in an unparseable state
- *   - machine-readable → this assistant and future tools can `jq` through it
- *
- * Consumed by: planner-query.ts (stream_event, rate_limit_event, result, error).
+ * Crash-safe NDJSON transcripts. One JSON object per line survives partial writes.
+ * Planner/steering live at `<runDir>/transcripts/<name>.ndjson`; per-stream agent
+ * transcripts at `<runDir>/transcripts/streams/<streamId>.ndjson`.
  */
 let _runDir;
 export function setTranscriptRunDir(dir) {
@@ -25,9 +15,7 @@ export function getTranscriptRunDir() {
 export function transcriptPath(name) {
     return _runDir ? join(_runDir, "transcripts", `${name}.ndjson`) : undefined;
 }
-/** Names that already errored — guard against repeated stderr spam. */
 const _seenErrors = new Set();
-/** Append a single event; log to stderr once per name on failure (C5). */
 export function writeTranscriptEvent(name, event) {
     const path = transcriptPath(name);
     if (!path)
@@ -44,3 +32,75 @@ export function writeTranscriptEvent(name, event) {
         }
     }
 }
+// Keyed subscription: avoids O(N) fanout when many guards each filter for one stream.
+const _listeners = new Map();
+export function onStreamEvent(streamId, fn) {
+    let set = _listeners.get(streamId);
+    if (!set) {
+        set = new Set();
+        _listeners.set(streamId, set);
+    }
+    set.add(fn);
+    return () => {
+        const s = _listeners.get(streamId);
+        if (!s)
+            return;
+        s.delete(fn);
+        if (s.size === 0)
+            _listeners.delete(streamId);
+    };
+}
+function dispatchStreamEvent(streamId, evt) {
+    const set = _listeners.get(streamId);
+    if (!set)
+        return;
+    for (const fn of set) {
+        try {
+            fn(evt);
+        }
+        catch { /* listener errors must not break the sink */ }
+    }
+}
+export class StreamSink {
+    streamId;
+    agentId;
+    lastByteAt;
+    eventCount = 0;
+    finished = false;
+    _path;
+    constructor(streamId, agentId) {
+        this.streamId = streamId;
+        this.agentId = agentId;
+        this.lastByteAt = Date.now();
+        if (_runDir) {
+            this._path = join(_runDir, "transcripts", "streams", `${streamId}.ndjson`);
+            mkdirSync(dirname(this._path), { recursive: true });
+        }
+    }
+    append(msg) {
+        const evt = {
+            t: Date.now(),
+            type: msg.type,
+            payload: msg,
+            meta: { streamId: this.streamId, agentId: this.agentId },
+        };
+        this.lastByteAt = evt.t;
+        this.eventCount++;
+        if (this._path) {
+            try {
+                appendFileSync(this._path, JSON.stringify(evt) + "\n");
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`[StreamSink] append("${this.streamId}") failed: ${msg}\n`);
+            }
+        }
+        dispatchStreamEvent(this.streamId, evt);
+    }
+    markFinished() {
+        this.finished = true;
+    }
+    get path() {
+        return this._path;
+    }
+}

package/dist/core/types.d.ts

@@ -12,12 +12,27 @@ export interface Task {
     noWorktree?: boolean;
     /** SDK session ID to resume from (set when task was paused mid-turn). */
     resumeSessionId?: string;
+    /**
+     * Discriminator for the (provider, model, cwd) that produced `resumeSessionId`.
+     * The SDK keys sessions by project path locally and by account/model on the
+     * backend; if any of those differ at resume time the saved id points at a
+     * conversation neither side can find. Compared against the live key on resume;
+     * mismatch drops `resumeSessionId` before the SDK errors with
+     * "No conversation found with session ID".
+     */
+    resumeContextKey?: string;
     /** Working directory preserved from a previous run (worktree dir for paused-and-resumed tasks). */
     agentCwd?: string;
     /** The kind of work: "execute" modifies files, others are read-only/analysis. Defaults to "execute". */
     type?: string;
     /** Shell command that must exit 0 for the task to be considered done. Runs in cwd after merge. Failed postconditions trigger the same retry path as filesChanged=0. */
     postcondition?: string;
+    /** Groups sibling tasks for A/B pairing — tasks with the same groupId are considered comparable. */
+    groupId?: string;
+    /** A/B arm assignment: "treatment" includes the test skill, "control" explicitly excludes it. */
+    abArm?: "treatment" | "control";
+    /** Skill name to exclude from L0 stub for control arm agents. */
+    abExcludeSkill?: string;
 }
 /** Schema for a JSON task file that defines a batch of work for the swarm. */
 export interface TaskFile {
@@ -289,6 +304,8 @@ export interface RunState extends RunConfigBase {
     startedAt: string;
     /** Working directory for the run. */
     cwd: string;
+    /** 12-char repo fingerprint for skill storage. */
+    repoFingerprint: string;
     /** Original raw objective the user typed, before the setup coach rewrote it. Optional — only present when the coach ran and was accepted. */
     coachedObjective?: string;
     /** Unix timestamp (ms) when the coach produced the accepted rewrite. */

package/dist/planner/coach/coach.js

@@ -10,6 +10,7 @@ import { envFor, isCursorProxyProvider, ensureCursorProxyRunning, PROXY_DEFAULT_
 import { COACH_SCHEMA, validateCoachOutput } from "./schema.js";
 import { URL_REGEX, fetchUrlContent, collectRepoFacts, renderRepoFacts } from "./context.js";
 import { loadUserSettings, saveUserSettings } from "./settings.js";
+import { renderPrompt } from "../../prompts/load.js";
 export { loadUserSettings, saveUserSettings } from "./settings.js";
 export { validateCoachOutput, } from "./schema.js";
 export const COACH_MODEL = "claude-haiku-4-5";
@@ -59,7 +60,7 @@ export async function runSetupCoach(rawObjective, cwd, ctx) {
         }
     }
     const userMessage = renderRepoFacts(facts, rawObjective, ctx.providers, ctx.cliFlags, planContent);
-    const prompt = `${skill}\n\n---\n\n${userMessage}\n\nRespond with the JSON object defined in "Invocation contract" only.`;
+    const prompt = renderPrompt("00_setup/00-2_coach-wrapper", { variant: "WRAP", vars: { skill, userMessage } });
     // cursor "auto" maps to a slow thinking-class model for large prompts (182s observed).
     // composer-2-fast gives the same quality for structured JSON at ~8s.
     const CURSOR_FAST_MODEL = "composer-2-fast";
@@ -142,7 +143,9 @@ export async function runSetupCoach(rawObjective, cwd, ctx) {
         const amend = (await ask(`\n  ${chalk.cyan(">")} what would you change? `)).trim();
         if (!amend)
             return null;
-        const amendedPrompt = `${prompt}\n\n---\n\nUser amendment (apply and return a revised JSON object):\n${amend}`;
+        const amendedPrompt = renderPrompt("00_setup/00-2_coach-wrapper", {
+            variant: "AMEND", vars: { previousPrompt: prompt, amendment: amend },
+        });
         const amendTurn = createTurn("coach", "Coach (amended)", "coach-amend-0", model);
         beginTurn(amendTurn);
         try {

package/dist/planner/planner.d.ts

@@ -1,6 +1,5 @@
 import type { Task } from "../core/types.js";
 export declare function salvageFromFile(outFile: string | undefined, budget: number | undefined, onLog: (text: string, kind?: "status" | "event") => void, why: string): Task[] | null;
-export declare const DESIGN_THINKING = "\nHOW TO THINK ABOUT EVERY TASK:\n\nStart from the user's job. What is someone hiring this product to do? \"I need to send money abroad cheaply\"  -- not \"I need a currency conversion API.\" Every decision  -- what to build, how fast it needs to respond, what happens on error  -- flows from the job.\n\nThe experience IS the product. A 200ms server response is not a \"performance metric\"  -- it's the difference between an app that feels alive and one that feels broken. A loading state is not \"polish\"  -- it's the user knowing the app heard them. An error message is not \"error handling\"  -- it's the app being honest. There is no line between backend and UX. The server, the API, the database query, the render  -- they're all one experience the user either trusts or doesn't.\n\nBuild the core, verify it works, learn, iterate. Don't plan 20 features and build them all. Build the ONE thing that matters most, run it, see if it actually works from a user's chair. What you learn from seeing it run will change what you build next. Each wave should make what exists better before adding what doesn't exist yet.\n\nConsistency is what makes complex things feel simple. One design system, rigid rules, no exceptions. This is how Revolut ships a super-app with 30+ features that doesn't feel like chaos.\n";
 export declare function planTasks(objective: string, cwd: string, plannerModel: string, workerModel: string, budget: number | undefined, concurrency: number, onLog: (text: string) => void, flexNote?: string, outFile?: string, transcriptName?: string): Promise<Task[]>;
 export declare function identifyThemes(objective: string, count: number, cwd: string, model: string, onLog?: (text: string) => void, transcriptName?: string): Promise<string[]>;
 export declare function buildThinkingTasks(objective: string, themes: string[], designDir: string, plannerModel: string, previousKnowledge?: string): Task[];