@vauban-org/agent-sdk 0.16.0

package/dist/orchestration/ooda/react-loop.js

@@ -0,0 +1,90 @@
+/**
+ * ReactLoop — Reason + Act tool-calling loop for the act phase.
+ *
+ * Thought → Action → Observation loop with maxStep guard. Model-agnostic:
+ * accepts an `LLMCompletionFn` that decouples from any specific provider.
+ *
+ * Used within the `act` phase of an OODA cycle when the agent needs multi-step
+ * reasoning with tool calls (ReAct pattern).
+ *
+ * Loop stops on:
+ *   - Final answer (no tool call in response)
+ *   - maxSteps reached
+ *   - LLM error
+ *   - AbortSignal fired
+ *
+ * @public
+ */
+// ─── Constants ──────────────────────────────────────────────────────────────────
+const DEFAULT_MAX_STEPS = 10;
+const DEFAULT_MAX_TOOL_CALL_SIZE = 10_240; // 10KB
+// ─── Loop ───────────────────────────────────────────────────────────────────────
+/**
+ * Run a ReAct (Reasoning + Acting) loop.
+ *
+ * ```
+ * Thought → Action → Observation → Thought → ... → Final Answer
+ * ```
+ */
+export async function reactLoop(opts) {
+    const maxSteps = opts.maxSteps ?? DEFAULT_MAX_STEPS;
+    const maxToolCallSize = opts.maxToolCallSize ?? DEFAULT_MAX_TOOL_CALL_SIZE;
+    const allowedTools = opts.allowedTools;
+    const steps = [];
+    const messages = [
+        { role: "system", content: opts.systemPrompt },
+        { role: "user", content: opts.task },
+    ];
+    for (let i = 0; i < maxSteps; i++) {
+        if (opts.signal?.aborted) {
+            return { answer: "", steps, totalSteps: i, truncated: true };
+        }
+        // Thought → Action
+        const response = await opts.llm(messages);
+        steps.push({
+            index: i,
+            thought: response.content,
+            action: response.toolCalls?.[0],
+        });
+        // Final answer — no tool call
+        if (response.isFinal || !response.toolCalls || response.toolCalls.length === 0) {
+            return { answer: response.content, steps, totalSteps: i + 1, truncated: false };
+        }
+        const toolCall = response.toolCalls[0];
+        // Validate tool call size
+        const toolJson = JSON.stringify(toolCall);
+        if (toolJson.length > maxToolCallSize) {
+            steps[i].error = `Tool call exceeds ${maxToolCallSize}B limit`;
+            steps[i].observation = `Error: tool call too large (${toolJson.length}B > ${maxToolCallSize}B limit)`;
+            messages.push({ role: "assistant", content: response.content, name: toolCall.tool }, { role: "tool", content: steps[i].observation, tool_call_id: `call_${i}` });
+            continue;
+        }
+        // Check allowed tools
+        if (allowedTools && !allowedTools.includes(toolCall.tool)) {
+            steps[i].error = `Tool "${toolCall.tool}" not in allowed list`;
+            steps[i].observation = `Error: tool "${toolCall.tool}" is not allowed. Available tools: ${allowedTools.join(", ")}`;
+            messages.push({ role: "assistant", content: response.content, name: toolCall.tool }, { role: "tool", content: steps[i].observation, tool_call_id: `call_${i}` });
+            continue;
+        }
+        // Observation — execute tool
+        try {
+            const observation = await opts.executeTool(toolCall);
+            steps[i].observation = observation;
+        }
+        catch (err) {
+            steps[i].error = err instanceof Error ? err.message : String(err);
+            steps[i].observation = `Error executing tool "${toolCall.tool}": ${steps[i].error}`;
+        }
+        // Feed observation back into the conversation
+        messages.push({ role: "assistant", content: response.content, name: toolCall.tool }, { role: "tool", content: steps[i].observation, tool_call_id: `call_${i}` });
+    }
+    // Truncated — max steps reached
+    const lastStep = steps[steps.length - 1];
+    return {
+        answer: lastStep?.thought ?? "",
+        steps,
+        totalSteps: maxSteps,
+        truncated: true,
+    };
+}
+//# sourceMappingURL=react-loop.js.map

