@jmanuelcorral/openteam 0.2.1 → 0.2.2

package/dist/index.js

@@ -46,8 +46,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",
@@ -148,6 +151,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",
@@ -169,8 +205,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”.",
@@ -337,9 +374,11 @@ var PrivacyModeSchema = z.enum([
 ]);
 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)
@@ -1883,6 +1922,17 @@ var SessionEndpointEventSchema = EventBaseSchema.extend({
   worktree: z5.string().min(1).optional(),
   title: z5.string().min(1).optional()
 });
+var ShadowDiagnosticEventSchema = EventBaseSchema.extend({
+  type: z5.literal("shadow-diagnostic"),
+  batchID: z5.string().min(1),
+  failureClass: z5.enum([
+    "invalid-node-id",
+    "journal-create-failed",
+    "journal-append-failed",
+    "observation-failed",
+    "unknown"
+  ])
+});
 var OpenTeamEventSchema = z5.discriminatedUnion("type", [
   RouteEventSchema,
   MessageEventSchema,
@@ -1890,7 +1940,8 @@ var OpenTeamEventSchema = z5.discriminatedUnion("type", [
   MeetingEventSchema,
   DecisionEventSchema,
   ActivityEventSchema,
-  SessionEndpointEventSchema
+  SessionEndpointEventSchema,
+  ShadowDiagnosticEventSchema
 ]);
 
 // src/plugin/capture.ts
@@ -2669,7 +2720,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 {
@@ -2835,6 +2889,85 @@ var GraphEventV1Schema = z7.discriminatedUnion("type", [
   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/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/graph/ids.ts
 var NUL = "\x00";
 function operationID(runID, nodeID, revision = 0) {
@@ -4891,6 +5024,893 @@ function buildMemoryInjector(deps, policy) {
   };
 }
 
+// src/plugin/orchestrateTool.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+import { z as z13 } from "zod";
+
+// src/orchestrator/permissions.ts
+var ROLE_PERMISSIONS = {
+  rusty: ["read", "edit", "multiFileEdit", "destructive", "network", "shell"],
+  livingston: ["read", "edit", "multiFileEdit", "network", "shell"],
+  yen: ["read", "edit", "network", "shell"],
+  basher: ["read", "edit"],
+  scribe: ["read", "edit"],
+  linus: ["read", "edit", "shell"],
+  reviewer: ["read"]
+};
+var elevatedTier = {
+  trivial: "simple",
+  simple: "moderate",
+  moderate: "hard",
+  hard: "hard"
+};
+function elevateTierForPermissions(baseTier, perms) {
+  const needsElevation = perms.includes("destructive") || perms.includes("multiFileEdit");
+  return needsElevation ? elevatedTier[baseTier] : baseTier;
+}
+
+// src/orchestrator/roles.ts
+import { z as z12 } from "zod";
+var modelSelectionSchema = z12.object({
+  providerID: z12.string().min(1),
+  modelID: z12.string().min(1)
+});
+var roleCapabilityTierSchema = z12.union([
+  z12.literal(1),
+  z12.literal(2),
+  z12.literal(3),
+  z12.literal(4),
+  z12.literal(5)
+]);
+var AgentRoleProfileSchema = z12.object({
+  roleID: z12.string().min(1),
+  opencodeAgent: z12.string().min(1).optional(),
+  defaultTier: z12.enum(["trivial", "simple", "moderate", "hard"]),
+  minReasoningTier: roleCapabilityTierSchema,
+  minCodeQualityTier: roleCapabilityTierSchema,
+  needsToolCallingByDefault: z12.boolean(),
+  preferredLocalModels: z12.array(modelSelectionSchema),
+  preferredFrontierModels: z12.array(z12.union([modelSelectionSchema, z12.literal("auto")])),
+  localFirst: z12.boolean()
+});
+var TEAM_ROLES = {
+  rusty: {
+    roleID: "rusty",
+    opencodeAgent: "architect",
+    defaultTier: "hard",
+    minReasoningTier: 5,
+    minCodeQualityTier: 5,
+    needsToolCallingByDefault: true,
+    preferredLocalModels: [],
+    preferredFrontierModels: ["auto"],
+    localFirst: false
+  },
+  livingston: {
+    roleID: "livingston",
+    opencodeAgent: "integration",
+    defaultTier: "moderate",
+    minReasoningTier: 4,
+    minCodeQualityTier: 4,
+    needsToolCallingByDefault: true,
+    preferredLocalModels: [{ providerID: "ollama", modelID: "qwen3:8b" }],
+    preferredFrontierModels: ["auto"],
+    localFirst: false
+  },
+  yen: {
+    roleID: "yen",
+    opencodeAgent: "local-runtime",
+    defaultTier: "moderate",
+    minReasoningTier: 3,
+    minCodeQualityTier: 4,
+    needsToolCallingByDefault: true,
+    preferredLocalModels: [
+      { providerID: "ollama", modelID: "qwen3-coder:latest" }
+    ],
+    preferredFrontierModels: ["auto"],
+    localFirst: true
+  },
+  basher: {
+    roleID: "basher",
+    opencodeAgent: "routing-cost",
+    defaultTier: "moderate",
+    minReasoningTier: 3,
+    minCodeQualityTier: 4,
+    needsToolCallingByDefault: false,
+    preferredLocalModels: [{ providerID: "ollama", modelID: "qwen3:8b" }],
+    preferredFrontierModels: ["auto"],
+    localFirst: true
+  },
+  scribe: {
+    roleID: "scribe",
+    opencodeAgent: "scribe",
+    defaultTier: "trivial",
+    minReasoningTier: 1,
+    minCodeQualityTier: 1,
+    needsToolCallingByDefault: false,
+    preferredLocalModels: [{ providerID: "ollama", modelID: "qwen3:8b" }],
+    preferredFrontierModels: [],
+    localFirst: true
+  },
+  linus: {
+    roleID: "linus",
+    opencodeAgent: "tester",
+    defaultTier: "simple",
+    minReasoningTier: 2,
+    minCodeQualityTier: 3,
+    needsToolCallingByDefault: true,
+    preferredLocalModels: [{ providerID: "lmstudio", modelID: "local-coder" }],
+    preferredFrontierModels: ["auto"],
+    localFirst: true
+  },
+  reviewer: {
+    roleID: "reviewer",
+    opencodeAgent: "reviewer",
+    defaultTier: "moderate",
+    minReasoningTier: 4,
+    minCodeQualityTier: 5,
+    needsToolCallingByDefault: false,
+    preferredLocalModels: [{ providerID: "ollama", modelID: "qwen3:8b" }],
+    preferredFrontierModels: ["auto"],
+    localFirst: true
+  }
+};
+function getRoleProfile(roleID) {
+  return TEAM_ROLES[roleID];
+}
+function roleToRequirement(role, task, tier) {
+  const baseRequirement = deriveRequirement(tier ?? role.defaultTier, task);
+  return {
+    ...baseRequirement,
+    minReasoningTier: Math.max(baseRequirement.minReasoningTier, role.minReasoningTier),
+    minCodeQualityTier: Math.max(baseRequirement.minCodeQualityTier, role.minCodeQualityTier),
+    needsTools: baseRequirement.needsTools || role.needsToolCallingByDefault
+  };
+}
+
+// src/orchestrator/subsessions.ts
+function errorReason(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
+}
+function createArgs(req) {
+  const body = {};
+  const args = { body };
+  if (req.parentSessionID !== undefined) {
+    body.parentID = req.parentSessionID;
+  }
+  if (req.title !== undefined) {
+    body.title = req.title;
+  }
+  if (req.directory !== undefined) {
+    args.query = { directory: req.directory };
+  }
+  return args;
+}
+function promptArgs(sessionID, req) {
+  const body = {
+    model: req.model,
+    parts: [{ type: "text", text: req.prompt }]
+  };
+  if (req.agent !== undefined) {
+    body.agent = req.agent;
+  }
+  if (req.systemPrompt !== undefined) {
+    body.system = req.systemPrompt;
+  }
+  return {
+    path: { id: sessionID },
+    body
+  };
+}
+async function withTimeout(promise, timeoutMs) {
+  if (timeoutMs === undefined) {
+    return promise;
+  }
+  let timeoutID;
+  const timeout = new Promise((_, reject) => {
+    timeoutID = setTimeout(() => {
+      reject(new Error(`prompt timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timeoutID);
+  }
+}
+async function runSubsession(client, req, deps = {}) {
+  let sessionID;
+  try {
+    const created = await client.session.create(createArgs(req));
+    if (created.error !== undefined) {
+      return {
+        success: false,
+        roleID: req.roleID,
+        model: req.model,
+        failureStage: "create",
+        failureReason: errorReason(created.error)
+      };
+    }
+    sessionID = created.data?.id;
+    if (sessionID === undefined || sessionID.length === 0) {
+      return {
+        success: false,
+        roleID: req.roleID,
+        model: req.model,
+        failureStage: "create",
+        failureReason: "create response did not include a session id"
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      roleID: req.roleID,
+      model: req.model,
+      failureStage: "create",
+      failureReason: errorReason(error)
+    };
+  }
+  try {
+    const prompted = await withTimeout(client.session.prompt(promptArgs(sessionID, req)), deps.timeoutMs);
+    if (prompted.error !== undefined) {
+      return {
+        success: false,
+        sessionID,
+        roleID: req.roleID,
+        model: req.model,
+        failureStage: "prompt",
+        failureReason: errorReason(prompted.error)
+      };
+    }
+    return {
+      success: true,
+      sessionID,
+      roleID: req.roleID,
+      model: req.model,
+      response: prompted.data
+    };
+  } catch (error) {
+    return {
+      success: false,
+      sessionID,
+      roleID: req.roleID,
+      model: req.model,
+      failureStage: "prompt",
+      failureReason: errorReason(error)
+    };
+  }
+}
+
+// src/orchestrator/coordinator.ts
+function defaultRole() {
+  return TEAM_ROLES.scribe;
+}
+function roleFor(roleID) {
+  return getRoleProfile(roleID) ?? defaultRole();
+}
+function permissionsFor(roleID) {
+  return ROLE_PERMISSIONS[roleID] ?? [];
+}
+function roleRequiresFrontier(role, task) {
+  return task.explicitOverride === undefined && role.localFirst === false && role.defaultTier === "hard" && role.preferredFrontierModels.length > 0;
+}
+function roleAdjustedTask(role, input, requirement) {
+  const task = {
+    ...input.task,
+    prompt: input.task.prompt ?? input.prompt
+  };
+  if (requirement.needsTools) {
+    task.requiresTools = true;
+  }
+  if (roleRequiresFrontier(role, task)) {
+    task.explicitOverride = "alwaysFrontier";
+  }
+  return task;
+}
+function satisfiesRoleRequirement(requirement, profile) {
+  return profile.kind === "frontier" && profile.availability !== "unavailable" && profile.contextWindow >= requirement.minContextWindow && profile.reasoningTier >= requirement.minReasoningTier && profile.codeQualityTier >= requirement.minCodeQualityTier && (!requirement.needsTools || profile.supportsToolCalling) && (!requirement.needsVision || profile.supportsVision);
+}
+function roleCapableProfiles(profiles, requirement) {
+  if (profiles === undefined) {
+    return;
+  }
+  return profiles.filter((profile) => satisfiesRoleRequirement(requirement, profile));
+}
+function routingInput(input, role) {
+  const classifiedTier = classifyHeuristic({
+    ...input.task,
+    prompt: input.task.prompt ?? input.prompt
+  }).tier;
+  const permissionTier = elevateTierForPermissions(classifiedTier, permissionsFor(input.roleID));
+  const tier = permissionTier;
+  const requirement = roleToRequirement(role, input.task, tier);
+  const task = roleAdjustedTask(role, input, requirement);
+  const baseInput = {
+    config: input.config,
+    task,
+    tier
+  };
+  const profiles = roleCapableProfiles(input.profiles, requirement);
+  if (profiles !== undefined) {
+    baseInput.profiles = profiles;
+  }
+  if (input.availableModels !== undefined) {
+    baseInput.availableModels = input.availableModels;
+  }
+  if (input.budgetState !== undefined) {
+    baseInput.budgetState = input.budgetState;
+  }
+  return baseInput;
+}
+function recordSessionID(input, subsession) {
+  return subsession.sessionID ?? input.parentSessionID;
+}
+function buildRecord(input, decision2, subsession, deps, decisionID, batchID) {
+  const context = {
+    ts: deps.now(),
+    promptHash: hashPrompt(input.prompt),
+    promptChars: input.task.promptChars
+  };
+  const sessionID = recordSessionID(input, subsession);
+  if (sessionID !== undefined) {
+    context.sessionID = sessionID;
+  }
+  if (input.task.estimatedInputTokens !== undefined) {
+    context.tokensIn = input.task.estimatedInputTokens;
+  }
+  if (input.task.estimatedOutputTokens !== undefined) {
+    context.tokensOut = input.task.estimatedOutputTokens;
+  }
+  const base = toCostRecord(decision2, context);
+  const record = {
+    ...base,
+    decisionID,
+    agent: input.roleID,
+    success: subsession.success
+  };
+  if (batchID !== undefined) {
+    record.batchID = batchID;
+  }
+  if (input.taskID !== undefined) {
+    record.taskID = input.taskID;
+  }
+  if (subsession.failureReason !== undefined) {
+    record.failureReason = subsession.failureReason;
+  }
+  if (subsession.failureStage !== undefined) {
+    record.failureStage = subsession.failureStage;
+  }
+  return record;
+}
+function classifyFailureForTelemetry(failureReason, failureStage) {
+  const lower = failureReason.toLowerCase();
+  if (lower.includes("timed out") || lower.includes("timeout")) {
+    return "prompt-timeout";
+  }
+  if (lower.includes("did not include a session id") || lower.includes("missing session")) {
+    return "create-no-id";
+  }
+  if (failureStage === "create") {
+    return "create-rejected";
+  }
+  if (failureStage === "prompt") {
+    return "prompt-rejected";
+  }
+  return "unknown";
+}
+function correlatedCostRecordToRouteEvent(record) {
+  const event = {
+    ...costRecordToRouteEvent(record),
+    decisionID: record.decisionID,
+    agent: record.agent,
+    success: record.success
+  };
+  if (record.batchID !== undefined) {
+    event.batchID = record.batchID;
+  }
+  if (record.taskID !== undefined) {
+    event.taskID = record.taskID;
+  }
+  if (record.failureReason !== undefined) {
+    event.failureReason = classifyFailureForTelemetry(record.failureReason, record.failureStage);
+  }
+  if (record.failureStage !== undefined) {
+    event.failureStage = record.failureStage;
+  }
+  return event;
+}
+function buildMeetingEvent(inputs, batchID, decisionIDs, ts) {
+  const sessionID = inputs.find((input) => input.parentSessionID !== undefined)?.parentSessionID;
+  if (sessionID === undefined) {
+    return;
+  }
+  return {
+    v: EVENT_SCHEMA_VERSION,
+    type: "meeting",
+    ts,
+    sessionID,
+    batchID,
+    roles: inputs.map((input) => input.roleID),
+    decisionIDs: [...decisionIDs]
+  };
+}
+async function safeEmit(sink, event) {
+  try {
+    await sink.emit(event);
+  } catch {}
+}
+async function runRoleTaskWithCorrelation(input, deps, correlation) {
+  const role = roleFor(input.roleID);
+  const decision2 = chooseModel(routingInput(input, role));
+  const request = {
+    roleID: input.roleID,
+    model: decision2.selected,
+    prompt: input.prompt
+  };
+  if (input.parentSessionID !== undefined) {
+    request.parentSessionID = input.parentSessionID;
+  }
+  if (input.title !== undefined) {
+    request.title = input.title;
+  }
+  if (input.systemPrompt !== undefined) {
+    request.systemPrompt = input.systemPrompt;
+  }
+  if (role.opencodeAgent !== undefined) {
+    request.agent = role.opencodeAgent;
+  }
+  if (input.directory !== undefined) {
+    request.directory = input.directory;
+  }
+  const subsessionDeps = deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs };
+  const subsession = await runSubsession(deps.client, request, subsessionDeps);
+  const record = buildRecord(input, decision2, subsession, deps, correlation.decisionID, correlation.batchID);
+  await safeEmit(deps.sink, correlatedCostRecordToRouteEvent(record));
+  return { decision: decision2, subsession, record };
+}
+function topologicalWaves(inputs) {
+  const waves = [];
+  const placed = new Set;
+  while (placed.size < inputs.length) {
+    const wave = [];
+    for (const input of inputs) {
+      if (placed.has(input.roleID))
+        continue;
+      const deps = input.dependsOn ?? [];
+      if (deps.every((dep) => placed.has(dep))) {
+        wave.push(input);
+      }
+    }
+    if (wave.length === 0) {
+      const unplaceable = inputs.filter((i) => !placed.has(i.roleID));
+      waves.push(unplaceable);
+      break;
+    }
+    for (const input of wave) {
+      placed.add(input.roleID);
+    }
+    waves.push(wave);
+  }
+  return waves;
+}
+async function runRoleTasks(inputs, deps) {
+  const batchID = deps.newDecisionID();
+  const planned = inputs.map((input) => ({
+    input,
+    correlation: { decisionID: deps.newDecisionID(), batchID }
+  }));
+  const meeting = buildMeetingEvent(inputs, batchID, planned.map((entry) => entry.correlation.decisionID), deps.now());
+  if (meeting !== undefined) {
+    await safeEmit(deps.sink, meeting);
+  }
+  const correlationByRole = new Map(planned.map((entry) => [entry.input.roleID, entry.correlation]));
+  const waves = topologicalWaves(inputs);
+  const allResults = [];
+  const succeeded = new Set;
+  const cancelled = [];
+  for (const wave of waves) {
+    const runnable = [];
+    for (const input of wave) {
+      const deps_ = input.dependsOn ?? [];
+      if (deps_.every((dep) => succeeded.has(dep))) {
+        runnable.push(input);
+      } else {
+        cancelled.push(input.roleID);
+      }
+    }
+    const waveResults = await Promise.all(runnable.map((input) => {
+      const correlation = correlationByRole.get(input.roleID);
+      if (correlation === undefined) {
+        throw new Error(`missing correlation for ${input.roleID}`);
+      }
+      return runRoleTaskWithCorrelation(input, deps, correlation);
+    }));
+    for (const result of waveResults) {
+      allResults.push(result);
+      if (result.subsession.success) {
+        succeeded.add(result.subsession.roleID);
+      }
+    }
+  }
+  return { batchID, results: allResults, cancelled };
+}
+
+// src/plugin/orchestrateTool.ts
+var RoleAssignmentSchema = z13.object({
+  roleID: z13.string().min(1).describe("Role identifier from the roster"),
+  prompt: z13.string().min(1).describe("Work prompt for this role"),
+  title: z13.string().min(1).optional().describe("Human-readable title"),
+  dependsOn: z13.array(z13.string().min(1)).optional().describe("Role IDs this assignment depends on (DAG edges)")
+}).strict();
+var OrchestratePayloadSchema = z13.object({
+  assignments: z13.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
+  parentSessionID: z13.string().min(1).optional().describe("Parent session for subsessions"),
+  directory: z13.string().min(1).optional().describe("Working directory override")
+}).strict();
+function validateAssignmentDependencies(assignments) {
+  const ids = new Set;
+  for (const a of assignments) {
+    if (ids.has(a.roleID)) {
+      return { code: "duplicate-role", detail: a.roleID };
+    }
+    ids.add(a.roleID);
+  }
+  for (const a of assignments) {
+    for (const dep of a.dependsOn ?? []) {
+      if (!ids.has(dep)) {
+        return {
+          code: "dangling-reference",
+          detail: `${a.roleID} depends on unknown role "${dep}"`
+        };
+      }
+    }
+  }
+  const state = new Map;
+  const deps = new Map;
+  for (const a of assignments) {
+    deps.set(a.roleID, a.dependsOn ?? []);
+  }
+  const visit = (id) => {
+    const s = state.get(id);
+    if (s === "done")
+      return;
+    if (s === "visiting")
+      return id;
+    state.set(id, "visiting");
+    for (const dep of deps.get(id) ?? []) {
+      const cycle = visit(dep);
+      if (cycle !== undefined)
+        return cycle;
+    }
+    state.set(id, "done");
+    return;
+  };
+  for (const a of assignments) {
+    const cycle = visit(a.roleID);
+    if (cycle !== undefined) {
+      return { code: "cycle", detail: cycle };
+    }
+  }
+  return;
+}
+function adaptSdkClient(sdk) {
+  return {
+    session: {
+      create: async (args) => {
+        const result = await sdk.session.create(args);
+        const out = {};
+        if (result.data !== undefined) {
+          out.data = result.data;
+        }
+        if (result.error !== undefined) {
+          out.error = result.error;
+        }
+        return out;
+      },
+      prompt: async (args) => {
+        const result = await sdk.session.prompt(args);
+        const out = {};
+        if (result.data !== undefined) {
+          out.data = result.data;
+        }
+        if (result.error !== undefined) {
+          out.error = result.error;
+        }
+        return out;
+      }
+    }
+  };
+}
+function deriveTaskSignals2(prompt) {
+  return {
+    promptChars: prompt.length,
+    hasCode: /```/.test(prompt),
+    estimatedInputTokens: Math.ceil(prompt.length / 4),
+    estimatedOutputTokens: 0
+  };
+}
+function projectResults(results, cancelled = []) {
+  const roles = results.map((r) => {
+    const summary = {
+      roleID: r.subsession.roleID,
+      model: r.decision.selected,
+      success: r.subsession.success
+    };
+    if (r.subsession.sessionID !== undefined) {
+      summary.sessionID = r.subsession.sessionID;
+    }
+    if (r.subsession.failureStage !== undefined) {
+      summary.failureStage = r.subsession.failureStage;
+    }
+    if (r.subsession.failureReason !== undefined) {
+      summary.failureReason = r.subsession.failureReason;
+    }
+    return summary;
+  });
+  const result = {
+    kind: "completed",
+    roles,
+    ...cancelled.length > 0 ? { cancelled } : {}
+  };
+  assertReferenceOnly(result);
+  return result;
+}
+function buildRoleTaskInputs(payload, config) {
+  return payload.assignments.map((a) => ({
+    roleID: a.roleID,
+    prompt: a.prompt,
+    task: deriveTaskSignals2(a.prompt),
+    config,
+    ...a.title !== undefined ? { title: a.title } : {},
+    ...a.dependsOn !== undefined && a.dependsOn.length > 0 ? { dependsOn: a.dependsOn } : {},
+    ...payload.parentSessionID !== undefined ? { parentSessionID: payload.parentSessionID } : {},
+    ...payload.directory !== undefined ? { directory: payload.directory } : {}
+  }));
+}
+function formatResult(result) {
+  if (result.kind === "error") {
+    return `orchestration error: ${result.reason}`;
+  }
+  const lines = result.roles.map((r) => `${r.roleID}: ${r.success ? "ok" : "failed"} → ${r.model.providerID}/${r.model.modelID}${r.sessionID !== undefined ? ` (session ${r.sessionID})` : ""}${r.failureReason !== undefined ? ` — ${r.failureReason}` : ""}`);
+  const cancelled = result.cancelled ?? [];
+  if (cancelled.length > 0) {
+    lines.push(`⚠ cancelled (dependency failed): ${cancelled.join(", ")}`);
+  }
+  return `orchestration completed (${result.roles.length} role(s)):
+${lines.join(`
+`)}`;
+}
+function shadowArtifact2(runID, nodeID) {
+  return {
+    uri: `shadow://${runID}/${nodeID}`,
+    sha256: sha256Hex(`shadow-artifact\x00${runID}\x00${nodeID}`),
+    bytes: 0
+  };
+}
+function buildGraphSpecFromAssignments(assignments, batchID) {
+  const anchorDigest = sha256Hex(JSON.stringify({
+    batchID,
+    roles: assignments.map((a) => a.roleID)
+  }));
+  const anchor = { taskID: batchID, specDigest: anchorDigest };
+  const nodes = assignments.map((a) => ({
+    id: a.roleID,
+    role: "implementer",
+    dependsOn: a.dependsOn ?? [],
+    anchor
+  }));
+  return { version: 1, runID: batchID, nodes };
+}
+function synthesizeJournalEvents(spec, results, cancelled = []) {
+  const runID = spec.runID;
+  const events = [
+    {
+      v: 1,
+      seq: 0,
+      runID,
+      type: "run.started",
+      specDigest: graphSpecDigest(spec)
+    }
+  ];
+  const resultByRole = new Map;
+  for (const r of results) {
+    resultByRole.set(r.subsession.roleID, r);
+  }
+  const cancelledSet = new Set(cancelled);
+  for (const node of spec.nodes) {
+    if (cancelledSet.has(node.id)) {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.cancelled",
+        nodeID: node.id
+      });
+      continue;
+    }
+    const result = resultByRole.get(node.id);
+    const operation = operationID(runID, node.id);
+    const attempt = attemptID(operation, 0);
+    events.push({
+      v: 1,
+      seq: events.length,
+      runID,
+      type: "node.dispatched",
+      nodeID: node.id,
+      operationID: operation,
+      attemptID: attempt
+    });
+    if (result === undefined || !result.subsession.success) {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.failed",
+        nodeID: node.id,
+        operationID: operation,
+        attemptID: attempt,
+        errorClass: "unknown"
+      });
+    } else {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.succeeded",
+        nodeID: node.id,
+        operationID: operation,
+        attemptID: attempt,
+        artifact: shadowArtifact2(runID, node.id)
+      });
+    }
+  }
+  const allSucceeded = cancelled.length === 0 && results.every((r) => r.subsession.success);
+  events.push({
+    v: 1,
+    seq: events.length,
+    runID,
+    type: allSucceeded ? "run.completed" : "run.failed"
+  });
+  return events;
+}
+function buildObservation(batchID, _assignments, results, parentSessionID, cancelled = []) {
+  const allSucceeded = cancelled.length === 0 && results.every((r) => r.subsession.success);
+  return {
+    runID: batchID,
+    executed: true,
+    status: allSucceeded ? "completed" : "failed",
+    fixes: 0,
+    nodes: results.map((r) => ({
+      id: r.subsession.roleID,
+      role: "implementer",
+      model: `${r.decision.selected.providerID}/${r.decision.selected.modelID}`,
+      ok: r.subsession.success,
+      ...r.subsession.sessionID !== undefined ? { sessionRef: r.subsession.sessionID } : {}
+    })),
+    ...parentSessionID !== undefined ? { parentSessionRef: parentSessionID } : {}
+  };
+}
+function classifyShadowFailure(_error, phase) {
+  if (phase === "create")
+    return "journal-create-failed";
+  if (phase === "append")
+    return "journal-append-failed";
+  if (phase === "observe")
+    return "observation-failed";
+  return "unknown";
+}
+async function emitShadowDiagnostic(sink, batchID, failureClass, now) {
+  const event = {
+    v: EVENT_SCHEMA_VERSION,
+    type: "shadow-diagnostic",
+    ts: now(),
+    sessionID: batchID,
+    batchID,
+    failureClass
+  };
+  try {
+    await sink.emit(event);
+  } catch {}
+}
+async function runShadowProducer(deps, payload, batch) {
+  if (deps.graphMode === "off")
+    return { ok: true };
+  if (deps.journal === undefined || deps.observeLegacyExecution === undefined) {
+    return { ok: true };
+  }
+  const spec = buildGraphSpecFromAssignments(payload.assignments, batch.batchID);
+  for (const node of spec.nodes) {
+    const parsed = NodeIDSchema.safeParse(node.id);
+    if (!parsed.success) {
+      const failureClass = "invalid-node-id";
+      await emitShadowDiagnostic(deps.sink, batch.batchID, failureClass, deps.now);
+      return { ok: false, failureClass };
+    }
+  }
+  let handle;
+  try {
+    handle = await deps.journal.create(spec);
+  } catch {
+    const failureClass = classifyShadowFailure(undefined, "create");
+    await emitShadowDiagnostic(deps.sink, batch.batchID, failureClass, deps.now);
+    return { ok: false, failureClass };
+  }
+  const events = synthesizeJournalEvents(spec, batch.results, batch.cancelled);
+  for (let i = 0;i < events.length; i++) {
+    const event = events[i];
+    if (event !== undefined) {
+      try {
+        await deps.journal.append(handle, event, i);
+      } catch {
+        const failureClass = classifyShadowFailure(undefined, "append");
+        await emitShadowDiagnostic(deps.sink, batch.batchID, failureClass, deps.now);
+        return { ok: false, failureClass };
+      }
+    }
+  }
+  const observation = buildObservation(batch.batchID, payload.assignments, batch.results, payload.parentSessionID, batch.cancelled);
+  try {
+    await deps.observeLegacyExecution(observation);
+  } catch {
+    const failureClass = classifyShadowFailure(undefined, "observe");
+    await emitShadowDiagnostic(deps.sink, batch.batchID, failureClass, deps.now);
+    return { ok: false, failureClass };
+  }
+  return { ok: true };
+}
+function createOrchestrateTool(deps) {
+  return tool3({
+    description: "Distributes work across roster roles via openteam's coordinator. " + "Each assignment spawns a subsession with model selection driven by " + "the role profile and routing config. Use instead of manually spawning " + "tasks when a roster exists.",
+    args: {
+      assignments: tool3.schema.array(tool3.schema.object({
+        roleID: tool3.schema.string().describe("Role identifier from the roster"),
+        prompt: tool3.schema.string().describe("Work prompt for this role"),
+        title: tool3.schema.string().optional().describe("Human-readable title"),
+        dependsOn: tool3.schema.array(tool3.schema.string()).optional().describe("Role IDs this assignment depends on")
+      })).describe("Role assignments to distribute"),
+      parentSessionID: tool3.schema.string().optional().describe("Parent session for subsessions"),
+      directory: tool3.schema.string().optional().describe("Working directory override")
+    },
+    async execute(args) {
+      const parsed = OrchestratePayloadSchema.safeParse(args);
+      if (!parsed.success) {
+        return `validation error: ${parsed.error.message}`;
+      }
+      const depError = validateAssignmentDependencies(parsed.data.assignments);
+      if (depError !== undefined) {
+        return `dependency validation error: ${depError.code} — ${depError.detail}`;
+      }
+      try {
+        const inputs = buildRoleTaskInputs(parsed.data, deps.config);
+        const coordinatorDeps = {
+          client: deps.client,
+          sink: deps.sink,
+          now: deps.now,
+          newDecisionID: deps.newDecisionID
+        };
+        const batch = await runRoleTasks(inputs, coordinatorDeps);
+        const projected = projectResults(batch.results, batch.cancelled);
+        const shadowResult = await runShadowProducer(deps, parsed.data, batch);
+        const base = formatResult(projected);
+        if (!shadowResult.ok) {
+          return `${base}
+⚠ shadow observation failed: ${shadowResult.failureClass}`;
+        }
+        return base;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        const result = { kind: "error", reason };
+        return formatResult(result);
+      }
+    }
+  });
+}
+
 // src/plugin/sessionTracker.ts
 function createSessionTracker() {
   const knownSessions = new Set;
@@ -4950,6 +5970,213 @@ function createToolcallTracker(deps) {
   };
 }
 
+// src/storage/graph/fsGraphJournal.ts
+import { join as join2 } from "node:path";
+
+// 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/storage/graph/codec.ts
+var CODEC_VERSION = 1;
+var GENESIS_DIGEST = sha256Hex("openteam/graph-journal/genesis/v1");
+var NUL2 = "\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((key2) => `${JSON.stringify(key2)}:${canonical(record[key2])}`);
+  return `{${entries.join(",")}}`;
+}
+function frameDigest(prev, event) {
+  return sha256Hex(`${prev}${NUL2}${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/fsGraphJournal.ts
+var NUL3 = "\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${NUL3}${runID}${NUL3}${prev}${NUL3}${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/local/embeddings.ts
 function parseEmbeddingsResponse(payload) {
   if (typeof payload !== "object" || payload === null || !Array.isArray(payload.data)) {
@@ -5357,6 +6584,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/index.ts
 function createShellExec($) {
@@ -5531,7 +6856,8 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
     telemetryPath,
     opencodeConfigPath: OPENCODE_CONFIG_PATH,
     orchestratorAgentPath: ORCHESTRATOR_AGENT_PATH,
-    agentDir: dirname2(ORCHESTRATOR_AGENT_PATH)
+    agentDir: dirname2(ORCHESTRATOR_AGENT_PATH),
+    version: PACKAGE_VERSION
   };
 }
 var server = async (ctx, rawOptions) => {
@@ -5621,11 +6947,26 @@ var server = async (ctx, rawOptions) => {
     shadow: shadowDeps,
     tracker: sessionTracker
   });
+  const orchestrateClient = adaptSdkClient(ctx.client);
+  const effectiveGraphMode = graphConfig.effectiveMode;
+  const journalRoot = config.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT;
+  const journal = effectiveGraphMode !== "off" ? createFsGraphJournal(journalRoot) : undefined;
+  const orchestrateTool = createOrchestrateTool({
+    client: orchestrateClient,
+    sink,
+    config,
+    now,
+    newDecisionID: () => crypto.randomUUID(),
+    graphMode: effectiveGraphMode,
+    journal,
+    observeLegacyExecution: graphSurface.observeLegacyExecution
+  });
   return {
     ...hooks,
     tool: {
       openteam: createCommandTool(cliDeps),
-      "openteam-graph": graphSurface.definition
+      "openteam-graph": graphSurface.definition,
+      "openteam-orchestrate": orchestrateTool
     },
     "tool.execute.before": async (input) => {
       toolcalls.before(input);
@@ -5670,5 +7011,6 @@ export {
   src_default as default,
   createEventSink,
   createCliDeps,
-  buildGateInput
+  buildGateInput,
+  PACKAGE_VERSION
 };