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

package/dist/core/loops/runtime.d.ts

@@ -0,0 +1,95 @@
+import { type LoopConditionConfig, type LoopConditionOptions } from "./condition.js";
+import { LOOP_USAGE, type LoopLimitRuntime } from "./limits.js";
+/** What the loop does between iterations before re-submitting the prompt:
+ *  re-send it, compact the context first, start a fresh session first, or run
+ *  the build loop (fresh session + a work queue on disk, see ralph.ts). */
+export type LoopAction = "prompt" | "compact" | "reset" | "ralph";
+export type LoopStart = {
+    ok: true;
+    prompt?: string;
+    hidden?: true;
+    /** Build loop only: the text to seed into the work queue before the
+     *  first iteration. Empty = the "write the queue" stub. The runtime
+     *  decides THAT the queue must exist; the caller, which owns the
+     *  workspace root, writes it. */
+    queueSeed?: string;
+    status: string;
+} | {
+    ok: false;
+    error: string;
+};
+export type LoopIterationDecision = {
+    action: "run";
+    prompt: string;
+    preamble?: "compact" | "reset";
+    /** The prompt is protocol, not user text: the transcript must not echo
+     *  it as a turn the user typed (`isHiddenInput` handles the wrapping). */
+    hidden?: true;
+} | {
+    action: "stop";
+    reason: string;
+} | {
+    action: "idle";
+};
+export interface LoopStatus {
+    state: "waiting" | "running" | "paused";
+    limit?: LoopLimitRuntime;
+    /** Remaining budget + continue-condition, for the status bar. */
+    label?: string;
+}
+/** Loop mode (the reference loop implementation (enabled / captured prompt / limit)).
+ *
+ *  While enabled, the next prompt the user sends is remembered and
+ *  re-submitted after every yield. The loop is NOT a scheduler: it fires only
+ *  when the session is idle and the run has settled. There is no artificial
+ *  pause between iterations — an unattended loop should not pay latency per
+ *  round — so the interrupt windows are the real ones: the live run (Esc
+ *  aborts it) and the continue-condition evaluation, whose verdict is voided
+ *  if the arming changed while it ran. It is session-scoped and deliberately
+ *  in-memory — a resumed session never re-enters a loop on its own (same rule
+ *  as goal mode). */
+export declare class LoopRuntime {
+    #private;
+    private readonly action;
+    constructor(action?: LoopAction);
+    get enabled(): boolean;
+    get paused(): boolean;
+    get prompt(): string | undefined;
+    get limit(): LoopLimitRuntime | undefined;
+    get condition(): LoopConditionConfig | undefined;
+    /** Human-readable condition, for status messages. */
+    get conditionLabel(): string | undefined;
+    /** The status-bar indicator: waiting / running / paused plus the remaining
+     *  budget and the condition. The driver owns its wording. */
+    statusLabel(): string | undefined;
+    /** What the user should call this loop. The build loop is a different way of
+     *  working (a queue and a fresh session per item), so it names itself; the
+     *  three context actions all stay "loop". One source for the name keeps the
+     *  status bar, the paused label and the caller's status prefix agreeing. */
+    get driverName(): string;
+    status(): LoopStatus | undefined;
+    /** `/loop [count|duration] [--while|--until <cmd>] [prompt]`. Already
+     *  enabled → disable (toggle), matching the reference loop. A malformed
+     *  limit is a hard error and leaves the mode alone. */
+    toggle(args: string, nowMs?: number): LoopStart;
+    /** The user's prompt becomes the loop prompt (the reference loop's
+     *  setLoopPrompt: also clears a pause — the next user prompt re-arms it).
+     *  Called on EVERY user submit, so the newest prompt wins; a loop keeps
+     *  replaying whatever the user last typed. */
+    capturePrompt(text: string): void;
+    /** Pause without exiting: drop the captured prompt, keep mode enabled (omp
+     *  pauseLoop — Esc between iterations lands here). */
+    pause(): void;
+    disable(reason?: string): string;
+    /** One settled run: may the loop re-submit?
+     *
+     *  Order matters. The condition gate runs BEFORE the budget is consumed, so
+     *  a halt never burns an iteration that did not run; the duration deadline
+     *  runs first of all, because an expired clock ends the loop regardless of
+     *  what the condition would have said. */
+    nextIteration(opts?: Omit<LoopConditionOptions, "timeoutMs"> & {
+        timeoutMs?: number;
+    }, nowMs?: number): Promise<LoopIterationDecision>;
+}
+export { LOOP_USAGE };
+//# sourceMappingURL=runtime.d.ts.map