package/dist/orchestration/ooda/react-loop.js.map

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

package/dist/orchestration/ooda/reflexion.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Reflexion Memory — Brain-stored lessons for future cycles.
+ *
+ * Safety constraints (non-negotiable):
+ *   - confidence MUST be > 0.6 for retrieval (prevents low-quality lessons from
+ *     poisoning future decisions).
+ *   - TTL defaults to 30 days (stale lessons expire).
+ *   - Every entry carries `sourceCycleId` and `outcomeType` for traceability.
+ *   - Brain stores with category="forge_reflexion", tags=["reflexion", "agent:<id>"].
+ *
+ * A single incorrect reflection persisting in a long-running agent is
+ * catastrophic — severity scales with agent lifetime. Confidence weighting
+ * + TTL guard against reflexion poisoning.
+ *
+ * @public
+ */
+export interface ReflexionEntry {
+    /** The lesson learned. */
+    content: string;
+    /** Confidence score (0.0 - 1.0). MUST be provided. */
+    confidence: number;
+    /** The cycle that generated this lesson. */
+    sourceCycleId: string;
+    /** What happened: "succeeded" | "failed" | "partial". */
+    outcomeType: "succeeded" | "failed" | "partial";
+    /** Time-to-live in milliseconds (default: 30 days). */
+    ttlMs?: number;
+}
+export interface ReflexionQuery {
+    agentId: string;
+    /** Only match entries for this outcome type. */
+    outcomeType?: "succeeded" | "failed" | "partial";
+    /** Max entries to return (default: 5). */
+    limit?: number;
+}
+/**
+ * Store a reflexion entry via a BrainPort-compatible archival function.
+ *
+ * The `archiver` is typically `brain.archiveKnowledge()` or
+ * `semantic.archive()`.
+ */
+export declare function storeReflexion(entry: ReflexionEntry, agentId: string, archiver: (input: {
+    content: string;
+    category?: string;
+    tags?: string[];
+    confidence?: number;
+    metadata?: Record<string, unknown>;
+}) => Promise<unknown>): Promise<void>;
+/**
+ * Query reflexion memory.
+ *
+ * ONLY returns entries with confidence > 0.6 AND within TTL window.
+ * The `querier` is typically `brain.queryKnowledge()` or `semantic.query()`.
+ */
+export declare function queryReflexionMemory(query: ReflexionQuery, querier: (q: string, filters?: Record<string, unknown>) => Promise<ReflexionEntry[]>): Promise<ReflexionEntry[]>;
+//# sourceMappingURL=reflexion.d.ts.map

package/dist/orchestration/ooda/reflexion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflexion.d.ts","sourceRoot":"","sources":["../../../src/orchestration/ooda/reflexion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,WAAW,cAAc;IAC7B,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,WAAW,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IAChD,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,WAAW,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IACjD,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AASD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,KAAK,OAAO,CAAC,OAAO,CAAC,GACrB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,cAAc,EAAE,CAAC,GACnF,OAAO,CAAC,cAAc,EAAE,CAAC,CAW3B"}

package/dist/orchestration/ooda/reflexion.js

