@jmanuelcorral/openteam 0.27.1 → 0.28.0

package/dist/index.js

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname8 } from "node:path";
+import { basename as basename4, dirname as dirname9, resolve as resolve15 } from "node:path";
 
 // src/capabilities/curated.ts
 var CURATED_FRONTIER_PROFILES = [
@@ -786,6 +786,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.",
@@ -1041,7 +1050,13 @@ var OrchestratorConfigSchema = z3.object({
   roles: OrchestratorRolesSchema,
   primary: AgentExecutionPolicySchema.optional(),
   maxRetries: z3.number().int().min(0).optional(),
-  maxModelsPerNode: z3.number().int().positive().optional()
+  maxModelsPerNode: z3.number().int().positive().optional(),
+  taskBudget: z3.object({
+    maxBatches: z3.number().int().min(1).max(1000).optional(),
+    maxAttempts: z3.number().int().min(1).max(1e4).optional(),
+    maxDurationMs: z3.number().int().min(1000).max(86400000).optional(),
+    maxDepth: z3.number().int().min(0).max(32).optional()
+  }).strict().optional()
 }).strict();
 var defaultFrontierModel = {
   providerID: "google",
@@ -1566,6 +1581,8 @@ var NodeFailureClassSchema = z6.enum([
   "prompt-auth",
   "prompt-content-filter",
   "prompt-context-length",
+  "prompt-output-truncated",
+  "budget-exhausted",
   "prompt-validation",
   "prompt-connection",
   "prompt-server",
@@ -3975,8 +3992,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) {
@@ -4251,15 +4275,29 @@ var MessageEventSchema = EventBaseSchema.extend({
   tokensReasoning: z11.number().int().min(0),
   tokensCacheRead: z11.number().int().min(0),
   tokensCacheWrite: z11.number().int().min(0),
-  durationMs: z11.number().int().min(0)
+  durationMs: z11.number().int().min(0),
+  usageStatus: z11.enum(["reported", "missing", "zero-unverified"]).optional(),
+  costStatus: z11.enum(["reported", "unavailable"]).optional(),
+  finish: z11.enum([
+    "stop",
+    "length",
+    "tool-calls",
+    "content-filter",
+    "error",
+    "unknown"
+  ]).optional(),
+  truncatedToolCall: z11.boolean().optional()
 });
 var ToolcallEventSchema = EventBaseSchema.extend({
   type: z11.literal("toolcall"),
   tool: z11.string().min(1),
   callID: z11.string().min(1),
   agent: z11.string().min(1).optional(),
-  durationMs: z11.number().int().min(0),
+  durationMs: z11.number().int().min(0).nullable(),
   ok: z11.boolean(),
+  executed: z11.boolean().optional(),
+  providerExecuted: z11.boolean().optional(),
+  failureKind: z11.enum(["input-invalid", "execution", "unknown"]).optional(),
   title: z11.string().optional()
 });
 var MeetingEventSchema = EventBaseSchema.extend({
@@ -4289,7 +4327,15 @@ var ActivityEventSchema = EventBaseSchema.extend({
   type: z11.literal("activity"),
   kind: z11.enum(["route", "agent", "decision", "commit"]),
   agent: z11.string().min(1).optional(),
-  summary: z11.string().min(1)
+  summary: z11.string().min(1),
+  phase: z11.enum([
+    "model-request",
+    "tool-input",
+    "tool-execution",
+    "report-validation",
+    "idle",
+    "unknown"
+  ]).optional()
 });
 var SessionEndpointEventSchema = EventBaseSchema.extend({
   type: z11.literal("session-endpoint"),
@@ -5298,7 +5344,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",
@@ -5760,7 +5814,7 @@ import { z as z15 } from "zod";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.27.1",
+  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",
@@ -8679,6 +8733,7 @@ var lifecycleFailureSchema = z18.object({
     "prompt-auth",
     "prompt-content-filter",
     "prompt-context-length",
+    "prompt-output-truncated",
     "prompt-validation",
     "prompt-connection",
     "prompt-server",
@@ -9730,17 +9785,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((resolve5) => {
-        state.queues[priority].push((release) => {
+      return new Promise((resolve5, reject) => {
+        const waiter = (release) => {
+          signal?.removeEventListener("abort", cancel);
           resolve5({ release, waitedMs: options.now() - queuedAt });
-        });
+        };
+        function cancel() {
+          const index = state.queues[priority].indexOf(waiter);
+          if (index < 0)
+            return;
+          state.queues[priority].splice(index, 1);
+          signal?.removeEventListener("abort", cancel);
+          reject(signal?.reason);
+        }
+        state.queues[priority].push(waiter);
+        signal?.addEventListener("abort", cancel, { once: true });
+        if (signal?.aborted)
+          cancel();
       });
     },
     activeCount(runtimeId) {
@@ -11078,6 +11147,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: (path2) => `Report persisted at ${path2}. 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.";
@@ -11148,6 +11243,183 @@ function incapableFixedModel(roleID, providerID, modelID) {
   return `openteam coordinator: request for role "${roleID}" blocked — ` + `execution-policy-model-incapable. Configured model "${providerID}/${modelID}" ` + `does not satisfy the role capability requirements.`;
 }
 
+// src/orchestrator/outputContract.ts
+import { createHash as createHash3 } from "node:crypto";
+var ROLE_REPORTS_ROOT = ".opencode/openteam-local/reports";
+var REPORT_STATUS_MARKER = "openteam-status";
+var REPORT_STATUS_LINE_PATTERN = /^[ ]{0,3}openteam-status:[ \t]*(.*?)[ \t]*$/i;
+var FENCE_DELIMITER_PATTERN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+function fenceDelimiter(line) {
+  const match = FENCE_DELIMITER_PATTERN.exec(line);
+  const run = match?.[1];
+  if (run === undefined)
+    return;
+  const marker = run.startsWith("`") ? "`" : "~";
+  return {
+    marker,
+    length: run.length,
+    remainder: match?.[2] ?? ""
+  };
+}
+function declaredStatus(value) {
+  const normalized = value.toLowerCase();
+  if (normalized === "done")
+    return "done";
+  if (normalized === "continue")
+    return "continue";
+  return "unknown";
+}
+function analyzeReport(text) {
+  let status = "unknown";
+  let fence;
+  const bodyLines = [];
+  for (const line of text.split(/\r?\n/)) {
+    const delimiter = fenceDelimiter(line);
+    if (fence !== undefined) {
+      bodyLines.push(line);
+      if (delimiter?.marker === fence.marker && delimiter.length >= fence.length && delimiter.remainder.trim().length === 0) {
+        fence = undefined;
+      }
+      continue;
+    }
+    if (delimiter !== undefined) {
+      fence = delimiter;
+      bodyLines.push(line);
+      continue;
+    }
+    const declaration = REPORT_STATUS_LINE_PATTERN.exec(line);
+    if (declaration !== null) {
+      status = declaredStatus(declaration[1] ?? "");
+      continue;
+    }
+    bodyLines.push(line);
+  }
+  return {
+    status,
+    body: bodyLines.join(`
+`).trim()
+  };
+}
+function parseReportStatus(text) {
+  if (text === undefined || text.length === 0)
+    return "unknown";
+  return analyzeReport(text).status;
+}
+var MIN_REPORT_BODY_CHARS = 40;
+var MAX_REPORT_SEGMENT_CHARS = 64;
+var REPORT_SEGMENT_HASH_CHARS = 24;
+var SAFE_REPORT_SEGMENT = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,62}[A-Za-z0-9_-])?$/;
+var WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
+function reportSegmentHash(value) {
+  return createHash3("sha256").update(value, "utf8").digest("hex").slice(0, REPORT_SEGMENT_HASH_CHARS);
+}
+function reportPathSegment(value) {
+  if (value.length <= MAX_REPORT_SEGMENT_CHARS && SAFE_REPORT_SEGMENT.test(value) && value === value.toLowerCase() && !WINDOWS_DEVICE_NAME.test(value)) {
+    return value;
+  }
+  const suffix = `~${reportSegmentHash(value)}`;
+  const maxPrefixChars = MAX_REPORT_SEGMENT_CHARS - suffix.length;
+  let prefix = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, maxPrefixChars).replace(/[.]+$/, "");
+  if (prefix.length === 0) {
+    prefix = "segment";
+  }
+  if (WINDOWS_DEVICE_NAME.test(prefix)) {
+    prefix = `safe-${prefix}`.slice(0, maxPrefixChars).replace(/[.]+$/, "");
+  }
+  return `${prefix}${suffix}`;
+}
+function reportHasSubstance(text) {
+  if (text === undefined)
+    return false;
+  return analyzeReport(text).body.length >= MIN_REPORT_BODY_CHARS;
+}
+function roleReportPath(batchID, roleID) {
+  return `${ROLE_REPORTS_ROOT}/${reportPathSegment(batchID)}/${reportPathSegment(roleID)}.md`;
+}
+function outputContractInstruction(reportPath, structuredReport) {
+  return [
+    "## Output contract (openteam)",
+    "",
+    ...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,",
+    "and the coordinator will have no record of it.",
+    "",
+    `Report file: ${reportPath}`,
+    "",
+    "Requirements:",
+    "- Write the ACTUAL results — what you found, what you changed, concrete",
+    "  conclusions, and any risks or follow-ups — never a promise to do the",
+    "  work later.",
+    "- Make it self-contained: the coordinator reads only this file, not your",
+    "  session transcript.",
+    "- If you could not complete the task, write what you attempted and why it",
+    "  is blocked, so the coordinator can report the truth.",
+    "- If the report file already exists from a previous pass, read it first and",
+    "  continue from where it left off rather than starting over.",
+    "",
+    "Completion status (REQUIRED — this is how the coordinator knows to stop):",
+    "On its own line in the report, declare your status EXACTLY as one of:",
+    `${REPORT_STATUS_MARKER}: done`,
+    "  The task is fully complete; no further passes are needed.",
+    `${REPORT_STATUS_MARKER}: continue`,
+    "  You have more work to do and will be run again.",
+    "The marker line must contain nothing else.",
+    "If you omit this line or write anything else, the coordinator treats the",
+    "task as NOT complete and runs you again, up to the configured retry bound."
+  ].join(`
+`);
+}
+function composeSubsessionPrompt(input) {
+  const reportPath = roleReportPath(input.batchID, input.roleID);
+  const handoff = input.handoff ? [
+    "",
+    "## Model handoff",
+    "",
+    "Continue the SAME node and original goal. Read the existing report first,",
+    "preserve useful prior findings, and complete the remaining work instead of",
+    "starting a new batch or replacing the objective."
+  ].join(`
+`) : "";
+  return {
+    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, input.structuredReport !== false)}`,
+    reportPath
+  };
+}
+
 // src/orchestrator/reportArtifactProbe.ts
 import { stat as stat2 } from "node:fs/promises";
 var reportArtifactExists = async (reportPath) => {
@@ -11169,15 +11441,76 @@ var readReportArtifact = async (reportPath) => {
   }
 };
 
-// src/orchestrator/roster.ts
+// src/orchestrator/reportDelivery.ts
 import { z as z20 } from "zod";
-var RosterEntrySchema = z20.object({
-  roleID: z20.string().min(1),
-  agentName: z20.string().min(1)
+var Submission = z20.object({
+  status: z20.enum(["done", "continue"]),
+  findings: z20.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/roster.ts
+import { z as z21 } from "zod";
+var RosterEntrySchema = z21.object({
+  roleID: z21.string().min(1),
+  agentName: z21.string().min(1)
 }).strict();
-var RosterSchema = z20.object({
-  universe: z20.string().min(1),
-  entries: z20.array(RosterEntrySchema)
+var RosterSchema = z21.object({
+  universe: z21.string().min(1),
+  entries: z21.array(RosterEntrySchema)
 }).strict();
 var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
 
@@ -11585,15 +11918,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((resolve5) => {
-    timeoutID = setTimeout(() => {
-      resolve5({ kind: "timeout" });
-    }, timeoutMs);
+    if (timeoutMs !== undefined)
+      timeoutID = setTimeout(() => {
+        resolve5({ kind: "timeout" });
+      }, timeoutMs);
+    abortListener = () => resolve5({ kind: "aborted" });
+    signal?.addEventListener("abort", abortListener, { once: true });
+    if (signal?.aborted)
+      abortListener();
   });
   try {
     return await Promise.race([
@@ -11602,6 +11941,8 @@ async function withTimeout(promise, timeoutMs) {
     ]);
   } finally {
     clearTimeout(timeoutID);
+    if (abortListener !== undefined)
+      signal?.removeEventListener("abort", abortListener);
   }
 }
 async function beforeDeadline(request, deadline, deps) {
@@ -11723,7 +12064,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 {
@@ -11750,19 +12119,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) => {
@@ -11770,8 +12152,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);
@@ -11782,8 +12165,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;
@@ -11816,12 +12199,137 @@ 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
     };
   }
 }
 
+// src/orchestrator/taskEffort.ts
+import { z as z22 } from "zod";
+var Binding = z22.object({
+  taskID: z22.string().regex(/^[a-f0-9]{64}$/),
+  depth: z22.number().int().min(0).max(128),
+  worker: z22.boolean()
+}).strict();
+var Record = z22.object({
+  v: z22.literal(1),
+  startedAt: z22.number().finite(),
+  batches: z22.number().int().min(0),
+  attempts: z22.number().int().min(0),
+  maxBatches: z22.number().int().positive(),
+  maxAttempts: z22.number().int().positive(),
+  maxDurationMs: z22.number().int().positive(),
+  maxDepth: z22.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 record = decode(Record, raw);
+      const remainingMs = Math.min(record.maxDurationMs, limits.maxDurationMs) - Math.max(0, deps.now() - record.startedAt);
+      const reason = ref.depth > Math.min(record.maxDepth, limits.maxDepth) ? "depth" : remainingMs <= 0 ? "duration" : kind === "batches" && record.batches >= Math.min(record.maxBatches, limits.maxBatches) ? "batches" : kind === "attempts" && record.attempts >= Math.min(record.maxAttempts, limits.maxAttempts) ? "attempts" : undefined;
+      if (reason !== undefined)
+        result = { ok: false, reason };
+      else {
+        if (kind !== "check")
+          record[kind] += 1;
+        result = {
+          ok: true,
+          remainingMs,
+          batches: record.batches,
+          attempts: record.attempts,
+          remainingBatches: Math.max(0, Math.min(record.maxBatches, limits.maxBatches) - record.batches),
+          remainingAttempts: Math.max(0, Math.min(record.maxAttempts, limits.maxAttempts) - record.attempts)
+        };
+      }
+      return JSON.stringify(record);
+    });
+    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/local/modelResidency.ts
 function runtimeRequiresModelResidency(kind) {
   return kind === "lemonade" || kind === "llama-swap";
@@ -12075,7 +12583,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") {
@@ -12089,6 +12597,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",
@@ -12096,7 +12615,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),
@@ -12107,6 +12630,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;
   }
@@ -12235,7 +12770,7 @@ function planWorktreeReconciliation(input) {
 }
 
 // src/telemetry/otelConfig.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 
 // src/telemetry/fanout.ts
 function createFanOutSink(deps) {
@@ -12313,10 +12848,10 @@ function createOtelSink(deps) {
 }
 
 // src/telemetry/otelConfig.ts
-var OtelBackendConfigSchema = z21.object({
-  backend: z21.literal("opentelemetry"),
-  connectionEnv: z21.string().min(1),
-  serviceName: z21.string().min(1).optional()
+var OtelBackendConfigSchema = z23.object({
+  backend: z23.literal("opentelemetry"),
+  connectionEnv: z23.string().min(1),
+  serviceName: z23.string().min(1).optional()
 }).strict();
 function parseConnectionString(raw) {
   const pairs = new Map;
@@ -15713,29 +16248,29 @@ import {
   unlink
 } from "node:fs/promises";
 import { dirname as dirname5, join as join12, resolve as resolve7 } from "node:path";
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 var CONSOLE_RUNTIME_SCHEMA_VERSION = 1;
 var CONSOLE_RUNTIME_DIRECTORY = ".opencode/openteam-local/console";
 var CONSOLE_RUNTIME_FILE = "runtime.json";
 var CONSOLE_LAUNCH_LOCK_FILE = "launch.lock";
 var CONSOLE_LOG_FILE = "console.log";
-var ConsoleRuntimeStateSchema = z22.object({
-  schemaVersion: z22.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
-  pid: z22.number().int().positive(),
-  workspaceRoot: z22.string().min(1),
-  host: z22.string().min(1),
-  port: z22.number().int().min(1).max(65535),
-  url: z22.url(),
-  startedAt: z22.iso.datetime({ offset: true }),
-  launchId: z22.uuid(),
-  logPath: z22.string().min(1)
+var ConsoleRuntimeStateSchema = z24.object({
+  schemaVersion: z24.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
+  pid: z24.number().int().positive(),
+  workspaceRoot: z24.string().min(1),
+  host: z24.string().min(1),
+  port: z24.number().int().min(1).max(65535),
+  url: z24.url(),
+  startedAt: z24.iso.datetime({ offset: true }),
+  launchId: z24.uuid(),
+  logPath: z24.string().min(1)
 }).strict();
-var ConsoleLaunchLockSchema = z22.object({
-  schemaVersion: z22.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
-  workspaceRoot: z22.string().min(1),
-  launchId: z22.uuid(),
-  ownerPid: z22.number().int().positive(),
-  createdAt: z22.iso.datetime({ offset: true })
+var ConsoleLaunchLockSchema = z24.object({
+  schemaVersion: z24.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
+  workspaceRoot: z24.string().min(1),
+  launchId: z24.uuid(),
+  ownerPid: z24.number().int().positive(),
+  createdAt: z24.iso.datetime({ offset: true })
 }).strict();
 
 class ConsoleRuntimeStateFileError extends Error {
@@ -16440,36 +16975,36 @@ function formatResponse(response) {
 }
 
 // src/plugin/reportRunSchema.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 
 // src/plugin/graphShadowIngress.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 var LEGACY_EXECUTION_TRACE_VERSION = 1;
-var LegacyExecutionStatusSchema = z23.enum([
+var LegacyExecutionStatusSchema = z25.enum([
   "completed",
   "failed",
   "cancelled"
 ]);
-var LegacyReviewOutcomeSchema = z23.enum([
+var LegacyReviewOutcomeSchema = z25.enum([
   "approved",
   "rejected",
   "inconclusive"
 ]);
-var LegacyTraceNodeV1Schema = z23.object({
+var LegacyTraceNodeV1Schema = z25.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z23.string().min(1),
-  sessionRef: z23.string().min(1).optional(),
+  model: z25.string().min(1),
+  sessionRef: z25.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var LegacyExecutionTraceV1Schema = z23.object({
-  version: z23.literal(LEGACY_EXECUTION_TRACE_VERSION),
+var LegacyExecutionTraceV1Schema = z25.object({
+  version: z25.literal(LEGACY_EXECUTION_TRACE_VERSION),
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
   outcome: LegacyReviewOutcomeSchema,
-  fixes: z23.number().int().nonnegative(),
-  nodes: z23.array(LegacyTraceNodeV1Schema).min(1),
-  parentSessionRef: z23.string().min(1).optional()
+  fixes: z25.number().int().nonnegative(),
+  nodes: z25.array(LegacyTraceNodeV1Schema).min(1),
+  parentSessionRef: z25.string().min(1).optional()
 }).strict();
 function gateReason2(gate) {
   if (gate === undefined || gate.mode === "off") {
@@ -16540,20 +17075,20 @@ function parseLegacyExecutionTrace(input) {
 }
 
 // src/plugin/reportRunSchema.ts
-var ReportRunNodeSchema = z24.object({
+var ReportRunNodeSchema = z26.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z24.string().min(1),
-  ok: z24.boolean(),
-  sessionRef: z24.string().min(1).optional(),
+  model: z26.string().min(1),
+  ok: z26.boolean(),
+  sessionRef: z26.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var ReportRunPayloadSchema = z24.object({
+var ReportRunPayloadSchema = z26.object({
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
-  fixes: z24.number().int().nonnegative(),
-  nodes: z24.array(ReportRunNodeSchema).min(1),
-  parentSessionRef: z24.string().min(1).optional()
+  fixes: z26.number().int().nonnegative(),
+  nodes: z26.array(ReportRunNodeSchema).min(1),
+  parentSessionRef: z26.string().min(1).optional()
 }).strict();
 
 // src/orchestrator/graphShadow.ts
@@ -17658,7 +18193,7 @@ function hashPrompt(prompt) {
 }
 
 // src/plugin/modelResidency.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 
 // src/local/lemonadeRequestGuard.ts
 var inferencePaths = new Set([
@@ -18029,7 +18564,7 @@ function createModelResidencyGuard(config, options) {
         throw failure("identity", model.providerID);
       fetch = installed.fetch;
     }
-    const configuredHeaders = z25.record(z25.string(), z25.string()).safeParse(provider?.options?.headers ?? {});
+    const configuredHeaders = z27.record(z27.string(), z27.string()).safeParse(provider?.options?.headers ?? {});
     if (!configuredHeaders.success)
       throw failure("configuration", model.providerID);
     const headers = new Headers(configuredHeaders.data);
@@ -18257,62 +18792,62 @@ ${lines.join(`
 }
 
 // src/memory/types.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z26.string().min(1);
-var MemoryKindSchema = z26.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z26.object({
-  id: z26.string().min(1),
+var OwnerKeySchema = z28.string().min(1);
+var MemoryKindSchema = z28.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z28.object({
+  id: z28.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z26.number().min(0).max(1),
-  validFrom: z26.number().finite(),
-  validUntil: z26.number().finite().nullable().default(null),
-  createdAt: z26.number().finite(),
-  invalidatedAt: z26.number().finite().nullable().default(null),
-  sourceHash: z26.string().min(1),
-  supersededBy: z26.string().min(1).nullable().default(null)
+  confidence: z28.number().min(0).max(1),
+  validFrom: z28.number().finite(),
+  validUntil: z28.number().finite().nullable().default(null),
+  createdAt: z28.number().finite(),
+  invalidatedAt: z28.number().finite().nullable().default(null),
+  sourceHash: z28.string().min(1),
+  supersededBy: z28.string().min(1).nullable().default(null)
 }).strict();
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z26.literal("fact"),
-  subject: z26.string().min(1),
-  predicate: z26.string().min(1),
-  object: z26.string().min(1),
-  category: z26.string().min(1).nullable().default(null)
+  kind: z28.literal("fact"),
+  subject: z28.string().min(1),
+  predicate: z28.string().min(1),
+  object: z28.string().min(1),
+  category: z28.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z26.literal("preference"),
-  category: z26.string().min(1),
-  preference: z26.string().min(1),
-  context: z26.string().min(1).nullable().default(null),
-  lastAccessedAt: z26.number().finite().nullable().default(null),
-  accessCount: z26.number().int().min(0).default(0)
+  kind: z28.literal("preference"),
+  category: z28.string().min(1),
+  preference: z28.string().min(1),
+  context: z28.string().min(1).nullable().default(null),
+  lastAccessedAt: z28.number().finite().nullable().default(null),
+  accessCount: z28.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z26.literal("entity"),
-  canonicalName: z26.string().min(1),
-  type: z26.string().min(1),
-  aliases: z26.array(z26.string().min(1)).default([])
+  kind: z28.literal("entity"),
+  canonicalName: z28.string().min(1),
+  type: z28.string().min(1),
+  aliases: z28.array(z28.string().min(1)).default([])
 });
 var RelationSchema = MemoryBaseSchema.extend({
-  kind: z26.literal("relation"),
-  from: z26.string().min(1),
-  to: z26.string().min(1),
-  predicate: z26.string().min(1),
-  annotation: z26.string().min(1).nullable().default(null)
+  kind: z28.literal("relation"),
+  from: z28.string().min(1),
+  to: z28.string().min(1),
+  predicate: z28.string().min(1),
+  annotation: z28.string().min(1).nullable().default(null)
 });
-var MemoryRecordSchema = z26.discriminatedUnion("kind", [
+var MemoryRecordSchema = z28.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema,
   RelationSchema
 ]);
-var RecallQuerySchema = z26.object({
+var RecallQuerySchema = z28.object({
   ownerKey: OwnerKeySchema,
-  kinds: z26.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z26.number().finite().nullable().default(null),
-  limit: z26.number().int().positive().default(8),
-  minSimilarity: z26.number().min(0).max(1).default(0.2),
-  includeShared: z26.boolean().default(true)
+  kinds: z28.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z28.number().finite().nullable().default(null),
+  limit: z28.number().int().positive().default(8),
+  minSimilarity: z28.number().min(0).max(1).default(0.2),
+  includeShared: z28.boolean().default(true)
 }).strict();
 
 // src/memory/rank.ts
@@ -18883,42 +19418,42 @@ function buildMemoryInjector(deps, policy) {
 
 // src/plugin/memoryTool.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 
 // src/memory/extract.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 var REDACTED = "[redacted]";
-var RawFactSchema = z27.object({
-  subject: z27.string().min(1),
-  predicate: z27.string().min(1),
-  object: z27.string().min(1),
-  category: z27.string().min(1).nullable().optional(),
-  confidence: z27.number().min(0).max(1).optional()
+var RawFactSchema = z29.object({
+  subject: z29.string().min(1),
+  predicate: z29.string().min(1),
+  object: z29.string().min(1),
+  category: z29.string().min(1).nullable().optional(),
+  confidence: z29.number().min(0).max(1).optional()
 });
-var RawPreferenceSchema = z27.object({
-  category: z27.string().min(1),
-  preference: z27.string().min(1),
-  context: z27.string().min(1).nullable().optional(),
-  confidence: z27.number().min(0).max(1).optional()
+var RawPreferenceSchema = z29.object({
+  category: z29.string().min(1),
+  preference: z29.string().min(1),
+  context: z29.string().min(1).nullable().optional(),
+  confidence: z29.number().min(0).max(1).optional()
 });
-var RawEntitySchema = z27.object({
-  canonicalName: z27.string().min(1),
-  type: z27.string().min(1),
-  aliases: z27.array(z27.string().min(1)).optional(),
-  confidence: z27.number().min(0).max(1).optional()
+var RawEntitySchema = z29.object({
+  canonicalName: z29.string().min(1),
+  type: z29.string().min(1),
+  aliases: z29.array(z29.string().min(1)).optional(),
+  confidence: z29.number().min(0).max(1).optional()
 });
-var RawRelationSchema = z27.object({
-  from: z27.string().min(1),
-  to: z27.string().min(1),
-  predicate: z27.string().min(1),
-  annotation: z27.string().min(1).nullable().optional(),
-  confidence: z27.number().min(0).max(1).optional()
+var RawRelationSchema = z29.object({
+  from: z29.string().min(1),
+  to: z29.string().min(1),
+  predicate: z29.string().min(1),
+  annotation: z29.string().min(1).nullable().optional(),
+  confidence: z29.number().min(0).max(1).optional()
 }).strict();
-var RawExtractionSchema = z27.object({
-  facts: z27.array(RawFactSchema).default([]),
-  preferences: z27.array(RawPreferenceSchema).default([]),
-  entities: z27.array(RawEntitySchema).default([]),
-  relations: z27.array(RawRelationSchema).default([])
+var RawExtractionSchema = z29.object({
+  facts: z29.array(RawFactSchema).default([]),
+  preferences: z29.array(RawPreferenceSchema).default([]),
+  entities: z29.array(RawEntitySchema).default([]),
+  relations: z29.array(RawRelationSchema).default([])
 });
 var DEFAULT_CONFIDENCE = 0.6;
 var SYSTEM_PROMPT = [
@@ -19172,13 +19707,13 @@ var memoryToolMessages = {
 
 // src/plugin/memoryTool.ts
 var SCRIBE_ROLE_ID = "scribe";
-var MemoryMessageSchema = z28.object({
-  role: z28.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
-  content: z28.string().min(1).describe(memoryToolMessages.messageContentDescription)
+var MemoryMessageSchema = z30.object({
+  role: z30.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
+  content: z30.string().min(1).describe(memoryToolMessages.messageContentDescription)
 }).strict();
-var MemoryWritePayloadSchema = z28.object({
-  messages: z28.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
-  roleID: z28.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
+var MemoryWritePayloadSchema = z30.object({
+  messages: z30.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
+  roleID: z30.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
 }).strict();
 function createMemoryTool(deps) {
   return tool4({
@@ -19362,7 +19897,7 @@ import { Session as Session2 } from "@opencode/schema/session";
 import { Tool } from "@opencode/schema/tool";
 import { tool as legacyTool } from "@opencode-ai/plugin/tool";
 import { Clock, Effect, Option, Stream } from "effect";
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 
 // src/plugin/nativeHostContext.ts
 import {
@@ -19424,7 +19959,7 @@ function nativeConfiguredInventory(models, config) {
 
 // src/plugin/nativeResidency.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { z as z29 } from "zod";
+import { z as z31 } 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;
@@ -19502,7 +20037,7 @@ function createNativeModelResidencyGuard(config, options) {
     });
   }
   function target(model, send, baseURL) {
-    const headers = new Headers(z29.record(z29.string(), z29.string()).parse(model.headers ?? {}));
+    const headers = new Headers(z31.record(z31.string(), z31.string()).parse(model.headers ?? {}));
     if (typeof model.settings?.apiKey === "string" && !headers.has("authorization"))
       headers.set("authorization", `Bearer ${model.settings.apiKey}`);
     return {
@@ -19540,7 +20075,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 z29.ZodError))
+        if (!(error instanceof ModelResidencyError) && !(error instanceof z31.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 };
@@ -19697,6 +20232,10 @@ function nativeAssistantResponse(sessionID, message) {
       ...message.cost === undefined ? {} : { cost: message.cost },
       ...message.tokens === undefined ? {} : { tokens: message.tokens },
       ...message.error === undefined ? {} : { error: message.error },
+      ...message.finish === undefined ? {} : { finish: message.finish },
+      ...message.rawFinish === undefined ? {} : { rawFinish: message.rawFinish },
+      hasGeneratedOutput: message.content.some((part) => part.type === "tool" || part.text.length > 0),
+      truncatedToolCall: message.finish === "length" && message.content.some((part) => part.type === "tool" && part.executed === false && part.state.status === "error" && part.state.error.type === "tool.input-json"),
       time: {
         created: DateTime.toEpochMillis(message.time.created),
         ...message.time.completed === undefined ? {} : { completed: DateTime.toEpochMillis(message.time.completed) }
@@ -19723,7 +20262,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)
@@ -19733,7 +20273,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)
@@ -19772,6 +20312,11 @@ function createNativeSessionClient(deps) {
         const assistant = [...messages].reverse().find((message) => message.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)
@@ -19811,8 +20356,8 @@ function createNativeSessionClient(deps) {
 }
 
 // src/plugin/nativeHost.ts
-var executionEvent = z30.preprocess(only(["type", "location", "data"]), z30.object({
-  type: z30.enum([
+var executionEvent = z32.preprocess(only(["type", "location", "data"]), z32.object({
+  type: z32.enum([
     "session.created",
     "session.deleted",
     "session.execution.started",
@@ -19820,15 +20365,30 @@ var executionEvent = z30.preprocess(only(["type", "location", "data"]), z30.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: z30.preprocess(only(["directory", "workspaceID"]), z30.object({
-    directory: z30.string(),
-    workspaceID: z30.string().optional()
+  location: z32.preprocess(only(["directory", "workspaceID"]), z32.object({
+    directory: z32.string(),
+    workspaceID: z32.string().optional()
   }).strict()).optional(),
-  data: z30.preprocess(only(["sessionID", "assistantMessageID"]), z30.object({
-    sessionID: z30.string(),
-    assistantMessageID: z30.string().optional()
+  data: z32.preprocess(only([
+    "sessionID",
+    "assistantMessageID",
+    "id",
+    "name",
+    "executed",
+    "error"
+  ]), z32.object({
+    sessionID: z32.string(),
+    assistantMessageID: z32.string().optional(),
+    id: z32.string().optional(),
+    name: z32.string().optional(),
+    executed: z32.boolean().optional(),
+    error: z32.preprocess(only(["type"]), z32.object({ type: z32.string() }).strict()).optional()
   }).strict())
 }).strict());
 var nativeBindings = Effect.fn("openteam.nativeBindings")(function* () {
@@ -19883,6 +20443,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 };
@@ -19937,6 +20506,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) => {
@@ -19981,6 +20556,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);
@@ -20113,7 +20689,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,
@@ -20140,9 +20719,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 message = messages.find((candidate) => candidate.id === value.data.assistantMessageID);
+          if (message?.type === "assistant") {
+            const part = message.content.find((candidate) => candidate.type === "tool" && candidate.id === value.data.id);
+            if (part?.type === "tool")
+              name = part.name;
+          }
+        }
+        const ok = value.type === "session.tool.success";
+        const inputFailure = value.data.error?.type === "tool.input-json" || value.data.error?.type === "tool.input-schema";
+        const executionReached = ok || value.data.error?.type === "tool.execution";
+        mapped = {
+          type: "openteam.tool.completed",
+          properties: {
+            sessionID,
+            callID: value.data.id,
+            tool: name ?? "unknown",
+            ok,
+            ...inputFailure ? { executed: false } : executionReached ? { executed: true } : {},
+            ...value.data.executed === undefined ? {} : { providerExecuted: value.data.executed },
+            ...!ok ? {
+              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 } }
@@ -20183,11 +20815,12 @@ function createNativePluginEffect(factory) {
 }
 
 // src/plugin/orchestrateTool.ts
+import { resolve as resolve11 } from "node:path";
 import { tool as tool5 } from "@opencode-ai/plugin";
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 
 // src/orchestrator/coordinator.ts
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 
 // src/orchestrator/nodeIteration.ts
 var DEFAULT_MAX_RETRIES = 2;
@@ -20195,153 +20828,6 @@ function nodePassBudget(maxRetries) {
   return 1 + (maxRetries ?? DEFAULT_MAX_RETRIES);
 }
 
-// src/orchestrator/outputContract.ts
-import { createHash as createHash3 } from "node:crypto";
-var ROLE_REPORTS_ROOT = ".opencode/openteam-local/reports";
-var REPORT_STATUS_MARKER = "openteam-status";
-var REPORT_STATUS_LINE_PATTERN = /^[ ]{0,3}openteam-status:[ \t]*(.*?)[ \t]*$/i;
-var FENCE_DELIMITER_PATTERN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-function fenceDelimiter(line) {
-  const match = FENCE_DELIMITER_PATTERN.exec(line);
-  const run = match?.[1];
-  if (run === undefined)
-    return;
-  const marker = run.startsWith("`") ? "`" : "~";
-  return {
-    marker,
-    length: run.length,
-    remainder: match?.[2] ?? ""
-  };
-}
-function declaredStatus(value) {
-  const normalized = value.toLowerCase();
-  if (normalized === "done")
-    return "done";
-  if (normalized === "continue")
-    return "continue";
-  return "unknown";
-}
-function analyzeReport(text) {
-  let status = "unknown";
-  let fence;
-  const bodyLines = [];
-  for (const line of text.split(/\r?\n/)) {
-    const delimiter = fenceDelimiter(line);
-    if (fence !== undefined) {
-      bodyLines.push(line);
-      if (delimiter?.marker === fence.marker && delimiter.length >= fence.length && delimiter.remainder.trim().length === 0) {
-        fence = undefined;
-      }
-      continue;
-    }
-    if (delimiter !== undefined) {
-      fence = delimiter;
-      bodyLines.push(line);
-      continue;
-    }
-    const declaration = REPORT_STATUS_LINE_PATTERN.exec(line);
-    if (declaration !== null) {
-      status = declaredStatus(declaration[1] ?? "");
-      continue;
-    }
-    bodyLines.push(line);
-  }
-  return {
-    status,
-    body: bodyLines.join(`
-`).trim()
-  };
-}
-function parseReportStatus(text) {
-  if (text === undefined || text.length === 0)
-    return "unknown";
-  return analyzeReport(text).status;
-}
-var MIN_REPORT_BODY_CHARS = 40;
-var MAX_REPORT_SEGMENT_CHARS = 64;
-var REPORT_SEGMENT_HASH_CHARS = 24;
-var SAFE_REPORT_SEGMENT = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,62}[A-Za-z0-9_-])?$/;
-var WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
-function reportSegmentHash(value) {
-  return createHash3("sha256").update(value, "utf8").digest("hex").slice(0, REPORT_SEGMENT_HASH_CHARS);
-}
-function reportPathSegment(value) {
-  if (value.length <= MAX_REPORT_SEGMENT_CHARS && SAFE_REPORT_SEGMENT.test(value) && value === value.toLowerCase() && !WINDOWS_DEVICE_NAME.test(value)) {
-    return value;
-  }
-  const suffix = `~${reportSegmentHash(value)}`;
-  const maxPrefixChars = MAX_REPORT_SEGMENT_CHARS - suffix.length;
-  let prefix = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, maxPrefixChars).replace(/[.]+$/, "");
-  if (prefix.length === 0) {
-    prefix = "segment";
-  }
-  if (WINDOWS_DEVICE_NAME.test(prefix)) {
-    prefix = `safe-${prefix}`.slice(0, maxPrefixChars).replace(/[.]+$/, "");
-  }
-  return `${prefix}${suffix}`;
-}
-function reportHasSubstance(text) {
-  if (text === undefined)
-    return false;
-  return analyzeReport(text).body.length >= MIN_REPORT_BODY_CHARS;
-}
-function roleReportPath(batchID, roleID) {
-  return `${ROLE_REPORTS_ROOT}/${reportPathSegment(batchID)}/${reportPathSegment(roleID)}.md`;
-}
-function outputContractInstruction(reportPath) {
-  return [
-    "## Output contract (openteam)",
-    "",
-    "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,",
-    "and the coordinator will have no record of it.",
-    "",
-    `Report file: ${reportPath}`,
-    "",
-    "Requirements:",
-    "- Write the ACTUAL results — what you found, what you changed, concrete",
-    "  conclusions, and any risks or follow-ups — never a promise to do the",
-    "  work later.",
-    "- Make it self-contained: the coordinator reads only this file, not your",
-    "  session transcript.",
-    "- If you could not complete the task, write what you attempted and why it",
-    "  is blocked, so the coordinator can report the truth.",
-    "- If the report file already exists from a previous pass, read it first and",
-    "  continue from where it left off rather than starting over.",
-    "",
-    "Completion status (REQUIRED — this is how the coordinator knows to stop):",
-    "On its own line in the report, declare your status EXACTLY as one of:",
-    `${REPORT_STATUS_MARKER}: done`,
-    "  The task is fully complete; no further passes are needed.",
-    `${REPORT_STATUS_MARKER}: continue`,
-    "  You have more work to do and will be run again.",
-    "The marker line must contain nothing else.",
-    "If you omit this line or write anything else, the coordinator treats the",
-    "task as NOT complete and runs you again, up to the configured retry bound."
-  ].join(`
-`);
-}
-function composeSubsessionPrompt(input) {
-  const reportPath = roleReportPath(input.batchID, input.roleID);
-  const handoff = input.handoff ? [
-    "",
-    "## Model handoff",
-    "",
-    "Continue the SAME node and original goal. Read the existing report first,",
-    "preserve useful prior findings, and complete the remaining work instead of",
-    "starting a new batch or replacing the objective."
-  ].join(`
-`) : "";
-  return {
-    prompt: `${input.prompt}${handoff}
-
-${outputContractInstruction(reportPath)}`,
-    reportPath
-  };
-}
-
 // src/orchestrator/permissions.ts
 var ROLE_PERMISSIONS = {
   architect: [
@@ -20661,7 +21147,7 @@ function buildRecord(input, decision2, subsession, deps, decisionID, batchID) {
   }
   return record;
 }
-var TelemetryFailureClassSchema = z31.enum([
+var TelemetryFailureClassSchema = z33.enum([
   "create-rejected",
   "create-no-id",
   "prompt-rejected",
@@ -20670,12 +21156,15 @@ var TelemetryFailureClassSchema = z31.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",
@@ -20778,6 +21267,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";
   }
@@ -20846,6 +21337,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 {
@@ -20915,7 +21408,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));
@@ -20926,13 +21419,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;
   }
@@ -20950,11 +21448,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, {
@@ -20999,27 +21503,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 = configuredRuntime2(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 = configuredRuntime2(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",
@@ -21047,8 +21590,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?.();
   }
 }
@@ -21160,15 +21712,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) {
@@ -21179,6 +21735,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 ?? "";
@@ -21278,6 +21836,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:
@@ -21350,14 +21909,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);
@@ -21443,13 +22007,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) {
@@ -21478,7 +22057,7 @@ async function runRoleTasks(inputs, deps, options = {}) {
 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 = z32.string().min(1).superRefine((roleID, ctx) => {
+var RoleIDSchema = z34.string().min(1).superRefine((roleID, ctx) => {
   if (!SAFE_ROLE_ID.test(roleID)) {
     ctx.addIssue({
       code: "custom",
@@ -21486,16 +22065,16 @@ var RoleIDSchema = z32.string().min(1).superRefine((roleID, ctx) => {
     });
   }
 });
-var RoleAssignmentSchema = z32.object({
+var RoleAssignmentSchema = z34.object({
   roleID: RoleIDSchema.describe("Role identifier from the roster"),
-  prompt: z32.string().min(1).describe("Work prompt for this role"),
-  title: z32.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z32.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
+  prompt: z34.string().min(1).describe("Work prompt for this role"),
+  title: z34.string().min(1).optional().describe("Human-readable title"),
+  dependsOn: z34.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
 }).strict();
-var OrchestratePayloadSchema = z32.object({
-  assignments: z32.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z32.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
-  directory: z32.string().min(1).optional().describe("Working directory override")
+var OrchestratePayloadSchema = z34.object({
+  assignments: z34.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
+  parentSessionID: z34.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
+  directory: z34.string().min(1).optional().describe("Working directory override")
 }).strict();
 function validateAssignmentDependencies(assignments) {
   const ids = new Set;
@@ -21680,8 +22259,15 @@ function adaptSdkClient(sdk, orchestratedModelOwnership) {
           if (result.error !== undefined) {
             out.error = normalizeSdkSessionFailure(result.error, "prompt");
           } else {
+            const info = isRecord7(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;
@@ -21841,7 +22427,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":
@@ -22124,8 +22713,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 = resolve11(deps.workspaceDirectory);
+        if (resolve11(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);
@@ -22148,6 +22745,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");
@@ -22157,7 +22762,7 @@ function createOrchestrateTool(deps) {
             executionAuthority: "coordinator",
             root: {
               operationID: rootOperationID,
-              taskID: batchID,
+              taskID: taskRef?.taskID ?? batchID,
               kind: "coordinator",
               roleID: "openteam",
               agentID: context.agent,
@@ -22182,6 +22787,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,
@@ -22199,10 +22810,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}`;
@@ -22233,7 +22849,7 @@ ${advisory}`;
 
 // src/plugin/registerCastTool.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 
 // src/messages/rosterSummary.ts
 var ROSTER_SUMMARY_HEADING = "Registered team model policies";
@@ -22349,12 +22965,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 resolve11 = (raw) => {
+      const resolve12 = (raw) => {
         const config = validateConfigInput(TEAM_PREPARATION_CONFIG, mergeConfigInputs(mergeConfigInputs(raw, options), overlay));
         assertEffectiveConfigModelDomains(config);
         return config;
       };
-      const current = resolve11(baseRaw);
+      const current = resolve12(baseRaw);
       const live = liveConfig ?? current;
       if (resolveExecutionMode({
         routerMode: current.router.executionMode,
@@ -22376,7 +22992,7 @@ function createTeamPreparation(deps) {
           ]))
         }
       });
-      const effective = resolve11(candidate);
+      const effective = resolve12(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;
@@ -22462,13 +23078,13 @@ async function persistPreparedTeam(storage, files) {
 }
 
 // src/plugin/registerCastTool.ts
-var CastEntrySchema = z33.object({
-  roleID: z33.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
-  agentName: z33.string().min(1).describe("Themed character name assigned to the role")
+var CastEntrySchema = z35.object({
+  roleID: z35.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
+  agentName: z35.string().min(1).describe("Themed character name assigned to the role")
 }).strict();
-var RegisterCastPayloadSchema = z33.object({
-  universe: z33.string().min(1).describe("Casting universe for this roster"),
-  entries: z33.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
+var RegisterCastPayloadSchema = z35.object({
+  universe: z35.string().min(1).describe("Casting universe for this roster"),
+  entries: z35.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
 }).strict();
 function offendingFields(error) {
   const fields = error.issues.flatMap((issue) => {
@@ -22588,7 +23204,7 @@ function createRegisterCastTool(deps) {
 }
 
 // src/plugin/reloadTool.ts
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 import { tool as tool7 } from "@opencode-ai/plugin/tool";
 var WAIT_MS = 30000;
 var SDK_TIMEOUT_MS = 5000;
@@ -22622,7 +23238,7 @@ function createReloadController(deps) {
       return () => clearTimeout(timer);
     }
   };
-  const directory = resolve11(deps.directory);
+  const directory = resolve12(deps.directory);
   let pending;
   let authorizing;
   let closed = false;
@@ -22770,7 +23386,7 @@ function createReloadController(deps) {
       const parsed = schema.safeParse(args);
       if (!parsed.success)
         return reloadMessages.invalid;
-      if (context.agent !== "openteam" || resolve11(context.directory) !== directory || context.sessionID.trim().length === 0)
+      if (context.agent !== "openteam" || resolve12(context.directory) !== directory || context.sessionID.trim().length === 0)
         return reloadMessages.denied;
       if (parsed.data.action === "cancel") {
         if ((pending?.sessionID ?? authorizing?.sessionID) !== context.sessionID)
@@ -22888,6 +23504,31 @@ function createReloadController(deps) {
   };
 }
 
+// src/plugin/reportTool.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+function createReportTool(delivery) {
+  return tool8({
+    description: reportDeliveryMessages.description,
+    args: {
+      status: tool8.schema.enum(["done", "continue"]).describe(reportDeliveryMessages.status),
+      findings: tool8.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;
@@ -22916,22 +23557,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",
@@ -22940,9 +23599,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);
+      }
     }
   };
 }
@@ -23147,22 +23820,22 @@ import {
   statSync,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join15, resolve as resolve13 } from "node:path";
+import { join as join15, resolve as resolve14 } from "node:path";
 import { ZodError } from "zod";
 
 // src/storage/lifecycle/codec.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 var LIFECYCLE_CODEC_VERSION = 1;
 var LIFECYCLE_GENESIS_DIGEST = sha256Hex("openteam/lifecycle-journal/genesis/v1");
 var NUL5 = "\x00";
 var NEWLINE2 = `
 `;
-var frameSchema = z34.object({
-  v: z34.literal(LIFECYCLE_CODEC_VERSION),
-  seq: z34.number().int().nonnegative(),
-  prev: z34.string().min(1),
-  sum: z34.string().min(1),
-  event: z34.unknown()
+var frameSchema = z36.object({
+  v: z36.literal(LIFECYCLE_CODEC_VERSION),
+  seq: z36.number().int().nonnegative(),
+  prev: z36.string().min(1),
+  sum: z36.string().min(1),
+  event: z36.unknown()
 }).strict();
 function canonical2(value) {
   if (Array.isArray(value)) {
@@ -23266,7 +23939,7 @@ import {
   unlinkSync,
   writeSync as writeSync2
 } from "node:fs";
-import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve12 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve13 } from "node:path";
 var SAFE_RUN_ID = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,126}[A-Za-z0-9])?$/u;
 
 class LifecycleFsError extends Error {
@@ -23290,7 +23963,7 @@ function validateRunID(runID) {
 }
 function resolvedLifecycleRoot(root) {
   try {
-    const absolute = resolve12(root);
+    const absolute = resolve13(root);
     mkdirSync2(absolute, { recursive: true });
     const rootStat = lstatSync2(absolute);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
@@ -23333,7 +24006,7 @@ function assertExistingSafeRun(root, runID) {
     throw new LifecycleFsError("unavailable");
   }
   const child = relative3(root, real);
-  if (child === "" || child.startsWith("..") || resolve12(root, child) !== real || dirname7(real) !== root) {
+  if (child === "" || child.startsWith("..") || resolve13(root, child) !== real || dirname7(real) !== root) {
     throw new LifecycleFsError("corrupt");
   }
   return real;
@@ -23573,7 +24246,7 @@ function canDeleteTerminalRun(runDir, runID, now) {
   return now >= lease.expiresAt;
 }
 var createFsLifecycleJournal = (options) => {
-  const configuredRoot = resolve13(options.root);
+  const configuredRoot = resolve14(options.root);
   const now = options.now ?? Date.now;
   const mutateRun = options.withMutationLock ?? withRunMutationLock;
   return {
@@ -23929,6 +24602,61 @@ var createFsLifecycleWriterLivenessProbe = (options) => ({
   }
 });
 
+// src/storage/scopedArtifacts.ts
+import { lstatSync as lstatSync4, mkdirSync as mkdirSync4, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname8, join as join17 } 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 = join17(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 = join17(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(dirname8(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) {
@@ -24073,7 +24801,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(dirname8(path4)) === NATIVE_CERTIFICATE_DIRECTORY ? `${NATIVE_CERTIFICATE_DIRECTORY}/` : "";
+    const hostDirectory = basename4(dirname9(path4)) === NATIVE_CERTIFICATE_DIRECTORY ? `${NATIVE_CERTIFICATE_DIRECTORY}/` : "";
     return await readFile5(new URL(`./certificates/${hostDirectory}${basename4(path4)}`, import.meta.url), "utf8");
   } catch {
     return;
@@ -24206,8 +24934,8 @@ async function readOpencodeVersion(serverUrl, options = {}) {
 }
 var DEFAULT_OPENCODE_VERSION_BACKOFF_MS = [50, 250];
 function defaultSleep(ms) {
-  return new Promise((resolve14) => {
-    setTimeout(resolve14, ms);
+  return new Promise((resolve16) => {
+    setTimeout(resolve16, ms);
   });
 }
 function createLazyOpencodeVersionReader(serverUrl, options = {}) {
@@ -24250,7 +24978,7 @@ function createLazyOpencodeVersionReader(serverUrl, options = {}) {
   };
 }
 async function buildGateInput(config, storage, opencodeVersion, warn, packagedRead = readPackagedCertificate) {
-  const hostPath = (path4) => isSupportedNativeOpencodeVersion(opencodeVersion) ? `${dirname8(path4)}/${NATIVE_CERTIFICATE_DIRECTORY}/${basename4(path4)}` : path4;
+  const hostPath = (path4) => isSupportedNativeOpencodeVersion(opencodeVersion) ? `${dirname9(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);
@@ -24459,7 +25187,7 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
     telemetryPath,
     opencodeConfigPaths: OPENCODE_CONFIG_CANDIDATES,
     orchestratorAgentPath: ORCHESTRATOR_AGENT_PATH,
-    agentDir: dirname8(ORCHESTRATOR_AGENT_PATH),
+    agentDir: dirname9(ORCHESTRATOR_AGENT_PATH),
     cachePort: realCacheAdapter,
     purge: createPluginPurgeRuntime(sessionsDir),
     loadRosterForDoctor: () => readStoredRosterForDoctor(storage),
@@ -24610,6 +25338,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)) {
@@ -24730,6 +25476,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,
@@ -24750,11 +25508,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: (ms) => new Promise((resolve14) => {
-      setTimeout(resolve14, ms);
+    delay: (ms) => new Promise((resolve16) => {
+      setTimeout(resolve16, ms);
     }),
     warn: diagnostics.warn("unknown-role")
   });
@@ -24820,7 +25582,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 () => {
@@ -24834,18 +25598,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();
       }
@@ -24862,6 +25652,7 @@ async function createPluginRuntime(ctx, rawOptions) {
           announceEndpoint(message.sessionID);
           sessionTracker.trackSession(message.sessionID);
           sink.emit(message);
+          await sessionPhase(message.sessionID, "unknown");
         }
       }
     }
@@ -24871,6 +25662,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 (resolve15(response.data.directory) !== resolve15(ctx.directory))
+        throw new Error(nativeHostMessages.workspaceMismatch);
+      return response.data.parentID;
+    }
+  },
   exec: createShellExec(ctx.$),
   serverUrl: () => ctx.serverUrl,
   ...ctx.client.config?.providers === undefined ? {} : {