wotann 0.5.0

package/dist/orchestration/tool-rules.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Tool-rules — declarative tool-flow enforcement.
+ *
+ * MOTIVATION
+ *
+ * Modern LLM agents make free-form tool-call sprees: read 10 files
+ * "just in case," then never read the right one. WOTANN's loop-
+ * detector catches identical-signature repetition, but doesn't model
+ * the SHAPE of a healthy tool flow. tool-rules.ts adds that shape:
+ * declare four kinds of rules and a validator checks every tool
+ * sequence against them.
+ *
+ * Rule types (ported from letta-ai/letta's letta_agent_v3.py)
+ *
+ *   InitToolRule(tool)          — `tool` must be the FIRST tool call
+ *                                  in a turn. No prior tool calls
+ *                                  allowed before it.
+ *   ContinueToolRule(after,     — when `after` is called, the next
+ *                    allowed)     tool MUST be one of `allowed` (or
+ *                                  no further tool — turn end).
+ *   TerminalToolRule(tool)      — once `tool` is called, no more
+ *                                  tool calls in this turn.
+ *   ChildToolRule(parent, child) — `child` may only be called AFTER
+ *                                  `parent` has been called at least
+ *                                  once in the current turn.
+ *
+ * USAGE
+ *
+ *   const rules: ReadonlyArray<ToolRule> = [
+ *     { kind: "init", tool: "explore_dir" },
+ *     { kind: "continue", after: "read_file", allowed: ["edit_file", "write_file"] },
+ *     { kind: "terminal", tool: "commit" },
+ *     { kind: "child", parent: "explore_dir", child: "read_file" },
+ *   ];
+ *
+ *   const verdict = validateToolSequence(["explore_dir", "read_file", "edit_file"], rules);
+ *   if (verdict.kind === "violation") { ... }
+ *
+ * INTEGRATION
+ *
+ * The validator is pure — caller integrates with the middleware
+ * pipeline by calling validateToolSequence([...prior, nextTool],
+ * rules) BEFORE dispatching `nextTool`. On violation, the agent's
+ * proposed tool call is rejected and the agent receives a feedback
+ * message describing the rule that was violated. See middleware/
+ * tool-flow-gate.ts (queued for follow-up wire).
+ *
+ * Quality bars:
+ *   - QB#3 honest stubs: the validator returns a typed verdict; no
+ *     silent success paths.
+ *   - QB#7 per-call state: rules are passed in, not module-global.
+ *     Same rule set + same sequence → same verdict (referentially
+ *     transparent).
+ */
+export type ToolRule = {
+    readonly kind: "init";
+    readonly tool: string;
+} | {
+    readonly kind: "continue";
+    readonly after: string;
+    readonly allowed: ReadonlyArray<string>;
+} | {
+    readonly kind: "terminal";
+    readonly tool: string;
+} | {
+    readonly kind: "child";
+    readonly parent: string;
+    readonly child: string;
+};
+export type ToolFlowVerdict = {
+    readonly kind: "ok";
+} | {
+    readonly kind: "violation";
+    readonly rule: ToolRule;
+    /**
+     * Index in the input sequence where the violation occurred.
+     * Always >= 0 and < sequence.length.
+     */
+    readonly atIndex: number;
+    /** Human-readable single-line summary. */
+    readonly reason: string;
+};
+/**
+ * Check `sequence` against `rules` IN ORDER. Returns the FIRST
+ * violation, or `{kind:"ok"}` if every rule is satisfied at every
+ * step.
+ *
+ * The validator is intentionally per-turn — it does NOT carry state
+ * across turns. If the caller wants cross-turn enforcement (e.g.
+ * "tool X may only be called once per session"), they pass the full
+ * session-tool-call list as `sequence`.
+ */
+export declare function validateToolSequence(sequence: ReadonlyArray<string>, rules: ReadonlyArray<ToolRule>): ToolFlowVerdict;
+/**
+ * Convenience: build a fresh ruleset by merging multiple rule
+ * arrays. Useful for stacking session-level rules + skill-level
+ * rules + caller-level rules.
+ */
+export declare function mergeRules(...rulesets: ReadonlyArray<ReadonlyArray<ToolRule>>): ReadonlyArray<ToolRule>;
+/**
+ * Predicate: is the given next tool valid given the prior sequence
+ * and rules? Convenience wrapper for the common pre-dispatch check
+ * site in the middleware pipeline.
+ */
+export declare function isNextToolAllowed(prior: ReadonlyArray<string>, next: string, rules: ReadonlyArray<ToolRule>): ToolFlowVerdict;
+//# sourceMappingURL=tool-rules.d.ts.map

package/dist/orchestration/tool-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-rules.d.ts","sourceRoot":"","sources":["../../src/orchestration/tool-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAIH,MAAM,MAAM,QAAQ,GAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACzC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GACvB;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAIN;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,GAC7B,eAAe,CAgFjB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,GAAG,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,GAClD,aAAa,CAAC,QAAQ,CAAC,CAEzB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,GAC7B,eAAe,CAEjB"}

package/dist/orchestration/tool-rules.js

@@ -0,0 +1,151 @@
+/**
+ * Tool-rules — declarative tool-flow enforcement.
+ *
+ * MOTIVATION
+ *
+ * Modern LLM agents make free-form tool-call sprees: read 10 files
+ * "just in case," then never read the right one. WOTANN's loop-
+ * detector catches identical-signature repetition, but doesn't model
+ * the SHAPE of a healthy tool flow. tool-rules.ts adds that shape:
+ * declare four kinds of rules and a validator checks every tool
+ * sequence against them.
+ *
+ * Rule types (ported from letta-ai/letta's letta_agent_v3.py)
+ *
+ *   InitToolRule(tool)          — `tool` must be the FIRST tool call
+ *                                  in a turn. No prior tool calls
+ *                                  allowed before it.
+ *   ContinueToolRule(after,     — when `after` is called, the next
+ *                    allowed)     tool MUST be one of `allowed` (or
+ *                                  no further tool — turn end).
+ *   TerminalToolRule(tool)      — once `tool` is called, no more
+ *                                  tool calls in this turn.
+ *   ChildToolRule(parent, child) — `child` may only be called AFTER
+ *                                  `parent` has been called at least
+ *                                  once in the current turn.
+ *
+ * USAGE
+ *
+ *   const rules: ReadonlyArray<ToolRule> = [
+ *     { kind: "init", tool: "explore_dir" },
+ *     { kind: "continue", after: "read_file", allowed: ["edit_file", "write_file"] },
+ *     { kind: "terminal", tool: "commit" },
+ *     { kind: "child", parent: "explore_dir", child: "read_file" },
+ *   ];
+ *
+ *   const verdict = validateToolSequence(["explore_dir", "read_file", "edit_file"], rules);
+ *   if (verdict.kind === "violation") { ... }
+ *
+ * INTEGRATION
+ *
+ * The validator is pure — caller integrates with the middleware
+ * pipeline by calling validateToolSequence([...prior, nextTool],
+ * rules) BEFORE dispatching `nextTool`. On violation, the agent's
+ * proposed tool call is rejected and the agent receives a feedback
+ * message describing the rule that was violated. See middleware/
+ * tool-flow-gate.ts (queued for follow-up wire).
+ *
+ * Quality bars:
+ *   - QB#3 honest stubs: the validator returns a typed verdict; no
+ *     silent success paths.
+ *   - QB#7 per-call state: rules are passed in, not module-global.
+ *     Same rule set + same sequence → same verdict (referentially
+ *     transparent).
+ */
+// ── Validator ──────────────────────────────────────────────
+/**
+ * Check `sequence` against `rules` IN ORDER. Returns the FIRST
+ * violation, or `{kind:"ok"}` if every rule is satisfied at every
+ * step.
+ *
+ * The validator is intentionally per-turn — it does NOT carry state
+ * across turns. If the caller wants cross-turn enforcement (e.g.
+ * "tool X may only be called once per session"), they pass the full
+ * session-tool-call list as `sequence`.
+ */
+export function validateToolSequence(sequence, rules) {
+    // 1. InitToolRule — if any init rule exists, the first tool MUST
+    //    match one of the init tools. (Multiple init rules == any-of.)
+    const initRules = rules.filter((r) => r.kind === "init");
+    if (initRules.length > 0 && sequence.length > 0) {
+        const first = sequence[0];
+        const validInits = initRules.map((r) => r.tool);
+        if (!validInits.includes(first)) {
+            const rule = initRules[0];
+            return {
+                kind: "violation",
+                rule,
+                atIndex: 0,
+                reason: `init rule violated: first tool must be one of [${validInits.join(", ")}], got "${first}"`,
+            };
+        }
+    }
+    // 2. TerminalToolRule — once a terminal tool is called, no more
+    //    tools in this sequence.
+    const terminalRules = rules.filter((r) => r.kind === "terminal");
+    for (let i = 0; i < sequence.length - 1; i++) {
+        const current = sequence[i];
+        const matchingTerminal = terminalRules.find((r) => r.tool === current);
+        if (matchingTerminal) {
+            return {
+                kind: "violation",
+                rule: matchingTerminal,
+                atIndex: i + 1,
+                reason: `terminal rule violated: "${current}" must end the turn, but "${sequence[i + 1]}" was called after`,
+            };
+        }
+    }
+    // 3. ContinueToolRule — when `after` is called, the next tool must
+    //    be in `allowed` (or absent — turn end).
+    const continueRules = rules.filter((r) => r.kind === "continue");
+    for (let i = 0; i < sequence.length - 1; i++) {
+        const current = sequence[i];
+        const next = sequence[i + 1];
+        const matchingContinue = continueRules.find((r) => r.after === current);
+        if (matchingContinue && !matchingContinue.allowed.includes(next)) {
+            return {
+                kind: "violation",
+                rule: matchingContinue,
+                atIndex: i + 1,
+                reason: `continue rule violated: after "${current}", must call one of [${matchingContinue.allowed.join(", ")}], got "${next}"`,
+            };
+        }
+    }
+    // 4. ChildToolRule — `child` may only be called after `parent` has
+    //    appeared at least once earlier in the sequence.
+    const childRules = rules.filter((r) => r.kind === "child");
+    if (childRules.length > 0) {
+        const seen = new Set();
+        for (let i = 0; i < sequence.length; i++) {
+            const tool = sequence[i];
+            const matchingChild = childRules.find((r) => r.child === tool);
+            if (matchingChild && !seen.has(matchingChild.parent)) {
+                return {
+                    kind: "violation",
+                    rule: matchingChild,
+                    atIndex: i,
+                    reason: `child rule violated: "${matchingChild.child}" requires "${matchingChild.parent}" to be called first`,
+                };
+            }
+            seen.add(tool);
+        }
+    }
+    return { kind: "ok" };
+}
+/**
+ * Convenience: build a fresh ruleset by merging multiple rule
+ * arrays. Useful for stacking session-level rules + skill-level
+ * rules + caller-level rules.
+ */
+export function mergeRules(...rulesets) {
+    return rulesets.flat();
+}
+/**
+ * Predicate: is the given next tool valid given the prior sequence
+ * and rules? Convenience wrapper for the common pre-dispatch check
+ * site in the middleware pipeline.
+ */
+export function isNextToolAllowed(prior, next, rules) {
+    return validateToolSequence([...prior, next], rules);
+}
+//# sourceMappingURL=tool-rules.js.map

package/dist/orchestration/tool-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-rules.js","sourceRoot":"","sources":["../../src/orchestration/tool-rules.ts"],"names":[],"mappings":"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"}

package/dist/orchestration/two-state-spec.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Two-state spec — Copilot Workspace's "current state -> desired state +
+ * deltas" editable specification primitive.
+ *
+ * Pure data + pure functions. No IO. No clock. The module exports:
+ *   - typed `TwoStateSpec` shape
+ *   - `parseSpec(markdown)`: deserialize from a 3-section markdown doc
+ *   - `renderSpec(spec)`: serialize back to markdown
+ *   - `computeDeltas(current, desired)`: line-diff producing `Delta[]`
+ *   - `applyEdit(spec, edit)`: immutable edit (returns new spec)
+ *
+ * Markdown format (intentionally simple — round-trips losslessly):
+ *
+ *   # Two-State Spec
+ *
+ *   ## Current State
+ *   <free-form text>
+ *
+ *   ## Desired State
+ *   <free-form text>
+ *
+ *   ## Deltas
+ *   - <kind>: <description>
+ *
+ * Quality bars: pure (no `process.env`, no clock). Immutable: every
+ * mutation returns a new object. Honest about being a primitive — the UI
+ * layer is responsible for richer editing flows.
+ */
+export type DeltaKind = "add" | "remove" | "modify";
+export interface Delta {
+    readonly kind: DeltaKind;
+    readonly description: string;
+}
+export interface TwoStateSpec {
+    readonly currentState: string;
+    readonly desiredState: string;
+    readonly deltas: readonly Delta[];
+}
+export type SpecField = "currentState" | "desiredState";
+export interface SpecEdit {
+    readonly field: SpecField;
+    readonly value: string;
+}
+export declare const EMPTY_SPEC: TwoStateSpec;
+/**
+ * Parse a markdown spec into a `TwoStateSpec`. Missing sections become
+ * empty strings / arrays. Unknown sections are ignored. Order of
+ * sections is enforced: Current → Desired → Deltas.
+ */
+export declare function parseSpec(markdown: string): TwoStateSpec;
+/**
+ * Render a `TwoStateSpec` back to markdown. Round-trips with `parseSpec`.
+ */
+export declare function renderSpec(spec: TwoStateSpec): string;
+/**
+ * Compute deltas between two state strings via line-level diff.
+ * Lines unique to `current` → `remove`. Lines unique to `desired` → `add`.
+ * No `modify` heuristic — we conservatively avoid pairing similar-looking
+ * lines because mismatched pairings are worse than two adjacent
+ * remove/add entries that the user can re-pair manually.
+ */
+export declare function computeDeltas(current: string, desired: string): readonly Delta[];
+/**
+ * Immutable edit: produces a new spec with `field` replaced and deltas
+ * recomputed against `currentState` / `desiredState`. The caller is
+ * responsible for persisting the result.
+ */
+export declare function applyEdit(spec: TwoStateSpec, edit: SpecEdit): TwoStateSpec;
+/**
+ * Recompute deltas from scratch — useful when both states were edited
+ * in one tick and the caller doesn't want to chain two `applyEdit`
+ * calls.
+ */
+export declare function recomputeDeltas(spec: TwoStateSpec): TwoStateSpec;
+//# sourceMappingURL=two-state-spec.d.ts.map

package/dist/orchestration/two-state-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"two-state-spec.d.ts","sourceRoot":"","sources":["../../src/orchestration/two-state-spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEpD,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;CACnC;AAED,MAAM,MAAM,SAAS,GAAG,cAAc,GAAG,cAAc,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAID,eAAO,MAAM,UAAU,EAAE,YAIxB,CAAC;AAuDF;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CAUxD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAWrD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,KAAK,EAAE,CAahF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,GAAG,YAAY,CAU1E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAEhE"}

package/dist/orchestration/two-state-spec.js

@@ -0,0 +1,160 @@
+/**
+ * Two-state spec — Copilot Workspace's "current state -> desired state +
+ * deltas" editable specification primitive.
+ *
+ * Pure data + pure functions. No IO. No clock. The module exports:
+ *   - typed `TwoStateSpec` shape
+ *   - `parseSpec(markdown)`: deserialize from a 3-section markdown doc
+ *   - `renderSpec(spec)`: serialize back to markdown
+ *   - `computeDeltas(current, desired)`: line-diff producing `Delta[]`
+ *   - `applyEdit(spec, edit)`: immutable edit (returns new spec)
+ *
+ * Markdown format (intentionally simple — round-trips losslessly):
+ *
+ *   # Two-State Spec
+ *
+ *   ## Current State
+ *   <free-form text>
+ *
+ *   ## Desired State
+ *   <free-form text>
+ *
+ *   ## Deltas
+ *   - <kind>: <description>
+ *
+ * Quality bars: pure (no `process.env`, no clock). Immutable: every
+ * mutation returns a new object. Honest about being a primitive — the UI
+ * layer is responsible for richer editing flows.
+ */
+// ── Empty + factories ──────────────────────────────────────
+export const EMPTY_SPEC = {
+    currentState: "",
+    desiredState: "",
+    deltas: [],
+};
+// ── Helpers (pure) ─────────────────────────────────────────
+const HEADER_CURRENT = "## Current State";
+const HEADER_DESIRED = "## Desired State";
+const HEADER_DELTAS = "## Deltas";
+function trimSection(s) {
+    return s.replace(/^\s+|\s+$/g, "");
+}
+function indexOfHeader(text, header) {
+    // Match header on its own line — never partial.
+    const lines = text.split("\n");
+    let offset = 0;
+    for (const line of lines) {
+        if (line.trim() === header)
+            return offset;
+        offset += line.length + 1; // +1 for newline
+    }
+    return -1;
+}
+function extractSection(text, start, end) {
+    const slice = text.slice(start, end >= 0 ? end : text.length);
+    // Drop the header line (first line of the slice).
+    const newlineIdx = slice.indexOf("\n");
+    if (newlineIdx === -1)
+        return "";
+    return trimSection(slice.slice(newlineIdx + 1));
+}
+function parseDeltas(section) {
+    const out = [];
+    for (const rawLine of section.split("\n")) {
+        const line = rawLine.trim();
+        if (!line.startsWith("- "))
+            continue;
+        const body = line.slice(2);
+        const colonIdx = body.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const kindRaw = body.slice(0, colonIdx).trim().toLowerCase();
+        const description = body.slice(colonIdx + 1).trim();
+        if (kindRaw === "add" || kindRaw === "remove" || kindRaw === "modify") {
+            out.push({ kind: kindRaw, description });
+        }
+    }
+    return out;
+}
+function renderDeltas(deltas) {
+    if (deltas.length === 0)
+        return "";
+    return deltas.map((d) => `- ${d.kind}: ${d.description}`).join("\n");
+}
+// ── Public API ─────────────────────────────────────────────
+/**
+ * Parse a markdown spec into a `TwoStateSpec`. Missing sections become
+ * empty strings / arrays. Unknown sections are ignored. Order of
+ * sections is enforced: Current → Desired → Deltas.
+ */
+export function parseSpec(markdown) {
+    const idxCurrent = indexOfHeader(markdown, HEADER_CURRENT);
+    const idxDesired = indexOfHeader(markdown, HEADER_DESIRED);
+    const idxDeltas = indexOfHeader(markdown, HEADER_DELTAS);
+    const currentEnd = idxDesired >= 0 ? idxDesired : idxDeltas >= 0 ? idxDeltas : -1;
+    const desiredEnd = idxDeltas >= 0 ? idxDeltas : -1;
+    const currentState = idxCurrent >= 0 ? extractSection(markdown, idxCurrent, currentEnd) : "";
+    const desiredState = idxDesired >= 0 ? extractSection(markdown, idxDesired, desiredEnd) : "";
+    const deltasSection = idxDeltas >= 0 ? extractSection(markdown, idxDeltas, -1) : "";
+    return { currentState, desiredState, deltas: parseDeltas(deltasSection) };
+}
+/**
+ * Render a `TwoStateSpec` back to markdown. Round-trips with `parseSpec`.
+ */
+export function renderSpec(spec) {
+    const parts = ["# Two-State Spec", ""];
+    parts.push(HEADER_CURRENT);
+    parts.push(spec.currentState.length > 0 ? spec.currentState : "");
+    parts.push("");
+    parts.push(HEADER_DESIRED);
+    parts.push(spec.desiredState.length > 0 ? spec.desiredState : "");
+    parts.push("");
+    parts.push(HEADER_DELTAS);
+    parts.push(renderDeltas(spec.deltas));
+    return parts.join("\n");
+}
+/**
+ * Compute deltas between two state strings via line-level diff.
+ * Lines unique to `current` → `remove`. Lines unique to `desired` → `add`.
+ * No `modify` heuristic — we conservatively avoid pairing similar-looking
+ * lines because mismatched pairings are worse than two adjacent
+ * remove/add entries that the user can re-pair manually.
+ */
+export function computeDeltas(current, desired) {
+    const currentLines = current.split("\n").filter((l) => l.trim().length > 0);
+    const desiredLines = desired.split("\n").filter((l) => l.trim().length > 0);
+    const currentSet = new Set(currentLines);
+    const desiredSet = new Set(desiredLines);
+    const out = [];
+    for (const line of currentLines) {
+        if (!desiredSet.has(line))
+            out.push({ kind: "remove", description: line });
+    }
+    for (const line of desiredLines) {
+        if (!currentSet.has(line))
+            out.push({ kind: "add", description: line });
+    }
+    return out;
+}
+/**
+ * Immutable edit: produces a new spec with `field` replaced and deltas
+ * recomputed against `currentState` / `desiredState`. The caller is
+ * responsible for persisting the result.
+ */
+export function applyEdit(spec, edit) {
+    const next = {
+        ...spec,
+        [edit.field]: edit.value,
+        deltas: computeDeltas(edit.field === "currentState" ? edit.value : spec.currentState, edit.field === "desiredState" ? edit.value : spec.desiredState),
+    };
+    return next;
+}
+/**
+ * Recompute deltas from scratch — useful when both states were edited
+ * in one tick and the caller doesn't want to chain two `applyEdit`
+ * calls.
+ */
+export function recomputeDeltas(spec) {
+    return { ...spec, deltas: computeDeltas(spec.currentState, spec.desiredState) };
+}
+//# sourceMappingURL=two-state-spec.js.map

package/dist/orchestration/two-state-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"two-state-spec.js","sourceRoot":"","sources":["../../src/orchestration/two-state-spec.ts"],"names":[],"mappings":"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"}

