omnius 1.0.670 → 1.0.671

package/dist/index.js

@@ -625936,6 +625936,7 @@ function recordCompletionEvidence(ledger, evidence) {
     ...evidence.verificationImpact ? { verificationImpact: evidence.verificationImpact } : {},
     ...evidence.metrics ? { metrics: evidence.metrics } : {},
     ...evidence.receipt ? { receipt: evidence.receipt } : {},
+    ...evidence.deliveryReceipt ? { deliveryReceipt: evidence.deliveryReceipt } : {},
     ...evidence.progressClass ? { progressClass: evidence.progressClass } : {}
   };
   return {
@@ -625963,6 +625964,7 @@ function recordToolEvidence(ledger, input) {
     verificationImpact: input.verificationImpact,
     metrics: input.metrics,
     receipt: input.receipt,
+    deliveryReceipt: input.deliveryReceipt,
     progressClass: input.progressClass
   });
 }
@@ -629782,13 +629784,19 @@ function selectedEvidence(ledger) {
     return {
       evidenceIds: [],
       commandReceipts: [],
+      deliveryReceipts: [],
       artifactHashes: []
     };
   }
-  const candidates = ledger.evidence.filter((entry) => entry.success === true && (entry.role === "verification" || entry.role === "mutation" || isValidObservationReceipt(entry))).slice(-16);
+  const candidates = ledger.evidence.filter((entry) => entry.success === true && (entry.role === "verification" || entry.role === "mutation" || entry.role === "delivery" && Boolean(entry.deliveryReceipt) || isValidObservationReceipt(entry))).slice(-16);
   const artifacts = /* @__PURE__ */ new Map();
