open-multi-agent-kit 0.78.0 → 0.78.1

package/dist/commands/team.js

@@ -8,7 +8,45 @@ import { join } from "path";
 import { refreshRunStateEstimate } from "../orchestration/run-state.js";
 import { createInteractiveRunState as createParallelRunState } from "./parallel/orchestrator.js";
 import { ensureCompletionArtifactContract } from "../orchestration/completion-artifacts.js";
+import { createOmkJsonEnvelope } from "../util/json-envelope.js";
+import { emitJson } from "../util/cli-contract.js";
+/**
+ * JSON path for `omk team --json`.
+ * Read-only describe: reports the expected team layout for the resolved run
+ * WITHOUT spawning or attaching tmux, so stdout stays exactly one
+ * omk.contract.v1 envelope (no banner, no ANSI) and never blocks/exits.
+ */
+async function emitTeamJson(options) {
+    const started = Date.now();
+    const root = getProjectRoot();
+    const resources = await getOmkResourceSettings();
+    const workerCount = normalizeWorkerCount(options.workers, resources.maxWorkers);
+    const runId = options.runId ?? `team-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+    const statePath = getRunPath(runId, "state.json", root);
+    const expected = buildExpectedTeamRuntimeStatus("omk-team", statePath, workerCount, "starting");
+    const data = {
+        teamId: runId,
+        members: expected.windows.map((window) => ({
+            name: window.name,
+            role: window.role,
+            nodeId: window.nodeId,
+        })),
+        statePath,
+    };
+    emitJson(createOmkJsonEnvelope({
+        command: "team",
+        status: "passed",
+        ok: true,
+        runId,
+        data,
+        durationMs: Date.now() - started,
+    }));
+}
 export async function teamCommand(options = {}) {
+    if (options.json === true || process.argv.includes("--json")) {
+        await emitTeamJson(options);
+        return;
+    }
     const root = getProjectRoot();
     const resources = await getOmkResourceSettings();
     const workerCount = normalizeWorkerCount(options.workers, resources.maxWorkers);

package/dist/contracts/provider-health.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared, provider-neutral health shape.
+ *
+ * This contract is intentionally additive: it is embedded alongside the
+ * existing `omk provider doctor <x> --json` payloads without removing or
+ * renaming any pre-existing keys. It never carries secret values — only
+ * boolean signals (e.g. `authOk`) and non-sensitive remediation hints.
+ */
+/** Classified failure category for a provider health check. */
+export type ProviderFailureKind = "none" | "runtime" | "auth" | "model" | "quota" | "policy" | "transient" | "unknown";
+/** Authority level a provider holds for a given capability lane. */
+export type ProviderAuthorityLevel = "none" | "advisory" | "direct" | "full";
+/**
+ * Normalized provider health snapshot.
+ *
+ * All fields are required so consumers can rely on a stable shape regardless
+ * of which provider produced it.
+ */
+export interface ProviderHealth {
+    /** Provider id (e.g. "kimi", "deepseek", "codex"). */
+    provider: string;
+    /** ISO-8601 timestamp of when the health snapshot was produced. */
+    checkedAt: string;
+    /** Runtime/transport reachable and enabled. */
+    runtimeOk: boolean;
+    /** Authentication satisfied (API key present or externally managed auth). */
+    authOk: boolean;
+    /** A resolvable default model is configured. */
+    modelOk: boolean;
+    /** No known quota/balance/rate-limit blocker. */
+    quotaOk: boolean;
+    /** Authority to perform write/merge work. */
+    writeAuthority: ProviderAuthorityLevel;
+    /** Authority to run shell/CLI work. */
+    shellAuthority: ProviderAuthorityLevel;
+    /** Authority to drive MCP tools. */
+    mcpAuthority: ProviderAuthorityLevel;
+    /** Classified failure category ("none" when healthy). */
+    failureKind: ProviderFailureKind;
+    /** Non-sensitive remediation hints (never includes secret values). */
+    remediation: string[];
+}

package/dist/contracts/provider-health.js

@@ -0,0 +1,9 @@
+/**
+ * Shared, provider-neutral health shape.
+ *
+ * This contract is intentionally additive: it is embedded alongside the
+ * existing `omk provider doctor <x> --json` payloads without removing or
+ * renaming any pre-existing keys. It never carries secret values — only
+ * boolean signals (e.g. `authOk`) and non-sensitive remediation hints.
+ */
+export {};

package/dist/goal/intent-frame.d.ts

@@ -1,6 +1,7 @@
 import type { ActionAtom, ActionAtomVerb, GoalEvidence, GoalSpec, IntentFrame, NextActionContract, PromptNoveltyReport } from "../contracts/goal.js";
 import type { DagNodeRouting } from "../orchestration/dag.js";
 import type { NextAction, RunState } from "../contracts/orchestration.js";
+import type { OuroborosDecision } from "../runtime/ouroboros-policy.js";
 export declare function buildIntentFrame(rawPrompt: string, input?: {
     constraints?: string[];
     successCriteria?: string[];
@@ -10,6 +11,29 @@ export declare function buildIntentFrame(rawPrompt: string, input?: {
     }>;
 }): IntentFrame;
 export declare function buildIntentFrameFromGoal(goal: GoalSpec): IntentFrame;
+/**
+ * IntentFrame enriched with an advisory Ouroboros routing decision.
+ * The existing IntentFrame shape is unchanged; the optional ouroboros
+ * field is additive and consumed only by callers that understand it.
+ */
+export type IntentFrameWithOuroboros = IntentFrame & {
+    ouroboros?: OuroborosDecision;
+};
+/**
+ * Build an IntentFrame and, for goal/spec/orchestration intents,
+ * attach a non-fatal Ouroboros routing decision.
+ *
+ * The base IntentFrame fields are never modified; the ouroboros hint
+ * is purely advisory.
+ */
+export declare function buildIntentFrameWithOuroboros(rawPrompt: string, input?: {
+    constraints?: string[];
+    successCriteria?: string[];
+    expectedArtifacts?: Array<{
+        name: string;
+        path?: string;
+    }>;
+}): Promise<IntentFrameWithOuroboros>;
 export declare function actionAtomRouting(atom: ActionAtom): NonNullable<DagNodeRouting["actionAtom"]>;
 export declare function renderActionDigest(frame: IntentFrame, options?: {
     maxAtoms?: number;

package/dist/goal/intent-frame.js

@@ -1,4 +1,5 @@
 import { extractPromptKeywords, promptDigestFingerprint } from "./prompt-digest.js";
+import { resolveOuroborosDecision } from "../runtime/ouroboros-policy.js";
 const TOKEN_PATTERN = /[\p{L}\p{N}_-]+/gu;
 const REPLAY_PATTERN = /repeat|replay|verbatim|same prompt|original objective|original goal|raw input|원문|반복|재사용|그대로/u;
 const REPLAY_THRESHOLD = 0.72;
@@ -51,6 +52,23 @@ export function buildIntentFrameFromGoal(goal) {
         expectedArtifacts: goal.expectedArtifacts,
     });
 }
+/**
+ * Build an IntentFrame and, for goal/spec/orchestration intents,
+ * attach a non-fatal Ouroboros routing decision.
+ *
+ * The base IntentFrame fields are never modified; the ouroboros hint
+ * is purely advisory.
+ */
+export async function buildIntentFrameWithOuroboros(rawPrompt, input = {}) {
+    const frame = buildIntentFrame(rawPrompt, input);
+    try {
+        const decision = await resolveOuroborosDecision({ intent: rawPrompt });
+        return { ...frame, ouroboros: decision };
+    }
+    catch {
+        return frame;
+    }
+}
 export function actionAtomRouting(atom) {
     return {
         id: atom.id,

package/dist/memory/local-graph-memory-store.d.ts

@@ -1,4 +1,5 @@
 import { type MemorySettings, type MemoryStatus } from "./memory-config.js";
+import type { RunManifest } from "../contracts/run.js";
 export interface MemorySearchResult {
     path: string;
     content: string;
@@ -114,6 +115,20 @@ export declare class LocalGraphMemoryStore {
     search(query: string, limit?: number): Promise<MemorySearchResult[]>;
     ontology(): Promise<MemoryOntology>;
     mindmap(query?: string, limit?: number): Promise<MemoryMindmap>;
+    /**
+     * Idempotent finalizer that links a finalized run manifest into the local
+     * graph. Emits run -> providerRoute -> provider, run -> evidence,
+     * run -> decision, and run -> artifact nodes/edges.
+     *
+     * Privacy: only ids, status, paths, sha256, and aggregate counts are stored.
+     * Raw evidence/decision message bodies and secrets are never persisted.
+     *
+     * Idempotency: node/edge ids are deterministic and prior run-generated
+     * nodes/edges (tagged `generatedFromRun`) are pruned before re-inserting, so
+     * re-running with the same (or a changed) manifest never duplicates state.
+     */
+    linkRun(runId: string, manifest: RunManifest): Promise<void>;
+    private applyRunManifest;
     graphQuery(query: string): Promise<GraphQueryResult>;
     private loadState;
     private emptyState;

package/dist/memory/local-graph-memory-store.js

@@ -339,6 +339,182 @@ export class LocalGraphMemoryStore {
         const root = this.buildMindmapTree(rootNode, state, includedIds, new Set());
         return { root, nodes: flatNodes, edges, ontology: ONTOLOGY };
     }
+    /**
+     * Idempotent finalizer that links a finalized run manifest into the local
+     * graph. Emits run -> providerRoute -> provider, run -> evidence,
+     * run -> decision, and run -> artifact nodes/edges.
+     *
+     * Privacy: only ids, status, paths, sha256, and aggregate counts are stored.
+     * Raw evidence/decision message bodies and secrets are never persisted.
+     *
+     * Idempotency: node/edge ids are deterministic and prior run-generated
+     * nodes/edges (tagged `generatedFromRun`) are pruned before re-inserting, so
+     * re-running with the same (or a changed) manifest never duplicates state.
+     */
+    async linkRun(runId, manifest) {
+        const canonicalRunId = manifest.runId || runId;
+        if (runId && manifest.runId && runId !== manifest.runId) {
+            throw new Error(`linkRun: runId mismatch (param=${runId}, manifest=${manifest.runId})`);
+        }
+        await this.mutateState((state, now) => {
+            this.applyRunManifest(state, canonicalRunId, manifest, now);
+        });
+    }
+    applyRunManifest(state, runId, manifest, now) {
+        state.updatedAt = now;
+        state.project = { ...this.settings.project };
+        state.ontology = ONTOLOGY;
+        // Prune prior run-generated child nodes/edges for idempotent re-runs. The
+        // Run node and shared Provider nodes are intentionally not pruned (the Run
+        // node is re-upserted preserving createdAt; Providers are shared by runs).
+        const staleNodeIds = new Set(state.nodes.filter((node) => node.properties.generatedFromRun === runId).map((node) => node.id));
+        state.nodes = state.nodes.filter((node) => !staleNodeIds.has(node.id));
+        state.edges = state.edges.filter((edge) => edge.properties.generatedFromRun !== runId && !staleNodeIds.has(edge.from) && !staleNodeIds.has(edge.to));
+        const tag = { generatedFromRun: runId };
+        const projectId = this.nodeId("Project", this.settings.project.key);
+        this.upsertNode(state, {
+            id: projectId,
+            type: "Project",
+            labels: ["OmkProject", "Project"],
+            label: this.settings.project.name,
+            summary: this.settings.project.root,
+            tags: ["project"],
+            properties: { key: this.settings.project.key, root: this.settings.project.root },
+            createdAt: now,
+            updatedAt: now,
+        });
+        const runNodeId = this.nodeId("Run", runId);
+        this.upsertNode(state, {
+            id: runNodeId,
+            type: "Run",
+            labels: ["OmkRun", "Run"],
+            label: runId,
+            summary: `Run ${runId} (${manifest.status})`,
+            tags: ["run", manifest.status],
+            properties: {
+                runId,
+                status: manifest.status,
+                schemaVersion: manifest.schemaVersion,
+                createdAt: manifest.createdAt,
+                completedAt: manifest.completedAt ?? null,
+                promptHash: manifest.promptHash ?? null,
+                decisionTracePath: manifest.decisionTracePath ?? null,
+                evidenceRequired: manifest.evidenceSummary.required,
+                evidencePassed: manifest.evidenceSummary.passed,
+                evidenceFailed: manifest.evidenceSummary.failed,
+                evidenceMissing: manifest.evidenceSummary.missing,
+                nodeCount: manifest.nodes.length,
+                artifactCount: manifest.artifacts.length,
+                projectKey: this.settings.project.key,
+                source: this.source,
+            },
+            createdAt: now,
+            updatedAt: now,
+        });
+        this.upsertEdge(state, projectId, runNodeId, "HAS_RUN", now, tag);
+        // Provider route -> provider.
+        const provider = manifest.providerPolicy.provider;
+        const mode = manifest.providerPolicy.mode ?? "auto";
+        const routeNodeId = this.nodeId("ProviderRoute", `${runId}:${provider}:${mode}`);
+        this.upsertNode(state, {
+            id: routeNodeId,
+            type: "ProviderRoute",
+            labels: ["OmkProviderRoute", "ProviderRoute"],
+            label: `${provider} (${mode})`,
+            summary: `Provider route for run ${runId}`,
+            tags: ["provider-route", provider, mode],
+            properties: { runId, provider, mode, projectKey: this.settings.project.key, generatedFromRun: runId },
+            createdAt: now,
+            updatedAt: now,
+        });
+        this.upsertEdge(state, runNodeId, routeNodeId, "HAS_PROVIDER_ROUTE", now, tag);
+        const providerNodeId = this.nodeId("Provider", provider);
+        this.upsertNode(state, {
+            id: providerNodeId,
+            type: "Provider",
+            labels: ["OmkProvider", "Provider"],
+            label: provider,
+            summary: `Provider ${provider}`,
+            tags: ["provider", provider],
+            properties: { provider, projectKey: this.settings.project.key },
+            createdAt: now,
+            updatedAt: now,
+        });
+        this.upsertEdge(state, routeNodeId, providerNodeId, "ROUTES_TO", now, tag);
+        // Evidence summary node (counts/paths/sha only — never raw bodies).
+        const evidenceArtifact = manifest.artifacts.find((artifact) => artifact.kind === "evidence" || /(^|\/)evidence\.jsonl$/i.test(artifact.path));
+        const evidenceNodeId = this.nodeId("Evidence", `${runId}:evidence`);
+        this.upsertNode(state, {
+            id: evidenceNodeId,
+            type: "Evidence",
+            labels: ["OmkEvidence", "Evidence"],
+            label: `evidence:${runId}`,
+            summary: `Evidence ${manifest.evidenceSummary.passed}/${manifest.evidenceSummary.required} passed`,
+            tags: ["evidence", manifest.status],
+            properties: {
+                runId,
+                required: manifest.evidenceSummary.required,
+                passed: manifest.evidenceSummary.passed,
+                failed: manifest.evidenceSummary.failed,
+                missing: manifest.evidenceSummary.missing,
+                path: evidenceArtifact?.path ?? null,
+                sha256: evidenceArtifact?.sha256 ?? null,
+                projectKey: this.settings.project.key,
+                generatedFromRun: runId,
+            },
+            createdAt: now,
+            updatedAt: now,
+        });
+        this.upsertEdge(state, runNodeId, evidenceNodeId, "HAS_EVIDENCE", now, tag);
+        // Decision trace node (path/sha only — never raw bodies).
+        const decisionArtifact = manifest.artifacts.find((artifact) => artifact.kind === "decision" ||
+            artifact.kind === "decisions" ||
+            /(^|\/)decisions\.jsonl$/i.test(artifact.path));
+        const decisionPath = manifest.decisionTracePath ?? decisionArtifact?.path ?? null;
+        const decisionNodeId = this.nodeId("Decision", `${runId}:decision`);
+        this.upsertNode(state, {
+            id: decisionNodeId,
+            type: "Decision",
+            labels: ["OmkDecision", "Decision"],
+            label: `decisions:${runId}`,
+            summary: `Decision trace for run ${runId}`,
+            tags: ["decision", manifest.status],
+            properties: {
+                runId,
+                path: decisionPath,
+                sha256: decisionArtifact?.sha256 ?? null,
+                projectKey: this.settings.project.key,
+                generatedFromRun: runId,
+            },
+            createdAt: now,
+            updatedAt: now,
+        });
+        this.upsertEdge(state, runNodeId, decisionNodeId, "HAS_DECISION", now, tag);
+        // Artifacts -> File/Artifact nodes (id/kind/path/sha only).
+        for (const artifact of manifest.artifacts) {
+            const artifactNodeId = this.nodeId("Artifact", `${runId}:${artifact.kind}:${artifact.path}`);
+            this.upsertNode(state, {
+                id: artifactNodeId,
+                type: "Artifact",
+                labels: ["OmkArtifact", "Artifact", "File"],
+                label: artifact.path,
+                path: artifact.path,
+                summary: `${artifact.kind} artifact`,
+                tags: ["artifact", artifact.kind, ...pathTags(artifact.path)],
+                properties: {
+                    runId,
+                    kind: artifact.kind,
+                    path: artifact.path,
+                    sha256: artifact.sha256 ?? null,
+                    projectKey: this.settings.project.key,
+                    generatedFromRun: runId,
+                },
+                createdAt: now,
+                updatedAt: now,
+            });
+            this.upsertEdge(state, runNodeId, artifactNodeId, "TOUCHES_FILE", now, tag);
+        }
+    }
     async graphQuery(query) {
         const normalized = query.replace(/\s+/g, " ").trim();
         const data = {};

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

@@ -1,6 +1,7 @@
 import { type MemoryStatus } from "./memory-config.js";
 import type { GraphQueryResult, MemoryMindmap, MemoryOntology, MemorySearchResult } from "./local-graph-memory-store.js";
 import type { MemoryBackend } from "./memory-config.js";
+import type { RunManifest } from "../contracts/run.js";
 export interface MemoryStoreOptions {
     projectRoot?: string;
     sessionId?: string;
@@ -19,7 +20,24 @@ export interface UnifiedMemoryStore {
     ontology?: () => Promise<MemoryOntology | null>;
     mindmap?: (query?: string, limit?: number) => Promise<MemoryMindmap | null>;
     graphQuery?: (query: string) => Promise<GraphQueryResult>;
+    linkRun?: (runId: string, manifest: RunManifest) => Promise<void>;
 }
+export interface LinkRunToGraphOptions {
+    projectRoot?: string;
+    sessionId?: string;
+    source?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Idempotent, non-fatal finalizer: links a finalized run manifest into the
+ * local graph memory backend. Returns true when the active backend linked the
+ * run, false when no graph backend is available (e.g. file-only backend).
+ *
+ * Only ids/status/paths/sha256/counts are persisted — never raw evidence or
+ * decision bodies, and never secrets. Callers should still wrap this in their
+ * own try/catch so a graph write failure can never fail a run.
+ */
+export declare function linkRunToGraph(runId: string, manifest: RunManifest, options?: LinkRunToGraphOptions): Promise<boolean>;
 export declare function createMemoryStore(backend: MemoryBackend, options?: MemoryStoreOptions): Promise<UnifiedMemoryStore | null>;
 export declare class MemoryStore {
     private readonly options;

package/dist/memory/memory-store.js

@@ -2,6 +2,24 @@ import { readFile, writeFile, mkdir } from "fs/promises";
 import { join, dirname, resolve, relative, isAbsolute } from "path";
 import { getProjectRoot } from "../util/fs.js";
 import { loadMemorySettings, summarizeMemorySettings, } from "./memory-config.js";
+import { loadMemorySettings as loadMemorySettingsForLink } from "./memory-config.js";
+/**
+ * Idempotent, non-fatal finalizer: links a finalized run manifest into the
+ * local graph memory backend. Returns true when the active backend linked the
+ * run, false when no graph backend is available (e.g. file-only backend).
+ *
+ * Only ids/status/paths/sha256/counts are persisted — never raw evidence or
+ * decision bodies, and never secrets. Callers should still wrap this in their
+ * own try/catch so a graph write failure can never fail a run.
+ */
+export async function linkRunToGraph(runId, manifest, options = {}) {
+    const settings = await loadMemorySettingsForLink(options.projectRoot, options.env);
+    const store = await createMemoryStore(settings.backend, options);
+    if (!store || typeof store.linkRun !== "function")
+        return false;
+    await store.linkRun(runId, manifest);
+    return true;
+}
 export async function createMemoryStore(backend, options = {}) {
     if (backend === "local_graph") {
         const { LocalGraphMemoryStore } = await import("./local-graph-memory-store.js");

package/dist/orchestration/adaptorch-topology.d.ts

@@ -0,0 +1,59 @@
+/**
+ * AdaptOrch-style topology router — pure TS, no IO, no python dependency.
+ *
+ * Extracts 5 structural features from a DAG and selects an execution topology
+ * using threshold-based rules matching the AdaptOrch TopologyRouter spec.
+ */
+export type DagTopology = "singleton" | "parallel" | "pipeline" | "map_reduce" | "hierarchical" | "dag" | "hybrid";
+export interface TopologyFeatures {
+    nodeCount: number;
+    edgeCount: number;
+    width: number;
+    criticalDepth: number;
+    couplingDensity: number;
+    parallelRatio: number;
+}
+export interface TopologyDecision {
+    topology: DagTopology;
+    reason: string;
+    features: TopologyFeatures;
+    waves: string[][];
+}
+export interface TopologyThresholds {
+    /** θ_ω — parallel ratio threshold (default 0.5) */
+    parallelRatio: number;
+    /** θ_γ — coupling density considered "high" (default 0.6) */
+    highCoupling: number;
+    /** θ_δ — node count threshold for hierarchical (default 5) */
+    hierarchicalSubtasks: number;
+}
+/**
+ * Returns `true` unless OMK_ADAPTORCH_ROUTING is explicitly off/0/false.
+ */
+export declare function isAdaptorchRoutingEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * Compute structural features of a DAG via Kahn topological sort.
+ * Returns layers (waves) and derived metrics.  If a cycle is detected,
+ * all nodes collapse into a single wave.
+ */
+export declare function computeTopologyFeatures(nodes: string[], edges: Array<{
+    from: string;
+    to: string;
+}>): TopologyFeatures & {
+    layers: string[][];
+};
+/**
+ * Select a topology and emit layered execution waves.
+ *
+ * Selection rules (in priority order):
+ *   0 nodes       → singleton
+ *   1 node        → singleton
+ *   high coupling → dag (if depth==1) or hierarchical (if depth>1)
+ *   parallelRatio ≥ θ_ω and nodes > 1 → parallel / map_reduce
+ *   criticalDepth == nodes → pipeline
+ *   otherwise     → hybrid
+ */
+export declare function routeTopology(nodeIds: string[], edges: Array<{
+    from: string;
+    to: string;
+}>, thresholds?: Partial<TopologyThresholds>): TopologyDecision;