package/dist/core/loops/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/core/loops/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAML,UAAU,EACV,KAAK,gBAAgB,EAGtB,MAAM,aAAa,CAAC;AAGrB;;2EAE2E;AAC3E,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAElE,MAAM,MAAM,SAAS,GACjB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,IAAI,CAAC;IACd;;;qCAGiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC,MAAM,MAAM,qBAAqB,GAC7B;IACE,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;IAC/B;8EAC0E;IAC1E,MAAM,CAAC,EAAE,IAAI,CAAC;CACf,GACD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvB,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;qBAUqB;AACrB,qBAAa,WAAW;;IAcV,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,GAAE,UAAqB;IAE1D,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,MAAM,IAAI,MAAM,GAAG,SAAS,CAE/B;IAED,IAAI,KAAK,IAAI,gBAAgB,GAAG,SAAS,CAExC;IAED,IAAI,SAAS,IAAI,mBAAmB,GAAG,SAAS,CAE/C;IAED,qDAAqD;IACrD,IAAI,cAAc,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED;iEAC6D;IAC7D,WAAW,IAAI,MAAM,GAAG,SAAS;IAOjC;;;gFAG4E;IAC5E,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,MAAM,IAAI,UAAU,GAAG,SAAS;IAoBhC;;2DAEuD;IACvD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAa,GAAG,SAAS;IA6CnD;;;kDAG8C;IAC9C,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAOjC;0DACsD;IACtD,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAWhC;;;;;8CAK0C;IACpC,aAAa,CACjB,IAAI,GAAE,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAEnE,EACD,KAAK,SAAa,GACjB,OAAO,CAAC,qBAAqB,CAAC;CAyClC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/core/loops/runtime.js