@@ -0,0 +1,58 @@
+/**
+ * Reflexion Memory — Brain-stored lessons for future cycles.
+ *
+ * Safety constraints (non-negotiable):
+ *   - confidence MUST be > 0.6 for retrieval (prevents low-quality lessons from
+ *     poisoning future decisions).
+ *   - TTL defaults to 30 days (stale lessons expire).
+ *   - Every entry carries `sourceCycleId` and `outcomeType` for traceability.
+ *   - Brain stores with category="forge_reflexion", tags=["reflexion", "agent:<id>"].
+ *
+ * A single incorrect reflection persisting in a long-running agent is
+ * catastrophic — severity scales with agent lifetime. Confidence weighting
+ * + TTL guard against reflexion poisoning.
+ *
+ * @public
+ */
+// ─── Constants ──────────────────────────────────────────────────────────────────
+const MIN_CONFIDENCE = 0.6;
+const DEFAULT_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+// ─── Store / Query ──────────────────────────────────────────────────────────────
+/**
+ * Store a reflexion entry via a BrainPort-compatible archival function.
+ *
+ * The `archiver` is typically `brain.archiveKnowledge()` or
+ * `semantic.archive()`.
+ */
+export async function storeReflexion(entry, agentId, archiver) {
+    await archiver({
+        content: entry.content,
+        category: "forge_reflexion",
+        tags: ["reflexion", `agent:${agentId}`],
+        confidence: entry.confidence,
+        metadata: {
+            sourceCycleId: entry.sourceCycleId,
+            outcomeType: entry.outcomeType,
+            ttlMs: entry.ttlMs ?? DEFAULT_TTL_MS,
+        },
+    });
+}
+/**
+ * Query reflexion memory.
+ *
+ * ONLY returns entries with confidence > 0.6 AND within TTL window.
+ * The `querier` is typically `brain.queryKnowledge()` or `semantic.query()`.
+ */
+export async function queryReflexionMemory(query, querier) {
+    const results = await querier(`reflexion ${query.agentId} ${query.outcomeType ?? ""}`, {
+        category: "forge_reflexion",
+        tags: ["reflexion", `agent:${query.agentId}`],
+        limit: query.limit ?? 5,
+    });
+    return results.filter((entry) => {
+        if (entry.confidence < MIN_CONFIDENCE)
+            return false;
+        return true;
+    }).slice(0, query.limit ?? 5);
+}
+//# sourceMappingURL=reflexion.js.map

package/dist/orchestration/ooda/reflexion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflexion.js","sourceRoot":"","sources":["../../../src/orchestration/ooda/reflexion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAyBH,mFAAmF;AAEnF,MAAM,cAAc,GAAG,GAAG,CAAC;AAC3B,MAAM,cAAc,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,UAAU;AAE3D,mFAAmF;AAEnF;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,KAAqB,EACrB,OAAe,EACf,QAMsB;IAEtB,MAAM,QAAQ,CAAC;QACb,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,QAAQ,EAAE,iBAAiB;QAC3B,IAAI,EAAE,CAAC,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC;QACvC,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,QAAQ,EAAE;YACR,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,cAAc;SACrC;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAqB,EACrB,OAAoF;IAEpF,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,aAAa,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,WAAW,IAAI,EAAE,EAAE,EAAE;QACrF,QAAQ,EAAE,iBAAiB;QAC3B,IAAI,EAAE,CAAC,WAAW,EAAE,SAAS,KAAK,CAAC,OAAO,EAAE,CAAC;QAC7C,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC;KACxB,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;QAC9B,IAAI,KAAK,CAAC,UAAU,GAAG,cAAc;YAAE,OAAO,KAAK,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;AAChC,CAAC"}

package/dist/orchestration/ooda/resource-limits.d.ts

