open-multi-agent-kit 0.78.6 → 0.78.7

package/dist/contracts/proof.d.ts

@@ -1,5 +1,5 @@
 import type { OMK_PROOF_BUNDLE_SCHEMA_VERSION, OMK_RUNTIME_VERSION } from "../version.js";
-export type ProofBundleScenario = "no-kimi-smoke" | "evidence-block" | "fallback-route" | "dag-dependent-block" | "replay-inspect" | "graph-audit" | "example-generation" | "doctor-provider" | "native-safety" | "contract-version-smoke";
+export type ProofBundleScenario = "no-kimi-smoke" | "evidence-block" | "fallback-route" | "dag-dependent-block" | "replay-inspect" | "graph-audit" | "example-generation" | "doctor-provider" | "contract-version-smoke";
 export type ProofBundleVerdict = "passed" | "failed" | "partial";
 export type ProofBundleFiles = {
     rawPrompt: string;

package/dist/goal/control-loop.d.ts

@@ -95,6 +95,21 @@ export interface NextPromptResult {
 }
 export declare function recallMemoryForGoal(goal: GoalSpec, root: string, runState?: RunState, signal?: AbortSignal): Promise<string>;
 export declare function generateNextPrompt(goal: GoalSpec, evidence: GoalEvidence[], runState?: RunState, memorySummary?: string, root?: string): Promise<NextPromptResult>;
+/** Buckets of run-state nodes grouped by lifecycle status. */
+export interface RunStateNodeBuckets {
+    failed: RunState["nodes"];
+    blocked: RunState["nodes"];
+    running: RunState["nodes"];
+    pending: RunState["nodes"];
+    success: RunState["nodes"];
+}
+/**
+ * Classify `runState.nodes` into status buckets in a SINGLE pass. Behavior-preserving
+ * replacement for five separate `.filter()` passes: each bucket holds exactly the nodes
+ * the matching `status === ...` filter would have selected, in the same order. `success`
+ * collects `status === "done"` nodes. Statuses outside these five are ignored.
+ */
+export declare function bucketRunStateNodesByStatus(runState: RunState | undefined): RunStateNodeBuckets;
 /**
  * Evaluate which success criteria still lack passing evidence.
  * Returns ordered list with required criteria first, then by weight desc.

package/dist/goal/control-loop.js

@@ -858,6 +858,41 @@ export async function generateNextPrompt(goal, evidence, runState, memorySummary
         };
     });
 }
+/**
+ * Classify `runState.nodes` into status buckets in a SINGLE pass. Behavior-preserving
+ * replacement for five separate `.filter()` passes: each bucket holds exactly the nodes
+ * the matching `status === ...` filter would have selected, in the same order. `success`
+ * collects `status === "done"` nodes. Statuses outside these five are ignored.
+ */
+export function bucketRunStateNodesByStatus(runState) {
+    const failed = [];
+    const blocked = [];
+    const running = [];
+    const pending = [];
+    const success = [];
+    for (const node of runState?.nodes ?? []) {
+        switch (node.status) {
+            case "failed":
+                failed.push(node);
+                break;
+            case "blocked":
+                blocked.push(node);
+                break;
+            case "running":
+                running.push(node);
+                break;
+            case "pending":
+                pending.push(node);
+                break;
+            case "done":
+                success.push(node);
+                break;
+            default:
+                break;
+        }
+    }
+    return { failed, blocked, running, pending, success };
+}
 async function generateNextPromptInner(goal, evidence, runState, memorySummary, root, signal) {
     if (signal?.aborted)
         throw signal.reason ?? new Error("Aborted");
@@ -880,11 +915,10 @@ async function generateNextPromptInner(goal, evidence, runState, memorySummary,
         const ev = evidence.find((e) => e.criterionId === c.id);
         return ev?.passed ?? false;
     });
-    const failedNodes = runState?.nodes.filter((n) => n.status === "failed") ?? [];
-    const blockedNodes = runState?.nodes.filter((n) => n.status === "blocked") ?? [];
-    const runningNodes = runState?.nodes.filter((n) => n.status === "running") ?? [];
-    const pendingNodes = runState?.nodes.filter((n) => n.status === "pending") ?? [];
-    const successNodes = runState?.nodes.filter((n) => n.status === "done") ?? [];
+    // Single pass over runState.nodes replaces five separate .filter() passes per
+    // iteration. Bucket contents and order are identical to the prior per-status
+    // filters because nodes are appended in iteration order.
+    const { failed: failedNodes, blocked: blockedNodes, running: runningNodes, pending: pendingNodes, success: successNodes, } = bucketRunStateNodesByStatus(runState);
     const proposedAction = suggestion.type === "close"
         ? "close"
         : failedNodes.length > 0 || blockedNodes.length > 0

package/dist/hud/render.d.ts

@@ -29,6 +29,8 @@ export interface HudRenderOptions {
     showUptime?: boolean;
     systemRefreshMs?: number;
     thinking?: import("./types.js").HudThinkingEntry[];
+    /** Optional live brand theme override; OMK_THEME is used when this is absent. */
+    theme?: string;
     /** Current working phase for gradient-animated status line */
     workingPhase?: import("../theme/working-indicator.js").WorkingPhase | null;
     /** Spinner animation type (defaults to "braille") */

package/dist/hud/render.js

@@ -12,6 +12,8 @@ import { t } from "../util/i18n.js";
 import { parseRunStateResult, buildRunViewModel, renderRunSummary, sanitizeForDisplay, } from "../util/run-view-model.js";
 import { hudTheme } from "../util/theme.js";
 import { renderWorkingIndicator } from "../theme/working-indicator.js";
+import { setBrandPaletteTheme } from "../brand/palette.js";
+import { getActiveBrandHudStatus } from "../brand/theme-compiled.js";
 import { loadTodos } from "../util/todo-sync.js";
 import { readSessionMeta } from "../util/session.js";
 const theme = hudTheme;
@@ -254,7 +256,7 @@ function renderNeonControlHeader(runId, workingPhase, workingSpinner) {
     const parts = [
         "",
         theme.style.phosphor("OMK//HUD") + "  " + runLabel,
-        theme.style.gray("NEON GRID ONLINE"),
+        theme.style.gray(getActiveBrandHudStatus()),
         theme.style.gray("Route agents. Verify evidence. Control the loop."),
     ];
     if (workingLine) {
@@ -940,6 +942,10 @@ async function renderSectionDashboard(options) {
     return output.join("\n");
 }
 export async function renderHudDashboard(options = {}) {
+    const requestedBrandTheme = options.theme ?? process.env.OMK_THEME;
+    if (requestedBrandTheme !== undefined) {
+        setBrandPaletteTheme(requestedBrandTheme);
+    }
     const width = options.terminalWidth ?? defaultHudTerminalWidth();
     if (options.section) {
         return renderSectionDashboard(options);

package/dist/mcp/secret-scanner.d.ts

@@ -168,6 +168,12 @@ export declare class SecretScanner extends EventEmitter {
     static severityIcon(severity: SecretSeverity): string;
     private findInText;
     private redactText;
+    /**
+     * Precompute the byte offset at which each line begins.
+     * lineStarts[0] is always 0; each subsequent entry is the index just after a
+     * "\n". Used to make getLineColumn O(log n) per lookup instead of O(offset).
+     */
+    private computeLineStarts;
     private getLineColumn;
     private getContext;
     private readFileSafe;

package/dist/mcp/secret-scanner.js

@@ -313,13 +313,14 @@ export class SecretScanner extends EventEmitter {
         const findings = [];
         let redacted = text;
         const activePatterns = this.getActivePatterns();
+        const lineStarts = this.computeLineStarts(text);
         for (const pattern of activePatterns) {
             pattern.pattern.lastIndex = 0;
             let match;
             while ((match = pattern.pattern.exec(text)) !== null) {
                 const matchedText = match[0];
                 const offset = match.index;
-                const { line, column } = this.getLineColumn(text, offset);
+                const { line, column } = this.getLineColumn(text, offset, lineStarts);
                 const context = this.getContext(text, offset, matchedText.length);
                 findings.push({
                     id: this.generateId(),
@@ -519,13 +520,14 @@ export class SecretScanner extends EventEmitter {
     findInText(text, sourceFile) {
         const findings = [];
         const activePatterns = this.getActivePatterns();
+        const lineStarts = this.computeLineStarts(text);
         for (const pattern of activePatterns) {
             pattern.pattern.lastIndex = 0;
             let match;
             while ((match = pattern.pattern.exec(text)) !== null) {
                 const matchedText = match[0];
                 const offset = match.index;
-                const { line, column } = this.getLineColumn(text, offset);
+                const { line, column } = this.getLineColumn(text, offset, lineStarts);
                 const context = this.getContext(text, offset, matchedText.length);
                 findings.push({
                     id: this.generateId(),
@@ -553,19 +555,50 @@ export class SecretScanner extends EventEmitter {
         }
         return result;
     }
-    getLineColumn(text, offset) {
-        let line = 1;
-        let column = 1;
-        for (let i = 0; i < offset && i < text.length; i++) {
-            if (text[i] === "\n") {
-                line++;
-                column = 1;
+    /**
+     * Precompute the byte offset at which each line begins.
+     * lineStarts[0] is always 0; each subsequent entry is the index just after a
+     * "\n". Used to make getLineColumn O(log n) per lookup instead of O(offset).
+     */
+    computeLineStarts(text) {
+        const lineStarts = [0];
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] === "\n")
+                lineStarts.push(i + 1);
+        }
+        return lineStarts;
+    }
+    getLineColumn(text, offset, lineStarts) {
+        // Backward-compatible fallback: original O(offset) scan when no precomputed
+        // index is supplied. Produces identical line/column numbers.
+        if (!lineStarts) {
+            let line = 1;
+            let column = 1;
+            for (let i = 0; i < offset && i < text.length; i++) {
+                if (text[i] === "\n") {
+                    line++;
+                    column = 1;
+                }
+                else {
+                    column++;
+                }
+            }
+            return { line, column };
+        }
+        // Binary search for the rightmost line start that is <= offset.
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= offset) {
+                lo = mid;
             }
             else {
-                column++;
+                hi = mid - 1;
             }
         }
-        return { line, column };
+        const lineStartOffset = lineStarts[lo];
+        return { line: lo + 1, column: offset - lineStartOffset + 1 };
     }
     getContext(text, offset, matchLength) {
         const ctxChars = this.contextChars;

package/dist/memory/graph-delta-log.d.ts

@@ -0,0 +1,137 @@
+import type { LocalGraphState, LocalGraphNode, LocalGraphEdge } from "./local-graph-memory-store.js";
+export interface DeltaRecord {
+    v: 2;
+    epoch: number;
+    seq: number;
+    ts: string;
+    meta: {
+        updatedAt: string;
+        project: {
+            key: string;
+            name: string;
+            root: string;
+        };
+        ontology: string;
+    };
+    nodes: {
+        del: string[];
+        put: LocalGraphNode[];
+    };
+    edges: {
+        del: string[];
+        put: LocalGraphEdge[];
+    };
+    crc: string;
+}
+export interface DeltaManifest {
+    formatVersion: 2;
+    snapshot: string;
+    snapshotEpoch: number;
+    delta: string;
+    deltaOpCount: number;
+}
+export type DurabilityMode = "legacy" | "delta";
+export declare function resolveDurabilityMode(env?: NodeJS.ProcessEnv): DurabilityMode;
+/**
+ * Compute an order-faithful delta between pre-mutation and post-mutation state.
+ * `put` entries are ordered by their index in the final array and repositioned
+ * entries are deleted-before-put, so Map-based replay reproduces the EXACT raw
+ * array order of the legacy full-rewrite (see `computeOrderedDelta`).
+ */
+export declare function computeDelta(preNodes: ReadonlyMap<string, LocalGraphNode>, preEdges: ReadonlyMap<string, LocalGraphEdge>, state: LocalGraphState): {
+    nodes: {
+        del: string[];
+        put: LocalGraphNode[];
+    };
+    edges: {
+        del: string[];
+        put: LocalGraphEdge[];
+    };
+};
+export declare function readManifest(graphPath: string): Promise<DeltaManifest | null>;
+export declare function writeManifest(graphPath: string, manifest: DeltaManifest): Promise<void>;
+/**
+ * Append a single delta record to the journal + fdatasync.
+ * Returns the seq number assigned to the record.
+ */
+export declare function appendDelta(graphPath: string, epoch: number, seq: number, ts: string, meta: DeltaRecord["meta"], nodesDelta: {
+    del: string[];
+    put: LocalGraphNode[];
+}, edgesDelta: {
+    del: string[];
+    put: LocalGraphEdge[];
+}): Promise<void>;
+/**
+ * Load snapshot from disk plus replay all valid delta records.
+ *
+ * Replay correctness lemma:
+ *   1. Base: nodes/edges loaded from snapshot into insertion-ordered Map.
+ *   2. For each record with epoch === currentEpoch:
+ *      a. Apply all `del` ids: Map.delete(key).
+ *      b. Apply all `put` entries in array order: Map.set(key, entry).
+ *         Map.set on existing key keeps position; on new/deleted key appends.
+ *   3. Materialize: `[...map.values()]` produces the exact same array order
+ *      as the full-rewrite saveState().
+ *
+ * Crash recovery: the last line of the delta log may be torn. If JSON.parse
+ * fails AND it is the last line, we treat it as a torn tail and discard it.
+ * A CRC mismatch on a non-final line is corruption → throws in strict mode.
+ */
+export declare function replayDeltas(baseState: LocalGraphState, records: DeltaRecord[], epoch: number): LocalGraphState;
+export interface DeltaParseResult {
+    records: DeltaRecord[];
+    /** Byte offset (exclusive end) of the last valid, newline-terminated record. */
+    validBytes: number;
+    /** True when a trailing, non-newline-terminated partial record was detected. */
+    torn: boolean;
+}
+export interface DeltaLoadResult {
+    state: LocalGraphState;
+    epoch: number;
+    lastSeq: number;
+    deltaOpCount: number;
+    /** Byte offset of the last valid record == where the next append lands. */
+    validBytes: number;
+}
+/**
+ * Full cold load in delta mode: manifest → snapshot → replay delta tail.
+ *
+ * Torn-tail recovery: if the log ends in a partial (non-newline-terminated)
+ * record, physically truncate the file to the last valid record boundary BEFORE
+ * returning, so the next O_APPEND write can never merge into the half-written
+ * line. Any cached append fd is closed first to drop the stale handle.
+ */
+export declare function loadStateViaDelta(graphPath: string, strict: boolean, emptyState: LocalGraphState): Promise<DeltaLoadResult>;
+/**
+ * One-time setup: load legacy graph-state.json (or empty), write snapshot,
+ * write manifest, create empty delta log. Does NOT delete the legacy file.
+ * If manifest already exists, this is a no-op.
+ */
+export declare function setupDeltaMode(graphPath: string, legacyState: LocalGraphState): Promise<DeltaManifest>;
+export interface CompactionThresholds {
+    maxBytes: number;
+    maxOps: number;
+}
+export declare function resolveCompactionThresholds(env?: NodeJS.ProcessEnv): CompactionThresholds;
+/**
+ * Check if compaction is needed and perform it if so.
+ * Procedure: write snapshot → write new manifest (commit pivot) → truncate delta.
+ * The manifest is the single commit point; crash before manifest pivot is safe.
+ */
+export declare function compactIfNeeded(graphPath: string, state: LocalGraphState, currentEpoch: number, currentOpCount: number, thresholds: CompactionThresholds): Promise<{
+    compacted: boolean;
+    newEpoch: number;
+    newOpCount: number;
+}>;
+export interface DeltaFileStats {
+    snapshotMtimeMs: number;
+    snapshotSize: number;
+    snapshotCtimeMs: number;
+    snapshotIno: number;
+    deltaSize: number;
+}
+export declare function statDeltaFiles(graphPath: string): DeltaFileStats | null;
+export declare function deltaStatsMatch(a: DeltaFileStats | null, b: DeltaFileStats | null): boolean;
+export declare function acquireDeltaLock(graphPath: string, maxWaitMs?: number): Promise<void>;
+export declare function releaseDeltaLock(graphPath: string): void;
+export declare function withDeltaLock<T>(graphPath: string, fn: () => Promise<T>, env?: NodeJS.ProcessEnv, maxWaitMs?: number): Promise<T>;