@@ -0,0 +1,222 @@
+import { DEFAULT_CONDITION_TIMEOUT_MS, describeLoopCondition, evaluateLoopCondition, } from "./condition.js";
+import { consumeLoopLimitIteration, createLoopLimitRuntime, describeLoopLimit, describeLoopLimitRuntime, isLoopDurationExpired, LOOP_USAGE, parseLoopArgs, } from "./limits.js";
+import { RALPH_PROTOCOL, RALPH_QUEUE, ralphCondition } from "./ralph.js";
+/** Loop mode (the reference loop implementation (enabled / captured prompt / limit)).
+ *
+ *  While enabled, the next prompt the user sends is remembered and
+ *  re-submitted after every yield. The loop is NOT a scheduler: it fires only
+ *  when the session is idle and the run has settled. There is no artificial
+ *  pause between iterations — an unattended loop should not pay latency per
+ *  round — so the interrupt windows are the real ones: the live run (Esc
+ *  aborts it) and the continue-condition evaluation, whose verdict is voided
+ *  if the arming changed while it ran. It is session-scoped and deliberately
+ *  in-memory — a resumed session never re-enters a loop on its own (same rule
+ *  as goal mode). */
+export class LoopRuntime {
+    action;
+    #enabled = false;
+    #paused = false;
+    #prompt;
+    #limit;
+    #condition;
+    /** Bumped by every transition that re-arms or disarms the loop. A condition
+     *  verdict is only valid for the arming it was computed for: the evaluation
+     *  is a window of up to two minutes during which `/loop`, Esc and the user's
+     *  next prompt can all land, and a disable-then-re-arm inside it used to look
+     *  exactly like "still armed" to the three-way check that tried to catch it
+     *  by comparing flags. */
+    #generation = 0;
+    constructor(action = "prompt") {
+        this.action = action;
+    }
+    get enabled() {
+        return this.#enabled;
+    }
+    get paused() {
+        return this.#paused;
+    }
+    get prompt() {
+        return this.#prompt;
+    }
+    get limit() {
+        return this.#limit;
+    }
+    get condition() {
+        return this.#condition;
+    }
+    /** Human-readable condition, for status messages. */
+    get conditionLabel() {
+        return this.#condition ? describeLoopCondition(this.#condition) : undefined;
+    }
+    /** The status-bar indicator: waiting / running / paused plus the remaining
+     *  budget and the condition. The driver owns its wording. */
+    statusLabel() {
+        const status = this.status();
+        if (!status)
+            return undefined;
+        if (status.state === "paused")
+            return `⏸ ${this.driverName} paused`;
+        return `↻ ${this.driverName}${status.label ? ` ${status.label}` : ""}`;
+    }
+    /** What the user should call this loop. The build loop is a different way of
+     *  working (a queue and a fresh session per item), so it names itself; the
+     *  three context actions all stay "loop". One source for the name keeps the
+     *  status bar, the paused label and the caller's status prefix agreeing. */
+    get driverName() {
+        return this.action === "ralph" ? "ralph" : "loop";
+    }
+    status() {
+        if (!this.#enabled)
+            return undefined;
+        // The build loop needs no captured prompt: its protocol is fixed and the
+        // queue is on disk, so an enabled build loop is running, not waiting.
+        const armed = this.action === "ralph" || this.#prompt !== undefined;
+        const state = this.#paused ? "paused" : armed ? "running" : "waiting";
+        const status = { state };
+        if (this.#limit)
+            status.limit = this.#limit;
+        // The bar shows WHAT will decide the next iteration, not just that one is
+        // pending: the remaining budget and, when set, the continue-condition.
+        const label = [
+            this.#limit ? describeLoopLimitRuntime(this.#limit) : undefined,
+            this.conditionLabel,
+        ]
+            .filter(Boolean)
+            .join(" · ");
+        if (label)
+            status.label = label;
+        return status;
+    }
+    /** `/loop [count|duration] [--while|--until <cmd>] [prompt]`. Already
+     *  enabled → disable (toggle), matching the reference loop. A malformed
+     *  limit is a hard error and leaves the mode alone. */
+    toggle(args, nowMs = Date.now()) {
+        if (this.#enabled) {
+            this.disable();
+            return { ok: true, status: "loop mode disabled" };
+        }
+        const parsed = parseLoopArgs(args);
+        if (typeof parsed === "string")
+            return { ok: false, error: parsed };
+        return this.#arm(parsed, nowMs);
+    }
+    #arm(parsed, nowMs) {
+        const build = this.action === "ralph";
+        this.#generation++;
+        this.#enabled = true;
+        this.#paused = false;
+        // The build loop's prompt is its protocol, never a captured user turn, so
+        // the parsed trailing text seeds the queue instead.
+        this.#prompt = build ? undefined : parsed.prompt;
+        this.#limit = createLoopLimitRuntime(parsed.limit, nowMs);
+        // The queue is the build loop's default authority on whether to continue;
+        // an explicit --while/--until replaces it.
+        this.#condition = parsed.condition ?? (build ? ralphCondition() : undefined);
+        const limitSuffix = parsed.limit ? ` limited to ${describeLoopLimit(parsed.limit)}` : "";
+        const conditionSuffix = this.#condition ? ` — ${describeLoopCondition(this.#condition)}` : "";
+        const remaining = this.#limit ? ` (${describeLoopLimitRuntime(this.#limit)})` : "";
+        if (build) {
+            return {
+                ok: true,
+                prompt: RALPH_PROTOCOL,
+                hidden: true,
+                // The item seeds the queue; absent means iteration one writes it.
+                queueSeed: parsed.prompt ?? "",
+                status: `build loop enabled${limitSuffix}${remaining}${conditionSuffix} — one ${RALPH_QUEUE} item per fresh session; /loop again disables, Esc pauses`,
+            };
+        }
+        const tail = parsed.prompt
+            ? "repeating it after each turn"
+            : "your next prompt will repeat after each turn";
+        return {
+            ok: true,
+            ...(parsed.prompt ? { prompt: parsed.prompt } : {}),
+            status: `loop mode enabled${limitSuffix}${remaining}${conditionSuffix} — ${tail}; /loop again disables, Esc pauses`,
+        };
+    }
+    /** The user's prompt becomes the loop prompt (the reference loop's
+     *  setLoopPrompt: also clears a pause — the next user prompt re-arms it).
+     *  Called on EVERY user submit, so the newest prompt wins; a loop keeps
+     *  replaying whatever the user last typed. */
+    capturePrompt(text) {
+        if (!this.#enabled)
+            return;
+        this.#generation++;
+        this.#prompt = text;
+        this.#paused = false;
+    }
+    /** Pause without exiting: drop the captured prompt, keep mode enabled (omp
+     *  pauseLoop — Esc between iterations lands here). */
+    pause() {
+        if (!this.#enabled)
+            return;
+        this.#generation++;
+        this.#prompt = undefined;
+        this.#paused = true;
+    }
+    disable(reason) {
+        const wasEnabled = this.#enabled;
+        this.#generation++;
+        this.#enabled = false;
+        this.#paused = false;
+        this.#prompt = undefined;
+        this.#limit = undefined;
+        this.#condition = undefined;
+        return wasEnabled && reason ? reason : "loop mode disabled";
+    }
+    /** One settled run: may the loop re-submit?
+     *
+     *  Order matters. The condition gate runs BEFORE the budget is consumed, so
+     *  a halt never burns an iteration that did not run; the duration deadline
+     *  runs first of all, because an expired clock ends the loop regardless of
+     *  what the condition would have said. */
+    async nextIteration(opts = {
+        cwd: process.cwd(),
+    }, nowMs = Date.now()) {
+        if (!this.#enabled)
+            return { action: "idle" };
+        // The verdict below is only valid for THIS arming; see #generation.
+        const generation = this.#generation;
+        // The build loop re-injects its protocol rather than a captured turn, so
+        // "waiting for a prompt" does not apply to it — but a pause does: pause()
+        // is the only thing that must stop it (Esc between iterations).
+        const build = this.action === "ralph";
+        const prompt = build ? RALPH_PROTOCOL : this.#prompt;
+        if (prompt === undefined || this.#paused)
+            return { action: "idle" };
+        if (isLoopDurationExpired(this.#limit, nowMs)) {
+            return { action: "stop", reason: "loop time limit reached" };
+        }
+        if (this.#condition) {
+            const verdict = await evaluateLoopCondition(this.#condition, {
+                ...opts,
+                timeoutMs: opts.timeoutMs ?? DEFAULT_CONDITION_TIMEOUT_MS,
+            });
+            if (verdict.kind === "aborted")
+                return { action: "idle" };
+            // The await above is a window: Esc (pause), /loop (disable) and a
+            // disable-then-re-arm can all land while the condition runs, which makes
+            // ANY verdict stale — a user who paused, or who restarted the loop, must
+            // not have it stopped out from under them by a halt they never saw
+            // coming. Comparing arming generations covers all of them at once,
+            // including the re-arm that leaves every flag looking unchanged.
+            if (this.#generation !== generation)
+                return { action: "idle" };
+            if (verdict.kind === "halt" || verdict.kind === "error") {
+                return { action: "stop", reason: verdict.message };
+            }
+        }
+        if (!consumeLoopLimitIteration(this.#limit, nowMs)) {
+            return { action: "stop", reason: "loop limit reached" };
+        }
+        // The build loop restarts the session every iteration: stale context is
+        // the failure mode it exists to avoid, and the queue carries what matters.
+        if (build)
+            return { action: "run", prompt, preamble: "reset", hidden: true };
+        if (this.action === "compact" || this.action === "reset") {
+            return { action: "run", prompt, preamble: this.action };
+        }
+        return { action: "run", prompt };
+    }
+}
+export { LOOP_USAGE };

package/dist/core/memory/managed-skills.d.ts

@@ -1,16 +1,5 @@
-/** Managed-skills primitives for the `learn` / `manage_skill` tools (omp
- *  managed-skills port). Managed skills live isolated in
- *  `<agentDir>/managed-skills` and resolve dead-last in skill discovery, so
- *  an authored skill of the same name always shadows them. The
- *  user-authored roots are never written by this module. */
-/** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
-export declare const MAX_MANAGED_SKILL_BYTES = 64000;
 /** Resolve the isolated managed-skills directory. */
 export declare function managedSkillsDir(): string;
-/** Validate + normalize a managed-skill name. Throws on anything outside the
- *  strict allowlist so a bad name can never escape managedSkillsDir()
- *  (blocks `..`, slashes, empty, and uppercase). */
-export declare function sanitizeSkillName(raw: string): string;
 /** Neutralize a machine-generated managed-skill description so it cannot
  *  break out of the system-prompt skill index (strip control/format chars,
  *  angle brackets, fence delimiters; collapse to one line). Applied on write

package/dist/core/memory/managed-skills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"managed-skills.d.ts","sourceRoot":"","sources":["../../../src/core/memory/managed-skills.ts"],"names":[],"mappings":"AAKA;;;;4DAI4D;AAE5D,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAI9C,qDAAqD;AACrD,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;oDAEoD;AACpD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED;;;8CAG8C;AAC9C,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAoBD;iFACiF;AACjF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAiEjF;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAiBrD;AAED;2EAC2E;AAC3E,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,GAAG,IAAI,CASzE;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAUxF;AAED,+DAA+D;AAC/D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D"}
+{"version":3,"file":"managed-skills.d.ts","sourceRoot":"","sources":["../../../src/core/memory/managed-skills.ts"],"names":[],"mappings":"AAgBA,qDAAqD;AACrD,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAeD;;;8CAG8C;AAC9C,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAoBD;iFACiF;AACjF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAiEjF;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAiBrD;AAED;2EAC2E;AAC3E,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,GAAG,IAAI,CASzE;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAUxF;AAED,+DAA+D;AAC/D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D"}

package/dist/core/memory/managed-skills.js

@@ -8,7 +8,7 @@ import { buildSkillIndex } from "../tools/skills.js";
  *  an authored skill of the same name always shadows them. The
  *  user-authored roots are never written by this module. */
 /** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
-export const MAX_MANAGED_SKILL_BYTES = 64_000;
+const MAX_MANAGED_SKILL_BYTES = 64_000;
 const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 /** Resolve the isolated managed-skills directory. */
 export function managedSkillsDir() {
@@ -17,7 +17,7 @@ export function managedSkillsDir() {
 /** Validate + normalize a managed-skill name. Throws on anything outside the
  *  strict allowlist so a bad name can never escape managedSkillsDir()
  *  (blocks `..`, slashes, empty, and uppercase). */
-export function sanitizeSkillName(raw) {
+function sanitizeSkillName(raw) {
     const name = raw.trim().toLowerCase();
     if (!SKILL_NAME_PATTERN.test(name)) {
         throw new Error(`Invalid skill name "${raw}". Use lowercase letters, digits, and hyphens (1-64 chars).`);

package/dist/core/memory/vector-store.d.ts

@@ -46,7 +46,6 @@ export interface VectorMemoryStore {
     supersede(id: string, byId: string): boolean;
     close(): void;
 }
-export declare function normalizeMemoryContent(content: string): string;
 export declare function openVectorMemoryStore(dbPath: string): VectorMemoryStore;
 /** FTS5 MATCH terms for a query: ASCII words OR-joined; CJK has no
  *  token boundaries under unicode61, so CJK-bearing queries fall back to a

package/dist/core/memory/vector-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector-store.d.ts","sourceRoot":"","sources":["../../../src/core/memory/vector-store.ts"],"names":[],"mappings":"AAEA;;;;;;;;iEAQiE;AAEjE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC;IACnC;2EACuE;IACvE,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC;IAC/C,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAC7C,KAAK,IAAI,MAAM,CAAC;IAChB,GAAG,IAAI,SAAS,EAAE,CAAC;IACnB,YAAY,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3C,4EAA4E;IAC5E,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IACrD,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7C,KAAK,IAAI,IAAI,CAAC;CACf;AAuCD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CA2GvE;AAED;;wEAEwE;AACxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO/D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD"}
+{"version":3,"file":"vector-store.d.ts","sourceRoot":"","sources":["../../../src/core/memory/vector-store.ts"],"names":[],"mappings":"AAEA;;;;;;;;iEAQiE;AAEjE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC;IACnC;2EACuE;IACvE,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC;IAC/C,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAC7C,KAAK,IAAI,MAAM,CAAC;IAChB,GAAG,IAAI,SAAS,EAAE,CAAC;IACnB,YAAY,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3C,4EAA4E;IAC5E,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IACrD,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7C,KAAK,IAAI,IAAI,CAAC;CACf;AAuCD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CA2GvE;AAED;;wEAEwE;AACxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO/D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD"}

package/dist/core/memory/vector-store.js

@@ -17,9 +17,6 @@ function toRow(raw) {
         createdAt: raw.created_at,
     };
 }
-export function normalizeMemoryContent(content) {
-    return content.trim().replace(/\s+/g, " ").toLowerCase();
-}
 export function openVectorMemoryStore(dbPath) {
     const db = new Database(dbPath, { create: true });
     db.exec("PRAGMA journal_mode = WAL");

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

@@ -0,0 +1,7 @@
+/** Plan mode: investigate and draft without changing the working tree, then
+ *  review the draft and choose how it reaches implementation (fresh session,
+ *  compacted context, or the current one). */
+export { planModePrompt, planRefinePrompt, planReminderPrompt } from "./prompts.js";
+export { type PlanLoopDecision, PlanRuntime } from "./runtime.js";
+export { enterPlanMode, implementationTurn, newestPlan, type PlanModeState, type PlanReviewChoice, planIsSubstantial, planPathFor, plansDir, planTitle, readPlan, writePlan, } from "./state.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/plans/index.ts"],"names":[],"mappings":"AAAA;;8CAE8C;AAC9C,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACpF,OAAO,EAAE,KAAK,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,WAAW,EACX,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,SAAS,GACV,MAAM,YAAY,CAAC"}

package/dist/core/plans/index.js

@@ -0,0 +1,6 @@
+/** Plan mode: investigate and draft without changing the working tree, then
+ *  review the draft and choose how it reaches implementation (fresh session,
+ *  compacted context, or the current one). */
+export { planModePrompt, planRefinePrompt, planReminderPrompt } from "./prompts.js";
+export { PlanRuntime } from "./runtime.js";
+export { enterPlanMode, implementationTurn, newestPlan, planIsSubstantial, planPathFor, plansDir, planTitle, readPlan, writePlan, } from "./state.js";

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

@@ -0,0 +1,20 @@
+import type { PlanModeState } from "./state.js";
+/** Plan-mode prompt blocks.
+ *
+ *  Read-only is enforced by the FILE TOOL GUARD (write/edit refuse anything
+ *  outside the plan draft — see core/tools/file-tools.ts), not by an allowlist:
+ *  investigation needs the full read surface plus bash. Bash is the honest
+ *  exception and is prompt-guarded only, exactly like the reference
+ *  implementation: a shell command can still change the tree, so the rule it
+ *  states is the rule that holds. */
+export declare function planModePrompt(state: PlanModeState): string;
+/** Sent when a planning turn settled without a draft: the model answered as if
+ *  in a normal turn, so the mode's contract has to be restated once. Capped by
+ *  the caller — a reminder loop would be worse than a missing plan. */
+export declare function planReminderPrompt(state: PlanModeState): string;
+/** Refinement: a review follow-up goes back to the planning turn as a HIDDEN
+ *  protocol prompt (the caller wraps it — it is multi-line boilerplate, not
+ *  something the user typed), with the draft path restated so the model edits
+ *  THAT document. */
+export declare function planRefinePrompt(state: PlanModeState, feedback: string): string;
+//# sourceMappingURL=prompts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/core/plans/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;qCAOqC;AAErC,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CA6B3D;AAED;;uEAEuE;AACvE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAa/D;AAED;;;qBAGqB;AACrB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY/E"}

package/dist/core/plans/prompts.js

@@ -0,0 +1,72 @@
+/** Plan-mode prompt blocks.
+ *
+ *  Read-only is enforced by the FILE TOOL GUARD (write/edit refuse anything
+ *  outside the plan draft — see core/tools/file-tools.ts), not by an allowlist:
+ *  investigation needs the full read surface plus bash. Bash is the honest
+ *  exception and is prompt-guarded only, exactly like the reference
+ *  implementation: a shell command can still change the tree, so the rule it
+ *  states is the rule that holds. */
+export function planModePrompt(state) {
+    return [
+        "<plan_mode>",
+        "Plan mode is active: investigate and produce a PLAN. The working tree is read-only for you.",
+        "",
+        `Write the plan to: ${state.planPath}`,
+        "(the only path write/edit will accept while plan mode is on)",
+        "",
+        "Rules:",
+        "- Do NOT modify the project. read/grep/glob/ls/tree and bash for INSPECTION only",
+        "  (git status, reading logs, running tests to learn the current state).",
+        "- Do NOT create, edit, move, or delete project files; do not run commands that",
+        "  mutate state (installs, apply, commit, rm, writes).",
+        "- Investigate before you draft: read the files the change touches, and check",
+        "  the assumptions the design depends on. An assumption you did not verify is",
+        "  a liability — name it in the plan instead of silently relying on it.",
+        "",
+        "The plan is a Markdown document. Cover, in this order:",
+        "1. **Context** — what changes and why, in the user's terms.",
+        "2. **Approach** — the design, including the alternatives you rejected and why.",
+        "3. **Critical files** — every file to touch, with the change each one gets.",
+        "4. **Verification** — the exact commands that prove the change works.",
+        "5. **Assumptions** — what you verified, and what remains a guess.",
+        "",
+        "Prefer explicit steps with an order that can actually be executed; call out",
+        "anything that has to happen before something else, and any rollback path.",
+        "When the plan is ready, write it to the path above and say so in one line.",
+        "</plan_mode>",
+    ].join("\n");
+}
+/** Sent when a planning turn settled without a draft: the model answered as if
+ *  in a normal turn, so the mode's contract has to be restated once. Capped by
+ *  the caller — a reminder loop would be worse than a missing plan. */
+export function planReminderPrompt(state) {
+    return [
+        "<plan_mode_reminder>",
+        "Plan mode is still active, but no plan was written this turn.",
+        "",
+        `Write the plan (Markdown, the five sections below) to ${state.planPath} using write,`,
+        "then stop. Do not implement anything.",
+        "",
+        "Sections: Context / Approach / Critical files / Verification / Assumptions.",
+        "If you are still missing information, say what you need in one line instead of",
+        "guessing — the user can answer and you continue planning.",
+        "</plan_mode_reminder>",
+    ].join("\n");
+}
+/** Refinement: a review follow-up goes back to the planning turn as a HIDDEN
+ *  protocol prompt (the caller wraps it — it is multi-line boilerplate, not
+ *  something the user typed), with the draft path restated so the model edits
+ *  THAT document. */
+export function planRefinePrompt(state, feedback) {
+    return [
+        "<plan_mode_refine>",
+        `Revise the plan at ${state.planPath}.`,
+        "",
+        "Feedback on the current draft:",
+        feedback.trim(),
+        "",
+        "Keep everything the feedback does not ask you to change, and write the whole",
+        "revised document back to the same path. Do not implement anything yet.",
+        "</plan_mode_refine>",
+    ].join("\n");
+}

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

@@ -0,0 +1,89 @@
+import { type PlanModeState } from "./state.js";
+/** Plan mode's runtime: the session-scoped state machine, extracted from the
+ *  TUI closure so it matches the other two turn drivers (goal, loop) — those
+ *  are classes their surface merely renders, while plan's five loose variables
+ *  were spread across twenty call sites. It owns mode state, the draft, the
+ *  contract/reminder bookkeeping and WHICH model should plan (activeModel);
+ *  the TUI performs the swap and owns the review surface, because both are
+ *  presentation. */
+export type PlanLoopDecision = 
+/** The turn produced a usable draft: nothing to queue. */
+{
+    action: "idle";
+    draftTitle?: string;
+}
+/** No usable draft yet and the reminder budget allows one: restate the
+ *  contract as the next turn. */
+ | {
+    action: "remind";
+}
+/** No usable draft and the reminder is spent: say so, queue nothing. */
+ | {
+    action: "stalled";
+};
+export declare class PlanRuntime {
+    #private;
+    /** Workspace root: plan paths live under it. */
+    private readonly workspaceRoot;
+    /** Persist a mode transition (session event); `null` = mode off. */
+    private readonly persist;
+    /** The model to plan with; absent = do not touch the model. */
+    private readonly planModel;
+    constructor(
+    /** Workspace root: plan paths live under it. */
+    workspaceRoot: string, 
+    /** Persist a mode transition (session event); `null` = mode off. */
+    persist?: (state: PlanModeState | null, paused: boolean) => void, 
+    /** The model to plan with; absent = do not touch the model. */
+    planModel?: string | undefined);
+    get state(): PlanModeState | null;
+    get enabled(): boolean;
+    get paused(): boolean;
+    /** The draft path, or undefined when plan mode is off. */
+    get draftPath(): string | undefined;
+    /** Model the session should be on right now: the plan model while planning,
+     *  otherwise whatever was active before (undefined = leave it alone). */
+    get activeModel(): string | undefined;
+    /** The guard the file tools need while planning: the ONE writable path. */
+    get writeGuard(): {
+        planPath: string;
+    } | undefined;
+    /** The status-bar indicator: the driver owns its wording. */
+    statusLabel(): string | undefined;
+    /** 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: string, reentry?: boolean): PlanModeState;
+    /** Active → paused: the draft and the mode stay, no turn is driven. */
+    pause(): void;
+    /** 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(): void;
+    /** 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: {
+        planPath: string;
+    } | null, sessionId: string): void;
+    /** 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: string | undefined): void;
+    readDraft(): string | null;
+    hasDraft(): boolean;
+    draftTitle(): string | undefined;
+    /** The contract prompt, ONCE per entry (it is long, and the mode is sticky).
+     *  Null when it was already delivered. */
+    takeContractPrompt(render: (state: PlanModeState) => string): string | null;
+    /** A user turn resets the reminder budget: they just spoke, so the model
+     *  gets another chance to draft. */
+    onUserTurn(): void;
+    /** 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(): PlanLoopDecision;
+    /** Refinement re-arms planning on the SAME draft (the caller wraps the
+     *  feedback as the turn's input). */
+    refine(sessionId: string): PlanModeState;
+    /** Save the draft elsewhere and stop planning without executing. */
+    saveCopy(destination: string): boolean;
+}
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/core/plans/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAMnB,MAAM,YAAY,CAAC;AAEpB;;;;;;oBAMoB;AAEpB,MAAM,MAAM,gBAAgB;AAC1B,0DAA0D;AACxD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE;AACzC;iCACiC;GAC/B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE;AACtB,wEAAwE;GACtE;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAE1B,qBAAa,WAAW;;IASpB,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,SAAS;;IAL1B,gDAAgD;IAC/B,aAAa,EAAE,MAAM;IACtC,oEAAoE;IACnD,OAAO,GAAE,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,KAAK,IAAe;IAC3F,+DAA+D;IAC9C,SAAS,GAAE,MAAM,GAAG,SAAqB;IAG5D,IAAI,KAAK,IAAI,aAAa,GAAG,IAAI,CAEhC;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,0DAA0D;IAC1D,IAAI,SAAS,IAAI,MAAM,GAAG,SAAS,CAElC;IAED;6EACyE;IACzE,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAGpC;IAED,2EAA2E;IAC3E,IAAI,UAAU,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAGjD;IAED,6DAA6D;IAC7D,WAAW,IAAI,MAAM,GAAG,SAAS;IAOjC;wEACoE;IACpE,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,aAAa;IAYxD,uEAAuE;IACvE,KAAK,IAAI,IAAI;IAMb;;2EAEuE;IACvE,KAAK,IAAI,IAAI;IASb;yEACqE;IACrE,OAAO,CAAC,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAgBvE;mEAC+D;IAC/D,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAIjD,SAAS,IAAI,MAAM,GAAG,IAAI;IAK1B,QAAQ,IAAI,OAAO;IAKnB,UAAU,IAAI,MAAM,GAAG,SAAS;IAKhC;8CAC0C;IAC1C,kBAAkB,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,MAAM,GAAG,MAAM,GAAG,IAAI;IAM3E;wCACoC;IACpC,UAAU,IAAI,IAAI;IAIlB;;mBAEe;IACf,UAAU,IAAI,gBAAgB;IAe9B;yCACqC;IACrC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa;IAQxC,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;CAMvC"}