@@ -0,0 +1,63 @@
+/**
+ * OODA resource limits runtime — sprint-525:quick-2.
+ *
+ * `ResourceLimitsRunner` is the runtime helper enforcing the
+ * `ResourceLimits` interface declared in `./types.ts` (quick-1).
+ * Hard caps on phase wall-clock, step count per cycle, and process heap
+ * usage. Defaults are conservative; agents with heavier workloads MUST
+ * raise them explicitly via the constructor — there is no implicit
+ * "unlimited" mode.
+ *
+ * Usage:
+ *   const runner = new ResourceLimitsRunner({ phaseTimeoutMs: 90_000 });
+ *   const ac = runner.createPhaseAbortController();
+ *   await runPhase(observePayload, { signal: ac.signal });
+ *   runner.enforceStepCount(steps.length);
+ *   runner.checkHeap();
+ *
+ * @public
+ */
+export interface ResourceLimitsOpts {
+    /** Hard wall-clock limit per OODA phase. Default: 60_000 ms. */
+    phaseTimeoutMs: number;
+    /** Max steps allowed per OODA cycle. Default: 200. */
+    maxStepsPerCycle: number;
+    /** Soft heap warning threshold (MiB). Default: 256. */
+    maxHeapMb: number;
+    /** Optional warn sink for heap excess (defaults to console.warn). */
+    onHeapExceeded?: (info: {
+        rssMb: number;
+        heapMb: number;
+        max: number;
+    }) => void;
+}
+export declare class StepCountExceededError extends Error {
+    readonly code = "OODA_STEP_COUNT_EXCEEDED";
+    constructor(currentCount: number, max: number);
+}
+export declare class ResourceLimitsRunner {
+    readonly phaseTimeoutMs: number;
+    readonly maxStepsPerCycle: number;
+    readonly maxHeapMb: number;
+    private readonly onHeapExceeded?;
+    constructor(opts?: Partial<ResourceLimitsOpts>);
+    /**
+     * Build an AbortController whose signal trips after `phaseTimeoutMs`.
+     * The host is responsible for forwarding the signal to async work
+     * (fetch, MCP calls, child Promise.race, …) so the abort actually
+     * propagates.
+     */
+    createPhaseAbortController(): AbortController;
+    /**
+     * Throw if `currentCount` exceeds `maxStepsPerCycle`. Caller increments
+     * the counter as steps are committed and calls this before the next
+     * step starts.
+     */
+    enforceStepCount(currentCount: number): void;
+    /**
+     * Sample the process heap and warn if it exceeds `maxHeapMb`. Pure
+     * observability — never throws (a hard kill is the OS' job).
+     */
+    checkHeap(): void;
+}
+//# sourceMappingURL=resource-limits.d.ts.map

package/dist/orchestration/ooda/resource-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-limits.d.ts","sourceRoot":"","sources":["../../../src/orchestration/ooda/resource-limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,gBAAgB,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACjF;AAQD,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,IAAI,8BAA8B;gBAC/B,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;CAI9C;AAED,qBAAa,oBAAoB;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAuC;gBAE3D,IAAI,GAAE,OAAO,CAAC,kBAAkB,CAAM;IAiBlD;;;;;OAKG;IACH,0BAA0B,IAAI,eAAe;IAgB7C;;;;OAIG;IACH,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAM5C;;;OAGG;IACH,SAAS,IAAI,IAAI;CAiBlB"}

package/dist/orchestration/ooda/resource-limits.js

