@chengchenccc/oh-my-agent 0.2.0-rc.2 → 0.2.0-rc.3

package/dist/core/plans/runtime.js

@@ -0,0 +1,170 @@
+import { enterPlanMode, planIsSubstantial, planPathFor, planTitle, readPlan, writePlan, } from "./state.js";
+export class PlanRuntime {
+    workspaceRoot;
+    persist;
+    planModel;
+    #state = null;
+    #paused = false;
+    #contractSent = false;
+    #reminders = 0;
+    /** Model that was active before the planning model took over. */
+    #priorModel;
+    constructor(
+    /** Workspace root: plan paths live under it. */
+    workspaceRoot, 
+    /** Persist a mode transition (session event); `null` = mode off. */
+    persist = () => { }, 
+    /** The model to plan with; absent = do not touch the model. */
+    planModel = undefined) {
+        this.workspaceRoot = workspaceRoot;
+        this.persist = persist;
+        this.planModel = planModel;
+    }
+    get state() {
+        return this.#state;
+    }
+    get enabled() {
+        return this.#state?.enabled === true && !this.#paused;
+    }
+    get paused() {
+        return this.#paused;
+    }
+    /** The draft path, or undefined when plan mode is off. */
+    get draftPath() {
+        return this.#state?.planPath;
+    }
+    /** Model the session should be on right now: the plan model while planning,
+     *  otherwise whatever was active before (undefined = leave it alone). */
+    get activeModel() {
+        if (this.#state?.enabled === true && this.planModel)
+            return this.planModel;
+        return this.#priorModel;
+    }
+    /** The guard the file tools need while planning: the ONE writable path. */
+    get writeGuard() {
+        const path = this.draftPath;
+        return this.enabled && path !== undefined ? { planPath: path } : undefined;
+    }
+    /** The status-bar indicator: the driver owns its wording. */
+    statusLabel() {
+        const state = this.#state;
+        if (!state)
+            return undefined;
+        const draft = this.hasDraft() ? " · draft" : "";
+        return `✎ plan${this.#paused ? " paused" : ""}${draft}`;
+    }
+    /** Enter (or re-enter after a pause). A re-entry keeps the draft and does
+     *  not re-arm the contract: the model already has it in context. */
+    enter(sessionId, reentry = false) {
+        const path = planPathFor(this.workspaceRoot, sessionId);
+        this.#state = enterPlanMode(path, reentry);
+        this.#paused = false;
+        if (!reentry) {
+            this.#contractSent = false;
+            this.#reminders = 0;
+        }
+        this.persist(this.#state, false);
+        return this.#state;
+    }
+    /** Active → paused: the draft and the mode stay, no turn is driven. */
+    pause() {
+        if (!this.#state)
+            return;
+        this.#paused = true;
+        this.persist(this.#state, true);
+    }
+    /** Fully off (the draft file stays on disk for /plan-review). The prior
+     *  model is KEPT: the surface restores it immediately after leaving, so
+     *  clearing it here would strand the session on the planning model. */
+    leave() {
+        if (!this.#state && !this.#paused)
+            return;
+        this.#state = null;
+        this.#paused = false;
+        this.#contractSent = false;
+        this.#reminders = 0;
+        this.persist(null, false);
+    }
+    /** Restore from a session's journal: a session that was planning comes back
+     *  PAUSED, so a resume never silently re-enters a read-only turn. */
+    restore(restored, sessionId) {
+        if (!restored) {
+            this.#state = null;
+            this.#paused = false;
+        }
+        else {
+            this.#state = enterPlanMode(restored.planPath || planPathFor(this.workspaceRoot, sessionId), true);
+            this.#paused = true;
+        }
+        this.#contractSent = false;
+        this.#reminders = 0;
+        this.#priorModel = undefined;
+    }
+    /** Record the model the session was on when planning started (called by the
+     *  surface that performs the switch; undefined is a no-op). */
+    notePriorModel(modelId) {
+        if (modelId !== undefined)
+            this.#priorModel ??= modelId;
+    }
+    readDraft() {
+        const path = this.draftPath;
+        return path === undefined ? null : readPlan(path);
+    }
+    hasDraft() {
+        const markdown = this.readDraft();
+        return markdown !== null && planIsSubstantial(markdown);
+    }
+    draftTitle() {
+        const markdown = this.readDraft();
+        return markdown ? planTitle(markdown) : undefined;
+    }
+    /** The contract prompt, ONCE per entry (it is long, and the mode is sticky).
+     *  Null when it was already delivered. */
+    takeContractPrompt(render) {
+        if (this.#state?.enabled !== true || this.#paused || this.#contractSent)
+            return null;
+        this.#contractSent = true;
+        return render(this.#state);
+    }
+    /** A user turn resets the reminder budget: they just spoke, so the model
+     *  gets another chance to draft. */
+    onUserTurn() {
+        this.#reminders = 0;
+    }
+    /** A planning turn settled: did it produce a plan? The draft is checked
+     *  FIRST — the reminder budget answers "may we nudge again", never "is there
+     *  a plan". */
+    settleTurn() {
+        if (this.#state?.enabled !== true || this.#paused)
+            return { action: "idle" };
+        const markdown = this.readDraft();
+        if (markdown !== null && planIsSubstantial(markdown)) {
+            this.#reminders = 0;
+            const title = planTitle(markdown);
+            return title ? { action: "idle", draftTitle: title } : { action: "idle" };
+        }
+        if (this.#reminders < 1) {
+            this.#reminders += 1;
+            return { action: "remind" };
+        }
+        return { action: "stalled" };
+    }
+    /** Refinement re-arms planning on the SAME draft (the caller wraps the
+     *  feedback as the turn's input). */
+    refine(sessionId) {
+        if (!this.#state)
+            return this.enter(sessionId, true);
+        this.#paused = false;
+        this.#reminders = 0;
+        this.persist(this.#state, false);
+        return this.#state;
+    }
+    /** Save the draft elsewhere and stop planning without executing. */
+    saveCopy(destination) {
+        const markdown = this.readDraft();
+        if (markdown === null)
+            return false;
+        writePlan(destination, markdown);
+        return true;
+    }
+}

package/dist/core/plans/state.d.ts

@@ -0,0 +1,55 @@
+/** Plan mode: investigate and draft a plan WITHOUT changing the working tree,
+ *  then review it and choose how it reaches implementation.
+ *
+ *  The plan is a durable markdown file (not a transcript message): it is what
+ *  the review surface reads, what the implementation turn receives, and what a
+ *  later session can pick up. One canonical path per session keeps the
+ *  "which draft did I approve" question answerable. */
+export interface PlanModeState {
+    enabled: boolean;
+    /** Absolute path of this session's plan draft. */
+    planPath: string;
+    /** True when the mode was restored from a session (a re-entry must not
+     *  re-switch the model or re-arm anything the user already decided). */
+    reentry?: boolean;
+}
+/** What the review surface chose. The three approvals differ in CONTEXT
+ *  handling, never in the plan's contents. */
+export type PlanReviewChoice = {
+    kind: "approve";
+    context: "fresh" | "compact" | "keep";
+} | {
+    kind: "refine";
+    feedback: string;
+} | {
+    kind: "save";
+    destination: string;
+};
+/** Directory holding a workspace's plan drafts. */
+export declare function plansDir(workspaceRoot: string): string;
+/** The session's canonical draft path. One file per session, so approving
+ *  always refers to the draft the user actually reviewed. */
+export declare function planPathFor(workspaceRoot: string, sessionId: string): string;
+export declare function readPlan(path: string): string | null;
+export declare function writePlan(path: string, markdown: string): void;
+/** Newest plan draft in the workspace, for /plan-review without a session
+ *  draft (a resumed session whose draft came from another conversation). */
+export declare function newestPlan(workspaceRoot: string): string | null;
+/** First markdown heading, used as the plan's title (and the session name
+ *  when implementation starts in a fresh conversation). */
+export declare function planTitle(markdown: string): string | undefined;
+/** Whether a draft is worth reviewing: a stub the model wrote on its way out
+ *  of the turn is not a plan. */
+export declare function planIsSubstantial(markdown: string): boolean;
+/** Enter transitions for plan mode. The `/plan` toggle is stateful and its
+ *  three states live in two places on purpose: OFF is the absence of a state
+ *  object (`PlanRuntime.state === null`), while PAUSED keeps one with
+ *  `enabled: true` so the draft and its path survive. A caller that reads only
+ *  `enabled` therefore cannot tell paused from active — ask the runtime. */
+export declare function enterPlanMode(planPath: string, reentry?: boolean): PlanModeState;
+/** The first implementation turn: the approved plan travels as this turn's
+ *  input, through the HIDDEN channel (the protocol rule): the user reviewed
+ *  the plan as a document, so replaying kilobytes of it as a chat bubble
+ *  would be noise. */
+export declare function implementationTurn(planPath: string, markdown: string, contextKept: boolean): string;
+//# sourceMappingURL=state.d.ts.map

package/dist/core/plans/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/core/plans/state.ts"],"names":[],"mappings":"AAGA;;;;;;uDAMuD;AAEvD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB;4EACwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;8CAC8C;AAC9C,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;6DAC6D;AAC7D,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAG9D;AAED;4EAC4E;AAC5E,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW/D;AAED;2DAC2D;AAC3D,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM9D;AAED;iCACiC;AACjC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAK3D;AAED;;;;4EAI4E;AAC5E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,aAAa,CAI9E;AAED;;;sBAGsB;AACtB,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,OAAO,GACnB,MAAM,CAeR"}

package/dist/core/plans/state.js

@@ -0,0 +1,88 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** Directory holding a workspace's plan drafts. */
+export function plansDir(workspaceRoot) {
+    return join(workspaceRoot, ".oma", "plans");
+}
+/** The session's canonical draft path. One file per session, so approving
+ *  always refers to the draft the user actually reviewed. */
+export function planPathFor(workspaceRoot, sessionId) {
+    return join(plansDir(workspaceRoot), `${sessionId}.md`);
+}
+export function readPlan(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+export function writePlan(path, markdown) {
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, markdown, "utf-8");
+}
+/** Newest plan draft in the workspace, for /plan-review without a session
+ *  draft (a resumed session whose draft came from another conversation). */
+export function newestPlan(workspaceRoot) {
+    const dir = plansDir(workspaceRoot);
+    try {
+        const files = readdirSync(dir)
+            .filter((f) => f.endsWith(".md"))
+            .map((f) => ({ path: join(dir, f), mtime: statSync(join(dir, f)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime);
+        return files[0]?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** First markdown heading, used as the plan's title (and the session name
+ *  when implementation starts in a fresh conversation). */
+export function planTitle(markdown) {
+    for (const line of markdown.split("\n")) {
+        const m = /^#{1,3}\s+(.+?)\s*$/.exec(line);
+        if (m?.[1])
+            return m[1].replace(/[*_`]/g, "").trim().slice(0, 80);
+    }
+    return undefined;
+}
+/** Whether a draft is worth reviewing: a stub the model wrote on its way out
+ *  of the turn is not a plan. */
+export function planIsSubstantial(markdown) {
+    const body = markdown.trim();
+    if (body.length < 120)
+        return false;
+    const headings = body.split("\n").filter((l) => /^#{1,3}\s+/.test(l)).length;
+    return headings >= 2;
+}
+/** Enter transitions for plan mode. The `/plan` toggle is stateful and its
+ *  three states live in two places on purpose: OFF is the absence of a state
+ *  object (`PlanRuntime.state === null`), while PAUSED keeps one with
+ *  `enabled: true` so the draft and its path survive. A caller that reads only
+ *  `enabled` therefore cannot tell paused from active — ask the runtime. */
+export function enterPlanMode(planPath, reentry = false) {
+    const state = { enabled: true, planPath };
+    if (reentry)
+        state.reentry = true;
+    return state;
+}
+/** The first implementation turn: the approved plan travels as this turn's
+ *  input, through the HIDDEN channel (the protocol rule): the user reviewed
+ *  the plan as a document, so replaying kilobytes of it as a chat bubble
+ *  would be noise. */
+export function implementationTurn(planPath, markdown, contextKept) {
+    return [
+        "The plan below was reviewed and APPROVED. Implement it now.",
+        "",
+        `Durable copy: ${planPath}`,
+        contextKept
+            ? "The planning conversation is still in context; treat it as background, not as instructions to re-litigate."
+            : "Work from the plan document alone.",
+        "",
+        "<approved_plan>",
+        markdown.trim(),
+        "</approved_plan>",
+        "",
+        "Follow the plan's steps in order. If the repository state contradicts the plan (a file moved, an assumption is false), stop and report the contradiction instead of improvising a different approach.",
+    ].join("\n");
+}

package/dist/core/runtime/agent-loop-messages.d.ts

@@ -23,6 +23,12 @@ type BatchEntry = {
     message: Message;
     createdAt: number;
 };
+/** Attach the producing call's durable telemetry (usage, stop reason) to an
+ *  assistant message. Both assembly sites — the tool batch and the text-only
+ *  entry — call this, so the session file's usage record cannot silently
+ *  diverge between turn shapes. Never sent on the wire: converters read
+ *  text/blocks only. */
+export declare function attachTurnTelemetry(message: Message, turn: ModelTurn): void;
 /** Build the atomic assistant(tool_use) + tool_result batch for one turn. */
 export declare function buildToolBatch(turn: ModelTurn, toolResults: readonly ToolExecutionResult[], opts: {
     toolFailureReminder?: boolean;

package/dist/core/runtime/agent-loop-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop-messages.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/agent-loop-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAqBvD;;;kEAGkE;AAClE,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,GACd,KAAK,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAMnF;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,SAAS,mBAAmB,EAAE,EAC3C,IAAI,EAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,UAAU,EAAE,CAyFd;AAED,4DAA4D;AAC5D,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,EACf,cAAc,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GACpD,UAAU,CAuBZ"}
+{"version":3,"file":"agent-loop-messages.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/agent-loop-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAqBvD;;;kEAGkE;AAClE,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,GACd,KAAK,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAMnF;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;wBAIwB;AACxB,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI,CAO3E;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,SAAS,mBAAmB,EAAE,EAC3C,IAAI,EAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,UAAU,EAAE,CA+Fd;AAED,4DAA4D;AAC5D,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,EACf,cAAc,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GACpD,UAAU,CA2BZ"}

package/dist/core/runtime/agent-loop-messages.js

@@ -21,6 +21,19 @@ export function buildThinkingBlock(turn) {
     // and signature/redacted attach at the end.
     return [makeThinkingBlock(turn.thinking, turn)];
 }
+/** Attach the producing call's durable telemetry (usage, stop reason) to an
+ *  assistant message. Both assembly sites — the tool batch and the text-only
+ *  entry — call this, so the session file's usage record cannot silently
+ *  diverge between turn shapes. Never sent on the wire: converters read
+ *  text/blocks only. */
+export function attachTurnTelemetry(message, turn) {
+    if (turn.usage) {
+        message.usage = { ...turn.usage };
+    }
+    if (turn.stopReason) {
+        message.stopReason = turn.stopReason;
+    }
+}
 /** Build the atomic assistant(tool_use) + tool_result batch for one turn. */
 export function buildToolBatch(turn, toolResults, opts) {
     const collapsedThinking = makeThinkingBlock(turn.thinking, turn);
@@ -36,7 +49,12 @@ export function buildToolBatch(turn, toolResults, opts) {
         }
         orderedWithCollapsedThinking.push(b);
     }
-    if (!thinkingInserted && turn.thinking) {
+    // Gate on the BLOCK, not on the text: a redacted_thinking block carries a
+    // signature and no reasoning text at all (agent-loop-run.ts reasoning_signature),
+    // so testing turn.thinking alone dropped it — and a replayed tool_use without
+    // its redacted_thinking block is rejected by the provider (400). Same
+    // predicate buildThinkingBlock uses.
+    if (!thinkingInserted && (turn.thinking || turn.thinkingSignature)) {
         orderedWithCollapsedThinking.push(collapsedThinking);
     }
     const assistantMessage = {
@@ -57,6 +75,7 @@ export function buildToolBatch(turn, toolResults, opts) {
             })),
         ],
     };
+    attachTurnTelemetry(assistantMessage, turn);
     return [
         {
             type: "message",
@@ -110,24 +129,30 @@ export function buildToolBatch(turn, toolResults, opts) {
 }
 /** Build the assistant(text) entry for a text-only turn. */
 export function buildTextAssistantEntry(turn, thinkingBlocks) {
-    const blocks = turn.ordered.length > 0
-        ? turn.ordered.map((b) => (b.type === "thinking" ? makeThinkingBlock(b.text, turn) : b))
-        : thinkingBlocks.length > 0
-            ? thinkingBlocks
-            : undefined;
+    // Ordered stream content wins; a signature-only stream falls back to the
+    // collapsed thinking block; a bare text turn carries no blocks at all.
+    let blocks;
+    if (turn.ordered.length > 0) {
+        blocks = turn.ordered.map((b) => (b.type === "thinking" ? makeThinkingBlock(b.text, turn) : b));
+    }
+    else if (thinkingBlocks.length > 0) {
+        blocks = thinkingBlocks;
+    }
+    const message = {
+        role: "assistant",
+        text: turn.text,
+        // Preserve the interleaved thinking/text order from the stream. The
+        // single collapsed thinking block (with signature) is still emitted for
+        // replay compatibility when the stream had a signature, but the ordered
+        // list keeps the trace faithful.
+        blocks,
+    };
+    attachTurnTelemetry(message, turn);
     return {
         type: "message",
         role: "assistant",
         source: "assistant",
-        message: {
-            role: "assistant",
-            text: turn.text,
-            // Preserve the interleaved thinking/text order from the stream. The
-            // single collapsed thinking block (with signature) is still emitted for
-            // replay compatibility when the stream had a signature, but the ordered
-            // list keeps the trace faithful.
-            blocks,
-        },
+        message,
         createdAt: Date.now(),
     };
 }

package/dist/core/runtime/agent-loop-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop-run.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/agent-loop-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,UAAU,EAAE,cAAc,CAAC;IAC3B,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAeD,wBAAsB,eAAe,CACnC,GAAG,EAAE,eAAe,EACpB,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,OAAO,CAAC,SAAS,CAAC,CA4GpB;AAED,wBAAsB,YAAY,CAChC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,SAAS,eAAe,EAAE,GAChC,OAAO,CAAC,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,CAqLvF;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,EAAE,CAAC,CAoCpB;AAGD,YAAY,EAAE,MAAM,EAAE,CAAC"}
+{"version":3,"file":"agent-loop-run.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/agent-loop-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,UAAU,EAAE,cAAc,CAAC;IAC3B,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAeD,wBAAsB,eAAe,CACnC,GAAG,EAAE,eAAe,EACpB,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,OAAO,CAAC,SAAS,CAAC,CA4GpB;AAED,wBAAsB,YAAY,CAChC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,SAAS,eAAe,EAAE,GAChC,OAAO,CAAC,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,CAqLvF;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,EAAE,CAAC,CA0BpB;AAGD,YAAY,EAAE,MAAM,EAAE,CAAC"}

package/dist/core/runtime/agent-loop-run.js

@@ -1,5 +1,6 @@
 import { debugLog } from "@chengchenccc/agent-contract";
 import { matchStreamRule, safeParseJson } from "./agent-loop-utils.js";
+import { latestCompaction } from "./compaction.js";
 import { retryStream } from "./retry.js";
 /** Coalesce consecutive same-kind stream deltas into one TurnBlock.
  *  `ordered` models contiguous thinking/text SEGMENTS (the trace shape),
@@ -308,18 +309,10 @@ export async function executeTools(ctx, calls) {
 }
 export async function readBranchMessages(store, sessionId) {
     const entries = await store.readBranch(sessionId);
-    // Find latest CompactionEntry
-    let compactionSummary = null;
-    let coveredIds = null;
-    for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i]?.type === "compaction") {
-            const comp = entries[i];
-            compactionSummary = comp.summary;
-            coveredIds = new Set(comp.coversEntryIds);
-            break;
-        }
-    }
-    return entries
+    const compaction = latestCompaction(entries);
+    const compactionSummary = compaction?.summary ?? null;
+    const coveredIds = compaction?.coveredIds ?? null;
+    const retained = entries
         .filter((e) => {
         if (e.type !== "message")
             return false;
@@ -327,19 +320,17 @@ export async function readBranchMessages(store, sessionId) {
             return false;
         return true;
     })
-        .map((e) => {
-        const msg = e.message;
-        // Prepend compaction summary as a system note if entries were compacted
-        return msg;
-    })
-        .flatMap((msg, _i, _arr) => {
-        // Insert summary as first user message if compaction applied
-        if (_i === 0 && compactionSummary && coveredIds && coveredIds.size > 0) {
-            return [
-                { role: "user", text: `[Context summary: ${compactionSummary}]` },
-                msg,
-            ];
-        }
-        return [msg];
-    });
+        .map((e) => e.message);
+    // The summary is prepended whenever a compaction applied, INDEPENDENTLY of
+    // whether any message survived it: inserted inside the map it would be
+    // dropped whenever the compaction covered the whole branch, leaving the
+    // model a system prompt and nothing else. compactSession clamps the cut, so
+    // this is the second layer of the same guarantee.
+    if (compactionSummary && coveredIds && coveredIds.size > 0) {
+        return [
+            { role: "user", text: `[Context summary: ${compactionSummary}]` },
+            ...retained,
+        ];
+    }
+    return retained;
 }

package/dist/core/runtime/agent-loop-runner.d.ts

@@ -1,9 +1,7 @@
-import type { BackendInputMessage } from "@chengchenccc/agent-contract";
-import type { Message } from "@chengchenccc/message";
+import { type BackendInputMessage } from "@chengchenccc/agent-contract";
 import type { OmaLoopEvent } from "./agent-event.js";
 import { type LoopCallContext, type LoopRuntimeState, type LoopToolMapRef } from "./agent-loop-run.js";
 import type { OmaLoopResult, OmaSession, OmaSessionOptions } from "./agent-loop-types.js";
-import { type UsageAnchor } from "./context-estimate.js";
 import type { CodingLoopInput } from "./loop-input.js";
 import type { TokenEstimateCache } from "./message-cache.js";
 import type { PluginTool } from "./plugin.js";
@@ -27,25 +25,6 @@ export interface LoopRunnerContext {
     baseTools: readonly PluginTool[];
     mutable: LoopRunnerMutable;
 }
-interface LoopStepState {
-    messages: Message[];
-    forceContinues: number;
-    overflowCompacted: boolean;
-    thresholdCompacted: boolean;
-    usageAnchor: UsageAnchor | null;
-    naturalStop: boolean;
-    runError: string | undefined;
-    systemPrompt: string;
-}
-export type TurnControl = {
-    action: "break";
-} | {
-    action: "return";
-    result: OmaLoopResult;
-};
-/** Run one model-turn retry loop (prune/compact/stream/handle). Returns
- *  "break" when the turn completed, or a terminal result. */
-export declare function runModelTurnLoop(ctx: LoopRunnerContext, stepState: LoopStepState): Promise<TurnControl>;
 /**
  * runLoop: inner loop runs model turns and tool calls until the model
  * stops. Each model turn is accumulated purely (streamModelTurn) and
@@ -56,5 +35,4 @@ export declare function runModelTurnLoop(ctx: LoopRunnerContext, stepState: Loop
  * (the backend orchestrates follow-ups via branch_input_queue).
  */
 export declare function runLoop(ctx: LoopRunnerContext, codingInput: CodingLoopInput, mode: "normal" | "follow_up"): Promise<OmaLoopResult>;
-export {};
 //# sourceMappingURL=agent-loop-runner.d.ts.map

package/dist/core/runtime/agent-loop-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop-runner.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/agent-loop-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAGpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1F,OAAO,EAGL,KAAK,WAAW,EAEjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,EAAE,CAAC,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3E,KAAK,EAAE,gBAAgB,CAAC;IACxB,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,MAAM,eAAe,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,SAAS,EAAE,SAAS,UAAU,EAAE,CAAC;IACjC,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED,UAAU,aAAa;IACrB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;CACtB;AA0KD,MAAM,MAAM,WAAW,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,CAAC;AAE5F;6DAC6D;AAC7D,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,iBAAiB,EACtB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,WAAW,CAAC,CA8QtB;AAED;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,eAAe,EAC5B,IAAI,EAAE,QAAQ,GAAG,WAAW,GAC3B,OAAO,CAAC,aAAa,CAAC,CAyExB"}
+{"version":3,"file":"agent-loop-runner.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/agent-loop-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAY,MAAM,8BAA8B,CAAC;AAIlF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAGpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAQ1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IACnC,EAAE,EAAE,aAAa,CAAC;IAClB,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,EAAE,CAAC,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3E,KAAK,EAAE,gBAAgB,CAAC;IACxB,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,MAAM,eAAe,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,SAAS,EAAE,SAAS,UAAU,EAAE,CAAC;IACjC,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AA0fD;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,iBAAiB,EACtB,WAAW,EAAE,eAAe,EAC5B,IAAI,EAAE,QAAQ,GAAG,WAAW,GAC3B,OAAO,CAAC,aAAa,CAAC,CAwExB"}