@jmanuelcorral/openteam 0.2.0 → 0.2.2

package/dist/cli.js

@@ -10,11 +10,187 @@ import { promisify } from "node:util";
 // src/cli/consoleServe.ts
 import { randomBytes } from "node:crypto";
 
-// src/console/protocol.ts
+// src/config/schema.ts
 import { z } from "zod";
+var ModelRefSchema = z.object({
+  providerID: z.string().min(1),
+  modelID: z.string().min(1)
+});
+var RouterModeSchema = z.enum(["economy", "balanced", "quality"]);
+var PrivacyModeSchema = z.enum([
+  "forceLocalOnSensitive",
+  "consentBeforeFrontier",
+  "off"
+]);
+var BaselineModeSchema = z.enum(["auto", "pinned"]);
+var GraphModeSchema = z.enum(["off", "shadow", "active"]);
+var DEFAULT_GRAPH_JOURNAL_ROOT = ".opencode/openteam/graph/runs";
+var GraphConfigSchema = z.object({
+  mode: GraphModeSchema.default("off"),
+  killSwitch: z.boolean().default(false),
+  journalRoot: z.string().min(1).default(DEFAULT_GRAPH_JOURNAL_ROOT),
+  operatorApproval: z.boolean().default(false),
+  worktrees: z.object({
+    enabled: z.boolean().default(false)
+  }).default({ enabled: false })
+});
+var ConsoleHostSchema = z.enum(["127.0.0.1", "localhost"]);
+var ConsoleConfigSchema = z.object({
+  host: ConsoleHostSchema.default("127.0.0.1"),
+  port: z.number().int().min(1024).max(65535).default(4599),
+  autoPortFallback: z.boolean().default(true),
+  refreshMs: z.number().int().min(250).default(2000),
+  recentRoutes: z.number().int().positive().default(50),
+  openBrowser: z.boolean().default(false),
+  remoteStorage: z.boolean().default(false),
+  terminal: z.object({
+    enabled: z.boolean().default(true),
+    pty: z.boolean().optional()
+  }).default({ enabled: true }),
+  graphView: z.object({
+    enabled: z.boolean().default(false)
+  }).optional()
+}).default({
+  host: "127.0.0.1",
+  port: 4599,
+  autoPortFallback: true,
+  refreshMs: 2000,
+  recentRoutes: 50,
+  openBrowser: false,
+  remoteStorage: false,
+  terminal: { enabled: true }
+});
+var StorageConfigSchema = z.object({
+  sqliteIndex: z.object({
+    enabled: z.boolean().default(false),
+    path: z.string().min(1).default(".opencode/openteam/index.sqlite")
+  }).default({ enabled: false, path: ".opencode/openteam/index.sqlite" })
+}).default({
+  sqliteIndex: { enabled: false, path: ".opencode/openteam/index.sqlite" }
+});
+var defaultLocalModel = {
+  providerID: "ollama",
+  modelID: "qwen3:8b"
+};
+var defaultFrontierModel = {
+  providerID: "anthropic",
+  modelID: "claude-sonnet-4-5"
+};
+var LocalRuntimeSchema = z.object({
+  id: z.enum(["ollama", "lmstudio", "foundry-local"]),
+  enabled: z.boolean().default(true),
+  baseURL: z.string().url().optional(),
+  discovery: z.enum(["cli", "sdk", "manual"]).optional(),
+  defaultModel: ModelRefSchema
+});
+var MemoryScopeSchema = z.enum(["project", "user"]);
+var MemoryExtractionModeSchema = z.enum([
+  "local",
+  "localWithFrontierFallback"
+]);
+var MemoryEmbeddingsProviderSchema = z.enum(["local", "none"]);
+var MemorySemanticSchema = z.object({
+  enabled: z.boolean().default(false),
+  storeContent: z.boolean().default(false),
+  logPath: z.string().min(1).default(".opencode/openteam/memory/records.jsonl"),
+  indexPath: z.string().min(1).default(".opencode/openteam/memory/index.sqlite"),
+  scope: MemoryScopeSchema.default("project"),
+  extraction: z.object({
+    mode: MemoryExtractionModeSchema.default("local"),
+    model: ModelRefSchema.nullable().default(null)
+  }).default({ mode: "local", model: null }),
+  embeddings: z.object({
+    provider: MemoryEmbeddingsProviderSchema.default("local"),
+    model: ModelRefSchema.nullable().default(null),
+    dim: z.number().int().positive().default(768)
+  }).default({ provider: "local", model: null, dim: 768 }),
+  recall: z.object({
+    maxResults: z.number().int().positive().default(8),
+    minSimilarity: z.number().min(0).max(1).default(0.2)
+  }).default({ maxResults: 8, minSimilarity: 0.2 }),
+  injection: z.object({
+    enabled: z.boolean().default(false),
+    maxChars: z.number().int().positive().default(1200),
+    maxItems: z.number().int().positive().default(8)
+  }).default({ enabled: false, maxChars: 1200, maxItems: 8 })
+}).default({
+  enabled: false,
+  storeContent: false,
+  logPath: ".opencode/openteam/memory/records.jsonl",
+  indexPath: ".opencode/openteam/memory/index.sqlite",
+  scope: "project",
+  extraction: { mode: "local", model: null },
+  embeddings: { provider: "local", model: null, dim: 768 },
+  recall: { maxResults: 8, minSimilarity: 0.2 },
+  injection: { enabled: false, maxChars: 1200, maxItems: 8 }
+});
+var MemoryConfigSchema = z.object({
+  semantic: MemorySemanticSchema
+});
+var OpenTeamConfigObjectSchema = z.object({
+  baseline: z.object({
+    mode: BaselineModeSchema.default("auto"),
+    pinnedModel: ModelRefSchema.nullable().default(null),
+    hardDefault: ModelRefSchema.default(defaultFrontierModel)
+  }).default({
+    mode: "auto",
+    pinnedModel: null,
+    hardDefault: defaultFrontierModel
+  }),
+  router: z.object({
+    mode: RouterModeSchema.default("balanced"),
+    localDefault: ModelRefSchema.default(defaultLocalModel),
+    trivialPromptMaxChars: z.number().int().positive().default(280),
+    frontierPromptMinChars: z.number().int().positive().default(2000),
+    frontierOnly: z.boolean().default(false)
+  }).default({
+    mode: "balanced",
+    localDefault: defaultLocalModel,
+    trivialPromptMaxChars: 280,
+    frontierPromptMinChars: 2000,
+    frontierOnly: false
+  }),
+  local: z.object({
+    runtimes: z.array(LocalRuntimeSchema).min(1).default([
+      {
+        id: "ollama",
+        enabled: true,
+        baseURL: "http://localhost:11434/v1",
+        defaultModel: { providerID: "ollama", modelID: "qwen3:8b" }
+      }
+    ])
+  }).default({
+    runtimes: [
+      {
+        id: "ollama",
+        enabled: true,
+        baseURL: "http://localhost:11434/v1",
+        defaultModel: defaultLocalModel
+      }
+    ]
+  }),
+  budgets: z.object({
+    sessionUSD: z.number().positive().optional(),
+    monthlyUSD: z.number().positive().optional(),
+    frontierTokensPerSession: z.number().int().positive().optional(),
+    hardStopOnBudgetExhaustion: z.boolean().default(false)
+  }).default({ hardStopOnBudgetExhaustion: false }),
+  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
+  console: ConsoleConfigSchema,
+  storage: StorageConfigSchema,
+  memory: MemoryConfigSchema.optional(),
+  graph: GraphConfigSchema.optional()
+});
+var OpenTeamConfigSchema = OpenTeamConfigObjectSchema;
+function resolveMemorySemantic(config) {
+  return config.memory?.semantic ?? MemorySemanticSchema.parse(undefined);
+}
+
+// src/console/protocol.ts
+import { z as z2 } from "zod";
 var MAX_INPUT_CHARS = 1e5;
