@jmanuelcorral/openteam 0.27.0 → 0.28.0

package/dist/cli.js

@@ -7,7 +7,7 @@ import { exec, execFile as execFile4 } from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile2 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname11, resolve as resolve17 } from "node:path";
+import { dirname as dirname12, resolve as resolve19 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 import {
   confirm as clackConfirm,
@@ -577,6 +577,15 @@ function migrateConfig(raw) {
 var consoleDetailMessages = {
   runtimeStateCleanupFailed: "The Console runtime state could not be published and its staging file could not be removed.",
   requestFailed: "The local opencode request failed.",
+  usageUnavailable: "Unavailable / partial",
+  usageCaution: "The host did not report trustworthy usage for every message. Counters are not confirmed totals; no token rate or real savings can be inferred.",
+  timingUnknown: "Unknown",
+  estimatedCost: "Estimated cost",
+  estimatedBaseline: "Estimated baseline",
+  estimatedSavings: "Estimated savings",
+  estimatedInput: "Estimated tokens in",
+  estimatedOutput: "Estimated tokens out",
+  estimatesNotUsage: "Routing estimates are separate from host-reported usage; they are not measured spend or proven savings.",
   nativeToolFailed: "The native tool execution failed.",
   follow: "Follow new activity",
   metadataOnly: "Lifecycle and telemetry stay metadata-only.",
@@ -832,7 +841,13 @@ var OrchestratorConfigSchema = z2.object({
   roles: OrchestratorRolesSchema,
   primary: AgentExecutionPolicySchema.optional(),
   maxRetries: z2.number().int().min(0).optional(),
-  maxModelsPerNode: z2.number().int().positive().optional()
+  maxModelsPerNode: z2.number().int().positive().optional(),
+  taskBudget: z2.object({
+    maxBatches: z2.number().int().min(1).max(1000).optional(),
+    maxAttempts: z2.number().int().min(1).max(1e4).optional(),
+    maxDurationMs: z2.number().int().min(1000).max(86400000).optional(),
+    maxDepth: z2.number().int().min(0).max(32).optional()
+  }).strict().optional()
 }).strict();
 var defaultFrontierModel = {
   providerID: "google",
@@ -1497,6 +1512,32 @@ function withReportedModelSlots(runtime, reported, aliases) {
 }
 
 // src/messages/orchestration.ts
+var reportDeliveryMessages = {
+  description: "Submit the active worker's substantive findings to its assigned durable report. No arbitrary paths or other sessions are accepted. This does not replace the coordinator's completion checks.",
+  status: "Whether the assigned work is done or needs another bounded pass.",
+  findings: "Concrete findings, changes, evidence and remaining work; at most 32768 characters.",
+  assignmentConflict: "A report assignment is already active for this session.",
+  noAssignment: "No active coordinator-owned report assignment exists for this session.",
+  invalidReport: "Report delivery requires substantive findings and a valid done/continue status within 32768 characters.",
+  unsafePath: "The private artifact path is unavailable, linked or outside the allowed boundary.",
+  workspaceMismatch: "Orchestration directory must match the trusted host workspace; a model-authored directory cannot change report or session scope.",
+  submitted: (path) => `Report persisted at ${path}. The coordinator will independently validate current, substantive completion.`
+};
+var taskEffortMessages = {
+  cancelled: "Task execution was cancelled; no replacement attempt was dispatched.",
+  createDeadline: "task-budget-exhausted: duration. Session creation did not settle before the deadline; no prompt was dispatched and retry is disabled.",
+  ledgerInvalid: "The cumulative task-effort ledger is invalid or unavailable; orchestration is stopped rather than resetting its allowance.",
+  exhausted: (reason) => `task-budget-exhausted: ${reason}. Keep existing work and reports. Another batch or worker cannot reset this task's allowance; a new root user turn starts a new task.`,
+  summary: (batches, attempts, remainingMs, remainingBatches, remainingAttempts) => `Task effort: ${batches} batch(es), ${attempts} attempt(s), ${Math.max(0, Math.floor(remainingMs / 1000))}s remaining; ${remainingBatches} batch(es) and ${remainingAttempts} attempt(s) available.`
+};
+var executionPhaseMessages = {
+  "model-request": "Model request",
+  "tool-input": "Preparing tool input",
+  "tool-execution": "Executing a tool",
+  "report-validation": "Validating durable report",
+  idle: "Session idle",
+  unknown: "Session phase unavailable"
+};
 var HOST_SESSION_REQUIRED = "Orchestration requires a nonempty host ToolContext sessionID.";
 var PARENT_OVERRIDE_IGNORED = "parentSessionID override ignored: the trusted host ToolContext session owns this orchestration and its children. Programmatic callers must supply their parent as the ToolContext sessionID.";
 var PARENT_SESSION_DESCRIPTION = "Legacy parent reference. Omit it: the trusted host ToolContext session is the parent. A differing payload value is ignored with an advisory.";
@@ -2359,15 +2400,29 @@ var MessageEventSchema = EventBaseSchema.extend({
   tokensReasoning: z5.number().int().min(0),
   tokensCacheRead: z5.number().int().min(0),
   tokensCacheWrite: z5.number().int().min(0),
-  durationMs: z5.number().int().min(0)
+  durationMs: z5.number().int().min(0),
+  usageStatus: z5.enum(["reported", "missing", "zero-unverified"]).optional(),
+  costStatus: z5.enum(["reported", "unavailable"]).optional(),
+  finish: z5.enum([
+    "stop",
+    "length",
+    "tool-calls",
+    "content-filter",
+    "error",
+    "unknown"
+  ]).optional(),
+  truncatedToolCall: z5.boolean().optional()
 });
 var ToolcallEventSchema = EventBaseSchema.extend({
   type: z5.literal("toolcall"),
   tool: z5.string().min(1),
   callID: z5.string().min(1),
   agent: z5.string().min(1).optional(),
-  durationMs: z5.number().int().min(0),
+  durationMs: z5.number().int().min(0).nullable(),
   ok: z5.boolean(),
+  executed: z5.boolean().optional(),
+  providerExecuted: z5.boolean().optional(),
+  failureKind: z5.enum(["input-invalid", "execution", "unknown"]).optional(),
   title: z5.string().optional()
 });
 var MeetingEventSchema = EventBaseSchema.extend({
@@ -2397,7 +2452,15 @@ var ActivityEventSchema = EventBaseSchema.extend({
   type: z5.literal("activity"),
   kind: z5.enum(["route", "agent", "decision", "commit"]),
   agent: z5.string().min(1).optional(),
-  summary: z5.string().min(1)
+  summary: z5.string().min(1),
+  phase: z5.enum([
+    "model-request",
+    "tool-input",
+    "tool-execution",
+    "report-validation",
+    "idle",
+    "unknown"
+  ]).optional()
 });
 var SessionEndpointEventSchema = EventBaseSchema.extend({
   type: z5.literal("session-endpoint"),
@@ -2860,11 +2923,17 @@ function reportHasSubstance(text) {
 function roleReportPath(batchID, roleID) {
   return `${ROLE_REPORTS_ROOT}/${reportPathSegment(batchID)}/${reportPathSegment(roleID)}.md`;
 }
-function outputContractInstruction(reportPath) {
+function outputContractInstruction(reportPath, structuredReport) {
   return [
     "## Output contract (openteam)",
     "",
-    "Write your complete findings to the report file below using the `write`",
+    ...structuredReport ? [
+      "Prefer `openteam-submit-report` with substantive `findings` and `status`",
+      "(`done` or `continue`): openteam persists only your assigned report and",
+      "confirms the write. Keep submissions concise; split large work into small",
+      "tool calls. If that tool is unavailable, write your complete findings"
+    ] : ["Write your complete findings"],
+    "to the report file below using the `write`",
     "tool (create parent directories as needed), and keep it updated with",
     "`edit` as you progress. This file is the ONLY channel your work reaches",
     "the coordinator: anything you do not write there is discarded and lost,",
@@ -2907,9 +2976,33 @@ function composeSubsessionPrompt(input) {
   ].join(`
 `) : "";
   return {
-    prompt: `${input.prompt}${handoff}
+    prompt: `${input.prompt}${handoff}${input.truncated !== true ? "" : [
+      "",
+      "",
+      "## Truncated tool-call recovery",
+      "",
+      "The previous response ended at the output limit and a tool call was invalid",
+      "before execution. Use smaller, bounded tool calls and concise findings.",
+      "Inspect the existing workspace and assigned report before continuing.",
+      "Never repair and execute the malformed JSON. Produce a fresh, complete",
+      "call only for work that is still necessary. Do not increase model limits",
+      "or change the execution domain. This continuation uses the same pass budget."
+    ].join(`
+`)}${input.repair === undefined ? "" : [
+      "",
+      "",
+      "## Report delivery repair",
+      "",
+      `Previous pass did not prove completion: ${input.repair}.`,
+      "Continue the SAME goal and existing workspace, not a new orchestration.",
+      "Read the assigned report and inspect the existing work first. Do not redo",
+      "completed implementation merely because its delivery failed. Persist the",
+      input.structuredReport === false ? "missing findings in the assigned report; do not just promise a report." : "missing findings with openteam-submit-report; do not just promise a report.",
+      "This repair consumes the existing node pass allowance."
+    ].join(`
+`)}
 
-${outputContractInstruction(reportPath)}`,
+${outputContractInstruction(reportPath, input.structuredReport !== false)}`,
     reportPath
   };
 }
@@ -3286,15 +3379,21 @@ function promptArgs(sessionID, req, signal) {
   }
   return args;
 }
-async function withTimeout(promise, timeoutMs) {
-  if (timeoutMs === undefined) {
+async function withTimeout(promise, timeoutMs, signal) {
+  if (timeoutMs === undefined && signal === undefined) {
     return { kind: "settled", value: await promise };
   }
   let timeoutID;
+  let abortListener;
   const timeout = new Promise((resolve) => {
-    timeoutID = setTimeout(() => {
-      resolve({ kind: "timeout" });
-    }, timeoutMs);
+    if (timeoutMs !== undefined)
+      timeoutID = setTimeout(() => {
+        resolve({ kind: "timeout" });
+      }, timeoutMs);
+    abortListener = () => resolve({ kind: "aborted" });
+    signal?.addEventListener("abort", abortListener, { once: true });
+    if (signal?.aborted)
+      abortListener();
   });
   try {
     return await Promise.race([
@@ -3303,6 +3402,8 @@ async function withTimeout(promise, timeoutMs) {
     ]);
   } finally {
     clearTimeout(timeoutID);
+    if (abortListener !== undefined)
+      signal?.removeEventListener("abort", abortListener);
   }
 }
 async function beforeDeadline(request, deadline, deps) {
@@ -3424,7 +3525,35 @@ async function confirmPromptRequestSettled(isSettled, deps, deadline) {
 async function runSubsession(client, req, deps) {
   let sessionID;
   try {
-    const created = await client.session.create(createArgs(req));
+    deps.signal?.throwIfAborted();
+    const createController = new AbortController;
+    const createSignal = deps.signal === undefined ? createController.signal : AbortSignal.any([deps.signal, createController.signal]);
+    const remaining = deps.deadlineAt === undefined ? undefined : Math.max(0, deps.deadlineAt - deps.now());
+    if (remaining === 0)
+      return {
+        success: false,
+        roleID: req.roleID,
+        model: req.model,
+        failureStage: "create",
+        failureReason: taskEffortMessages.createDeadline,
+        retrySafe: false
+      };
+    const createOutcome = await withTimeout(req.existingSessionID === undefined ? client.session.create(remaining === undefined && deps.signal === undefined ? createArgs(req) : { ...createArgs(req), signal: createSignal }) : Promise.resolve({
+      data: { id: req.existingSessionID },
+      error: undefined
+    }), remaining, deps.signal);
+    if (createOutcome.kind !== "settled") {
+      createController.abort();
+      return {
+        success: false,
+        roleID: req.roleID,
+        model: req.model,
+        failureStage: "create",
+        failureReason: createOutcome.kind === "timeout" ? taskEffortMessages.createDeadline : taskEffortMessages.cancelled,
+        retrySafe: false
+      };
+    }
+    const created = createOutcome.value;
     if (created.error !== undefined) {
       const normalizedFailure = isNormalizedSessionFailure(created.error) ? created.error : undefined;
       return {
@@ -3451,19 +3580,32 @@ async function runSubsession(client, req, deps) {
     try {
       await deps.onSessionCreated?.(sessionID);
     } catch {}
+    await deps.prepareSession?.(sessionID);
+    deps.signal?.throwIfAborted();
+    if (deps.deadlineAt !== undefined && deps.now() >= deps.deadlineAt)
+      return {
+        success: false,
+        sessionID,
+        roleID: req.roleID,
+        model: req.model,
+        failureStage: "create",
+        failureReason: taskEffortMessages.createDeadline,
+        retrySafe: false
+      };
   } catch (error) {
     return {
       success: false,
       roleID: req.roleID,
       model: req.model,
       failureStage: "create",
-      failureReason: errorReason(error),
-      retrySafe: true
+      failureReason: deps.signal?.aborted ? taskEffortMessages.cancelled : errorReason(error),
+      retrySafe: deps.signal?.aborted !== true
     };
   }
   const promptController = new AbortController;
+  const promptSignal = deps.signal === undefined ? promptController.signal : AbortSignal.any([deps.signal, promptController.signal]);
   let promptSettled = false;
-  const promptPromise = client.session.prompt(promptArgs(sessionID, req, promptController.signal)).then((value) => {
+  const promptPromise = client.session.prompt(promptArgs(sessionID, req, promptSignal)).then((value) => {
     promptSettled = true;
     return value;
   }, (error) => {
@@ -3471,8 +3613,9 @@ async function runSubsession(client, req, deps) {
     throw error;
   });
   try {
-    const outcome = await withTimeout(promptPromise, deps.timeoutMs);
-    if (outcome.kind === "timeout") {
+    const timeoutMs = deps.deadlineAt === undefined ? deps.timeoutMs : Math.min(deps.timeoutMs ?? Infinity, Math.max(0, deps.deadlineAt - deps.now()));
+    const outcome = await withTimeout(promptPromise, timeoutMs, deps.signal);
+    if (outcome.kind !== "settled") {
       promptController.abort();
       const stopDeadline = deps.now() + Math.max(0, deps.abortGraceMs);
       const stopped = await confirmSessionStopped(client, sessionID, req.directory, deps, stopDeadline);
@@ -3483,8 +3626,8 @@ async function runSubsession(client, req, deps) {
         roleID: req.roleID,
         model: req.model,
         failureStage: "prompt",
-        failureReason: !stopped.confirmed ? promptStopUnconfirmed(stopped.cause) : requestSettled ? promptTimedOut(deps.timeoutMs ?? 0) : promptStopUnconfirmed("request-unsettled"),
-        retrySafe: stopped.confirmed && requestSettled
+        failureReason: !stopped.confirmed ? promptStopUnconfirmed(stopped.cause) : requestSettled ? deps.deadlineAt !== undefined && deps.now() >= deps.deadlineAt ? taskEffortMessages.exhausted("duration") : outcome.kind === "aborted" ? taskEffortMessages.cancelled : promptTimedOut(deps.timeoutMs ?? 0) : promptStopUnconfirmed("request-unsettled"),
+        retrySafe: stopped.confirmed && requestSettled && outcome.kind !== "aborted" && (deps.deadlineAt === undefined || deps.now() < deps.deadlineAt)
       };
     }
     const prompted = outcome.value;
@@ -3517,8 +3660,8 @@ async function runSubsession(client, req, deps) {
       roleID: req.roleID,
       model: req.model,
       failureStage: "prompt",
-      failureReason: stopped.confirmed ? errorReason(error) : promptStopUnconfirmed(stopped.cause),
-      retrySafe: stopped.confirmed
+      failureReason: stopped.confirmed ? deps.signal?.aborted ? taskEffortMessages.cancelled : errorReason(error) : promptStopUnconfirmed(stopped.cause),
+      retrySafe: stopped.confirmed && deps.signal?.aborted !== true
     };
   }
 }
@@ -3714,12 +3857,15 @@ var TelemetryFailureClassSchema = z7.enum([
   "prompt-auth",
   "prompt-content-filter",
   "prompt-context-length",
+  "prompt-output-truncated",
+  "budget-exhausted",
   "prompt-validation",
   "prompt-connection",
   "prompt-server",
   "unknown"
 ]);
 var FAILURE_CAUSE_RULES = [
+  [["prompt-output-truncated"], "prompt-output-truncated"],
   [
     [
       "rate limit",
@@ -3822,6 +3968,8 @@ function matchFailureCause(lowerReason) {
 }
 function classifyFailureForTelemetry(failureReason, failureStage) {
   const lower = failureReason.toLowerCase();
+  if (lower.startsWith("task-budget-exhausted:"))
+    return "budget-exhausted";
   if (TIMEOUT_NEEDLES.some((needle) => lower.includes(needle))) {
     return "prompt-timeout";
   }
@@ -3900,6 +4048,8 @@ async function recordLifecycle(lifecycle, event) {
   await lifecycle.recorder.append(event);
 }
 function lifecycleFailureFor(subsession) {
+  if (subsession.failureReason?.startsWith("task-budget-exhausted:"))
+    return { class: "budget-exhausted", retryable: false };
   const normalized = subsession.normalizedFailure;
   if (normalized !== undefined) {
     return {
@@ -3969,7 +4119,7 @@ function buildNodeBudgetExhaustedEvent(roleID, passCount, sessionID, ts) {
     passCount
   };
 }
-async function runRoleTaskWithCorrelation(input, deps, correlation, batch, routed, handoff, reportBatchID, attemptLifecycle) {
+async function runRoleTaskWithCorrelation(input, deps, correlation, batch, routed, handoff, reportBatchID, attemptLifecycle, repair, truncated, existingSessionID) {
   const role = roleFor(input);
   if (routed.routeKind === "blocked") {
     throw new Error(coordinatorRoutingBlocked(input.roleID, routed.blockReason));
@@ -3980,13 +4130,18 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
     prompt: input.prompt,
     roleID: input.roleID,
     batchID: reportBatchID,
-    handoff
+    handoff,
+    structuredReport: deps.reportDelivery !== undefined,
+    ...repair === undefined ? {} : { repair },
+    ...truncated === true ? { truncated: true } : {}
   });
   const request = {
     roleID: input.roleID,
     model: decision2.selected,
     prompt: composed.prompt
   };
+  if (existingSessionID !== undefined)
+    request.existingSessionID = existingSessionID;
   if (input.parentSessionID !== undefined) {
     request.parentSessionID = input.parentSessionID;
   }
@@ -4004,11 +4159,17 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
   if (input.directory !== undefined) {
     request.directory = input.directory;
   }
+  let reportLease;
   const subsessionDeps = {
     abortGraceMs: deps.abortGraceMs,
     statusPollMs: deps.statusPollMs,
     now: deps.now,
     delay: deps.delay,
+    prepareSession: async (sessionID) => {
+      if (deps.taskEffort !== undefined)
+        deps.taskEffort.ledger.bindChild(deps.taskEffort.ref, sessionID);
+      reportLease = deps.reportDelivery?.open(sessionID, reportBatchID, input.roleID);
+    },
     ...deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs },
     ...attemptLifecycle === undefined ? {} : {
       onSessionCreated: (sessionID) => recordLifecycle(attemptLifecycle.lifecycle, {
@@ -4053,27 +4214,66 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
   }
   let release;
   let queueObservation;
-  if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
-    const limiter = deps.runtimeLimiter;
-    const priority = priorityForRole(role);
-    const dispatchRuntime = configuredRuntime(runtimeId, input.config) ?? { id: runtimeId };
-    const aliases = localModelAliases(decision2.selected.providerID, input.availableModels);
-    const poolKey = slotPoolKey(withReportedModelSlots(dispatchRuntime, deps.reportedModelSlots?.(runtimeId), aliases), aliases.get(decision2.selected.modelID) ?? decision2.selected.modelID);
-    release = limiter.tryAcquire(poolKey, priority);
-    let waitedMs = 0;
-    if (release === undefined) {
-      const acquisition = await limiter.acquire(poolKey, priority);
-      release = acquisition.release;
-      waitedMs = acquisition.waitedMs;
-    }
-    queueObservation = {
-      runtimeId,
-      waitedMs,
-      activeCount: limiter.activeCount(poolKey),
-      queuedCount: limiter.queuedCount(poolKey)
+  const admission = deps.taskEffort?.ledger.check(deps.taskEffort.ref);
+  async function denied(reason) {
+    const subsession = {
+      roleID: input.roleID,
+      model: decision2.selected,
+      success: false,
+      failureStage: "create",
+      retrySafe: false,
+      failureReason: reason
     };
+    const record = buildRecord(input, decision2, subsession, deps, correlation.decisionID, correlation.batchID);
+    await safeEmit(deps.sink, correlatedCostRecordToRouteEvent(record));
+    return { decision: decision2, subsession, record, reportPath: composed.reportPath };
   }
+  if (admission?.ok === false)
+    return denied(taskEffortMessages.exhausted(admission.reason));
+  if (deps.signal?.aborted)
+    return denied(taskEffortMessages.cancelled);
+  const queueController = new AbortController;
+  const queueSignal = deps.signal === undefined ? queueController.signal : AbortSignal.any([deps.signal, queueController.signal]);
+  const queueDeadline = admission?.ok === true ? setTimeout(() => queueController.abort(), admission.remainingMs) : undefined;
   try {
+    if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
+      const limiter = deps.runtimeLimiter;
+      const priority = priorityForRole(role);
+      const dispatchRuntime = configuredRuntime(runtimeId, input.config) ?? { id: runtimeId };
+      const aliases = localModelAliases(decision2.selected.providerID, input.availableModels);
+      const poolKey = slotPoolKey(withReportedModelSlots(dispatchRuntime, deps.reportedModelSlots?.(runtimeId), aliases), aliases.get(decision2.selected.modelID) ?? decision2.selected.modelID);
+      release = limiter.tryAcquire(poolKey, priority);
+      let waitedMs = 0;
+      if (release === undefined) {
+        let acquisition;
+        try {
+          acquisition = await limiter.acquire(poolKey, priority, queueSignal);
+        } catch (error) {
+          if (!queueSignal.aborted)
+            throw error;
+          return denied(queueController.signal.aborted ? taskEffortMessages.exhausted("duration") : taskEffortMessages.cancelled);
+        }
+        release = acquisition.release;
+        waitedMs = acquisition.waitedMs;
+      }
+      queueObservation = {
+        runtimeId,
+        waitedMs,
+        activeCount: limiter.activeCount(poolKey),
+        queuedCount: limiter.queuedCount(poolKey)
+      };
+    }
+    clearTimeout(queueDeadline);
+    const effort = deps.taskEffort?.ledger.attempt(deps.taskEffort.ref);
+    if (effort?.ok === false) {
+      return denied(taskEffortMessages.exhausted(effort.reason));
+    }
+    if (effort?.ok === true) {
+      subsessionDeps.timeoutMs = Math.min(subsessionDeps.timeoutMs ?? Infinity, effort.remainingMs);
+      subsessionDeps.deadlineAt = deps.now() + effort.remainingMs;
+    }
+    if (deps.signal !== undefined)
+      subsessionDeps.signal = deps.signal;
     if (attemptLifecycle !== undefined) {
       await recordLifecycle(attemptLifecycle.lifecycle, {
         type: "attempt.started",
@@ -4101,8 +4301,17 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
         await safeEmit(deps.sink, buildQueueEvent(queueObservation, sessionID, deps.now(), queueCorrelation));
       }
     }
-    return { decision: decision2, subsession, record, reportPath: composed.reportPath };
+    const reportSubmitted = await reportLease?.close();
+    return {
+      decision: decision2,
+      subsession,
+      record,
+      reportPath: composed.reportPath,
+      ...reportSubmitted === undefined ? {} : { reportSubmitted }
+    };
   } finally {
+    clearTimeout(queueDeadline);
+    await reportLease?.close();
     release?.();
   }
 }
@@ -4214,15 +4423,19 @@ async function assessCurrentAttemptReport(input, before, result, deps) {
       done: false
     };
   }
-  if (after === before) {
+  if (after === before && result.reportSubmitted !== true) {
     return {
       result: withFailure(gated, REPORT_STALE_REASON, "report"),
       done: false
     };
   }
+  const done = parseReportStatus(after) === "done" && reportHasSubstance(after);
   return {
     result: gated,
-    done: parseReportStatus(after) === "done" && reportHasSubstance(after)
+    done,
+    ...!done ? {
+      repairReason: !reportHasSubstance(after) ? "report-without-substance" : parseReportStatus(after) === "continue" ? "report-continue" : "report-status-missing"
+    } : {}
   };
 }
 function failedPassDisposition(subsession) {
@@ -4233,6 +4446,8 @@ function failedPassDisposition(subsession) {
   if (subsession.failureStage === "report")
     return "retry-incomplete";
   if (subsession.normalizedFailure !== undefined) {
+    if (subsession.normalizedFailure.failureClass === "prompt-output-truncated")
+      return "retry-incomplete";
     return subsession.normalizedFailure.retryable ? "retry-transport" : "terminal";
   }
   const failureReason = subsession.failureReason ?? "";
@@ -4332,6 +4547,7 @@ async function runNodeWithIteration(input, deps, correlation, batch, lifecycle)
   let totalPasses = 0;
   let spend = { usd: 0, frontierTokens: 0 };
   let lastResult;
+  let reportRepairReason;
   let escalationReason;
   const reportBatchID = correlation.batchID ?? correlation.decisionID;
   modelLoop:
@@ -4404,14 +4620,19 @@ async function runNodeWithIteration(input, deps, correlation, batch, lifecycle)
           retryIndex: pass - 1,
           selectionCause: lifecycleSelectionCause(totalPasses, modelIndex, retryReason, escalationReason)
         };
-        let result = await runRoleTaskWithCorrelation(input, deps, attemptCorrelation, batch, attemptDecision, modelIndex > 0, reportBatchID, attemptLifecycle);
+        let result = await runRoleTaskWithCorrelation(input, deps, attemptCorrelation, batch, attemptDecision, modelIndex > 0, reportBatchID, attemptLifecycle, reportRepairReason, lastResult?.subsession.normalizedFailure?.failureClass === "prompt-output-truncated", pass > 1 && reportRepairReason !== undefined && (lastResult?.subsession.success || lastResult?.subsession.failureStage === "report") && lastResult?.subsession.retrySafe !== false ? lastResult?.subsession.sessionID : undefined);
         totalPasses += 1;
         spend = {
           usd: attemptDecision.estimatedCostUSD === null ? spend.usd : spend.usd + attemptDecision.estimatedCostUSD,
           frontierTokens: spend.frontierTokens + (attemptDecision.routeKind === "frontier" ? (input.task.estimatedInputTokens ?? 0) + (input.task.estimatedOutputTokens ?? 0) : 0)
         };
+        if (result.subsession.sessionID !== undefined)
+          await deps.sessionPhase?.(result.subsession.sessionID, "report-validation");
         const assessment = await assessCurrentAttemptReport(input, before, result, deps);
+        if (result.subsession.sessionID !== undefined)
+          await deps.sessionPhase?.(result.subsession.sessionID, "idle");
         result = assessment.result;
+        reportRepairReason = assessment.repairReason ?? (result.subsession.failureStage === "report" ? result.subsession.failureReason : undefined);
         lastResult = result;
         if (assessment.done) {
           await recordAttemptTerminal(attemptLifecycle, result, "none", true);
@@ -4497,13 +4718,28 @@ async function runRoleTasks(inputs, deps, options = {}) {
         });
       }
     }
-    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}`);
+    const waveController = deps.taskEffort === undefined ? undefined : new AbortController;
+    const waveDeps = waveController === undefined ? deps : {
+      ...deps,
+      signal: deps.signal === undefined ? waveController.signal : AbortSignal.any([deps.signal, waveController.signal])
+    };
+    const waveTasks = runnable.map(async (input) => {
+      try {
+        const correlation = correlationByRole.get(input.roleID);
+        if (correlation === undefined) {
+          throw new Error(`missing correlation for ${input.roleID}`);
+        }
+        return await runNodeWithIteration(input, waveDeps, correlation, batch, lifecycle);
+      } catch (error) {
+        waveController?.abort();
+        throw error;
       }
-      return runNodeWithIteration(input, deps, correlation, batch, lifecycle);
-    }));
+    });
+    const waveResults = waveController === undefined ? await Promise.all(waveTasks) : (await Promise.allSettled(waveTasks)).map((outcome) => {
+      if (outcome.status === "rejected")
+        throw outcome.reason;
+      return outcome.value;
+    });
     for (const result of waveResults) {
       allResults.push(result);
       if (result.subsession.success) {
@@ -5720,6 +5956,11 @@ function applyRoute(session2, event) {
 }
 function applyMessage(session2, event) {
   session2.messageCount += 1;
+  const unknownUsage = event.usageStatus === undefined ? event.tokensIn + event.tokensOut + event.tokensReasoning + event.tokensCacheRead + event.tokensCacheWrite === 0 : event.usageStatus !== "reported";
+  if (unknownUsage)
+    session2.unavailableUsageMessages = (session2.unavailableUsageMessages ?? 0) + 1;
+  if (event.costStatus === "unavailable" || event.costStatus === undefined && unknownUsage && event.costUSD === 0)
+    session2.unavailableCostMessages = (session2.unavailableCostMessages ?? 0) + 1;
   session2.realCostUSD += event.costUSD;
   session2.tokensIn += event.tokensIn;
   session2.tokensOut += event.tokensOut;
@@ -5731,7 +5972,9 @@ function applyMessage(session2, event) {
 }
 function applyToolUsage(stats, event) {
   stats.count += 1;
-  stats.totalDurationMs += event.durationMs;
+  stats.totalDurationMs += event.durationMs ?? 0;
+  if (event.durationMs === null)
+    stats.unknownDurationCount = (stats.unknownDurationCount ?? 0) + 1;
   if (event.ok) {
     stats.ok += 1;
   } else {
@@ -5774,6 +6017,8 @@ function mergeTool(target, source) {
   target.ok += source.ok;
   target.failed += source.failed;
   target.totalDurationMs += source.totalDurationMs;
+  if (source.unknownDurationCount !== undefined)
+    target.unknownDurationCount = (target.unknownDurationCount ?? 0) + source.unknownDurationCount;
 }
 function accumulateTotals(totals, session2) {
   totals.sessions += 1;
@@ -5784,6 +6029,10 @@ function accumulateTotals(totals, session2) {
   totals.estimatedSavingsUSD = addEstimate(totals.estimatedSavingsUSD, session2.estimatedSavingsUSD);
   totals.realCostUSD += session2.realCostUSD;
   totals.messageCount += session2.messageCount;
+  if (session2.unavailableUsageMessages !== undefined)
+    totals.unavailableUsageMessages = (totals.unavailableUsageMessages ?? 0) + session2.unavailableUsageMessages;
+  if (session2.unavailableCostMessages !== undefined)
+    totals.unavailableCostMessages = (totals.unavailableCostMessages ?? 0) + session2.unavailableCostMessages;
   totals.tokensIn += session2.tokensIn;
   totals.tokensOut += session2.tokensOut;
   totals.tokensReasoning += session2.tokensReasoning;
@@ -5850,6 +6099,7 @@ function aggregateEvents(events) {
   const decisions = [];
   const meetings = [];
   const activity = [];
+  const calls = new Map;
   const sessionFor = (sessionID, ts) => {
     const existing = sessions.get(sessionID);
     if (existing === undefined) {
@@ -5870,7 +6120,13 @@ function aggregateEvents(events) {
         applyMessage(sessionFor(event.sessionID, event.ts), event);
         break;
       case "toolcall":
-        applyToolcall(sessionFor(event.sessionID, event.ts), event);
+        {
+          const key = `${event.sessionID}\x00${event.callID}`;
+          const previous = calls.get(key);
+          if (previous === undefined || previous.ok && !event.ok || previous.ok === event.ok && (event.durationMs ?? -1) > (previous.durationMs ?? -1)) {
+            calls.set(key, event);
+          }
+        }
         break;
       case "session-endpoint":
         applyEndpoint(sessionFor(event.sessionID, event.ts), event);
@@ -5883,9 +6139,19 @@ function aggregateEvents(events) {
         break;
       case "activity":
         activity.push(toActivity(event));
+        if (event.phase !== undefined) {
+          const session2 = sessionFor(event.sessionID, event.ts);
+          if (event.ts >= (session2.phaseAt ?? -Infinity)) {
+            session2.phase = event.phase;
+            session2.phaseAt = event.ts;
+          }
+        }
         break;
     }
   }
+  for (const event of calls.values()) {
+    applyToolcall(sessionFor(event.sessionID, event.ts), event);
+  }
   const totals = {
     sessions: 0,
     routeCount: 0,
@@ -6176,8 +6442,15 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
   ["graph.worktrees", ["enabled"]],
   ["lifecycle", ["root", "retention"]],
   ["lifecycle.retention", ["maxTerminalRuns", "maxAgeDays", "maxBytes"]],
-  ["orchestrator", ["roles", "primary", "maxRetries", "maxModelsPerNode"]],
+  [
+    "orchestrator",
+    ["roles", "primary", "maxRetries", "maxModelsPerNode", "taskBudget"]
+  ],
   ["orchestrator.primary", ["executionMode", "model", "fallbacks"]],
+  [
+    "orchestrator.taskBudget",
+    ["maxBatches", "maxAttempts", "maxDurationMs", "maxDepth"]
+  ],
   ["orchestrator.primary.fallbacks[]", MODEL_REF_KEYS]
 ]);
 function isUnrecognizedKeysIssue(issue) {
@@ -7466,6 +7739,488 @@ async function handleLifecycleHistoryRoute(request, response, url, deps) {
   return true;
 }
 
+// src/messages/agentView.ts
+var agentViewMessages = {
+  title: "Agent workspace",
+  graph: "Graph",
+  chronology: "Chronology",
+  filters: "Filters",
+  search: "Search operations",
+  searchHint: "Alias, role, model or operation ID",
+  allRoles: "All roles",
+  allStates: "All states",
+  role: "Role",
+  state: "State",
+  matches: "Matching operations",
+  noMatches: "No operations match these filters.",
+  filterNote: "Filtered operations stay dimmed to preserve context.",
+  hierarchy: "Hierarchy",
+  dependency: "Prerequisite",
+  legend: "Solid: parent/child. Dashed: prerequisite. Neither implies model activity.",
+  inspector: "Operation inspector",
+  root: "Select coordinator",
+  isolate: "Isolate hierarchy branch",
+  clearIsolation: "Show all branches",
+  selectedFiltered: "The selected operation is outside the current filters.",
+  zoomIn: "Zoom in",
+  zoomOut: "Zoom out",
+  fit: "Fit graph",
+  reset: "Reset view",
+  canvas: "Agent graph. Select an operation with Enter or Space. Arrow keys pan the canvas; plus and minus zoom.",
+  play: "Play recorded events",
+  pause: "Pause replay",
+  previous: "Previous event",
+  next: "Next event",
+  speed: "Events per second",
+  replayNote: "Replay uses recorded event prefixes. Current conversations and telemetry are never shown at historical cursors.",
+  noEvents: "No recorded events at this cursor.",
+  eventWindow: "Showing the most recent 1,000 events in this prefix. Use the cursor to inspect earlier history.",
+  attempts: "Attempts",
+  failures: "Failed attempts",
+  noModel: "Model not recorded",
+  noSession: "No session created",
+  phase: "Observed phase",
+  phaseUnknown: "Session phase unavailable",
+  historicalMetrics: "Live phase and usage are unavailable in historical replay.",
+  usage: "Reported input / output tokens",
+  usageUnavailable: "Usage unavailable / partial",
+  cost: "Reported cost",
+  costUnavailable: "Cost unavailable / partial",
+  tools: "Tool calls / failures",
+  noTools: "No tool outcomes observed",
+  related: "Related batches",
+  relatedNote: "Same task, or a batch whose root session is this operation's child session. Outcomes remain independent.",
+  relatedFailed: "Related failed batches",
+  missing: "Unresolved references",
+  states: {
+    waiting: "Waiting",
+    selected: "Selected",
+    queued: "Queued",
+    running: "Running",
+    succeeded: "Succeeded",
+    failed: "Failed",
+    blocked: "Blocked",
+    cancelled: "Cancelled",
+    interrupted: "Interrupted",
+    unknown: "Unknown"
+  },
+  events: {
+    "run.started": "Batch started",
+    "operation.queued": "Operation queued",
+    "attempt.model-selected": "Model selected",
+    "attempt.queued": "Attempt queued",
+    "attempt.started": "Attempt started",
+    "session.created": "Session created",
+    "attempt.terminal": "Attempt finished",
+    "operation.terminal": "Operation finished",
+    "run.terminal": "Batch finished"
+  }
+};
+
+// src/console/agentView.ts
+function layoutAgentOperations(operations) {
+  const byID = new Map(operations.map((operation) => [operation.operationID, operation]));
+  const rows = new Map;
+  const nodes = [];
+  let width = 256;
+  let height = 152;
+  for (const operation of byID.values()) {
+    const seen = new Set([operation.operationID]);
+    let parent = operation.parentOperationID;
+    let depth = 0;
+    while (parent !== undefined && byID.has(parent) && !seen.has(parent)) {
+      seen.add(parent);
+      depth++;
+      parent = byID.get(parent)?.parentOperationID;
+    }
+    const row = rows.get(depth) ?? 0;
+    rows.set(depth, row + 1);
+    const x = 28 + depth * 268;
+    const y = 28 + row * 148;
+    nodes.push({ id: operation.operationID, x, y });
+    width = Math.max(width, x + 256);
+    height = Math.max(height, y + 144);
+  }
+  return { nodes, width, height };
+}
+var AGENT_VIEW_CLIENT_JS = `
+var layoutAgentOperations=${layoutAgentOperations.toString()};
+function createAgentViewer(host,options){
+  var msg=${JSON.stringify(agentViewMessages)},phases=${JSON.stringify(executionPhaseMessages)};
+  var source=null,selected=null,isolated=null,run=null,mode='graph',playing=false,playTimer=null,pendingCursor=null;
+  var scale=1,offsetX=24,offsetY=24,positioned=false,drag=null,summaries=new Map((document.__consoleTelemetry||[]).map(function(item){return [item.sessionID,item]})),nodes=new Map(),layout=null;
+  var metricsKey='',relatedKey='';
+  var namespace='http://www.w3.org/2000/svg',byID=new Map(),tree=null,filtered=new Set(),openDetails=new Map();
+  function element(tag,text,className){var node=document.createElement(tag);if(text!==undefined){node.textContent=text}if(className){node.className=className}return node}
+  function button(label,action,marker){
+    var node=element('button',label);node.type='button';node.setAttribute('aria-label',label);
+    if(marker){node.setAttribute('data-agent-'+marker,'')}
+    node.addEventListener('click',action);return node;
+  }
+  function svgElement(tag,attributes,text){
+    var node=document.createElementNS(namespace,tag);
+    Object.keys(attributes||{}).forEach(function(key){node.setAttribute(key,String(attributes[key]))});
+    if(text!==undefined){node.textContent=text}return node;
+  }
+  function label(text,input){var node=element('label',text);node.appendChild(input);return node}
+  function option(select,value,text){var node=element('option',text);node.value=value;select.appendChild(node)}
+  var shell=element('section',undefined,'av-workspace');shell.setAttribute('aria-label',msg.title);
+  var tools=element('div',undefined,'av-toolbar');
+  var graphButton=button(msg.graph,function(){setMode('graph')},'graph');
+  var chronologyButton=button(msg.chronology,function(){setMode('chronology')},'chronology');
+  tools.append(graphButton,chronologyButton);
+  tools.appendChild(button(msg.previous,function(){pause();seek(Math.max(0,source.cursor-1),true)},'previous'));
+  var playButton=button(msg.play,togglePlayback,'play');tools.appendChild(playButton);
+  tools.appendChild(button(msg.next,function(){pause();seek(Math.min(source.head,source.cursor+1),true)},'next'));
+  var speed=element('select');speed.setAttribute('aria-label',msg.speed);
+  [1,2,5].forEach(function(value){option(speed,String(value),String(value))});
+  tools.appendChild(label(msg.speed,speed));
+  var count=element('span',undefined,'av-count');count.setAttribute('role','status');tools.appendChild(count);
+  shell.appendChild(tools);
+  var body=element('div',undefined,'av-body'),filters=element('aside',undefined,'av-filters');
+  filters.appendChild(element('h3',msg.filters));
+  var search=element('input');search.type='search';search.placeholder=msg.searchHint;search.setAttribute('data-agent-search','');
+  filters.appendChild(label(msg.search,search));
+  var role=element('select');role.setAttribute('data-agent-role','');option(role,'',msg.allRoles);
+  filters.appendChild(label(msg.role,role));
+  var status=element('select');status.setAttribute('data-agent-state','');option(status,'',msg.allStates);
+  Object.keys(msg.states).forEach(function(key){option(status,key,msg.states[key])});
+  filters.appendChild(label(msg.state,status));
+  var isolate=button(msg.isolate,function(){isolated=isolated?null:selected;applyFilters()},'isolate');
+  filters.appendChild(isolate);
+  filters.appendChild(button(msg.root,function(){select(source.rootOperationID)},'root'));
+  filters.appendChild(element('p',msg.filterNote));
+  var legend=element('div',undefined,'av-legend');legend.appendChild(element('p',msg.hierarchy,'av-solid'));
+  legend.appendChild(element('p',msg.dependency,'av-dashed'));legend.appendChild(element('p',msg.legend));filters.appendChild(legend);
+  var unresolved=element('p');unresolved.setAttribute('data-agent-unresolved','');filters.appendChild(unresolved);
+  body.appendChild(filters);
+  var center=element('div',undefined,'av-center');
+  var canvas=element('div',undefined,'av-canvas');
+  var zoomTools=element('div',undefined,'av-zoom');
+  zoomTools.append(button(msg.zoomIn,function(){zoom(1.2)},'zoom-in'),button(msg.zoomOut,function(){zoom(1/1.2)},'zoom-out'),
+    button(msg.fit,fit,'fit'),button(msg.reset,function(){scale=1;offsetX=24;offsetY=24;transform()},'reset'));
+  canvas.appendChild(zoomTools);
+  var svg=svgElement('svg',{'class':'av-graph','role':'group','aria-label':msg.canvas,tabindex:0});
+  var viewport=svgElement('g',{'class':'av-viewport'});svg.appendChild(viewport);canvas.appendChild(svg);
+  center.appendChild(canvas);
+  var chronology=element('ol',undefined,'av-chronology');chronology.hidden=true;chronology.setAttribute('aria-label',msg.chronology);
+  center.appendChild(chronology);
+  var empty=element('p',msg.noMatches,'av-empty');empty.hidden=true;center.appendChild(empty);
+  body.appendChild(center);
+  var inspector=element('aside',undefined,'av-inspector');
+  inspector.setAttribute('aria-label',msg.inspector);inspector.appendChild(element('h3',msg.inspector));
+  var notice=element('p',msg.selectedFiltered);notice.hidden=true;inspector.appendChild(notice);
+  var metrics=element('div',undefined,'av-metrics');metrics.setAttribute('data-agent-metrics','');inspector.appendChild(metrics);
+  var inspectorTree=element('div');inspectorTree.setAttribute('data-agent-inspector-tree','');inspector.appendChild(inspectorTree);
+  var related=element('section',undefined,'av-related');inspector.appendChild(related);
+  body.appendChild(inspector);shell.appendChild(body);
+  var replayNote=element('p',msg.replayNote,'av-replay-note');shell.appendChild(replayNote);
+  host.replaceChildren(shell);
+  host.classList.add('av-host');
+  function setMode(value){
+    mode=value;canvas.hidden=value!=='graph';chronology.hidden=value!=='chronology';
+    graphButton.setAttribute('aria-pressed',String(value==='graph'));chronologyButton.setAttribute('aria-pressed',String(value==='chronology'));
+    if(value==='graph'&&!positioned){fit()}
+  }
+  function transform(){
+    viewport.setAttribute('transform','translate('+offsetX+' '+offsetY+') scale('+scale+')');
+    svg.setAttribute('data-agent-scale',String(scale));
+  }
+  function fit(){
+    if(!layout){return}
+    var bounds=svg.getBoundingClientRect();if(!bounds.width||!bounds.height){return}
+    scale=Math.max(.06,Math.min(1.25,(bounds.width-48)/layout.width,(bounds.height-92)/layout.height));
+    offsetX=(bounds.width-layout.width*scale)/2;offsetY=60;positioned=true;transform();
+  }
+  function zoom(factor,x,y){
+    var bounds=svg.getBoundingClientRect(),cx=x===undefined?bounds.width/2:x,cy=y===undefined?bounds.height/2:y;
+    var next=Math.max(.06,Math.min(3,scale*factor));
+    offsetX=cx-(cx-offsetX)*next/scale;offsetY=cy-(cy-offsetY)*next/scale;scale=next;positioned=true;transform();
+  }
+  svg.addEventListener('wheel',function(event){
+    if(!event.ctrlKey&&!event.metaKey){return}
+    event.preventDefault();var bounds=svg.getBoundingClientRect();zoom(event.deltaY>0?1/1.15:1.15,event.clientX-bounds.left,event.clientY-bounds.top);
+  },{passive:false});
+  svg.addEventListener('pointerdown',function(event){
+    if(event.button!==0||event.target.closest('[data-agent-operation]')){return}
+    drag={x:event.clientX,y:event.clientY,left:offsetX,top:offsetY,id:event.pointerId};
+    svg.setPointerCapture(event.pointerId);
+  });
+  svg.addEventListener('pointermove',function(event){
+    if(!drag||event.pointerId!==drag.id){return}
+    offsetX=drag.left+event.clientX-drag.x;offsetY=drag.top+event.clientY-drag.y;positioned=true;transform();
+  });
+  function endDrag(){drag=null}
+  svg.addEventListener('pointerup',endDrag);svg.addEventListener('pointercancel',endDrag);svg.addEventListener('lostpointercapture',endDrag);
+  svg.addEventListener('keydown',function(event){
+    if(event.key==='+'||event.key==='='){event.preventDefault();zoom(1.2)}
+    else if(event.key==='-'){event.preventDefault();zoom(1/1.2)}
+    else if(['ArrowLeft','ArrowRight','ArrowUp','ArrowDown'].includes(event.key)){
+      event.preventDefault();offsetX+=event.key==='ArrowLeft'?40:event.key==='ArrowRight'?-40:0;
+      offsetY+=event.key==='ArrowUp'?40:event.key==='ArrowDown'?-40:0;positioned=true;transform();
+    }
+  });
+  function lastAttempt(operation){var attempts=operation.attempts||[];return attempts[attempts.length-1]}
+  function phaseFor(operation){
+    if(operation.state!=='running'){return msg.states[operation.state]||msg.states.unknown}
+    if(!options.isLive()){return msg.phaseUnknown}
+    var attempt=lastAttempt(operation),summary=summaries.get(attempt&&attempt.sessionID||options.rootSessionID(operation.operationID));
+    return summary&&phases[summary.phase]||msg.phaseUnknown;
+  }
+  function appendMetric(name,value){var row=element('p');row.append(element('span',name),element('strong',String(value)));metrics.appendChild(row)}
+  function updateMetrics(){
+    if(!source){return}
+    nodes.forEach(function(node,id){var phase=phaseFor(byID.get(id));if(node.phase.textContent!==phase){node.phase.textContent=phase}});
+    var operation=byID.get(selected),attempt=operation&&lastAttempt(operation);
+    var session=attempt&&attempt.sessionID||options.rootSessionID(operation&&operation.operationID),summary=summaries.get(session);
+    var key=JSON.stringify([source.runID,selected,options.isLive(),operation&&phaseFor(operation),summary]);
+    if(metricsKey===key){return}metricsKey=key;
+    metrics.replaceChildren();
+    if(!options.isLive()){metrics.appendChild(element('p',msg.historicalMetrics));return}
+    if(!operation){return}
+    appendMetric(msg.phase,phaseFor(operation));
+    var hasUsage=summary&&summary.messageCount>0&&!(summary.unavailableUsageMessages>0);
+    appendMetric(msg.usage,hasUsage?summary.tokensIn+' / '+summary.tokensOut:msg.usageUnavailable);
+    appendMetric(msg.cost,summary&&summary.messageCount>0&&!(summary.unavailableCostMessages>0)?'$'+summary.realCostUSD.toFixed(5):msg.costUnavailable);
+    appendMetric(msg.tools,summary&&summary.toolcalls.count?summary.toolcalls.count+' / '+summary.toolcalls.failed:msg.noTools);
+  }
+  function updateRelated(){
+    if(!source){return}
+    var current=(options.runs()||[]).find(function(item){return item.runID===source.runID});
+    var operation=byID.get(selected),sessions=new Set((operation&&operation.attempts||[]).map(function(attempt){return attempt.sessionID}).filter(Boolean));
+    var others=(options.isLive()?options.runs():[]).filter(function(item){return item.runID!==source.runID&&
+      (current&&item.rootTaskID===current.rootTaskID||item.rootSessionID&&sessions.has(item.rootSessionID))});
+    var key=JSON.stringify([source.runID,selected,others]);if(relatedKey===key){return}relatedKey=key;
+    related.replaceChildren();
+    if(!others.length){return}
+    related.appendChild(element('h4',msg.related));related.appendChild(element('p',msg.relatedNote));
+    var failed=others.filter(function(item){return item.terminalOutcome==='failed'}).length;
+    if(failed){related.appendChild(element('p',msg.relatedFailed+': '+failed,'av-warning'))}
+    others.forEach(function(item){
+      var link=element('a',item.runID+' · '+(msg.states[item.terminalOutcome]||msg.states.unknown));
+      var url=new URL(window.location.href);url.searchParams.set('run',item.runID);url.searchParams.delete('cursor');link.href=url.href;
+      link.setAttribute('data-agent-related-run',item.runID);link.setAttribute('data-state',item.terminalOutcome||'unknown');related.appendChild(link);
+    });
+  }
+  function select(id,quiet){
+    if(!byID.has(id)){selected=null;shell.removeAttribute('data-agent-selected');updateMetrics();updateRelated();return}
+    selected=id;shell.setAttribute('data-agent-selected',id);
+    nodes.forEach(function(node,key){node.group.setAttribute('aria-pressed',String(key===id))});
+    inspectorTree.querySelectorAll('.lct-operation-card').forEach(function(card){
+      card.hidden=card.parentElement.getAttribute('data-lifecycle-operation-id')!==id;
+    });
+    notice.hidden=!filtered.has(id);
+    inspector.scrollTop=quiet?inspector.scrollTop:0;
+    updateMetrics();updateRelated();
+    if(!quiet){document.dispatchEvent(new CustomEvent('console-conversation-selection'))}
+  }
+  function applyFilters(){
+    if(!source){return}
+    var term=search.value.trim().toLowerCase(),branch=null;
+    if(isolated&&byID.has(isolated)){
+      branch=new Set([isolated]);var parent=byID.get(isolated).parentOperationID;
+      while(parent&&byID.has(parent)&&!branch.has(parent)){branch.add(parent);parent=byID.get(parent).parentOperationID}
+      var descend=new Set([isolated]),changed=true;
+      while(changed){changed=false;byID.forEach(function(op,id){if(descend.has(op.parentOperationID)&&!descend.has(id)){descend.add(id);changed=true}})}
+      descend.forEach(function(id){branch.add(id)});
+    }
+    filtered=new Set();
+    byID.forEach(function(op,id){
+      var models=(op.attempts||[]).map(function(a){return a.model?a.model.providerID+'/'+a.model.modelID:''}).join(' ');
+      var match=(!term||[id,op.agentID||'',op.roleID,models].join(' ').toLowerCase().includes(term))&&
+        (!role.value||op.roleID===role.value)&&(!status.value||op.state===status.value)&&(!branch||branch.has(id));
+      if(!match){filtered.add(id)}
+      var node=nodes.get(id);if(node){node.group.setAttribute('data-filtered',String(!match));node.group.setAttribute('tabindex',match?'0':'-1')}
+    });
+    viewport.querySelectorAll('[data-edge-from]').forEach(function(edge){
+      edge.setAttribute('data-filtered',String(filtered.has(edge.getAttribute('data-edge-from'))||filtered.has(edge.getAttribute('data-edge-to'))));
+    });
+    chronology.querySelectorAll('[data-event-operation]').forEach(function(row){row.hidden=filtered.has(row.getAttribute('data-event-operation'))});
+    count.textContent=msg.matches+': '+(byID.size-filtered.size)+' / '+byID.size;
+    empty.hidden=filtered.size!==byID.size||byID.size===0;
+    notice.hidden=!filtered.has(selected);isolate.textContent=isolated?msg.clearIsolation:msg.isolate;
+    isolate.setAttribute('aria-pressed',String(!!isolated));
+  }
+  search.addEventListener('input',applyFilters);role.addEventListener('change',applyFilters);status.addEventListener('change',applyFilters);
+  function buildGraph(){
+    var focus=document.activeElement&&document.activeElement.getAttribute('data-agent-operation');
+    viewport.replaceChildren();nodes.clear();layout=layoutAgentOperations(Array.from(byID.values()));
+    var positions=new Map(layout.nodes.map(function(node){return [node.id,node]}));
+    var defs=svgElement('defs'),marker=svgElement('marker',{id:'agent-dependency-arrow',viewBox:'0 0 8 8',refX:7,refY:4,markerWidth:6,markerHeight:6,orient:'auto'});
+    marker.appendChild(svgElement('path',{d:'M0 0 L8 4 L0 8 Z',fill:'#8a777e'}));defs.appendChild(marker);viewport.appendChild(defs);
+    var missing=0;
+    function edge(from,to,kind){
+      var a=positions.get(from),b=positions.get(to);if(!a||!b){missing++;return}
+      var x1=a.x+228,y1=a.y+56,x2=b.x,y2=b.y+56,middle=(x1+x2)/2;
+      var path=svgElement('path',{'class':'av-edge','data-kind':kind,'data-edge-from':from,'data-edge-to':to,
+        d:'M'+x1+' '+y1+' C'+middle+' '+y1+' '+middle+' '+y2+' '+x2+' '+y2});
+      if(kind==='dependency'){path.setAttribute('marker-end','url(#agent-dependency-arrow)')}
+      path.appendChild(svgElement('title',{},(kind==='hierarchy'?msg.hierarchy:msg.dependency)+': '+from+' -> '+to));viewport.appendChild(path);
+    }
+    byID.forEach(function(operation){
+      if(operation.parentOperationID){edge(operation.parentOperationID,operation.operationID,'hierarchy')}
+      (operation.dependsOnOperationIDs||[]).forEach(function(id){edge(id,operation.operationID,'dependency')});
+    });
+    unresolved.textContent=msg.missing+': '+missing;unresolved.hidden=missing===0;
+    layout.nodes.forEach(function(position){
+      var operation=byID.get(position.id),attempt=lastAttempt(operation),identity=operation.agentID||operation.roleID;
+      var group=svgElement('g',{'class':'av-node',transform:'translate('+position.x+' '+position.y+')','data-agent-operation':position.id,
+        'data-state':operation.state,role:'button',tabindex:0,'aria-label':identity+' · '+operation.roleID+' · '+(msg.states[operation.state]||msg.states.unknown)});
+      group.appendChild(svgElement('rect',{width:228,height:120,rx:12}));
+      group.appendChild(svgElement('title',{},identity+' · '+position.id));
+      group.appendChild(svgElement('text',{x:14,y:23,'class':'av-role'},operation.roleID.slice(0,31)));
+      group.appendChild(svgElement('text',{x:14,y:45,'class':'av-name'},identity.slice(0,28)));
+      var model=attempt&&attempt.model?attempt.model.providerID+'/'+attempt.model.modelID:msg.noModel;
+      group.appendChild(svgElement('text',{x:14,y:64,'class':'av-model'},model.slice(0,32)));
+      var phase=svgElement('text',{x:14,y:84,'class':'av-phase'},phaseFor(operation));group.appendChild(phase);
+      var failures=(operation.attempts||[]).filter(function(a){return ['failed','interrupted','cancelled'].includes(a.state)}).length;
+      group.appendChild(svgElement('text',{x:14,y:105,'class':'av-attempts'},msg.attempts+': '+operation.attempts.length+' · '+msg.failures+': '+failures));
+      group.addEventListener('click',function(){select(position.id)});
+      group.addEventListener('keydown',function(event){if(event.key==='Enter'||event.key===' '){event.preventDefault();select(position.id)}});
+      nodes.set(position.id,{group:group,phase:phase});viewport.appendChild(group);
+    });
+    transform();if(!positioned){fit()}
+    if(focus&&nodes.has(focus)){nodes.get(focus).group.focus({preventScroll:true})}
+  }
+  function buildChronology(){
+    var top=chronology.scrollTop;chronology.replaceChildren();var events=source.timeline||[];
+    if(!events.length){chronology.appendChild(element('li',msg.noEvents))}
+    if(events.length>1000){chronology.appendChild(element('li',msg.eventWindow))}
+    events.slice(-1000).forEach(function(event){
+      var id=event.operationID||event.root&&event.root.operationID||source.rootOperationID,op=byID.get(id);
+      var row=element('li');row.setAttribute('data-event-operation',id);row.setAttribute('data-event-seq',String(event.seq));
+      var item=button('',function(){pause();select(id);seek(event.seq+1,true)});
+      item.appendChild(element('time',new Date(event.at).toISOString()));
+      item.appendChild(element('strong',msg.events[event.type]||event.type));
+      item.appendChild(element('span',(op&&(op.agentID||op.roleID)||id)+(event.outcome?' · '+(msg.states[event.outcome]||event.outcome):'')));
+      row.appendChild(item);chronology.appendChild(row);
+    });chronology.scrollTop=top;
+  }
+  function seek(cursor,push){pendingCursor=cursor;options.seek(cursor,push)}
+  function pause(){playing=false;clearTimeout(playTimer);playTimer=null;playButton.textContent=msg.play;playButton.setAttribute('aria-label',msg.play);playButton.setAttribute('aria-pressed','false')}
+  function tick(){
+    if(!playing||!source){return}
+    if(document.hidden||!shell.isConnected){pause();return}
+    if(pendingCursor===null||source.cursor===pendingCursor){
+      if(source.cursor>=source.head){pause();return}
+      seek(source.cursor+1,false);
+    }
+    playTimer=setTimeout(tick,1000/Number(speed.value));
+  }
+  function togglePlayback(){
+    if(playing){pause();return}if(!source||source.head===0){return}
+    playing=true;playButton.textContent=msg.pause;playButton.setAttribute('aria-label',msg.pause);playButton.setAttribute('aria-pressed','true');
+    seek(source.cursor>=source.head?0:source.cursor,true);playTimer=setTimeout(tick,1000/Number(speed.value));
+  }
+  function rememberDetails(){
+    if(!tree){return}
+    tree.querySelectorAll('[data-lifecycle-operation-id]').forEach(function(article){
+      var card=article.querySelector('.lct-operation-card');if(!card){return}
+      card.querySelectorAll('details:not(.lc-conversation details)').forEach(function(detail,index){
+        openDetails.set(article.getAttribute('data-lifecycle-operation-id')+':'+index,detail.open);
+      });
+    });
+  }
+  function update(projection,nextTree){
+    var changedRun=run!==projection.runID;
+    if(changedRun){pause();selected=projection.rootOperationID;isolated=null;positioned=false;openDetails.clear()}
+    else{rememberDetails()}
+    run=projection.runID;source=projection;
+    byID=new Map((projection.operations||[]).map(function(op){return [op.operationID,op]}));
+    if(!byID.has(selected)){selected=byID.has(projection.rootOperationID)?projection.rootOperationID:byID.keys().next().value}
+    var oldRole=role.value;role.replaceChildren();option(role,'',msg.allRoles);
+    Array.from(new Set(Array.from(byID.values()).map(function(op){return op.roleID}))).sort().forEach(function(value){option(role,value,value)});
+    if(Array.from(role.options).some(function(item){return item.value===oldRole})){role.value=oldRole}
+    var top=inspector.scrollTop;tree=nextTree;inspectorTree.replaceChildren(tree);
+    tree.querySelectorAll('[data-lifecycle-operation-id]').forEach(function(article){
+      var card=article.querySelector('.lct-operation-card');if(!card){return}
+      card.querySelectorAll('details').forEach(function(detail,index){
+        var saved=openDetails.get(article.getAttribute('data-lifecycle-operation-id')+':'+index);if(saved!==undefined){detail.open=saved}
+      });
+    });
+    isolate.disabled=byID.size===0;
+    buildGraph();buildChronology();applyFilters();select(selected,true);setMode(mode);inspector.scrollTop=changedRun?0:top;
+  }
+  function onTelemetry(event){
+    summaries=new Map((event.detail&&event.detail.sessions||[]).map(function(item){return [item.sessionID,item]}));
+    if(shell.isConnected){updateMetrics()}
+  }
+  function onVisibility(){if(document.hidden){pause()}}
+  document.addEventListener('console-telemetry',onTelemetry);
+  document.addEventListener('visibilitychange',onVisibility);
+  window.addEventListener('pagehide',pause);
+  return {update:update,pause:pause,connected:function(){return shell.isConnected},refresh:function(){updateMetrics();updateRelated();if(!positioned&&mode==='graph'){fit()}},
+    dispose:function(){pause();document.removeEventListener('console-telemetry',onTelemetry);document.removeEventListener('visibilitychange',onVisibility);
+      window.removeEventListener('pagehide',pause);host.classList.remove('av-host')}};
+}
+`;
+var AGENT_VIEW_STYLE = `
+#screen-tree:has(.av-workspace){max-width:none}
+.av-host{max-height:none;padding:0;overflow:visible}
+.av-workspace{--av-bg:#121012;--av-text:#f3edef;--av-muted:#b7aab0;--av-line:#3b3036;--av-accent:#c9184c;--cp-bg:#121012;--cp-surface:#1d181c;--cp-surface-soft:#262026;--cp-text:#f3edef;--cp-text-muted:#b7aab0;--cp-border:#3b3036;--cp-border-strong:#79646d;--cp-accent:#f47b9e;--cp-success:#77c491;--cp-danger:#ff8699;color:var(--av-text);background:var(--av-bg);border:1px solid var(--av-line);border-radius:14px;overflow:hidden}
+.av-workspace [hidden]{display:none!important}
+.av-workspace button,.av-workspace input,.av-workspace select{font:inherit;color:inherit;background:#211b20;border:1px solid var(--av-line);border-radius:7px;padding:6px 9px}
+.av-workspace button:hover,.av-workspace button[aria-pressed="true"]{border-color:#ee7399;color:#ffa2be}
+.av-workspace :focus-visible{outline:2px solid #ec5282;outline-offset:3px}
+.av-toolbar{display:flex;align-items:center;gap:7px;flex-wrap:wrap;padding:12px;border-bottom:1px solid var(--av-line);font-size:12px}
+.av-toolbar label{display:flex;align-items:center;gap:6px}.av-count{margin-left:auto;color:var(--av-muted)}
+.av-body{display:grid;grid-template-columns:180px minmax(300px,1fr) minmax(280px,360px);height:min(78vh,860px);min-height:520px}
+.av-filters{padding:16px 12px;border-right:1px solid var(--av-line);overflow:auto;font-size:12px}
+.av-filters h3,.av-inspector>h3{color:var(--av-text);font-size:12px;letter-spacing:.06em;text-transform:uppercase;margin-bottom:14px}
+.av-filters label{display:grid;gap:6px;margin-bottom:14px;color:var(--av-muted)}
+.av-filters input,.av-filters select{width:100%;min-width:0;color:var(--av-text)}
+.av-filters>button{display:block;width:100%;margin:9px 0;font-size:12px;text-align:left}
+.av-filters p,.av-related p{margin:10px 0;color:var(--av-muted);line-height:1.5;font-size:11px}
+.av-legend{margin-top:24px;border-top:1px solid var(--av-line);padding-top:8px}
+.av-solid:before,.av-dashed:before{content:"";display:inline-block;width:24px;border-top:2px solid #b7aab0;margin-right:7px;vertical-align:middle}.av-dashed:before{border-top-style:dashed}
+.av-center{position:relative;min-width:0;background:#fdfbf6;color:#30272d}
+.av-canvas{position:relative;height:100%;min-height:380px;overflow:hidden;background-image:radial-gradient(#e3d9db .8px,transparent .8px);background-size:20px 20px}
+.av-zoom{position:absolute;display:flex;gap:5px;top:12px;left:12px;z-index:2;flex-wrap:wrap}
+.av-zoom button{background:#fdfbf6;color:#342c30;border-color:#d6c5cb;font-size:11px;box-shadow:0 1px 3px #0001}
+.av-zoom button:hover{color:#a50e3c}
+.av-graph{width:100%;height:100%;display:block;cursor:grab;touch-action:none}
+.av-node{cursor:pointer;outline:none}.av-node rect{fill:#fffdf9;stroke:#d2c5ca;stroke-width:1.5}
+.av-node:hover rect,.av-node:focus-visible rect{stroke:#69434f;stroke-width:2}
+.av-node[aria-pressed="true"] rect{stroke:#c9184c;stroke-width:2.5}
+.av-node[data-state="failed"] rect,.av-node[data-state="interrupted"] rect{fill:#fff0f1;stroke:#bf3150}
+.av-node[data-state="succeeded"] rect{fill:#f4faf3;stroke:#79a186}
+.av-node text{fill:#362b31;font:11px var(--font-sans);pointer-events:none}
+.av-node .av-role{fill:#755f69;font-size:10px;letter-spacing:.04em}
+.av-node .av-name{font-size:16px;font-weight:650}
+.av-node .av-model,.av-node .av-attempts{fill:#6d5a63;font-size:10px;font-family:var(--font-mono)}
+.av-node .av-phase{fill:#9d234b;font-size:11px}
+.av-node[data-filtered="true"]{opacity:.22}
+.av-edge{fill:none;stroke:#a6969c;stroke-width:1.5}
+.av-edge[data-kind="dependency"]{stroke:#bd5776;stroke-dasharray:5 5}
+.av-edge[data-filtered="true"]{opacity:.12}
+.av-empty{position:absolute;bottom:18px;left:18px;right:18px;background:#fdfbf6;padding:10px;border:1px solid #d6c5cb;border-radius:7px;font-size:12px}
+.av-inspector{overflow:auto;min-width:0;padding:16px 14px;border-left:1px solid var(--av-line);overflow-anchor:none}
+.av-inspector .lct-tree,.av-inspector .lct-operation{min-width:0;margin:0;padding:0;max-width:100%}
+.av-inspector .lct-operation-children{margin:0;padding:0;border:0}
+.av-inspector .lct-operation-card{border-left-width:3px;box-shadow:none;border-radius:8px;padding:12px}
+.av-inspector .lct-operation-meta,.av-inspector .lct-attempt-meta{grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}
+.av-inspector .lct-operation-head,.av-inspector .lct-attempt-head{flex-wrap:wrap}
+.av-inspector .lct-session{display:block}.av-inspector code,.av-inspector dd{overflow-wrap:anywhere;word-break:break-word}
+.av-inspector .lc-conversation{padding:9px}.av-inspector .lc-conversation pre{padding:8px;font-size:11px}
+.av-inspector .lct-attempt{padding:10px;min-width:0}
+.av-inspector .lct-times{display:block;font-size:10px}
+.av-inspector .lct-unlinked>h4,.av-inspector .lct-unlinked>p,.av-inspector .lct-no-attempts{font-size:11px}
+.av-metrics{margin-bottom:14px;font-size:11px;border-bottom:1px solid var(--av-line);padding-bottom:10px}
+.av-metrics p{display:flex;flex-wrap:wrap;gap:3px 8px;justify-content:space-between;margin:5px 0}.av-metrics span{color:var(--av-muted)}
+.av-related{margin-top:18px}.av-related a{display:block;color:#f59fba;overflow-wrap:anywhere;font-size:11px;margin:8px 0}
+.av-related a[data-state="failed"],.av-warning{color:#ff8699!important}
+.av-chronology{list-style:none;margin:0;padding:18px;height:100%;overflow:auto}
+.av-chronology li{border-left:2px solid #d2c5ca;padding:0 0 12px 16px}
+.av-chronology button{display:grid;gap:7px;text-align:left;width:100%;background:#fffdf9;color:#30272d;border-color:#d2c5ca;padding:12px}
+.av-chronology button:hover{border-color:#c9184c;color:#9d234b}
+.av-chronology time{font:10px var(--font-mono);color:#725e68}.av-chronology span{font-size:11px;overflow-wrap:anywhere}
+.av-replay-note{padding:10px 14px;margin:0;border-top:1px solid var(--av-line);color:var(--av-muted);font-size:11px}
+@media(max-width:1280px){.av-body{grid-template-columns:145px minmax(250px,1fr) 300px}.av-toolbar{gap:5px}}
+@media(max-width:1050px){.av-body{grid-template-columns:minmax(250px,1fr) 300px}.av-filters{grid-column:1/-1;display:flex;flex-wrap:wrap;gap:10px;align-items:center;border-bottom:1px solid var(--av-line);max-height:150px}.av-filters label{width:150px;margin:0}.av-filters>button{width:auto}.av-filters h3,.av-filters>p,.av-legend{display:none}.av-body{height:auto}.av-center,.av-inspector{height:620px}}
+@media(max-width:740px){.av-body{display:block}.av-center{height:430px}.av-inspector{height:auto;max-height:650px;border-left:0;border-top:1px solid var(--av-line)}.av-count{width:100%;margin:0}.av-filters{max-height:none}.av-toolbar{font-size:11px}}
+@media(prefers-reduced-motion:reduce){.av-workspace *{animation:none!important;transition:none!important}}
+`;
+
 // src/console/inspector.ts
 var CONVERSATION_CLIENT_JS = `
 function wireConversationInspector(){
@@ -7708,7 +8463,9 @@ function wireConversationInspector(){
   });
   document.addEventListener('conversation-tree-replacing',function(){
     var scroll=document.querySelector('.scroll'),tree=mount&&mount.querySelector('[data-lifecycle-tree-mount]');
-    retained={focus:document.activeElement,scroll:scroll,scrollTop:scroll&&scroll.scrollTop,treeTop:tree&&tree.scrollTop,positions:[]};
+    var inspector=mount&&mount.querySelector('.av-inspector');
+    retained={focus:document.activeElement,scroll:scroll,scrollTop:scroll&&scroll.scrollTop,treeTop:tree&&tree.scrollTop,
+      inspector:inspector,inspectorTop:inspector&&inspector.scrollTop,positions:[]};
     records.forEach(function(record){
       [record.body].concat(Array.from(record.panel.querySelectorAll('pre'))).forEach(function(node){
         retained.positions.push([node,node.scrollTop,node.scrollLeft]);
@@ -7723,6 +8480,7 @@ function wireConversationInspector(){
       var tree=mount&&mount.querySelector('[data-lifecycle-tree-mount]');
       if(tree&&retained.treeTop!==null){tree.scrollTop=retained.treeTop}
       if(retained.scroll){retained.scroll.scrollTop=retained.scrollTop}
+      if(retained.inspector&&retained.inspector.isConnected){retained.inspector.scrollTop=retained.inspectorTop}
       if(retained.focus&&retained.focus.isConnected&&retained.focus!==document.activeElement&&
         (!document.activeElement||document.activeElement===document.body||document.activeElement===document.documentElement)){
         retained.focus.focus({preventScroll:true});
@@ -7877,6 +8635,8 @@ var CONSOLE_REFRESH_JS = `
         if(viewStopped||viewRequest!==controller||!result){return}
         if(typeof result.data.routing!=='string'||typeof result.data.logs!=='string'){return}
         latestView=result.data;viewRevision=result.revision;
+        document.__consoleTelemetry=latestView.sessionSummaries||[];
+        document.dispatchEvent(new CustomEvent('console-telemetry',{detail:{sessions:latestView.sessionSummaries||[]}}));
         var updated=document.querySelector('.token-chip b');
         if(updated&&typeof latestView.updatedAt==='string'){updated.textContent=latestView.updatedAt}
         if(Number.isInteger(latestView.refreshMs)&&latestView.refreshMs>=250&&latestView.refreshMs!==ms){
@@ -8515,6 +9275,7 @@ var LIFECYCLE_THEME_BOOT = `
 })();
 `;
 var LIFECYCLE_CLIENT_JS = `
+${AGENT_VIEW_CLIENT_JS}
 function wireLifecycleTimeline(){
   var mount=document.getElementById('lifecycle-timeline-mount');
   if(!mount){return}
@@ -8553,6 +9314,11 @@ function wireLifecycleTimeline(){
     lastSseHead:new Map()
   };
   var projectionKey='';
+  var agentViewer=null,agentRuns=[],agentRootOperationID=null;
+  function clearAgentViewer(){
+    if(agentViewer){agentViewer.dispose();agentViewer=null}
+    var note=mount.querySelector('[data-agent-degraded]');if(note){note.remove()}
+  }
   var committedRun=mount.getAttribute('data-lifecycle-run')||null,committedCursor=urlCursor();
 
   function invalidateConversation(){
@@ -8687,6 +9453,7 @@ function wireLifecycleTimeline(){
     if(sliderWired||!slider){return}
     sliderWired=true;
     slider.addEventListener('input',function(){
+      if(agentViewer){agentViewer.pause()}
       var c=parseInt(slider.value,10);
       if(!scrubInProgress){
         history.pushState(null,'',window.location.href);
@@ -8829,6 +9596,7 @@ function wireLifecycleTimeline(){
   function renderView(d,requestedCursor){
     ensureViewControls();
     state.runID=d.selection.runID;
+    agentRuns=d.runs||[];
     state.head=d.selection.head;
     state.cursor=d.selection.cursor;
     state.followLive=requestedCursor===null;
@@ -8905,6 +9673,7 @@ function wireLifecycleTimeline(){
   }
 
   function renderLegacy(d){
+    clearAgentViewer();
     ensureViewControls();
     state.runID=d.selection.runID;
     state.head=0;
@@ -8943,19 +9712,37 @@ function wireLifecycleTimeline(){
 
   function renderProjection(proj,recording){
     if(!proj||!treeMountEl){return}
+    agentRootOperationID=proj.rootOperationID;
     var degraded=recording&&recording.state==='degraded';
     var option=runSelect&&Array.from(runSelect.options).find(function(o){return o.value===proj.runID});
     var key=JSON.stringify([proj.runID,proj.cursor,proj.rootOperationID,proj.operations,degraded,option&&option.getAttribute('data-run-session')]);
-    if(key===projectionKey){return}
+    if(key===projectionKey){if(agentViewer){agentViewer.refresh()}return}
     projectionKey=key;
     document.dispatchEvent(new CustomEvent('conversation-tree-replacing'));
-    treeMountEl.textContent='';
+    if(!agentViewer||!agentViewer.connected()){
+      if(agentViewer){agentViewer.dispose()}
+      agentViewer=createAgentViewer(treeMountEl,{
+        isLive:function(){return state.followLive},
+        runs:function(){return agentRuns},
+        rootSessionID:function(id){
+          if(id!==agentRootOperationID){return undefined}
+          var option=runSelect&&Array.from(runSelect.options).find(function(o){return o.value===state.runID});
+          return option&&option.getAttribute('data-run-session')||undefined;
+        },
+        seek:function(cursor,push){
+          if(push){pushUrl(state.runID,cursor)}else{replaceUrl(state.runID,cursor)}
+          navigateFromUrl(false);
+        }
+      });
+    }
+    var priorNote=mount.querySelector('[data-agent-degraded]');if(priorNote){priorNote.remove()}
     if(degraded){
       var note=makeElement('div','lc-partial-note',message('partial-tail'));
+      note.setAttribute('data-agent-degraded','');
       note.setAttribute('role','status');
-      treeMountEl.appendChild(note);
+      treeMountEl.before(note);
     }
-    treeMountEl.appendChild(buildOperationTree(proj));
+    agentViewer.update(proj,buildOperationTree(proj));
   }
 
   function makeElement(tag,className,text){
@@ -9288,6 +10075,7 @@ function wireLifecycleTimeline(){
   }
 
   function showError(){
+    clearAgentViewer();
     invalidateConversation();
     projectionKey='';
     mount.setAttribute('data-lifecycle-state','error');
@@ -9304,6 +10092,7 @@ function wireLifecycleTimeline(){
   }
 
   function showApiError(err){
+    clearAgentViewer();
     projectionKey='';
     mount.setAttribute('data-lifecycle-state','error');
     updateScreenCopy('unavailable',false,null);
@@ -9320,6 +10109,7 @@ function wireLifecycleTimeline(){
   }
 
   function showDisabled(d){
+    clearAgentViewer();
     projectionKey='';
     mount.setAttribute('data-lifecycle-state','disabled');
     updateScreenCopy('unavailable',false,null);
@@ -9337,6 +10127,7 @@ function wireLifecycleTimeline(){
   }
 
   function showEmpty(){
+    clearAgentViewer();
     projectionKey='';
     mount.setAttribute('data-lifecycle-state','empty');
     updateScreenCopy('empty',false,null);
@@ -9355,6 +10146,7 @@ function wireLifecycleTimeline(){
   // --- Run selector change ---
   if(runSelect){
     runSelect.addEventListener('change',function(){
+      if(agentViewer){agentViewer.pause()}
       var newRun=runSelect.value;
       pushUrl(newRun,null);  // committed selection → traversable entry
       navigateFromUrl(false);
@@ -9369,6 +10161,7 @@ function wireLifecycleTimeline(){
   // --- Live / Return to live ---
   if(liveBtn){
     liveBtn.addEventListener('click',function(){
+      if(agentViewer){agentViewer.pause()}
       pushUrl(state.explicitRun,null);  // return-to-live preserves automatic run selection
       navigateFromUrl(false);
     });
@@ -9393,6 +10186,7 @@ function wireLifecycleTimeline(){
 
   // --- Browser back/forward ---
   window.addEventListener('popstate',function(){
+    if(agentViewer){agentViewer.pause()}
     navigateFromUrl(false);
   });
 
@@ -9447,7 +10241,11 @@ function ms(value) {
   return value >= 1000 ? `${(value / 1000).toFixed(2)}s` : `${Math.round(value)}ms`;
 }
 function avgMs(stats) {
-  return stats.count === 0 ? "—" : ms(stats.totalDurationMs / stats.count);
+  const known = stats.count - (stats.unknownDurationCount ?? 0);
+  return stats.count === 0 ? "—" : known === 0 ? consoleDetailMessages.timingUnknown : ms(stats.totalDurationMs / known);
+}
+function measured(value, unavailable) {
+  return (unavailable ?? 0) === 0 ? String(value) : `<span title="${escapeHtml(consoleDetailMessages.usageCaution)}">${escapeHtml(consoleDetailMessages.usageUnavailable)}</span>`;
 }
 function agentModel(agent) {
   return agent.model === undefined ? "inherits default" : `${agent.model.providerID}/${agent.model.modelID}`;
@@ -9462,15 +10260,16 @@ function summaryPanel(cost) {
   return [
     '<section class="panel" id="panel-summary">',
     "<h2>Routing summary</h2>",
+    `<p class="muted">${escapeHtml(consoleDetailMessages.estimatesNotUsage)}</p>`,
     '<div class="grid">',
     `<div class="stat"><span class="k">Decisions</span><span class="v">${cost.count}</span></div>`,
     `<div class="stat"><span class="k">Local</span><span class="v">${cost.localCount}</span></div>`,
     `<div class="stat"><span class="k">Frontier</span><span class="v">${cost.frontierCount}</span></div>`,
-    `<div class="stat"><span class="k">Real cost</span><span class="v">${usd(cost.totalEstimatedUSD)}</span></div>`,
-    `<div class="stat"><span class="k">Baseline</span><span class="v">${usd(cost.totalBaselineUSD)}</span></div>`,
-    `<div class="stat"><span class="k">Savings</span><span class="v good">${usd(cost.totalSavingsUSD)} (${pct(cost.savingsPct)})</span></div>`,
-    `<div class="stat"><span class="k">Tokens in</span><span class="v">${cost.tokensIn}</span></div>`,
-    `<div class="stat"><span class="k">Tokens out</span><span class="v">${cost.tokensOut}</span></div>`,
+    `<div class="stat"><span class="k">${escapeHtml(consoleDetailMessages.estimatedCost)}</span><span class="v">${usd(cost.totalEstimatedUSD)}</span></div>`,
+    `<div class="stat"><span class="k">${escapeHtml(consoleDetailMessages.estimatedBaseline)}</span><span class="v">${usd(cost.totalBaselineUSD)}</span></div>`,
+    `<div class="stat"><span class="k">${escapeHtml(consoleDetailMessages.estimatedSavings)}</span><span class="v good">${usd(cost.totalSavingsUSD)} (${pct(cost.savingsPct)})</span></div>`,
+    `<div class="stat"><span class="k">${escapeHtml(consoleDetailMessages.estimatedInput)}</span><span class="v">${cost.tokensIn}</span></div>`,
+    `<div class="stat"><span class="k">${escapeHtml(consoleDetailMessages.estimatedOutput)}</span><span class="v">${cost.tokensOut}</span></div>`,
     "</div>",
     "</section>"
   ].join("");
@@ -9585,12 +10384,12 @@ function totalsPanel(totals) {
     '<div class="grid">',
     `<div class="stat"><span class="k">Sessions</span><span class="v">${totals.sessions}</span></div>`,
     `<div class="stat"><span class="k">Messages</span><span class="v">${totals.messageCount}</span></div>`,
-    `<div class="stat"><span class="k">Real cost</span><span class="v">${usd(totals.realCostUSD)}</span></div>`,
+    `<div class="stat"><span class="k">Real cost</span><span class="v">${measured(usd(totals.realCostUSD), totals.unavailableCostMessages)}</span></div>`,
     `<div class="stat"><span class="k">Est. savings</span><span class="v good">${usd(totals.estimatedSavingsUSD)}</span></div>`,
-    `<div class="stat"><span class="k">Tokens in</span><span class="v">${totals.tokensIn}</span></div>`,
-    `<div class="stat"><span class="k">Tokens out</span><span class="v">${totals.tokensOut}</span></div>`,
-    `<div class="stat"><span class="k">Reasoning</span><span class="v">${totals.tokensReasoning}</span></div>`,
-    `<div class="stat"><span class="k">Cache r/w</span><span class="v">${totals.tokensCacheRead}/${totals.tokensCacheWrite}</span></div>`,
+    `<div class="stat"><span class="k">Tokens in</span><span class="v">${measured(totals.tokensIn, totals.unavailableUsageMessages)}</span></div>`,
+    `<div class="stat"><span class="k">Tokens out</span><span class="v">${measured(totals.tokensOut, totals.unavailableUsageMessages)}</span></div>`,
+    `<div class="stat"><span class="k">Reasoning</span><span class="v">${measured(totals.tokensReasoning, totals.unavailableUsageMessages)}</span></div>`,
+    `<div class="stat"><span class="k">Cache r/w</span><span class="v">${measured(`${totals.tokensCacheRead}/${totals.tokensCacheWrite}`, totals.unavailableUsageMessages)}</span></div>`,
     `<div class="stat"><span class="k">Toolcalls</span><span class="v">${t.count} <span class="good">${t.ok}✓</span> <span class="frontier">${t.failed}✗</span></span></div>`,
     `<div class="stat"><span class="k">Avg tool dur.</span><span class="v">${avgMs(t)}</span></div>`,
     "</div>",
@@ -9613,8 +10412,8 @@ function sessionRow(session2) {
     `<td>${sessionNameHtml(session2.sessionID, sessionName(session2))}<br>${observedTimeHtml(session2)}<br><code>${escapeHtml(session2.sessionID)}</code></td>`,
     `<td>${models}</td>`,
     `<td><span class="local">${session2.localCount}</span>/<span class="frontier">${session2.frontierCount}</span></td>`,
-    `<td>${usd(session2.realCostUSD)}</td>`,
-    `<td>${session2.tokensIn}/${session2.tokensOut}</td>`,
+    `<td>${measured(usd(session2.realCostUSD), session2.unavailableCostMessages)}</td>`,
+    `<td>${measured(`${session2.tokensIn}/${session2.tokensOut}`, session2.unavailableUsageMessages)}</td>`,
     `<td>${session2.toolcalls.count} (${avgMs(session2.toolcalls)})</td>`,
     "</tr>"
   ].join("");
@@ -9751,8 +10550,8 @@ function sessionHeaderPanel(tab) {
     `<div class="stat"><span class="k">Endpoint</span><span class="v">${endpoint}</span></div>`,
     dir,
     title,
-    `<div class="stat"><span class="k">Real cost</span><span class="v">${usd(s.realCostUSD)}</span></div>`,
-    `<div class="stat"><span class="k">Tokens in/out</span><span class="v">${s.tokensIn}/${s.tokensOut}</span></div>`,
+    `<div class="stat"><span class="k">Real cost</span><span class="v">${measured(usd(s.realCostUSD), s.unavailableCostMessages)}</span></div>`,
+    `<div class="stat"><span class="k">Tokens in/out</span><span class="v">${measured(`${s.tokensIn}/${s.tokensOut}`, s.unavailableUsageMessages)}</span></div>`,
     `<div class="stat"><span class="k">Local/Frontier</span><span class="v"><span class="local">${s.localCount}</span>/<span class="frontier">${s.frontierCount}</span></span></div>`,
     `<div class="stat"><span class="k">Toolcalls</span><span class="v">${s.toolcalls.count} (${avgMs(s.toolcalls)})</span></div>`,
     "</div>",
@@ -10653,7 +11452,7 @@ function renderConsoleHtml(state, options = {}) {
     '<meta name="viewport" content="width=device-width,initial-scale=1">',
     "<title>openteam console</title>",
     lifecycleEnabled ? `<script>${LIFECYCLE_THEME_BOOT}</script>` : "",
-    `<style>${CONSOLE_STYLE}${CONVERSATION_STYLE}${graphOptionProvided ? GRAPH_STYLE : ""}${lifecycleEnabled ? LIFECYCLE_STYLE : ""}</style>`,
+    `<style>${CONSOLE_STYLE}${CONVERSATION_STYLE}${graphOptionProvided ? GRAPH_STYLE : ""}${lifecycleEnabled ? LIFECYCLE_STYLE + AGENT_VIEW_STYLE : ""}</style>`,
     "</head>",
     "<body>",
     '<div class="app">',
@@ -10683,6 +11482,7 @@ function renderConsoleUpdate(state, options = {}) {
     routing: routingScreenBody(state),
     logs: logsScreenBody(state, options.terminalEnabled === true, options.ptyEnabled === true),
     sessionCount: state.sessionsDetail.length,
+    sessionSummaries: state.sessions,
     ...options.graphView ? {
       tree: treeGraphPanel(options.graphView.projection, options.drilldownEnabled === true, false, options.graphView.mode ?? "active")
     } : {}
@@ -12618,6 +13418,7 @@ var lifecycleFailureSchema = z13.object({
     "prompt-auth",
     "prompt-content-filter",
     "prompt-context-length",
+    "prompt-output-truncated",
     "prompt-validation",
     "prompt-connection",
     "prompt-server",
@@ -13662,6 +14463,8 @@ var NodeFailureClassSchema = z17.enum([
   "prompt-auth",
   "prompt-content-filter",
   "prompt-context-length",
+  "prompt-output-truncated",
+  "budget-exhausted",
   "prompt-validation",
   "prompt-connection",
   "prompt-server",
@@ -17776,7 +18579,7 @@ function createMigrateAdapter(root) {
 }
 
 // src/cli/opencodeVersion.ts
-var SEMVER_PATTERN = /(\d+\.\d+\.\d+)/;
+var SEMVER_PATTERN = /(\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)/;
 function normalizeVersion(raw) {
   if (raw === undefined) {
     return;
@@ -18170,7 +18973,15 @@ function buildOrchestratorAgent(model, options = {}) {
     "  `title` is optional and only for readability.",
     "- `parentSessionID` (optional): the current session, so that the subsessions",
     "  link as children.",
-    "- `directory` (optional): working directory if it differs from the current one.",
+    "- `directory` (optional): omit it to use the trusted host workspace. A different",
+    "  directory is rejected; this argument cannot authorize another workspace.",
+    "",
+    "Related and nested batches share a cumulative task budget, not a fresh allowance",
+    "per call. On `task-budget-exhausted`, stop delegation and summarize preserved",
+    "work and remaining tasks. Never create another batch/session or edit effort",
+    "state to reset that allowance. Only a genuinely new root user turn starts a new task.",
+    "Workers should use `openteam-submit-report` for their assigned report, retaining",
+    "operator permission checks. Do not broaden file or shell permissions to deliver it.",
     "",
     "The tool returns a per-role summary: selected model, success or",
     "failure, the created session, and — for each role — a `report` file path",
@@ -21728,7 +22539,8 @@ var nativeHostMessages = {
   setupPolicyQuestion: (paths, providers) => `Remove exact project-local provider.use deny rules for ${providers.join(", ")} from ${paths.join(", ")}? Older setup added these rules, but they may also be operator limits. Confirm only if you intend to enable the guarded native transport.`,
   setupPolicyPreserved: "Setup stopped. Provider-denial rules were preserved and no files were written.",
   setupPolicyNotice: "Only the explicitly reviewed project rules were removed. Wildcard, scoped, unrelated and global provider denials remain authoritative.",
-  unsupportedVersion: (version) => `openteam has not verified the native plugin contract for opencode ${version}. The supported native host is 2.0.5.`,
+  unsupportedVersion: (version) => `openteam does not support native opencode ${version}. The supported stable native range is >=2.0.5 <3.0.0.`,
+  certificateVersionMismatch: (certified, live) => `certified for "${certified}", running "${live}" — evidence is outside the supported host compatibility range`,
   missingBindings: "The native opencode execution context is unavailable. No child session or privileged operation was started.",
   missingVersion: "The opencode host did not provide an authoritative version or server endpoint.",
   workspaceMismatch: "The native opencode session does not belong to this workspace.",
@@ -21746,7 +22558,7 @@ var nativeHostMessages = {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.27.0",
+  version: "0.28.0",
   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",
@@ -22041,10 +22853,31 @@ function parseSemver(version) {
     patch: Number(match[3])
   };
 }
+function compareSemver2(a, b) {
+  if (a.major !== b.major) {
+    return a.major < b.major ? -1 : 1;
+  }
+  if (a.minor !== b.minor) {
+    return a.minor < b.minor ? -1 : 1;
+  }
+  if (a.patch !== b.patch) {
+    return a.patch < b.patch ? -1 : 1;
+  }
+  return 0;
+}
+function isSupportedNativeOpencodeVersion(version) {
+  if (version === undefined || !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version))
+    return false;
+  const live = parseSemver(version);
+  const minimum = parseSemver(NATIVE_OPENCODE_VERSION);
+  return Object.values(live).every(Number.isSafeInteger) && live.major === minimum.major && compareSemver2(live, minimum) >= 0;
+}
 function isCertificateVersionCompatible(certifiedVersion, liveVersion) {
   if (certifiedVersion === liveVersion) {
     return true;
   }
+  if (isSupportedNativeOpencodeVersion(certifiedVersion) && isSupportedNativeOpencodeVersion(liveVersion))
+    return compareSemver2(parseSemver(liveVersion), parseSemver(certifiedVersion)) >= 0;
   let certified;
   let live;
   try {
@@ -22609,7 +23442,7 @@ function orchestratorAgentModel(answers) {
 }
 function buildOpencodeConfig(answers) {
   assertSetupResidency(answers);
-  const policies = answers.opencodeVersion === NATIVE_OPENCODE_VERSION ? [] : residentV2Policies(answers.runtimes.filter((choice) => choice.enabled && runtimeRequiresModelResidency(localRuntimeKind(choice))).map(choiceProviderID));
+  const policies = isSupportedNativeOpencodeVersion(answers.opencodeVersion) ? [] : residentV2Policies(answers.runtimes.filter((choice) => choice.enabled && runtimeRequiresModelResidency(localRuntimeKind(choice))).map(choiceProviderID));
   const provider = {};
   const providerOwner = new Map;
   for (const choice of answers.runtimes) {
@@ -24153,7 +24986,7 @@ async function runSetup(deps) {
     try {
       existingOpenTeamConfig = await readExistingOpenTeamConfig(openTeamPath, deps);
       existingOpencodeFiles = await readExistingOpencodeConfigFiles(opencodeConfigPaths, deps);
-      if (opencodeVersion === NATIVE_OPENCODE_VERSION) {
+      if (isSupportedNativeOpencodeVersion(opencodeVersion)) {
         existingOpencodeFiles = existingOpencodeFiles.map((file) => {
           nativeDocuments.set(file.path, file.raw);
           return { ...file, raw: nativeSetupView(file.raw) };
@@ -24198,7 +25031,7 @@ async function runSetup(deps) {
         throw new Error(finalOpenTeamConfig.local.runtimes.some((runtime) => runtime.defaultModel.providerID === providerID && localRuntimeKind(runtime) === "lemonade") ? executionSetupMessages.lemonadeRetainedProviderUnprotected(providerID) : executionSetupMessages.retainedResidencyProviderUnprotected(providerID));
     }
     const nativePolicyMigrations = new Set;
-    if (opencodeVersion === NATIVE_OPENCODE_VERSION) {
+    if (isSupportedNativeOpencodeVersion(opencodeVersion)) {
       const providers = new Set(effectiveOpenTeamConfig.local.runtimes.filter((runtime) => runtime.enabled && runtimeRequiresModelResidency(localRuntimeKind(runtime))).map((runtime) => runtime.defaultModel.providerID));
       const planned = existingOpencodeFiles.map((file) => {
         const raw = withoutReviewedNativeDenials(file.raw, providers);
@@ -24217,7 +25050,7 @@ async function runSetup(deps) {
         prompt.note(nativeHostMessages.setupPolicyNotice);
       }
     }
-    const v2Denials = opencodeVersion === NATIVE_OPENCODE_VERSION ? [] : residentV2Policies([
+    const v2Denials = isSupportedNativeOpencodeVersion(opencodeVersion) ? [] : residentV2Policies([
       ...opencodeConfig.experimental?.policies.map((policy) => policy.resource) ?? [],
       ...effectiveOpenTeamConfig.local.runtimes.filter((runtime) => runtimeRequiresModelResidency(localRuntimeKind(runtime))).map((runtime) => runtime.defaultModel.providerID)
     ]);
@@ -24360,7 +25193,7 @@ async function runSetup(deps) {
     await verifyResidencyBeforeWrite(deps, answers, effectiveOpenTeamConfig, effectivePlannedOpencode);
     const serializedOpencodePlan = [...opencodeWritePlan].map(([path2, contents]) => [
       path2,
-      serializeOpencodeConfig(opencodeVersion === NATIVE_OPENCODE_VERSION ? restoreNativeSetupConfig(contents, nativeDocuments.get(path2)) : contents)
+      serializeOpencodeConfig(isSupportedNativeOpencodeVersion(opencodeVersion) ? restoreNativeSetupConfig(contents, nativeDocuments.get(path2)) : contents)
     ]);
     await deps.writeFile(openTeamPath, serializeOpenTeamConfig(finalOpenTeamConfig));
     for (const [path2, contents] of serializedOpencodePlan) {
@@ -27850,7 +28683,7 @@ function planStartupHygieneMigration(exists) {
 
 // src/index.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname10 } from "node:path";
+import { basename as basename4, dirname as dirname11, resolve as resolve18 } from "node:path";
 
 // src/graph/certificate.ts
 import { z as z29 } from "zod";
@@ -28017,7 +28850,7 @@ function parseShadowCertificate(value, opencodeVersion) {
     throw new ShadowCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
   }
   if (!isCertificateVersionCompatible(certificate.opencodeVersion, opencodeVersion)) {
-    throw new ShadowCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", running "${opencodeVersion}" — evidence is accepted only on ${certificate.opencodeVersion} or a newer patch of the same minor line`);
+    throw new ShadowCertificateError("opencode-mismatch", nativeHostMessages.certificateVersionMismatch(certificate.opencodeVersion, opencodeVersion));
   }
   return certificate;
 }
@@ -28202,7 +29035,7 @@ function parseReleaseCertificate(value, opencodeVersion, expectedShadowDigest) {
     throw new ReleaseCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
   }
   if (!isCertificateVersionCompatible(certificate.opencodeVersion, opencodeVersion)) {
-    throw new ReleaseCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", running "${opencodeVersion}" — evidence is accepted only on ${certificate.opencodeVersion} or a newer patch of the same minor line`);
+    throw new ReleaseCertificateError("opencode-mismatch", nativeHostMessages.certificateVersionMismatch(certificate.opencodeVersion, opencodeVersion));
   }
   return certificate;
 }
@@ -29020,17 +29853,31 @@ function createRuntimeConcurrencyLimiter(options) {
   }
   return {
     tryAcquire,
-    acquire(runtimeId, priority = "worker") {
+    async acquire(runtimeId, priority = "worker", signal) {
+      signal?.throwIfAborted();
       const immediate = tryAcquire(runtimeId, priority);
       if (immediate !== undefined) {
         return Promise.resolve({ release: immediate, waitedMs: 0 });
       }
       const state = stateFor(runtimeId);
       const queuedAt = options.now();
-      return new Promise((resolve13) => {
-        state.queues[priority].push((release) => {
+      return new Promise((resolve13, reject) => {
+        const waiter = (release) => {
+          signal?.removeEventListener("abort", cancel2);
           resolve13({ release, waitedMs: options.now() - queuedAt });
-        });
+        };
+        function cancel2() {
+          const index = state.queues[priority].indexOf(waiter);
+          if (index < 0)
+            return;
+          state.queues[priority].splice(index, 1);
+          signal?.removeEventListener("abort", cancel2);
+          reject(signal?.reason);
+        }
+        state.queues[priority].push(waiter);
+        signal?.addEventListener("abort", cancel2, { once: true });
+        if (signal?.aborted)
+          cancel2();
       });
     },
     activeCount(runtimeId) {
@@ -29071,6 +29918,192 @@ var readReportArtifact = async (reportPath) => {
   }
 };
 
+// src/orchestrator/reportDelivery.ts
+import { z as z30 } from "zod";
+var Submission = z30.object({
+  status: z30.enum(["done", "continue"]),
+  findings: z30.string().min(1).max(32768)
+}).strict();
+function createReportDelivery(deps) {
+  const active = new Map;
+  return {
+    open(sessionID, batchID, roleID) {
+      if (active.has(sessionID))
+        throw new Error(reportDeliveryMessages.assignmentConflict);
+      const lease = {
+        path: roleReportPath(batchID, roleID),
+        open: true,
+        submitted: false,
+        pending: Promise.resolve()
+      };
+      active.set(sessionID, lease);
+      return {
+        async close() {
+          lease.open = false;
+          await lease.pending;
+          if (active.get(sessionID) === lease)
+            active.delete(sessionID);
+          return lease.submitted;
+        }
+      };
+    },
+    path(sessionID) {
+      const lease = active.get(sessionID);
+      if (lease?.open !== true)
+        throw new Error(reportDeliveryMessages.noAssignment);
+      return lease.path;
+    },
+    async submit(sessionID, input) {
+      const payload = Submission.safeParse(input);
+      if (!payload.success || !reportHasSubstance(payload.data.findings))
+        throw new Error(reportDeliveryMessages.invalidReport);
+      const lease = active.get(sessionID);
+      if (lease?.open !== true)
+        throw new Error(reportDeliveryMessages.noAssignment);
+      const content = `${payload.data.findings.trim()}
+
+openteam-status: ${payload.data.status}
+`;
+      if (parseReportStatus(content) !== payload.data.status)
+        throw new Error(reportDeliveryMessages.invalidReport);
+      const write = lease.pending.then(async () => {
+        if (!lease.open)
+          throw new Error(reportDeliveryMessages.noAssignment);
+        await deps.write(lease.path, content);
+        lease.submitted = true;
+      });
+      lease.pending = write.then(() => {}, () => {});
+      await write;
+      return lease.path;
+    }
+  };
+}
+
+// src/orchestrator/taskEffort.ts
+import { z as z31 } from "zod";
+var Binding = z31.object({
+  taskID: z31.string().regex(/^[a-f0-9]{64}$/),
+  depth: z31.number().int().min(0).max(128),
+  worker: z31.boolean()
+}).strict();
+var Record = z31.object({
+  v: z31.literal(1),
+  startedAt: z31.number().finite(),
+  batches: z31.number().int().min(0),
+  attempts: z31.number().int().min(0),
+  maxBatches: z31.number().int().positive(),
+  maxAttempts: z31.number().int().positive(),
+  maxDurationMs: z31.number().int().positive(),
+  maxDepth: z31.number().int().min(0)
+}).strict();
+function decode(schema, raw) {
+  let value;
+  try {
+    value = JSON.parse(raw ?? "null");
+  } catch {
+    throw new Error(taskEffortMessages.ledgerInvalid);
+  }
+  const parsed = schema.safeParse(value);
+  if (!parsed.success)
+    throw new Error(taskEffortMessages.ledgerInvalid);
+  return parsed.data;
+}
+function createTaskEffort(deps) {
+  const limits = {
+    maxBatches: deps.limits?.maxBatches ?? 8,
+    maxAttempts: deps.limits?.maxAttempts ?? 32,
+    maxDurationMs: deps.limits?.maxDurationMs ?? 7200000,
+    maxDepth: deps.limits?.maxDepth ?? 3
+  };
+  const bindingPath = (sessionID) => `sessions/${sha256Hex(sessionID)}.json`;
+  const taskPath = (taskID) => `tasks/${taskID}.json`;
+  function initialize(sessionID, messageID) {
+    const taskID = sha256Hex(`${sessionID}\x00${messageID}`);
+    deps.store.update(taskPath(taskID), (previous) => {
+      if (previous !== undefined) {
+        decode(Record, previous);
+        return previous;
+      }
+      return JSON.stringify({
+        v: 1,
+        startedAt: deps.now(),
+        batches: 0,
+        attempts: 0,
+        ...limits
+      });
+    });
+    const binding = { taskID, depth: 0, worker: false };
+    deps.store.write(bindingPath(sessionID), JSON.stringify(binding));
+    return binding;
+  }
+  function bindChild(parent, sessionID) {
+    if (parent.depth >= 128)
+      throw new Error(taskEffortMessages.ledgerInvalid);
+    deps.store.write(bindingPath(sessionID), JSON.stringify({
+      taskID: parent.taskID,
+      depth: parent.depth + 1,
+      worker: true
+    }));
+  }
+  async function forSession(sessionID, ancestors = new Set) {
+    if (ancestors.has(sessionID) || ancestors.size >= 128)
+      throw new Error(taskEffortMessages.ledgerInvalid);
+    const stored = deps.store.read(bindingPath(sessionID));
+    if (stored !== undefined)
+      return decode(Binding, stored);
+    ancestors.add(sessionID);
+    const parentID = await deps.parentSession?.(sessionID);
+    if (parentID !== undefined) {
+      const parent = await forSession(parentID, ancestors);
+      bindChild(parent, sessionID);
+      return { taskID: parent.taskID, depth: parent.depth + 1 };
+    }
+    return initialize(sessionID, "restored-session");
+  }
+  function consume(ref, kind) {
+    let result = { ok: false, reason: "duration" };
+    deps.store.update(taskPath(ref.taskID), (raw) => {
+      const record3 = decode(Record, raw);
+      const remainingMs = Math.min(record3.maxDurationMs, limits.maxDurationMs) - Math.max(0, deps.now() - record3.startedAt);
+      const reason = ref.depth > Math.min(record3.maxDepth, limits.maxDepth) ? "depth" : remainingMs <= 0 ? "duration" : kind === "batches" && record3.batches >= Math.min(record3.maxBatches, limits.maxBatches) ? "batches" : kind === "attempts" && record3.attempts >= Math.min(record3.maxAttempts, limits.maxAttempts) ? "attempts" : undefined;
+      if (reason !== undefined)
+        result = { ok: false, reason };
+      else {
+        if (kind !== "check")
+          record3[kind] += 1;
+        result = {
+          ok: true,
+          remainingMs,
+          batches: record3.batches,
+          attempts: record3.attempts,
+          remainingBatches: Math.max(0, Math.min(record3.maxBatches, limits.maxBatches) - record3.batches),
+          remainingAttempts: Math.max(0, Math.min(record3.maxAttempts, limits.maxAttempts) - record3.attempts)
+        };
+      }
+      return JSON.stringify(record3);
+    });
+    return result;
+  }
+  return {
+    async userTurn(sessionID, messageID) {
+      const stored = deps.store.read(bindingPath(sessionID));
+      if (stored !== undefined && decode(Binding, stored).worker)
+        return;
+      const parentID = await deps.parentSession?.(sessionID);
+      if (parentID !== undefined) {
+        bindChild(await forSession(parentID), sessionID);
+        return;
+      }
+      initialize(sessionID, messageID);
+    },
+    forSession,
+    bindChild,
+    batch: (ref) => consume(ref, "batches"),
+    attempt: (ref) => consume(ref, "attempts"),
+    check: (ref) => consume(ref, "check")
+  };
+}
+
 // src/plugin/availability.ts
 function modelKey4(model) {
   return `${model.providerID}/${model.modelID}`;
@@ -29316,7 +30349,7 @@ function createAvailabilityCache(options) {
 
 // src/plugin/capture.ts
 function nonNeg(value) {
-  return typeof value === "number" && value >= 0 ? Math.trunc(value) : 0;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
 }
 function messageEventFrom(info, now) {
   if (info.role !== "assistant") {
@@ -29330,6 +30363,17 @@ function messageEventFrom(info, now) {
   }
   const created = info.time.created ?? info.time.completed;
   const durationMs = Math.max(0, Math.trunc(info.time.completed - created));
+  const counters = [info.tokens?.input, info.tokens?.output];
+  const hasUsage = counters.every((value) => typeof value === "number" && Number.isFinite(value) && value >= 0);
+  const zeroUsage = [
+    info.tokens?.input,
+    info.tokens?.output,
+    info.tokens?.reasoning,
+    info.tokens?.cache?.read,
+    info.tokens?.cache?.write
+  ].every((value) => value === undefined || value === 0);
+  const usageStatus = !hasUsage ? "missing" : zeroUsage && info.hasGeneratedOutput !== false ? "zero-unverified" : "reported";
+  const hasCost = typeof info.cost === "number" && Number.isFinite(info.cost) && info.cost >= 0;
   const event = {
     v: EVENT_SCHEMA_VERSION,
     type: "message",
@@ -29337,7 +30381,11 @@ function messageEventFrom(info, now) {
     sessionID: info.sessionID,
     providerID: info.providerID,
     modelID: info.modelID,
-    costUSD: typeof info.cost === "number" && info.cost >= 0 ? info.cost : 0,
+    costUSD: hasCost ? info.cost ?? 0 : 0,
+    usageStatus,
+    costStatus: hasCost && (info.cost !== 0 || usageStatus === "reported") ? "reported" : "unavailable",
+    ...info.finish === undefined ? {} : { finish: finishReason(info.finish) },
+    ...info.truncatedToolCall === true ? { truncatedToolCall: true } : {},
     tokensIn: nonNeg(info.tokens?.input),
     tokensOut: nonNeg(info.tokens?.output),
     tokensReasoning: nonNeg(info.tokens?.reasoning),
@@ -29348,6 +30396,18 @@ function messageEventFrom(info, now) {
   if (info.mode !== undefined) {
     event.mode = info.mode;
   }
+  function finishReason(value) {
+    switch (value) {
+      case "stop":
+      case "length":
+      case "tool-calls":
+      case "content-filter":
+      case "error":
+        return value;
+      default:
+        return "unknown";
+    }
+  }
   if (info.id !== undefined) {
     event.messageID = info.id;
   }
@@ -30077,36 +31137,36 @@ function formatResponse(response) {
 }
 
 // src/plugin/reportRunSchema.ts
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 
 // src/plugin/graphShadowIngress.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 var LEGACY_EXECUTION_TRACE_VERSION = 1;
-var LegacyExecutionStatusSchema = z30.enum([
+var LegacyExecutionStatusSchema = z32.enum([
   "completed",
   "failed",
   "cancelled"
 ]);
-var LegacyReviewOutcomeSchema = z30.enum([
+var LegacyReviewOutcomeSchema = z32.enum([
   "approved",
   "rejected",
   "inconclusive"
 ]);
-var LegacyTraceNodeV1Schema = z30.object({
+var LegacyTraceNodeV1Schema = z32.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z30.string().min(1),
-  sessionRef: z30.string().min(1).optional(),
+  model: z32.string().min(1),
+  sessionRef: z32.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var LegacyExecutionTraceV1Schema = z30.object({
-  version: z30.literal(LEGACY_EXECUTION_TRACE_VERSION),
+var LegacyExecutionTraceV1Schema = z32.object({
+  version: z32.literal(LEGACY_EXECUTION_TRACE_VERSION),
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
   outcome: LegacyReviewOutcomeSchema,
-  fixes: z30.number().int().nonnegative(),
-  nodes: z30.array(LegacyTraceNodeV1Schema).min(1),
-  parentSessionRef: z30.string().min(1).optional()
+  fixes: z32.number().int().nonnegative(),
+  nodes: z32.array(LegacyTraceNodeV1Schema).min(1),
+  parentSessionRef: z32.string().min(1).optional()
 }).strict();
 function gateReason2(gate) {
   if (gate === undefined || gate.mode === "off") {
@@ -30177,20 +31237,20 @@ function parseLegacyExecutionTrace(input) {
 }
 
 // src/plugin/reportRunSchema.ts
-var ReportRunNodeSchema = z31.object({
+var ReportRunNodeSchema = z33.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z31.string().min(1),
-  ok: z31.boolean(),
-  sessionRef: z31.string().min(1).optional(),
+  model: z33.string().min(1),
+  ok: z33.boolean(),
+  sessionRef: z33.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var ReportRunPayloadSchema = z31.object({
+var ReportRunPayloadSchema = z33.object({
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
-  fixes: z31.number().int().nonnegative(),
-  nodes: z31.array(ReportRunNodeSchema).min(1),
-  parentSessionRef: z31.string().min(1).optional()
+  fixes: z33.number().int().nonnegative(),
+  nodes: z33.array(ReportRunNodeSchema).min(1),
+  parentSessionRef: z33.string().min(1).optional()
 }).strict();
 
 // src/orchestrator/graphShadow.ts
@@ -30692,7 +31752,7 @@ async function handleReportRun(args, observe, tracker) {
 }
 
 // src/plugin/modelResidency.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 
 // src/local/lemonadeRequestGuard.ts
 var inferencePaths = new Set([
@@ -31063,7 +32123,7 @@ function createModelResidencyGuard(config, options) {
         throw failure2("identity", model.providerID);
       fetch2 = installed.fetch;
     }
-    const configuredHeaders = z32.record(z32.string(), z32.string()).safeParse(provider?.options?.headers ?? {});
+    const configuredHeaders = z34.record(z34.string(), z34.string()).safeParse(provider?.options?.headers ?? {});
     if (!configuredHeaders.success)
       throw failure2("configuration", model.providerID);
     const headers = new Headers(configuredHeaders.data);
@@ -31291,62 +32351,62 @@ ${lines.join(`
 }
 
 // src/memory/types.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z33.string().min(1);
-var MemoryKindSchema = z33.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z33.object({
-  id: z33.string().min(1),
+var OwnerKeySchema = z35.string().min(1);
+var MemoryKindSchema = z35.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z35.object({
+  id: z35.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z33.number().min(0).max(1),
-  validFrom: z33.number().finite(),
-  validUntil: z33.number().finite().nullable().default(null),
-  createdAt: z33.number().finite(),
-  invalidatedAt: z33.number().finite().nullable().default(null),
-  sourceHash: z33.string().min(1),
-  supersededBy: z33.string().min(1).nullable().default(null)
+  confidence: z35.number().min(0).max(1),
+  validFrom: z35.number().finite(),
+  validUntil: z35.number().finite().nullable().default(null),
+  createdAt: z35.number().finite(),
+  invalidatedAt: z35.number().finite().nullable().default(null),
+  sourceHash: z35.string().min(1),
+  supersededBy: z35.string().min(1).nullable().default(null)
 }).strict();
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z33.literal("fact"),
-  subject: z33.string().min(1),
-  predicate: z33.string().min(1),
-  object: z33.string().min(1),
-  category: z33.string().min(1).nullable().default(null)
+  kind: z35.literal("fact"),
+  subject: z35.string().min(1),
+  predicate: z35.string().min(1),
+  object: z35.string().min(1),
+  category: z35.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z33.literal("preference"),
-  category: z33.string().min(1),
-  preference: z33.string().min(1),
-  context: z33.string().min(1).nullable().default(null),
-  lastAccessedAt: z33.number().finite().nullable().default(null),
-  accessCount: z33.number().int().min(0).default(0)
+  kind: z35.literal("preference"),
+  category: z35.string().min(1),
+  preference: z35.string().min(1),
+  context: z35.string().min(1).nullable().default(null),
+  lastAccessedAt: z35.number().finite().nullable().default(null),
+  accessCount: z35.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z33.literal("entity"),
-  canonicalName: z33.string().min(1),
-  type: z33.string().min(1),
-  aliases: z33.array(z33.string().min(1)).default([])
+  kind: z35.literal("entity"),
+  canonicalName: z35.string().min(1),
+  type: z35.string().min(1),
+  aliases: z35.array(z35.string().min(1)).default([])
 });
 var RelationSchema = MemoryBaseSchema.extend({
-  kind: z33.literal("relation"),
-  from: z33.string().min(1),
-  to: z33.string().min(1),
-  predicate: z33.string().min(1),
-  annotation: z33.string().min(1).nullable().default(null)
+  kind: z35.literal("relation"),
+  from: z35.string().min(1),
+  to: z35.string().min(1),
+  predicate: z35.string().min(1),
+  annotation: z35.string().min(1).nullable().default(null)
 });
-var MemoryRecordSchema = z33.discriminatedUnion("kind", [
+var MemoryRecordSchema = z35.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema,
   RelationSchema
 ]);
-var RecallQuerySchema = z33.object({
+var RecallQuerySchema = z35.object({
   ownerKey: OwnerKeySchema,
-  kinds: z33.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z33.number().finite().nullable().default(null),
-  limit: z33.number().int().positive().default(8),
-  minSimilarity: z33.number().min(0).max(1).default(0.2),
-  includeShared: z33.boolean().default(true)
+  kinds: z35.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z35.number().finite().nullable().default(null),
+  limit: z35.number().int().positive().default(8),
+  minSimilarity: z35.number().min(0).max(1).default(0.2),
+  includeShared: z35.boolean().default(true)
 }).strict();
 
 // src/memory/rank.ts
@@ -31917,42 +32977,42 @@ function buildMemoryInjector(deps, policy) {
 
 // src/plugin/memoryTool.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 
 // src/memory/extract.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 var REDACTED = "[redacted]";
-var RawFactSchema = z34.object({
-  subject: z34.string().min(1),
-  predicate: z34.string().min(1),
-  object: z34.string().min(1),
-  category: z34.string().min(1).nullable().optional(),
-  confidence: z34.number().min(0).max(1).optional()
+var RawFactSchema = z36.object({
+  subject: z36.string().min(1),
+  predicate: z36.string().min(1),
+  object: z36.string().min(1),
+  category: z36.string().min(1).nullable().optional(),
+  confidence: z36.number().min(0).max(1).optional()
 });
-var RawPreferenceSchema = z34.object({
-  category: z34.string().min(1),
-  preference: z34.string().min(1),
-  context: z34.string().min(1).nullable().optional(),
-  confidence: z34.number().min(0).max(1).optional()
+var RawPreferenceSchema = z36.object({
+  category: z36.string().min(1),
+  preference: z36.string().min(1),
+  context: z36.string().min(1).nullable().optional(),
+  confidence: z36.number().min(0).max(1).optional()
 });
-var RawEntitySchema = z34.object({
-  canonicalName: z34.string().min(1),
-  type: z34.string().min(1),
-  aliases: z34.array(z34.string().min(1)).optional(),
-  confidence: z34.number().min(0).max(1).optional()
+var RawEntitySchema = z36.object({
+  canonicalName: z36.string().min(1),
+  type: z36.string().min(1),
+  aliases: z36.array(z36.string().min(1)).optional(),
+  confidence: z36.number().min(0).max(1).optional()
 });
-var RawRelationSchema = z34.object({
-  from: z34.string().min(1),
-  to: z34.string().min(1),
-  predicate: z34.string().min(1),
-  annotation: z34.string().min(1).nullable().optional(),
-  confidence: z34.number().min(0).max(1).optional()
+var RawRelationSchema = z36.object({
+  from: z36.string().min(1),
+  to: z36.string().min(1),
+  predicate: z36.string().min(1),
+  annotation: z36.string().min(1).nullable().optional(),
+  confidence: z36.number().min(0).max(1).optional()
 }).strict();
-var RawExtractionSchema = z34.object({
-  facts: z34.array(RawFactSchema).default([]),
-  preferences: z34.array(RawPreferenceSchema).default([]),
-  entities: z34.array(RawEntitySchema).default([]),
-  relations: z34.array(RawRelationSchema).default([])
+var RawExtractionSchema = z36.object({
+  facts: z36.array(RawFactSchema).default([]),
+  preferences: z36.array(RawPreferenceSchema).default([]),
+  entities: z36.array(RawEntitySchema).default([]),
+  relations: z36.array(RawRelationSchema).default([])
 });
 var DEFAULT_CONFIDENCE = 0.6;
 var SYSTEM_PROMPT = [
@@ -32206,13 +33266,13 @@ var memoryToolMessages = {
 
 // src/plugin/memoryTool.ts
 var SCRIBE_ROLE_ID = "scribe";
-var MemoryMessageSchema = z35.object({
-  role: z35.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
-  content: z35.string().min(1).describe(memoryToolMessages.messageContentDescription)
+var MemoryMessageSchema = z37.object({
+  role: z37.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
+  content: z37.string().min(1).describe(memoryToolMessages.messageContentDescription)
 }).strict();
-var MemoryWritePayloadSchema = z35.object({
-  messages: z35.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
-  roleID: z35.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
+var MemoryWritePayloadSchema = z37.object({
+  messages: z37.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
+  roleID: z37.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
 }).strict();
 function createMemoryTool(deps) {
   return tool5({
@@ -32396,7 +33456,7 @@ import { Session as Session2 } from "@opencode/schema/session";
 import { Tool as Tool2 } from "@opencode/schema/tool";
 import { tool as legacyTool } from "@opencode-ai/plugin/tool";
 import { Clock, Effect, Option, Stream } from "effect";
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 
 // src/plugin/nativeHostContext.ts
 import {
@@ -32458,7 +33518,7 @@ function nativeConfiguredInventory(models, config) {
 
 // src/plugin/nativeResidency.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 var NATIVE_RESIDENCY_PROVIDER_PACKAGE = "aisdk:@ai-sdk/openai-compatible@2.0.75";
 var NATIVE_ADMISSION_HEADER = "x-openteam-local-admission";
 var MAX_ADMISSIONS = 2048;
@@ -32536,7 +33596,7 @@ function createNativeModelResidencyGuard(config, options) {
     });
   }
   function target(model, send, baseURL) {
-    const headers = new Headers(z36.record(z36.string(), z36.string()).parse(model.headers ?? {}));
+    const headers = new Headers(z38.record(z38.string(), z38.string()).parse(model.headers ?? {}));
     if (typeof model.settings?.apiKey === "string" && !headers.has("authorization"))
       headers.set("authorization", `Bearer ${model.settings.apiKey}`);
     return {
@@ -32574,7 +33634,7 @@ function createNativeModelResidencyGuard(config, options) {
         localTargets.set(key(ref), target(model, guardedFetch(binding, options.fetch), binding.baseURL));
         return model;
       } catch (error) {
-        if (!(error instanceof ModelResidencyError) && !(error instanceof z36.ZodError))
+        if (!(error instanceof ModelResidencyError) && !(error instanceof z38.ZodError))
           throw error;
         (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(model.providerID, residentRuntimes.find((runtime) => runtime.defaultModel.providerID === model.providerID)?.kind === "llama-swap" ? "llama-swap" : "Lemonade"));
         return { ...model, enabled: false };
@@ -32731,6 +33791,10 @@ function nativeAssistantResponse(sessionID, message2) {
       ...message2.cost === undefined ? {} : { cost: message2.cost },
       ...message2.tokens === undefined ? {} : { tokens: message2.tokens },
       ...message2.error === undefined ? {} : { error: message2.error },
+      ...message2.finish === undefined ? {} : { finish: message2.finish },
+      ...message2.rawFinish === undefined ? {} : { rawFinish: message2.rawFinish },
+      hasGeneratedOutput: message2.content.some((part) => part.type === "tool" || part.text.length > 0),
+      truncatedToolCall: message2.finish === "length" && message2.content.some((part) => part.type === "tool" && part.executed === false && part.state.status === "error" && part.state.error.type === "tool.input-json"),
       time: {
         created: DateTime.toEpochMillis(message2.time.created),
         ...message2.time.completed === undefined ? {} : { completed: DateTime.toEpochMillis(message2.time.completed) }
@@ -32757,7 +33821,8 @@ function createNativeSessionClient(deps) {
   }
   return {
     async create(args) {
-      const signal = deps.signal?.();
+      const parentSignal = deps.signal?.();
+      const signal = parentSignal === undefined ? args.signal : args.signal === undefined ? parentSignal : AbortSignal.any([parentSignal, args.signal]);
       signal?.throwIfAborted();
       assertDirectory(args.query?.directory);
       if (args.body?.parentID === undefined)
@@ -32767,7 +33832,7 @@ function createNativeSessionClient(deps) {
       const child = await deps.run(deps.sessions().create({
         parentID,
         ...args.body.title === undefined ? {} : { title: args.body.title }
-      }));
+      }), signal === undefined ? undefined : { signal });
       if (!sameNativeWorkspace(child.location, location))
         throw new Error(nativeHostMessages.workspaceMismatch);
       if (child.parentID !== parentID)
@@ -32806,6 +33871,11 @@ function createNativeSessionClient(deps) {
         const assistant = [...messages].reverse().find((message2) => message2.type === "assistant");
         if (final.outcome === "interrupted")
           throw new Error(nativeHostMessages.executionInterrupted);
+        if (assistant?.time.completed !== undefined) {
+          const response = nativeAssistantResponse(sessionID, assistant);
+          if (response.info.truncatedToolCall)
+            return { data: response, error: undefined };
+        }
         if (final.outcome !== "succeeded" || assistant?.error !== undefined)
           throw new Error(nativeHostMessages.executionFailed);
         if (assistant?.time.completed === undefined)
@@ -32845,8 +33915,8 @@ function createNativeSessionClient(deps) {
 }
 
 // src/plugin/nativeHost.ts
-var executionEvent = z37.preprocess(only(["type", "location", "data"]), z37.object({
-  type: z37.enum([
+var executionEvent = z39.preprocess(only(["type", "location", "data"]), z39.object({
+  type: z39.enum([
     "session.created",
     "session.deleted",
     "session.execution.started",
@@ -32854,15 +33924,30 @@ var executionEvent = z37.preprocess(only(["type", "location", "data"]), z37.obje
     "session.execution.failed",
     "session.execution.interrupted",
     "session.step.ended",
-    "session.step.failed"
+    "session.step.started",
+    "session.step.failed",
+    "session.tool.input.started",
+    "session.tool.success",
+    "session.tool.failed"
   ]),
-  location: z37.preprocess(only(["directory", "workspaceID"]), z37.object({
-    directory: z37.string(),
-    workspaceID: z37.string().optional()
+  location: z39.preprocess(only(["directory", "workspaceID"]), z39.object({
+    directory: z39.string(),
+    workspaceID: z39.string().optional()
   }).strict()).optional(),
-  data: z37.preprocess(only(["sessionID", "assistantMessageID"]), z37.object({
-    sessionID: z37.string(),
-    assistantMessageID: z37.string().optional()
+  data: z39.preprocess(only([
+    "sessionID",
+    "assistantMessageID",
+    "id",
+    "name",
+    "executed",
+    "error"
+  ]), z39.object({
+    sessionID: z39.string(),
+    assistantMessageID: z39.string().optional(),
+    id: z39.string().optional(),
+    name: z39.string().optional(),
+    executed: z39.boolean().optional(),
+    error: z39.preprocess(only(["type"]), z39.object({ type: z39.string() }).strict()).optional()
   }).strict())
 }).strict());
 var nativeBindings = Effect.fn("openteam.nativeBindings")(function* () {
@@ -32903,7 +33988,7 @@ function legacyModel(ref) {
 }
 function createNativePluginEffect(factory) {
   return Effect.fn("openteam.native")(function* (ctx) {
-    if (ctx.app.version !== NATIVE_OPENCODE_VERSION)
+    if (!isSupportedNativeOpencodeVersion(ctx.app.version))
       return yield* Effect.die(new Error(nativeHostMessages.unsupportedVersion(ctx.app.version)));
     const version = ctx.app.version;
     const effectContext = yield* Effect.context();
@@ -32917,6 +34002,15 @@ function createNativePluginEffect(factory) {
     let config;
     let residency;
     const systemPrompts = new Map;
+    const toolNames = new Map;
+    const rememberTool = (sessionID, callID, name) => {
+      toolNames.set(`${sessionID}\x00${callID}`, name);
+      if (toolNames.size > 8192) {
+        const oldest = toolNames.keys().next().value;
+        if (oldest !== undefined)
+          toolNames.delete(oldest);
+      }
+    };
     const toolSignals = new AsyncLocalStorage;
     const remember = (next) => {
       bindings = { ...bindings, ...next };
@@ -32971,6 +34065,12 @@ function createNativePluginEffect(factory) {
       directory,
       worktree: ctx.location.project.directory,
       client,
+      toolOutcomesFromEvents: true,
+      parentSession: async (sessionID) => {
+        const info = await run(requiredBindings().sessions.get(Session2.ID.make(sessionID)));
+        assertWorkspace(info.location);
+        return info.parentID;
+      },
       exec: nativeExec(directory),
       serverUrl: () => {
         const url = bindings?.server?.urls().find((value) => {
@@ -33015,6 +34115,7 @@ function createNativePluginEffect(factory) {
     yield* Effect.addFinalizer(() => Effect.promise(async () => {
       guard.dispose();
       systemPrompts.clear();
+      toolNames.clear();
       await hooks.dispose?.();
     }));
     yield* ctx.provider.transform(guard.providers);
@@ -33147,7 +34248,10 @@ function createNativePluginEffect(factory) {
         });
       }
     });
-    yield* ctx.tool.hook("execute.before", (event) => Effect.promise(() => hooks["tool.execute.before"]?.({ tool: event.tool, sessionID: event.sessionID, callID: event.id }, { args: event.input }) ?? Promise.resolve()));
+    yield* ctx.tool.hook("execute.before", (event) => Effect.promise(() => {
+      rememberTool(event.sessionID, event.id, event.tool);
+      return hooks["tool.execute.before"]?.({ tool: event.tool, sessionID: event.sessionID, callID: event.id }, { args: event.input }) ?? Promise.resolve();
+    }));
     yield* ctx.tool.hook("execute.after", (event) => Effect.promise(() => hooks["tool.execute.after"]?.({
       tool: event.tool,
       sessionID: event.sessionID,
@@ -33174,9 +34278,62 @@ function createNativePluginEffect(factory) {
       if (value.type === "session.deleted") {
         guard.finished(sessionID);
         systemPrompts.delete(sessionID);
+        for (const key2 of toolNames.keys()) {
+          if (key2.startsWith(`${sessionID}\x00`))
+            toolNames.delete(key2);
+        }
       }
       let mapped;
-      if (value.type === "session.created" || value.type === "session.deleted") {
+      if (value.type === "session.tool.input.started") {
+        if (value.data.id !== undefined && value.data.name !== undefined)
+          rememberTool(sessionID, value.data.id, value.data.name);
+        await hooks.event?.({
+          event: {
+            type: "openteam.session.phase",
+            properties: { sessionID, phase: "tool-input" }
+          }
+        });
+        return;
+      } else if (value.type === "session.step.started") {
+        mapped = {
+          type: "openteam.session.phase",
+          properties: { sessionID, phase: "model-request" }
+        };
+      } else if (value.type === "session.tool.success" || value.type === "session.tool.failed") {
+        if (value.data.id === undefined)
+          return;
+        const key2 = `${sessionID}\x00${value.data.id}`;
+        let name = toolNames.get(key2);
+        if (name === undefined && bindings !== undefined) {
+          const messages = await run(bindings.sessions.messages({
+            sessionID: Session2.ID.make(sessionID),
+            limit: 100
+          }));
+          const message2 = messages.find((candidate) => candidate.id === value.data.assistantMessageID);
+          if (message2?.type === "assistant") {
+            const part = message2.content.find((candidate) => candidate.type === "tool" && candidate.id === value.data.id);
+            if (part?.type === "tool")
+              name = part.name;
+          }
+        }
+        const ok2 = value.type === "session.tool.success";
+        const inputFailure = value.data.error?.type === "tool.input-json" || value.data.error?.type === "tool.input-schema";
+        const executionReached = ok2 || value.data.error?.type === "tool.execution";
+        mapped = {
+          type: "openteam.tool.completed",
+          properties: {
+            sessionID,
+            callID: value.data.id,
+            tool: name ?? "unknown",
+            ok: ok2,
+            ...inputFailure ? { executed: false } : executionReached ? { executed: true } : {},
+            ...value.data.executed === undefined ? {} : { providerExecuted: value.data.executed },
+            ...!ok2 ? {
+              failureKind: inputFailure ? "input-invalid" : executionReached ? "execution" : "unknown"
+            } : {}
+          }
+        };
+      } else if (value.type === "session.created" || value.type === "session.deleted") {
         mapped = {
           type: value.type,
           properties: { info: { id: sessionID } }
@@ -33217,12 +34374,13 @@ function createNativePluginEffect(factory) {
 }
 
 // src/plugin/orchestrateTool.ts
+import { resolve as resolve16 } from "node:path";
 import { tool as tool6 } from "@opencode-ai/plugin";
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 var _pluginWarnedRoles = new Set;
 var EMPTY_ROLE_ID_SET = new Set;
 var SAFE_ROLE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
-var RoleIDSchema = z38.string().min(1).superRefine((roleID, ctx) => {
+var RoleIDSchema = z40.string().min(1).superRefine((roleID, ctx) => {
   if (!SAFE_ROLE_ID.test(roleID)) {
     ctx.addIssue({
       code: "custom",
@@ -33230,16 +34388,16 @@ var RoleIDSchema = z38.string().min(1).superRefine((roleID, ctx) => {
     });
   }
 });
-var RoleAssignmentSchema = z38.object({
+var RoleAssignmentSchema = z40.object({
   roleID: RoleIDSchema.describe("Role identifier from the roster"),
-  prompt: z38.string().min(1).describe("Work prompt for this role"),
-  title: z38.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z38.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
+  prompt: z40.string().min(1).describe("Work prompt for this role"),
+  title: z40.string().min(1).optional().describe("Human-readable title"),
+  dependsOn: z40.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
 }).strict();
-var OrchestratePayloadSchema = z38.object({
-  assignments: z38.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z38.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
-  directory: z38.string().min(1).optional().describe("Working directory override")
+var OrchestratePayloadSchema = z40.object({
+  assignments: z40.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
+  parentSessionID: z40.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
+  directory: z40.string().min(1).optional().describe("Working directory override")
 }).strict();
 function validateAssignmentDependencies(assignments) {
   const ids = new Set;
@@ -33424,8 +34582,15 @@ function adaptSdkClient(sdk, orchestratedModelOwnership) {
           if (result.error !== undefined) {
             out.error = normalizeSdkSessionFailure(result.error, "prompt");
           } else {
+            const info = isRecord8(result.data) ? nestedRecord2(result.data, "info") : undefined;
             const nestedFailure = nestedAssistantFailure(result.data);
-            if (nestedFailure !== undefined) {
+            if (info?.finish === "length" && info.truncatedToolCall === true) {
+              out.error = {
+                kind: "normalized-session-failure",
+                failureClass: "prompt-output-truncated",
+                retryable: true
+              };
+            } else if (nestedFailure !== undefined) {
               out.error = normalizeSdkSessionFailure(nestedFailure, "prompt");
             } else if (result.data !== undefined) {
               out.data = result.data;
@@ -33585,7 +34750,10 @@ function mapTelemetryFailureClassToErrorClass(cls) {
     case "prompt-rate-limited":
     case "prompt-connection":
     case "prompt-server":
+    case "prompt-output-truncated":
       return "transient";
+    case "budget-exhausted":
+      return "permanent";
     case "create-rejected":
     case "create-no-id":
     case "prompt-rejected":
@@ -33868,8 +35036,16 @@ function createOrchestrateTool(deps) {
       }
       const parentOverrideIgnored = parsed.data.parentSessionID !== undefined && parsed.data.parentSessionID !== context.sessionID;
       parsed.data.parentSessionID = context.sessionID;
-      if (parsed.data.directory === undefined && context.directory !== undefined)
-        parsed.data.directory = context.directory;
+      if (deps.workspaceDirectory !== undefined) {
+        const workspace = resolve16(deps.workspaceDirectory);
+        if (resolve16(workspace, parsed.data.directory ?? ".") !== workspace)
+          return reportDeliveryMessages.workspaceMismatch;
+        parsed.data.directory = workspace;
+      } else if (parsed.data.directory === undefined) {
+        const directory = context.directory;
+        if (directory !== undefined)
+          parsed.data.directory = directory;
+      }
       const depError = validateAssignmentDependencies(parsed.data.assignments);
       if (depError !== undefined) {
         return dependencyValidationError(depError.code, depError.detail);
@@ -33892,6 +35068,14 @@ function createOrchestrateTool(deps) {
             return missingAgentDefinition(agentName, input.roleID);
           }
         }
+        const taskRef = await deps.taskEffort?.forSession(context.sessionID);
+        if (taskRef !== undefined && deps.taskEffort !== undefined) {
+          const effort2 = deps.taskEffort.batch(taskRef);
+          if (!effort2.ok)
+            return taskEffortMessages.exhausted(effort2.reason);
+          for (const input of inputs)
+            input.taskID = taskRef.taskID;
+        }
         const batchID = deps.newDecisionID();
         if (deps.lifecycleRecorder !== undefined) {
           const rootOperationID = operationID(batchID, "openteam");
@@ -33901,7 +35085,7 @@ function createOrchestrateTool(deps) {
             executionAuthority: "coordinator",
             root: {
               operationID: rootOperationID,
-              taskID: batchID,
+              taskID: taskRef?.taskID ?? batchID,
               kind: "coordinator",
               roleID: "openteam",
               agentID: context.agent,
@@ -33926,6 +35110,12 @@ function createOrchestrateTool(deps) {
           reportedModelSlots: deps.reportedModelSlots,
           readReportArtifact: deps.readReportArtifact,
           reportArtifactExists: deps.reportArtifactExists,
+          ...deps.reportDelivery === undefined ? {} : { reportDelivery: deps.reportDelivery },
+          ...deps.sessionPhase === undefined ? {} : { sessionPhase: deps.sessionPhase },
+          signal: context.abort,
+          ...deps.taskEffort === undefined || taskRef === undefined ? {} : {
+            taskEffort: { ledger: deps.taskEffort, ref: taskRef }
+          },
           abortGraceMs: deps.abortGraceMs,
           statusPollMs: deps.statusPollMs,
           delay: deps.delay,
@@ -33943,10 +35133,15 @@ function createOrchestrateTool(deps) {
         lifecycleStatus = activeLifecycleRecorder?.status() ?? lifecycleStatus;
         const projected = projectResults(batch.results, batch.cancelled);
         const shadowResult = await runShadowProducer(deps, parsed.data, batch);
+        const effort = taskRef === undefined ? undefined : deps.taskEffort?.check(taskRef);
+        const effortSummary = effort === undefined ? "" : `
+
+${effort.ok ? taskEffortMessages.summary(effort.batches, effort.attempts, effort.remainingMs, effort.remainingBatches, effort.remainingAttempts) : taskEffortMessages.exhausted(effort.reason)}`;
         const base = formatResult(projected) + (parentOverrideIgnored ? `
 
-${PARENT_OVERRIDE_IGNORED}` : "");
-        const advisory = singleAssignmentAdvisory(parsed.data.assignments.length, assignableRoleIDs(deps.config).length);
+${PARENT_OVERRIDE_IGNORED}` : "") + effortSummary;
+        const exhausted = effort?.ok === false || effort?.ok === true && (effort.remainingBatches === 0 || effort.remainingAttempts === 0);
+        const advisory = exhausted ? undefined : singleAssignmentAdvisory(parsed.data.assignments.length, assignableRoleIDs(deps.config).length);
         const withAdvisory = advisory === undefined ? base : `${base}
 
 ${advisory}`;
@@ -33977,7 +35172,7 @@ ${advisory}`;
 
 // src/plugin/registerCastTool.ts
 import { tool as tool7 } from "@opencode-ai/plugin";
-import { z as z39 } from "zod";
+import { z as z41 } from "zod";
 
 // src/messages/rosterSummary.ts
 var ROSTER_SUMMARY_HEADING = "Registered team model policies";
@@ -34093,12 +35288,12 @@ function createTeamPreparation(deps) {
       OpenTeamConfigSchema.parse(migrateConfig(baseRaw));
       const overlay = overlayBefore === undefined ? undefined : parseConfigFileJson(DEFAULT_LOCAL_OVERLAY_PATH, overlayBefore);
       const options = configOptionsFromPluginOptions(deps.options);
-      const resolve16 = (raw) => {
+      const resolve17 = (raw) => {
         const config = validateConfigInput(TEAM_PREPARATION_CONFIG, mergeConfigInputs(mergeConfigInputs(raw, options), overlay));
         assertEffectiveConfigModelDomains(config);
         return config;
       };
-      const current = resolve16(baseRaw);
+      const current = resolve17(baseRaw);
       const live = liveConfig ?? current;
       if (resolveExecutionMode({
         routerMode: current.router.executionMode,
@@ -34120,7 +35315,7 @@ function createTeamPreparation(deps) {
           ]))
         }
       });
-      const effective = resolve16(candidate);
+      const effective = resolve17(candidate);
       const requestedProfiles = new Set(roster.entries.filter((entry) => !isKnownNonWorkerRole(entry.roleID) && getRoleProfile(entry.roleID, live.orchestrator?.roles) === undefined).map((entry) => getRoleProfile(entry.roleID, effective.orchestrator?.roles)));
       const additions = Object.fromEntries(Object.entries(effective.orchestrator?.roles ?? {}).filter(([key2, profile]) => requestedProfiles.has(profile) && !Object.hasOwn(live.orchestrator?.roles ?? {}, key2)));
       const hasAdditions = Object.keys(additions).length > 0;
@@ -34206,13 +35401,13 @@ async function persistPreparedTeam(storage, files) {
 }
 
 // src/plugin/registerCastTool.ts
-var CastEntrySchema = z39.object({
-  roleID: z39.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
-  agentName: z39.string().min(1).describe("Themed character name assigned to the role")
+var CastEntrySchema = z41.object({
+  roleID: z41.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
+  agentName: z41.string().min(1).describe("Themed character name assigned to the role")
 }).strict();
-var RegisterCastPayloadSchema = z39.object({
-  universe: z39.string().min(1).describe("Casting universe for this roster"),
-  entries: z39.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
+var RegisterCastPayloadSchema = z41.object({
+  universe: z41.string().min(1).describe("Casting universe for this roster"),
+  entries: z41.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
 }).strict();
 function offendingFields(error) {
   const fields = error.issues.flatMap((issue) => {
@@ -34332,7 +35527,7 @@ function createRegisterCastTool(deps) {
 }
 
 // src/plugin/reloadTool.ts
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 import { tool as tool8 } from "@opencode-ai/plugin/tool";
 var WAIT_MS = 30000;
 var SDK_TIMEOUT_MS = 5000;
@@ -34366,7 +35561,7 @@ function createReloadController(deps) {
       return () => clearTimeout(timer);
     }
   };
-  const directory = resolve16(deps.directory);
+  const directory = resolve17(deps.directory);
   let pending;
   let authorizing;
   let closed = false;
@@ -34514,7 +35709,7 @@ function createReloadController(deps) {
       const parsed = schema.safeParse(args);
       if (!parsed.success)
         return reloadMessages.invalid;
-      if (context.agent !== "openteam" || resolve16(context.directory) !== directory || context.sessionID.trim().length === 0)
+      if (context.agent !== "openteam" || resolve17(context.directory) !== directory || context.sessionID.trim().length === 0)
         return reloadMessages.denied;
       if (parsed.data.action === "cancel") {
         if ((pending?.sessionID ?? authorizing?.sessionID) !== context.sessionID)
@@ -34632,6 +35827,31 @@ function createReloadController(deps) {
   };
 }
 
+// src/plugin/reportTool.ts
+import { tool as tool9 } from "@opencode-ai/plugin";
+function createReportTool(delivery) {
+  return tool9({
+    description: reportDeliveryMessages.description,
+    args: {
+      status: tool9.schema.enum(["done", "continue"]).describe(reportDeliveryMessages.status),
+      findings: tool9.schema.string().min(1).max(32768).describe(reportDeliveryMessages.findings)
+    },
+    async execute(args, context) {
+      context.abort.throwIfAborted();
+      const path4 = delivery.path(context.sessionID);
+      await context.ask({
+        permission: "openteam-submit-report",
+        patterns: [path4],
+        always: [],
+        metadata: { reportPath: path4 }
+      });
+      context.abort.throwIfAborted();
+      await delivery.submit(context.sessionID, args);
+      return reportDeliveryMessages.submitted(path4);
+    }
+  });
+}
+
 // src/plugin/sessionTracker.ts
 function createSessionTracker() {
   const knownSessions = new Set;
@@ -34660,22 +35880,40 @@ function createSessionTracker() {
 }
 
 // src/plugin/toolcalls.ts
+var MAX_TRACKED_CALLS = 8192;
 function key2(sessionID, callID) {
   return `${sessionID}\x00${callID}`;
 }
 function createToolcallTracker(deps) {
   const now = deps.now ?? Date.now;
   const started = new Map;
+  const completed = new Set;
   return {
     before(input) {
-      started.set(key2(input.sessionID, input.callID), now());
+      const mapKey = key2(input.sessionID, input.callID);
+      if (completed.has(mapKey) || started.has(mapKey))
+        return;
+      started.set(mapKey, now());
+      if (started.size > MAX_TRACKED_CALLS) {
+        const oldest = started.keys().next().value;
+        if (oldest !== undefined)
+          started.delete(oldest);
+      }
     },
     after(input) {
       const mapKey = key2(input.sessionID, input.callID);
+      if (completed.has(mapKey))
+        return;
+      completed.add(mapKey);
+      if (completed.size > MAX_TRACKED_CALLS) {
+        const oldest = completed.values().next().value;
+        if (oldest !== undefined)
+          completed.delete(oldest);
+      }
       const start = started.get(mapKey);
       started.delete(mapKey);
       const end = now();
-      const durationMs = start === undefined ? 0 : Math.max(0, end - start);
+      const durationMs = input.durationMs !== undefined ? input.durationMs : start === undefined ? null : Math.max(0, Math.trunc(end - start));
       const event = {
         v: EVENT_SCHEMA_VERSION,
         type: "toolcall",
@@ -34684,9 +35922,23 @@ function createToolcallTracker(deps) {
         tool: input.tool,
         callID: input.callID,
         durationMs,
-        ok: true
+        ok: input.ok ?? true,
+        ...input.executed === undefined ? {} : { executed: input.executed },
+        ...input.providerExecuted === undefined ? {} : { providerExecuted: input.providerExecuted },
+        ...input.failureKind === undefined ? {} : { failureKind: input.failureKind }
       };
       return deps.sink.emit(event);
+    },
+    forgetSession(sessionID) {
+      const prefix = `${sessionID}\x00`;
+      for (const mapKey of started.keys()) {
+        if (mapKey.startsWith(prefix))
+          started.delete(mapKey);
+      }
+      for (const mapKey of completed) {
+        if (mapKey.startsWith(prefix))
+          completed.delete(mapKey);
+      }
     }
   };
 }
@@ -34874,6 +36126,61 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   }
 }
 
+// src/storage/scopedArtifacts.ts
+import { lstatSync as lstatSync4, mkdirSync as mkdirSync4, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname10, join as join22 } from "node:path";
+function createScopedArtifactStore(directory, root) {
+  function pathFor(name) {
+    const workspace = realpathSync3(directory);
+    const segments = [...splitVirtualPath(root), ...splitVirtualPath(name)];
+    const filename = segments.pop();
+    if (!filename)
+      throw new Error(reportDeliveryMessages.unsafePath);
+    let path4 = workspace;
+    for (const segment of segments) {
+      path4 = join22(path4, segment);
+      try {
+        mkdirSync4(path4, { mode: 448 });
+      } catch (error) {
+        if (!(typeof error === "object" && error !== null && ("code" in error) && error.code === "EEXIST"))
+          throw error;
+      }
+      const stat4 = lstatSync4(path4);
+      if (!stat4.isDirectory() || stat4.isSymbolicLink())
+        throw new Error(reportDeliveryMessages.unsafePath);
+    }
+    const target = join22(path4, filename);
+    try {
+      const stat4 = lstatSync4(target);
+      if (!stat4.isFile() || stat4.isSymbolicLink() || stat4.size > 1048576)
+        throw new Error(reportDeliveryMessages.unsafePath);
+    } catch (error) {
+      if (!isMissingFsError(error))
+        throw error;
+    }
+    return target;
+  }
+  return {
+    read(name) {
+      return readUtf8(pathFor(name));
+    },
+    write(name, content) {
+      if (Buffer.byteLength(content, "utf8") > 1048576)
+        throw new Error(reportDeliveryMessages.unsafePath);
+      writeDurableAtomically(pathFor(name), content);
+    },
+    update(name, change) {
+      const path4 = pathFor(name);
+      withRunMutationLock(dirname10(path4), () => {
+        const content = change(readUtf8(path4));
+        if (Buffer.byteLength(content, "utf8") > 1048576)
+          throw new Error(reportDeliveryMessages.unsafePath);
+        writeDurableAtomically(path4, content);
+      });
+    }
+  };
+}
+
 // src/telemetry/otelExporter.ts
 var DEFAULT_SERVICE_NAME = "openteam";
 function tracesUrl(ingestionEndpoint) {
@@ -35018,7 +36325,7 @@ var RELEASE_CERT_PATH = "artifacts/graph-release-certificate.json";
 var SOAK_CERT_PATH = "artifacts/graph-soak-certificate.json";
 async function readPackagedCertificate(path4) {
   try {
-    const hostDirectory = basename4(dirname10(path4)) === NATIVE_CERTIFICATE_DIRECTORY ? `${NATIVE_CERTIFICATE_DIRECTORY}/` : "";
+    const hostDirectory = basename4(dirname11(path4)) === NATIVE_CERTIFICATE_DIRECTORY ? `${NATIVE_CERTIFICATE_DIRECTORY}/` : "";
     return await readFile5(new URL(`./certificates/${hostDirectory}${basename4(path4)}`, import.meta.url), "utf8");
   } catch {
     return;
@@ -35143,8 +36450,8 @@ async function tryReadOpencodeVersion(serverUrl, fetchFn, client) {
 }
 var DEFAULT_OPENCODE_VERSION_BACKOFF_MS = [50, 250];
 function defaultSleep(ms2) {
-  return new Promise((resolve17) => {
-    setTimeout(resolve17, ms2);
+  return new Promise((resolve19) => {
+    setTimeout(resolve19, ms2);
   });
 }
 function createLazyOpencodeVersionReader(serverUrl, options = {}) {
@@ -35187,7 +36494,7 @@ function createLazyOpencodeVersionReader(serverUrl, options = {}) {
   };
 }
 async function buildGateInput(config, storage, opencodeVersion, warn, packagedRead = readPackagedCertificate) {
-  const hostPath = (path4) => opencodeVersion === NATIVE_OPENCODE_VERSION ? `${dirname10(path4)}/${NATIVE_CERTIFICATE_DIRECTORY}/${basename4(path4)}` : path4;
+  const hostPath = (path4) => isSupportedNativeOpencodeVersion(opencodeVersion) ? `${dirname11(path4)}/${NATIVE_CERTIFICATE_DIRECTORY}/${basename4(path4)}` : path4;
   const shadow = await readAndParseCertificate(storage, hostPath(SHADOW_CERT_PATH), (raw) => parseShadowCertificate(raw, opencodeVersion), (cert) => shadowCertificateBindingDigest(cert.evidence), packagedRead);
   const shadowDigest = shadow.status === "valid" ? shadow.digest : "0".repeat(64);
   const release = await readAndParseCertificate(storage, hostPath(RELEASE_CERT_PATH), (raw) => parseReleaseCertificate(raw, opencodeVersion, shadowDigest), (cert) => cert.digest, packagedRead);
@@ -35396,7 +36703,7 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
     telemetryPath,
     opencodeConfigPaths: OPENCODE_CONFIG_CANDIDATES,
     orchestratorAgentPath: ORCHESTRATOR_AGENT_PATH,
-    agentDir: dirname10(ORCHESTRATOR_AGENT_PATH),
+    agentDir: dirname11(ORCHESTRATOR_AGENT_PATH),
     cachePort: realCacheAdapter,
     purge: createPluginPurgeRuntime(sessionsDir),
     loadRosterForDoctor: () => readStoredRosterForDoctor(storage),
@@ -35547,6 +36854,24 @@ async function createPluginRuntime(ctx, rawOptions) {
     return version === "unknown" ? undefined : version;
   }, workspaceRoot);
   const toolcalls = createToolcallTracker({ sink });
+  const sessionPhase = async (sessionID, phase) => {
+    try {
+      await sink.emit({
+        v: 1,
+        type: "activity",
+        ts: now(),
+        sessionID,
+        kind: "agent",
+        summary: executionPhaseMessages[phase],
+        phase
+      });
+    } catch (error) {
+      logTelemetryError(error, diagnostics.warn("telemetry-write-failed", {
+        persist: false,
+        toast: false
+      }));
+    }
+  };
   const announcedSessions = new Set;
   const announceEndpoint = (sessionID) => {
     if (sessionID === undefined || announcedSessions.has(sessionID)) {
@@ -35667,6 +36992,18 @@ async function createPluginRuntime(ctx, rawOptions) {
     },
     now
   });
+  const reportStore = createScopedArtifactStore(ctx.directory, ROLE_REPORTS_ROOT);
+  const taskEffort = createTaskEffort({
+    store: createScopedArtifactStore(ctx.directory, ".opencode/openteam-local/effort"),
+    now,
+    ...config.orchestrator?.taskBudget === undefined ? {} : { limits: config.orchestrator.taskBudget },
+    ...ctx.parentSession === undefined ? {} : { parentSession: ctx.parentSession }
+  });
+  const reportDelivery = createReportDelivery({
+    write: async (path4, content) => {
+      reportStore.write(path4.slice(ROLE_REPORTS_ROOT.length + 1), content);
+    }
+  });
   const orchestrateTool = createOrchestrateTool({
     client: orchestrateClient,
     sink,
@@ -35687,11 +37024,15 @@ async function createPluginRuntime(ctx, rawOptions) {
     capabilityProfiles,
     reportArtifactExists,
     readReportArtifact,
+    reportDelivery,
+    taskEffort,
+    sessionPhase,
+    workspaceDirectory: ctx.directory,
     lifecycleRecorder,
     abortGraceMs: DEFAULT_ABORT_GRACE_MS,
     statusPollMs: DEFAULT_STATUS_POLL_MS,
-    delay: (ms2) => new Promise((resolve17) => {
-      setTimeout(resolve17, ms2);
+    delay: (ms2) => new Promise((resolve19) => {
+      setTimeout(resolve19, ms2);
     }),
     warn: diagnostics.warn("unknown-role")
   });
@@ -35757,7 +37098,9 @@ async function createPluginRuntime(ctx, rawOptions) {
     ...hooks,
     "chat.message": async (input, output) => {
       reload.userTurn(input.sessionID);
+      await taskEffort.userTurn(input.sessionID, input.messageID ?? output.message.id);
       await hooks["chat.message"]?.(input, output);
+      await sessionPhase(input.sessionID, "model-request");
       announceEndpoint(input.sessionID);
     },
     dispose: async () => {
@@ -35771,18 +37114,44 @@ async function createPluginRuntime(ctx, rawOptions) {
       "openteam-orchestrate": orchestrateTool,
       "openteam-memory": memoryTool,
       "openteam-register-cast": registerCastTool,
-      "openteam-reload": reload.tool
+      "openteam-reload": reload.tool,
+      "openteam-submit-report": createReportTool(reportDelivery)
     },
     "tool.execute.before": async (input) => {
       toolcalls.before(input);
+      await sessionPhase(input.sessionID, "tool-execution");
     },
     "tool.execute.after": async (input) => {
-      await toolcalls.after(input);
+      if (ctx.toolOutcomesFromEvents !== true)
+        await toolcalls.after(input);
       if (input.tool === "openteam-reload")
         reload.toolCompleted(input.sessionID);
     },
     event: async ({ event }) => {
       reload.event(event);
+      if (event.type === "openteam.tool.completed") {
+        await toolcalls.after(event.properties);
+        await sessionPhase(event.properties.sessionID, "unknown");
+      } else if (event.type === "openteam.session.phase") {
+        await sessionPhase(event.properties.sessionID, event.properties.phase);
+      } else if (event.type === "session.idle") {
+        if (typeof event.properties?.sessionID === "string")
+          await sessionPhase(event.properties.sessionID, "idle");
+      } else if (event.type === "message.part.updated") {
+        const part = event.properties.part;
+        if (part.type === "tool" && (part.state.status === "completed" || part.state.status === "error")) {
+          await toolcalls.after({
+            tool: part.tool,
+            sessionID: part.sessionID,
+            callID: part.callID,
+            ok: part.state.status === "completed",
+            durationMs: Math.max(0, Math.trunc(part.state.time.end - part.state.time.start)),
+            ...part.state.status === "error" ? { failureKind: "execution" } : {}
+          });
+        }
+      } else if (event.type === "session.deleted") {
+        toolcalls.forgetSession(event.properties.info.id);
+      }
       if (event.type === "session.created" || event.type === "session.idle") {
         cache.refresh();
       }
@@ -35799,6 +37168,7 @@ async function createPluginRuntime(ctx, rawOptions) {
           announceEndpoint(message2.sessionID);
           sessionTracker.trackSession(message2.sessionID);
           sink.emit(message2);
+          await sessionPhase(message2.sessionID, "unknown");
         }
       }
     }
@@ -35808,6 +37178,19 @@ var server = (ctx, rawOptions) => createPluginRuntime({
   directory: ctx.directory,
   worktree: ctx.worktree,
   client: ctx.client,
+  ...typeof ctx.client.session?.get !== "function" ? {} : {
+    parentSession: async (sessionID) => {
+      const response = await ctx.client.session.get({
+        path: { id: sessionID },
+        query: { directory: ctx.directory }
+      });
+      if (response.error !== undefined || response.data === undefined)
+        throw new Error(nativeHostMessages.missingBindings);
+      if (resolve18(response.data.directory) !== resolve18(ctx.directory))
+        throw new Error(nativeHostMessages.workspaceMismatch);
+      return response.data.parentID;
+    }
+  },
   exec: createShellExec(ctx.$),
   serverUrl: () => ctx.serverUrl,
   ...ctx.client.config?.providers === undefined ? {} : {
@@ -36434,7 +37817,7 @@ function createGitLastCommit(exec) {
 // src/cli.ts
 var execFileAsync3 = promisify3(execFile4);
 var execAsync = promisify3(exec);
-var AGENT_DIR = dirname11(ORCHESTRATOR_AGENT_PATH);
+var AGENT_DIR = dirname12(ORCHESTRATOR_AGENT_PATH);
 var storage = createFsStorageProvider(process.cwd());
 var CLI_LIFECYCLE_WRITER_IDENTITY = {
   processID: process.pid,
@@ -36521,7 +37904,7 @@ async function readConfigFile(path4, resolution) {
     return storage.read(path4);
   }
   try {
-    return await readFile6(resolve17(path4), "utf8");
+    return await readFile6(resolve19(path4), "utf8");
   } catch (error) {
     throw new Error(`[openteam] config file named by --config could not be read: ${path4} (${describeFileReadError(error)})`);
   }
@@ -36544,8 +37927,8 @@ async function saveConfig(config, path4, resolution = { explicit: false }) {
     return;
   }
   const contents = serializeOpenTeamConfig(config);
-  const diskPath = resolve17(path4);
-  await mkdir5(dirname11(diskPath), { recursive: true });
+  const diskPath = resolve19(path4);
+  await mkdir5(dirname12(diskPath), { recursive: true });
   await writeFile2(diskPath, contents, "utf8");
 }
 function parseConfigSelection(argv) {
@@ -36590,8 +37973,8 @@ async function openBrowser(url) {
   }
 }
 function waitForSignal() {
-  return new Promise((resolve18) => {
-    const done = () => resolve18();
+  return new Promise((resolve20) => {
+    const done = () => resolve20();
     process.once("SIGINT", done);
     process.once("SIGTERM", done);
   });
@@ -36792,7 +38175,7 @@ async function main() {
         workspaceRoot,
         configuredRoot: initialConsoleConfig.lifecycle?.root ?? DEFAULT_LIFECYCLE_ROOT
       });
-      const legacyGraphRoot = resolve17(workspaceRoot, initialConsoleConfig.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT);
+      const legacyGraphRoot = resolve19(workspaceRoot, initialConsoleConfig.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT);
       const lifecycleAvailability = initialConsoleConfig.console.graphView?.enabled === true ? "enabled" : "history-disabled";
       const lifecycleHistoryReader = createLifecycleHistoryProvider({
         lifecycleRoot,