@@ -0,0 +1,107 @@
+/**
+ * OODA resource limits runtime — sprint-525:quick-2.
+ *
+ * `ResourceLimitsRunner` is the runtime helper enforcing the
+ * `ResourceLimits` interface declared in `./types.ts` (quick-1).
+ * Hard caps on phase wall-clock, step count per cycle, and process heap
+ * usage. Defaults are conservative; agents with heavier workloads MUST
+ * raise them explicitly via the constructor — there is no implicit
+ * "unlimited" mode.
+ *
+ * Usage:
+ *   const runner = new ResourceLimitsRunner({ phaseTimeoutMs: 90_000 });
+ *   const ac = runner.createPhaseAbortController();
+ *   await runPhase(observePayload, { signal: ac.signal });
+ *   runner.enforceStepCount(steps.length);
+ *   runner.checkHeap();
+ *
+ * @public
+ */
+const DEFAULTS = {
+    phaseTimeoutMs: 60_000,
+    maxStepsPerCycle: 200,
+    maxHeapMb: 256,
+};
+export class StepCountExceededError extends Error {
+    code = "OODA_STEP_COUNT_EXCEEDED";
+    constructor(currentCount, max) {
+        super(`[ooda] step count ${currentCount} exceeds max ${max} per cycle`);
+        this.name = "StepCountExceededError";
+    }
+}
+export class ResourceLimitsRunner {
+    phaseTimeoutMs;
+    maxStepsPerCycle;
+    maxHeapMb;
+    onHeapExceeded;
+    constructor(opts = {}) {
+        const merged = { ...DEFAULTS, ...opts };
+        if (merged.phaseTimeoutMs <= 0) {
+            throw new Error("[ooda/resource-limits] phaseTimeoutMs must be > 0");
+        }
+        if (merged.maxStepsPerCycle <= 0) {
+            throw new Error("[ooda/resource-limits] maxStepsPerCycle must be > 0");
+        }
+        if (merged.maxHeapMb <= 0) {
+            throw new Error("[ooda/resource-limits] maxHeapMb must be > 0");
+        }
+        this.phaseTimeoutMs = merged.phaseTimeoutMs;
+        this.maxStepsPerCycle = merged.maxStepsPerCycle;
+        this.maxHeapMb = merged.maxHeapMb;
+        this.onHeapExceeded = merged.onHeapExceeded;
+    }
+    /**
+     * Build an AbortController whose signal trips after `phaseTimeoutMs`.
+     * The host is responsible for forwarding the signal to async work
+     * (fetch, MCP calls, child Promise.race, …) so the abort actually
+     * propagates.
+     */
+    createPhaseAbortController() {
+        const ac = new AbortController();
+        const timer = setTimeout(() => {
+            ac.abort(new Error(`[ooda] phase timeout after ${this.phaseTimeoutMs}ms`));
+        }, this.phaseTimeoutMs);
+        // Don't keep the event loop alive purely for this watchdog.
+        if (typeof timer === "object" && timer && "unref" in timer) {
+            timer.unref?.();
+        }
+        // Cancel the timer on natural abort to free the timer slot.
+        ac.signal.addEventListener("abort", () => clearTimeout(timer), {
+            once: true,
+        });
+        return ac;
+    }
+    /**
+     * Throw if `currentCount` exceeds `maxStepsPerCycle`. Caller increments
+     * the counter as steps are committed and calls this before the next
+     * step starts.
+     */
+    enforceStepCount(currentCount) {
+        if (currentCount > this.maxStepsPerCycle) {
+            throw new StepCountExceededError(currentCount, this.maxStepsPerCycle);
+        }
+    }
+    /**
+     * Sample the process heap and warn if it exceeds `maxHeapMb`. Pure
+     * observability — never throws (a hard kill is the OS' job).
+     */
+    checkHeap() {
+        if (typeof process === "undefined" || typeof process.memoryUsage !== "function") {
+            return;
+        }
+        const mem = process.memoryUsage();
+        const heapMb = mem.heapUsed / (1024 * 1024);
+        const rssMb = mem.rss / (1024 * 1024);
+        if (heapMb > this.maxHeapMb) {
+            const info = { rssMb, heapMb, max: this.maxHeapMb };
+            if (this.onHeapExceeded) {
+                this.onHeapExceeded(info);
+            }
+            else {
+                // eslint-disable-next-line no-console -- intentional fallback when no sink wired
+                console.warn("[ooda/resource-limits] heap exceeded", info);
+            }
+        }
+    }
+}
+//# sourceMappingURL=resource-limits.js.map

package/dist/orchestration/ooda/resource-limits.js.map

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

package/dist/orchestration/ooda/run-step-persistence.d.ts