+  const deliveries = /* @__PURE__ */ new Map();
   const commandReceipts = [];
   for (const entry of candidates) {
+    if (entry.deliveryReceipt) {
+      const key = `${entry.deliveryReceipt.provider}\0${entry.deliveryReceipt.receiptId}`;
+      deliveries.set(key, entry.deliveryReceipt);
+    }
     for (const item of entry.receipt?.artifactHashes ?? []) {
       if (item.path && item.sha256)
         artifacts.set(item.path, item.sha256);
@@ -629814,6 +629822,7 @@ function selectedEvidence(ledger) {
   return {
     evidenceIds: candidates.map((entry) => entry.id),
     commandReceipts,
+    deliveryReceipts: [...deliveries.values()],
     artifactHashes: [...artifacts.entries()].map(([path16, sha25610]) => ({
       path: path16,
       sha256: sha25610
@@ -629823,11 +629832,21 @@ function selectedEvidence(ledger) {
 function buildCompletionFinalizationRecord(input) {
   const committedAtIso = input.committedAtIso ?? (/* @__PURE__ */ new Date()).toISOString();
   const evidence = selectedEvidence(input.ledger ?? void 0);
+  const deliveries = /* @__PURE__ */ new Map();
+  for (const receipt2 of [
+    ...evidence.deliveryReceipts,
+    ...input.deliveryReceipts ?? []
+  ]) {
+    deliveries.set(`${receipt2.provider}\0${receipt2.receiptId}`, receipt2);
+  }
+  const deliveryReceipts = [...deliveries.values()];
   const identity3 = [
     input.runId,
     input.taskEpoch ?? "",
     input.status,
+    input.expectedOutcomeContract ? JSON.stringify(input.expectedOutcomeContract) : "",
     evidence.evidenceIds.join(","),
+    deliveryReceipts.map((receipt2) => `${receipt2.provider}:${receipt2.receiptId}`).join(","),
     committedAtIso
   ].join("\0");
   return {
@@ -629839,10 +629858,13 @@ function buildCompletionFinalizationRecord(input) {
     status: input.status,
     ...input.ledger ? { ledgerStatus: input.ledger.status } : {},
     summary: clean4(input.summary, 4e3),
+    ...input.expectedOutcomeContract ? { expectedOutcomeContract: input.expectedOutcomeContract } : {},
+    ...input.expectedOutcomeAssessment ? { expectedOutcomeAssessment: input.expectedOutcomeAssessment } : {},
     committedAtIso,
     runtimeProvenance: captureCompletionRuntimeProvenance(),
     evidenceIds: evidence.evidenceIds,
     commandReceipts: evidence.commandReceipts,
+    deliveryReceipts,
     artifactHashes: evidence.artifactHashes,
     projections: {
       ledger: "pending",
@@ -629902,7 +629924,10 @@ function commitTerminalTrajectoryProjection(stateDir, record, payload) {
 function loadCompletionFinalization(stateDir, runId) {
   try {
     const loaded = JSON.parse(readFileSync77(completionFinalizationPath(stateDir, runId), "utf8"));
-    return loaded.phase === "committed" ? loaded : null;
+    return loaded.phase === "committed" ? {
+      ...loaded,
+      deliveryReceipts: Array.isArray(loaded.deliveryReceipts) ? loaded.deliveryReceipts : []
+    } : null;
   } catch {
     return null;
   }
@@ -629913,6 +629938,465 @@ var init_completionFinalization = __esm({
   }
 });
 
+// packages/orchestrator/dist/expectedOutcomeContract.js
+function cleanId(value2, max = 240) {
+  if (typeof value2 !== "string")
+    return void 0;
+  const clean7 = value2.trim().slice(0, max);
+  return clean7 || void 0;
+}
+function normalizeExpectedOutcomeContractV1(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2))
+    return null;
+  const record = value2;
+  if (record["schema"] !== "omnius.expected-outcome-contract.v1")
+    return null;
+  const route = record["route"];
+  const continuity = record["continuity"];
+  const planningMode = record["planningMode"];
+  if (!ROUTES.has(route) || !CONTINUITIES.has(continuity))
+    return null;
+  if (!PLANNING_MODES.has(planningMode))
+    return null;
+  const confidence2 = record["confidence"];
+  const reason = cleanId(record["reason"], 1e3);
+  if (typeof confidence2 !== "number" || !Number.isFinite(confidence2) || confidence2 < 0 || confidence2 > 1 || !reason || !Array.isArray(record["citedEvidenceIds"])) {
+    return null;
+  }
+  const citedEvidenceIds = [
+    ...new Set(record["citedEvidenceIds"].map((value3) => cleanId(value3, 500)).filter((value3) => Boolean(value3)))
+  ].slice(0, 64);
+  if (citedEvidenceIds.length !== record["citedEvidenceIds"].length)
+    return null;
+  const outcome = record["outcome"];
+  if (!OUTCOMES.has(outcome))
+    return null;
+  if (!Array.isArray(record["requiredEffects"]))
+    return null;
+  const requiredEffects = [
+    ...new Set(record["requiredEffects"].filter((effect) => typeof effect === "string" && EFFECTS.has(effect)))
+  ];
+  if (requiredEffects.length !== record["requiredEffects"].length || !requiredEffects.includes(CORE_EFFECT[outcome])) {
+    return null;
+  }
+  const activeScopeId = cleanId(record["activeScopeId"], 500);
+  const inputId = cleanId(record["inputId"]);
+  const decisionId = cleanId(record["decisionId"]);
+  return {
+    schema: "omnius.expected-outcome-contract.v1",
+    route,
+    continuity,
+    ...activeScopeId ? { activeScopeId } : {},
+    citedEvidenceIds,
+    confidence: confidence2,
+    reason,
+    planningMode,
+    outcome,
+    requiredEffects,
+    ...inputId ? { inputId } : {},
+    ...decisionId ? { decisionId } : {}
+  };
+}
+function assessExpectedOutcomeContractV1(contract, observed) {
+  const observedSet = new Set(observed);
+  const observedEffects = [...EFFECTS].filter((effect) => observedSet.has(effect));
+  const missingEffects = contract.requiredEffects.filter((effect) => !observedSet.has(effect));
+  return {
+    schema: "omnius.expected-outcome-assessment.v1",
+    outcome: contract.outcome,
+    requiredEffects: [...contract.requiredEffects],
+    observedEffects,
+    missingEffects,
+    satisfied: missingEffects.length === 0
+  };
+}
+function expectedOutcomeAllowsTextOnlyCompletion(contract) {
+  return Boolean(contract && contract.route === "chat" && contract.outcome === "conversation" && contract.requiredEffects.length === 1 && contract.requiredEffects[0] === "visible_response");
+}
+function normalizeCompletionDeliveryReceipt(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2))
+    return null;
+  const record = value2;
+  if (record["schema"] !== "omnius.completion-delivery-receipt.v1")
+    return null;
+  const provider = cleanId(record["provider"], 120);
+  const target = cleanId(record["target"], 500);
+  const receiptId = cleanId(record["receiptId"], 500);
+  const deliveredAtIso = cleanId(record["deliveredAtIso"], 80);
+  if (!provider || !target || !receiptId || !deliveredAtIso)
+    return null;
+  const artifactPaths = Array.isArray(record["artifactPaths"]) ? [
+    ...new Set(record["artifactPaths"].filter((path16) => typeof path16 === "string").map((path16) => path16.trim().slice(0, 1e3)).filter(Boolean))
+  ].slice(0, 32) : void 0;
+  return {
+    schema: "omnius.completion-delivery-receipt.v1",
+    provider,
+    target,
+    receiptId,
+    deliveredAtIso,
+    ...artifactPaths?.length ? { artifactPaths } : {}
+  };
+}
+var OUTCOMES, ROUTES, CONTINUITIES, PLANNING_MODES, EFFECTS, CORE_EFFECT;
+var init_expectedOutcomeContract = __esm({
+  "packages/orchestrator/dist/expectedOutcomeContract.js"() {
+    "use strict";
+    OUTCOMES = /* @__PURE__ */ new Set([
+      "conversation",
+      "read_only",
+      "mutation",
+      "delivery"
+    ]);
+    ROUTES = /* @__PURE__ */ new Set(["chat", "action"]);
+    CONTINUITIES = /* @__PURE__ */ new Set([
+      "new",
+      "continue_active",
+      "status_probe",
+      "replace"
+    ]);
+    PLANNING_MODES = /* @__PURE__ */ new Set([
+      "none",
+      "checklist"
+    ]);
+    EFFECTS = /* @__PURE__ */ new Set([
+      "visible_response",
+      "observation",
+      "mutation",
+      "verification",
+      "delivery"
+    ]);
+    CORE_EFFECT = {
+      conversation: "visible_response",
+      read_only: "observation",
+      mutation: "mutation",
+      delivery: "delivery"
+    };
+  }
+});
+
+// packages/orchestrator/dist/todoObservability.js
+function emptyStatusCounts() {
+  return { pending: 0, inProgress: 0, completed: 0, blocked: 0 };
+}
+function incrementStatus(counts, status) {
+  if (status === "in_progress")
+    counts.inProgress += 1;
+  else
+    counts[status] += 1;
+}
+function copyStrings(values) {
+  return values ? Array.from(values) : void 0;
+}
+function copyItem(todo, sourceOrdinal) {
+  return {
+    id: todo.id,
+    content: todo.content,
+    status: todo.status,
+    sourceOrdinal,
+    ...todo.activeForm !== void 0 ? { activeForm: todo.activeForm } : {},
+    ...todo.parentId !== void 0 ? { parentId: todo.parentId } : {},
+    ...todo.blocker !== void 0 ? { blocker: todo.blocker } : {},
+    ...todo.owner !== void 0 ? { owner: todo.owner } : {},
+    ...todo.blocks !== void 0 ? { blocks: copyStrings(todo.blocks) } : {},
+    ...todo.blockedBy !== void 0 ? { blockedBy: copyStrings(todo.blockedBy) } : {},
+    ...todo.createdAt !== void 0 ? { createdAt: todo.createdAt } : {},
+    ...todo.updatedAt !== void 0 ? { updatedAt: todo.updatedAt } : {},
+    ...todo.completedAt !== void 0 ? { completedAt: todo.completedAt } : {}
+  };
+}
+function validateSnapshotInput(input) {
+  if (!input.sessionId.trim())
+    throw new Error("Todo snapshot sessionId must not be empty");
+  if (!Number.isSafeInteger(input.revision) || input.revision < 0) {
+    throw new Error("Todo snapshot revision must be a non-negative safe integer");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const todo of input.todos) {
+    if (!todo.id.trim())
+      throw new Error("Todo snapshot item id must not be empty");
+    if (ids.has(todo.id))
+      throw new Error(`Duplicate todo id '${todo.id}'`);
+    ids.add(todo.id);
+  }
+}
+function buildHierarchy(items) {
+  const byId = new Map(items.map((item) => [item.id, item]));
+  const invalidParents = /* @__PURE__ */ new Set();
+  const issues = [];
+  for (const item of items) {
+    if (!item.parentId)
+      continue;
+    if (item.parentId === item.id) {
+      invalidParents.add(item.id);
+      issues.push({ code: "self_parent", todoId: item.id, parentId: item.parentId });
+    } else if (!byId.has(item.parentId)) {
+      invalidParents.add(item.id);
+      issues.push({ code: "missing_parent", todoId: item.id, parentId: item.parentId });
+    }
+  }
+  const visitState = /* @__PURE__ */ new Map();
+  const stack = [];
+  const visit = (id2) => {
+    const state5 = visitState.get(id2);
+    if (state5 === "visited")
+      return;
+    if (state5 === "visiting") {
+      const start2 = stack.lastIndexOf(id2);
+      for (const cycleId of stack.slice(Math.max(0, start2))) {
+        const cycleItem = byId.get(cycleId);
+        if (!cycleItem?.parentId || invalidParents.has(cycleId))
+          continue;
+        invalidParents.add(cycleId);
+        issues.push({
+          code: "cyclic_parent",
+          todoId: cycleId,
+          parentId: cycleItem.parentId
+        });
+      }
+      return;
+    }
+    visitState.set(id2, "visiting");
+    stack.push(id2);
+    const parentId = byId.get(id2)?.parentId;
+    if (parentId && byId.has(parentId) && parentId !== id2)
+      visit(parentId);
+    stack.pop();
+    visitState.set(id2, "visited");
+  };
+  for (const item of items)
+    visit(item.id);
+  const children2 = /* @__PURE__ */ new Map();
+  const resolvedParent = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const item of items) {
+    const parentId = item.parentId;
+    if (!parentId || invalidParents.has(item.id) || !byId.has(parentId)) {
+      roots.push(item);
+      continue;
+    }
+    resolvedParent.set(item.id, parentId);
+    const bucket2 = children2.get(parentId) ?? [];
+    bucket2.push(item);
+    children2.set(parentId, bucket2);
+  }
+  return { byId, children: children2, roots, resolvedParent, issues };
+}
+function snapshotCounts(items) {
+  const hierarchy = buildHierarchy(items);
+  const status = emptyStatusCounts();
+  const leafStatus = emptyStatusCounts();
+  let leaves = 0;
+  for (const item of items) {
+    incrementStatus(status, item.status);
+    if ((hierarchy.children.get(item.id)?.length ?? 0) === 0) {
+      leaves += 1;
+      incrementStatus(leafStatus, item.status);
+    }
+  }
+  return {
+    total: items.length,
+    roots: hierarchy.roots.length,
+    leaves,
+    open: items.length - status.completed,
+    openLeaves: leaves - leafStatus.completed,
+    status,
+    leafStatus
+  };
+}
+function createTodoSnapshot(input) {
+  validateSnapshotInput(input);
+  const items = input.todos.map((todo, index) => copyItem(todo, index));
+  return {
+    schemaVersion: 1,
+    sessionId: input.sessionId,
+    ...input.taskEpoch !== void 0 ? { taskEpoch: input.taskEpoch } : {},
+    revision: input.revision,
+    observedAt: input.observedAt,
+    items,
+    counts: snapshotCounts(items)
+  };
+}
+function descendantStats(item, hierarchy) {
+  const children2 = hierarchy.children.get(item.id) ?? [];
+  if (children2.length === 0) {
+    const leafCounts2 = emptyStatusCounts();
+    incrementStatus(leafCounts2, item.status);
+    return { descendantCount: 0, leafCounts: leafCounts2, displayStatus: item.status };
+  }
+  let descendantCount = 0;
+  const leafCounts = emptyStatusCounts();
+  for (const child2 of children2) {
+    const childStats = descendantStats(child2, hierarchy);
+    descendantCount += 1 + childStats.descendantCount;
+    leafCounts.pending += childStats.leafCounts.pending;
+    leafCounts.inProgress += childStats.leafCounts.inProgress;
+    leafCounts.completed += childStats.leafCounts.completed;
+    leafCounts.blocked += childStats.leafCounts.blocked;
+  }
+  const displayStatus = leafCounts.blocked > 0 ? "blocked" : leafCounts.inProgress > 0 ? "in_progress" : leafCounts.pending > 0 ? item.status === "completed" ? "in_progress" : item.status : "completed";
+  return { descendantCount, leafCounts, displayStatus };
+}
+function buildTodoRenderModel(snapshot) {
+  const hierarchy = buildHierarchy(snapshot.items);
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (item, depth) => {
+    if (seen.has(item.id))
+      return;
+    seen.add(item.id);
+    const stats = descendantStats(item, hierarchy);
+    const resolvedParentId = hierarchy.resolvedParent.get(item.id);
+    rows.push({
+      ...item,
+      ordinal: rows.length,
+      depth,
+      ...resolvedParentId ? { resolvedParentId } : {},
+      displayStatus: stats.displayStatus,
+      directChildCount: hierarchy.children.get(item.id)?.length ?? 0,
+      descendantCount: stats.descendantCount,
+      leafCounts: stats.leafCounts
+    });
+    for (const child2 of hierarchy.children.get(item.id) ?? [])
+      visit(child2, depth + 1);
+  };
+  for (const root of hierarchy.roots)
+    visit(root, 0);
+  for (const item of snapshot.items)
+    visit(item, 0);
+  const activeTodoIds = rows.filter((row2) => row2.status === "in_progress").map((row2) => row2.id);
+  const blockedTodoIds = rows.filter((row2) => row2.status === "blocked").map((row2) => row2.id);
+  const state5 = rows.length === 0 ? "empty" : blockedTodoIds.length > 0 ? "blocked" : snapshot.counts.openLeaves === 0 ? "completed" : "active";
+  return {
+    schemaVersion: 1,
+    sessionId: snapshot.sessionId,
+    ...snapshot.taskEpoch !== void 0 ? { taskEpoch: snapshot.taskEpoch } : {},
+    revision: snapshot.revision,
+    observedAt: snapshot.observedAt,
+    state: state5,
+    counts: snapshot.counts,
+    activeTodoIds,
+    blockedTodoIds,
+    rows,
+    hierarchyIssues: hierarchy.issues
+  };
+}
+function sameStrings(a2, b) {
+  if (a2 === b)
+    return true;
+  if (!a2 || !b || a2.length !== b.length)
+    return false;
+  return a2.every((value2, index) => value2 === b[index]);
+}
+function detailChanges(previous, current) {
+  const fields = [];
+  if (previous.activeForm !== current.activeForm)
+    fields.push("activeForm");
+  if (previous.blocker !== current.blocker)
+    fields.push("blocker");
+  if (previous.owner !== current.owner)
+    fields.push("owner");
+  if (!sameStrings(previous.blocks, current.blocks))
+    fields.push("blocks");
+  if (!sameStrings(previous.blockedBy, current.blockedBy))
+    fields.push("blockedBy");
+  return fields;
+}
+function transitionBase(previous, current, todoId) {
+  return {
+    sessionId: current.sessionId,
+    ...current.taskEpoch !== void 0 ? { taskEpoch: current.taskEpoch } : {},
+    fromRevision: previous.revision,
+    toRevision: current.revision,
+    observedAt: current.observedAt,
+    todoId
+  };
+}
+function diffTodoSnapshots(previous, current) {
+  if (previous.sessionId !== current.sessionId) {
+    throw new Error("Cannot diff todo snapshots from different sessions");
+  }
+  if (previous.taskEpoch !== current.taskEpoch) {
+    throw new Error("Cannot diff todo snapshots from different task epochs");
+  }
+  if (current.revision <= previous.revision) {
+    throw new Error("Todo snapshot revision must increase when diffing");
+  }
+  const previousById = new Map(previous.items.map((item) => [item.id, item]));
+  const currentById = new Map(current.items.map((item) => [item.id, item]));
+  const transitions = [];
+  for (const item of current.items) {
+    const prior = previousById.get(item.id);
+    const base3 = transitionBase(previous, current, item.id);
+    if (!prior) {
+      transitions.push({ ...base3, kind: "created", item });
+      continue;
+    }
+    if (prior.status !== item.status) {
+      transitions.push({
+        ...base3,
+        kind: "status_changed",
+        from: prior.status,
+        to: item.status,
+        item
+      });
+    }
+    if (prior.parentId !== item.parentId) {
+      transitions.push({
+        ...base3,
+        kind: "reparented",
+        fromParentId: prior.parentId ?? null,
+        toParentId: item.parentId ?? null,
+        item
+      });
+    }
+    if (prior.content !== item.content) {
+      transitions.push({
+        ...base3,
+        kind: "content_changed",
+        from: prior.content,
+        to: item.content,
+        item
+      });
+    }
+    const fields = detailChanges(prior, item);
+    if (fields.length > 0) {
+      transitions.push({ ...base3, kind: "details_changed", fields, item });
+    }
+  }
+  for (const prior of previous.items) {
+    if (currentById.has(prior.id))
+      continue;
+    transitions.push({
+      ...transitionBase(previous, current, prior.id),
+      kind: "deleted",
+      previous: prior
+    });
+  }
+  return transitions;
+}
+function createTodoSnapshotEvent(runId, snapshot) {
+  return {
+    type: "todo_snapshot",
+    runId,
+    snapshot,
+    timestamp: snapshot.observedAt
+  };
+}
+function createTodoTransitionEvents(runId, previous, current) {
+  return diffTodoSnapshots(previous, current).map((transition2) => ({
+    type: "todo_transition",
+    runId,
+    transition: transition2,
+    snapshotRevision: current.revision,
+    timestamp: current.observedAt
+  }));
+}
+var init_todoObservability = __esm({
+  "packages/orchestrator/dist/todoObservability.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/verificationCommand.js
 function exactTrailingExitReporterPrimary(command) {
   let quote = null;
@@ -652897,6 +653381,8 @@ var init_agenticRunner = __esm({
     init_verification_ledger();
     init_completionAutoFinalize();
     init_completionFinalization();
+    init_expectedOutcomeContract();
+    init_todoObservability();
     init_verificationCommand();
     init_completionContract();
     init_dist6();
@@ -653244,6 +653730,10 @@ ${loadPrompt("agentic/system-small.md")}`;
       _consecutiveEnoent = 0;
       _assistantTextEmitted = false;
       // WO-E26: prevent double-emit
+      _expectedOutcomeObservedEffects = /* @__PURE__ */ new Set();
+      _completionDeliveryReceipts = /* @__PURE__ */ new Map();
+      _todoObservabilitySnapshot;
+      _todoObservabilityRevision = 0;
       _recentEnoents = [];
       // sliding window of last 8 tool calls
       _microcompactHintEmitted = false;
@@ -654942,6 +655432,22 @@ ${parts.join("\n")}
         } catch {
         }
       }
+      _observeExpectedOutcomeEffect(effect) {
+        if (this.options.expectedOutcomeContract) {
+          this._expectedOutcomeObservedEffects.add(effect);
+        }
+      }
+      _recordCompletionDeliveryReceipt(value2) {
+        const receipt2 = normalizeCompletionDeliveryReceipt(value2);
+        if (!receipt2)
+          return null;
+        this._completionDeliveryReceipts.set(`${receipt2.provider}\0${receipt2.receiptId}`, receipt2);
+        this._observeExpectedOutcomeEffect("delivery");
+        return receipt2;
+      }
+      _currentExpectedOutcomeAssessment() {
+        return this.options.expectedOutcomeContract ? assessExpectedOutcomeContractV1(this.options.expectedOutcomeContract, this._expectedOutcomeObservedEffects) : void 0;
+      }
       /**
        * Commit one authoritative terminal receipt before emitting a result to the
        * TUI.  The receipt is the source of truth; ledger/workboard/debug/trajectory
@@ -654956,6 +655462,9 @@ ${parts.join("\n")}
             taskEpoch: this._taskEpoch,
             status: input.status,
             summary: input.summary,
+            expectedOutcomeContract: this.options.expectedOutcomeContract,
+            expectedOutcomeAssessment: input.expectedOutcomeAssessment,
+            deliveryReceipts: [...this._completionDeliveryReceipts.values()],
             ledger: this._completionLedger,
             workboardPresent: Boolean(this._workboard)
           });
@@ -655063,11 +655572,16 @@ runtime_module_sha256=${record.runtimeProvenance.module.sha256 ?? "unknown"}`
       constructor(backend, options2) {
         const adversaryMode = options2?.adversaryMode ?? options2?.observerMode ?? "both";
         const disableAdversaryCritic = options2?.disableAdversaryCritic ?? options2?.disableStepCritic ?? true;
+        const expectedOutcomeContract = options2?.expectedOutcomeContract ? normalizeExpectedOutcomeContractV1(options2.expectedOutcomeContract) : void 0;
+        if (options2?.expectedOutcomeContract && !expectedOutcomeContract) {
+          throw new TypeError("Invalid ExpectedOutcomeContractV1");
+        }
         this.backend = backend;
         this._explicitCompactionThreshold = typeof options2?.compactionThreshold === "number";
         this.options = {
           maxTurns: options2?.maxTurns ?? 60,
           acceptTextOnlyCompletion: options2?.acceptTextOnlyCompletion ?? false,
+          expectedOutcomeContract,
           maxTokens: options2?.maxTokens ?? 16384,
           temperature: options2?.temperature ?? 0,
           requestTimeoutMs: options2?.requestTimeoutMs ?? 3e5,
@@ -657774,6 +658288,29 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return null;
         }
       }
+      _emitTodoObservabilitySnapshot() {
+        if (!this._onTypedEvent)
+          return;
+        const todos = this.readSessionTodos();
+        if (!todos)
+          return;
+        const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const next = createTodoSnapshot({
+          sessionId: this._sessionId || process.env["OMNIUS_SESSION_ID"] || "default",
+          taskEpoch: this._taskEpoch,
+          revision: ++this._todoObservabilityRevision,
+          observedAt,
+          todos
+        });
+        const runId = this.currentArtifactRunId();
+        if (this._todoObservabilitySnapshot) {
+          for (const event of createTodoTransitionEvents(runId, this._todoObservabilitySnapshot, next)) {
+            this._onTypedEvent(event);
+          }
+        }
+        this._todoObservabilitySnapshot = next;
+        this._onTypedEvent(createTodoSnapshotEvent(runId, next));
+      }
       _operationalWorkGraphPersistenceKey() {
         const session = this._sessionId || process.env["OMNIUS_SESSION_ID"] || "default";
         return `${session}-run-${this.quickHash(this._activeRunId || "inactive")}-task-epoch-${this._taskEpoch}`;
@@ -657852,8 +658389,6 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
             messages2.splice(index, 1);
           }
         }
-        if (!this.writesUserTaskArtifacts())
-          return;
         if (!this.tools.has("task_complete"))
           return;
         const openItems = openTodoLeaves(this._normalizeTodosForPrompt(this.readSessionTodos() ?? []));
@@ -659044,7 +659579,10 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         return kept.length > 0 ? kept.join(" | ") : null;
       }
       _recordCompletionToolEvidenceFromResult(input) {
-        if (!this._completionLedger || input.toolName === "task_complete")
+        if (!this._completionLedger)
+          return;
+        const deliveryReceipt = input.result.success === true ? normalizeCompletionDeliveryReceipt(input.result.completionDeliveryReceipt) : null;
+        if (input.toolName === "task_complete" && !deliveryReceipt)
           return;
         const realFileMutation = input.realFileMutation ?? this._isRealProjectMutation(input.toolName, input.result);
         const attemptedTargetPaths = this._extractToolTargetPaths(input.toolName, input.args, input.result);
@@ -659076,11 +659614,12 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           outputPreview: (input.outputPreview ?? this._toolEvidencePreview(input.result, void 0, 1200, input.toolName)).toString().slice(0, input.toolName === "audio_analyze" || input.toolName === "video_understand" ? 1200 : 500),
           argsKey: input.argsKey.slice(0, 300),
           targetPaths: evidenceTargetPaths2,
-          role: input.result.completionEvidenceRole ?? (input.result.alreadyApplied === true ? "mutation" : realFileMutation ? "mutation" : input.result.runtimeAuthored === true && !shellVerification ? "blocker" : shellVerification ? "verification" : input.result.success === true ? "observation" : void 0),
+          role: input.result.completionEvidenceRole ?? (deliveryReceipt ? "delivery" : input.result.alreadyApplied === true ? "mutation" : realFileMutation ? "mutation" : input.result.runtimeAuthored === true && !shellVerification ? "blocker" : shellVerification ? "verification" : input.result.success === true ? "observation" : void 0),
           family: input.result.completionEvidenceFamily ?? (input.result.runtimeAuthored === true && !shellVerification ? "runtime_control" : shellVerification ? shellVerificationFamily : void 0),
           verificationImpact: input.result.completionVerificationImpact ?? (input.result.alreadyApplied === true ? "neutral" : realFileMutation ? "invalidates" : void 0),
           metrics: input.result.completionEvidenceMetrics,
-          receipt: receipt2
+          receipt: receipt2,
+          deliveryReceipt: deliveryReceipt ?? void 0
         });
         if (realFileMutation && realMutationPaths.length > 0) {
           for (const filePath of realMutationPaths) {
@@ -663445,6 +663984,11 @@ Rewrite it now for ${ctx3.model}.`;
        */
       prepareReusableRun(configuration) {
         this.options.dynamicContext = String(configuration.dynamicContext ?? "");
+        const expectedOutcomeContract = configuration.expectedOutcomeContract ? normalizeExpectedOutcomeContractV1(configuration.expectedOutcomeContract) : void 0;
+        if (configuration.expectedOutcomeContract && !expectedOutcomeContract) {
+          throw new TypeError("Invalid ExpectedOutcomeContractV1");
+        }
+        this.options.expectedOutcomeContract = expectedOutcomeContract ?? void 0;
         this.tools.clear();
         this._activatedTools.clear();
         this._toolLastUsedTurn.clear();
@@ -666686,6 +667230,11 @@ ${dynamicProjectContext}`
         let acceptedTaskCompleteStatus;
         let bruteForceCycle = 0;
         this._assistantTextEmitted = false;
+        this._expectedOutcomeObservedEffects.clear();
+        this._completionDeliveryReceipts.clear();
+        this._todoObservabilitySnapshot = void 0;
+        this._todoObservabilityRevision = 0;
+        this._emitTodoObservabilitySnapshot();
         this._microcompactHintEmitted = false;
         this._hookDenyHintCount = 0;
         this._selfConsistencyVotes = 0;
@@ -667291,6 +667840,8 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             this._completionLedger = reconcileClaimsWithEvidence(this._completionLedger);
             this._refreshIntegrationClosure();
           }
+          if (this.options.expectedOutcomeContract)
+            return false;
           const authoritativeDeficit = authoritativeCompletionDeficit(turn);
           if (authoritativeDeficit) {
             return holdAuthoritativeCompletionDeficit(authoritativeDeficit, args, turn);
@@ -668887,6 +669438,7 @@ ${memoryLines.join("\n")}`
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           this.gcSystemMessages(requestMessages2);
           requestMessages2 = this._prepareModelFacingMessages(requestMessages2, turn);
+          this._injectTaskCloseoutReconciliationContext(requestMessages2);
           const echoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
           if (this._echoTempBoostTurns > 0)
             this._echoTempBoostTurns--;
@@ -670732,6 +671284,21 @@ ${diagnostic}`;
               }
               const realFileMutation = this._isRealProjectMutation(tc.name, result);
               const observedStateMutation = realFileMutation || shellFilesystemMutation || result.success === true && result.mutated === true;
+              if (result.success === true && (observedStateMutation || result.alreadyApplied === true)) {
+                this._observeExpectedOutcomeEffect("mutation");
+              }
+              if (result.success === true && result.runtimeAuthored !== true && (isReadLike && !result.completionEvidenceRole || result.completionEvidenceRole === "observation" || result.completionEvidenceRole === "verification")) {
+                this._observeExpectedOutcomeEffect("observation");
+              }
+              if (result.success === true && result.runtimeAuthored !== true && result.completionEvidenceRole === "verification") {
+                this._observeExpectedOutcomeEffect("verification");
+              }
+              if (result.success === true && result.completionDeliveryReceipt) {
+                this._recordCompletionDeliveryReceipt(result.completionDeliveryReceipt);
+              }
+              if (result.success === true && result.completionVisibleResponse === true) {
+                this._observeExpectedOutcomeEffect("visible_response");
+              }
               const realMutationPaths = realFileMutation ? this._extractToolTargetPaths(tc.name, tc.arguments, result) : shellFilesystemMutation ? shellMutationPaths : [];
               this._recordRecentToolOutcomeForWorldState({
                 turn,
@@ -670817,6 +671384,7 @@ ${diagnostic}`;
                   }
                   this._writesSinceLastTodoWrite = 0;
                   this._progressGateActive = false;
+                  this._emitTodoObservabilitySnapshot();
                 }
                 if (tc.name === "file_read") {
                   const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "");
@@ -673037,6 +673605,7 @@ Only call task_complete when the task is actually complete and the evidence is f
             });
             const cleanNonStream = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
             if (cleanNonStream) {
+              this._observeExpectedOutcomeEffect("visible_response");
               this.emit({
                 type: "assistant_text",
                 content: cleanNonStream,
@@ -673044,7 +673613,7 @@ Only call task_complete when the task is actually complete and the evidence is f
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
-            if (this.options.acceptTextOnlyCompletion && cleanNonStream) {
+            if (this.options.acceptTextOnlyCompletion && expectedOutcomeAllowsTextOnlyCompletion(this.options.expectedOutcomeContract) && cleanNonStream) {
               completed = true;
               summary = cleanNonStream;
               this._onTypedEvent?.({
@@ -673057,24 +673626,6 @@ Only call task_complete when the task is actually complete and the evidence is f
               break;
             }
             this.adversaryObserve(messages2, turn);
-            if (/task.?complete|all tests pass/i.test(content)) {
-              const completionArgs = { summary: content };
-              if (holdTaskCompleteGates(completionArgs, turn)) {
-                if (this._completionIncompleteVerification)
-                  break;
-                continue;
-              }
-              completed = true;
-              summary = content;
-              this._onTypedEvent?.({
-                type: "completion_requested",
-                runId: this.currentArtifactRunId(),
-                summary: content.slice(0, 500),
-                sourcePath: this.options.streamEnabled ? "stream" : "batch",
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-              break;
-            }
             if (isThinkOnly) {
               if (consecutiveThinkOnly >= MAX_CONSECUTIVE_THINK_ONLY) {
                 const recentSuccesses = this._adversaryToolOutcomes.slice(-3).filter((o2) => o2.succeeded);
@@ -673412,6 +673963,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
             this.gcSystemMessages(compactedMsgs);
             const modelFacingMessages = this._prepareModelFacingMessages(compactedMsgs, turn);
+            this._injectTaskCloseoutReconciliationContext(modelFacingMessages);
             const bfEchoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
             if (this._echoTempBoostTurns > 0)
               this._echoTempBoostTurns--;
@@ -673943,10 +674495,34 @@ ${terminalFeedback.slice(0, 4e3)}`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
+        const expectedOutcomeAssessment = this._currentExpectedOutcomeAssessment();
+        if (completed && !declaredDegradedCompletion && expectedOutcomeAssessment && !expectedOutcomeAssessment.satisfied) {
+          const attemptedSummary = summary.trim();
+          const missing = expectedOutcomeAssessment.missingEffects.join(", ");
+          const observed = expectedOutcomeAssessment.observedEffects.join(", ") || "none";
+          completed = false;
+          summary = [
+            "INCOMPLETE_VERIFICATION: declared success did not satisfy the host-bound expected outcome.",
+            `Outcome: ${expectedOutcomeAssessment.outcome}`,
+            `Missing effects: ${missing}`,
+            `Observed effects: ${observed}`,
+            ...attemptedSummary ? [`Attempted terminal summary: ${attemptedSummary.slice(0, 1200)}`] : []
+          ].join("\n");
+          this._completionIncompleteVerification = {
+            reason: "completion_evidence_missing",
+            summary
+          };
+          this.emit({
+            type: "status",
+            content: `expected outcome not satisfied; terminal success downgraded without retry (missing: ${missing})`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         let runStatus = declaredDegradedCompletion ? "incomplete" : completed ? "completed" : this._completionLedger?.status === "blocked" || this._completionLedger?.status === "request_changes" || this._completionLedger?.status === "incomplete_verification" ? "incomplete_verification" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
         const terminalReceipt = this._commitTerminalFinalization({
           status: runStatus,
           summary,
+          expectedOutcomeAssessment,
           trajectoryPayload: {
             task: persistentTaskGoal.slice(0, 1e3),
             outcome: completed ? "pass" : this.aborted ? "aborted" : runStatus === "incomplete_verification" ? "incomplete_verification" : "incomplete",
@@ -673961,7 +674537,9 @@ ${terminalFeedback.slice(0, 4e3)}`,
             totalToolCalls: toolCallCount,
             totalTokens,
             filesModified: [...this._taskState.modifiedFiles.keys()],
-            durationMs
+            durationMs,
+            expectedOutcomeContract: this.options.expectedOutcomeContract,
+            expectedOutcomeAssessment
           }
         });
         if (!terminalReceipt) {
@@ -674772,7 +675350,10 @@ ${detail}` : detail;
           testsRun,
           provenanceAnchors,
           gitProgress: this._gitProgressSummary(),
-          terminalReceiptId: terminalReceipt?.id
+          terminalReceiptId: terminalReceipt?.id,
+          expectedOutcomeContract: this.options.expectedOutcomeContract,
+          expectedOutcomeAssessment,
+          deliveryReceipts: [...this._completionDeliveryReceipts.values()]
         };
       }
       // -------------------------------------------------------------------------
@@ -680454,6 +681035,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
         const textToolParse = parseTextToolCalls(content.replace(/<think>[\s\S]*?<\/think>/g, "").trim(), modelProfile);
         const cleanContent = stripXmlControlBlocks(textToolParse.content, modelProfile);
         if (cleanContent) {
+          this._observeExpectedOutcomeEffect("visible_response");
           this.emit({
             type: "assistant_text",
             content: cleanContent,
@@ -689223,6 +689805,7 @@ __export(dist_exports3, {
   applyWorldPatch: () => applyWorldPatch,
   arcSummary: () => arcSummary,
   artifactReference: () => artifactReference,
+  assessExpectedOutcomeContractV1: () => assessExpectedOutcomeContractV1,
   auditCompletionClaims: () => auditCompletionClaims,
   auditPerceptionClaims: () => auditPerceptionClaims,
   brokerQueueDeadlineResponse: () => brokerQueueDeadlineResponse,
@@ -689257,6 +689840,7 @@ __export(dist_exports3, {
   buildSkillDescription: () => buildSkillDescription,
   buildSteeringPacket: () => buildSteeringPacket,
   buildSubAgentSystemPrompt: () => buildSubAgentSystemPrompt,
+  buildTodoRenderModel: () => buildTodoRenderModel,
   buildTrajectoryCheckpoint: () => buildTrajectoryCheckpoint,
   buildTrajectoryGroundingPrompt: () => buildTrajectoryGroundingPrompt,
   buildUnitTodos: () => buildUnitTodos,
@@ -689311,6 +689895,9 @@ __export(dist_exports3, {
   createRootFeatureNode: () => createRootFeatureNode,
   createServicesManifest: () => createServicesManifest,
   createSteeringIngress: () => createSteeringIngress,
+  createTodoSnapshot: () => createTodoSnapshot,
+  createTodoSnapshotEvent: () => createTodoSnapshotEvent,
+  createTodoTransitionEvents: () => createTodoTransitionEvents,
   createValidationContract: () => createValidationContract,
   criticalPathDepth: () => criticalPathDepth,
   debugArtifactRoot: () => debugArtifactRoot,
@@ -689329,6 +689916,7 @@ __export(dist_exports3, {
   detectGitProgressBaseline: () => detectGitProgressBaseline,
   detectPressure: () => detectPressure,
   detectTaskType: () => detectTaskType,
+  diffTodoSnapshots: () => diffTodoSnapshots,
   discoverPlugins: () => discoverPlugins3,
   discoverSystemOllamaModelStore: () => discoverSystemOllamaModelStore,
   effectiveContextWindow: () => effectiveContextWindow,
@@ -689341,6 +689929,7 @@ __export(dist_exports3, {
   executeBatch: () => executeBatch,
   executeHook: () => executeHook,
   expandContextReference: () => expandContextReference,
+  expectedOutcomeAllowsTextOnlyCompletion: () => expectedOutcomeAllowsTextOnlyCompletion,
   extractClaims: () => extractClaims,
   extractConstraint: () => extractConstraint,
   extractContextSpansForGroundedness: () => extractContextSpansForGroundedness,
@@ -689424,7 +690013,9 @@ __export(dist_exports3, {
   mintClaimScopeToken: () => mintClaimScopeToken,
   mintScopeToken: () => mintScopeToken,
   missingCapabilityRecovery: () => missingCapabilityRecovery,
+  normalizeCompletionDeliveryReceipt: () => normalizeCompletionDeliveryReceipt,
   normalizeCompletionKey: () => normalizeCompletionKey,
+  normalizeExpectedOutcomeContractV1: () => normalizeExpectedOutcomeContractV1,
   normalizeMemoryCompilationPlanAudit: () => normalizeMemoryCompilationPlanAudit,
   noteAfterTask: () => noteAfterTask,
   operationalWorldStatePath: () => operationalWorldStatePath,
@@ -689592,6 +690183,7 @@ var init_dist8 = __esm({
     init_reference_contracts();
     init_deliveryCoverage();
     init_completionFinalization();
+    init_expectedOutcomeContract();
     init_ollama_pool();
     init_ollama_pool_cleanup();
     init_modelProfile();
@@ -689612,6 +690204,7 @@ var init_dist8 = __esm({
     init_completionLedger();
     init_integrationClosure();
     init_runEvents();
+    init_todoObservability();
     init_costTracker();
     init_workEvaluator();
     init_model_router();
@@ -781936,6 +782529,21 @@ function telegramInteractionDecisionResponseFormatForPacket(packet) {
     },
     maxItems: 16
   };
+  const outcomeContract = properties.expected_outcome_contract;
+  if (outcomeContract.properties) {
+    outcomeContract.properties.input_id = {
+      type: "string",
+      enum: [packet.inputId]
+    };
+    outcomeContract.properties.cited_evidence_ids = {
+      type: "array",
+      items: {
+        type: "string",
+        enum: packet.evidence.map((entry) => entry.id)
+      },
+      maxItems: 16
+    };
+  }
   return format3;
 }
 function extractPartialTelegramReplyJson(buffer2) {
@@ -782102,6 +782710,24 @@ function telegramThinkSuppressedRequest(request) {
   ) : [];
   return { ...request, messages: messages2, think: false };
 }
+function parseTelegramExpectedOutcomeContract(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
+  const raw = value2;
+  return normalizeExpectedOutcomeContractV1({
+    schema: raw["schema"],
+    route: raw["route"],
+    continuity: raw["continuity"],
+    activeScopeId: raw["active_scope_id"] ?? raw["activeScopeId"],
+    citedEvidenceIds: raw["cited_evidence_ids"] ?? raw["citedEvidenceIds"],
+    confidence: raw["confidence"],
+    reason: raw["reason"],
+    planningMode: raw["planning_mode"] ?? raw["planningMode"],
+    outcome: raw["outcome"],
+    requiredEffects: raw["required_effects"] ?? raw["requiredEffects"],
+    inputId: raw["input_id"] ?? raw["inputId"],
+    decisionId: raw["decision_id"] ?? raw["decisionId"]
+  });
+}
 function parseTelegramInteractionDecision(text3, forcedRoute, options2 = {}) {
   for (const jsonText of telegramDecisionJsonCandidates(text3)) {
     try {
@@ -782111,6 +782737,9 @@ function parseTelegramInteractionDecision(text3, forcedRoute, options2 = {}) {
       const parsedRoute = parsed["route"] === "chat" || parsed["route"] === "action" ? parsed["route"] : null;
       const route = forcedRoute ?? parsedRoute;
       if (!route) continue;
+      const expectedOutcomeContract = parseTelegramExpectedOutcomeContract(
+        parsed["expected_outcome_contract"] ?? parsed["expectedOutcomeContract"]
+      );
       const shouldReplyRaw = parsed["should_reply"] ?? parsed["shouldReply"];
       if (options2.requireShouldReply && typeof shouldReplyRaw !== "boolean")
         continue;
@@ -782143,6 +782772,7 @@ function parseTelegramInteractionDecision(text3, forcedRoute, options2 = {}) {
       );
       return {
         route,
+        ...expectedOutcomeContract ? { expectedOutcomeContract } : {},
         shouldReply,
         confidence: confidence2,
         reason,
@@ -782978,6 +783608,10 @@ function normalizeTelegramSubAgentLimit(value2) {
   );
 }
 function selectTelegramFinalResponse(args) {
+  const committedTerminalReply = cleanTelegramVisibleReply(
+    args.terminalUserReply || ""
+  );
+  if (committedTerminalReply) return committedTerminalReply;
   const committedVisibleReply = cleanTelegramVisibleReply(
     args.visibleReplyText || ""
   );
@@ -783041,11 +783675,58 @@ function renderTelegramLiveProgressHTML(progressLines, accumulated, steeringReco
 }
 function telegramAdminLivePanelPageLabel(page2) {
   if (page2 === "response") return "Reply";
+  if (page2 === "tasks") return "Tasks";
   if (page2 === "tools") return "Tools";
   if (page2 === "logs") return "Activity";
   if (page2 === "evidence") return "Evidence";
   return "Context";
 }
+function telegramAdminTodoProgressLabel(snapshot) {
+  if (!snapshot) return "Tasks";
+  return `Tasks ${snapshot.counts.leafStatus.completed}/${snapshot.counts.leaves}`;
+}
+function telegramAdminTodoMarker(status) {
+  if (status === "completed") return "✓";
+  if (status === "in_progress") return "●";
+  if (status === "blocked") return "!";
+  return "○";
+}
+function telegramAdminTodoPackets(snapshot) {
+  if (!snapshot) return [];
+  const model = buildTodoRenderModel(snapshot);
+  return model.rows.map((row2) => {
+    const status = row2.directChildCount > 0 ? row2.displayStatus : row2.status;
+    const indentation = "  ".repeat(Math.min(6, row2.depth));
+    const detail = [
+      `id=${row2.id}`,
+      `status=${status}`,
+      row2.directChildCount > 0 ? `leaf_progress=${row2.leafCounts.completed}/${Object.values(row2.leafCounts).reduce((sum2, count) => sum2 + count, 0)}` : "",
+      row2.owner ? `owner=${row2.owner}` : "",
+      row2.blocker ? `blocker=${row2.blocker}` : "",
+      row2.blockedBy?.length ? `blocked_by=${row2.blockedBy.join(", ")}` : ""
+    ].filter(Boolean).join("\n");
+    return {
+      title: `${telegramAdminTodoMarker(status)} ${indentation}${row2.content}`,
+      body: detail
+    };
+  });
+}
+function telegramAdminTodoTransitionLine(event) {
+  const transition2 = event.transition;
+  if (transition2.kind === "status_changed") {
+    return `${telegramAdminTodoMarker(transition2.to)} ${transition2.item.content}: ${transition2.from} → ${transition2.to}`;
+  }
+  if (transition2.kind === "created") {
+    return `○ ${transition2.item.content}: added`;
+  }
+  if (transition2.kind === "deleted") {
+    return `○ ${transition2.previous.content}: removed`;
+  }
+  if (transition2.kind === "reparented") {
+    return `○ ${transition2.item.content}: moved`;
+  }
+  return `○ ${transition2.item.content}: updated`;
+}
 function telegramPanelHtmlFallback(html) {
   const chunks = segmentTelegramHtml(html, 3600);
   if (chunks.length <= 1) return chunks[0] ?? "";
@@ -783203,6 +783884,7 @@ function createTelegramAdminLivePanelState(args) {
     activePage: "response",
     dirtyPages: {
       response: false,
+      tasks: false,
       tools: false,
       logs: false,
       evidence: false,
@@ -783215,6 +783897,7 @@ function createTelegramAdminLivePanelState(args) {
     responseSegments: [],
     responseSegmentSequence: 0,
     steeringReconciliations: [],
+    todoTransitionLines: [],
     evidenceText: "",
     toolLines: [],
     mutationLines: [],
@@ -783223,6 +783906,22 @@ function createTelegramAdminLivePanelState(args) {
     contextPages: []
   };
 }
+function applyTelegramAdminLivePanelRunEvent(state5, event) {
+  if (event.type === "todo_snapshot") {
+    state5.todoSnapshot = event.snapshot;
+    state5.updatedAt = Date.now();
+    if (state5.activePage !== "tasks") state5.dirtyPages.tasks = true;
+    return;
+  }
+  if (event.type !== "todo_transition") return;
+  const line = telegramAdminTodoTransitionLine(event);
+  if (state5.todoTransitionLines[state5.todoTransitionLines.length - 1] !== line) {
+    state5.todoTransitionLines.push(line);
+    trimTelegramAdminPanelLines(state5.todoTransitionLines, 24);
+  }
+  state5.updatedAt = Date.now();
+  if (state5.activePage !== "tasks") state5.dirtyPages.tasks = true;
+}
 function applyTelegramAdminLivePanelEvent(state5, event) {
   if (event.type === "stream_start") {
     const turn = telegramAdminEventTurn(event);
@@ -783316,6 +784015,32 @@ function renderTelegramAdminLivePanelPayload(state5) {
       steeringHtml,
       clipped ? convertMarkdownToTelegramHTML(clipped) : "<i>Working…</i>"
     ].filter(Boolean).join("\n\n");
+  } else if (state5.activePage === "tasks") {
+    const snapshot = state5.todoSnapshot;
+    const model = snapshot ? buildTodoRenderModel(snapshot) : void 0;
+    const transitions = state5.todoTransitionLines.slice(-8);
+    const rendered = renderTelegramPanelPage({
+      title: "Tasks",
+      subtitle: model ? `${model.counts.leafStatus.completed}/${model.counts.leaves} leaf tasks complete; ${model.counts.leafStatus.inProgress} active; ${model.counts.leafStatus.blocked} blocked.` : "No checklist exists for this run.",
+      metadata,
+      sections: [
+        {
+          title: "Checklist",
+          packets: telegramAdminTodoPackets(snapshot)
+        },
+        {
+          title: "Recent changes",
+          packets: transitions.map((line, index) => ({
+            title: `Change ${index + 1}`,
+            body: line
+          }))
+        }
+      ],
+      emptyText: "No checklist exists for this run.",
+      footer: "Page 2 of 6 · Tasks"
+    });
+    body = telegramPanelHtmlFallback(rendered.html);
+    richHtml = rendered.richHtml;
   } else if (state5.activePage === "tools") {
     const lines = state5.toolLines.slice(-12);
     const rendered = renderTelegramPanelPage({
@@ -783324,7 +784049,7 @@ function renderTelegramAdminLivePanelPayload(state5) {
       metadata,
       sections: [{ packets: telegramAdminLinePackets(lines, "Tool event") }],
       emptyText: "No tool calls yet.",
-      footer: "Page 2 of 5 · Tools"
+      footer: "Page 3 of 6 · Tools"
     });
     body = telegramPanelHtmlFallback(rendered.html);
     richHtml = rendered.richHtml;
@@ -783346,7 +784071,7 @@ function renderTelegramAdminLivePanelPayload(state5) {
         }
       ],
       emptyText: "No workspace changes or runner activity yet.",
-      footer: "Page 3 of 5 · Activity"
+      footer: "Page 4 of 6 · Activity"
     });
     body = telegramPanelHtmlFallback(rendered.html);
     richHtml = rendered.richHtml;
@@ -783361,7 +784086,7 @@ function renderTelegramAdminLivePanelPayload(state5) {
       metadata,
       sections: [{ packets }],
       emptyText: "No completion evidence yet.",
-      footer: "Page 4 of 5 · Evidence"
+      footer: "Page 5 of 6 · Evidence"
     });
     body = telegramPanelHtmlFallback(rendered.html);
     richHtml = rendered.richHtml;
@@ -783384,7 +784109,7 @@ function renderTelegramAdminLivePanelPayload(state5) {
   }
   const text3 = body;
   const pageButtons = TELEGRAM_ADMIN_LIVE_PANEL_PAGES.map((page2) => ({
-    text: `${page2 === state5.activePage ? "●" : "○"} ${telegramAdminLivePanelPageLabel(page2)}${state5.dirtyPages[page2] ? " *" : ""}`,
+    text: `${page2 === state5.activePage ? "●" : "○"} ${page2 === "tasks" ? telegramAdminTodoProgressLabel(state5.todoSnapshot) : telegramAdminLivePanelPageLabel(page2)}${state5.dirtyPages[page2] ? " *" : ""}`,
     callback_data: `omni:v1:tgadmin:${state5.nonce}:page:${page2}`,
     ...page2 === state5.activePage ? { style: "primary" } : {}
   }));
@@ -784735,6 +785460,7 @@ Telegram link integrity contract:
           required: [
             "input_id",
             "route",
+            "expected_outcome_contract",
             "should_reply",
             "confidence",
             "reason",
@@ -784747,6 +785473,65 @@ Telegram link integrity contract:
             recoverable: { type: "boolean" },
             input_id: { type: "string" },
             route: { type: "string", enum: ["chat", "action"] },
+            expected_outcome_contract: {
+              type: "object",
+              additionalProperties: false,
+              required: [
+                "schema",
+                "route",
+                "continuity",
+                "cited_evidence_ids",
+                "confidence",
+                "reason",
+                "planning_mode",
+                "outcome",
+                "required_effects",
+                "input_id"
+              ],
+              properties: {
+                schema: {
+                  type: "string",
+                  enum: ["omnius.expected-outcome-contract.v1"]
+                },
+                route: { type: "string", enum: ["chat", "action"] },
+                continuity: {
+                  type: "string",
+                  enum: ["new", "continue_active", "status_probe", "replace"]
+                },
+                active_scope_id: { anyOf: [{ type: "string" }, { type: "null" }] },
+                cited_evidence_ids: {
+                  type: "array",
+                  items: { type: "string" },
+                  maxItems: 16
+                },
+                confidence: { type: "number", minimum: 0, maximum: 1 },
+                reason: { type: "string" },
+                planning_mode: {
+                  type: "string",
+                  enum: ["none", "checklist"]
+                },
+                outcome: {
+                  type: "string",
+                  enum: ["conversation", "read_only", "mutation", "delivery"]
+                },
+                required_effects: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: [
+                      "visible_response",
+                      "observation",
+                      "mutation",
+                      "verification",
+                      "delivery"
+                    ]
+                  },
+                  minItems: 1,
+                  maxItems: 5
+                },
+                input_id: { type: "string" }
+              }
+            },
             should_reply: { type: "boolean" },
             confidence: { type: "number", minimum: 0, maximum: 1 },
             reason: { type: "string" },
@@ -784843,7 +785628,7 @@ Telegram link integrity contract:
     TELEGRAM_MODERATION_APPROVAL_TTL_MS = 5 * 6e4;
     TELEGRAM_MODERATION_APPROVAL_RETENTION_MS = 24 * 60 * 6e4;
     TELEGRAM_MODERATION_APPROVAL_MAX_RECORDS = 64;
-    TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA = `{"input_id":"exact host input_id","route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","addressed_actor_keys":["only actor keys from evidence packet"],"self_role":"addressee"|"participant"|"observer"|"uncertain","reply_basis":"direct_turn"|"ongoing_self_task"|"social_intervention"|"none"|"uncertain","evidence_ids":["only evidence ids from evidence packet"],"attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"explicit durable cadence preference"}}`;
+    TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA = `{"input_id":"exact host input_id","route":"chat"|"action","expected_outcome_contract":{"schema":"omnius.expected-outcome-contract.v1","route":"chat"|"action","continuity":"new"|"continue_active"|"status_probe"|"replace","active_scope_id":null|"active task scope id","cited_evidence_ids":["only evidence ids from evidence packet"],"confidence":0.0-1.0,"reason":"short outcome reason","planning_mode":"none"|"checklist","outcome":"conversation"|"read_only"|"mutation"|"delivery","required_effects":["visible_response"|"observation"|"mutation"|"verification"|"delivery"],"input_id":"exact host input_id"},"should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","addressed_actor_keys":["only actor keys from evidence packet"],"self_role":"addressee"|"participant"|"observer"|"uncertain","reply_basis":"direct_turn"|"ongoing_self_task"|"social_intervention"|"none"|"uncertain","evidence_ids":["only evidence ids from evidence packet"],"attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"explicit durable cadence preference"}}`;
     TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT = {
       type: "json_schema",
       json_schema: {
@@ -785022,6 +785807,7 @@ Telegram link integrity contract:
     TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT = 20;
     TELEGRAM_ADMIN_LIVE_PANEL_PAGES = [
       "response",
+      "tasks",
       "tools",
       "logs",
       "evidence",
@@ -786378,7 +787164,7 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
       }
       buildTelegramRouterUnavailableDecision(msg, toolContext, params) {
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
-        const route = forcedRoute ?? (msg.chatType === "private" ? "chat" : "action");
+        const route = forcedRoute ?? (toolContext === "telegram-admin-dm" ? "action" : msg.chatType === "private" ? "chat" : "action");
         const failOpen = this.shouldFailOpenTelegramRouterUnavailable(
           msg,
           toolContext
@@ -787759,7 +788545,7 @@ Model: <code>${escapeTelegramHTML(model.id)}</code>`
         const summary = result.success ? [
           `<b>Generation complete</b>`,
           artifactCount > 0 ? `Sent ${artifactCount} artifact${artifactCount === 1 ? "" : "s"}.` : "No artifact file was detected in the tool result.",
-          `<blockquote expandable>${escapeTelegramHTML(result.output || result.llmContent || "Done.")}</blockquote>`
+          `<blockquote expandable>${escapeTelegramHTML(result.output || result.llmContent || "The generation tool returned no text.")}</blockquote>`
         ].join("\n") : [
           `<b>Generation failed</b>`,
           `<blockquote expandable>${escapeTelegramHTML(result.error || result.output || "Unknown failure.")}</blockquote>`
@@ -792643,6 +793429,39 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
             message: `input_id must be ${JSON.stringify(packet.inputId)}.`
           });
         }
+        const expectedOutcomeContract = decision2.expectedOutcomeContract ? normalizeExpectedOutcomeContractV1(decision2.expectedOutcomeContract) : null;
+        if (expectedOutcomeContract) {
+          if (expectedOutcomeContract.route !== decision2.route) {
+            issues.push({
+              code: "outcome_route_mismatch",
+              message: `expected_outcome_contract.route must match route=${decision2.route}.`
+            });
+          }
+          if (expectedOutcomeContract.inputId !== packet.inputId) {
+            issues.push({
+              code: "outcome_input_id_mismatch",
+              message: `expected_outcome_contract.input_id must be ${JSON.stringify(packet.inputId)}.`
+            });
+          }
+          const allowedOutcomeEvidence = new Set(
+            packet.evidence.map((entry) => entry.id)
+          );
+          const unknownOutcomeEvidence = expectedOutcomeContract.citedEvidenceIds.filter(
+            (id2) => !allowedOutcomeEvidence.has(id2)
+          );
+          if (unknownOutcomeEvidence.length > 0) {
+            issues.push({
+              code: "unknown_outcome_evidence_id",
+              message: `expected_outcome_contract.cited_evidence_ids contains unknown values ${JSON.stringify(unknownOutcomeEvidence)}.`
+            });
+          }
+          if (decision2.shouldReply && !expectedOutcomeContract.requiredEffects.includes("visible_response")) {
+            issues.push({
+              code: "reply_outcome_missing_visible_response",
+              message: "A reply-worthy Telegram decision requires visible_response in expected_outcome_contract.required_effects."
+            });
+          }
+        }
         if (!decision2.selfRole) {
           issues.push({
             code: "missing_self_role",
@@ -792731,6 +793550,7 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
           JSON.stringify({
             inputId: packet.inputId,
             route: decision2.route,
+            expectedOutcomeContract,
             shouldReply: decision2.shouldReply,
             addressed,
             selfRole: decision2.selfRole,
@@ -792738,7 +793558,20 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
             evidenceIds
           })
         ).digest("hex").slice(0, 20)}`;
-        return { decision: { ...decision2, decisionId }, issues: [] };
+        return {
+          decision: {
+            ...decision2,
+            decisionId,
+            ...expectedOutcomeContract ? {
+              expectedOutcomeContract: {
+                ...expectedOutcomeContract,
+                inputId: packet.inputId,
+                decisionId
+              }
+            } : {}
+          },
+          issues: []
+        };
       }
       validateTelegramInteractionDecision(decision2, packet) {
         return this.validateTelegramInteractionDecisionDetailed(decision2, packet).decision;
@@ -792768,6 +793601,12 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
         const bound = {
           ...decision2,
           inputId: packet.inputId,
+          ...decision2.expectedOutcomeContract ? {
+            expectedOutcomeContract: {
+              ...decision2.expectedOutcomeContract,
+              inputId: packet.inputId
+            }
+          } : {},
           addressedActorKeys: [packet.selfActorKey],
           selfRole: "addressee",
           replyBasis: "direct_turn",
@@ -792827,7 +793666,15 @@ arguments=` : ""}` + (chunk.toolCallArgs ?? "");
             defaultShouldReply: false,
             requireShouldReply: true
           });
-          if (parsed && evidencePacket) parsed.inputId = evidencePacket.inputId;
+          if (parsed && evidencePacket) {
+            parsed.inputId = evidencePacket.inputId;
+            if (parsed.expectedOutcomeContract) {
+              parsed.expectedOutcomeContract = {
+                ...parsed.expectedOutcomeContract,
+                inputId: evidencePacket.inputId
+              };
+            }
+          }
           const normalized4 = parsed && evidencePacket ? this.normalizeTelegramInteractionDecisionImplications(
             parsed,
             evidencePacket
@@ -793194,8 +794041,9 @@ ${retryText}`,
           })()
         });
         if (!config) {
+          const fallbackRoute = forcedRoute ?? (toolContext === "telegram-admin-dm" ? "action" : isGroup ? "action" : "chat");
           const fallback = {
-            route: forcedRoute ?? (isGroup ? "action" : "chat"),
+            route: fallbackRoute,
             shouldReply: false,
             confidence: 0,
             reason: "router inference unavailable; no model-derived reply decision",
@@ -793302,6 +794150,10 @@ ${stimulationProbe.context}`,
           `Target binding: infer the addressees and this bot's role before should_reply. Another actor being addressed does not force silence; a reply can still be valid for an ongoing self-owned task or a socially useful intervention, but it must use that reply_basis and cite current evidence.`,
           `Authorization integrity: should_reply=true requires a non-none, non-uncertain reply_basis and at least one cited evidence_id. direct_turn requires self_role=addressee and the self actor key in addressed_actor_keys. ongoing_self_task requires the active_task evidence id.`,
           `Classification boundary: decide whether an action runner is needed, but do not execute a tool and do not emit a tool invocation. A required capability is represented only by route="action" in the attention schema.`,
+          `Expected-outcome boundary: produce expected_outcome_contract from the current input and cited host evidence. Do not derive it from keywords or a fixed request-category table.`,
+          `Required effects are cumulative. Use visible_response for conversation. Use observation for a current factual inspection. Use mutation for a requested state change. Add verification when the requested result must be checked after the final mutation. Use delivery only when an external provider acknowledgement is part of success.`,
+          `Use planning_mode="checklist" when the inferred work has multiple substantive dependent effects. Use planning_mode="none" for direct conversation or one bounded effect.`,
+          `Continuity and active_scope_id must describe whether this input starts, continues, probes, or replaces the active scoped task. Cite only evidence IDs supplied by the host.`,
           ``,
           `Schema: ${TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA}`,
           ``,
@@ -793429,7 +794281,15 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             defaultShouldReply: false,
             requireShouldReply: true
           });
-          if (parsed) parsed.inputId = evidencePacket.inputId;
+          if (parsed) {
+            parsed.inputId = evidencePacket.inputId;
+            if (parsed.expectedOutcomeContract) {
+              parsed.expectedOutcomeContract = {
+                ...parsed.expectedOutcomeContract,
+                inputId: evidencePacket.inputId
+              };
+            }
+          }
           const normalized4 = parsed ? this.normalizeTelegramInteractionDecisionImplications(
             parsed,
             evidencePacket
@@ -794842,7 +795702,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
         if (event.contextFrame || state5.contextPages.length === 0 && (subAgent.contextFrame || subAgent.promptSnapshot)) {
           this.refreshTelegramAdminLivePanelContextPages(state5, subAgent, msg);
         }
-        if (state5.messageId === void 0 && !state5.responseText.trim()) {
+        if (state5.messageId === void 0 && !state5.responseText.trim() && !state5.todoSnapshot && state5.toolLines.length === 0 && state5.mutationLines.length === 0 && state5.logLines.length === 0) {
           return;
         }
         const now2 = Date.now();
@@ -794858,13 +795718,29 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
           });
         }
       }
+      updateTelegramAdminLivePanelFromRunEvent(subAgent, msg, event) {
+        const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
+        applyTelegramAdminLivePanelRunEvent(state5, event);
+        const now2 = Date.now();
+        if (state5.messageId !== void 0 && now2 - subAgent.lastEditMs <= 900) {
+          return;
+        }
+        subAgent.lastEditMs = now2;
+        if (subAgent.liveMessagePromise) return;
+        subAgent.liveMessagePromise = this.renderTelegramAdminLivePanel(state5).then(() => {
+          subAgent.liveMessageId = state5.messageId ?? null;
+        }).catch(() => {
+        }).finally(() => {
+          subAgent.liveMessagePromise = null;
+        });
+      }
       async finalizeTelegramAdminLivePanel(subAgent, msg, replyText, status = "completed", evidenceText = "") {
         const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
         state5.status = status;
         state5.steeringReconciliations = [
           ...subAgent.steeringReconciliations.values()
         ];
-        state5.responseText = replyText || (status === "failed" ? "I couldn't complete that request." : "Done.");
+        state5.responseText = replyText || (status === "failed" ? "I couldn't complete that request. Open Evidence for the recorded blocker." : "The run reached its completion boundary, but it did not produce a user-facing result. Open Evidence for the recorded outcome.");
         state5.responseSegments = [];
         state5.activeResponseSegmentKey = void 0;
         if (evidenceText.trim()) {
@@ -794968,6 +795844,8 @@ ${signals || "No final validating tool/status signal was available."}`
         const verified = [
           `Backend status: ${subAgent.runnerStatus || (subAgent.runnerCompleted ? "completed" : "unknown")}.`,
           stats ? `Run shape: ${stats}.` : "",
+          subAgent.runnerTerminalReceiptId ? `Terminal receipt: ${subAgent.runnerTerminalReceiptId}.` : "",
+          subAgent.runnerExpectedOutcomeAssessment ? `Expected outcome: ${subAgent.runnerExpectedOutcomeAssessment.satisfied ? "satisfied" : "not satisfied"}; observed ${subAgent.runnerExpectedOutcomeAssessment.observedEffects.join(", ") || "none"}; missing ${subAgent.runnerExpectedOutcomeAssessment.missingEffects.join(", ") || "none"}.` : "",
           failures.length > 0 ? `⚠ ${failures.length} tool call(s) failed without a confirmed retry — treat any success claim above as unverified.` : "",
           summary && summary !== finalText ? `Runner summary: ${summary}` : ""
         ].filter(Boolean).join("\n");
@@ -795761,16 +796639,23 @@ Join: ${newUrl}`
         );
         let decision2;
         if (isAdminDM) {
-          decision2 = {
-            route: this.interactionMode === "action" ? "action" : "chat",
-            shouldReply: true,
-            confidence: 1,
-            reason: "authenticated admin DM is direct operator work",
-            source: "forced-mode",
-            silentDisposition: "directly admitted to the Telegram AgenticRunner",
-            routerMode: "consolidated",
-            routerLatencyMs: 0
-          };
+          try {
+            decision2 = await this.inferTelegramInteractionDecisionCoalesced(
+              msg,
+              toolContext
+            );
+          } catch (err) {
+            decision2 = this.fallbackTelegramRouterDecision(msg, toolContext, err);
+          }
+          decision2 = this.bindTrustedTelegramDecision(
+            {
+              ...decision2,
+              shouldReply: true,
+              reason: `${decision2.reason}; authenticated admin DM is direct operator work`,
+              silentDisposition: "directly admitted to the Telegram AgenticRunner"
+            },
+            this.buildTelegramInteractionEvidencePacket(msg)
+          );
         } else {
           try {
             decision2 = await this.inferTelegramInteractionDecisionCoalesced(
@@ -795879,7 +796764,8 @@ Join: ${newUrl}`
             msg,
             toolContext,
             rapidContext,
-            decisionContext
+            decisionContext,
+            decision2.expectedOutcomeContract
           );
           if (shouldDeferNotes && visibleReplyDelivered) {
             this.deliverTelegramPostReplyNotes(
@@ -795939,6 +796825,7 @@ Join: ${newUrl}`
           assistantText: "",
           streamText: "",
           visibleReplyText: "",
+          terminalUserReply: "",
           currentStreamToolNames: /* @__PURE__ */ new Set(),
           toolNamesThisRun: /* @__PURE__ */ new Set(),
           successfulToolNamesThisRun: /* @__PURE__ */ new Set(),
@@ -795954,6 +796841,7 @@ Join: ${newUrl}`
           pendingContextPackets: [],
           runId: `telegram:${randomBytes29(8).toString("hex")}`,
           taskEpoch: work.intakeRecords[work.intakeRecords.length - 1]?.taskEpoch ?? this.telegramTaskEpoch(sessionKey),
+          expectedOutcomeContract: decision2.expectedOutcomeContract,
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(
             msg,
             toolContext
@@ -796082,7 +796970,7 @@ Join: ${newUrl}`
                 subAgent,
                 ""
               );
-              const deliveredFinalText2 = "Done.";
+              const deliveredFinalText2 = "The run reached its completion boundary, but it did not produce a user-facing result. Open Evidence for the recorded outcome.";
               this.subAgentViewCallbacks?.onWrite(
                 subAgent.viewId,
                 `completed: ${evidenceText}`
@@ -796281,7 +797169,7 @@ ${errMsg}`
         }
       }
       /** Admin quick-chat: conversational profile with full admin context/tools. */
-      async handleTelegramAdminChatAgent(msg, toolContext, additionalContext = "") {
+      async handleTelegramAdminChatAgent(msg, toolContext, additionalContext = "", authorizationContext = "", expectedOutcomeContract) {
         const sessionKey = this.sessionKeyForMessage(msg);
         const subAgent = {
           chatId: msg.chatId,
@@ -796295,6 +797183,7 @@ ${errMsg}`
           assistantText: "",
           streamText: "",
           visibleReplyText: "",
+          terminalUserReply: "",
           currentStreamToolNames: /* @__PURE__ */ new Set(),
           toolNamesThisRun: /* @__PURE__ */ new Set(),
           successfulToolNamesThisRun: /* @__PURE__ */ new Set(),
@@ -796310,6 +797199,7 @@ ${errMsg}`
           pendingContextPackets: [],
           runId: `telegram:${randomBytes29(8).toString("hex")}`,
           taskEpoch: this.telegramTaskEpoch(sessionKey),
+          expectedOutcomeContract,
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(
             msg,
             toolContext
@@ -796378,7 +797268,8 @@ ${errMsg}`
             subAgent,
             mediaContext,
             "chat",
-            additionalContext
+            additionalContext,
+            authorizationContext
           ).catch((err) => {
             if (subAgent.preempted) return "";
             throw err;
@@ -796444,7 +797335,7 @@ ${errMsg}`
             return false;
           }
           if (!finalText) {
-            const deliveredFinalText2 = "Done.";
+            const deliveredFinalText2 = "The run reached its completion boundary, but it did not produce a user-facing result. Open Evidence for the recorded outcome.";
             const evidenceText2 = this.telegramAdminCompletionRunText(subAgent, "");
             this.subAgentViewCallbacks?.onWrite(subAgent.viewId, evidenceText2);
             this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
@@ -796582,12 +797473,14 @@ ${errMsg}`
         }
       }
       /** Fast Telegram chat path: direct streamed completion, no tool loop. */
-      async handleTelegramChatCompletion(msg, toolContext, additionalContext = "", authorizationContext = "") {
+      async handleTelegramChatCompletion(msg, toolContext, additionalContext = "", authorizationContext = "", expectedOutcomeContract) {
         if (toolContext === "telegram-admin-dm") {
           return this.handleTelegramAdminChatAgent(
             msg,
             toolContext,
-            additionalContext
+            additionalContext,
+            authorizationContext,
+            expectedOutcomeContract
           );
         }
         const viewId = `${this.viewIdForMessage(msg)}-chat`;
@@ -796928,7 +797821,6 @@ ${conversationStream}`
         );
       }
       retainTelegramVisibleReplyDraft(subAgent, draft, streamToolNames = subAgent.currentStreamToolNames) {
-        if (subAgent.visibleReplyText) return;
         const clean7 = cleanTelegramVisibleReply(draft);
         if (!clean7) return;
         const toolNames = [...streamToolNames];
@@ -797010,12 +797902,13 @@ ${creativeWorkspace}` : ""
           contextWindowSize,
           modelTier: modelTier2,
           disableTodoCompletionGuard: true,
-          disableTodoPlanningNudges: true,
+          disableTodoPlanningNudges: subAgent.expectedOutcomeContract?.planningMode !== "checklist",
+          expectedOutcomeContract: subAgent.expectedOutcomeContract,
           // The attention router already classified this private-admin turn as
           // chat. Accept its first visible assistant answer as the terminal result
           // instead of spending two more generations demanding task_complete.
           // Action routes keep the normal explicit completion/evidence boundary.
-          acceptTextOnlyCompletion: isAdminDM && profile === "chat",
+          acceptTextOnlyCompletion: isAdminDM && profile === "chat" && subAgent.expectedOutcomeContract?.route === "chat",
           streamEnabled: true,
           dynamicContext: runnerDynamicContext,
           captureContextFrame: true,
@@ -797044,6 +797937,9 @@ ${creativeWorkspace}` : ""
           // ── WO #03 (Typed Gateway Event Stream): structured event feed ──
           onTypedEvent: (event) => {
             this.forwardTelegramRunnerIntakeLifecycle(event);
+            if (isAdminDM && (event.type === "todo_snapshot" || event.type === "todo_transition")) {
+              this.updateTelegramAdminLivePanelFromRunEvent(subAgent, msg, event);
+            }
             if (event.type === "steering_lifecycle" && event.reconciliation) {
               upsertTelegramSteeringReconciliation(
                 subAgent.steeringReconciliations,
@@ -797341,11 +798237,14 @@ ${additionalContext}`;
         subAgent.runnerTurns = result.turns;
         subAgent.runnerToolCalls = result.toolCalls;
         subAgent.runnerSummary = result.summary;
+        subAgent.runnerTerminalReceiptId = result.terminalReceiptId;
+        subAgent.runnerExpectedOutcomeAssessment = result.expectedOutcomeAssessment;
         if (result.status === "completed") subAgent.completionBoundarySeen = true;
         if (result.status === "incomplete_verification") {
           subAgent.completionBoundarySeen = false;
         }
-        const finalResponse = selectTelegramFinalResponse({
+        const candidateFinalReply = selectTelegramFinalResponse({
+          terminalUserReply: subAgent.terminalUserReply,
           visibleReplyText: subAgent.visibleReplyText,
           assistantText: subAgent.assistantText,
           streamText: subAgent.streamText,
@@ -797353,13 +798252,13 @@ ${additionalContext}`;
           summary: result.summary,
           completionBoundarySeen: subAgent.completionBoundarySeen
         });
-        const scrutinyText = [finalResponse, result.summary].filter(Boolean).join("\n");
-        const violations = auditPerceptionClaims(scrutinyText, {
+        const violations = auditPerceptionClaims(candidateFinalReply, {
           toolsUsed: [
             ...subAgent.successfulToolNamesThisRun,
             ...telegramMediaContextEvidenceTools(mediaContext)
           ]
         });
+        let validatedFinalReply = candidateFinalReply;
         if (violations.length > 0) {
           this.subAgentViewCallbacks?.onWrite(
             subAgent.viewId,
@@ -797368,11 +798267,11 @@ ${additionalContext}`;
           const needed = [...new Set(violations.map((v) => v.requiredTool))].join(
             "; "
           );
-          return finalResponse ? `${finalResponse}
+          validatedFinalReply = candidateFinalReply ? `${candidateFinalReply}
 
 Verification note: I have not actually run ${needed} for the unsupported action claim above.` : `I have not actually run ${needed} yet, so I cannot verify that claim.`;
         }
-        return finalResponse;
+        return validatedFinalReply;
       }
       telegramScopedMemoryPrefix(chatId) {
         const raw = chatId === void 0 ? "unknown" : String(chatId);
@@ -798338,13 +799237,17 @@ Scoped workspace: ${scopedRoot}`,
         const bridge = this;
         const taskComplete = {
           name: "task_complete",
-          description: "Internal completion signal for Telegram runs. Put the actual user-facing reply in assistant text before calling this. Acquired public media must first pass semantic analysis and receive a Telegram delivery receipt; this tool enforces both conditions. Use summary 'no_reply' only to silently skip responding; never write that sentinel as assistant text.",
+          description: "Internal completion signal for Telegram runs. Put the natural, evidence-grounded Telegram reply in user_reply (preferred) or assistant text before calling this. summary is internal lifecycle bookkeeping and is never sent to Telegram. Acquired public media must first pass semantic analysis and receive a Telegram delivery receipt; this tool enforces both conditions. Use summary 'no_reply' only to silently skip responding; never write that sentinel as assistant text or user_reply.",
           parameters: {
             type: "object",
             properties: {
               summary: {
                 type: "string",
                 description: "Internal completion note, or 'no_reply' to skip when no assistant reply should be sent. This is never shown directly to Telegram."
+              },
+              user_reply: {
+                type: "string",
+                description: "Optional exact natural-language reply to send to the Telegram user. Ground claims in successful tool evidence. This takes precedence over prior planning drafts; task_complete.summary never substitutes for it."
               }
             },
             required: ["summary"]
@@ -798382,9 +799285,16 @@ Scoped workspace: ${scopedRoot}`,
                 };
               }
             }
+            const terminalUserReply = cleanTelegramVisibleReply(
+              typeof args["user_reply"] === "string" ? args["user_reply"] : ""
+            );
+            if (activeSubAgent && terminalUserReply) {
+              activeSubAgent.terminalUserReply = terminalUserReply;
+            }
             return {
               success: true,
-              output: args["summary"] || "complete"
+              output: args["summary"] || "complete",
+              completionVisibleResponse: Boolean(terminalUserReply)
             };
           }
         };
@@ -798880,6 +799790,16 @@ Scoped workspace: ${scopedRoot}`,
                 currentMsg
               });
               const reportedMutation = result && typeof result === "object" && !Array.isArray(result) && typeof result["mutated"] === "boolean" ? Boolean(result["mutated"]) : void 0;
+              const resultRecord = result && typeof result === "object" && !Array.isArray(result) ? result : void 0;
+              const deliveredMessageId = Number(resultRecord?.["message_id"]);
+              const deliveredTarget = resultRecord?.["chat_id"];
+              const deliveryReceipt = action === "send_message" && (typeof deliveredTarget === "string" || typeof deliveredTarget === "number") && Number.isInteger(deliveredMessageId) && deliveredMessageId > 0 ? {
+                schema: "omnius.completion-delivery-receipt.v1",
+                provider: "telegram",
+                target: String(deliveredTarget),
+                receiptId: `message:${deliveredMessageId}`,
+                deliveredAtIso: (/* @__PURE__ */ new Date()).toISOString()
+              } : void 0;
               return {
                 success: true,
                 output: typeof result === "string" ? result : JSON.stringify(result, null, 2),
@@ -798888,7 +799808,11 @@ Scoped workspace: ${scopedRoot}`,
                 mutated: reportedMutation ?? TELEGRAM_TOOL_MUTATING_GROUPS.has(
                   TELEGRAM_TOOL_ACTION_GROUP[action]
                 ),
-                mutatedFiles: []
+                mutatedFiles: [],
+                ...deliveryReceipt ? {
+                  completionEvidenceRole: "delivery",
+                  completionDeliveryReceipt: deliveryReceipt
+                } : {}
               };
             } catch (err) {
               return {
@@ -801909,14 +802833,26 @@ ${objectMemory.contextBlock}`
                 currentMsg,
                 ledgerPath
               );
-              return {
+              const deliveredResult = {
                 success: true,
                 output: `Sent Telegram file: ${basename44(file.path)} as ${kind} to ${String(target.chatId)}${messageId ? ` (message_id ${messageId})` : ""}`,
                 llmContent: `Sent ${basename44(file.path)} to Telegram as ${kind}.`,
                 durationMs: performance.now() - start2,
                 mutated: false,
-                mutatedFiles: []
+                mutatedFiles: [],
+                ...messageId ? {
+                  completionEvidenceRole: "delivery",
+                  completionDeliveryReceipt: {
+                    schema: "omnius.completion-delivery-receipt.v1",
+                    provider: "telegram",
+                    target: String(target.chatId),
+                    receiptId: `message:${messageId}`,
+                    deliveredAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+                    artifactPaths: [ledgerPath]
+                  }
+                } : {}
               };
+              return deliveredResult;
             } catch (err) {
               return {
                 success: false,