-var SessionInputSchema = z.object({
-  text: z.string().min(1).max(MAX_INPUT_CHARS)
+var SessionInputSchema = z2.object({
+  text: z2.string().min(1).max(MAX_INPUT_CHARS)
 });
 function parseSessionInput(raw) {
   const result = SessionInputSchema.safeParse(raw);
@@ -623,214 +799,40 @@ function splitVirtualPath(path) {
 import { z as z4 } from "zod";
 
 // src/capabilities/types.ts
-import { z as z2 } from "zod";
-var CapabilityTierSchema = z2.union([
-  z2.literal(0),
-  z2.literal(1),
-  z2.literal(2),
-  z2.literal(3),
-  z2.literal(4),
-  z2.literal(5)
+import { z as z3 } from "zod";
+var CapabilityTierSchema = z3.union([
+  z3.literal(0),
+  z3.literal(1),
+  z3.literal(2),
+  z3.literal(3),
+  z3.literal(4),
+  z3.literal(5)
 ]);
-var ComplexityTierSchema = z2.enum([
+var ComplexityTierSchema = z3.enum([
   "trivial",
   "simple",
   "moderate",
   "hard"
 ]);
-var ModelCapabilityProfileSchema = z2.object({
-  ref: z2.object({
-    providerID: z2.string().min(1),
-    modelID: z2.string().min(1)
+var ModelCapabilityProfileSchema = z3.object({
+  ref: z3.object({
+    providerID: z3.string().min(1),
+    modelID: z3.string().min(1)
   }),
-  kind: z2.enum(["local", "frontier", "router"]),
-  contextWindow: z2.number().int().positive(),
-  maxOutputTokens: z2.number().int().positive(),
-  supportsToolCalling: z2.boolean(),
-  supportsVision: z2.boolean(),
+  kind: z3.enum(["local", "frontier", "router"]),
+  contextWindow: z3.number().int().positive(),
+  maxOutputTokens: z3.number().int().positive(),
+  supportsToolCalling: z3.boolean(),
+  supportsVision: z3.boolean(),
   reasoningTier: CapabilityTierSchema,
   codeQualityTier: CapabilityTierSchema,
-  costPer1M: z2.object({
-    inputUSD: z2.number().min(0),
-    outputUSD: z2.number().min(0)
+  costPer1M: z3.object({
+    inputUSD: z3.number().min(0),
+    outputUSD: z3.number().min(0)
   }),
-  availability: z2.enum(["available", "degraded", "unavailable"])
+  availability: z3.enum(["available", "degraded", "unavailable"])
 });
 
-// src/config/schema.ts
-import { z as z3 } from "zod";
-var ModelRefSchema = z3.object({
-  providerID: z3.string().min(1),
-  modelID: z3.string().min(1)
-});
-var RouterModeSchema = z3.enum(["economy", "balanced", "quality"]);
-var PrivacyModeSchema = z3.enum([
-  "forceLocalOnSensitive",
-  "consentBeforeFrontier",
-  "off"
-]);
-var BaselineModeSchema = z3.enum(["auto", "pinned"]);
-var GraphModeSchema = z3.enum(["off", "shadow", "active"]);
-var GraphConfigSchema = z3.object({
-  mode: GraphModeSchema.default("off"),
-  killSwitch: z3.boolean().default(false),
-  operatorApproval: z3.boolean().default(false),
-  worktrees: z3.object({
-    enabled: z3.boolean().default(false)
-  }).default({ enabled: false })
-});
-var ConsoleHostSchema = z3.enum(["127.0.0.1", "localhost"]);
-var ConsoleConfigSchema = z3.object({
-  host: ConsoleHostSchema.default("127.0.0.1"),
-  port: z3.number().int().min(1024).max(65535).default(4599),
-  autoPortFallback: z3.boolean().default(true),
-  refreshMs: z3.number().int().min(250).default(2000),
-  recentRoutes: z3.number().int().positive().default(50),
-  openBrowser: z3.boolean().default(false),
-  remoteStorage: z3.boolean().default(false),
-  terminal: z3.object({
-    enabled: z3.boolean().default(true),
-    pty: z3.boolean().optional()
-  }).default({ enabled: true }),
-  graphView: z3.object({
-    enabled: z3.boolean().default(false)
-  }).optional()
-}).default({
-  host: "127.0.0.1",
-  port: 4599,
-  autoPortFallback: true,
-  refreshMs: 2000,
-  recentRoutes: 50,
-  openBrowser: false,
-  remoteStorage: false,
-  terminal: { enabled: true }
-});
-var StorageConfigSchema = z3.object({
-  sqliteIndex: z3.object({
-    enabled: z3.boolean().default(false),
-    path: z3.string().min(1).default(".opencode/openteam/index.sqlite")
-  }).default({ enabled: false, path: ".opencode/openteam/index.sqlite" })
-}).default({
-  sqliteIndex: { enabled: false, path: ".opencode/openteam/index.sqlite" }
-});
-var defaultLocalModel = {
-  providerID: "ollama",
-  modelID: "qwen3:8b"
-};
-var defaultFrontierModel = {
-  providerID: "anthropic",
-  modelID: "claude-sonnet-4-5"
-};
-var LocalRuntimeSchema = z3.object({
-  id: z3.enum(["ollama", "lmstudio", "foundry-local"]),
-  enabled: z3.boolean().default(true),
-  baseURL: z3.string().url().optional(),
-  discovery: z3.enum(["cli", "sdk", "manual"]).optional(),
-  defaultModel: ModelRefSchema
-});
-var MemoryScopeSchema = z3.enum(["project", "user"]);
-var MemoryExtractionModeSchema = z3.enum([
-  "local",
-  "localWithFrontierFallback"
-]);
-var MemoryEmbeddingsProviderSchema = z3.enum(["local", "none"]);
-var MemorySemanticSchema = z3.object({
-  enabled: z3.boolean().default(false),
-  storeContent: z3.boolean().default(false),
-  logPath: z3.string().min(1).default(".opencode/openteam/memory/records.jsonl"),
-  indexPath: z3.string().min(1).default(".opencode/openteam/memory/index.sqlite"),
-  scope: MemoryScopeSchema.default("project"),
-  extraction: z3.object({
-    mode: MemoryExtractionModeSchema.default("local"),
-    model: ModelRefSchema.nullable().default(null)
-  }).default({ mode: "local", model: null }),
-  embeddings: z3.object({
-    provider: MemoryEmbeddingsProviderSchema.default("local"),
-    model: ModelRefSchema.nullable().default(null),
-    dim: z3.number().int().positive().default(768)
-  }).default({ provider: "local", model: null, dim: 768 }),
-  recall: z3.object({
-    maxResults: z3.number().int().positive().default(8),
-    minSimilarity: z3.number().min(0).max(1).default(0.2)
-  }).default({ maxResults: 8, minSimilarity: 0.2 }),
-  injection: z3.object({
-    enabled: z3.boolean().default(false),
-    maxChars: z3.number().int().positive().default(1200),
-    maxItems: z3.number().int().positive().default(8)
-  }).default({ enabled: false, maxChars: 1200, maxItems: 8 })
-}).default({
-  enabled: false,
-  storeContent: false,
-  logPath: ".opencode/openteam/memory/records.jsonl",
-  indexPath: ".opencode/openteam/memory/index.sqlite",
-  scope: "project",
-  extraction: { mode: "local", model: null },
-  embeddings: { provider: "local", model: null, dim: 768 },
-  recall: { maxResults: 8, minSimilarity: 0.2 },
-  injection: { enabled: false, maxChars: 1200, maxItems: 8 }
-});
-var MemoryConfigSchema = z3.object({
-  semantic: MemorySemanticSchema
-});
-var OpenTeamConfigObjectSchema = z3.object({
-  baseline: z3.object({
-    mode: BaselineModeSchema.default("auto"),
-    pinnedModel: ModelRefSchema.nullable().default(null),
-    hardDefault: ModelRefSchema.default(defaultFrontierModel)
-  }).default({
-    mode: "auto",
-    pinnedModel: null,
-    hardDefault: defaultFrontierModel
-  }),
-  router: z3.object({
-    mode: RouterModeSchema.default("balanced"),
-    localDefault: ModelRefSchema.default(defaultLocalModel),
-    trivialPromptMaxChars: z3.number().int().positive().default(280),
-    frontierPromptMinChars: z3.number().int().positive().default(2000),
-    frontierOnly: z3.boolean().default(false)
-  }).default({
-    mode: "balanced",
-    localDefault: defaultLocalModel,
-    trivialPromptMaxChars: 280,
-    frontierPromptMinChars: 2000,
-    frontierOnly: false
-  }),
-  local: z3.object({
-    runtimes: z3.array(LocalRuntimeSchema).min(1).default([
-      {
-        id: "ollama",
-        enabled: true,
-        baseURL: "http://localhost:11434/v1",
-        defaultModel: { providerID: "ollama", modelID: "qwen3:8b" }
-      }
-    ])
-  }).default({
-    runtimes: [
-      {
-        id: "ollama",
-        enabled: true,
-        baseURL: "http://localhost:11434/v1",
-        defaultModel: defaultLocalModel
-      }
-    ]
-  }),
-  budgets: z3.object({
-    sessionUSD: z3.number().positive().optional(),
-    monthlyUSD: z3.number().positive().optional(),
-    frontierTokensPerSession: z3.number().int().positive().optional(),
-    hardStopOnBudgetExhaustion: z3.boolean().default(false)
-  }).default({ hardStopOnBudgetExhaustion: false }),
-  privacyMode: PrivacyModeSchema.default("forceLocalOnSensitive"),
-  console: ConsoleConfigSchema,
-  storage: StorageConfigSchema,
-  memory: MemoryConfigSchema.optional(),
-  graph: GraphConfigSchema.optional()
-});
-var OpenTeamConfigSchema = OpenTeamConfigObjectSchema;
-function resolveMemorySemantic(config) {
-  return config.memory?.semantic ?? MemorySemanticSchema.parse(undefined);
-}
-
 // src/telemetry/events.ts
 var EVENT_SCHEMA_VERSION = 1;
 var EventBaseSchema = z4.object({
@@ -910,6 +912,17 @@ var SessionEndpointEventSchema = EventBaseSchema.extend({
   worktree: z4.string().min(1).optional(),
   title: z4.string().min(1).optional()
 });
+var ShadowDiagnosticEventSchema = EventBaseSchema.extend({
+  type: z4.literal("shadow-diagnostic"),
+  batchID: z4.string().min(1),
+  failureClass: z4.enum([
+    "invalid-node-id",
+    "journal-create-failed",
+    "journal-append-failed",
+    "observation-failed",
+    "unknown"
+  ])
+});
 var OpenTeamEventSchema = z4.discriminatedUnion("type", [
   RouteEventSchema,
   MessageEventSchema,
@@ -917,7 +930,8 @@ var OpenTeamEventSchema = z4.discriminatedUnion("type", [
   MeetingEventSchema,
   DecisionEventSchema,
   ActivityEventSchema,
-  SessionEndpointEventSchema
+  SessionEndpointEventSchema,
+  ShadowDiagnosticEventSchema
 ]);
 
 // src/storage/fsStorageProvider.ts
@@ -3301,6 +3315,875 @@ async function createConsoleRuntime(deps) {
   };
 }
 
+// src/cli/graphViewProvider.ts
+import { readdirSync, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/storage/graph/fsGraphJournal.ts
+import { join as join2 } from "node:path";
+
+// src/context/redaction.ts
+import { createHash } from "node:crypto";
+
+class RedactionError extends Error {
+  code;
+  key;
+  constructor(key) {
+    super(`raw content field is not allowed: "${key}"`);
+    this.name = "RedactionError";
+    this.code = "raw-content";
+    this.key = key;
+  }
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function redactedRef(ref) {
+  return { uri: ref.uri, sha256: ref.sha256, bytes: ref.bytes };
+}
+var FORBIDDEN_RAW_KEYS = new Set([
+  "content",
+  "text",
+  "brief",
+  "prompt",
+  "raw",
+  "body",
+  "output",
+  "findings",
+  "message",
+  "source"
+]);
+function walkForbiddenKeys(value, onForbidden) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkForbiddenKeys(item, onForbidden);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (FORBIDDEN_RAW_KEYS.has(key)) {
+      const shouldStop = onForbidden(key);
+      if (shouldStop)
+        return;
+    }
+    walkForbiddenKeys(child, onForbidden);
+  }
+}
+function assertReferenceOnly(value) {
+  walkForbiddenKeys(value, (key) => {
+    throw new RedactionError(key);
+  });
+}
+
+// src/graph/types.ts
+var TERMINAL_NODE_STATUSES = new Set([
+  "succeeded",
+  "cancelled"
+]);
+var TERMINAL_RUN_STATUSES = new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+
+// src/graph/reducer.ts
+class ReducerError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ReducerError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function initialState(spec) {
+  const nodes = {};
+  for (const node of spec.nodes) {
+    nodes[node.id] = { status: "pending", attempts: 0 };
+  }
+  return { runID: spec.runID, status: "running", seq: -1, nodes };
+}
+function withNode(state, nodeID, next) {
+  return {
+    ...state,
+    nodes: { ...state.nodes, [nodeID]: next },
+    seq: state.seq
+  };
+}
+function specNode(spec, nodeID) {
+  return spec.nodes.find((node) => node.id === nodeID);
+}
+function applyRunStarted(state, seq, specDigest) {
+  if (state.specDigest !== undefined) {
+    if (state.specDigest === specDigest) {
+      return state;
+    }
+    throw new ReducerError("run-started-conflict", specDigest);
+  }
+  return { ...state, specDigest, seq };
+}
+function applyDispatched(spec, state, event) {
+  const node = specNode(spec, event.nodeID);
+  const current = state.nodes[event.nodeID];
+  if (node === undefined || current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  for (const dep of node.dependsOn) {
+    if (state.nodes[dep]?.status !== "succeeded") {
+      throw new ReducerError("dependency-not-satisfied", `${event.nodeID} <- ${dep}`);
+    }
+  }
+  const running = {
+    status: "running",
+    attempts: current.attempts + 1,
+    operationID: event.operationID,
+    attemptID: event.attemptID
+  };
+  if (current.status === "pending") {
+    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
+  }
+  if (current.status === "failed") {
+    if (current.operationID !== event.operationID) {
+      throw new ReducerError("dispatch-conflict", event.nodeID);
+    }
+    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
+  }
+  if (current.status === "running") {
+    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
+      return state;
+    }
+    throw new ReducerError("dispatch-conflict", event.nodeID);
+  }
+  throw new ReducerError("illegal-transition", `dispatch ${current.status}`);
+}
+function applySucceeded(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  if (current.status === "succeeded") {
+    if (current.operationID === event.operationID && current.artifactSha256 === event.artifact.sha256) {
+      return state;
+    }
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  if (current.status !== "running") {
+    throw new ReducerError("illegal-transition", `succeed ${current.status}`);
+  }
+  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    status: "succeeded",
+    attempts: current.attempts,
+    operationID: event.operationID,
+    attemptID: event.attemptID,
+    artifactSha256: event.artifact.sha256
+  });
+}
+function applyFailed(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  if (current.status === "failed") {
+    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
+      return state;
+    }
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  if (current.status !== "running") {
+    throw new ReducerError("illegal-transition", `fail ${current.status}`);
+  }
+  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    status: "failed",
+    attempts: current.attempts,
+    operationID: event.operationID,
+    attemptID: event.attemptID
+  });
+}
+function applyCancelled(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  if (current.status === "cancelled") {
+    return state;
+  }
+  if (current.status === "succeeded") {
+    throw new ReducerError("illegal-transition", "cancel succeeded");
+  }
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    ...current,
+    status: "cancelled"
+  });
+}
+function applyRunCompleted(state, seq) {
+  for (const node of Object.values(state.nodes)) {
+    if (node.status !== "succeeded" && node.status !== "cancelled") {
+      throw new ReducerError("incomplete-run", node.status);
+    }
+  }
+  return { ...state, status: "completed", seq };
+}
+function applyEvent(spec, state, event) {
+  if (event.runID !== state.runID) {
+    throw new ReducerError("run-mismatch", event.runID);
+  }
+  if (TERMINAL_RUN_STATUSES.has(state.status)) {
+    if (event.type === "run.completed" && state.status === "completed" || event.type === "run.failed" && state.status === "failed" || event.type === "run.cancelled" && state.status === "cancelled") {
+      return state;
+    }
+    throw new ReducerError("post-terminal", event.type);
+  }
+  switch (event.type) {
+    case "run.started":
+      return applyRunStarted(state, event.seq, event.specDigest);
+    case "node.dispatched":
+      return applyDispatched(spec, state, event);
+    case "node.succeeded":
+      return applySucceeded(state, event);
+    case "node.failed":
+      return applyFailed(state, event);
+    case "node.cancelled":
+      return applyCancelled(state, event);
+    case "run.completed":
+      return applyRunCompleted(state, event.seq);
+    case "run.failed":
+      return { ...state, status: "failed", seq: event.seq };
+    case "run.cancelled":
+      return { ...state, status: "cancelled", seq: event.seq };
+  }
+}
+
+// src/graph/replay.ts
+class ReplayError extends Error {
+  code;
+  detail;
+  constructor(detail) {
+    super(`sequence-gap: ${detail}`);
+    this.name = "ReplayError";
+    this.code = "sequence-gap";
+    this.detail = detail;
+  }
+}
+function replay(spec, events) {
+  let state = initialState(spec);
+  events.forEach((event, index) => {
+    if (event.seq !== index) {
+      throw new ReplayError(`expected ${index}, got ${event.seq}`);
+    }
+    state = applyEvent(spec, state, event);
+  });
+  return state;
+}
+
+// src/graph/schema.ts
+import { z as z7 } from "zod";
+
+// src/context/schema.ts
+import { z as z6 } from "zod";
+var PrivacyClassSchema = z6.enum(["public", "internal", "sensitive"]);
+var Sha256Schema = z6.string().regex(/^[0-9a-f]{64}$/, "expected lowercase hex sha-256");
+var IdentifierSchema = z6.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "invalid identifier");
+var TaskAnchorSchema = z6.object({
+  taskID: IdentifierSchema,
+  specDigest: Sha256Schema
+}).strict();
+var ContextRefSchema = z6.object({
+  uri: z6.string().min(1).max(1024),
+  sha256: Sha256Schema,
+  bytes: z6.number().int().nonnegative(),
+  mediaType: z6.string().min(1).max(128).optional()
+}).strict();
+var ManifestEntrySchema = z6.object({
+  label: IdentifierSchema,
+  sha256: Sha256Schema,
+  bytes: z6.number().int().nonnegative(),
+  ref: ContextRefSchema.optional()
+}).strict();
+var ArtifactManifestSchema = z6.object({
+  version: z6.literal(1),
+  taskID: IdentifierSchema,
+  privacyClass: PrivacyClassSchema,
+  entries: z6.array(ManifestEntrySchema)
+}).strict();
+var NodeContextContractSchema = z6.object({
+  version: z6.literal(1),
+  refs: z6.array(ContextRefSchema),
+  privacyClass: PrivacyClassSchema,
+  maxInputTokens: z6.number().int().positive().optional()
+}).strict();
+
+// src/graph/schema.ts
+var GRAPH_SPEC_VERSION = 1;
+var GRAPH_EVENT_VERSION = 1;
+var NodeIDSchema = z7.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid node id");
+var NodeRoleSchema = z7.enum(["implementer", "reviewer"]);
+var OperationIDSchema = z7.string().regex(/^[0-9a-f]{8,64}$/, "invalid operation id");
+var AttemptIDSchema = z7.string().regex(/^[0-9a-f]{8,64}$/, "invalid attempt id");
+var ErrorClassSchema = z7.enum([
+  "transient",
+  "permanent",
+  "timeout",
+  "cancelled",
+  "unknown"
+]);
+var GraphNodeSchema = z7.object({
+  id: NodeIDSchema,
+  role: NodeRoleSchema,
+  dependsOn: z7.array(NodeIDSchema).default([]),
+  anchor: TaskAnchorSchema,
+  reviews: NodeIDSchema.optional()
+}).strict();
+var GraphSpecV1Schema = z7.object({
+  version: z7.literal(GRAPH_SPEC_VERSION),
+  runID: NodeIDSchema,
+  nodes: z7.array(GraphNodeSchema).min(1)
+}).strict();
+var eventEnvelope = {
+  v: z7.literal(GRAPH_EVENT_VERSION),
+  seq: z7.number().int().nonnegative(),
+  runID: NodeIDSchema
+};
+var RunStartedEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("run.started"),
+  specDigest: Sha256Schema
+}).strict();
+var NodeDispatchedEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.dispatched"),
+  nodeID: NodeIDSchema,
+  operationID: OperationIDSchema,
+  attemptID: AttemptIDSchema
+}).strict();
+var NodeSucceededEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.succeeded"),
+  nodeID: NodeIDSchema,
+  operationID: OperationIDSchema,
+  attemptID: AttemptIDSchema,
+  artifact: ContextRefSchema
+}).strict();
+var NodeFailedEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.failed"),
+  nodeID: NodeIDSchema,
+  operationID: OperationIDSchema,
+  attemptID: AttemptIDSchema,
+  errorClass: ErrorClassSchema
+}).strict();
+var NodeCancelledEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.cancelled"),
+  nodeID: NodeIDSchema
+}).strict();
+var RunCompletedEventSchema = z7.object({ ...eventEnvelope, type: z7.literal("run.completed") }).strict();
+var RunFailedEventSchema = z7.object({ ...eventEnvelope, type: z7.literal("run.failed") }).strict();
+var RunCancelledEventSchema = z7.object({ ...eventEnvelope, type: z7.literal("run.cancelled") }).strict();
+var GraphEventV1Schema = z7.discriminatedUnion("type", [
+  RunStartedEventSchema,
+  NodeDispatchedEventSchema,
+  NodeSucceededEventSchema,
+  NodeFailedEventSchema,
+  NodeCancelledEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  RunCancelledEventSchema
+]);
+
+class GraphSchemaError extends Error {
+  code;
+  issues;
+  constructor(code, error) {
+    super(`${code}: ${error.issues.map((issue) => issue.message).join("; ")}`);
+    this.name = "GraphSchemaError";
+    this.code = code;
+    this.issues = error.issues.map((issue) => issue.message);
+  }
+}
+function parseGraphSpec(input) {
+  const result = GraphSpecV1Schema.safeParse(input);
+  if (!result.success) {
+    throw new GraphSchemaError("invalid-spec", result.error);
+  }
+  return result.data;
+}
+function parseGraphEvent(input) {
+  const result = GraphEventV1Schema.safeParse(input);
+  if (!result.success) {
+    throw new GraphSchemaError("invalid-event", result.error);
+  }
+  return result.data;
+}
+
+// src/storage/graph/codec.ts
+var CODEC_VERSION = 1;
+var GENESIS_DIGEST = sha256Hex("openteam/graph-journal/genesis/v1");
+var NUL = "\x00";
+var NEWLINE = `
+`;
+function canonical(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  const record = value;
+  const entries = Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`);
+  return `{${entries.join(",")}}`;
+}
+function frameDigest(prev, event) {
+  return sha256Hex(`${prev}${NUL}${canonical(event)}`);
+}
+
+class JournalCodecError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "JournalCodecError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function encodeFrame(prev, seq, event) {
+  const sum = frameDigest(prev, event);
+  const line = canonical({ v: CODEC_VERSION, seq, prev, sum, event });
+  return { line, digest: sum };
+}
+function decodeFrame(raw, index, expectedPrev) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new JournalCodecError("bad-frame", `unparseable frame ${index}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new JournalCodecError("bad-frame", `frame ${index} is not an object`);
+  }
+  const frame = parsed;
+  if (frame.v !== CODEC_VERSION) {
+    throw new JournalCodecError("bad-version", `frame ${index}`);
+  }
+  if (typeof frame.seq !== "number" || typeof frame.prev !== "string" || typeof frame.sum !== "string") {
+    throw new JournalCodecError("bad-frame", `frame ${index} header`);
+  }
+  let event;
+  try {
+    event = parseGraphEvent(frame.event);
+  } catch {
+    throw new JournalCodecError("bad-frame", `frame ${index} event`);
+  }
+  if (frame.seq !== index) {
+    throw new JournalCodecError("bad-sequence", `expected ${index}, got ${frame.seq}`);
+  }
+  if (frame.prev !== expectedPrev) {
+    throw new JournalCodecError("chain-break", `frame ${index}`);
+  }
+  if (frame.sum !== frameDigest(frame.prev, event)) {
+    throw new JournalCodecError("bad-checksum", `frame ${index}`);
+  }
+  return { event, digest: frame.sum };
+}
+function decodeJournal(text) {
+  const segments = text.split(NEWLINE);
+  const trailing = segments.pop() ?? "";
+  const partialTail = trailing !== "";
+  const events = [];
+  let prev = GENESIS_DIGEST;
+  segments.forEach((raw, index) => {
+    const { event, digest } = decodeFrame(raw, index, prev);
+    events.push(event);
+    prev = digest;
+  });
+  return { events, digest: prev, partialTail };
+}
+
+// src/storage/graph/provider.ts
+class JournalError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "JournalError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+// src/storage/graph/writer.ts
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  writeSync
+} from "node:fs";
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function writeDurable(file, content) {
+  const fd = openSync(file, "w");
+  try {
+    writeSync(fd, content);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function appendDurable(file, content) {
+  const fd = openSync(file, "a");
+  try {
+    writeSync(fd, content);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function readText(file) {
+  if (!existsSync(file)) {
+    return;
+  }
+  return readFileSync(file, "utf8");
+}
+function pathExists(path) {
+  return existsSync(path);
+}
+
+// src/storage/graph/fsGraphJournal.ts
+var NUL2 = "\x00";
+var JOURNAL_FILE = "journal.ndjson";
+var OWNER_FILE = "owner";
+var SPEC_FILE = "spec.json";
+function createFsGraphJournal(root) {
+  let counter = 0;
+  const runDir = (runID) => join2(root, runID);
+  const journalPath = (runID) => join2(runDir(runID), JOURNAL_FILE);
+  const ownerPath = (runID) => join2(runDir(runID), OWNER_FILE);
+  const specPath = (runID) => join2(runDir(runID), SPEC_FILE);
+  const issueToken = (runID, prev) => {
+    const token = sha256Hex(`writer${NUL2}${runID}${NUL2}${prev}${NUL2}${counter}`).slice(0, 32);
+    counter += 1;
+    return token;
+  };
+  const readDecoded = (runID) => {
+    const text = readText(journalPath(runID)) ?? "";
+    try {
+      return decodeJournal(text);
+    } catch (error) {
+      throw new JournalError("corrupt", error.message);
+    }
+  };
+  return {
+    async create(spec) {
+      const parsed = parseGraphSpec(structuredClone(spec));
+      if (pathExists(runDir(parsed.runID))) {
+        throw new JournalError("already-exists", parsed.runID);
+      }
+      ensureDir(runDir(parsed.runID));
+      writeDurable(specPath(parsed.runID), JSON.stringify(parsed));
+      writeDurable(journalPath(parsed.runID), "");
+      const token = issueToken(parsed.runID, GENESIS_DIGEST);
+      writeDurable(ownerPath(parsed.runID), token);
+      return { runID: parsed.runID, writerToken: token };
+    },
+    async takeOver(runID) {
+      if (!pathExists(runDir(runID))) {
+        throw new JournalError("not-found", runID);
+      }
+      const prev = readText(ownerPath(runID)) ?? GENESIS_DIGEST;
+      const token = issueToken(runID, prev);
+      writeDurable(ownerPath(runID), token);
+      return { runID, writerToken: token };
+    },
+    async append(handle, event, expectedSeq) {
+      if (!pathExists(runDir(handle.runID))) {
+        throw new JournalError("not-found", handle.runID);
+      }
+      if (readText(ownerPath(handle.runID)) !== handle.writerToken) {
+        throw new JournalError("writer-conflict", handle.runID);
+      }
+      const decoded = readDecoded(handle.runID);
+      if (decoded.partialTail) {
+        throw new JournalError("corrupt", "partial tail; recovery required");
+      }
+      const head = decoded.events.length;
+      if (event.seq < head) {
+        throw new JournalError("duplicate-event", `seq ${event.seq}`);
+      }
+      if (event.seq !== head || expectedSeq !== head) {
+        throw new JournalError("sequence-mismatch", `head=${head} expected=${expectedSeq} event=${event.seq}`);
+      }
+      const frame = encodeFrame(decoded.digest, head, event);
+      appendDurable(journalPath(handle.runID), `${frame.line}
+`);
+    },
+    async load(runID) {
+      if (!pathExists(runDir(runID))) {
+        throw new JournalError("not-found", runID);
+      }
+      const decoded = readDecoded(runID);
+      const specText = readText(specPath(runID));
+      if (specText === undefined) {
+        throw new JournalError("corrupt", "missing spec");
+      }
+      let spec;
+      try {
+        spec = parseGraphSpec(JSON.parse(specText));
+      } catch (error) {
+        throw new JournalError("corrupt", error.message);
+      }
+      let loaded;
+      try {
+        loaded = {
+          spec,
+          events: decoded.events,
+          state: replay(spec, decoded.events)
+        };
+      } catch (error) {
+        throw new JournalError("corrupt", error.message);
+      }
+      return loaded;
+    },
+    async exists(runID) {
+      return pathExists(runDir(runID));
+    }
+  };
+}
+
+// src/telemetry/graphProjection.ts
+function projectGraphEvent(event) {
+  const record = {
+    v: event.v,
+    seq: event.seq,
+    runID: event.runID,
+    type: event.type,
+    ..."nodeID" in event ? { nodeID: event.nodeID } : {},
+    ..."operationID" in event ? { operationID: event.operationID } : {},
+    ..."attemptID" in event ? { attemptID: event.attemptID } : {},
+    ..."errorClass" in event ? { errorClass: event.errorClass } : {},
+    ..."specDigest" in event ? { specDigest: event.specDigest } : {},
+    ..."artifact" in event ? { artifact: redactedRef(event.artifact) } : {}
+  };
+  assertReferenceOnly(record);
+  return record;
+}
+
+// src/telemetry/graphRuntimeHealth.ts
+var RUN_TERMINAL_TYPES = new Set([
+  "run.completed",
+  "run.failed",
+  "run.cancelled"
+]);
+var NODE_TERMINAL_TYPES = new Set([
+  "node.succeeded",
+  "node.failed",
+  "node.cancelled"
+]);
+function isRecoveryRequired(journal, unknownEffects) {
+  return journal === "corrupt" || unknownEffects > 0;
+}
+function computeGraphRuntimeHealth(input) {
+  const dispatched = new Set;
+  const resolved = new Set;
+  let runTerminalSeq = Number.POSITIVE_INFINITY;
+  const staleAttempts = new Set;
+  for (const event of input.events) {
+    if (event.type === "node.dispatched") {
+      dispatched.add(event.attemptID);
+    } else if (NODE_TERMINAL_TYPES.has(event.type)) {
+      if ("attemptID" in event && event.attemptID !== undefined) {
+        resolved.add(event.attemptID);
+        if (event.seq > runTerminalSeq) {
+          staleAttempts.add(event.attemptID);
+        }
+      }
+    }
+    if (RUN_TERMINAL_TYPES.has(event.type)) {
+      if (event.seq < runTerminalSeq) {
+        runTerminalSeq = event.seq;
+      }
+    }
+  }
+  let unknownEffects = 0;
+  for (const attemptID of dispatched) {
+    if (!resolved.has(attemptID)) {
+      unknownEffects++;
+    }
+  }
+  const staleCompletions = staleAttempts.size;
+  const recoveryRequired = isRecoveryRequired(input.journal, unknownEffects);
+  let conflicts = 0;
+  if (input.lease !== undefined && !input.lease.released && input.lease.holder !== input.holder) {
+    conflicts++;
+  }
+  if (input.worktrees !== undefined) {
+    conflicts += input.worktrees.blocked;
+  }
+  const health = {
+    recoveryRequired,
+    unknownEffects,
+    staleCompletions,
+    conflicts,
+    killSwitch: input.killSwitch
+  };
+  assertReferenceOnly(health);
+  return health;
+}
+
+// src/telemetry/graphView.ts
+function isReady(node, state) {
+  return node.dependsOn.every((dep) => state.nodes[dep]?.status === "succeeded");
+}
+function toViewState(node, status, state) {
+  if (status === "running") {
+    return "active";
+  }
+  if (status === "pending") {
+    return isReady(node, state) ? "ready" : "pending";
+  }
+  return status;
+}
+function deriveVerdict(status) {
+  if (status === "succeeded") {
+    return "approved";
+  }
+  if (status === "failed") {
+    return "rejected";
+  }
+  return "inconclusive";
+}
+function indexTelemetry(telemetry) {
+  const lastError = new Map;
+  const lastArtifact = new Map;
+  for (const record of telemetry) {
+    if (record.nodeID === undefined) {
+      continue;
+    }
+    if (record.type === "node.failed" && record.errorClass !== undefined) {
+      lastError.set(record.nodeID, record.errorClass);
+    }
+    if (record.type === "node.succeeded" && record.artifact !== undefined) {
+      lastArtifact.set(record.nodeID, record.artifact);
+    }
+  }
+  return { lastError, lastArtifact };
+}
+function buildNodeView(node, input, lastError, lastArtifact) {
+  const runtime = input.state.nodes[node.id];
+  const status = runtime?.status ?? "pending";
+  const attempts = runtime?.attempts ?? 0;
+  const errorClass = lastError.get(node.id);
+  const artifact = lastArtifact.get(node.id);
+  const sessionRef = input.sessions?.[node.id];
+  const review = node.role === "reviewer" && node.reviews !== undefined ? { verdict: deriveVerdict(status), reassigned: attempts > 1 } : undefined;
+  return {
+    nodeID: node.id,
+    role: node.role,
+    state: toViewState(node, status, input.state),
+    attempts,
+    ...errorClass !== undefined ? { lastErrorClass: errorClass } : {},
+    ...review !== undefined ? { review } : {},
+    ...node.reviews !== undefined ? { revisionOf: node.reviews } : {},
+    ...artifact !== undefined ? { artifact } : {},
+    ...sessionRef !== undefined ? { sessionRef } : {}
+  };
+}
+function buildEdges(spec) {
+  return spec.nodes.flatMap((node) => node.dependsOn.map((from) => ({ from, to: node.id })));
+}
+function buildGraphView(input) {
+  const { lastError, lastArtifact } = indexTelemetry(input.telemetry);
+  const nodes = input.spec.nodes.map((node) => buildNodeView(node, input, lastError, lastArtifact));
+  const projection = {
+    version: 1,
+    runID: input.spec.runID,
+    nodes,
+    edges: buildEdges(input.spec),
+    health: input.health
+  };
+  assertReferenceOnly(projection);
+  return projection;
+}
+
+// src/cli/graphViewProvider.ts
+function selectMostRecentRun(journalRoot) {
+  if (!pathExists(journalRoot)) {
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync(journalRoot);
+  } catch {
+    return;
+  }
+  if (entries.length === 0) {
+    return;
+  }
+  let best;
+  for (const name of entries) {
+    const specFile = join3(journalRoot, name, "spec.json");
+    let mtime;
+    try {
+      mtime = statSync(specFile).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (best === undefined || mtime > best.mtime || mtime === best.mtime && name > best.runID) {
+      best = { runID: name, mtime };
+    }
+  }
+  return best?.runID;
+}
+function createGraphViewProvider(deps) {
+  const selectRun = deps.selectRun ?? selectMostRecentRun;
+  const journal = createFsGraphJournal(deps.journalRoot);
+  return {
+    async readView() {
+      const runID = selectRun(deps.journalRoot);
+      if (runID === undefined) {
+        return null;
+      }
+      try {
+        const loaded = await journal.load(runID);
+        const telemetry = loaded.events.map(projectGraphEvent);
+        const health = computeGraphRuntimeHealth({
+          events: loaded.events,
+          journal: "clean",
+          lease: undefined,
+          holder: "console",
+          killSwitch: deps.killSwitch
+        });
+        return buildGraphView({
+          spec: loaded.spec,
+          state: loaded.state,
+          telemetry,
+          health
+        });
+      } catch (error) {
+        if (error instanceof JournalError && error.code === "corrupt") {
+          deps.log(`Graph view: journal for run "${runID}" is corrupt (${error.detail}); skipping.`);
+          return null;
+        }
+        if (error instanceof JournalError && error.code === "not-found") {
+          return null;
+        }
+        throw error;
+      }
+    }
+  };
+}
+
 // src/cli/consoleServe.ts
 function parseConsoleServeArgs(rest) {
   return {
@@ -3323,6 +4206,14 @@ async function runConsoleServe(deps, options) {
     endpoint,
     ...deps.serverPassword !== undefined ? { password: deps.serverPassword } : {}
   }));
+  const graphMode = config.graph?.mode ?? "off";
+  const graphViewEnabled = config.console.graphView?.enabled === true;
+  const buildGraphView2 = deps.createGraphViewProvider ?? createGraphViewProvider;
+  const graphViewProvider = graphMode !== "off" && graphViewEnabled ? buildGraphView2({
+    journalRoot: config.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT,
+    killSwitch: config.graph?.killSwitch ?? false,
+    log: deps.log
+  }) : undefined;
   let runtime;
   try {
     runtime = await start({
@@ -3343,6 +4234,7 @@ async function runConsoleServe(deps, options) {
         createClient: makeClient,
         createPtyClient: makePtyClient
       },
+      ...graphViewProvider !== undefined ? { graphView: graphViewProvider } : {},
       ...config.console.remoteStorage ? {
         storageApi: {
           storage: deps.storage,
@@ -4535,8 +5427,11 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "con `mode: subagent` (usa `read`/`glob`/`list`).",
     "",
     "- **Si el equipo YA existe** → actúa como coordinador: entiende la tarea,",
-    "  repártela entre los subagentes adecuados con la herramienta `task` y",
-    "  reutiliza el reparto existente. No vuelvas a castear ni recrear agentes.",
+    "  identifica qué roles del roster la cubren y **delega la distribución a la",
+    "  herramienta `openteam-orchestrate`** con las asignaciones correspondientes.",
+    "  openteam se encarga del routing de modelo, la creación de subsesiones y la",
+    "  telemetría — tú no necesitas usar `task` directamente para roles del roster.",
+    "  Reutiliza el reparto existente. No vuelvas a castear ni recrear agentes.",
     "- **Si NO existe equipo** (sin `openteam-roster.md` ni subagentes): **no pidas",
     "  permiso para crearlo**. Entiende primero las tareas que implica la",
     "  petición, diseña el equipo mínimo necesario, **créalo a demanda** y luego",
@@ -4637,6 +5532,39 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "Explica brevemente al usuario tu plan (qué va en paralelo y qué en serie, y",
     "por qué) antes o mientras lanzas las tareas.",
     "",
+    "## Distribución de trabajo con `openteam-orchestrate`",
+    "",
+    "Cuando el roster existe, **usa la herramienta `openteam-orchestrate`** para",
+    "distribuir el trabajo entre los roles del equipo. Esta herramienta delega a",
+    "nuestro código el routing de modelo por rol, la creación de subsesiones y la",
+    "telemetría — no improvises estos pasos manualmente con `task`.",
+    "",
+    "Payload (las claves son estrictas — claves desconocidas se rechazan):",
+    "",
+    "```json",
+    "{",
+    '  "assignments": [',
+    '    { "roleID": "<rol-del-roster>", "prompt": "<tarea accionable>", "title": "<título opcional>" },',
+    '    { "roleID": "<otro-rol>", "prompt": "<otra tarea>" }',
+    "  ],",
+    '  "parentSessionID": "<sesión actual, opcional>",',
+    '  "directory": "<directorio de trabajo, opcional>"',
+    "}",
+    "```",
+    "",
+    "- `assignments` (obligatorio): lista de asignaciones. Cada una tiene un",
+    "  `roleID` (debe coincidir con un rol del roster) y un `prompt` accionable.",
+    "  `title` es opcional y solo para legibilidad.",
+    "- `parentSessionID` (opcional): la sesión actual, para que las subsesiones",
+    "  se vinculen como hijas.",
+    "- `directory` (opcional): directorio de trabajo si difiere del actual.",
+    "",
+    "La herramienta devuelve un resumen por rol: modelo seleccionado, éxito o",
+    "fallo, y sesión creada. Si un rol falla, el resto sigue ejecutándose.",
+    "",
+    "**Usa `task` directamente** solo para subagentes ad-hoc que no estén en el",
+    "roster (p. ej. un agente creado a demanda para un trabajo puntual).",
+    "",
     "## Lista de tareas con responsable visible",
     "",
     "Mantén la lista de tareas de la sesión con `todowrite` y **haz visible quién",
@@ -4658,8 +5586,9 @@ function buildOrchestratorAgent(frontier, options = {}) {
     "",
     "- **Empieza siempre comprobando el equipo** (roster + subagentes) antes de",
     "  delegar; si falta, créalo antes de repartir el trabajo.",
-    "- Delega el trabajo con la herramienta `task` al subagente adecuado; tú te",
-    "  mantienes como coordinador y no implementas lo que puede hacer un subagente.",
+    "- Delega el trabajo del roster con `openteam-orchestrate`; usa `task` solo",
+    "  para subagentes ad-hoc que no tengan rol en el roster. Tú te mantienes como",
+    "  coordinador y no implementas lo que puede hacer un subagente.",
     "- **Lanza en un solo turno las tareas independientes** para que corran en",
     "  paralelo; secuencia solo las que dependen de un resultado previo.",
     "- Crea subagentes **justo cuando el trabajo lo pide**, nunca “por si acaso”.",
@@ -4953,7 +5882,10 @@ async function runCli(argv, deps) {
       const config = await deps.loadConfig(configPath);
       return { exitCode: 0, stdout: renderConsoleStatus(config.console) };
     }
-    if (command === undefined || command === "help" || command === "--help") {
+    if (command === "--version" || command === "-v") {
+      return { exitCode: 0, stdout: deps.version };
+    }
+    if (command === undefined || command === "help" || command === "--help" || command === "-h") {
       return { exitCode: 0, stdout: HELP };
     }
     return {
@@ -5560,54 +6492,54 @@ function loadOpenTeamConfig(raw) {
 }
 
 // src/memory/types.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z6.string().min(1);
-var MemoryKindSchema = z6.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z6.object({
-  id: z6.string().min(1),
+var OwnerKeySchema = z8.string().min(1);
+var MemoryKindSchema = z8.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z8.object({
+  id: z8.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z6.number().min(0).max(1),
-  validFrom: z6.number().finite(),
-  validUntil: z6.number().finite().nullable().default(null),
-  createdAt: z6.number().finite(),
-  invalidatedAt: z6.number().finite().nullable().default(null),
-  sourceHash: z6.string().min(1),
-  supersededBy: z6.string().min(1).nullable().default(null)
+  confidence: z8.number().min(0).max(1),
+  validFrom: z8.number().finite(),
+  validUntil: z8.number().finite().nullable().default(null),
+  createdAt: z8.number().finite(),
+  invalidatedAt: z8.number().finite().nullable().default(null),
+  sourceHash: z8.string().min(1),
+  supersededBy: z8.string().min(1).nullable().default(null)
 });
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z6.literal("fact"),
-  subject: z6.string().min(1),
-  predicate: z6.string().min(1),
-  object: z6.string().min(1),
-  category: z6.string().min(1).nullable().default(null)
+  kind: z8.literal("fact"),
+  subject: z8.string().min(1),
+  predicate: z8.string().min(1),
+  object: z8.string().min(1),
+  category: z8.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z6.literal("preference"),
-  category: z6.string().min(1),
-  preference: z6.string().min(1),
-  context: z6.string().min(1).nullable().default(null),
-  lastAccessedAt: z6.number().finite().nullable().default(null),
-  accessCount: z6.number().int().min(0).default(0)
+  kind: z8.literal("preference"),
+  category: z8.string().min(1),
+  preference: z8.string().min(1),
+  context: z8.string().min(1).nullable().default(null),
+  lastAccessedAt: z8.number().finite().nullable().default(null),
+  accessCount: z8.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z6.literal("entity"),
-  canonicalName: z6.string().min(1),
-  type: z6.string().min(1),
-  aliases: z6.array(z6.string().min(1)).default([])
+  kind: z8.literal("entity"),
+  canonicalName: z8.string().min(1),
+  type: z8.string().min(1),
+  aliases: z8.array(z8.string().min(1)).default([])
 });
-var MemoryRecordSchema = z6.discriminatedUnion("kind", [
+var MemoryRecordSchema = z8.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema
 ]);
-var RecallQuerySchema = z6.object({
+var RecallQuerySchema = z8.object({
   ownerKey: OwnerKeySchema,
-  kinds: z6.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z6.number().finite().nullable().default(null),
-  limit: z6.number().int().positive().default(8),
-  minSimilarity: z6.number().min(0).max(1).default(0.2),
-  includeShared: z6.boolean().default(true)
+  kinds: z8.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z8.number().finite().nullable().default(null),
+  limit: z8.number().int().positive().default(8),
+  minSimilarity: z8.number().min(0).max(1).default(0.2),
+  includeShared: z8.boolean().default(true)
 });
 
 // src/memory/rank.ts
@@ -6516,6 +7448,104 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
     return;
   }
 }
+// package.json
+var package_default = {
+  name: "@jmanuelcorral/openteam",
+  version: "0.2.2",
+  packageManager: "bun@1.3.14",
+  description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
+  license: "MIT",
+  author: "Jose Manuel Corral",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/jmanuelcorral/openteam.git"
+  },
+  homepage: "https://github.com/jmanuelcorral/openteam#readme",
+  bugs: {
+    url: "https://github.com/jmanuelcorral/openteam/issues"
+  },
+  keywords: [
+    "opencode",
+    "opencode-plugin",
+    "llm",
+    "routing",
+    "local-llm",
+    "ollama",
+    "lm-studio",
+    "foundry-local",
+    "cost-optimization",
+    "multi-agent"
+  ],
+  engines: {
+    bun: ">=1.3",
+    node: "^22.22.2 || ^24.15.0 || >=26.0.0"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    openteam: "./dist/cli.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "AGENTS.md",
+    ".opencode/openteam.example.json",
+    ".opencode/command/openteam.md"
+  ],
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  trustedDependencies: [],
+  sideEffects: false,
+  scripts: {
+    prebuild: "bun run clean",
+    build: "bun run build:js && bun run build:cli && bun run build:types",
+    "build:js": "bun build ./src/index.ts --target=node --format=esm --outfile=dist/index.js --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod",
+    "build:cli": 'bun build ./src/cli.ts --target=node --format=esm --outfile=dist/cli.js --banner "#!/usr/bin/env node" --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @clack/prompts',
+    "build:types": "tsc -p tsconfig.build.json",
+    clean: `node -e "require('node:fs').rmSync('dist', { recursive: true, force: true })"`,
+    test: "bun test",
+    "test:cov": "bun test --coverage",
+    "certify:shadow": "bun test tests/certification/graph-shadow.test.ts",
+    "certify:release": "bun test tests/certification/graph-release.test.ts",
+    "coverage:check": "node scripts/check-coverage.mjs",
+    typecheck: "tsc --noEmit",
+    lint: "biome check .",
+    "format:check": "biome format .",
+    "docs:install": "cd docs && bun install --frozen-lockfile --ignore-scripts",
+    "docs:dev": "cd docs && bun run docs:dev",
+    "docs:build": "cd docs && bun run docs:build",
+    "docs:preview": "cd docs && bun run docs:preview",
+    prepublishOnly: "bun run build",
+    "link:local": "bun run build && npm link",
+    "hooks:install": "git config core.hooksPath .githooks"
+  },
+  dependencies: {
+    "@clack/prompts": "1.7.0",
+    "@opencode-ai/plugin": "1.18.18",
+    "@opencode-ai/sdk": "1.18.18",
+    zod: "4.4.3"
+  },
+  devDependencies: {
+    "@biomejs/biome": "2.5.9",
+    "@types/bun": "1.3.14",
+    typescript: "7.0.2"
+  }
+};
+
+// src/version.ts
+var PACKAGE_VERSION = package_default.version;
 
 // src/web/git.ts
 function createGitLastCommit(exec) {
@@ -6623,7 +7653,8 @@ var deps = {
   telemetryPath: DEFAULT_TELEMETRY_PATH,
   opencodeConfigPath: OPENCODE_CONFIG_PATH,
   orchestratorAgentPath: ORCHESTRATOR_AGENT_PATH,
-  agentDir: AGENT_DIR
+  agentDir: AGENT_DIR,
+  version: PACKAGE_VERSION
 };
 function createSetupDeps() {
   return {