@@ -0,0 +1,50 @@
+/**
+ * OODA run_step persistence helpers — sprint-525:quick-2.
+ *
+ * Mirrors the pattern from src/router/execution-pipeline.ts (sprint-521):
+ *   insertRunStep  → INSERT row with status='pending', returns stepId
+ *   completeRunStep → UPDATE status='done' + leaf_hash_poseidon (Poseidon JCS)
+ *   errorRunStep    → UPDATE status='error' + error_message
+ *
+ * Decoupled from the command-center monolith: imports computeLeafHash
+ * via the SDK's own poseidon module (shipped sprint-521:quick-13).
+ *
+ * The DbClient interface is the minimal pg.Pool/pg.Client subset already
+ * used by `agent-run-tracker.ts` — keeps the SDK pg-free at install time.
+ *
+ * @public
+ */
+import type { DbClient } from "../../tracking/agent-run-tracker.js";
+import type { OODAPhaseKind } from "./types.js";
+export interface InsertRunStepInput {
+    type: OODAPhaseKind;
+    /** Human-readable phase tag (e.g. "observe", "orient", "decide", "act"). */
+    phase: string;
+    stepIndex: number;
+    payload?: Record<string, unknown>;
+    parentStepId?: string;
+}
+/**
+ * Insert a `run_step` row in `pending` state and return the freshly
+ * minted UUID. Caller is responsible for finishing it via
+ * `completeRunStep` / `errorRunStep`.
+ */
+export declare function insertRunStep(db: DbClient, runId: string, input: InsertRunStepInput): Promise<{
+    stepId: string;
+}>;
+/**
+ * Mark a `run_step` row as `done`, attach its final payload, and write
+ * the Poseidon leaf hash for cryptographic accountability.
+ *
+ * The leaf hash is computed from the FINAL payload (not the pending one),
+ * keeping the on-disk hash in sync with the canonical state at completion.
+ */
+export declare function completeRunStep(db: DbClient, stepId: string, payload: Record<string, unknown>): Promise<{
+    leafHash: string;
+}>;
+/**
+ * Mark a `run_step` row as `error` with the given error message.
+ * Idempotent w.r.t. multiple error calls — last-write-wins on the message.
+ */
+export declare function errorRunStep(db: DbClient, stepId: string, error: Error): Promise<void>;
+//# sourceMappingURL=run-step-persistence.d.ts.map

package/dist/orchestration/ooda/run-step-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-step-persistence.d.ts","sourceRoot":"","sources":["../../../src/orchestration/ooda/run-step-persistence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,aAAa,CAAC;IACpB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAiC7B;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA2B/B;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/orchestration/ooda/run-step-persistence.js

