@jmanuelcorral/openteam 0.19.0 → 0.20.0

package/dist/index.js

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { readFile as readFile3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname4 } from "node:path";
+import { basename as basename3, dirname as dirname5 } from "node:path";
 
 // src/capabilities/curated.ts
 var CURATED_FRONTIER_PROFILES = [
@@ -799,6 +799,29 @@ var GraphModeSchema = z3.enum(["off", "shadow", "active"]);
 var GraphEngineSchema = z3.enum(["builtin", "langgraph"]);
 var DEFAULT_GRAPH_JOURNAL_ROOT = ".opencode/openteam-local/graph/runs";
 var DEFAULT_GRAPH_WORKTREES_DIR = ".opencode/openteam-local/graph/worktrees";
+var DEFAULT_LIFECYCLE_ROOT = ".opencode/openteam-local/lifecycle/runs";
+var DEFAULT_LIFECYCLE_MAX_TERMINAL_RUNS = 200;
+var DEFAULT_LIFECYCLE_MAX_AGE_DAYS = 30;
+var DEFAULT_LIFECYCLE_MAX_BYTES = 268435456;
+var LifecycleConfigSchema = z3.object({
+  root: z3.string().min(1).default(DEFAULT_LIFECYCLE_ROOT),
+  retention: z3.object({
+    maxTerminalRuns: z3.number().int().nonnegative().default(DEFAULT_LIFECYCLE_MAX_TERMINAL_RUNS),
+    maxAgeDays: z3.number().nonnegative().default(DEFAULT_LIFECYCLE_MAX_AGE_DAYS),
+    maxBytes: z3.number().int().nonnegative().default(DEFAULT_LIFECYCLE_MAX_BYTES)
+  }).strict().default({
+    maxTerminalRuns: DEFAULT_LIFECYCLE_MAX_TERMINAL_RUNS,
+    maxAgeDays: DEFAULT_LIFECYCLE_MAX_AGE_DAYS,
+    maxBytes: DEFAULT_LIFECYCLE_MAX_BYTES
+  })
+}).strict().default({
+  root: DEFAULT_LIFECYCLE_ROOT,
+  retention: {
+    maxTerminalRuns: DEFAULT_LIFECYCLE_MAX_TERMINAL_RUNS,
+    maxAgeDays: DEFAULT_LIFECYCLE_MAX_AGE_DAYS,
+    maxBytes: DEFAULT_LIFECYCLE_MAX_BYTES
+  }
+});
 var GraphConfigSchema = z3.object({
   mode: GraphModeSchema.default("active"),
   engine: GraphEngineSchema.optional(),
@@ -1102,6 +1125,7 @@ var OpenTeamConfigObjectSchema = z3.object({
   console: ConsoleConfigSchema,
   storage: StorageConfigSchema,
   memory: MemoryConfigSchema.optional(),
+  lifecycle: LifecycleConfigSchema,
   graph: GraphConfigSchema.default({
     mode: "active",
     killSwitch: false,
@@ -1571,6 +1595,32 @@ function runCancelled(runID, seq) {
   return { v: GRAPH_EVENT_VERSION, type: "run.cancelled", runID, seq };
 }
 
+// src/graph/ids.ts
+var NUL = "\x00";
+function operationID(runID, nodeID, revision = 0) {
+  return sha256Hex(`op${NUL}${runID}${NUL}${nodeID}${NUL}${revision}`).slice(0, 32);
+}
+function attemptID(operation, attempt) {
+  return sha256Hex(`att${NUL}${operation}${NUL}${attempt}`).slice(0, 32);
+}
+function canonicalSpec(spec) {
+  const nodes = spec.nodes.map((node) => ({
+    id: node.id,
+    role: node.role,
+    dependsOn: [...node.dependsOn],
+    anchor: { taskID: node.anchor.taskID, specDigest: node.anchor.specDigest },
+    ...node.reviews === undefined ? {} : { reviews: node.reviews }
+  }));
+  return JSON.stringify({
+    version: spec.version,
+    runID: spec.runID,
+    nodes
+  });
+}
+function graphSpecDigest(spec) {
+  return sha256Hex(canonicalSpec(spec));
+}
+
 // src/storage/graph/provider.ts
 class JournalError extends Error {
   code;
@@ -1714,7 +1764,7 @@ function createRunRegistry(root) {
 }
 
 // src/storage/graph/workspaceLease.ts
-var NUL = "\x00";
+var NUL2 = "\x00";
 var leaseRecordSchema = z8.object({
   runID: z8.string().min(1),
   holder: z8.string().min(1),
@@ -1734,7 +1784,7 @@ class LeaseError extends Error {
 }
 function createWorkspaceLease(root, registry = createRunRegistry(root)) {
   const leasePath = (runID) => join3(root, `lease-${runID}.json`);
-  const deriveToken = (runID, holder) => sha256Hex(`lease${NUL}${runID}${NUL}${holder}`).slice(0, 32);
+  const deriveToken = (runID, holder) => sha256Hex(`lease${NUL2}${runID}${NUL2}${holder}`).slice(0, 32);
   const parse2 = (text) => {
     let raw;
     try {
@@ -1815,32 +1865,6 @@ function planCancellation(state) {
 // src/orchestrator/graphReview.ts
 import { z as z9 } from "zod";
 
-// src/graph/ids.ts
-var NUL2 = "\x00";
-function operationID(runID, nodeID, revision = 0) {
-  return sha256Hex(`op${NUL2}${runID}${NUL2}${nodeID}${NUL2}${revision}`).slice(0, 32);
-}
-function attemptID(operation, attempt) {
-  return sha256Hex(`att${NUL2}${operation}${NUL2}${attempt}`).slice(0, 32);
-}
-function canonicalSpec(spec) {
-  const nodes = spec.nodes.map((node) => ({
-    id: node.id,
-    role: node.role,
-    dependsOn: [...node.dependsOn],
-    anchor: { taskID: node.anchor.taskID, specDigest: node.anchor.specDigest },
-    ...node.reviews === undefined ? {} : { reviews: node.reviews }
-  }));
-  return JSON.stringify({
-    version: spec.version,
-    runID: spec.runID,
-    nodes
-  });
-}
-function graphSpecDigest(spec) {
-  return sha256Hex(canonicalSpec(spec));
-}
-
 // src/graph/policies.ts
 var DEFAULT_RETRY_LIMIT = 3;
 var DEFAULT_REVISION_LIMIT = 2;
@@ -1932,6 +1956,18 @@ function plan(spec, state) {
 function specDigest(spec) {
   return sha256Hex(JSON.stringify(spec));
 }
+function graphFailure(errorClass, retryable) {
+  return {
+    class: errorClass === "cancelled" ? "cancelled" : "unknown",
+    retryable
+  };
+}
+function graphFailureOutcome(errorClass) {
+  if (errorClass === "cancelled") {
+    return "cancelled";
+  }
+  return errorClass === "unknown" ? "unknown" : "failed";
+}
 function findNode(spec, nodeID) {
   return spec.nodes.find((candidate) => candidate.id === nodeID);
 }
@@ -1953,21 +1989,126 @@ function nextRetry(loaded, limit) {
   const first = [...byNode.keys()].sort()[0];
   return first === undefined ? undefined : byNode.get(first);
 }
+function advanceAttemptExpectation(attempts, attemptID2, minimumPhase) {
+  const current = attempts.get(attemptID2);
+  if (current === undefined || current === "queued" && minimumPhase !== "queued" || current === "started" && minimumPhase === "terminal") {
+    attempts.set(attemptID2, minimumPhase);
+  }
+}
+function graphLifecycleExpectations(loaded, options = {}) {
+  const limit = options.retryLimit ?? DEFAULT_RETRY_LIMIT;
+  const cancelledNodeIDs = new Set(options.cancelledNodeIDs ?? []);
+  return loaded.spec.nodes.map((node, nodeIndex) => {
+    const state = loaded.state.nodes[node.id];
+    const authoritativeStatus = cancelledNodeIDs.has(node.id) ? "cancelled" : state?.status ?? "pending";
+    const operation = state?.operationID ?? operationID(loaded.spec.runID, node.id);
+    const attempts = new Map;
+    for (const event of loaded.events) {
+      if (event.type === "node.dispatched" && event.nodeID === node.id) {
+        advanceAttemptExpectation(attempts, event.attemptID, "started");
+      } else if ((event.type === "node.succeeded" || event.type === "node.failed") && event.nodeID === node.id) {
+        advanceAttemptExpectation(attempts, event.attemptID, "terminal");
+      }
+    }
+    if (cancelledNodeIDs.has(node.id) && state !== undefined && state.attempts > 0 && state.attemptID !== undefined) {
+      advanceAttemptExpectation(attempts, state.attemptID, "terminal");
+    }
+    const attemptExpectations = [
+      ...attempts
+    ].map(([attemptID2, minimumPhase]) => ({
+      attemptID: attemptID2,
+      minimumPhase
+    }));
+    if (state !== undefined && (attempts.size !== state.attempts || state.attemptID !== undefined && !attempts.has(state.attemptID))) {
+      attemptExpectations.push({
+        attemptID: null,
+        minimumPhase: authoritativeStatus === "succeeded" || authoritativeStatus === "failed" || authoritativeStatus === "cancelled" ? "terminal" : "started"
+      });
+    }
+    let operationTerminalRequired = authoritativeStatus === "succeeded" || authoritativeStatus === "cancelled";
+    if (authoritativeStatus === "failed") {
+      let lastFailure;
+      for (const event of loaded.events) {
+        if (event.type === "node.failed" && event.nodeID === node.id && event.attemptID === state?.attemptID) {
+          lastFailure = event;
+        }
+      }
+      const retryRemains = options.closingStatus === undefined && lastFailure !== undefined && state !== undefined && retryAllowed(lastFailure.errorClass, state.attempts, limit);
+      operationTerminalRequired = !retryRemains;
+    }
+    if (authoritativeStatus === "pending" && options.closingStatus !== undefined) {
+      operationTerminalRequired = true;
+    }
+    return {
+      operationID: operation,
+      operationQueuedRequired: nodeIndex > 0,
+      operationTerminalRequired,
+      attempts: attemptExpectations
+    };
+  });
+}
 function createGraphRuntime(deps) {
-  const { spec, journal, lease, effects, holder } = deps;
+  const { spec, journal, lease, effects, holder, lifecycle } = deps;
   const retryLimit = deps.retryLimit ?? DEFAULT_RETRY_LIMIT;
   const runID = spec.runID;
+  const rootNode = spec.nodes[0];
+  const rootOperationID = operationID(runID, rootNode.id);
   let writer;
   let leaseHandle;
+  let lifecycleWritable = lifecycle !== undefined;
+  async function recordLifecycleEvent(event) {
+    if (lifecycle === undefined || !lifecycleWritable) {
+      return;
+    }
+    try {
+      const result = await lifecycle.append(event);
+      lifecycleWritable = result.ok && result.status.state === "healthy";
+    } catch {
+      lifecycleWritable = false;
+    }
+  }
+  async function verifyLifecycle(loaded, options = {}) {
+    if (lifecycle === undefined || !lifecycleWritable) {
+      return;
+    }
+    try {
+      const status = await lifecycle.verifyOperations(graphLifecycleExpectations(loaded, {
+        ...options,
+        retryLimit
+      }), {
+        requireCompleteObservedWork: options.closingStatus !== undefined
+      });
+      lifecycleWritable = status.state === "healthy";
+    } catch {
+      lifecycleWritable = false;
+    }
+  }
   async function ensureStarted() {
     if (writer !== undefined) {
       return writer;
     }
     leaseHandle = await lease.acquire(runID, holder);
-    writer = await journal.exists(runID) ? await journal.takeOver(runID) : await journal.create(spec);
+    const existed = await journal.exists(runID);
+    writer = existed ? await journal.takeOver(runID) : await journal.create(spec);
     const loaded = await journal.load(runID);
     if (loaded.events.length === 0) {
       await journal.append(writer, runStarted(runID, 0, specDigest(spec)), 0);
+      for (const node of spec.nodes) {
+        if (node.id === rootNode.id) {
+          continue;
+        }
+        await recordLifecycleEvent({
+          type: "operation.queued",
+          operationID: operationID(runID, node.id),
+          taskID: node.anchor.taskID,
+          kind: "graph-node",
+          roleID: node.role,
+          parentOperationID: rootOperationID,
+          dependsOnOperationIDs: node.dependsOn.map((nodeID) => operationID(runID, nodeID))
+        });
+      }
+    } else if (lifecycle !== undefined) {
+      await verifyLifecycle(loaded);
     }
     return writer;
   }
@@ -1980,8 +2121,24 @@ function createGraphRuntime(deps) {
     await lease.release(handle);
   }
   async function dispatchNode2(handle, loaded, node, operation, attempt, attemptIndex) {
+    const attemptRef = {
+      operationID: operation,
+      taskID: node.anchor.taskID,
+      attemptID: attempt,
+      attempt: attemptIndex,
+      modelIndex: 0,
+      retryIndex: attemptIndex
+    };
+    await recordLifecycleEvent({
+      type: "attempt.queued",
+      ...attemptRef
+    });
     const intentSeq = loaded.events.length;
     await journal.append(handle, nodeDispatched(runID, intentSeq, node.id, operation, attempt), intentSeq);
+    await recordLifecycleEvent({
+      type: "attempt.started",
+      ...attemptRef
+    });
     const receipt = await effects.execute({
       runID,
       node,
@@ -1991,8 +2148,40 @@ function createGraphRuntime(deps) {
     const receiptSeq = intentSeq + 1;
     if (receipt.outcome === "succeeded") {
       await journal.append(handle, nodeSucceeded(runID, receiptSeq, node.id, operation, attempt, receipt.artifact), receiptSeq);
+      await recordLifecycleEvent({
+        type: "attempt.terminal",
+        ...attemptRef,
+        outcome: "succeeded",
+        continuation: "none"
+      });
+      await recordLifecycleEvent({
+        type: "operation.terminal",
+        operationID: operation,
+        taskID: node.anchor.taskID,
+        outcome: "succeeded",
+        attemptCount: attemptIndex + 1
+      });
     } else {
       await journal.append(handle, nodeFailed(runID, receiptSeq, node.id, operation, attempt, receipt.errorClass), receiptSeq);
+      const willRetry = retryAllowed(receipt.errorClass, attemptIndex + 1, retryLimit);
+      const failure = graphFailure(receipt.errorClass, willRetry);
+      await recordLifecycleEvent({
+        type: "attempt.terminal",
+        ...attemptRef,
+        outcome: graphFailureOutcome(receipt.errorClass),
+        continuation: willRetry ? "retry-same-effect" : "none",
+        failure
+      });
+      if (!willRetry) {
+        await recordLifecycleEvent({
+          type: "operation.terminal",
+          operationID: operation,
+          taskID: node.anchor.taskID,
+          outcome: graphFailureOutcome(receipt.errorClass),
+          attemptCount: attemptIndex + 1,
+          failure
+        });
+      }
     }
     return {
       kind: "dispatched",
@@ -2003,16 +2192,44 @@ function createGraphRuntime(deps) {
       backoffMs: backoffDelayMs(attemptIndex)
     };
   }
-  async function finishRun(handle, head, state) {
+  async function finishRun(handle, loaded) {
+    const { state } = loaded;
+    const head = loaded.events.length;
     const statuses = Object.values(state.nodes).map((node) => node.status);
     if (statuses.every((s) => s === "succeeded" || s === "cancelled")) {
       await journal.append(handle, runCompleted(runID, head), head);
+      await verifyLifecycle(loaded, { closingStatus: "completed" });
+      await recordLifecycleEvent({
+        type: "run.terminal",
+        outcome: "succeeded",
+        operationCount: spec.nodes.length
+      });
       return { kind: "completed" };
     }
     if (statuses.some((s) => s === "running")) {
       return { kind: "blocked", reason: "in-flight-effect" };
     }
     await journal.append(handle, runFailed(runID, head), head);
+    for (const node of spec.nodes) {
+      if (state.nodes[node.id]?.status !== "pending") {
+        continue;
+      }
+      await recordLifecycleEvent({
+        type: "operation.terminal",
+        operationID: operationID(runID, node.id),
+        taskID: node.anchor.taskID,
+        outcome: "blocked",
+        attemptCount: 0,
+        failure: { class: "dependency-failed", retryable: false }
+      });
+    }
+    await verifyLifecycle(loaded, { closingStatus: "failed" });
+    await recordLifecycleEvent({
+      type: "run.terminal",
+      outcome: "failed",
+      operationCount: spec.nodes.length,
+      failure: { class: "unknown", retryable: false }
+    });
     return { kind: "failed" };
   }
   return {
@@ -2042,7 +2259,7 @@ function createGraphRuntime(deps) {
         const nextAttemptID = attemptID(retry.operationID, retry.attempt);
         return dispatchNode2(handle, loaded, node, retry.operationID, nextAttemptID, retry.attempt);
       }
-      const outcome = await finishRun(handle, loaded.events.length, loaded.state);
+      const outcome = await finishRun(handle, loaded);
       if (outcome.kind === "completed" || outcome.kind === "failed") {
         await releaseLeaseIfHeld();
       }
@@ -2284,7 +2501,126 @@ function toErrorOutcome(error) {
   throw error;
 }
 function createGraphIngress(deps) {
-  const { policy, journal, lease, effects, holder } = deps;
+  const {
+    policy,
+    journal,
+    lease,
+    effects,
+    holder,
+    lifecycleRecorder,
+    lifecycleSource
+  } = deps;
+  const activeLifecycleRuns = new Map;
+  function unavailableRecording(runID) {
+    return {
+      runID,
+      state: "unavailable",
+      lastCommittedHead: 0,
+      failure: { code: "unavailable", recoverable: true, runID }
+    };
+  }
+  async function beginLifecycle(spec) {
+    if (lifecycleRecorder === undefined) {
+      return {};
+    }
+    if (lifecycleSource === undefined) {
+      return { status: unavailableRecording(spec.runID) };
+    }
+    let begun;
+    try {
+      const root = spec.nodes[0];
+      begun = await lifecycleRecorder.beginRun({
+        runID: spec.runID,
+        source: lifecycleSource,
+        executionAuthority: "graph",
+        root: {
+          operationID: operationID(spec.runID, root.id),
+          taskID: root.anchor.taskID,
+          kind: "graph-node",
+          roleID: root.role
+        }
+      });
+    } catch {
+      return { status: unavailableRecording(spec.runID) };
+    }
+    if (!begun.ok) {
+      return { status: begun.status };
+    }
+    activeLifecycleRuns.set(spec.runID, begun.recorder);
+    return { recorder: begun.recorder, status: begun.status };
+  }
+  async function continueLifecycle(runID) {
+    const active = activeLifecycleRuns.get(runID);
+    if (active !== undefined) {
+      return { recorder: active, status: active.status() };
+    }
+    if (lifecycleRecorder === undefined || lifecycleSource === undefined) {
+      return lifecycleRecorder === undefined ? {} : { status: unavailableRecording(runID) };
+    }
+    if (lifecycleRecorder.continueRun === undefined) {
+      return { status: unavailableRecording(runID) };
+    }
+    let continued;
+    try {
+      continued = await lifecycleRecorder.continueRun(runID);
+    } catch {
+      return { status: unavailableRecording(runID) };
+    }
+    if (!continued.ok) {
+      return { status: continued.status };
+    }
+    activeLifecycleRuns.set(runID, continued.recorder);
+    return {
+      recorder: continued.recorder,
+      status: continued.status
+    };
+  }
+  async function appendLifecycle(recorder, event) {
+    if (recorder === undefined) {
+      return;
+    }
+    try {
+      await recorder.append(event);
+    } catch {}
+  }
+  async function finishObservation(runID, recorder, terminal) {
+    if (recorder === undefined) {
+      return;
+    }
+    let status = recorder.status();
+    if (terminal || status.state !== "healthy") {
+      activeLifecycleRuns.delete(runID);
+      try {
+        status = await recorder.release();
+      } catch {
+        status = unavailableRecording(runID);
+      }
+    }
+    return status;
+  }
+  async function abandonObservation(runID, recorder) {
+    activeLifecycleRuns.delete(runID);
+    try {
+      await recorder.release();
+    } catch {}
+  }
+  async function verifyObservation(runID, observation, expectations, verificationOptions = {}) {
+    const recorder = observation.recorder;
+    if (recorder === undefined) {
+      return observation;
+    }
+    try {
+      const status = await recorder.verifyOperations(expectations, verificationOptions);
+      if (status.state === "healthy") {
+        return { recorder, status };
+      }
+      await abandonObservation(runID, recorder);
+      return { status };
+    } catch {
+      await abandonObservation(runID, recorder);
+      return { status: unavailableRecording(runID) };
+    }
+  }
   function taskGate(taskID) {
     const decision = decideIngress(policy, taskID);
     return decision.route === "legacy" ? {
@@ -2303,21 +2639,33 @@ function createGraphIngress(deps) {
       if (blocked !== undefined) {
         return blocked;
       }
+      let observation;
       try {
         const spec = compileSddTask(task);
+        observation = await beginLifecycle(spec);
         const runtime = createGraphRuntime({
           spec,
           journal,
           lease,
           effects,
-          holder
+          holder,
+          ...observation.recorder === undefined ? {} : { lifecycle: observation.recorder }
         });
+        const step = await runtime.step();
+        const recording = await finishObservation(spec.runID, observation.recorder, step.kind === "completed" || step.kind === "failed") ?? observation.status;
         return {
           kind: "accepted",
           runID: spec.runID,
-          step: await runtime.step()
+          step,
+          ...recording === undefined ? {} : { recording }
         };
       } catch (error) {
+        if (observation?.recorder !== undefined) {
+          activeLifecycleRuns.delete(observation.recorder.runID);
+          try {
+            await observation.recorder.release();
+          } catch {}
+        }
         return toErrorOutcome(error);
       }
     },
@@ -2326,17 +2674,36 @@ function createGraphIngress(deps) {
       if (blocked !== undefined) {
         return blocked;
       }
+      let observation;
       try {
         const loaded = await journal.load(runID);
+        observation = loaded.state.status === "running" ? await continueLifecycle(runID) : {};
+        if (loaded.state.status === "running") {
+          observation = await verifyObservation(runID, observation, graphLifecycleExpectations(loaded));
+        }
         const runtime = createGraphRuntime({
           spec: loaded.spec,
           journal,
           lease,
           effects,
-          holder
+          holder,
+          ...observation.recorder === undefined ? {} : { lifecycle: observation.recorder }
         });
-        return { kind: "accepted", runID, step: await runtime.step() };
+        const step = await runtime.step();
+        const recording = await finishObservation(runID, observation.recorder, step.kind === "completed" || step.kind === "failed") ?? observation.status;
+        return {
+          kind: "accepted",
+          runID,
+          step,
+          ...recording === undefined ? {} : { recording }
+        };
       } catch (error) {
+        if (observation?.recorder !== undefined) {
+          activeLifecycleRuns.delete(runID);
+          try {
+            await observation.recorder.release();
+          } catch {}
+        }
         return toErrorOutcome(error);
       }
     },
@@ -2379,6 +2746,7 @@ function createGraphIngress(deps) {
       if (blocked !== undefined) {
         return blocked;
       }
+      let observation;
       try {
         const loaded = await journal.load(runID);
         const plan2 = planCancellation(loaded.state);
@@ -2390,24 +2758,95 @@ function createGraphIngress(deps) {
             abortNodeIDs: []
           };
         }
+        observation = await continueLifecycle(runID);
+        const observationsBeforeCancellation = graphLifecycleExpectations(loaded);
+        observation = await verifyObservation(runID, observation, observationsBeforeCancellation);
         const leaseHandle = await lease.acquire(runID, holder);
-        const handle = await journal.takeOver(runID);
-        let seq = loaded.events.length;
-        for (const nodeID of plan2.cancelNodeIDs) {
-          await journal.append(handle, nodeCancelled(runID, seq, nodeID), seq);
-          seq += 1;
-        }
-        if (plan2.cancelRun) {
-          await journal.append(handle, runCancelled(runID, seq), seq);
+        try {
+          const handle = await journal.takeOver(runID);
+          let seq = loaded.events.length;
+          for (const nodeID of plan2.cancelNodeIDs) {
+            await journal.append(handle, nodeCancelled(runID, seq, nodeID), seq);
+            seq += 1;
+            const node = loaded.spec.nodes.find((candidate) => candidate.id === nodeID);
+            const state = loaded.state.nodes[nodeID];
+            if (node === undefined || state === undefined) {
+              continue;
+            }
+            if (state.status === "running" && state.operationID !== undefined && state.attemptID !== undefined && state.attempts > 0) {
+              const attempt = state.attempts - 1;
+              await appendLifecycle(observation.recorder, {
+                type: "attempt.terminal",
+                operationID: state.operationID,
+                taskID: node.anchor.taskID,
+                attemptID: state.attemptID,
+                attempt,
+                modelIndex: 0,
+                retryIndex: attempt,
+                outcome: "cancelled",
+                continuation: "none",
+                failure: { class: "cancelled", retryable: false }
+              });
+            }
+            await appendLifecycle(observation.recorder, {
+              type: "operation.terminal",
+              operationID: state.operationID ?? operationID(runID, nodeID),
+              taskID: node.anchor.taskID,
+              outcome: "cancelled",
+              attemptCount: state.attempts,
+              failure: { class: "cancelled", retryable: false }
+            });
+          }
+          if (plan2.cancelRun) {
+            await journal.append(handle, runCancelled(runID, seq), seq);
+            for (const node of loaded.spec.nodes) {
+              const state = loaded.state.nodes[node.id];
+              if (state?.status !== "failed")
+                continue;
+              const operation = state.operationID ?? operationID(runID, node.id);
+              const awaitingRetry = observationsBeforeCancellation.some((expected) => expected.operationID === operation && !expected.operationTerminalRequired);
+              if (!awaitingRetry)
+                continue;
+              await appendLifecycle(observation.recorder, {
+                type: "operation.terminal",
+                operationID: operation,
+                taskID: node.anchor.taskID,
+                outcome: "cancelled",
+                attemptCount: state.attempts,
+                failure: { class: "cancelled", retryable: false }
+              });
+            }
+            observation = await verifyObservation(runID, observation, graphLifecycleExpectations(loaded, {
+              closingStatus: "cancelled",
+              cancelledNodeIDs: plan2.cancelNodeIDs
+            }), { requireCompleteObservedWork: true });
+            if (observation.recorder !== undefined) {
+              await appendLifecycle(observation.recorder, {
+                type: "run.terminal",
+                outcome: "cancelled",
+                operationCount: loaded.spec.nodes.length,
+                failure: { class: "cancelled", retryable: false }
+              });
+            }
+          }
+        } finally {
+          await lease.release(leaseHandle);
         }
-        await lease.release(leaseHandle);
+        const recording = await finishObservation(runID, observation.recorder, plan2.cancelRun) ?? observation.status;
         return {
           kind: "cancelled",
           runID,
           cancelledNodeIDs: plan2.cancelNodeIDs,
-          abortNodeIDs: plan2.abortNodeIDs
+          abortNodeIDs: plan2.abortNodeIDs,
+          ...recording === undefined ? {} : { recording }
         };
       } catch (error) {
+        if (observation?.recorder !== undefined) {
+          activeLifecycleRuns.delete(runID);
+          try {
+            await observation.recorder.release();
+          } catch {}
+        }
         return toErrorOutcome(error);
       }
     }
@@ -3184,14 +3623,46 @@ function createGraphOperator(options) {
     evaluateCutoverGate,
     createIngress(policy, config) {
       const root = journalRoot(config);
+      const lifecycleRecorder = options.createLifecycleRecorder === undefined ? options.lifecycleRecorder : (() => {
+        let recorder;
+        const getRecorder = () => {
+          recorder ??= options.createLifecycleRecorder(config);
+          return recorder;
+        };
+        return {
+          beginRun: (input) => getRecorder().beginRun(input),
+          async continueRun(runID) {
+            const continuation = getRecorder().continueRun;
+            if (continuation === undefined) {
+              return {
+                ok: false,
+                status: {
+                  runID,
+                  state: "unavailable",
+                  lastCommittedHead: 0,
+                  failure: {
+                    code: "unavailable",
+                    recoverable: true,
+                    runID
+                  }
+                }
+              };
+            }
+            return continuation(runID);
+          }
+        };
+      })();
       const effects = resolveGraphEngine(config) === "langgraph" ? createLangGraphEffects(options.nodeExecutor) : inertGraphEffects();
-      return createGraphIngress({
+      const ingressOptions = {
         policy,
         journal: createFsGraphJournal(root),
         lease: createWorkspaceLease(root),
         effects,
-        holder: options.holder
-      });
+        holder: options.holder,
+        lifecycleRecorder,
+        lifecycleSource: options.lifecycleSource
+      };
+      return createGraphIngress(ingressOptions);
     }
   };
 }
@@ -3311,6 +3782,7 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
       "storage",
       "memory",
       "graph",
+      "lifecycle",
       "orchestrator",
       "configVersion"
     ]
@@ -3409,6 +3881,8 @@ 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.primary", ["executionMode", "model", "fallbacks"]],
   ["orchestrator.primary.fallbacks[]", MODEL_REF_KEYS]
@@ -5658,46 +6132,922 @@ function parseSoakCertificate(value, expectedPolicy, expectedLedgerDigest) {
   return certificate;
 }
 
-// src/local/cacheAdapter.ts
-import * as fs2 from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-var SCOPE_PREFIX = "@jmanuelcorral/openteam";
-var SCOPE_SEGMENTS = SCOPE_PREFIX.split("/");
-function resolveCacheRoot(override) {
-  if (override !== undefined && override.trim() !== "") {
-    return override;
+// src/lifecycle/root.ts
+import { isAbsolute, normalize, relative, resolve as resolve3 } from "node:path";
+
+// src/messages/lifecycleStorage.ts
+var lifecycleStorageMessages = {
+  configuredRootEscapesWorkspace: "Configured lifecycle root must remain beneath the workspace root."
+};
+
+// src/lifecycle/root.ts
+var resolveLifecycleRoot = (options) => {
+  const workspaceRoot = resolve3(options.workspaceRoot);
+  if (isAbsolute(options.configuredRoot)) {
+    return normalize(resolve3(options.configuredRoot));
+  }
+  const resolved = resolve3(workspaceRoot, options.configuredRoot);
+  const workspaceRelative = relative(workspaceRoot, resolved);
+  if (workspaceRelative === ".." || workspaceRelative.startsWith(`..\\`) || workspaceRelative.startsWith("../") || isAbsolute(workspaceRelative)) {
+    throw new Error(lifecycleStorageMessages.configuredRootEscapesWorkspace);
+  }
+  return normalize(resolved);
+};
+
+// src/lifecycle/schema.ts
+import { z as z17 } from "zod";
+var nonEmptyString = z17.string().min(1);
+var nonNegativeInteger = z17.number().int().nonnegative();
+var positiveInteger = z17.number().int().positive();
+var modelSelectionSchema2 = z17.object({
+  providerID: nonEmptyString,
+  modelID: nonEmptyString
+}).strict();
+var lifecycleFailureSchema = z17.object({
+  class: z17.enum([
+    "routing-blocked",
+    "create-rejected",
+    "create-no-id",
+    "prompt-rejected",
+    "prompt-timeout",
+    "prompt-rate-limited",
+    "prompt-auth",
+    "prompt-content-filter",
+    "prompt-context-length",
+    "prompt-validation",
+    "prompt-connection",
+    "prompt-server",
+    "prompt-stop-unconfirmed",
+    "report-incomplete",
+    "report-not-durable",
+    "budget-exhausted",
+    "dependency-failed",
+    "cancelled",
+    "interrupted",
+    "unknown"
+  ]),
+  statusCode: z17.number().int().min(100).max(599).optional(),
+  retryable: z17.boolean().optional()
+}).strict();
+var lifecycleRootOperationSchema = z17.object({
+  operationID: nonEmptyString,
+  taskID: nonEmptyString,
+  kind: z17.enum(["coordinator", "graph-node"]),
+  roleID: nonEmptyString,
+  agentID: nonEmptyString.optional(),
+  sessionID: nonEmptyString.optional()
+}).strict();
+var lifecycleRunStartInputSchema = z17.object({
+  runID: nonEmptyString,
+  source: z17.enum(["plugin", "cli"]),
+  executionAuthority: z17.enum(["coordinator", "graph"]),
+  root: lifecycleRootOperationSchema
+}).strict();
+var LifecycleRunMetadataSchema = lifecycleRunStartInputSchema.extend({
+  version: z17.literal(1),
+  createdAt: nonNegativeInteger
+}).strict();
+var attemptRefShape = {
+  operationID: nonEmptyString,
+  taskID: nonEmptyString,
+  attemptID: nonEmptyString,
+  attempt: nonNegativeInteger,
+  modelIndex: nonNegativeInteger,
+  retryIndex: nonNegativeInteger
+};
+var eventEnvelopeShape = {
+  v: z17.literal(1),
+  seq: nonNegativeInteger,
+  runID: nonEmptyString,
+  at: nonNegativeInteger
+};
+var runStartedBodyShape = {
+  type: z17.literal("run.started"),
+  source: z17.enum(["plugin", "cli"]),
+  executionAuthority: z17.enum(["coordinator", "graph"]),
+  root: lifecycleRootOperationSchema
+};
+var operationQueuedBodyShape = {
+  type: z17.literal("operation.queued"),
+  operationID: nonEmptyString,
+  taskID: nonEmptyString,
+  kind: z17.enum(["role", "graph-node"]),
+  roleID: nonEmptyString,
+  agentID: nonEmptyString.optional(),
+  parentOperationID: nonEmptyString,
+  dependsOnOperationIDs: z17.array(nonEmptyString).readonly()
+};
+var modelSelectedBodyShape = {
+  type: z17.literal("attempt.model-selected"),
+  ...attemptRefShape,
+  decisionID: nonEmptyString,
+  model: modelSelectionSchema2,
+  routeKind: z17.enum(["local", "frontier"]),
+  selectionCause: z17.enum([
+    "initial",
+    "retry-incomplete",
+    "retry-transport",
+    "fallback-incomplete",
+    "fallback-transport"
+  ]),
+  runtimeID: nonEmptyString.optional()
+};
+var attemptQueuedBodyShape = {
+  type: z17.literal("attempt.queued"),
+  ...attemptRefShape,
+  runtimeID: nonEmptyString.optional()
+};
+var attemptStartedBodyShape = {
+  type: z17.literal("attempt.started"),
+  ...attemptRefShape
+};
+var sessionCreatedBodyShape = {
+  type: z17.literal("session.created"),
+  ...attemptRefShape,
+  sessionID: nonEmptyString,
+  parentSessionID: nonEmptyString.optional()
+};
+var attemptTerminalBodyShape = {
+  type: z17.literal("attempt.terminal"),
+  ...attemptRefShape,
+  outcome: z17.enum([
+    "succeeded",
+    "failed",
+    "cancelled",
+    "interrupted",
+    "unknown"
+  ]),
+  continuation: z17.enum([
+    "none",
+    "retry-same-model",
+    "fallback-next-model",
+    "retry-same-effect"
+  ]),
+  sessionID: nonEmptyString.optional(),
+  failure: lifecycleFailureSchema.optional()
+};
+var operationTerminalBodyShape = {
+  type: z17.literal("operation.terminal"),
+  operationID: nonEmptyString,
+  taskID: nonEmptyString,
+  outcome: z17.enum([
+    "succeeded",
+    "failed",
+    "cancelled",
+    "interrupted",
+    "unknown",
+    "blocked"
+  ]),
+  attemptCount: nonNegativeInteger,
+  finalSessionID: nonEmptyString.optional(),
+  failure: lifecycleFailureSchema.optional()
+};
+var runTerminalBodyShape = {
+  type: z17.literal("run.terminal"),
+  outcome: z17.enum([
+    "succeeded",
+    "failed",
+    "cancelled",
+    "interrupted",
+    "unknown"
+  ]),
+  operationCount: nonNegativeInteger,
+  failure: lifecycleFailureSchema.optional()
+};
+var bodySchemas = [
+  z17.object(runStartedBodyShape).strict(),
+  z17.object(operationQueuedBodyShape).strict(),
+  z17.object(modelSelectedBodyShape).strict(),
+  z17.object(attemptQueuedBodyShape).strict(),
+  z17.object(attemptStartedBodyShape).strict(),
+  z17.object(sessionCreatedBodyShape).strict(),
+  z17.object(attemptTerminalBodyShape).strict(),
+  z17.object(operationTerminalBodyShape).strict(),
+  z17.object(runTerminalBodyShape).strict()
+];
+var appendBodySchemas = bodySchemas.slice(1);
+var LifecycleAppendEventSchema = z17.discriminatedUnion("type", appendBodySchemas);
+var LifecycleEventSchema = z17.discriminatedUnion("type", [
+  z17.object({ ...eventEnvelopeShape, ...runStartedBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...operationQueuedBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...modelSelectedBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...attemptQueuedBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...attemptStartedBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...sessionCreatedBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...attemptTerminalBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...operationTerminalBodyShape }).strict(),
+  z17.object({ ...eventEnvelopeShape, ...runTerminalBodyShape }).strict()
+]);
+var LifecycleWriterLeaseInputSchema = z17.object({
+  writer: z17.object({
+    processID: positiveInteger,
+    processInstanceID: nonEmptyString
+  }).strict(),
+  now: nonNegativeInteger,
+  leaseDurationMs: positiveInteger
+}).strict();
+var LifecycleWriterLeaseSchema = z17.object({
+  version: z17.literal(1),
+  runID: nonEmptyString,
+  writerToken: nonEmptyString,
+  processID: positiveInteger,
+  processInstanceID: nonEmptyString,
+  acquiredAt: nonNegativeInteger,
+  heartbeatAt: nonNegativeInteger,
+  expiresAt: nonNegativeInteger
+}).strict().superRefine((lease, context) => {
+  if (lease.heartbeatAt < lease.acquiredAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["heartbeatAt"],
+      message: "heartbeatAt precedes acquiredAt"
+    });
   }
-  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
-  return path.join(base, "opencode", "packages");
-}
-function readJsonSafe(filePath) {
-  try {
-    const text = fs2.readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(text);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    return;
-  } catch {
-    return;
+  if (lease.expiresAt <= lease.heartbeatAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["expiresAt"],
+      message: "expiresAt must follow heartbeatAt"
+    });
+  }
+});
+function omitBoundedLifecycleSource(value) {
+  if (Array.isArray(value)) {
+    return value.map(omitBoundedLifecycleSource);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
   }
+  return Object.fromEntries(Object.entries(value).flatMap(([key, child]) => {
+    if (key === "source" && (child === "plugin" || child === "cli" || child === "lifecycle")) {
+      return [];
+    }
+    return [[key, omitBoundedLifecycleSource(child)]];
+  }));
 }
-function extractVersion(pkg) {
-  if (pkg === undefined)
-    return "";
-  const v = pkg.version;
-  return typeof v === "string" ? v : "";
+function assertLifecycleReferenceOnly(value) {
+  assertReferenceOnly(omitBoundedLifecycleSource(value));
 }
-function readDirectoryEntries(dir) {
-  try {
-    return fs2.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return [];
+function parseLifecycleRunStartInput(value) {
+  const parsed = lifecycleRunStartInputSchema.parse(value);
+  assertLifecycleReferenceOnly(parsed);
+  return parsed;
+}
+function parseLifecycleRunMetadata(value) {
+  const parsed = LifecycleRunMetadataSchema.parse(value);
+  assertLifecycleReferenceOnly(parsed);
+  return parsed;
+}
+function parseLifecycleAppendEvent(value) {
+  const parsed = LifecycleAppendEventSchema.parse(value);
+  assertLifecycleReferenceOnly(parsed);
+  return parsed;
+}
+function parseLifecycleEvent(value) {
+  const parsed = LifecycleEventSchema.parse(value);
+  assertLifecycleReferenceOnly(parsed);
+  return parsed;
+}
+function parseLifecycleWriterLeaseInput(value) {
+  return LifecycleWriterLeaseInputSchema.parse(value);
+}
+function parseLifecycleWriterLease(value) {
+  const parsed = LifecycleWriterLeaseSchema.parse(value);
+  assertLifecycleReferenceOnly(parsed);
+  return parsed;
+}
+
+// src/lifecycle/project.ts
+function operationForEvent(operations, event) {
+  const operation = operations.get(event.operationID);
+  if (operation === undefined) {
+    throw new Error(`lifecycle event references unknown operation ${event.operationID}`);
+  }
+  if (operation.taskID !== event.taskID) {
+    throw new Error(`lifecycle task identity changed for ${event.operationID}`);
   }
+  return operation;
 }
-function lstatPlainDirectory(dir) {
-  try {
+function attemptForEvent(operations, event) {
+  const operation = operationForEvent(operations, event);
+  const attempt = operation.attempts.find((candidate) => candidate.attemptID === event.attemptID);
+  if (attempt === undefined) {
+    throw new Error(`lifecycle event references unknown attempt ${event.attemptID}`);
+  }
+  if (attempt.attempt !== event.attempt || attempt.modelIndex !== event.modelIndex || attempt.retryIndex !== event.retryIndex) {
+    throw new Error(`lifecycle attempt identity changed for ${event.attemptID}`);
+  }
+  return { operation, attempt };
+}
+function terminalOperationState(outcome) {
+  if (outcome === undefined) {
+    throw new Error("terminal lifecycle operation is missing its outcome");
+  }
+  return outcome;
+}
+var projectLifecyclePrefix = (input) => {
+  const metadata = parseLifecycleRunMetadata(input.metadata);
+  if (!Number.isInteger(input.cursor) || input.cursor < 0 || input.cursor > input.events.length) {
+    throw new RangeError(`lifecycle cursor ${input.cursor} is outside 0..${input.events.length}`);
+  }
+  const events = input.events.map((event, index) => {
+    const parsed = parseLifecycleEvent(event);
+    if (parsed.seq !== index || parsed.runID !== metadata.runID) {
+      throw new Error(`invalid lifecycle event envelope at sequence ${index}`);
+    }
+    return parsed;
+  });
+  const root = {
+    operationID: metadata.root.operationID,
+    taskID: metadata.root.taskID,
+    kind: metadata.root.kind,
+    roleID: metadata.root.roleID,
+    ...metadata.root.agentID === undefined ? {} : { agentID: metadata.root.agentID },
+    state: "waiting",
+    dependsOnOperationIDs: [],
+    attempts: []
+  };
+  const operations = new Map([
+    [root.operationID, root]
+  ]);
+  const edges = [];
+  let observedState = "pending";
+  for (const event of events.slice(0, input.cursor)) {
+    switch (event.type) {
+      case "run.started": {
+        if (event.root.operationID !== metadata.root.operationID || event.root.taskID !== metadata.root.taskID || event.source !== metadata.source || event.executionAuthority !== metadata.executionAuthority) {
+          throw new Error("run.started does not match lifecycle metadata");
+        }
+        root.state = "running";
+        observedState = "running";
+        break;
+      }
+      case "operation.queued": {
+        if (operations.has(event.operationID)) {
+          throw new Error(`duplicate lifecycle operation ${event.operationID}`);
+        }
+        operations.set(event.operationID, {
+          operationID: event.operationID,
+          taskID: event.taskID,
+          kind: event.kind,
+          roleID: event.roleID,
+          ...event.agentID === undefined ? {} : { agentID: event.agentID },
+          state: "queued",
+          parentOperationID: event.parentOperationID,
+          dependsOnOperationIDs: [...event.dependsOnOperationIDs],
+          attempts: [],
+          queuedAt: event.at
+        });
+        edges.push({
+          kind: "hierarchy",
+          from: event.parentOperationID,
+          to: event.operationID
+        });
+        for (const dependency of event.dependsOnOperationIDs) {
+          edges.push({
+            kind: "dependency",
+            from: dependency,
+            to: event.operationID
+          });
+        }
+        break;
+      }
+      case "attempt.model-selected": {
+        const operation = operationForEvent(operations, event);
+        if (operation.attempts.some((attempt) => attempt.attemptID === event.attemptID || attempt.attempt === event.attempt)) {
+          throw new Error(`duplicate lifecycle attempt ${event.attemptID}`);
+        }
+        operation.attempts.push({
+          operationID: event.operationID,
+          taskID: event.taskID,
+          attemptID: event.attemptID,
+          attempt: event.attempt,
+          modelIndex: event.modelIndex,
+          retryIndex: event.retryIndex,
+          state: "selected",
+          decisionID: event.decisionID,
+          model: event.model,
+          routeKind: event.routeKind,
+          selectionCause: event.selectionCause,
+          ...event.runtimeID === undefined ? {} : { runtimeID: event.runtimeID },
+          selectedAt: event.at
+        });
+        break;
+      }
+      case "attempt.queued": {
+        const operation = operationForEvent(operations, event);
+        let attempt = operation.attempts.find((candidate) => candidate.attemptID === event.attemptID);
+        if (attempt === undefined) {
+          if (operation.kind !== "graph-node" || operation.attempts.some((candidate) => candidate.attempt === event.attempt)) {
+            throw new Error(`lifecycle event references unknown attempt ${event.attemptID}`);
+          }
+          attempt = {
+            operationID: event.operationID,
+            taskID: event.taskID,
+            attemptID: event.attemptID,
+            attempt: event.attempt,
+            modelIndex: event.modelIndex,
+            retryIndex: event.retryIndex,
+            state: "queued"
+          };
+          operation.attempts.push(attempt);
+        } else if (attempt.attempt !== event.attempt || attempt.modelIndex !== event.modelIndex || attempt.retryIndex !== event.retryIndex) {
+          throw new Error(`lifecycle attempt identity changed for ${event.attemptID}`);
+        }
+        attempt.state = "queued";
+        attempt.queuedAt = event.at;
+        if (event.runtimeID !== undefined) {
+          attempt.runtimeID = event.runtimeID;
+        }
+        break;
+      }
+      case "attempt.started": {
+        const { operation, attempt } = attemptForEvent(operations, event);
+        attempt.state = "running";
+        attempt.startedAt = event.at;
+        operation.state = "running";
+        break;
+      }
+      case "session.created": {
+        const { attempt } = attemptForEvent(operations, event);
+        attempt.sessionID = event.sessionID;
+        if (event.parentSessionID !== undefined) {
+          attempt.parentSessionID = event.parentSessionID;
+        }
+        break;
+      }
+      case "attempt.terminal": {
+        const { attempt } = attemptForEvent(operations, event);
+        attempt.state = event.outcome;
+        attempt.outcome = event.outcome;
+        attempt.continuation = event.continuation;
+        attempt.terminalAt = event.at;
+        if (event.sessionID !== undefined) {
+          attempt.sessionID = event.sessionID;
+        }
+        if (event.failure !== undefined) {
+          attempt.failure = event.failure;
+        }
+        break;
+      }
+      case "operation.terminal": {
+        const operation = operationForEvent(operations, event);
+        operation.outcome = event.outcome;
+        operation.state = terminalOperationState(event.outcome);
+        operation.terminalAt = event.at;
+        if (event.failure !== undefined) {
+          operation.failure = event.failure;
+        }
+        break;
+      }
+      case "run.terminal":
+        observedState = event.outcome;
+        root.state = event.outcome;
+        root.outcome = event.outcome;
+        root.terminalAt = event.at;
+        if (event.failure !== undefined) {
+          root.failure = event.failure;
+        }
+        break;
+    }
+  }
+  const timeline = events.slice(0, input.cursor);
+  const projection = {
+    version: 1,
+    source: "lifecycle",
+    runID: metadata.runID,
+    cursor: input.cursor,
+    head: events.length,
+    observedState,
+    rootOperationID: metadata.root.operationID,
+    operations: [...operations.values()].map((operation) => ({
+      ...operation,
+      dependsOnOperationIDs: [...operation.dependsOnOperationIDs],
+      attempts: operation.attempts.map((attempt) => ({ ...attempt }))
+    })),
+    edges,
+    timeline,
+    lastEventAt: timeline.at(-1)?.at ?? null
+  };
+  assertLifecycleReferenceOnly(projection);
+  return projection;
+};
+
+// src/lifecycle/runtimeRecorder.ts
+var DEFAULT_LIFECYCLE_HEARTBEAT_INTERVAL_MS = 5000;
+var DEFAULT_LIFECYCLE_WRITER_LEASE_MS = 30000;
+var createNodeLifecycleHeartbeatScheduler = () => ({
+  start(intervalMs, heartbeat) {
+    let stopped = false;
+    let running = false;
+    const timer = setInterval(() => {
+      if (stopped || running) {
+        return;
+      }
+      running = true;
+      heartbeat().catch(() => {}).finally(() => {
+        running = false;
+      });
+    }, Math.max(1, intervalMs));
+    timer.unref?.();
+    return {
+      stop() {
+        if (stopped) {
+          return;
+        }
+        stopped = true;
+        clearInterval(timer);
+      }
+    };
+  }
+});
+function thrownJournalFailure(runID) {
+  return {
+    code: "unavailable",
+    recoverable: true,
+    runID
+  };
+}
+function failedStatus(current, failure) {
+  return {
+    runID: current.runID,
+    state: failure.recoverable ? "degraded" : "unavailable",
+    lastCommittedHead: current.lastCommittedHead,
+    failure
+  };
+}
+function attemptObservationMissing(attempt, expectation) {
+  if (expectation.attemptID === null || attempt?.queuedAt === undefined) {
+    return true;
+  }
+  if (expectation.minimumPhase !== "queued" && attempt.startedAt === undefined) {
+    return true;
+  }
+  return expectation.minimumPhase === "terminal" && attempt.terminalAt === undefined;
+}
+function operationObservationMissing(projection, expectation) {
+  const operation = projection.operations.find((candidate) => candidate.operationID === expectation.operationID);
+  if (operation === undefined || expectation.operationQueuedRequired && operation.queuedAt === undefined || expectation.operationTerminalRequired && operation.terminalAt === undefined) {
+    return true;
+  }
+  return expectation.attempts.some((attemptExpectation) => attemptObservationMissing(operation.attempts.find((attempt) => attempt.attemptID === attemptExpectation.attemptID), attemptExpectation));
+}
+function hasIncompleteObservedWork(projection) {
+  return projection.operations.some((operation) => operation.operationID !== projection.rootOperationID && operation.terminalAt === undefined || operation.attempts.some((attempt) => attempt.terminalAt === undefined));
+}
+function createActiveRunRecorder(options, handle, initialHead) {
+  const runID = handle.runID;
+  let current = {
+    runID,
+    state: "healthy",
+    lastCommittedHead: initialHead
+  };
+  let schedule;
+  let released = false;
+  let queue = Promise.resolve();
+  const stopSchedule = () => {
+    schedule?.stop();
+    schedule = undefined;
+  };
+  const degrade = (failure) => {
+    current = failedStatus(current, failure);
+    stopSchedule();
+  };
+  const serialize = (work) => {
+    const result = queue.then(work, work);
+    queue = result.then(() => {}, () => {});
+    return result;
+  };
+  const releaseOwner = async () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    stopSchedule();
+    try {
+      const release = await options.journal.release(handle);
+      if (!release.ok) {
+        degrade(release.error);
+      }
+    } catch {
+      degrade(thrownJournalFailure(runID));
+    }
+  };
+  const verifyCommittedProjection = async (expectations, verificationOptions) => {
+    try {
+      const loaded = await options.journal.load(runID);
+      if (!loaded.ok) {
+        degrade(loaded.error);
+        return false;
+      }
+      if (loaded.value.integrity !== "clean" || loaded.value.head !== current.lastCommittedHead) {
+        degrade({ code: "corrupt", recoverable: false, runID });
+        return false;
+      }
+      const projection = projectLifecyclePrefix({
+        ...loaded.value,
+        cursor: loaded.value.head
+      });
+      if (expectations.some((expectation) => operationObservationMissing(projection, expectation)) || verificationOptions.requireCompleteObservedWork === true && hasIncompleteObservedWork(projection)) {
+        degrade({ code: "unavailable", recoverable: false, runID });
+        return false;
+      }
+      return true;
+    } catch {
+      degrade({ code: "unavailable", recoverable: false, runID });
+      return false;
+    }
+  };
+  const heartbeat = () => serialize(async () => {
+    if (released || current.state !== "healthy") {
+      return;
+    }
+    try {
+      const result = await options.journal.heartbeat(handle, {
+        now: options.now(),
+        leaseDurationMs: options.leaseDurationMs
+      });
+      if (!result.ok) {
+        degrade(result.error);
+      }
+    } catch {
+      degrade(thrownJournalFailure(runID));
+    }
+  });
+  const recorder = {
+    runID,
+    append(event) {
+      return serialize(async () => {
+        if (released || current.state !== "healthy") {
+          return { ok: false, status: current };
+        }
+        if (event.type === "run.terminal" && !await verifyCommittedProjection([], {
+          requireCompleteObservedWork: true
+        })) {
+          await releaseOwner();
+          return { ok: false, status: current };
+        }
+        let appended;
+        try {
+          appended = await options.journal.append(handle, event, current.lastCommittedHead);
+        } catch {
+          degrade(thrownJournalFailure(runID));
+          return { ok: false, status: current };
+        }
+        if (!appended.ok) {
+          degrade(appended.error);
+          return { ok: false, status: current };
+        }
+        current = {
+          runID,
+          state: "healthy",
+          lastCommittedHead: appended.value.head
+        };
+        if (event.type === "run.terminal") {
+          await releaseOwner();
+          if (current.state === "healthy" && options.retention !== undefined) {
+            try {
+              const retained = await options.journal.pruneTerminal(options.retention, options.now());
+              if (!retained.ok) {
+                degrade(retained.error);
+              }
+            } catch {
+              degrade(thrownJournalFailure(runID));
+            }
+          }
+        }
+        return {
+          ok: true,
+          receipt: appended.value,
+          status: current
+        };
+      });
+    },
+    status() {
+      return current;
+    },
+    verifyOperations(expectations, verificationOptions = {}) {
+      return serialize(async () => {
+        if (released || current.state !== "healthy") {
+          return current;
+        }
+        await verifyCommittedProjection(expectations, verificationOptions);
+        if (current.state !== "healthy") {
+          await releaseOwner();
+        }
+        return current;
+      });
+    },
+    release() {
+      return serialize(async () => {
+        await releaseOwner();
+        return current;
+      });
+    }
+  };
+  schedule = options.heartbeatScheduler.start(options.heartbeatIntervalMs, heartbeat);
+  return recorder;
+}
+function continuationFailure(runID, lastCommittedHead, failure) {
+  return {
+    ok: false,
+    status: failedStatus({
+      runID,
+      state: "healthy",
+      lastCommittedHead
+    }, failure)
+  };
+}
+var createRuntimeLifecycleRecorder = (options) => {
+  const runtime = {
+    async beginRun(input) {
+      const startedAt = options.now();
+      let started;
+      try {
+        started = await options.journal.start(input, {
+          writer: options.writer,
+          now: startedAt,
+          leaseDurationMs: options.leaseDurationMs
+        });
+      } catch {
+        return {
+          ok: false,
+          status: {
+            runID: input.runID,
+            state: "unavailable",
+            lastCommittedHead: 0,
+            failure: thrownJournalFailure(input.runID)
+          }
+        };
+      }
+      if (!started.ok) {
+        return {
+          ok: false,
+          status: {
+            runID: input.runID,
+            state: "unavailable",
+            lastCommittedHead: 0,
+            failure: started.error
+          }
+        };
+      }
+      const receipt = started.value;
+      const recorder = createActiveRunRecorder(options, receipt.handle, receipt.head);
+      return {
+        ok: true,
+        recorder,
+        receipt,
+        status: recorder.status()
+      };
+    }
+  };
+  const writerLiveness = options.writerLiveness;
+  if (writerLiveness === undefined) {
+    return runtime;
+  }
+  return {
+    ...runtime,
+    async continueRun(runID) {
+      const releaseTaken = async (handle) => {
+        try {
+          await options.journal.release(handle);
+        } catch {}
+      };
+      let loaded;
+      try {
+        loaded = await options.journal.load(runID);
+      } catch {
+        return continuationFailure(runID, 0, thrownJournalFailure(runID));
+      }
+      if (!loaded.ok) {
+        return continuationFailure(runID, 0, loaded.error);
+      }
+      if (loaded.value.integrity !== "clean") {
+        return continuationFailure(runID, loaded.value.head, {
+          code: "corrupt",
+          recoverable: false,
+          runID
+        });
+      }
+      if (loaded.value.events.at(-1)?.type === "run.terminal") {
+        return continuationFailure(runID, loaded.value.head, {
+          code: "terminal-run",
+          recoverable: false,
+          runID
+        });
+      }
+      let observed;
+      try {
+        observed = await writerLiveness.observe(runID);
+      } catch {
+        return continuationFailure(runID, loaded.value.head, thrownJournalFailure(runID));
+      }
+      let expected;
+      if (observed.kind === "absent") {
+        expected = { kind: "absent" };
+      } else if (observed.kind === "expired") {
+        expected = {
+          kind: "expired",
+          writerToken: observed.lease.writerToken,
+          expiresAt: observed.lease.expiresAt
+        };
+      } else {
+        return continuationFailure(runID, loaded.value.head, {
+          code: observed.kind === "active" ? "active-run" : "unavailable",
+          recoverable: true,
+          runID
+        });
+      }
+      let taken;
+      try {
+        taken = await options.journal.takeOver(runID, expected, {
+          writer: options.writer,
+          now: options.now(),
+          leaseDurationMs: options.leaseDurationMs
+        });
+      } catch {
+        return continuationFailure(runID, loaded.value.head, thrownJournalFailure(runID));
+      }
+      if (!taken.ok) {
+        return continuationFailure(runID, loaded.value.head, taken.error);
+      }
+      let confirmed;
+      try {
+        confirmed = await options.journal.load(runID);
+      } catch {
+        await releaseTaken(taken.value);
+        return continuationFailure(runID, loaded.value.head, thrownJournalFailure(runID));
+      }
+      if (!confirmed.ok) {
+        await releaseTaken(taken.value);
+        return continuationFailure(runID, loaded.value.head, confirmed.error);
+      }
+      if (confirmed.value.integrity !== "clean") {
+        await releaseTaken(taken.value);
+        return continuationFailure(runID, confirmed.value.head, {
+          code: "corrupt",
+          recoverable: false,
+          runID
+        });
+      }
+      if (confirmed.value.events.at(-1)?.type === "run.terminal") {
+        await releaseTaken(taken.value);
+        return continuationFailure(runID, confirmed.value.head, {
+          code: "terminal-run",
+          recoverable: false,
+          runID
+        });
+      }
+      const recorder = createActiveRunRecorder(options, taken.value, confirmed.value.head);
+      return {
+        ok: true,
+        recorder,
+        status: recorder.status()
+      };
+    }
+  };
+};
+
+// src/local/cacheAdapter.ts
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var SCOPE_PREFIX = "@jmanuelcorral/openteam";
+var SCOPE_SEGMENTS = SCOPE_PREFIX.split("/");
+function resolveCacheRoot(override) {
+  if (override !== undefined && override.trim() !== "") {
+    return override;
+  }
+  const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+  return path.join(base, "opencode", "packages");
+}
+function readJsonSafe(filePath) {
+  try {
+    const text = fs2.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(text);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+function extractVersion(pkg) {
+  if (pkg === undefined)
+    return "";
+  const v = pkg.version;
+  return typeof v === "string" ? v : "";
+}
+function readDirectoryEntries(dir) {
+  try {
+    return fs2.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function lstatPlainDirectory(dir) {
+  try {
     const stat2 = fs2.lstatSync(dir);
     if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
       return;
@@ -5882,9 +7232,9 @@ function createRuntimeConcurrencyLimiter(options) {
       }
       const state = stateFor(runtimeId);
       const queuedAt = options.now();
-      return new Promise((resolve3) => {
+      return new Promise((resolve4) => {
         state.queues[priority].push((release) => {
-          resolve3({ release, waitedMs: options.now() - queuedAt });
+          resolve4({ release, waitedMs: options.now() - queuedAt });
         });
       });
     },
@@ -6592,14 +7942,14 @@ var readReportArtifact = async (reportPath) => {
 };
 
 // src/orchestrator/roster.ts
-import { z as z17 } from "zod";
-var RosterEntrySchema = z17.object({
-  roleID: z17.string().min(1),
-  agentName: z17.string().min(1)
+import { z as z18 } from "zod";
+var RosterEntrySchema = z18.object({
+  roleID: z18.string().min(1),
+  agentName: z18.string().min(1)
 }).strict();
-var RosterSchema = z17.object({
-  universe: z17.string().min(1),
-  entries: z17.array(RosterEntrySchema)
+var RosterSchema = z18.object({
+  universe: z18.string().min(1),
+  entries: z18.array(RosterEntrySchema)
 }).strict();
 var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
 
@@ -6772,6 +8122,18 @@ function enforceGuaranteedRoles(roster) {
   return { universe: roster.universe, entries: [...roster.entries, ...added] };
 }
 
+// src/messages/lifecycleRuntime.ts
+function normalizedSessionFailureMessage(failure) {
+  return `session request failed (${failure.failureClass})`;
+}
+function lifecycleRecordingAdvisory(status) {
+  if (status.state === "healthy") {
+    return;
+  }
+  const failure = status.failure === undefined ? "" : ` (${status.failure.code})`;
+  return `Lifecycle history recording is ${status.state}${failure}; model execution continued without claiming complete history.`;
+}
+
 // src/orchestrator/subsessions.ts
 var DEFAULT_ABORT_GRACE_MS = 2000;
 var DEFAULT_STATUS_POLL_MS = 100;
@@ -6911,6 +8273,9 @@ function errorReason(error) {
   }
   return safeToString(error);
 }
+function isNormalizedSessionFailure(value) {
+  return isObject3(value) && safeGet(value, "kind") === "normalized-session-failure" && typeof safeGet(value, "failureClass") === "string" && typeof safeGet(value, "retryable") === "boolean";
+}
 function createArgs(req) {
   const body = {};
   const args = { body };
@@ -6953,9 +8318,9 @@ async function withTimeout(promise, timeoutMs) {
     return { kind: "settled", value: await promise };
   }
   let timeoutID;
-  const timeout = new Promise((resolve3) => {
+  const timeout = new Promise((resolve4) => {
     timeoutID = setTimeout(() => {
-      resolve3({ kind: "timeout" });
+      resolve4({ kind: "timeout" });
     }, timeoutMs);
   });
   try {
@@ -6975,8 +8340,8 @@ async function beforeDeadline(request, deadline, deps) {
   const controller = new AbortController;
   let timeoutID;
   const observedRequest = Promise.resolve().then(() => request(controller.signal)).then((value) => ({ kind: "settled", value }), (error) => ({ kind: "rejected", error }));
-  const timeout = new Promise((resolve3) => {
-    timeoutID = setTimeout(() => resolve3({ kind: "timeout" }), remainingMs);
+  const timeout = new Promise((resolve4) => {
+    timeoutID = setTimeout(() => resolve4({ kind: "timeout" }), remainingMs);
   });
   try {
     const outcome = await Promise.race([observedRequest, timeout]);
@@ -7110,13 +8475,15 @@ async function runSubsession(client, req, deps) {
   try {
     const created = await client.session.create(createArgs(req));
     if (created.error !== undefined) {
+      const normalizedFailure = isNormalizedSessionFailure(created.error) ? created.error : undefined;
       return {
         success: false,
         roleID: req.roleID,
         model: req.model,
         failureStage: "create",
-        failureReason: errorReason(created.error),
-        retrySafe: true
+        failureReason: normalizedFailure === undefined ? errorReason(created.error) : normalizedSessionFailureMessage(normalizedFailure),
+        retrySafe: true,
+        ...normalizedFailure === undefined ? {} : { normalizedFailure }
       };
     }
     sessionID = created.data?.id;
@@ -7130,6 +8497,9 @@ async function runSubsession(client, req, deps) {
         retrySafe: true
       };
     }
+    try {
+      await deps.onSessionCreated?.(sessionID);
+    } catch {}
   } catch (error) {
     return {
       success: false,
@@ -7168,14 +8538,16 @@ async function runSubsession(client, req, deps) {
     }
     const prompted = outcome.value;
     if (prompted.error !== undefined) {
+      const normalizedFailure = isNormalizedSessionFailure(prompted.error) ? prompted.error : undefined;
       return {
         success: false,
         sessionID,
         roleID: req.roleID,
         model: req.model,
         failureStage: "prompt",
-        failureReason: errorReason(prompted.error),
-        retrySafe: true
+        failureReason: normalizedFailure === undefined ? errorReason(prompted.error) : normalizedSessionFailureMessage(normalizedFailure),
+        retrySafe: true,
+        ...normalizedFailure === undefined ? {} : { normalizedFailure }
       };
     }
     return {
@@ -7797,7 +9169,7 @@ function planWorktreeReconciliation(input) {
 }
 
 // src/telemetry/otelConfig.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/telemetry/fanout.ts
 function createFanOutSink(deps) {
@@ -7875,10 +9247,10 @@ function createOtelSink(deps) {
 }
 
 // src/telemetry/otelConfig.ts
-var OtelBackendConfigSchema = z18.object({
-  backend: z18.literal("opentelemetry"),
-  connectionEnv: z18.string().min(1),
-  serviceName: z18.string().min(1).optional()
+var OtelBackendConfigSchema = z19.object({
+  backend: z19.literal("opentelemetry"),
+  connectionEnv: z19.string().min(1),
+  serviceName: z19.string().min(1).optional()
 }).strict();
 function parseConnectionString(raw) {
   const pairs = new Map;
@@ -11165,36 +12537,36 @@ function formatResponse(response) {
 }
 
 // src/plugin/reportRunSchema.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/plugin/graphShadowIngress.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var LEGACY_EXECUTION_TRACE_VERSION = 1;
-var LegacyExecutionStatusSchema = z19.enum([
+var LegacyExecutionStatusSchema = z20.enum([
   "completed",
   "failed",
   "cancelled"
 ]);
-var LegacyReviewOutcomeSchema = z19.enum([
+var LegacyReviewOutcomeSchema = z20.enum([
   "approved",
   "rejected",
   "inconclusive"
 ]);
-var LegacyTraceNodeV1Schema = z19.object({
+var LegacyTraceNodeV1Schema = z20.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z19.string().min(1),
-  sessionRef: z19.string().min(1).optional(),
+  model: z20.string().min(1),
+  sessionRef: z20.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var LegacyExecutionTraceV1Schema = z19.object({
-  version: z19.literal(LEGACY_EXECUTION_TRACE_VERSION),
+var LegacyExecutionTraceV1Schema = z20.object({
+  version: z20.literal(LEGACY_EXECUTION_TRACE_VERSION),
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
   outcome: LegacyReviewOutcomeSchema,
-  fixes: z19.number().int().nonnegative(),
-  nodes: z19.array(LegacyTraceNodeV1Schema).min(1),
-  parentSessionRef: z19.string().min(1).optional()
+  fixes: z20.number().int().nonnegative(),
+  nodes: z20.array(LegacyTraceNodeV1Schema).min(1),
+  parentSessionRef: z20.string().min(1).optional()
 }).strict();
 function gateReason2(gate) {
   if (gate === undefined || gate.mode === "off") {
@@ -11265,20 +12637,20 @@ function parseLegacyExecutionTrace(input) {
 }
 
 // src/plugin/reportRunSchema.ts
-var ReportRunNodeSchema = z20.object({
+var ReportRunNodeSchema = z21.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z20.string().min(1),
-  ok: z20.boolean(),
-  sessionRef: z20.string().min(1).optional(),
+  model: z21.string().min(1),
+  ok: z21.boolean(),
+  sessionRef: z21.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var ReportRunPayloadSchema = z20.object({
+var ReportRunPayloadSchema = z21.object({
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
-  fixes: z20.number().int().nonnegative(),
-  nodes: z20.array(ReportRunNodeSchema).min(1),
-  parentSessionRef: z20.string().min(1).optional()
+  fixes: z21.number().int().nonnegative(),
+  nodes: z21.array(ReportRunNodeSchema).min(1),
+  parentSessionRef: z21.string().min(1).optional()
 }).strict();
 
 // src/orchestrator/graphShadow.ts
@@ -12579,62 +13951,62 @@ ${lines.join(`
 }
 
 // src/memory/types.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z21.string().min(1);
-var MemoryKindSchema = z21.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z21.object({
-  id: z21.string().min(1),
+var OwnerKeySchema = z22.string().min(1);
+var MemoryKindSchema = z22.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z22.object({
+  id: z22.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z21.number().min(0).max(1),
-  validFrom: z21.number().finite(),
-  validUntil: z21.number().finite().nullable().default(null),
-  createdAt: z21.number().finite(),
-  invalidatedAt: z21.number().finite().nullable().default(null),
-  sourceHash: z21.string().min(1),
-  supersededBy: z21.string().min(1).nullable().default(null)
+  confidence: z22.number().min(0).max(1),
+  validFrom: z22.number().finite(),
+  validUntil: z22.number().finite().nullable().default(null),
+  createdAt: z22.number().finite(),
+  invalidatedAt: z22.number().finite().nullable().default(null),
+  sourceHash: z22.string().min(1),
+  supersededBy: z22.string().min(1).nullable().default(null)
 }).strict();
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z21.literal("fact"),
-  subject: z21.string().min(1),
-  predicate: z21.string().min(1),
-  object: z21.string().min(1),
-  category: z21.string().min(1).nullable().default(null)
+  kind: z22.literal("fact"),
+  subject: z22.string().min(1),
+  predicate: z22.string().min(1),
+  object: z22.string().min(1),
+  category: z22.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z21.literal("preference"),
-  category: z21.string().min(1),
-  preference: z21.string().min(1),
-  context: z21.string().min(1).nullable().default(null),
-  lastAccessedAt: z21.number().finite().nullable().default(null),
-  accessCount: z21.number().int().min(0).default(0)
+  kind: z22.literal("preference"),
+  category: z22.string().min(1),
+  preference: z22.string().min(1),
+  context: z22.string().min(1).nullable().default(null),
+  lastAccessedAt: z22.number().finite().nullable().default(null),
+  accessCount: z22.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z21.literal("entity"),
-  canonicalName: z21.string().min(1),
-  type: z21.string().min(1),
-  aliases: z21.array(z21.string().min(1)).default([])
+  kind: z22.literal("entity"),
+  canonicalName: z22.string().min(1),
+  type: z22.string().min(1),
+  aliases: z22.array(z22.string().min(1)).default([])
 });
 var RelationSchema = MemoryBaseSchema.extend({
-  kind: z21.literal("relation"),
-  from: z21.string().min(1),
-  to: z21.string().min(1),
-  predicate: z21.string().min(1),
-  annotation: z21.string().min(1).nullable().default(null)
+  kind: z22.literal("relation"),
+  from: z22.string().min(1),
+  to: z22.string().min(1),
+  predicate: z22.string().min(1),
+  annotation: z22.string().min(1).nullable().default(null)
 });
-var MemoryRecordSchema = z21.discriminatedUnion("kind", [
+var MemoryRecordSchema = z22.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema,
   RelationSchema
 ]);
-var RecallQuerySchema = z21.object({
+var RecallQuerySchema = z22.object({
   ownerKey: OwnerKeySchema,
-  kinds: z21.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z21.number().finite().nullable().default(null),
-  limit: z21.number().int().positive().default(8),
-  minSimilarity: z21.number().min(0).max(1).default(0.2),
-  includeShared: z21.boolean().default(true)
+  kinds: z22.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z22.number().finite().nullable().default(null),
+  limit: z22.number().int().positive().default(8),
+  minSimilarity: z22.number().min(0).max(1).default(0.2),
+  includeShared: z22.boolean().default(true)
 }).strict();
 
 // src/memory/rank.ts
@@ -13205,42 +14577,42 @@ function buildMemoryInjector(deps, policy) {
 
 // src/plugin/memoryTool.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/memory/extract.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var REDACTED = "[redacted]";
-var RawFactSchema = z22.object({
-  subject: z22.string().min(1),
-  predicate: z22.string().min(1),
-  object: z22.string().min(1),
-  category: z22.string().min(1).nullable().optional(),
-  confidence: z22.number().min(0).max(1).optional()
+var RawFactSchema = z23.object({
+  subject: z23.string().min(1),
+  predicate: z23.string().min(1),
+  object: z23.string().min(1),
+  category: z23.string().min(1).nullable().optional(),
+  confidence: z23.number().min(0).max(1).optional()
 });
-var RawPreferenceSchema = z22.object({
-  category: z22.string().min(1),
-  preference: z22.string().min(1),
-  context: z22.string().min(1).nullable().optional(),
-  confidence: z22.number().min(0).max(1).optional()
+var RawPreferenceSchema = z23.object({
+  category: z23.string().min(1),
+  preference: z23.string().min(1),
+  context: z23.string().min(1).nullable().optional(),
+  confidence: z23.number().min(0).max(1).optional()
 });
-var RawEntitySchema = z22.object({
-  canonicalName: z22.string().min(1),
-  type: z22.string().min(1),
-  aliases: z22.array(z22.string().min(1)).optional(),
-  confidence: z22.number().min(0).max(1).optional()
+var RawEntitySchema = z23.object({
+  canonicalName: z23.string().min(1),
+  type: z23.string().min(1),
+  aliases: z23.array(z23.string().min(1)).optional(),
+  confidence: z23.number().min(0).max(1).optional()
 });
-var RawRelationSchema = z22.object({
-  from: z22.string().min(1),
-  to: z22.string().min(1),
-  predicate: z22.string().min(1),
-  annotation: z22.string().min(1).nullable().optional(),
-  confidence: z22.number().min(0).max(1).optional()
+var RawRelationSchema = z23.object({
+  from: z23.string().min(1),
+  to: z23.string().min(1),
+  predicate: z23.string().min(1),
+  annotation: z23.string().min(1).nullable().optional(),
+  confidence: z23.number().min(0).max(1).optional()
 }).strict();
-var RawExtractionSchema = z22.object({
-  facts: z22.array(RawFactSchema).default([]),
-  preferences: z22.array(RawPreferenceSchema).default([]),
-  entities: z22.array(RawEntitySchema).default([]),
-  relations: z22.array(RawRelationSchema).default([])
+var RawExtractionSchema = z23.object({
+  facts: z23.array(RawFactSchema).default([]),
+  preferences: z23.array(RawPreferenceSchema).default([]),
+  entities: z23.array(RawEntitySchema).default([]),
+  relations: z23.array(RawRelationSchema).default([])
 });
 var DEFAULT_CONFIDENCE = 0.6;
 var SYSTEM_PROMPT = [
@@ -13494,13 +14866,13 @@ var memoryToolMessages = {
 
 // src/plugin/memoryTool.ts
 var SCRIBE_ROLE_ID = "scribe";
-var MemoryMessageSchema = z23.object({
-  role: z23.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
-  content: z23.string().min(1).describe(memoryToolMessages.messageContentDescription)
+var MemoryMessageSchema = z24.object({
+  role: z24.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
+  content: z24.string().min(1).describe(memoryToolMessages.messageContentDescription)
 }).strict();
-var MemoryWritePayloadSchema = z23.object({
-  messages: z23.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
-  roleID: z23.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
+var MemoryWritePayloadSchema = z24.object({
+  messages: z24.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
+  roleID: z24.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
 }).strict();
 function createMemoryTool(deps) {
   return tool3({
@@ -13625,10 +14997,10 @@ function createOrchestratedModelOwnership() {
 
 // src/plugin/orchestrateTool.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/orchestrator/coordinator.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/orchestrator/nodeIteration.ts
 var DEFAULT_MAX_RETRIES = 2;
@@ -14091,9 +15463,12 @@ function buildRecord(input, decision2, subsession, deps, decisionID, batchID) {
   if (subsession.failureStage !== undefined) {
     record.failureStage = subsession.failureStage;
   }
+  if (subsession.normalizedFailure !== undefined) {
+    record.normalizedFailure = subsession.normalizedFailure;
+  }
   return record;
 }
-var TelemetryFailureClassSchema = z24.enum([
+var TelemetryFailureClassSchema = z25.enum([
   "create-rejected",
   "create-no-id",
   "prompt-rejected",
@@ -14241,7 +15616,9 @@ function correlatedCostRecordToRouteEvent(record) {
   if (record.taskID !== undefined) {
     event.taskID = record.taskID;
   }
-  if (record.failureReason !== undefined) {
+  if (record.normalizedFailure !== undefined) {
+    event.failureReason = record.normalizedFailure.failureClass;
+  } else if (record.failureReason !== undefined) {
     event.failureReason = classifyFailureForTelemetry(record.failureReason, record.failureStage);
   }
   if (record.failureStage !== undefined) {
@@ -14269,6 +15646,48 @@ async function safeEmit(sink, event) {
     await sink.emit(event);
   } catch {}
 }
+async function recordLifecycle(lifecycle, event) {
+  if (lifecycle === undefined) {
+    return;
+  }
+  await lifecycle.recorder.append(event);
+}
+function lifecycleFailureFor(subsession) {
+  const normalized = subsession.normalizedFailure;
+  if (normalized !== undefined) {
+    return {
+      class: normalized.failureClass,
+      retryable: normalized.retryable,
+      ...normalized.statusCode === undefined ? {} : { statusCode: normalized.statusCode }
+    };
+  }
+  if (subsession.failureStage === "report") {
+    return {
+      class: subsession.failureReason === REPORT_NOT_DURABLE_REASON ? "report-not-durable" : "report-incomplete",
+      retryable: true
+    };
+  }
+  if (subsession.retrySafe === false) {
+    return { class: "prompt-stop-unconfirmed", retryable: false };
+  }
+  if (subsession.failureReason === undefined) {
+    return;
+  }
+  return {
+    class: classifyFailureForTelemetry(subsession.failureReason, subsession.failureStage),
+    retryable: failedPassDisposition(subsession) !== "terminal"
+  };
+}
+function lifecycleOutcomeFor(subsession) {
+  if (subsession.success) {
+    return "succeeded";
+  }
+  const failureClass = lifecycleFailureFor(subsession)?.class;
+  if (failureClass === "cancelled" || failureClass === "interrupted" || failureClass === "unknown") {
+    return failureClass;
+  }
+  return "failed";
+}
 function buildQueueEvent(observation, sessionID, ts, correlation) {
   const event = {
     v: EVENT_SCHEMA_VERSION,
@@ -14303,7 +15722,7 @@ function buildNodeBudgetExhaustedEvent(roleID, passCount, sessionID, ts) {
     passCount
   };
 }
-async function runRoleTaskWithCorrelation(input, deps, correlation, batch, routed, handoff, reportBatchID) {
+async function runRoleTaskWithCorrelation(input, deps, correlation, batch, routed, handoff, reportBatchID, attemptLifecycle) {
   const role = roleFor(input);
   if (routed.routeKind === "blocked") {
     throw new Error(coordinatorRoutingBlocked(input.roleID, routed.blockReason));
@@ -14343,9 +15762,48 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
     statusPollMs: deps.statusPollMs,
     now: deps.now,
     delay: deps.delay,
-    ...deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs }
+    ...deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs },
+    ...attemptLifecycle === undefined ? {} : {
+      onSessionCreated: (sessionID) => recordLifecycle(attemptLifecycle.lifecycle, {
+        type: "session.created",
+        operationID: attemptLifecycle.operationID,
+        taskID: attemptLifecycle.taskID,
+        attemptID: attemptLifecycle.attemptID,
+        attempt: attemptLifecycle.attempt,
+        modelIndex: attemptLifecycle.modelIndex,
+        retryIndex: attemptLifecycle.retryIndex,
+        sessionID,
+        ...input.parentSessionID === undefined ? {} : { parentSessionID: input.parentSessionID }
+      })
+    }
   };
   const runtimeId = selection.runtimeId;
+  if (attemptLifecycle !== undefined) {
+    await recordLifecycle(attemptLifecycle.lifecycle, {
+      type: "attempt.model-selected",
+      operationID: attemptLifecycle.operationID,
+      taskID: attemptLifecycle.taskID,
+      attemptID: attemptLifecycle.attemptID,
+      attempt: attemptLifecycle.attempt,
+      modelIndex: attemptLifecycle.modelIndex,
+      retryIndex: attemptLifecycle.retryIndex,
+      decisionID: correlation.decisionID,
+      model: decision2.selected,
+      routeKind: decision2.routeKind === "local" ? "local" : "frontier",
+      selectionCause: attemptLifecycle.selectionCause,
+      ...runtimeId === undefined ? {} : { runtimeID: runtimeId }
+    });
+    await recordLifecycle(attemptLifecycle.lifecycle, {
+      type: "attempt.queued",
+      operationID: attemptLifecycle.operationID,
+      taskID: attemptLifecycle.taskID,
+      attemptID: attemptLifecycle.attemptID,
+      attempt: attemptLifecycle.attempt,
+      modelIndex: attemptLifecycle.modelIndex,
+      retryIndex: attemptLifecycle.retryIndex,
+      ...runtimeId === undefined ? {} : { runtimeID: runtimeId }
+    });
+  }
   let release;
   let queueObservation;
   if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
@@ -14368,6 +15826,17 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
     };
   }
   try {
+    if (attemptLifecycle !== undefined) {
+      await recordLifecycle(attemptLifecycle.lifecycle, {
+        type: "attempt.started",
+        operationID: attemptLifecycle.operationID,
+        taskID: attemptLifecycle.taskID,
+        attemptID: attemptLifecycle.attemptID,
+        attempt: attemptLifecycle.attempt,
+        modelIndex: attemptLifecycle.modelIndex,
+        retryIndex: attemptLifecycle.retryIndex
+      });
+    }
     const subsession = await runSubsession(deps.client, request, subsessionDeps);
     const record = buildRecord(input, decision2, subsession, deps, correlation.decisionID, correlation.batchID);
     await safeEmit(deps.sink, correlatedCostRecordToRouteEvent(record));
@@ -14515,6 +15984,9 @@ function failedPassDisposition(subsession) {
     return "terminal";
   if (subsession.failureStage === "report")
     return "retry-incomplete";
+  if (subsession.normalizedFailure !== undefined) {
+    return subsession.normalizedFailure.retryable ? "retry-transport" : "terminal";
+  }
   const failureReason = subsession.failureReason ?? "";
   const causeClass = classifyFailureForTelemetry(failureReason, undefined);
   if (causeClass === "prompt-auth" || causeClass === "prompt-content-filter" || causeClass === "prompt-validation") {
@@ -14529,7 +16001,59 @@ function failedPassDisposition(subsession) {
   }
   return "terminal";
 }
-async function runNodeWithIteration(input, deps, correlation, batch) {
+function lifecycleSelectionCause(attempt, modelIndex, retryReason, escalationReason) {
+  if (attempt === 0) {
+    return "initial";
+  }
+  if (modelIndex > 0) {
+    return escalationReason === "transport" ? "fallback-transport" : "fallback-incomplete";
+  }
+  return retryReason === "transport" ? "retry-transport" : "retry-incomplete";
+}
+function lifecycleContinuation(disposition, pass, passBudget, modelIndex, candidateCount) {
+  if (disposition === "terminal") {
+    return "none";
+  }
+  if (pass < passBudget) {
+    return "retry-same-model";
+  }
+  return modelIndex + 1 < candidateCount ? "fallback-next-model" : "none";
+}
+async function recordAttemptTerminal(attempt, result, continuation, succeeded) {
+  if (attempt === undefined) {
+    return;
+  }
+  const failure = succeeded ? undefined : lifecycleFailureFor(result.subsession) ?? {
+    class: "report-incomplete",
+    retryable: true
+  };
+  await recordLifecycle(attempt.lifecycle, {
+    type: "attempt.terminal",
+    operationID: attempt.operationID,
+    taskID: attempt.taskID,
+    attemptID: attempt.attemptID,
+    attempt: attempt.attempt,
+    modelIndex: attempt.modelIndex,
+    retryIndex: attempt.retryIndex,
+    outcome: succeeded ? "succeeded" : result.subsession.success ? "failed" : lifecycleOutcomeFor(result.subsession),
+    continuation,
+    ...result.subsession.sessionID === undefined ? {} : { sessionID: result.subsession.sessionID },
+    ...failure === undefined ? {} : { failure }
+  });
+}
+async function recordOperationTerminal(lifecycle, input, batchID, result, attemptCount) {
+  const failure = lifecycleFailureFor(result.subsession);
+  await recordLifecycle(lifecycle, {
+    type: "operation.terminal",
+    operationID: operationID(batchID, input.roleID),
+    taskID: input.taskID ?? batchID,
+    outcome: lifecycleOutcomeFor(result.subsession),
+    attemptCount,
+    ...result.subsession.sessionID === undefined ? {} : { finalSessionID: result.subsession.sessionID },
+    ...failure === undefined ? {} : { failure }
+  });
+}
+async function runNodeWithIteration(input, deps, correlation, batch, lifecycle) {
   if (getRoleProfile(input.roleID, input.config.orchestrator?.roles) === undefined) {
     warnUnknownRole(input.roleID, deps.warn, deps.warnedRoles);
   }
@@ -14539,9 +16063,20 @@ async function runNodeWithIteration(input, deps, correlation, batch) {
     usd: 0,
     frontierTokens: 0
   });
+  const lifecycleBatchID = correlation.batchID ?? lifecycle?.recorder.runID;
   const executionPolicy = roleCapablePolicy(input, role);
   const plan2 = chooseModel(routingInput(input, role, executionPolicy, initialBudget));
   if (plan2.routeKind === "blocked") {
+    if (lifecycleBatchID !== undefined) {
+      await recordLifecycle(lifecycle, {
+        type: "operation.terminal",
+        operationID: operationID(lifecycleBatchID, input.roleID),
+        taskID: input.taskID ?? lifecycleBatchID,
+        outcome: "blocked",
+        attemptCount: 0,
+        failure: { class: "routing-blocked", retryable: false }
+      });
+    }
     throw new Error(coordinatorRoutingBlocked(input.roleID, plan2.blockReason));
   }
   const candidates = uniqueModels([plan2.selected, ...plan2.fallbackChain]);
@@ -14566,7 +16101,29 @@ async function runNodeWithIteration(input, deps, correlation, batch) {
             continue modelLoop;
           }
           if (lastResult !== undefined) {
-            return withFailure(lastResult, routed.blockReason ?? REPORT_INCOMPLETE_REASON, "report");
+            const blocked = withFailure(lastResult, routed.blockReason ?? REPORT_INCOMPLETE_REASON, "report");
+            if (lifecycleBatchID !== undefined) {
+              await recordLifecycle(lifecycle, {
+                type: "operation.terminal",
+                operationID: operationID(lifecycleBatchID, input.roleID),
+                taskID: input.taskID ?? lifecycleBatchID,
+                outcome: "failed",
+                attemptCount: totalPasses,
+                ...blocked.subsession.sessionID === undefined ? {} : { finalSessionID: blocked.subsession.sessionID },
+                failure: { class: "budget-exhausted", retryable: false }
+              });
+            }
+            return blocked;
+          }
+          if (lifecycleBatchID !== undefined) {
+            await recordLifecycle(lifecycle, {
+              type: "operation.terminal",
+              operationID: operationID(lifecycleBatchID, input.roleID),
+              taskID: input.taskID ?? lifecycleBatchID,
+              outcome: "blocked",
+              attemptCount: 0,
+              failure: { class: "routing-blocked", retryable: false }
+            });
           }
           throw new Error(coordinatorRoutingBlocked(input.roleID, routed.blockReason));
         }
@@ -14589,7 +16146,17 @@ async function runNodeWithIteration(input, deps, correlation, batch) {
         }).reportPath;
         const resolvedReportPath = resolveReportProbePath(input.directory, reportPath);
         const before = await deps.readReportArtifact(resolvedReportPath);
-        let result = await runRoleTaskWithCorrelation(input, deps, attemptCorrelation, batch, attemptDecision, modelIndex > 0, reportBatchID);
+        const attemptLifecycle = lifecycle === undefined || lifecycleBatchID === undefined ? undefined : {
+          lifecycle,
+          operationID: operationID(lifecycleBatchID, input.roleID),
+          taskID: input.taskID ?? lifecycleBatchID,
+          attemptID: attemptID(operationID(lifecycleBatchID, input.roleID), totalPasses),
+          attempt: totalPasses,
+          modelIndex,
+          retryIndex: pass - 1,
+          selectionCause: lifecycleSelectionCause(totalPasses, modelIndex, retryReason, escalationReason)
+        };
+        let result = await runRoleTaskWithCorrelation(input, deps, attemptCorrelation, batch, attemptDecision, modelIndex > 0, reportBatchID, attemptLifecycle);
         totalPasses += 1;
         spend = {
           usd: attemptDecision.estimatedCostUSD === null ? spend.usd : spend.usd + attemptDecision.estimatedCostUSD,
@@ -14599,10 +16166,19 @@ async function runNodeWithIteration(input, deps, correlation, batch) {
         result = assessment.result;
         lastResult = result;
         if (assessment.done) {
+          await recordAttemptTerminal(attemptLifecycle, result, "none", true);
+          if (lifecycleBatchID !== undefined) {
+            await recordOperationTerminal(lifecycle, input, lifecycleBatchID, result, totalPasses);
+          }
           return result;
         }
         const disposition = failedPassDisposition(result.subsession);
+        const continuation = lifecycleContinuation(disposition, pass, passBudget, modelIndex, candidates.length);
+        await recordAttemptTerminal(attemptLifecycle, result, continuation, false);
         if (disposition === "terminal") {
+          if (lifecycleBatchID !== undefined) {
+            await recordOperationTerminal(lifecycle, input, lifecycleBatchID, result, totalPasses);
+          }
           return result;
         }
         retryReason = disposition === "retry-transport" ? "transport" : "incomplete";
@@ -14617,14 +16193,34 @@ async function runNodeWithIteration(input, deps, correlation, batch) {
   }
   const sessionID = recordSessionID(input, lastResult.subsession) ?? correlation.batchID ?? input.roleID;
   await safeEmit(deps.sink, buildNodeBudgetExhaustedEvent(input.roleID, totalPasses, sessionID, deps.now()));
+  if (lifecycleBatchID !== undefined) {
+    await recordOperationTerminal(lifecycle, input, lifecycleBatchID, lastResult, totalPasses);
+  }
   return lastResult;
 }
-async function runRoleTasks(inputs, deps) {
-  const batchID = deps.newDecisionID();
+async function runRoleTasks(inputs, deps, options = {}) {
+  const batchID = options.batchID ?? deps.newDecisionID();
+  const lifecycle = options.lifecycle;
   const planned = inputs.map((input) => ({
     input,
     correlation: { decisionID: deps.newDecisionID(), batchID }
   }));
+  if (lifecycle !== undefined) {
+    for (const input of inputs) {
+      const role = roleFor(input);
+      const agentID = input.agentOverride ?? role.opencodeAgent;
+      await recordLifecycle(lifecycle, {
+        type: "operation.queued",
+        operationID: operationID(batchID, input.roleID),
+        taskID: input.taskID ?? batchID,
+        kind: "role",
+        roleID: input.roleID,
+        ...agentID === undefined ? {} : { agentID },
+        parentOperationID: lifecycle.rootOperationID,
+        dependsOnOperationIDs: (input.dependsOn ?? []).map((roleID) => operationID(batchID, roleID))
+      });
+    }
+  }
   const batch = await resolveBatchReachability(inputs, deps);
   const meeting = buildMeetingEvent(inputs, batchID, planned.map((entry) => entry.correlation.decisionID), deps.now());
   if (meeting !== undefined) {
@@ -14643,6 +16239,14 @@ async function runRoleTasks(inputs, deps) {
         runnable.push(input);
       } else {
         cancelled.push(input.roleID);
+        await recordLifecycle(lifecycle, {
+          type: "operation.terminal",
+          operationID: operationID(batchID, input.roleID),
+          taskID: input.taskID ?? batchID,
+          outcome: "blocked",
+          attemptCount: 0,
+          failure: { class: "dependency-failed", retryable: false }
+        });
       }
     }
     const waveResults = await Promise.all(runnable.map((input) => {
@@ -14650,7 +16254,7 @@ async function runRoleTasks(inputs, deps) {
       if (correlation === undefined) {
         throw new Error(`missing correlation for ${input.roleID}`);
       }
-      return runNodeWithIteration(input, deps, correlation, batch);
+      return runNodeWithIteration(input, deps, correlation, batch, lifecycle);
     }));
     for (const result of waveResults) {
       allResults.push(result);
@@ -14659,6 +16263,20 @@ async function runRoleTasks(inputs, deps) {
       }
     }
   }
+  const firstFailure = allResults.find((result) => !result.subsession.success);
+  const succeededRun = cancelled.length === 0 && allResults.length === inputs.length && firstFailure === undefined;
+  const runOutcome = succeededRun ? "succeeded" : firstFailure === undefined ? "failed" : lifecycleOutcomeFor(firstFailure.subsession);
+  await recordLifecycle(lifecycle, {
+    type: "run.terminal",
+    outcome: runOutcome,
+    operationCount: inputs.length,
+    ...succeededRun ? {} : {
+      failure: firstFailure === undefined ? { class: "dependency-failed", retryable: false } : lifecycleFailureFor(firstFailure.subsession) ?? {
+        class: "unknown",
+        retryable: false
+      }
+    }
+  });
   return { batchID, results: allResults, cancelled };
 }
 
@@ -14666,7 +16284,7 @@ async function runRoleTasks(inputs, deps) {
 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 = z25.string().min(1).superRefine((roleID, ctx) => {
+var RoleIDSchema = z26.string().min(1).superRefine((roleID, ctx) => {
   if (!SAFE_ROLE_ID.test(roleID)) {
     ctx.addIssue({
       code: "custom",
@@ -14674,16 +16292,16 @@ var RoleIDSchema = z25.string().min(1).superRefine((roleID, ctx) => {
     });
   }
 });
-var RoleAssignmentSchema = z25.object({
+var RoleAssignmentSchema = z26.object({
   roleID: RoleIDSchema.describe("Role identifier from the roster"),
-  prompt: z25.string().min(1).describe("Work prompt for this role"),
-  title: z25.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z25.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
+  prompt: z26.string().min(1).describe("Work prompt for this role"),
+  title: z26.string().min(1).optional().describe("Human-readable title"),
+  dependsOn: z26.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
 }).strict();
-var OrchestratePayloadSchema = z25.object({
-  assignments: z25.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z25.string().min(1).optional().describe("Parent session for subsessions"),
-  directory: z25.string().min(1).optional().describe("Working directory override")
+var OrchestratePayloadSchema = z26.object({
+  assignments: z26.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
+  parentSessionID: z26.string().min(1).optional().describe("Parent session for subsessions"),
+  directory: z26.string().min(1).optional().describe("Working directory override")
 }).strict();
 function validateAssignmentDependencies(assignments) {
   const ids = new Set;
@@ -14741,17 +16359,118 @@ function validateAssignmentDependencies(assignments) {
   }
   return;
 }
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nestedRecord2(value, key) {
+  const nested = value[key];
+  return isRecord5(nested) ? nested : undefined;
+}
+function numberField(records, keys) {
+  for (const record of records) {
+    for (const key of keys) {
+      const value = record[key];
+      if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+      }
+    }
+  }
+  return;
+}
+function booleanField(records, keys) {
+  for (const record of records) {
+    for (const key of keys) {
+      const value = record[key];
+      if (typeof value === "boolean") {
+        return value;
+      }
+    }
+  }
+  return;
+}
+function boundedErrorTokens(records) {
+  const tokens = [];
+  for (const record of records) {
+    for (const key of ["name", "code", "type", "message"]) {
+      const value = record[key];
+      if (typeof value === "string" && value.length <= 100) {
+        tokens.push(value.toLowerCase());
+      }
+    }
+  }
+  return tokens.join(" ");
+}
+function promptFailureClass(statusCode, tokens) {
+  if (statusCode === 401 || statusCode === 403 || /\bauth(?:entication|orization)?\b|unauthorized|forbidden/u.test(tokens)) {
+    return "prompt-auth";
+  }
+  if (/content[-_ ]?filter|moderation|safety/u.test(tokens)) {
+    return "prompt-content-filter";
+  }
+  if (/context[-_ ]?(?:length|window)|token[-_ ]?limit/u.test(tokens)) {
+    return "prompt-context-length";
+  }
+  if (statusCode === 429 || /rate[-_ ]?limit|quota/u.test(tokens)) {
+    return "prompt-rate-limited";
+  }
+  if (statusCode === 408 || /timeout|timedout|deadline/u.test(tokens)) {
+    return "prompt-timeout";
+  }
+  if (/connection|network|socket|econnrefused|econnreset|enotfound/u.test(tokens)) {
+    return "prompt-connection";
+  }
+  if (statusCode === 400 || statusCode === 422 || /validation|invalid[-_ ]?request|bad[-_ ]?request/u.test(tokens)) {
+    return "prompt-validation";
+  }
+  if (statusCode !== undefined && statusCode >= 500 && statusCode <= 599) {
+    return "prompt-server";
+  }
+  return "unknown";
+}
+function retryableFailure(failureClass, statusCode, declared) {
+  if (failureClass === "prompt-auth" || failureClass === "prompt-content-filter" || failureClass === "prompt-context-length" || failureClass === "prompt-validation") {
+    return false;
+  }
+  if (declared !== undefined) {
+    return declared;
+  }
+  return failureClass === "prompt-timeout" || failureClass === "prompt-rate-limited" || failureClass === "prompt-connection" || failureClass === "prompt-server" || statusCode !== undefined && statusCode >= 500 && statusCode <= 599;
+}
+function normalizeSdkSessionFailure(error, stage) {
+  const root = isRecord5(error) ? error : {};
+  const data = nestedRecord2(root, "data");
+  const nestedError = nestedRecord2(root, "error");
+  const records = [
+    root,
+    ...data === undefined ? [] : [data],
+    ...nestedError === undefined ? [] : [nestedError]
+  ];
+  const statusCode = numberField(records, ["statusCode", "status"]);
+  const declaredRetryable = booleanField(records, ["isRetryable", "retryable"]);
+  const failureClass = stage === "create" ? "create-rejected" : promptFailureClass(statusCode, boundedErrorTokens(records));
+  return {
+    kind: "normalized-session-failure",
+    failureClass,
+    retryable: retryableFailure(failureClass, statusCode, declaredRetryable),
+    ...statusCode === undefined ? {} : { statusCode }
+  };
+}
+function nestedAssistantFailure(data) {
+  if (!isRecord5(data)) {
+    return;
+  }
+  return nestedRecord2(data, "info")?.error;
+}
 function adaptSdkClient(sdk, orchestratedModelOwnership) {
   return {
     session: {
       create: async (args) => {
         const result = await sdk.session.create(args);
         const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
         if (result.error !== undefined) {
-          out.error = result.error;
+          out.error = normalizeSdkSessionFailure(result.error, "create");
+        } else if (result.data !== undefined) {
+          out.data = result.data;
         }
         return out;
       },
@@ -14764,11 +16483,15 @@ function adaptSdkClient(sdk, orchestratedModelOwnership) {
         try {
           const result = await sdk.session.prompt(args);
           const out = {};
-          if (result.data !== undefined) {
-            out.data = result.data;
-          }
           if (result.error !== undefined) {
-            out.error = result.error;
+            out.error = normalizeSdkSessionFailure(result.error, "prompt");
+          } else {
+            const nestedFailure = nestedAssistantFailure(result.data);
+            if (nestedFailure !== undefined) {
+              out.error = normalizeSdkSessionFailure(nestedFailure, "prompt");
+            } else if (result.data !== undefined) {
+              out.data = result.data;
+            }
           }
           return out;
         } finally {
@@ -14778,22 +16501,20 @@ function adaptSdkClient(sdk, orchestratedModelOwnership) {
       abort: async (args) => {
         const result = await sdk.session.abort(args);
         const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
         if (result.error !== undefined) {
-          out.error = result.error;
+          out.error = normalizeSdkSessionFailure(result.error, "prompt");
+        } else if (result.data !== undefined) {
+          out.data = result.data;
         }
         return out;
       },
       status: async (args) => {
         const result = await sdk.session.status(args);
         const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
         if (result.error !== undefined) {
-          out.error = result.error;
+          out.error = normalizeSdkSessionFailure(result.error, "prompt");
+        } else if (result.data !== undefined) {
+          out.data = result.data;
         }
         return out;
       }
@@ -15208,6 +16929,8 @@ function createOrchestrateTool(deps) {
       if (depError !== undefined) {
         return dependencyValidationError(depError.code, depError.detail);
       }
+      let activeLifecycleRecorder;
+      let lifecycleStatus;
       try {
         const rosterEntries = await deps.rosterEntries();
         const rosterRoleIDs = rosterEntries.length === 0 ? EMPTY_ROLE_ID_SET : new Set(rosterEntries.map((entry) => entry.roleID));
@@ -15224,6 +16947,27 @@ function createOrchestrateTool(deps) {
             return missingAgentDefinition(agentName, input.roleID);
           }
         }
+        const batchID = deps.newDecisionID();
+        if (deps.lifecycleRecorder !== undefined) {
+          const rootOperationID = operationID(batchID, "openteam");
+          const begun = await deps.lifecycleRecorder.beginRun({
+            runID: batchID,
+            source: "plugin",
+            executionAuthority: "coordinator",
+            root: {
+              operationID: rootOperationID,
+              taskID: batchID,
+              kind: "coordinator",
+              roleID: "openteam",
+              agentID: "openteam",
+              ...parsed.data.parentSessionID === undefined ? {} : { sessionID: parsed.data.parentSessionID }
+            }
+          });
+          lifecycleStatus = begun.status;
+          if (begun.ok) {
+            activeLifecycleRecorder = begun.recorder;
+          }
+        }
         const coordinatorDeps = {
           client: deps.client,
           sink: deps.sink,
@@ -15242,7 +16986,16 @@ function createOrchestrateTool(deps) {
           delay: deps.delay,
           ...deps.timeoutMs === undefined ? {} : { timeoutMs: deps.timeoutMs }
         };
-        const batch = await runRoleTasks(inputs, coordinatorDeps);
+        const batch = await runRoleTasks(inputs, coordinatorDeps, {
+          batchID,
+          ...activeLifecycleRecorder === undefined ? {} : {
+            lifecycle: {
+              recorder: activeLifecycleRecorder,
+              rootOperationID: operationID(batchID, "openteam")
+            }
+          }
+        });
+        lifecycleStatus = activeLifecycleRecorder?.status() ?? lifecycleStatus;
         const projected = projectResults(batch.results, batch.cancelled);
         const shadowResult = await runShadowProducer(deps, parsed.data, batch);
         const base = formatResult(projected);
@@ -15250,15 +17003,26 @@ function createOrchestrateTool(deps) {
         const withAdvisory = advisory === undefined ? base : `${base}
 
 ${advisory}`;
+        const recordingAdvisory = lifecycleStatus === undefined ? undefined : lifecycleRecordingAdvisory(lifecycleStatus);
+        const withRecordingStatus = recordingAdvisory === undefined ? withAdvisory : `${withAdvisory}
+
+⚠ ${recordingAdvisory}`;
         if (!shadowResult.ok) {
-          return `${withAdvisory}
+          return `${withRecordingStatus}
 ⚠ shadow observation failed: ${shadowResult.failureClass}`;
         }
-        return withAdvisory;
+        return withRecordingStatus;
       } catch (error) {
+        if (activeLifecycleRecorder !== undefined) {
+          lifecycleStatus = await activeLifecycleRecorder.release();
+        }
         const reason = error instanceof Error ? error.message : String(error);
         const result = { kind: "error", reason };
-        return formatResult(result);
+        const base = formatResult(result);
+        const advisory = lifecycleStatus === undefined ? undefined : lifecycleRecordingAdvisory(lifecycleStatus);
+        return advisory === undefined ? base : `${base}
+
+⚠ ${advisory}`;
       }
     }
   });
@@ -15266,7 +17030,7 @@ ${advisory}`;
 
 // src/plugin/registerCastTool.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/orchestrator/rosterPersistence.ts
 function rosterFence(roster) {
@@ -15301,13 +17065,13 @@ async function persistRosterPreservingProse(storage, roster, path4 = OPENTEAM_RO
 }
 
 // src/plugin/registerCastTool.ts
-var CastEntrySchema = z26.object({
-  roleID: z26.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
-  agentName: z26.string().min(1).describe("Themed character name assigned to the role")
+var CastEntrySchema = z27.object({
+  roleID: z27.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
+  agentName: z27.string().min(1).describe("Themed character name assigned to the role")
 }).strict();
-var RegisterCastPayloadSchema = z26.object({
-  universe: z26.string().min(1).describe("Casting universe for this roster"),
-  entries: z26.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
+var RegisterCastPayloadSchema = z27.object({
+  universe: z27.string().min(1).describe("Casting universe for this roster"),
+  entries: z27.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
 }).strict();
 function offendingFields(error) {
   const fields = error.issues.flatMap((issue) => {
@@ -15489,12 +17253,12 @@ async function createBunSqliteDatabase(path4) {
 }
 
 // src/memory/embedText.ts
-function normalize(parts) {
+function normalize2(parts) {
   return parts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
 }
 function recordEmbeddingText(record) {
   if (record.kind === "fact") {
-    return normalize([
+    return normalize2([
       record.subject,
       record.predicate,
       record.object,
@@ -15502,21 +17266,21 @@ function recordEmbeddingText(record) {
     ]);
   }
   if (record.kind === "preference") {
-    return normalize([
+    return normalize2([
       record.category,
       record.preference,
       record.context ?? ""
     ]);
   }
   if (record.kind === "relation") {
-    return normalize([
+    return normalize2([
       record.from,
       record.predicate,
       record.to,
       record.annotation ?? ""
     ]);
   }
-  return normalize([record.canonicalName, record.type, ...record.aliases]);
+  return normalize2([record.canonicalName, record.type, ...record.aliases]);
 }
 
 // src/storage/index/memoryEmbeddings.ts
@@ -15596,6 +17360,799 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   }
 }
 
+// src/storage/lifecycle/fsLifecycleJournal.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  statSync,
+  unlinkSync as unlinkSync2
+} from "node:fs";
+import { join as join12, resolve as resolve7 } from "node:path";
+import { ZodError } from "zod";
+
+// src/storage/lifecycle/codec.ts
+import { z as z28 } from "zod";
+var LIFECYCLE_CODEC_VERSION = 1;
+var LIFECYCLE_GENESIS_DIGEST = sha256Hex("openteam/lifecycle-journal/genesis/v1");
+var NUL5 = "\x00";
+var NEWLINE2 = `
+`;
+var frameSchema = z28.object({
+  v: z28.literal(LIFECYCLE_CODEC_VERSION),
+  seq: z28.number().int().nonnegative(),
+  prev: z28.string().min(1),
+  sum: z28.string().min(1),
+  event: z28.unknown()
+}).strict();
+function canonical2(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonical2).join(",")}]`;
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key2, child]) => `${JSON.stringify(key2)}:${canonical2(child)}`).join(",")}}`;
+}
+function lifecycleFrameDigest(previousDigest, event) {
+  return sha256Hex(`${previousDigest}${NUL5}${canonical2(event)}`);
+}
+
+class LifecycleCodecError extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "LifecycleCodecError";
+    this.code = code;
+  }
+}
+function encodeLifecycleFrame(previousDigest, event) {
+  const digest = lifecycleFrameDigest(previousDigest, event);
+  return {
+    line: canonical2({
+      v: LIFECYCLE_CODEC_VERSION,
+      seq: event.seq,
+      prev: previousDigest,
+      sum: digest,
+      event
+    }),
+    digest
+  };
+}
+function encodeLifecycleJournal(events) {
+  let previousDigest = LIFECYCLE_GENESIS_DIGEST;
+  let encoded = "";
+  for (const event of events) {
+    const frame = encodeLifecycleFrame(previousDigest, event);
+    encoded += `${frame.line}${NEWLINE2}`;
+    previousDigest = frame.digest;
+  }
+  return encoded;
+}
+function decodeLifecycleJournal(text) {
+  const segments = text.split(NEWLINE2);
+  const trailing = segments.pop() ?? "";
+  const partialTail = trailing.length > 0;
+  const events = [];
+  let previousDigest = LIFECYCLE_GENESIS_DIGEST;
+  for (const [index, raw] of segments.entries()) {
+    let unknownFrame;
+    try {
+      unknownFrame = JSON.parse(raw);
+    } catch {
+      throw new LifecycleCodecError("bad-frame");
+    }
+    const parsedFrame = frameSchema.safeParse(unknownFrame);
+    if (!parsedFrame.success) {
+      const version = typeof unknownFrame === "object" && unknownFrame !== null && "v" in unknownFrame ? unknownFrame.v : undefined;
+      throw new LifecycleCodecError(version !== undefined && version !== LIFECYCLE_CODEC_VERSION ? "bad-version" : "bad-frame");
+    }
+    const frame = parsedFrame.data;
+    let event;
+    try {
+      event = parseLifecycleEvent(frame.event);
+    } catch {
+      throw new LifecycleCodecError("bad-frame");
+    }
+    if (frame.seq !== index || event.seq !== index) {
+      throw new LifecycleCodecError("bad-sequence");
+    }
+    if (frame.prev !== previousDigest) {
+      throw new LifecycleCodecError("chain-break");
+    }
+    if (frame.sum !== lifecycleFrameDigest(previousDigest, event)) {
+      throw new LifecycleCodecError("bad-checksum");
+    }
+    events.push(event);
+    previousDigest = frame.sum;
+  }
+  return { events, digest: previousDigest, partialTail };
+}
+
+// src/storage/lifecycle/fsLifecycleSupport.ts
+import { randomUUID } from "node:crypto";
+import {
+  appendFileSync,
+  closeSync as closeSync2,
+  existsSync as existsSync2,
+  fsyncSync as fsyncSync2,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync3,
+  readSync,
+  realpathSync as realpathSync2,
+  renameSync,
+  rmSync as rmSync2,
+  unlinkSync,
+  writeSync as writeSync2
+} from "node:fs";
+import { basename as basename2, dirname as dirname4, join as join11, relative as relative2, resolve as resolve6 } 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 {
+  kind;
+  constructor(kind) {
+    super(kind);
+    this.name = "LifecycleFsError";
+    this.kind = kind;
+  }
+}
+function isMissingFsError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isExistsFsError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function validateRunID(runID) {
+  if (!SAFE_RUN_ID.test(runID) || runID === "." || runID === "..") {
+    throw new LifecycleFsError("corrupt");
+  }
+}
+function resolvedLifecycleRoot(root) {
+  try {
+    const absolute = resolve6(root);
+    mkdirSync2(absolute, { recursive: true });
+    const rootStat = lstatSync2(absolute);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+      throw new LifecycleFsError("unavailable");
+    }
+    return realpathSync2.native(absolute);
+  } catch (error) {
+    if (error instanceof LifecycleFsError) {
+      throw error;
+    }
+    throw new LifecycleFsError("unavailable");
+  }
+}
+function directRunPath(root, runID) {
+  validateRunID(runID);
+  const path4 = join11(root, runID);
+  if (dirname4(path4) !== root || basename2(path4) !== runID) {
+    throw new LifecycleFsError("corrupt");
+  }
+  return path4;
+}
+function assertExistingSafeRun(root, runID) {
+  const path4 = directRunPath(root, runID);
+  let stats;
+  try {
+    stats = lstatSync2(path4);
+  } catch (error) {
+    if (isMissingFsError(error)) {
+      throw new LifecycleFsError("missing");
+    }
+    throw new LifecycleFsError("unavailable");
+  }
+  if (!stats.isDirectory() || stats.isSymbolicLink()) {
+    throw new LifecycleFsError("corrupt");
+  }
+  let real;
+  try {
+    real = realpathSync2.native(path4);
+  } catch {
+    throw new LifecycleFsError("unavailable");
+  }
+  const child = relative2(root, real);
+  if (child === "" || child.startsWith("..") || resolve6(root, child) !== real || dirname4(real) !== root) {
+    throw new LifecycleFsError("corrupt");
+  }
+  return real;
+}
+function assertSafeRegularFile(path4) {
+  let stats;
+  try {
+    stats = lstatSync2(path4);
+  } catch (error) {
+    if (isMissingFsError(error)) {
+      throw new LifecycleFsError("missing");
+    }
+    throw new LifecycleFsError("unavailable");
+  }
+  if (!stats.isFile() || stats.isSymbolicLink()) {
+    throw new LifecycleFsError("corrupt");
+  }
+}
+function readUtf8(path4) {
+  try {
+    assertSafeRegularFile(path4);
+    return readFileSync3(path4, "utf8");
+  } catch (error) {
+    if (error instanceof LifecycleFsError && error.kind === "missing") {
+      return;
+    }
+    throw error;
+  }
+}
+function writeDurable2(path4, content) {
+  const descriptor = openSync2(path4, "w");
+  try {
+    writeSync2(descriptor, content);
+    fsyncSync2(descriptor);
+  } finally {
+    closeSync2(descriptor);
+  }
+}
+function appendDurable2(path4, content) {
+  const descriptor = openSync2(path4, "a");
+  try {
+    appendFileSync(descriptor, content, "utf8");
+    fsyncSync2(descriptor);
+  } finally {
+    closeSync2(descriptor);
+  }
+}
+function writeDurableAtomically(path4, content) {
+  const temporary = join11(dirname4(path4), `.${basename2(path4)}.${randomUUID()}.next`);
+  try {
+    writeDurable2(temporary, content);
+    renameSync(temporary, path4);
+  } finally {
+    rmSync2(temporary, { force: true });
+  }
+}
+function readLockContents(path4) {
+  if (!existsSync2(path4)) {
+    return;
+  }
+  const descriptor = openSync2(path4, "r");
+  try {
+    const buffer = Buffer.alloc(128);
+    const bytes = readSync(descriptor, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytes).toString("utf8");
+  } finally {
+    closeSync2(descriptor);
+  }
+}
+function withRunMutationLock(runDir, mutate) {
+  const lockPath = join11(runDir, ".mutation-lock");
+  const lockToken = randomUUID();
+  let descriptor;
+  try {
+    descriptor = openSync2(lockPath, "wx");
+  } catch (error) {
+    if (isExistsFsError(error)) {
+      throw new LifecycleFsError("conflict");
+    }
+    throw new LifecycleFsError("unavailable");
+  }
+  try {
+    writeSync2(descriptor, lockToken);
+    fsyncSync2(descriptor);
+  } finally {
+    closeSync2(descriptor);
+  }
+  try {
+    return mutate();
+  } finally {
+    try {
+      if (readLockContents(lockPath) === lockToken) {
+        unlinkSync(lockPath);
+      }
+    } catch {}
+  }
+}
+
+// src/storage/lifecycle/fsLifecycleJournal.ts
+var EVENTS_FILE = "events.ndjson";
+var METADATA_FILE = "run.json";
+var OWNER_FILE2 = "owner";
+var KNOWN_RUN_FILES = new Set([EVENTS_FILE, METADATA_FILE, OWNER_FILE2]);
+function failure(code, options = {}) {
+  const { recoverable = false, ...context } = options;
+  return { code, recoverable, ...context };
+}
+function ok(value) {
+  return { ok: true, value };
+}
+function failed(error) {
+  return { ok: false, error };
+}
+function mapFsFailure(error, runID) {
+  const context = runID === undefined ? {} : { runID };
+  if (error instanceof ZodError || error instanceof RedactionError) {
+    return failure("corrupt", context);
+  }
+  if (error instanceof LifecycleFsError) {
+    switch (error.kind) {
+      case "missing":
+        return failure("not-found", context);
+      case "conflict":
+        return failure("writer-conflict", { recoverable: true, ...context });
+      case "corrupt":
+        return failure("corrupt", context);
+      case "unavailable":
+        return failure("unavailable", { recoverable: true, ...context });
+    }
+  }
+  return failure("unavailable", { recoverable: true, ...context });
+}
+function parseJson(text, parse2) {
+  try {
+    return parse2(JSON.parse(text));
+  } catch {
+    throw new LifecycleFsError("corrupt");
+  }
+}
+function issueWriterToken() {
+  return randomUUID2().replaceAll("-", "");
+}
+function createLease(runID, writerToken, input) {
+  return parseLifecycleWriterLease({
+    version: 1,
+    runID,
+    writerToken,
+    processID: input.writer.processID,
+    processInstanceID: input.writer.processInstanceID,
+    acquiredAt: input.now,
+    heartbeatAt: input.now,
+    expiresAt: input.now + input.leaseDurationMs
+  });
+}
+function readLease2(runDir) {
+  const text = readUtf8(join12(runDir, OWNER_FILE2));
+  return text === undefined ? undefined : parseJson(text, parseLifecycleWriterLease);
+}
+function readRun(runDir, runID) {
+  const metadataPath = join12(runDir, METADATA_FILE);
+  const eventsPath = join12(runDir, EVENTS_FILE);
+  assertSafeRegularFile(metadataPath);
+  assertSafeRegularFile(eventsPath);
+  const metadataText = readUtf8(metadataPath);
+  const eventsText = readUtf8(eventsPath);
+  if (metadataText === undefined || eventsText === undefined) {
+    throw new LifecycleFsError("corrupt");
+  }
+  const metadata = parseJson(metadataText, parseLifecycleRunMetadata);
+  if (metadata.runID !== runID) {
+    throw new LifecycleFsError("corrupt");
+  }
+  let decoded;
+  try {
+    decoded = decodeLifecycleJournal(eventsText);
+  } catch {
+    throw new LifecycleFsError("corrupt");
+  }
+  for (const [index, event] of decoded.events.entries()) {
+    if (event.runID !== runID || event.seq !== index) {
+      throw new LifecycleFsError("corrupt");
+    }
+  }
+  const first = decoded.events[0];
+  if (first === undefined || first.type !== "run.started" || first.source !== metadata.source || first.executionAuthority !== metadata.executionAuthority || first.root.operationID !== metadata.root.operationID || first.root.taskID !== metadata.root.taskID) {
+    throw new LifecycleFsError("corrupt");
+  }
+  return { metadata, decoded };
+}
+function terminalOutcome(events) {
+  const last = events.at(-1);
+  return last?.type === "run.terminal" ? last.outcome : undefined;
+}
+function summaryForRun(runDir, runID) {
+  const loaded = readRun(runDir, runID);
+  const lastEvent = loaded.decoded.events.at(-1);
+  const terminal = terminalOutcome(loaded.decoded.events);
+  return {
+    metadata: loaded.metadata,
+    updatedAt: lastEvent?.at ?? loaded.metadata.createdAt,
+    ...terminal === undefined ? {} : { terminalOutcome: terminal },
+    head: loaded.decoded.events.length,
+    integrity: loaded.decoded.partialTail ? "partial-tail" : "clean"
+  };
+}
+function runBytes(runDir) {
+  return readdirSync2(runDir).reduce((total, entry) => {
+    const path4 = join12(runDir, entry);
+    const stats = lstatSync3(path4);
+    if (!stats.isFile() || stats.isSymbolicLink()) {
+      throw new LifecycleFsError("corrupt");
+    }
+    return total + stats.size;
+  }, 0);
+}
+function validateRetention(policy) {
+  if (!Number.isInteger(policy.maxTerminalRuns) || policy.maxTerminalRuns < 0 || !Number.isFinite(policy.maxAgeMs) || policy.maxAgeMs < 0 || !Number.isFinite(policy.maxBytes) || policy.maxBytes < 0) {
+    throw new LifecycleFsError("corrupt");
+  }
+}
+function canDeleteTerminalRun(runDir, runID, now) {
+  const summary = summaryForRun(runDir, runID);
+  if (summary.integrity !== "clean" || summary.terminalOutcome === undefined) {
+    return false;
+  }
+  const entries = readdirSync2(runDir);
+  if (entries.some((entry) => entry !== ".mutation-lock" && !KNOWN_RUN_FILES.has(entry))) {
+    return false;
+  }
+  const lease = readLease2(runDir);
+  if (lease === undefined) {
+    return true;
+  }
+  if (lease.runID !== runID || now < lease.heartbeatAt) {
+    return false;
+  }
+  return now >= lease.expiresAt;
+}
+var createFsLifecycleJournal = (options) => {
+  const configuredRoot = resolve7(options.root);
+  const now = options.now ?? Date.now;
+  const mutateRun = options.withMutationLock ?? withRunMutationLock;
+  return {
+    async start(input, leaseInput) {
+      let runID;
+      let stagingPath;
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const parsedInput = parseLifecycleRunStartInput(input);
+        const parsedLeaseInput = parseLifecycleWriterLeaseInput(leaseInput);
+        runID = parsedInput.runID;
+        validateRunID(runID);
+        const runPath = directRunPath(root, runID);
+        try {
+          statSync(runPath);
+          return failed(failure("already-exists", { runID }));
+        } catch (error) {
+          if (!isMissingFsError(error)) {
+            throw error;
+          }
+        }
+        stagingPath = join12(root, `.start-${runID}-${randomUUID2()}`);
+        mkdirSync3(stagingPath);
+        const writerToken = issueWriterToken();
+        const eventAt = now();
+        const metadata = parseLifecycleRunMetadata({
+          ...parsedInput,
+          version: 1,
+          createdAt: eventAt
+        });
+        const lease = createLease(runID, writerToken, parsedLeaseInput);
+        const event = parseLifecycleEvent({
+          v: 1,
+          seq: 0,
+          runID,
+          at: eventAt,
+          type: "run.started",
+          source: parsedInput.source,
+          executionAuthority: parsedInput.executionAuthority,
+          root: parsedInput.root
+        });
+        writeDurable2(join12(stagingPath, METADATA_FILE), `${JSON.stringify(metadata)}
+`);
+        writeDurable2(join12(stagingPath, EVENTS_FILE), encodeLifecycleJournal([event]));
+        writeDurable2(join12(stagingPath, OWNER_FILE2), `${JSON.stringify(lease)}
+`);
+        try {
+          renameSync2(stagingPath, runPath);
+        } catch (error) {
+          if (typeof error === "object" && error !== null && "code" in error && ["EEXIST", "ENOTEMPTY"].includes(String(error.code))) {
+            return failed(failure("already-exists", { runID }));
+          }
+          throw error;
+        }
+        stagingPath = undefined;
+        return ok({
+          handle: { runID, writerToken },
+          metadata,
+          event,
+          lease,
+          head: 1
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error, runID));
+      } finally {
+        if (stagingPath !== undefined) {
+          rmSync3(stagingPath, { recursive: true, force: true });
+        }
+      }
+    },
+    async takeOver(runID, expected, leaseInput) {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const parsedLeaseInput = parseLifecycleWriterLeaseInput(leaseInput);
+        const runDir = assertExistingSafeRun(root, runID);
+        return mutateRun(runDir, () => {
+          const current = readLease2(runDir);
+          if (expected.kind === "absent") {
+            if (current !== undefined) {
+              return failed(failure("writer-conflict", { recoverable: true, runID }));
+            }
+          } else if (current === undefined || current.writerToken !== expected.writerToken || current.expiresAt !== expected.expiresAt || parsedLeaseInput.now < current.expiresAt) {
+            return failed(failure("writer-conflict", { recoverable: true, runID }));
+          }
+          const writerToken = issueWriterToken();
+          const lease = createLease(runID, writerToken, parsedLeaseInput);
+          writeDurableAtomically(join12(runDir, OWNER_FILE2), `${JSON.stringify(lease)}
+`);
+          return ok({ runID, writerToken });
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error, runID));
+      }
+    },
+    async append(handle, event, expectedHead) {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const parsedBody = parseLifecycleAppendEvent(event);
+        const runDir = assertExistingSafeRun(root, handle.runID);
+        return mutateRun(runDir, () => {
+          const lease = readLease2(runDir);
+          if (lease === undefined || lease.runID !== handle.runID || lease.writerToken !== handle.writerToken) {
+            return failed(failure("writer-conflict", {
+              recoverable: true,
+              runID: handle.runID
+            }));
+          }
+          const loaded = readRun(runDir, handle.runID);
+          if (loaded.decoded.partialTail) {
+            return failed(failure("corrupt", { runID: handle.runID }));
+          }
+          const actualHead = loaded.decoded.events.length;
+          if (expectedHead < actualHead) {
+            return failed(failure("duplicate-event", {
+              runID: handle.runID,
+              expectedHead,
+              actualHead
+            }));
+          }
+          if (expectedHead !== actualHead) {
+            return failed(failure("sequence-mismatch", {
+              recoverable: true,
+              runID: handle.runID,
+              expectedHead,
+              actualHead
+            }));
+          }
+          const previous = loaded.decoded.events.at(-1);
+          if (previous?.type === "run.terminal") {
+            return failed(failure("duplicate-event", {
+              runID: handle.runID,
+              expectedHead,
+              actualHead
+            }));
+          }
+          const committedEvent = parseLifecycleEvent({
+            v: 1,
+            seq: actualHead,
+            runID: handle.runID,
+            at: now(),
+            ...parsedBody
+          });
+          const frame = encodeLifecycleFrame(loaded.decoded.digest, committedEvent);
+          appendDurable2(join12(runDir, EVENTS_FILE), `${frame.line}
+`);
+          return ok({ event: committedEvent, head: actualHead + 1 });
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error, handle.runID));
+      }
+    },
+    async heartbeat(handle, leaseInput) {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const parsed = parseLifecycleWriterLeaseInput({
+          writer: { processID: 1, processInstanceID: "heartbeat-validation" },
+          now: leaseInput.now,
+          leaseDurationMs: leaseInput.leaseDurationMs
+        });
+        const runDir = assertExistingSafeRun(root, handle.runID);
+        return mutateRun(runDir, () => {
+          const current = readLease2(runDir);
+          if (current === undefined || current.writerToken !== handle.writerToken || parsed.now < current.heartbeatAt || parsed.now >= current.expiresAt) {
+            return failed(failure("writer-conflict", {
+              recoverable: true,
+              runID: handle.runID
+            }));
+          }
+          const lease = parseLifecycleWriterLease({
+            ...current,
+            heartbeatAt: parsed.now,
+            expiresAt: parsed.now + parsed.leaseDurationMs
+          });
+          writeDurableAtomically(join12(runDir, OWNER_FILE2), `${JSON.stringify(lease)}
+`);
+          return ok({ lease });
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error, handle.runID));
+      }
+    },
+    async release(handle) {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const runDir = assertExistingSafeRun(root, handle.runID);
+        return mutateRun(runDir, () => {
+          const lease = readLease2(runDir);
+          if (lease === undefined || lease.writerToken !== handle.writerToken) {
+            return failed(failure("writer-conflict", {
+              recoverable: true,
+              runID: handle.runID
+            }));
+          }
+          unlinkSync2(join12(runDir, OWNER_FILE2));
+          return ok(undefined);
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error, handle.runID));
+      }
+    },
+    async load(runID) {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const runDir = assertExistingSafeRun(root, runID);
+        const loaded = readRun(runDir, runID);
+        return ok({
+          metadata: loaded.metadata,
+          events: loaded.decoded.events,
+          head: loaded.decoded.events.length,
+          integrity: loaded.decoded.partialTail ? "partial-tail" : "clean"
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error, runID));
+      }
+    },
+    async list() {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        const summaries = [];
+        for (const entry of readdirSync2(root, { withFileTypes: true })) {
+          if (!entry.isDirectory() || entry.isSymbolicLink() || entry.name.startsWith(".")) {
+            continue;
+          }
+          try {
+            validateRunID(entry.name);
+            const runDir = assertExistingSafeRun(root, entry.name);
+            summaries.push(summaryForRun(runDir, entry.name));
+          } catch (error) {
+            return failed(mapFsFailure(error, entry.name));
+          }
+        }
+        summaries.sort((left, right) => right.updatedAt - left.updatedAt || right.metadata.runID.localeCompare(left.metadata.runID));
+        return ok(summaries);
+      } catch (error) {
+        return failed(mapFsFailure(error));
+      }
+    },
+    async pruneTerminal(policy, now2) {
+      try {
+        const root = resolvedLifecycleRoot(configuredRoot);
+        validateRetention(policy);
+        if (!Number.isFinite(now2) || now2 < 0) {
+          throw new LifecycleFsError("corrupt");
+        }
+        const candidates = [];
+        for (const entry of readdirSync2(root, { withFileTypes: true })) {
+          if (!entry.isDirectory() || entry.isSymbolicLink() || entry.name.startsWith(".")) {
+            continue;
+          }
+          try {
+            validateRunID(entry.name);
+            const runDir = assertExistingSafeRun(root, entry.name);
+            const summary = summaryForRun(runDir, entry.name);
+            if (summary.terminalOutcome === undefined || summary.integrity !== "clean") {
+              continue;
+            }
+            candidates.push({
+              runID: entry.name,
+              updatedAt: summary.updatedAt,
+              bytes: runBytes(runDir),
+              canDelete: canDeleteTerminalRun(runDir, entry.name, now2)
+            });
+          } catch (error) {
+            return failed(mapFsFailure(error, entry.name));
+          }
+        }
+        candidates.sort((left, right) => left.updatedAt - right.updatedAt || left.runID.localeCompare(right.runID));
+        let retainedRuns = candidates.length;
+        let retainedBytes = candidates.reduce((total, candidate) => total + candidate.bytes, 0);
+        const deletedRunIDs = [];
+        for (const candidate of candidates) {
+          const tooOld = now2 - candidate.updatedAt > policy.maxAgeMs;
+          const tooMany = retainedRuns > policy.maxTerminalRuns;
+          const tooLarge = retainedBytes > policy.maxBytes;
+          if (!candidate.canDelete || !tooOld && !tooMany && !tooLarge) {
+            continue;
+          }
+          const runDir = assertExistingSafeRun(root, candidate.runID);
+          const deleted = mutateRun(runDir, () => {
+            if (!canDeleteTerminalRun(runDir, candidate.runID, now2)) {
+              return false;
+            }
+            rmSync3(runDir, { recursive: true });
+            return true;
+          });
+          if (deleted) {
+            deletedRunIDs.push(candidate.runID);
+            retainedRuns -= 1;
+            retainedBytes -= candidate.bytes;
+          }
+        }
+        return ok({
+          deletedRunIDs,
+          retainedTerminalRuns: retainedRuns,
+          retainedBytes
+        });
+      } catch (error) {
+        return failed(mapFsFailure(error));
+      }
+    }
+  };
+};
+
+// src/storage/lifecycle/fsLifecycleWriterLivenessProbe.ts
+import { join as join13 } from "node:path";
+var createFsLifecycleWriterLivenessProbe = (options) => ({
+  async observe(runID) {
+    const observedAt = options.now();
+    try {
+      const root = resolvedLifecycleRoot(options.root);
+      const runDir = assertExistingSafeRun(root, runID);
+      const ownerText = readUtf8(join13(runDir, "owner"));
+      if (ownerText === undefined) {
+        return { kind: "absent", observedAt };
+      }
+      let lease;
+      try {
+        lease = parseLifecycleWriterLease(JSON.parse(ownerText));
+      } catch {
+        return { kind: "unknown", observedAt, reason: "owner-invalid" };
+      }
+      if (lease.runID !== runID) {
+        return {
+          kind: "unknown",
+          observedAt,
+          reason: "owner-invalid",
+          lease
+        };
+      }
+      if (observedAt < lease.heartbeatAt) {
+        return {
+          kind: "unknown",
+          observedAt,
+          reason: "clock-regressed",
+          lease
+        };
+      }
+      if (observedAt >= lease.expiresAt) {
+        return { kind: "expired", observedAt, lease };
+      }
+      return { kind: "active", observedAt, lease };
+    } catch (error) {
+      if (error instanceof LifecycleFsError) {
+        if (error.kind === "missing") {
+          return { kind: "absent", observedAt };
+        }
+        if (error.kind === "corrupt") {
+          return { kind: "unknown", observedAt, reason: "owner-invalid" };
+        }
+      }
+      return { kind: "unknown", observedAt, reason: "probe-unavailable" };
+    }
+  }
+});
+
 // src/telemetry/otelExporter.ts
 var DEFAULT_SERVICE_NAME = "openteam";
 function tracesUrl(ingestionEndpoint) {
@@ -15642,7 +18199,7 @@ var createOtlpSpanExporter = (connection, config) => {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.19.0",
+  version: "0.20.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",
@@ -15746,6 +18303,30 @@ var package_default = {
 var PACKAGE_VERSION = package_default.version;
 
 // src/index.ts
+var LIFECYCLE_WRITER_IDENTITY = {
+  processID: process.pid,
+  processInstanceID: crypto.randomUUID()
+};
+function createConfiguredLifecycleRecorder(config, workspaceRoot, now) {
+  const root = resolveLifecycleRoot({
+    workspaceRoot,
+    configuredRoot: config.lifecycle?.root ?? DEFAULT_LIFECYCLE_ROOT
+  });
+  return createRuntimeLifecycleRecorder({
+    journal: createFsLifecycleJournal({ root, now }),
+    writerLiveness: createFsLifecycleWriterLivenessProbe({ root, now }),
+    writer: LIFECYCLE_WRITER_IDENTITY,
+    now,
+    heartbeatScheduler: createNodeLifecycleHeartbeatScheduler(),
+    heartbeatIntervalMs: DEFAULT_LIFECYCLE_HEARTBEAT_INTERVAL_MS,
+    leaseDurationMs: DEFAULT_LIFECYCLE_WRITER_LEASE_MS,
+    retention: {
+      maxTerminalRuns: config.lifecycle?.retention.maxTerminalRuns ?? DEFAULT_LIFECYCLE_MAX_TERMINAL_RUNS,
+      maxAgeMs: (config.lifecycle?.retention.maxAgeDays ?? DEFAULT_LIFECYCLE_MAX_AGE_DAYS) * 24 * 60 * 60 * 1000,
+      maxBytes: config.lifecycle?.retention.maxBytes ?? DEFAULT_LIFECYCLE_MAX_BYTES
+    }
+  });
+}
 function createShellExec($) {
   return async (command, args) => {
     const output = await $`${command} ${[...args]}`.nothrow().quiet();
@@ -15821,7 +18402,7 @@ var RELEASE_CERT_PATH = "artifacts/graph-release-certificate.json";
 var SOAK_CERT_PATH = "artifacts/graph-soak-certificate.json";
 async function readPackagedCertificate(path4) {
   try {
-    return await readFile3(new URL(`./certificates/${basename2(path4)}`, import.meta.url), "utf8");
+    return await readFile3(new URL(`./certificates/${basename3(path4)}`, import.meta.url), "utf8");
   } catch {
     return;
   }
@@ -15953,8 +18534,8 @@ async function readOpencodeVersion(serverUrl, options = {}) {
 }
 var DEFAULT_OPENCODE_VERSION_BACKOFF_MS = [50, 250];
 function defaultSleep(ms) {
-  return new Promise((resolve5) => {
-    setTimeout(resolve5, ms);
+  return new Promise((resolve8) => {
+    setTimeout(resolve8, ms);
   });
 }
 function createLazyOpencodeVersionReader(serverUrl, options = {}) {
@@ -16197,13 +18778,15 @@ function createCliDeps(config, registry, telemetryPath, sessionsDir = DEFAULT_SE
     graphOperator: createGraphOperator({
       storage,
       holder: "openteam-cli",
+      lifecycleSource: "cli",
+      createLifecycleRecorder: (graphConfig) => createConfiguredLifecycleRecorder(graphConfig, process.cwd(), () => Date.now()),
       evaluateCutoverGate: async (gateConfig) => evaluateCutoverGateForBoundary(gateConfig, storage, resolveOpencodeVersion === undefined ? undefined : await resolveOpencodeVersion())
     }),
     configPath: DEFAULT_CONFIG_PATH,
     telemetryPath,
     opencodeConfigPaths: OPENCODE_CONFIG_CANDIDATES,
     orchestratorAgentPath: ORCHESTRATOR_AGENT_PATH,
-    agentDir: dirname4(ORCHESTRATOR_AGENT_PATH),
+    agentDir: dirname5(ORCHESTRATOR_AGENT_PATH),
     cachePort: realCacheAdapter,
     purge: createPluginPurgeRuntime(sessionsDir),
     loadRosterForDoctor: () => readStoredRosterForDoctor(storage),
@@ -16259,6 +18842,8 @@ var server = async (ctx, rawOptions) => {
   const storage = createFsStorageProvider(ctx.directory || ctx.worktree || process.cwd());
   const runtimeConfig = await loadRuntimeOpenTeamConfig(storage, rawOptions);
   const config = runtimeConfig.config;
+  const workspaceRoot = ctx.directory || ctx.worktree || process.cwd();
+  const lifecycleRecorder = createConfiguredLifecycleRecorder(config, workspaceRoot, now);
   const registry = new RuntimeRegistry({
     fetch: globalThis.fetch,
     clock: () => new Date().toISOString(),
@@ -16393,6 +18978,8 @@ var server = async (ctx, rawOptions) => {
   const graphOperator = createGraphOperator({
     storage,
     holder: "openteam-plugin",
+    lifecycleSource: "plugin",
+    lifecycleRecorder,
     exec: createShellExec(ctx.$),
     repoRoot: ctx.directory
   });
@@ -16468,10 +19055,11 @@ var server = async (ctx, rawOptions) => {
     capabilityProfiles,
     reportArtifactExists,
     readReportArtifact,
+    lifecycleRecorder,
     abortGraceMs: DEFAULT_ABORT_GRACE_MS,
     statusPollMs: DEFAULT_STATUS_POLL_MS,
-    delay: (ms) => new Promise((resolve5) => {
-      setTimeout(resolve5, ms);
+    delay: (ms) => new Promise((resolve8) => {
+      setTimeout(resolve8, ms);
     }),
     warn: diagnostics.warn("unknown-role")
   });