package/dist/orchestration/ultraplan.d.ts

@@ -0,0 +1,93 @@
+/**
+ * ULTRAPLAN — Remote cloud planning with extended thinking budget.
+ *
+ * When a task is too complex for a single context window, ULTRAPLAN
+ * offloads the planning phase to the most powerful model with maximum
+ * thinking time (e.g., Claude Opus 4.6 with 30-min think budget).
+ *
+ * FLOW:
+ * 1. User requests a complex task
+ * 2. ULTRAPLAN sends a detailed planning prompt to the strongest available model
+ * 3. The model plans with extended thinking (up to 128K thinking tokens)
+ * 4. The plan is returned as a structured document
+ * 5. Execution phase uses the plan with a fast model (Sonnet/Haiku)
+ *
+ * This implements the Architect/Editor pattern at maximum scale:
+ * - Architect: Opus with 30-min think budget
+ * - Editor: Sonnet/Codex for fast implementation
+ */
+import type { ProviderName } from "../core/types.js";
+import type { KnowledgeGraph } from "../memory/graph-rag.js";
+export interface ULTRAPLANConfig {
+    /**
+     * Provider for planning. Empty string means "no default — caller must
+     * specify or read from runtime config." See DEFAULT_CONFIG below for
+     * the rationale.
+     */
+    readonly planProvider: ProviderName | "";
+    /** Model for planning (e.g., claude-opus-4-7). Empty when provider is empty. */
+    readonly planModel: string;
+    /** Maximum thinking tokens for the planning phase */
+    readonly maxThinkingTokens: number;
+    /** Maximum time for the planning phase in ms */
+    readonly maxPlanTimeMs: number;
+    /** Provider for execution. Same empty-sentinel convention as planProvider. */
+    readonly execProvider: ProviderName | "";
+    /** Model for execution (e.g., claude-sonnet-4-7). Empty when provider is empty. */
+    readonly execModel: string;
+}
+export interface ULTRAPLANResult {
+    readonly plan: StructuredPlan;
+    readonly planDurationMs: number;
+    readonly planTokensUsed: number;
+    readonly executionResults: readonly PhaseResult[];
+    readonly totalDurationMs: number;
+    readonly success: boolean;
+}
+export interface StructuredPlan {
+    readonly title: string;
+    readonly summary: string;
+    readonly phases: readonly PlanPhase[];
+    readonly risks: readonly string[];
+    readonly acceptanceCriteria: readonly string[];
+    readonly estimatedComplexity: "low" | "medium" | "high" | "extreme";
+}
+export interface PlanPhase {
+    readonly id: number;
+    readonly name: string;
+    readonly description: string;
+    readonly files: readonly string[];
+    readonly dependencies: readonly number[];
+    readonly estimatedTokens: number;
+}
+export interface PhaseResult {
+    readonly phaseId: number;
+    readonly success: boolean;
+    readonly output: string;
+    readonly tokensUsed: number;
+    readonly durationMs: number;
+}
+/**
+ * Build the planning prompt for ULTRAPLAN.
+ * This prompt elicits a structured plan with phases, dependencies, and risks.
+ *
+ * D11: if a knowledge graph is supplied, the planner seeds its context with
+ * the entities and relationships most relevant to the task so the model
+ * proposes phases against what *actually* exists in the repo (files,
+ * modules, prior decisions) instead of hallucinating structure.
+ */
+export declare function buildPlanningPrompt(task: string, context?: string, knowledgeGraph?: KnowledgeGraph): string;
+/**
+ * Parse a model's planning response into a StructuredPlan.
+ */
+export declare function parsePlanResponse(response: string): StructuredPlan;
+/**
+ * Get the default ULTRAPLAN configuration.
+ */
+export declare function getDefaultConfig(): ULTRAPLANConfig;
+/**
+ * Check if ULTRAPLAN should be triggered for a task.
+ * Heuristic: tasks with 3+ phases, 5+ files, or explicit keywords.
+ */
+export declare function shouldUseULTRAPLAN(task: string): boolean;
+//# sourceMappingURL=ultraplan.d.ts.map

package/dist/orchestration/ultraplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ultraplan.d.ts","sourceRoot":"","sources":["../../src/orchestration/ultraplan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,YAAY,GAAG,EAAE,CAAC;IACzC,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,gDAAgD;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,YAAY,GAAG,EAAE,CAAC;IACzC,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,WAAW,EAAE,CAAC;IAClD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;CACrE;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,EAChB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAmCR;AA+BD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CA8DlE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAElD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYxD"}