@@ -0,0 +1,89 @@
+/**
+ * OODA run_step persistence helpers — sprint-525:quick-2.
+ *
+ * Mirrors the pattern from src/router/execution-pipeline.ts (sprint-521):
+ *   insertRunStep  → INSERT row with status='pending', returns stepId
+ *   completeRunStep → UPDATE status='done' + leaf_hash_poseidon (Poseidon JCS)
+ *   errorRunStep    → UPDATE status='error' + error_message
+ *
+ * Decoupled from the command-center monolith: imports computeLeafHash
+ * via the SDK's own poseidon module (shipped sprint-521:quick-13).
+ *
+ * The DbClient interface is the minimal pg.Pool/pg.Client subset already
+ * used by `agent-run-tracker.ts` — keeps the SDK pg-free at install time.
+ *
+ * @public
+ */
+import { computeLeafHash } from "@vauban-org/proof-core";
+/**
+ * Insert a `run_step` row in `pending` state and return the freshly
+ * minted UUID. Caller is responsible for finishing it via
+ * `completeRunStep` / `errorRunStep`.
+ */
+export async function insertRunStep(db, runId, input) {
+    if (typeof runId !== "string" || runId.length === 0) {
+        throw new Error("[ooda] insertRunStep: runId must be a non-empty string");
+    }
+    if (!Number.isInteger(input.stepIndex) || input.stepIndex < 0) {
+        throw new Error("[ooda] insertRunStep: stepIndex must be a non-negative integer");
+    }
+    const payloadJson = JSON.stringify(input.payload ?? {});
+    const res = await db.query(`INSERT INTO run_step
+       (run_id, step_index, parent_step_id, type, phase, status, started_at, payload)
+     VALUES
+       ($1, $2, $3, $4, $5, 'pending', now(), $6::jsonb)
+     RETURNING id`, [
+        runId,
+        input.stepIndex,
+        input.parentStepId ?? null,
+        input.type,
+        input.phase,
+        payloadJson,
+    ]);
+    const row = res.rows[0];
+    if (!row) {
+        throw new Error("[ooda] insertRunStep: insert returned no row");
+    }
+    return { stepId: row.id };
+}
+/**
+ * Mark a `run_step` row as `done`, attach its final payload, and write
+ * the Poseidon leaf hash for cryptographic accountability.
+ *
+ * The leaf hash is computed from the FINAL payload (not the pending one),
+ * keeping the on-disk hash in sync with the canonical state at completion.
+ */
+export async function completeRunStep(db, stepId, payload) {
+    if (typeof stepId !== "string" || stepId.length === 0) {
+        throw new Error("[ooda] completeRunStep: stepId must be a non-empty string");
+    }
+    if (payload === null ||
+        typeof payload !== "object" ||
+        Array.isArray(payload)) {
+        throw new Error("[ooda] completeRunStep: payload must be a plain object");
+    }
+    const leafHash = computeLeafHash(payload);
+    await db.query(`UPDATE run_step
+        SET status = 'done',
+            finished_at = now(),
+            payload = $2::jsonb,
+            leaf_hash_poseidon = $3
+      WHERE id = $1`, [stepId, JSON.stringify(payload), leafHash]);
+    return { leafHash };
+}
+/**
+ * Mark a `run_step` row as `error` with the given error message.
+ * Idempotent w.r.t. multiple error calls — last-write-wins on the message.
+ */
+export async function errorRunStep(db, stepId, error) {
+    if (typeof stepId !== "string" || stepId.length === 0) {
+        throw new Error("[ooda] errorRunStep: stepId must be a non-empty string");
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    await db.query(`UPDATE run_step
+        SET status = 'error',
+            finished_at = now(),
+            error_message = $2
+      WHERE id = $1`, [stepId, message]);
+}
+//# sourceMappingURL=run-step-persistence.js.map

package/dist/orchestration/ooda/run-step-persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-step-persistence.js","sourceRoot":"","sources":["../../../src/orchestration/ooda/run-step-persistence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAazD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,EAAY,EACZ,KAAa,EACb,KAAyB;IAEzB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,IAAK,KAAK,CAAC,SAAoB,GAAG,CAAC,EAAE,CAAC;QAC1E,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,KAAK,CACxB;;;;kBAIc,EACd;QACE,KAAK;QACL,KAAK,CAAC,SAAS;QACf,KAAK,CAAC,YAAY,IAAI,IAAI;QAC1B,KAAK,CAAC,IAAI;QACV,KAAK,CAAC,KAAK;QACX,WAAW;KACZ,CACF,CAAC;IAEF,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxB,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,EAAY,EACZ,MAAc,EACd,OAAgC;IAEhC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IACD,IACE,OAAO,KAAK,IAAI;QAChB,OAAO,OAAO,KAAK,QAAQ;QAC3B,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EACtB,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IAED,MAAM,QAAQ,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAE1C,MAAM,EAAE,CAAC,KAAK,CACZ;;;;;oBAKgB,EAChB,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAC5C,CAAC;IAEF,OAAO,EAAE,QAAQ,EAAE,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,EAAY,EACZ,MAAc,EACd,KAAY;IAEZ,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAEvE,MAAM,EAAE,CAAC,KAAK,CACZ;;;;oBAIgB,EAChB,CAAC,MAAM,EAAE,OAAO,CAAC,CAClB,CAAC;AACJ,CAAC"}

package/dist/orchestration/ooda/skills.d.ts

@@ -0,0 +1,58 @@
+/**
+ * OODA Skill Registry — interface only (sprint-525:quick-1 foundation).
+ *
+ * Implementations land in sprint-525:quick-5. Skills are pure (or
+ * side-effect-bearing) callable units invoked from inside OODA phase
+ * functions. The `dryRunMocks` map lets tests + dry-run mode replace
+ * any skill execution with a deterministic mock keyed by skill name.
+ *
+ * The SkillRegistry is intentionally untyped at the value level to keep
+ * the SDK barrel compatible with arbitrary downstream skill libraries.
+ * A typed lookup helper can be layered on top in 0.7.x.
+ *
+ * @public
+ */
+import type { DbClient } from "../../tracking/agent-run-tracker.js";
+import type { LoggerPort } from "../../ports/logger.js";
+/**
+ * Context handed to each skill invocation.
+ *
+ * `isReplay` MUST be honored by skills that have side-effects: when true,
+ * the skill must short-circuit and emit no observable mutation (no LLM
+ * call, no HTTP, no DB INSERT). This guarantees replay safety for the
+ * OODA cycle log.
+ */
+export interface SkillContext {
+    readonly isReplay: boolean;
+    readonly dryRunMocks: Record<string, (input: unknown) => unknown>;
+    readonly db: DbClient;
+    readonly logger: LoggerPort;
+}
+/**
+ * Skill — single named callable unit invoked from an OODA phase.
+ *
+ * `inputSchema` is typed `unknown` here to keep the registry value-type
+ * homogeneous. Concrete skill libraries may use Zod (already a SDK dep)
+ * to refine the input — but validation is enforced inside `execute`.
+ */
+export interface Skill<I = unknown, O = unknown> {
+    readonly name: string;
+    /**
+     * Runtime validator/parser for the skill input. Concrete skill libs
+     * typically wire `z.ZodType<I>` here; the registry stays untyped.
+     */
+    readonly inputSchema: {
+        parse: (raw: unknown) => I;
+    };
+    execute(input: I, ctx: SkillContext): Promise<O>;
+}
+/**
+ * SkillRegistry — name → skill map. Used by OODA phases to look up and
+ * invoke skills without coupling to concrete implementations.
+ */
+export type SkillRegistry = Record<string, Skill>;
+/**
+ * Empty registry — convenience for tests and minimal agents.
+ */
+export declare const EMPTY_SKILL_REGISTRY: SkillRegistry;
+//# sourceMappingURL=skills.d.ts.map

package/dist/orchestration/ooda/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../src/orchestration/ooda/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC;IAClE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE;QAAE,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,CAAC,CAAA;KAAE,CAAC;IACrD,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAiC,CAAC"}

package/dist/orchestration/ooda/skills.js

@@ -0,0 +1,19 @@
+/**
+ * OODA Skill Registry — interface only (sprint-525:quick-1 foundation).
+ *
+ * Implementations land in sprint-525:quick-5. Skills are pure (or
+ * side-effect-bearing) callable units invoked from inside OODA phase
+ * functions. The `dryRunMocks` map lets tests + dry-run mode replace
+ * any skill execution with a deterministic mock keyed by skill name.
+ *
+ * The SkillRegistry is intentionally untyped at the value level to keep
+ * the SDK barrel compatible with arbitrary downstream skill libraries.
+ * A typed lookup helper can be layered on top in 0.7.x.
+ *
+ * @public
+ */
+/**
+ * Empty registry — convenience for tests and minimal agents.
+ */
+export const EMPTY_SKILL_REGISTRY = Object.freeze({});
+//# sourceMappingURL=skills.js.map

package/dist/orchestration/ooda/skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../../src/orchestration/ooda/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA2CH;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAkB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC"}