omnius 1.0.550 → 1.0.551

package/dist/index.js

@@ -571719,48 +571719,44 @@ function ago(ms) {
   const h = Math.floor(m2 / 60);
   return `${h}h ago`;
 }
-function computeNextActionHint(reconciled, recentFailures, focusDirective) {
-  if (focusDirective?.requiredNextAction) {
-    const reason = focusDirective.reason ? ` Reason: ${focusDirective.reason.slice(0, 180)}.` : "";
-    return `Active recovery directive requires ${focusDirective.requiredNextAction}.${reason} Follow that before completion or unrelated work.`;
-  }
+function computeNextActionHint(reconciled, recentFailures, _focusDirective) {
   if (recentFailures.length > 0) {
     const first2 = recentFailures[0];
-    return `Resolve or explicitly account for unresolved failure "${first2.stem}" (${first2.attempts} attempt${first2.attempts === 1 ? "" : "s"}). Do not infer completion from plan state while failures remain.`;
+    return `Unresolved failure: "${first2.stem}" (${first2.attempts} attempt${first2.attempts === 1 ? "" : "s"}).`;
   }
   const inProgress = reconciled.find((t2) => t2.reconciled === "in_progress");
   if (inProgress)
-    return `Continue your in-progress item: "${inProgress.content.slice(0, 100)}".`;
+    return `In-progress plan item: "${inProgress.content.slice(0, 100)}".`;
   const claimedMissing = reconciled.filter((t2) => t2.reconciled === "claimed_missing");
   if (claimedMissing.length > 0) {
     const first2 = claimedMissing[0];
     const missing = first2.artifactCheck?.find((c9) => c9.reason === "missing")?.path;
-    return `A completed todo claims an artifact that is missing on disk: "${first2.content.slice(0, 60)}" — expected ${missing ?? "an artifact"}. Either produce it or correct the todo.`;
+    return `Plan/disk mismatch: completed todo "${first2.content.slice(0, 60)}" claims missing ${missing ?? "artifact"}.`;
   }
   const claimedEmpty = reconciled.filter((t2) => t2.reconciled === "claimed_empty");
   if (claimedEmpty.length > 0) {
     const first2 = claimedEmpty[0];
-    return `A completed todo declares an empty artifact: "${first2.content.slice(0, 60)}". Fill it in or revise the todo.`;
+    return `Plan/disk mismatch: completed todo "${first2.content.slice(0, 60)}" declares an empty artifact.`;
   }
   const claimedNoProof = reconciled.filter((t2) => t2.reconciled === "claimed_no_proof");
   if (claimedNoProof.length > 0) {
     const first2 = claimedNoProof[0];
-    return `A completed todo has no on-disk evidence: "${first2.content.slice(0, 80)}". Add declaredArtifacts to the next todo_write so completion is verifiable.`;
+    return `Plan evidence gap: completed todo "${first2.content.slice(0, 80)}" has no declared on-disk evidence.`;
   }
   const pending2 = reconciled.filter((t2) => t2.reconciled === "pending");
   if (pending2.length > 0) {
     const first2 = pending2[0];
-    return `Next pending plan item: "${first2.content.slice(0, 100)}". Take direct action toward it.`;
+    return `Pending plan item: "${first2.content.slice(0, 100)}".`;
   }
   const completedUnverified = reconciled.filter((t2) => t2.reconciled === "completed_unverified");
   if (completedUnverified.length > 0) {
     const first2 = completedUnverified[0];
-    return `A completed todo has a verifyCommand that hasn't run during this snapshot: ${first2.rationale}`;
+    return `Verification evidence is absent for completed todo: ${first2.rationale}`;
   }
   if (reconciled.length === 0) {
-    return `No declared plan items are available. Continue from the active goal and evidence; report completion only with direct verification.`;
+    return `No declared plan items are available.`;
   }
-  return `Declared plan items have no visible gaps. Continue from the active goal and evidence; report completion only with direct verification.`;
+  return `Declared plan items have no visible disk gaps in this snapshot.`;
 }
 function regenerate(opts) {
   const startMs = Date.now();
@@ -571855,22 +571851,11 @@ function regenerate(opts) {
     }
   }
   lines.push(``);
-  if (opts.focusDirective?.requiredNextAction) {
-    lines.push(`ACTIVE RECOVERY DIRECTIVE:`);
-    lines.push(`  required_next_action=${opts.focusDirective.requiredNextAction}`);
-    if (opts.focusDirective.state) {
-      lines.push(`  state=${opts.focusDirective.state}`);
-    }
-    if (opts.focusDirective.reason) {
-      lines.push(`  reason=${opts.focusDirective.reason.slice(0, 240)}`);
-    }
-    lines.push(``);
-  }
   const nextActionHint = computeNextActionHint(reconciled, opts.recentFailures, opts.focusDirective);
-  lines.push(`SUGGESTED NEXT STEP (derived from gap analysis, not authoritative):`);
+  lines.push(`PLAN / FAILURE DIAGNOSTIC:`);
   lines.push(`  ${nextActionHint}`);
   lines.push(``);
-  lines.push(`This snapshot replaces re-derivation by tool calls. Prior <world-state> blocks have been stripped from this conversation. Re-listing the workspace or re-reading completed todos is unproductive — the data is in this block.`);
+  lines.push(`Snapshot scope: workspace scan, reconciled plan, and unresolved failures at generation time. Prior world-state snapshots are replaced on regeneration.`);
   lines.push(`</world-state>`);
   const block = lines.join("\n");
   return {
@@ -572715,35 +572700,8 @@ ${item.outputPreview ?? ""}`));
   return directive;
 }
 function renderDirectiveAsMessage(d2) {
-  if (d2.parseFallback) {
-    return "";
-  }
-  const lines = [];
-  lines.push(`[STUCK-STATE META-ANALYZER — REG-49]`);
-  lines.push(``);
-  lines.push(`A meta-analyzer sub-agent reviewed the recent tool-call pattern, the`);
-  lines.push(`current world state, and the plan; it produced a single concrete`);
-  lines.push(`unblocking action for you to take.`);
-  lines.push(``);
-  lines.push(`DIAGNOSIS: ${d2.diagnosis}`);
-  lines.push(``);
-  lines.push(`STOP DOING (anti-pattern): ${d2.anti_pattern}`);
-  lines.push(``);
-  lines.push(`DO NEXT:`);
-  lines.push(`  Tool: ${d2.next_action.tool}`);
-  const argsJson = JSON.stringify(d2.next_action.args_seed, null, 2);
-  lines.push(`  Args:`);
-  for (const ln of argsJson.split("\n"))
-    lines.push(`    ${ln}`);
-  lines.push(`  Rationale: ${d2.next_action.rationale}`);
-  lines.push(``);
-  lines.push(`AFTER THE ACTION, verify with: ${d2.verification}`);
-  lines.push(``);
-  lines.push(`This directive comes from a meta-analysis of YOUR recent activity. Treat`);
-  lines.push(`the args as a bounded recommendation, not permission to invent a target.`);
-  lines.push(`If its evidence is stale or insufficient, first refresh the cited target`);
-  lines.push(`or run the listed verification; do not repeat the anti-pattern.`);
-  return lines.join("\n");
+  void d2;
+  return "";
 }
 async function runStuckAnalyzer(opts) {
   const startMs = Date.now();
@@ -573121,42 +573079,8 @@ function parseFrameVerdict(rawResponse) {
   };
 }
 function renderVerdictAsMessage(v) {
-  if (v.parseFallback)
-    return "";
-  if (v.verdict === "continue")
-    return "";
-  const lines = [];
-  lines.push(`[PROBLEM-FRAME VALIDATION — REG-51 — ${v.verdict.toUpperCase()}]`);
-  lines.push(``);
-  lines.push(`A meta-strategy validator reviewed your goal, current sub-task, and recent`);
-  lines.push(`activity. Verdict:`);
-  lines.push(``);
-  lines.push(`  ${v.rationale}`);
-  lines.push(``);
-  if (v.verdict === "simplify" || v.verdict === "pivot") {
-    const rf = v.recommended_frame;
-    const verb = v.verdict === "simplify" ? "SHRINK YOUR CURRENT FRAME" : "PIVOT TO A DIFFERENT FRAME";
-    lines.push(`${verb}:`);
-    lines.push(``);
-    lines.push(`  New sub-task:       ${rf.new_subtask}`);
-    lines.push(`  Why this is better: ${rf.why_better}`);
-    lines.push(`  Done when:          ${rf.success_criterion}`);
-    lines.push(``);
-    lines.push(`Update your todo list to reflect this new framing on your next response.`);
-    lines.push(`Then take ONE concrete action toward the new sub-task. Do NOT continue`);
-    lines.push(`the previous approach — it has been judged ${v.verdict === "pivot" ? "wrong" : "too ambitious"} for`);
-    lines.push(`your current state.`);
-  } else if (v.verdict === "declare-blocked") {
-    lines.push(`DECLARE BLOCKED:`);
-    lines.push(``);
-    lines.push(`  ${v.blocker_summary}`);
-    lines.push(``);
-    lines.push(`Call task_complete with a summary that names this blocker EXPLICITLY. Do`);
-    lines.push(`not pretend the work is done; do not keep iterating. The validator has`);
-    lines.push(`determined no productive frame exists from this state. Surface the`);
-    lines.push(`blocker and let the user / next agent intervene.`);
-  }
-  return lines.join("\n");
+  void v;
+  return "";
 }
 async function runFrameValidator(opts) {
   const startMs = Date.now();
@@ -574048,9 +573972,8 @@ function buildTrajectoryCheckpoint(input) {
     doNotRepeat.push("Retrying the blocked action unchanged without new evidence.");
   } else if (focus) {
     assessment = "recovery_required";
-    nextAction = extractFocusNextAction(focus) || nextAction;
-    successEvidence = "The focus recovery requirement is satisfied by a fresh tool observation.";
-    doNotRepeat.push("Ignoring the active focus recovery directive.");
+    const focusDiagnostic = extractFocusNextAction(focus);
+    successEvidence = focusDiagnostic ? `Active controller directive remains unresolved: ${focusDiagnostic}` : "An active controller directive is unresolved; its evidence is recorded separately.";
   } else if (hasRecentFailure && !fullWriteRecoveredByMutation) {
     assessment = "recovery_required";
     nextAction = "Use the newest failure evidence to make one different, narrow diagnostic or repair action.";
@@ -574156,7 +574079,7 @@ function buildTrajectoryCheckpoint(input) {
 }
 function renderTrajectoryCheckpoint(checkpoint, maxChars = 1100) {
   const lines = [
-    "[TRAJECTORY CHECKPOINT]",
+    "[TRAJECTORY DIAGNOSTIC]",
     `revision=${checkpoint.revision} turn=${checkpoint.turn} trigger=${checkpoint.trigger}`,
     `Goal: ${checkpoint.goal}`,
     `Assessment: ${checkpoint.assessment}`,
@@ -574164,8 +574087,8 @@ function renderTrajectoryCheckpoint(checkpoint, maxChars = 1100) {
     checkpoint.currentStep ? `Current step: ${checkpoint.currentStep}` : null,
     // Keep the action contract ahead of explanatory evidence so truncation can
     // never hide the guard that the main agent must follow.
-    `Required next action: ${checkpoint.nextAction}`,
-    `Success evidence: ${checkpoint.successEvidence}`,
+    `Observed next action: ${checkpoint.nextAction}`,
+    `Observed success evidence: ${checkpoint.successEvidence}`,
     checkpoint.situationAssessment ? `${checkpoint.groundingSource === "model" ? "Reasoned situation" : "Safety orientation"}: ${checkpoint.situationAssessment}` : null,
     checkpoint.groundingEvidenceRefs?.length ? `Grounding evidence: ${checkpoint.groundingEvidenceRefs.join(", ")}` : null,
     checkpoint.completedWork.length > 0 ? `Completed evidence-backed work: ${checkpoint.completedWork.join("; ")}` : null,
@@ -574173,9 +574096,8 @@ function renderTrajectoryCheckpoint(checkpoint, maxChars = 1100) {
     ...checkpoint.groundedFacts.map((fact) => `- [${fact.evidence}; ${fact.freshness}] ${fact.statement}`),
     checkpoint.openQuestions.length > 0 ? "Open questions:" : null,
     ...checkpoint.openQuestions.map((question) => `- ${question}`),
-    checkpoint.doNotRepeat.length > 0 ? "Do not repeat:" : null,
-    ...checkpoint.doNotRepeat.map((constraint) => `- ${constraint}`),
-    "Attention rule: reconcile the next tool call with this checkpoint. Treat stale or unknown evidence as a reason to read or verify. Do not quote this checkpoint or produce a reasoning transcript."
+    checkpoint.doNotRepeat.length > 0 ? "Recorded retry risks:" : null,
+    ...checkpoint.doNotRepeat.map((constraint) => `- ${constraint}`)
   ].filter((line) => Boolean(line));
   return truncate2(lines.join("\n"), maxChars);
 }
@@ -578054,65 +577976,6 @@ function normalizeFailurePatterns(patterns) {
     return a2.signature.localeCompare(b.signature);
   });
 }
-function buildFailureModeHandoff(input) {
-  const toolCalls = input.toolCallLog ?? [];
-  const maxRecentCalls = input.maxRecentCalls ?? 8;
-  const recentCalls = maxRecentCalls > 0 ? toolCalls.slice(-maxRecentCalls) : [];
-  const failedCalls = toolCalls.filter((call) => call.success === false);
-  const modified = normalizeModifiedFiles(input.taskState?.modifiedFiles);
-  const failedApproaches = input.taskState?.failedApproaches ?? [];
-  const completedSteps = input.taskState?.completedSteps ?? [];
-  const pendingSteps = input.taskState?.pendingSteps ?? [];
-  const currentStep = cleanInline(input.taskState?.currentStep, 180);
-  const nextAction = cleanInline(input.taskState?.nextAction, 180);
-  const goal = cleanInline(input.taskGoal || input.taskState?.goal || input.taskState?.originalGoal || "", 260);
-  const patterns = normalizeFailurePatterns(input.errorPatterns).slice(0, input.maxPatterns ?? 10);
-  if (patterns.length === 0 && recentCalls.length === 0 && modified.length === 0 && failedApproaches.length === 0 && !goal) {
-    return null;
-  }
-  const lines = ["[FAILURE-MODE INTAKE]"];
-  if (goal)
-    lines.push(`Goal: ${goal}`);
-  if (patterns.length > 0) {
-    lines.push("Top persisted failure modes:");
-    for (const p2 of patterns) {
-      const guidance = p2.guidance ? ` - ${p2.guidance}` : "";
-      lines.push(`- ${p2.signature} x${p2.count}${guidance}`);
-    }
-  }
-  if (recentCalls.length > 0) {
-    const total = toolCalls.length;
-    const failed = failedCalls.length;
-    const mutations = toolCalls.filter((call) => call.mutated || (call.mutatedFiles?.length ?? 0) > 0).length;
-    lines.push(`Current run: ${total} tool calls, ${failed} failed, ${mutations} mutation calls.`);
-    const lastFailure = failedCalls[failedCalls.length - 1];
-    if (lastFailure) {
-      const preview = cleanInline(lastFailure.outputPreview, 240);
-      lines.push(`Last raw failure: ${lastFailure.name}${preview ? ` - ${preview}` : ""}`);
-    }
-  }
-  if (modified.length > 0) {
-    lines.push(`Files touched: ${modified.slice(-8).map(([path16, action]) => `${path16} (${action})`).join(", ")}`);
-  } else {
-    lines.push("Files touched: none recorded.");
-  }
-  if (completedSteps.length > 0) {
-    lines.push(`Recent completed steps: ${completedSteps.slice(-4).join("; ")}`);
-  }
-  if (currentStep)
-    lines.push(`Current step: ${currentStep}`);
-  if (failedApproaches.length > 0) {
-    lines.push(`Failed approaches: ${failedApproaches.slice(-4).join("; ")}`);
-  }
-  if (pendingSteps.length > 0) {
-    lines.push(`Remaining work: ${pendingSteps.slice(0, 5).join("; ")}`);
-  } else if (nextAction) {
-    lines.push(`Next action: ${nextAction}`);
-  }
-  lines.push("Operating rule: base the next move on the raw failure/output state above; do not repeat the same failed approach unchanged.");
-  lines.push("[/FAILURE-MODE INTAKE]");
-  return lines.join("\n");
-}
 function computeCommitProgressGate(input) {
   const cooldown = input.cooldownTurns ?? 4;
   if (typeof input.lastInjectedTurn === "number" && input.lastInjectedTurn >= 0 && input.turn - input.lastInjectedTurn < cooldown) {
@@ -578699,6 +578562,57 @@ context_fabric: included=${included.length} dropped=${dropped.length} truncated=
 });
 
 // packages/orchestrator/dist/context-compiler.js
+function isControllerStateMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes(CONTROLLER_STATE_MARKER);
+}
+function isActionGroundTruthMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes(ACTION_GROUND_TRUTH_MARKER);
+}
+function isProtectedControllerMessage(message2) {
+  return isControllerStateMessage(message2) || isActionGroundTruthMessage(message2);
+}
+function modelFacingMessageCap(message2) {
+  if (isControllerStateMessage(message2)) {
+    return MODEL_FACING_CONTROLLER_STATE_CHAR_CAP;
+  }
+  if (isActionGroundTruthMessage(message2)) {
+    return MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP;
+  }
+  if (message2.role === "tool")
+    return MODEL_FACING_TOOL_CHAR_CAP;
+  if (message2.role === "system")
+    return MODEL_FACING_SYSTEM_CHAR_CAP;
+  return messageText(message2.content).length;
+}
+function stripLegacyRuntimeControlFragments(content) {
+  let out = content;
+  out = out.replace(new RegExp(`(?:^|\\n)\\s*${LEGACY_RUNTIME_CONTROL_BLOCK_START_RE.source}[\\s\\S]*?(?=\\n\\s*\\n|\\n(?=\\s*#{1,6}\\s)|\\n(?=\\s*\\[(?:CONTROLLER STATE v1|RECENT ACTION GROUND TRUTH)\\])|$)`, "gim"), "\n");
+  const pieces = out.split(/(\n\s*\n)/);
+  out = pieces.map((piece) => LEGACY_RUNTIME_CONTROL_FRAGMENT_RE.test(piece) ? "" : piece).join("");
+  return collapseWhitespace(out);
+}
+function splitOversizedSystemMessages(messages2) {
+  const out = [];
+  for (const message2 of messages2) {
+    if (message2.role !== "system" || typeof message2.content !== "string" || isProtectedControllerMessage(message2) || message2.content.length <= MODEL_FACING_SYSTEM_CHAR_CAP) {
+      out.push(message2);
+      continue;
+    }
+    let remaining = message2.content.trim();
+    while (remaining.length > MODEL_FACING_SYSTEM_CHAR_CAP) {
+      const window2 = remaining.slice(0, MODEL_FACING_SYSTEM_CHAR_CAP);
+      const boundary = Math.max(window2.lastIndexOf("\n\n"), window2.lastIndexOf("\n"));
+      const cut = boundary >= Math.floor(MODEL_FACING_SYSTEM_CHAR_CAP * 0.5) ? boundary : MODEL_FACING_SYSTEM_CHAR_CAP;
+      const chunk = remaining.slice(0, cut).trim();
+      if (chunk)
+        out.push({ ...message2, content: chunk });
+      remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining)
+      out.push({ ...message2, content: remaining });
+  }
+  return out;
+}
 function isCurrentGoalMessage(message2) {
   return typeof message2.content === "string" && message2.content.includes("[CURRENT USER GOAL]");
 }
@@ -578712,14 +578626,15 @@ function applyModelFacingBudget(messages2, preserveFirstSystem) {
     const content = messageText(message2.content);
     const isReservedTransactionMessage = reservedTransaction.has(index);
     const isPriorityIntent = message2.role === "user" || isCurrentGoalMessage(message2);
-    const perMessageCap = message2.role === "tool" ? MODEL_FACING_TOOL_CHAR_CAP : message2.role === "system" ? MODEL_FACING_SYSTEM_CHAR_CAP : content.length;
-    const allowed = isReservedTransactionMessage ? perMessageCap : isPriorityIntent ? content.length : Math.min(remaining, perMessageCap);
-    if (!isReservedTransactionMessage && !isPriorityIntent && allowed <= 0) {
+    const perMessageCap = modelFacingMessageCap(message2);
+    const isProtectedController = isProtectedControllerMessage(message2);
+    const allowed = isReservedTransactionMessage ? perMessageCap : isPriorityIntent ? content.length : isProtectedController ? perMessageCap : Math.min(remaining, perMessageCap);
+    if (!isReservedTransactionMessage && !isPriorityIntent && !isProtectedController && allowed <= 0) {
       continue;
     }
     const bounded = content.length > allowed && allowed > 0 ? `${content.slice(0, Math.max(0, allowed - 83))}
 [truncated_by_context_budget: retained higher-priority current intent/evidence]` : content;
-    if (!isReservedTransactionMessage && !isPriorityIntent && !bounded) {
+    if (!isReservedTransactionMessage && !isPriorityIntent && !isProtectedController && !bounded) {
       continue;
     }
     kept.push(typeof message2.content === "string" ? { ...message2, content: bounded } : message2);
@@ -578812,7 +578727,7 @@ function latestResolvedToolTransaction(messages2) {
 }
 function modelFacingReservedChars(message2) {
   const content = messageText(message2.content);
-  const cap = message2.role === "tool" ? MODEL_FACING_TOOL_CHAR_CAP : message2.role === "system" ? MODEL_FACING_SYSTEM_CHAR_CAP : content.length;
+  const cap = modelFacingMessageCap(message2);
   return Math.min(content.length, cap);
 }
 function retireLinkedAssistantReadIntents(messages2) {
@@ -578838,6 +578753,12 @@ function runtimeControlSemanticKey(content) {
   const normalized = content.replace(/\s+/g, " ").trim().toLowerCase();
   if (!normalized)
     return null;
+  if (content.includes(CONTROLLER_STATE_MARKER)) {
+    return "context.controller-state";
+  }
+  if (content.includes(ACTION_GROUND_TRUTH_MARKER)) {
+    return "context.action-ground-truth";
+  }
   if (content.includes("[ACTIVE CONTEXT FRAME]"))
     return "context.active-frame";
   if (content.includes("[TRAJECTORY CHECKPOINT]"))
@@ -578923,8 +578844,16 @@ function retireDuplicateToolFailures(messages2) {
 function prepareModelFacingApiMessages(input) {
   const preserveFirstSystem = input.preserveFirstSystem !== false;
   const sanitized = [];
-  for (let index = 0; index < input.messages.length; index++) {
-    const message2 = input.messages[index];
+  const withoutLegacyControl = input.messages.flatMap((message2) => {
+    if (message2.role !== "system" || typeof message2.content !== "string" || isProtectedControllerMessage(message2)) {
+      return [message2];
+    }
+    const stripped = stripLegacyRuntimeControlFragments(message2.content);
+    return stripped ? [{ ...message2, content: stripped }] : [];
+  });
+  const independentlyBounded = splitOversizedSystemMessages(withoutLegacyControl);
+  for (let index = 0; index < independentlyBounded.length; index++) {
+    const message2 = independentlyBounded[index];
     if (message2.role === "system" && typeof message2.content === "string") {
       if (preserveFirstSystem && sanitized.length === 0) {
         sanitized.push({ ...message2 });
@@ -579016,9 +578945,36 @@ function normalizeContextSignalsForModel(signals) {
   }
   return { signals: normalized, rejected };
 }
+function typeControllerSignal(signal) {
+  if (signal.modelVisible === false)
+    return signal;
+  if (signal.content.includes(CONTROLLER_STATE_MARKER)) {
+    return {
+      ...signal,
+      id: "controller-state-v1",
+      dedupeKey: "context.controller_state_v1",
+      semanticKey: "context.controller_state_v1",
+      conflictGroup: "context.controller_state",
+      priority: Math.max(signal.priority ?? 0, PRIORITY.GOAL + 15),
+      ttlTurns: 1
+    };
+  }
+  if (signal.content.includes(ACTION_GROUND_TRUTH_MARKER)) {
+    return {
+      ...signal,
+      id: "recent-action-ground-truth",
+      dedupeKey: "context.recent_action_ground_truth",
+      semanticKey: "context.recent_action_ground_truth",
+      conflictGroup: "context.action_ground_truth",
+      priority: Math.max(signal.priority ?? 0, PRIORITY.GOAL + 14),
+      ttlTurns: 1
+    };
+  }
+  return signal;
+}
 function compileContextFrameV2(input) {
   const builder = input.builder ?? new ContextFrameBuilder();
-  const normalized = normalizeContextSignalsForModel(input.signals);
+  const normalized = normalizeContextSignalsForModel(input.signals.map(typeControllerSignal));
   const goal = deriveCurrentGoal({
     explicitGoal: input.currentGoal,
     signals: normalized.signals
@@ -579058,7 +579014,7 @@ function compileContextFrameV2(input) {
     }
   };
 }
-var MODEL_FACING_CONTEXT_CHAR_BUDGET, MODEL_FACING_TOOL_CHAR_CAP, MODEL_FACING_SYSTEM_CHAR_CAP, ASSISTANT_READ_INTENT_RETIRED_MARKER, RESTORE_NOISE_LINE_RE, RUNTIME_GUIDANCE_RE, ACTIVE_CONTEXT_RE;
+var MODEL_FACING_CONTEXT_CHAR_BUDGET, MODEL_FACING_TOOL_CHAR_CAP, MODEL_FACING_SYSTEM_CHAR_CAP, MODEL_FACING_CONTROLLER_STATE_CHAR_CAP, MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP, CONTROLLER_STATE_MARKER, ACTION_GROUND_TRUTH_MARKER, LEGACY_RUNTIME_CONTROL_FRAGMENT_RE, LEGACY_RUNTIME_CONTROL_BLOCK_START_RE, ASSISTANT_READ_INTENT_RETIRED_MARKER, RESTORE_NOISE_LINE_RE, RUNTIME_GUIDANCE_RE, ACTIVE_CONTEXT_RE;
 var init_context_compiler = __esm({
   "packages/orchestrator/dist/context-compiler.js"() {
     "use strict";
@@ -579066,6 +579022,12 @@ var init_context_compiler = __esm({
     MODEL_FACING_CONTEXT_CHAR_BUDGET = 48e3;
     MODEL_FACING_TOOL_CHAR_CAP = 6e3;
     MODEL_FACING_SYSTEM_CHAR_CAP = 8e3;
+    MODEL_FACING_CONTROLLER_STATE_CHAR_CAP = 4e3;
+    MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP = 5500;
+    CONTROLLER_STATE_MARKER = "[CONTROLLER STATE v1]";
+    ACTION_GROUND_TRUTH_MARKER = "[RECENT ACTION GROUND TRUTH]";
+    LEGACY_RUNTIME_CONTROL_FRAGMENT_RE = /(?:\bREG-\d+\b|\bfocus supervisor\b|\bworld[ -]state\b|\brecent tool failures\b|\bstop\s*[—-]\s*retry loop\b|\bstagnation replan\b|\bfirst-edit nudge\b|\bintra-run lesson\b|\blocal error-informed nudge\b|\b(?:failure|failing)\s+(?:recovery|replan|loop)\b|\bdoom-loop\b|\b(?:prior\s+)?failure reflection\b|\breflexion\b|\b(?:cross-session|prior)\s+lessons?\b|\bprogress gate\b|\bforecast\b)/i;
+    LEGACY_RUNTIME_CONTROL_BLOCK_START_RE = /(?:\[(?:REG-\d+|FOCUS SUPERVISOR[^\]]*|WORLD[ -]STATE[^\]]*|RECENT TOOL FAILURES|STOP\s*[—-]\s*RETRY LOOP|STAGNATION REPLAN[^\]]*|FIRST-EDIT NUDGE[^\]]*|INTRA-RUN LESSON[^\]]*|LOCAL ERROR-INFORMED NUDGE[^\]]*|FORECAST[^\]]*|PROGRESS GATE[^\]]*|FAIL(?:URE|ING)[^\]]*(?:RECOVERY|REPLAN|LOOP)[^\]]*|DOOM-LOOP[^\]]*)\]|<(?:world-state|focus-supervisor|failure-recovery|reflection|lessons?)[^>]*>)/i;
     ASSISTANT_READ_INTENT_RETIRED_MARKER = "[assistant read intent retired: the linked tool result is already available; decide from that evidence instead of restating a read plan]";
     RESTORE_NOISE_LINE_RE = /^\s*(?:🔊|E Task timeout reached|E Incomplete:|⚠ Task incomplete|Tokens:\s*[\d,]+|▹\s*continue\b|·\s*(?:Starting fresh|Context (?:auto-)?restored|Nexus P2P network connected|REST API:|Voice feedback enabled|Memory maintenance:)|.*\bSHELL TRANSCRIPT\b.*|.*speaker emoji.*).*$/i;
     RUNTIME_GUIDANCE_RE = /\[RUNTIME_GUIDANCE_INTAKE v\d+\][\s\S]*?<<<RUNTIME_GUIDANCE>>>\s*([\s\S]*?)\s*<<<END_RUNTIME_GUIDANCE>>>[\s\S]*?\[\/RUNTIME_GUIDANCE_INTAKE\]/g;
@@ -581053,6 +581015,37 @@ var init_debugArtifactLibrary = __esm({
 });
 
 // packages/orchestrator/dist/focusSupervisor.js
+function satisfactionForRequiredAction(action) {
+  switch (action) {
+    case "read_authoritative_target":
+    case "disambiguate_edit_match":
+      return { kind: "fresh_read" };
+    case "run_verification":
+      return { kind: "verification" };
+    case "update_todos":
+      return { kind: "todo_update" };
+    case "report_blocked":
+    case "report_incomplete":
+      return { kind: "blocked_completion" };
+    default:
+      return { kind: "distinct_action" };
+  }
+}
+function inferDirectiveSource(input) {
+  if (/stale|hash|authoritative target|ambiguous/i.test(input.reason)) {
+    return "stale_write";
+  }
+  if (input.requiredNextAction === "run_verification") {
+    return "verification_failure";
+  }
+  if (input.requiredNextAction === "use_cached_evidence") {
+    return "duplicate_action";
+  }
+  if (input.requiredNextAction === "report_blocked" || input.requiredNextAction === "report_incomplete") {
+    return "completion_gate";
+  }
+  return "repeated_failure";
+}
 function resolveFocusSupervisorSilent(envValue = process.env["OMNIUS_FOCUS_SUPERVISOR_SILENT"]) {
   const normalized = String(envValue ?? "").trim().toLowerCase();
   if (normalized === "0" || normalized === "false" || normalized === "off") {
@@ -581425,6 +581418,10 @@ var init_focusSupervisor = __esm({
       availableTools = null;
       /** SILENCE: when true, block() downgrades to pass() (never stops a call). */
       silent;
+      taskEpoch;
+      directiveTtlTurns;
+      lastObservedTurn = 0;
+      onDirectiveLifecycle;
       constructor(options2 = {}) {
         this.mode = options2.mode ?? "auto";
         this.modelTier = options2.modelTier ?? "large";
@@ -581433,6 +581430,9 @@ var init_focusSupervisor = __esm({
         this.availableTools = options2.availableTools ? new Set(Array.from(options2.availableTools)) : null;
         this.convergenceBreaker = options2.convergenceBreaker ?? null;
         this.familyCwd = options2.cwd;
+        this.taskEpoch = Math.max(0, Math.floor(options2.taskEpoch ?? 0));
+        this.directiveTtlTurns = Math.max(1, Math.floor(options2.directiveTtlTurns ?? (this.modelTier === "large" ? 1 : 2)));
+        this.onDirectiveLifecycle = options2.onDirectiveLifecycle;
       }
       get enabled() {
         return this.mode !== "off";
@@ -581440,6 +581440,69 @@ var init_focusSupervisor = __esm({
       get currentDirective() {
         return this.directive;
       }
+      /**
+       * A task redirect/replacement is a control boundary. Old directives remain
+       * auditable through telemetry but cannot survive into the new task epoch.
+       */
+      setTaskEpoch(taskEpoch, turn = this.lastObservedTurn) {
+        const next = Math.max(0, Math.floor(taskEpoch));
+        if (next === this.taskEpoch)
+          return;
+        if (this.directive) {
+          this.transitionDirective("superseded", turn, `task epoch changed from ${this.taskEpoch} to ${next}`);
+        }
+        this.taskEpoch = next;
+        this.state = "observe";
+        this.ignoredDirectiveStreak = 0;
+        this.lastIgnoredDirectiveTurn = null;
+        this.repeatedViolationCounts.clear();
+      }
+      /**
+       * Controller integration point for structured detectors. It replaces the
+       * current directive only when the supplied evidence is newer or materially
+       * changes the recovery requirement; callers must not pass model prose alone.
+       */
+      activateEvidenceDirective(input) {
+        if (!this.enabled)
+          return null;
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        return this.setDirective({
+          turn: input.turn,
+          state: input.state ?? "single_next_action",
+          reason: input.reason,
+          requiredNextAction: input.requiredNextAction,
+          forbiddenActionFamilies: input.forbiddenActionFamilies ?? [],
+          source: input.source,
+          evidenceRefs: input.evidenceRefs,
+          evidenceStateVersion: input.evidenceStateVersion,
+          satisfaction: input.satisfaction
+        });
+      }
+      supersedeActiveDirective(reason, turn = this.lastObservedTurn, supersededBy) {
+        this.transitionDirective("superseded", turn, reason, supersededBy);
+      }
+      cancelActiveDirective(reason, turn = this.lastObservedTurn) {
+        this.transitionDirective("cancelled", turn, reason);
+      }
+      /** A compact, factual record for a controller frame; no directive history. */
+      compactDirective(turn = this.lastObservedTurn) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, turn);
+        this.expireDirectiveIfNeeded(this.lastObservedTurn);
+        const directive = this.directive;
+        if (!directive)
+          return null;
+        return {
+          id: directive.id,
+          taskEpoch: directive.taskEpoch ?? this.taskEpoch,
+          source: directive.source ?? "manual",
+          state: directive.state,
+          requiredNextAction: directive.requiredNextAction,
+          evidenceRefs: directive.evidenceRefs ?? [],
+          evidenceStateVersion: directive.evidenceStateVersion ?? 0,
+          expiresAfterTurn: directive.expiresAfterTurn,
+          satisfaction: directive.satisfaction
+        };
+      }
       /**
        * CE-A1: the runner rehydrated evicted evidence back into the model's
        * window. Any read-oriented directive is now satisfiable (or already
@@ -581476,7 +581539,10 @@ var init_focusSupervisor = __esm({
       shellFailureRequiredNextAction() {
         return this.silent && this.modelTier === "small" ? "creative_pivot_or_research" : "use_cached_evidence";
       }
-      snapshot() {
+      snapshot(turn) {
+        const observedTurn = turn === void 0 ? this.lastObservedTurn : Math.max(this.lastObservedTurn, Math.max(0, Math.floor(turn)));
+        this.lastObservedTurn = observedTurn;
+        this.expireDirectiveIfNeeded(observedTurn);
         return {
           mode: this.mode,
           enabled: this.enabled,
@@ -581490,22 +581556,36 @@ var init_focusSupervisor = __esm({
       observeContext(snapshot) {
         this.lastContext = snapshot;
       }
-      renderFrame() {
+      renderFrame(turn = this.lastObservedTurn) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, turn);
+        this.expireDirectiveIfNeeded(this.lastObservedTurn);
         if (!this.enabled || !this.directive)
           return null;
+        if (this.modelTier === "large")
+          return null;
         const d2 = this.directive;
         return [
-          "[FOCUS SUPERVISOR]",
+          "[ACTIVE DIRECTIVE STATE]",
+          `task_epoch=${d2.taskEpoch ?? this.taskEpoch}`,
           `state=${d2.state}`,
           `directive_id=${d2.id}`,
+          `lifecycle=${d2.lifecycleState ?? "active"}`,
+          `source=${d2.source ?? "manual"}`,
           `required_next_action=${d2.requiredNextAction}`,
-          `reason=${d2.reason}`,
+          `evidence_refs=${(d2.evidenceRefs ?? []).join(",") || "none"}`,
+          `evidence_state_version=${d2.evidenceStateVersion ?? 0}`,
+          d2.expiresAfterTurn !== void 0 ? `expires_after_turn=${d2.expiresAfterTurn}` : "expires_after_turn=unknown",
+          d2.satisfaction ? `satisfaction=${d2.satisfaction.kind}` : "",
+          `diagnosis=${d2.reason}`,
           d2.forbiddenActionFamilies.length ? `forbidden_action_families=${d2.forbiddenActionFamilies.join(", ")}` : "",
-          d2.ignoredCount > 0 ? `ignored_count=${d2.ignoredCount}` : "",
-          "Follow the required next action before returning to broad exploration or completion."
+          d2.ignoredCount > 0 ? `ignored_count=${d2.ignoredCount}` : ""
         ].filter(Boolean).join("\n");
       }
       evaluateProposedCall(input) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        if (input.taskEpoch !== void 0)
+          this.setTaskEpoch(input.taskEpoch, input.turn);
+        this.expireDirectiveIfNeeded(input.turn);
         this.lastContext = input.context ?? this.lastContext;
         if (!this.enabled)
           return this.pass();
@@ -581665,14 +581745,14 @@ var init_focusSupervisor = __esm({
         return this.pass();
       }
       observeToolResult(input) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        this.expireDirectiveIfNeeded(input.turn);
         if (!this.enabled)
           return;
-        if (input.mutated) {
+        if (input.mutated)
           this.sawMutationSinceFailure = true;
-          this.clearSatisfiedDirective("mutation landed", input.turn);
-          return;
-        }
-        if (input.success && input.alreadyApplied) {
+        const satisfiesAlreadyApplied = this.directive?.satisfaction?.kind === "distinct_action" || this.directive?.satisfaction?.kind === "fresh_read" && input.usedAuthoritativeTargetEvidence === true && isEditTool(input.toolName);
+        if (input.success && input.alreadyApplied && satisfiesAlreadyApplied) {
           this.clearSatisfiedDirective("requested edit already applied", input.turn);
           return;
         }
@@ -581707,7 +581787,7 @@ var init_focusSupervisor = __esm({
           this.lastReason = "runtime-authored control result did not execute the requested tool";
           return;
         }
-        if (input.toolName === "todo_write" && input.success) {
+        if (input.toolName === "todo_write" && input.success && this.directive?.satisfaction?.kind === "todo_update") {
           if (input.noop) {
             this.lastDecision = "todo_noop_not_satisfied";
             this.lastReason = "todo_write returned no-op; checklist state did not change";
@@ -581840,10 +581920,11 @@ var init_focusSupervisor = __esm({
           return;
         this.setDirective({
           turn,
-          state: "forced_replan",
-          reason: `${reason} — do NOT report incomplete and do NOT repeat a variant of what failed. TRIAGE: web_search the exact error/blocker to find how it is solved, OR pivot to a fundamentally different approach you have not tried, then act on it.`,
-          requiredNextAction: "creative_pivot_or_research",
-          forbiddenActionFamilies: ["brute_force"]
+          state: "terminal_incomplete",
+          reason,
+          requiredNextAction: "report_incomplete",
+          forbiddenActionFamilies: ["brute_force"],
+          source: "completion_gate"
         });
       }
       shouldStrictlyIntervene(context2) {
@@ -581872,7 +581953,12 @@ var init_focusSupervisor = __esm({
       }
       setDirective(input) {
         const existing = this.directive;
-        const stable = existing && existing.state === input.state && existing.reason === input.reason && existing.requiredNextAction === input.requiredNextAction;
+        const evidenceStateVersion = input.evidenceStateVersion ?? 0;
+        const stable = existing && existing.state === input.state && existing.reason === input.reason && existing.requiredNextAction === input.requiredNextAction && (existing.evidenceStateVersion ?? 0) >= evidenceStateVersion;
+        if (existing && !stable) {
+          this.transitionDirective("superseded", input.turn, "replaced by newer evidence or a different recovery requirement");
+        }
+        const source = input.source ?? inferDirectiveSource(input);
         const directive = stable ? {
           ...existing,
           forbiddenActionFamilies: uniqueLimited([
@@ -581880,13 +581966,20 @@ var init_focusSupervisor = __esm({
             ...input.forbiddenActionFamilies
           ])
         } : {
-          id: `focus_${++directiveCounter}`,
+          id: `focus_${this.taskEpoch}_${++directiveCounter}`,
           state: input.state,
           reason: input.reason,
           requiredNextAction: input.requiredNextAction,
           forbiddenActionFamilies: uniqueLimited(input.forbiddenActionFamilies),
           createdTurn: input.turn,
-          ignoredCount: 0
+          ignoredCount: 0,
+          taskEpoch: this.taskEpoch,
+          lifecycleState: "active",
+          source,
+          evidenceRefs: uniqueLimited(input.evidenceRefs ?? [`turn:${input.turn}`]),
+          evidenceStateVersion,
+          expiresAfterTurn: input.turn + this.directiveTtlTurns,
+          satisfaction: input.satisfaction ?? satisfactionForRequiredAction(input.requiredNextAction)
         };
         if (!stable && (!existing || existing.state !== input.state || existing.requiredNextAction !== input.requiredNextAction)) {
           this.repeatedViolationCounts.clear();
@@ -581896,12 +581989,45 @@ var init_focusSupervisor = __esm({
         this.lastReason = directive.reason;
         if (!stable)
           this.lastIgnoredDirectiveTurn = null;
+        if (!stable) {
+          this.emitDirectiveLifecycle({
+            directive,
+            taskEpoch: this.taskEpoch,
+            transition: "created",
+            turn: input.turn,
+            reason: directive.reason
+          });
+        }
         return directive;
       }
-      clearSatisfiedDirective(reason, _turn) {
-        if (!this.directive)
+      clearSatisfiedDirective(reason, turn) {
+        this.transitionDirective("satisfied", turn, reason);
+      }
+      expireDirectiveIfNeeded(turn) {
+        const expires = this.directive?.expiresAfterTurn;
+        if (expires !== void 0 && turn >= expires) {
+          this.transitionDirective("expired", turn, "directive TTL elapsed without new evidence");
+        }
+      }
+      transitionDirective(transition, turn, reason, supersededBy) {
+        const directive = this.directive;
+        if (!directive)
           return;
-        this.lastDecision = "directive_satisfied";
+        const resolved = {
+          ...directive,
+          lifecycleState: transition,
+          resolvedTurn: turn,
+          resolutionReason: reason,
+          ...supersededBy ? { supersededBy } : {}
+        };
+        this.emitDirectiveLifecycle({
+          directive: resolved,
+          taskEpoch: this.taskEpoch,
+          transition,
+          turn,
+          reason
+        });
+        this.lastDecision = transition === "satisfied" ? "directive_satisfied" : `directive_${transition}`;
         this.lastReason = reason;
         this.directive = null;
         this.state = "observe";
@@ -581909,6 +582035,12 @@ var init_focusSupervisor = __esm({
         this.lastIgnoredDirectiveTurn = null;
         this.repeatedViolationCounts.clear();
       }
+      emitDirectiveLifecycle(event) {
+        try {
+          this.onDirectiveLifecycle?.(event);
+        } catch {
+        }
+      }
       pass() {
         return {
           kind: "pass",
@@ -589537,12 +589669,6 @@ ${parts.join("\n")}
         const gitContract = renderGitProgressActionContract(this._gitProgress);
         if (gitContract)
           lines.push(gitContract);
-        const focus = this._focusSupervisor?.snapshot().directive ?? null;
-        if (focus) {
-          lines.push(`focus_required_next_action=${focus.requiredNextAction}`);
-          lines.push(`focus_valid_tools=${this._focusToolsForRequiredAction(focus.requiredNextAction)}`);
-          lines.push(`focus_reason=${focus.reason}`);
-        }
         const snapshot = this._currentWorkboardSnapshotForFrame();
         const action = snapshot ? this._deriveWorkboardActionContract(snapshot) : null;
         if (snapshot && action) {
@@ -590386,28 +590512,8 @@ ${parts.join("\n")}
         const pressureCue = pressureCheck(task);
         const rawPrompt = getSystemPromptForTier(this.options.modelTier);
         const basePrompt = rawPrompt + pressureCue;
-        const todoBatchGuidance = this._todoWriteAvailable() ? " Use todo_write between batches to mark progress." : "";
-        const _BATCH_GUIDANCE = {
-          small: `
-
-## Response batching
-
-Emit AT MOST 2 tool calls per response. After observing their results, plan the next 2 in your following response. Smaller batches let the orchestrator deliver cache/failure/progress signals to you between actions. Tool calls beyond the cap are dropped.${todoBatchGuidance}`,
-          medium: `
-
-## Response batching
-
-Emit AT MOST 4 tool calls per response. After observing their results, plan the next batch in your following response. Smaller batches let the orchestrator deliver cache/failure/progress signals to you between actions. Tool calls beyond the cap are dropped.${todoBatchGuidance}`,
-          large: `
-
-## Response batching
-
-Emit AT MOST 6 tool calls per response. Smaller batches receive better feedback (cache/failure/progress signals between actions). Tool calls beyond the cap are dropped.${todoBatchGuidance}`
-        };
-        const batchGuidance = _BATCH_GUIDANCE[this.options.modelTier ?? "large"] ?? _BATCH_GUIDANCE.large;
-        const shellGuidance = "\n\n## Shell command patterns\n\nWhen investigating a build/test/install failure, RUN THE COMMAND WITHOUT TRUNCATION FIRST to see the full error.\nAvoid `| tail -N` / `| head -N` / `| sed -n '1,Np'` on commands you don't yet trust — they drop the part of the output where errors usually appear.\nPipefail is on by default in this orchestrator: a pipeline's exit code reflects the FIRST failing stage, not just the last. So `<cmd> | tail -80` returns non-zero if `<cmd>` failed.\nWhen you DO want to limit context (after diagnosis), prefer `<cmd> 2>&1 | tail -300` (or larger) so you keep enough output to see the actual error block.\nIf your command exited 0 but produced suspiciously short output (~< 800 chars), the orchestrator will inject a [HINT — pipe-to-truncator detected] block telling you to re-run without truncation.";
-        const editTransportGuidance = "\n\n## Existing-file edit loop\n\nFor an existing non-trivial file, use this loop: (1) file_read the implicated range or whole small file, (2) file_patch a contiguous line range or file_edit exact current text, (3) inspect the resulting diff/changed range, and (4) run the declared verifier live. Use batch_edit only for multiple exact replacements built from one fresh read.\nfile_write is for new files, empty/placeholder files, and deliberate replacement of a genuinely small file. Never use file_write as a fallback for stale hashes, old_string mismatches, malformed patch arguments, or repeated edit failures. A 'different approach' means refresh evidence or change the diagnostic/patch shape; it does not mean broaden a local repair into a whole-file rewrite.\nPreviously observed or compacted results are orientation only. Re-run file_read whenever a freshness/hash guard asks for current text, and re-run the exact verifier after every relevant mutation; cached output never proves current file state or completion.";
-        const basePromptWithBatching = basePrompt + batchGuidance + shellGuidance + editTransportGuidance;
+        const toolProtocol = "\n\n## Tool protocol\nUse a bounded tool batch, inspect returned evidence before the next batch, and use structured tool calls. For an existing file, provide fresh target evidence for a mutation; hash and scope validation are enforced by the tools. Verify a claimed end state with current evidence.";
+        const basePromptWithBatching = basePrompt + toolProtocol;
         sections.push({
           label: "c_instr",
           content: basePromptWithBatching,
@@ -594758,7 +594864,6 @@ ${latest.output || ""}`.trim();
               `files=${scan.files.length}${scan.truncated ? "+" : ""}`,
               `dirs=${scan.dirs.length}`,
               `bytes=${totalBytes}`,
-              focusSnapshot?.directive?.requiredNextAction ? `supervisor_required_next_action=${focusSnapshot.directive.requiredNextAction}` : `supervisor_required_next_action=none`,
               recentActionLines.length ? `recent_actions=${recentActions.length}` : `recent_actions=0`,
               recentActionLines.length ? recentActionLines.join("\n") : "",
               ""
@@ -594811,7 +594916,6 @@ ${latest.output || ""}`.trim();
             `root=${root}`,
             `files=${scan.files.length}${scan.truncated ? "+" : ""} dirs=${scan.dirs.length} total_bytes=${totalBytes}`,
             `artifact=${artifactDisplay}`,
-            focusSnapshot?.directive?.requiredNextAction ? `supervisor_required_next_action=${focusSnapshot.directive.requiredNextAction}` : `supervisor_required_next_action=none`,
             recentActionLines.length ? `recent_actions:
 ${recentActionLines.join("\n")}` : "recent_actions=none",
             "Use this tree for path orientation. It includes empty directories; it does not include file contents.",
@@ -595398,9 +595502,9 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
         const artifactContractBlock = this._contractRegistry.format(15);
         const todoBlock = this._renderTodoStateBlock(turn);
         const gitBlock = this._renderGitProgressBlock(turn);
-        const failureBlock = this._renderRecentFailuresBlock(turn);
-        const churnBlock = this._renderWriteChurnBlock(turn);
-        const focusBlock = this._focusSupervisor?.renderFrame() ?? null;
+        const failureBlock = null;
+        const churnBlock = null;
+        const focusBlock = null;
         const actionContractBlock = this._renderNextActionContract(turn);
         const trajectoryCheckpoint = await this._refreshTrajectoryCheckpoint(turn, focusBlock, [
           workspaceTreeBlock,
@@ -595416,8 +595520,7 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
         const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
         const observationBlock = process.env["OMNIUS_DISABLE_OBSERVATION_FRAME"] === "1" ? null : this._observationLedger.renderBlock(5e3);
         const anchorsBlock = this.surfaceAnchors(messages2);
-        const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
-${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
+        const pprMemoryBlock = null;
         const activeItems = await this._collectActiveSemanticContextItems({
           goalBlock,
           filesystemBlock,
@@ -595506,15 +595609,6 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("task_state", "turn.focus-supervisor", focusBlock, {
-            id: "focus-supervisor",
-            dedupeKey: "turn.focus-supervisor",
-            semanticKey: "context.focus-supervisor",
-            conflictGroup: "context.focus-supervisor",
-            priority: 98,
-            createdTurn: turn,
-            ttlTurns: 1
-          }),
           signalFromBlock("recent_failure", "turn.failures", failureBlock, {
             id: "recent-failures",
             dedupeKey: "turn.failures",
@@ -598551,7 +598645,11 @@ Respond with the assessment and take the selected evidence-backed action.`;
           }
         }
         const contextComposition = await this.assembleContext(task, context2);
-        let systemPrompt = contextComposition.assembled;
+        const staticContextLabels = /* @__PURE__ */ new Set(["c_instr", "c_conventions", "c_state"]);
+        let systemPrompt = contextComposition.sections.filter((section) => staticContextLabels.has(section.label)).map((section) => section.content).join("");
+        const dynamicProjectContext = contextComposition.sections.filter((section) => !staticContextLabels.has(section.label) && section.label !== "c_lessons").map((section) => section.content).join("");
+        if (!systemPrompt)
+          systemPrompt = contextComposition.assembled;
         try {
           systemPrompt = `${systemPrompt}
 
@@ -598623,7 +598721,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               kind: "system_prompt",
               capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
               taskPreview: persistentTaskGoal.slice(0, 240),
-              assembledCharCount: systemPrompt.length,
+              assembledCharCount: systemPrompt.length + dynamicProjectContext.length,
               totalTokenEstimate: contextComposition.totalTokenEstimate,
               sections: contextComposition.sections.map((section, order) => ({
                 label: section.label,
@@ -598647,17 +598745,20 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         const messages2 = [
           { role: "system", content: systemPrompt },
           ...missionCompletionContract ? [{ role: "system", content: missionCompletionContract }] : [],
+          ...dynamicProjectContext ? [
+            {
+              role: "system",
+              content: `[DYNAMIC PROJECT STATE]
+${dynamicProjectContext}`
+            }
+          ] : [],
           { role: "user", content: userContent }
         ];
         const preflightMemoryRecall = await this._buildPreflightTaskMemoryRecall(persistentTaskGoal);
         if (preflightMemoryRecall) {
-          messages2.splice(messages2.length - 1, 0, {
-            role: "system",
-            content: preflightMemoryRecall
-          });
           this.emit({
             type: "status",
-            content: "Preflight memory recall injected for task-relevant prior episodes",
+            content: "Preflight memory recall retained for telemetry; omitted from model context",
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -598782,17 +598883,17 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             const reflections = this._reflectionBuffer.getRelevantReflections(persistentTaskGoal, 3);
             if (reflections.length > 0) {
               const reflectionCtx = this._reflectionBuffer.formatForContext(reflections);
-              messages2.push({ role: "system", content: reflectionCtx });
+              void reflectionCtx;
               this.emit({
                 type: "status",
-                content: `Reflexion: injected ${reflections.length} prior failure reflection(s) for this task type`,
+                content: `Reflexion: retained ${reflections.length} prior failure reflection(s) for telemetry only`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
           }
         } catch {
         }
-        if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
+        if (false) {
           try {
             const failureHandoff = buildFailureModeHandoff({
               taskGoal: persistentTaskGoal,
@@ -598809,8 +598910,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
                 priority: 85,
                 createdTurn: 0
               });
-              if (signal)
-                this._contextLedger.upsert(signal);
+              void signal;
             }
           } catch {
           }
@@ -599605,7 +599705,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
                 });
               } else {
                 const directive = this._failingApproachDirective(faSignal);
-                messages2.push({ role: "system", content: directive });
+                void directive;
                 this.emit({
                   type: "adversary_reaction",
                   adversary: {
@@ -599642,7 +599742,7 @@ Respond with EXACTLY this structure before your next tool call:
   NEXT ACTION: <a single creative edit — file_write / file_edit / batch_edit — that tests the picked hypothesis>
 
 If the hypothesis cannot be tested by a creative edit, ask the human via task_complete with summary 'BLOCKED: <reason>'.`;
-            messages2.push({ role: "system", content: replan });
+            void replan;
             stagnationCooldownUntilTurn = turn + 8;
             const _tel58 = this._describeTopClusterTelemetry();
             const _telSuffix58 = _tel58 ? `; rca3_preamble=applied; top_cluster=${_tel58.code} (${_tel58.observations}×); has_hint=${_tel58.hasHint}` : `; rca3_preamble=none`;
@@ -599673,7 +599773,7 @@ Respond with EXACTLY this structure before your next tool call:
   WHY: <one sentence>
   FALSIFICATION: <observable signal that would refute the pick>
   NEXT ACTION: <a single targeted edit — file_edit / file_patch / batch_edit; file_write only for a verified-new file>`;
-              messages2.push({ role: "system", content: _replan60 });
+              void _replan60;
               stagnationCooldownUntilTurn = turn + REG60_COOLDOWN_TURNS;
               const _tel60 = this._describeTopClusterTelemetry();
               const _telSuffix60 = _tel60 ? `; rca3_preamble=applied; top_cluster=${_tel60.code} (${_tel60.observations}×); has_hint=${_tel60.hasHint}` : `; rca3_preamble=none`;
@@ -599738,7 +599838,7 @@ Respond with EXACTLY this structure before your next tool call:
                     ].join("\n");
                   }
                 }
-                messages2.push({ role: "system", content: _stagBody });
+                void _stagBody;
                 stagnationCooldownUntilTurn = turn + 5;
                 try {
                   const memMod = await Promise.resolve().then(() => (init_dist(), dist_exports));
@@ -599770,12 +599870,7 @@ Respond with EXACTLY this structure before your next tool call:
                   const recipes = this._episodeStore ? memMod.lookupBySignature(this._episodeStore, sig, 1) : [];
                   if (recipes.length > 0) {
                     const r2 = recipes[0];
-                    messages2.push({
-                      role: "system",
-                      content: `[STAGNATION RECIPE — found from prior run with same failure shape]
-${r2.content}
-If this matches your current shape, try it before continuing.`
-                    });
+                    void r2;
                     this.emit({
                       type: "status",
                       content: `[STAGNATION RECIPE] surfaced prior recipe (sig=${sig}) for current failure shape`,
@@ -599943,30 +600038,6 @@ If this matches your current shape, try it before continuing.`
                   ``,
                   `  (e) REPORT BLOCKED: only when evidence shows a missing dependency, ambiguous requirement, or external service issue. State the blocker and prerequisite; do not call \`task_complete\` merely because this detector fired.`
                 ];
-                messages2.push({
-                  role: "system",
-                  content: [
-                    `[STUCK DETECTOR HALT — REG-44]`,
-                    ``,
-                    `Window: last ${_windowCalls.length} tool calls.`,
-                    `  • Reads/exploration calls: ${_readCount}`,
-                    `  • Productive mutations:    ${_mutationCount}`,
-                    `  • Stale (cached/blocked/no-op) results: ${_staleCount}`,
-                    `  • Triggers fired: ${_trigLabels.join(", ")}`,
-                    ``,
-                    `You are consuming turns without accumulating decision-ready evidence or verified progress. Every shape of “stuck” — read-heavy without a narrowing question, repeated cache hits, blocked-shell loops, no-op todo updates, or blind mutation retries — can produce this signal. The exact tool names do not decide the fix; the freshest evidence does.`,
-                    ``,
-                    ..._reg44ChoiceLines,
-                    ``,
-                    `Recent failures (real or synthetic):`,
-                    _failureBlocks,
-                    ``,
-                    _staleSamples.length > 0 ? `Stale-result samples in this window:
-${_staleSamples.join("\n")}` : ``,
-                    ``,
-                    `Do NOT in your next response: re-read a file you've already read this turn, re-run a shell command that just got blocked, or update todos without changing them. Those are the moves that landed you here.`
-                  ].filter(Boolean).join("\n")
-                });
                 this.emit({
                   type: "status",
                   content: `REG-44 STUCK detector fired at turn ${turn} — triggers=[${_trigLabels.join(",")}], reads=${_readCount}, mutations=${_mutationCount}, stale=${_staleCount}, window=${_windowCalls.length}`,
@@ -600037,10 +600108,7 @@ ${_staleSamples.join("\n")}` : ``,
                       callable: _smaCallable
                     }).then((_smaResult) => {
                       if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                        messages2.push({
-                          role: "system",
-                          content: _smaResult.injection
-                        });
+                        void _smaResult.injection;
                         this.emit({
                           type: "status",
                           content: `REG-49 stuck-meta-analyzer fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -600131,19 +600199,6 @@ ${_staleSamples.join("\n")}` : ``,
                   ``,
                   `Do NOT in your next response: write to ${_wtWorstPath} again without first running and reading the failing command's output.`
                 ];
-                messages2.push({
-                  role: "system",
-                  content: [
-                    `[WRITE-THRASH HALT — REG-50]`,
-                    ``,
-                    `In the last ${_wtWindow.length} tool calls you have written the same file ${_wtWorstCount} times:`,
-                    `  ${_wtWorstPath}`,
-                    ``,
-                    `No successful test/build/typecheck command ran between writes — you are iterating the file blind, hoping the next variation works. This is a write-thrash anti-pattern. Repeated edits without verification confirm nothing.`,
-                    ``,
-                    ..._reg50ChoiceLines
-                  ].join("\n")
-                });
                 this.emit({
                   type: "status",
                   content: `REG-50 WRITE-THRASH halt fired at turn ${turn} — file=${_wtWorstPath}, count=${_wtWorstCount}/${_wtThreshold}, no successful verify in window`,
@@ -600210,10 +600265,7 @@ ${_staleSamples.join("\n")}` : ``,
                       callable: _smaCallable50
                     }).then((_smaResult) => {
                       if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                        messages2.push({
-                          role: "system",
-                          content: _smaResult.injection
-                        });
+                        void _smaResult.injection;
                         this.emit({
                           type: "status",
                           content: `REG-50 → SSMA fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -600277,19 +600329,6 @@ ${_staleSamples.join("\n")}` : ``,
                   ``,
                   `Do NOT in your next response: call file_edit or batch_edit on ${_efWorstPath} again with another guess at old_string.`
                 ];
-                messages2.push({
-                  role: "system",
-                  content: [
-                    `[EDIT-FAIL-THRASH HALT — REG-53]`,
-                    ``,
-                    `In the last ${_efWindow.length} tool calls you have failed file_edit/batch_edit on the same file ${_efWorstCount} times:`,
-                    `  ${_efWorstPath}`,
-                    ``,
-                    `Each failure means your old_string did not match the file content. Your remembered version of this file has diverged from what's on disk — likely because an earlier edit succeeded and shifted things, or because you guessed at the file's content.`,
-                    ``,
-                    ..._reg53ChoiceLines
-                  ].join("\n")
-                });
                 this.emit({
                   type: "status",
                   content: `REG-53 EDIT-FAIL-THRASH halt fired at turn ${turn} — file=${_efWorstPath}, failures=${_efWorstCount}/${_efThreshold}`,
@@ -600367,10 +600406,7 @@ ${_staleSamples.join("\n")}` : ``,
                   callable: _pfvCallable
                 }).then((_pfvResult) => {
                   if (_pfvResult.injection && !_pfvResult.verdict.parseFallback && _pfvResult.verdict.verdict !== "continue") {
-                    messages2.push({
-                      role: "system",
-                      content: _pfvResult.injection
-                    });
+                    void _pfvResult.injection;
                     this.emit({
                       type: "status",
                       content: `REG-51 PFV fired at turn ${turn} — verdict=${_pfvResult.verdict.verdict}, trigger=${_pfvTriggerReason}, ssmaCount=${this._ssmaFiredCount}, ${_pfvResult.durationMs}ms`,
@@ -600435,18 +600471,6 @@ ${_staleSamples.join("\n")}` : ``,
                   ].join("\n");
                 }
               }
-              messages2.push({
-                role: "system",
-                content: [
-                  `[STICKY ESCALATION — REG-45 — failure persists across turns]`,
-                  ``,
-                  `You have an unresolved high-attempt failure that you may have stopped trying to fix. Every turn that this remains unresolved, this reflection will resurface so the issue stays visible:`,
-                  ``,
-                  _body,
-                  ``,
-                  `If this failure is genuinely irrelevant now (e.g. the goal moved on), the only way to clear this notice is to make a successful attempt of the same call (or close-equivalent) — that resets the failure record. Otherwise, address it now.`
-                ].join("\n")
-              });
               this._stickyEscalationsSurfacedThisTurn.add(_stem);
               this._reflectionsInjectedThisTurn.add(_stem);
               this.emit({
@@ -600922,10 +600946,11 @@ ${memoryLines.join("\n")}`
           const echoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
           if (this._echoTempBoostTurns > 0)
             this._echoTempBoostTurns--;
-          const actionGroundTruth = this._buildRecentActionGroundTruth(turn);
-          if (actionGroundTruth) {
-            requestMessages.push({ role: "system", content: actionGroundTruth });
-          }
+          this._stripLegacyControlMessages(requestMessages);
+          requestMessages.push({
+            role: "system",
+            content: this._buildRecentActionGroundTruth(turn)
+          });
           this._retireLinkedAssistantReadIntents(requestMessages);
           const chatRequest = {
             messages: requestMessages,
@@ -601470,10 +601495,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   const pattern = rawPattern;
                   if (pattern.tool === tc.name && (pattern.count ?? 0) >= 2 && !currentRunToolAlreadySucceeded && !this._errorGuidanceInjected.has(sig)) {
                     this._errorGuidanceInjected.add(sig);
-                    messages2.push({
-                      role: "system",
-                      content: `[LEARNED FROM EXPERIENCE] ${tc.name} has failed ${pattern.count} times with "${pattern.errorType}" errors. Guidance: ${pattern.guidance}`
-                    });
+                    void pattern;
                   }
                 }
               }
@@ -601688,7 +601710,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   ``,
                   _localFailureNudge
                 ].join("\n");
-                pushSoftInjection("system", reg61SteerMsg);
+                void reg61SteerMsg;
                 this.emit({
                   type: "status",
                   content: `REG-61 STEER — nudge injected for '${tc.name}' at turn ${turn}; tool ALLOWED; gate stays active${_dbgLoop.detected ? `; REG-66 debug-loop variant (${_dbgLoop.kind} "${_debugLoopSampleSafe.slice(0, 60)}" ${_dbgLoop.count}×)` : ""}`,
@@ -602031,11 +602053,8 @@ Read the current file if needed, make a different concrete edit, or move to veri
                         ].join("\n");
                       }
                     }
-                    if (_isEscalation) {
-                      messages2.push({ role: "system", content: _reflBody });
-                    } else {
-                      pushSoftInjection("system", _reflBody);
-                    }
+                    void _isEscalation;
+                    void _reflBody;
                     this.emit({
                       type: "status",
                       content: `REG-26 reflection surfaced for stem '${_reflStem.slice(0, 60)}' (attempts=${_reflEntry.attempts}, distinct_errors=${_reflEntry.errorSignatures?.size ?? 0}, escalation=${_isEscalation})`,
@@ -602231,7 +602250,7 @@ ${cachedResult}`,
                 });
                 if (focusDecision.kind === "block_tool_call" && this._maybeAutoDelegate(tc, focusDecision.directive, messages2, turn)) {
                 } else if (focusDecision.kind === "inject_guidance") {
-                  pushSoftInjection("system", focusDecision.message);
+                  void focusDecision.message;
                 } else if (!repeatShortCircuit) {
                   repeatShortCircuit = {
                     success: focusDecision.success,
@@ -602606,21 +602625,7 @@ ${cachedResult}`,
                                   });
                                   if (process.env["OMNIUS_DISABLE_REG59"] !== "1") {
                                     const _errCtx59 = this._buildErrorContextPreamble();
-                                    messages2.push({
-                                      role: "system",
-                                      content: `[STAGNATION REPLAN — REG-59 same-error escalation]
-The error cluster you keep hitting has occurred 5+ times. Your current approach is NOT working. STOP retrying it.
-` + _errCtx59 + `
-Respond with EXACTLY this structure before your next tool call:
-  HYPOTHESES (3 NEW theories — must be DIFFERENT from anything tried so far):
-  1. ...
-  2. ...
-  3. ...
-  PICK: <number 1-3>
-  WHY: <one sentence — what makes this hypothesis NEW>
-  FALSIFICATION: <observable signal that would refute the pick>
-  NEXT ACTION: <single tool call that tests the picked hypothesis — preferably a creative edit, not a read>`
-                                    });
+                                    void _errCtx59;
                                     stagnationCooldownUntilTurn = turn + 8;
                                     const _tel59 = this._describeTopClusterTelemetry();
                                     const _telSuffix59 = _tel59 ? `; rca3_preamble=applied; top_cluster=${_tel59.code} (${_tel59.observations}×); has_hint=${_tel59.hasHint}` : `; rca3_preamble=none`;
@@ -603643,7 +603648,7 @@ Respond with EXACTLY this structure before your next tool call:
                     ``,
                     this._renderLocalFailureNudge(turn)
                   ].join("\n");
-                  pushSoftInjection("system", opaqueMessage);
+                  void opaqueMessage;
                   this.emit({
                     type: "status",
                     content: `REG-32 opaque-error local nudge fired for stem '${_refStem.slice(0, 60)}'`,
@@ -604311,8 +604316,7 @@ Then use file_read on individual FILES inside it.`);
                     createdTurn: turn,
                     ttlTurns: 4
                   });
-                  if (signal)
-                    this._contextLedger.upsert(signal);
+                  void signal;
                   lastShellPivotTurn = turn;
                   this.emit({
                     type: "status",
@@ -604321,7 +604325,7 @@ Then use file_read on individual FILES inside it.`);
                   });
                 }
               }
-              if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1" && !result.success && turn - lastFailureHandoffTurn >= 4) {
+              if (false) {
                 const runtimeHandoff = buildFailureModeHandoff({
                   taskGoal: persistentTaskGoal,
                   errorPatterns: this._taskRelevantErrorPatterns,
@@ -604338,8 +604342,7 @@ Then use file_read on individual FILES inside it.`);
                     createdTurn: turn,
                     ttlTurns: 4
                   });
-                  if (signal)
-                    this._contextLedger.upsert(signal);
+                  void signal;
                   lastFailureHandoffTurn = turn;
                 }
               }
@@ -604366,8 +604369,7 @@ Then use file_read on individual FILES inside it.`);
               return {
                 tc,
                 output,
-                success: result.success,
-                ...runtimeSystemGuidance ? { systemGuidance: runtimeSystemGuidance } : {}
+                success: result.success
               };
             };
             const rawToolCalls = msg.toolCalls;
@@ -604494,12 +604496,7 @@ ${sr.result.output}`;
                   const r2 = await executeSingle(tc);
                   if (r2) {
                     messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
-                    if (r2.systemGuidance) {
-                      messages2.push({
-                        role: "system",
-                        content: r2.systemGuidance
-                      });
-                    }
+                    void r2.systemGuidance;
                     if (r2.tc.name === "task_complete") {
                       if (!r2.success) {
                         messages2.push({
@@ -604608,12 +604605,7 @@ ${sr.result.output}`;
                 for (const r2 of results) {
                   if (r2) {
                     messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
-                    if (r2.systemGuidance) {
-                      messages2.push({
-                        role: "system",
-                        content: r2.systemGuidance
-                      });
-                    }
+                    void r2.systemGuidance;
                     if (r2.tc.name === "task_complete") {
                       if (!r2.success) {
                         messages2.push({
@@ -604704,21 +604696,7 @@ ${sr.result.output}`;
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 const partialResults = this._taskState.completedSteps.length > 0 ? this._taskState.completedSteps.join(". ") : `Progress made before loop: ${topRepeated}`;
-                messages2.push({
-                  role: "system",
-                  content: `LOOP CIRCUIT BREAKER: ${loopInterventionCount} interventions attempted but repetition continues.
-
-MANDATORY: Change state before taking another action. Choose one:
-1. Try a completely different approach
-2. Re-read the exact current target once if the loop is caused by a stale edit
-3. Run verification if files changed since the last successful check
-4. Call ask_user if user input is the real blocker
-5. Report blocked/incomplete with the concrete blocker if no safe progress path remains
-
-Your partial progress: ${partialResults}
-
-Do not call task_complete solely because this circuit breaker fired.`
-                });
+                void partialResults;
                 loopInterventionCount = 0;
               }
               const findings = [];
@@ -604816,10 +604794,7 @@ Only call task_complete when the task is actually complete and the evidence is f
                     callable: _smaCallable
                   }).then((_smaResult) => {
                     if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                      messages2.push({
-                        role: "system",
-                        content: _smaResult.injection
-                      });
+                      void _smaResult.injection;
                       this.emit({
                         type: "status",
                         content: `REG-49 stuck-meta-analyzer fired (loop-intervention path) at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -605229,13 +605204,11 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             const bfEchoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
             if (this._echoTempBoostTurns > 0)
               this._echoTempBoostTurns--;
-            const bruteForceGroundTruth = this._buildRecentActionGroundTruth(turn);
-            if (bruteForceGroundTruth) {
-              modelFacingMessages.push({
-                role: "system",
-                content: bruteForceGroundTruth
-              });
-            }
+            this._stripLegacyControlMessages(modelFacingMessages);
+            modelFacingMessages.push({
+              role: "system",
+              content: this._buildRecentActionGroundTruth(turn)
+            });
             const chatRequest = {
               messages: modelFacingMessages,
               tools: toolDefs,
@@ -605394,12 +605367,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
                 this._toolLastUsedTurn.set(r2.tc.name, turn);
                 this._advanceContextTreeOnToolCall(r2.tc.name, this._buildExactArgsKey(r2.tc.arguments ?? {}), turn, messages2);
-                if (r2.systemGuidance) {
-                  messages2.push({
-                    role: "system",
-                    content: r2.systemGuidance
-                  });
-                }
+                void r2.systemGuidance;
                 if (r2.tc.name === "task_complete") {
                   if (!r2.success) {
                     messages2.push({
@@ -608187,8 +608155,7 @@ ${tail}`;
             createdTurn: turn,
             ttlTurns: 20
           });
-          if (signal)
-            this._contextLedger.upsert(signal);
+          void signal;
         }
         this.emit({
           type: "user_interrupt",
@@ -608623,37 +608590,13 @@ Describe what you see and integrate this into your current approach.` : "[User s
         let middle = messages2.slice(headEndIdx, recentStart);
         if (middle.length === 0)
           return messages2;
-        const DEFENSE_DIRECTIVE_PREFIXES = [
-          "[STUCK DETECTOR HALT — REG-44]",
-          "[STUCK-STATE META-ANALYZER — REG-49]",
-          "[WRITE-THRASH HALT — REG-50]",
-          "[PROBLEM-FRAME VALIDATION — REG-51",
-          "[EDIT-FAIL-THRASH HALT — REG-53]"
-        ];
-        const isDefenseDirective = (msg) => {
-          const c9 = typeof msg.content === "string" ? msg.content : "";
-          return msg.role === "system" && DEFENSE_DIRECTIVE_PREFIXES.some((pfx) => c9.startsWith(pfx));
-        };
-        const stickyDefenses = [];
-        const filteredMiddle = [];
-        for (const msg of middle) {
-          if (isDefenseDirective(msg))
-            stickyDefenses.push(msg);
-          else
-            filteredMiddle.push(msg);
-        }
-        const filteredRecent = [];
-        for (const msg of recent) {
-          if (isDefenseDirective(msg))
-            stickyDefenses.push(msg);
-          else
-            filteredRecent.push(msg);
-        }
-        const stickyToKeep = stickyDefenses.slice(-10);
-        if (stickyToKeep.length > 0) {
+        const filteredMiddle = middle.filter((message2) => !this._isLegacyControlMessage(message2));
+        const filteredRecent = recent.filter((message2) => !this._isLegacyControlMessage(message2));
+        const retiredLegacyCount = middle.length + recent.length - filteredMiddle.length - filteredRecent.length;
+        if (retiredLegacyCount > 0) {
           this.emit({
             type: "status",
-            content: `REG-54 sticky-defenses preserved ${stickyToKeep.length} directive(s) across compaction (out of ${stickyDefenses.length} matched)`,
+            content: `Controller cleanup retired ${retiredLegacyCount} legacy REG/recovery message(s) during compaction`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -608921,7 +608864,6 @@ ${telegramPersonaHead}` : stripped
         let result = [
           ...narrowedHead,
           compactionMsg,
-          ...stickyToKeep,
           ...filteredRecent
         ];
         const fileRecoveryBudget = Math.floor((this._branchRoutingContextWindow() || 32768) * 0.15);
@@ -609021,10 +608963,9 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
             createdTurn: this._taskState.toolCallCount,
             ttlTurns: 8
           });
-          if (signal)
-            this._contextLedger.upsert(signal);
+          void signal;
         }
-        if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
+        if (false) {
           try {
             const compactFailureHandoff = buildFailureModeHandoff({
               taskGoal: this._taskState.goal,
@@ -609041,8 +608982,7 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
                 createdTurn: this._taskState.toolCallCount,
                 ttlTurns: 8
               });
-              if (signal)
-                this._contextLedger.upsert(signal);
+              void signal;
             }
           } catch {
           }
@@ -609084,7 +609024,6 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
             result = [
               ...narrowedHead,
               compactionMsg,
-              ...stickyToKeep,
               ...protectedRecoveryMessages,
               ...trimmedRecent
             ];
@@ -609290,22 +609229,49 @@ ${trimmedNew}`;
           this._recentToolOutcomes.shift();
         }
       }
-      /** Late, bounded execution facts. Never use model prose or controller files. */
+      /**
+       * The only late control block visible to a model. It is regenerated from
+       * authoritative run state on each request; it never carries prompt history.
+       * Large models receive state only. Small/medium models may receive one
+       * bounded directive with an explicit expiry and exit condition.
+       */
       _buildRecentActionGroundTruth(turn) {
         const activePaths = [...this._taskState.modifiedFiles.entries()].map(([rawPath, rawAction]) => ({
           path: this._normalizeEvidencePath(rawPath),
           rawAction
-        })).filter((entry) => entry.path && !entry.path.startsWith(".omnius/")).slice(-8);
-        if (activePaths.length === 0)
-          return null;
+        })).filter((entry) => entry.path && !entry.path.startsWith(".omnius/")).slice(-5);
+        const todos = this.readSessionTodos() ?? [];
+        const todoCounts = todos.reduce((counts, todo) => {
+          const status = String(todo.status ?? "pending");
+          if (status === "completed")
+            counts.completed++;
+          else if (status === "blocked")
+            counts.blocked++;
+          else if (status === "in_progress")
+            counts.inProgress++;
+          else
+            counts.pending++;
+          return counts;
+        }, { completed: 0, blocked: 0, inProgress: 0, pending: 0 });
+        const activeLeaf = todos.find((todo) => ["in_progress", "pending", "open", "needs_changes"].includes(String(todo.status ?? "")));
         const verifier = this._worldFacts.lastTest;
         const verifierState = verifier?.summary ? `outcome=${verifier.passed ? "passed" : "failed"} turn=${verifier.turn ?? "?"}` : "outcome=not_recorded";
         const verifierRequired = this._compileFixLoop?.active === true && this._compileFixLoop.verifierDirtySinceTurn !== null;
+        const intent = this._taskState.originalGoal || this._taskState.goal || this._taskState.currentStep || "unspecified";
         const lines = [
-          "[RECENT ACTION GROUND TRUTH]",
-          `turn=${turn} stateVersion=${this._adversaryStateVersion}`,
+          "[CONTROLLER STATE v1]",
+          `task_epoch=${this._taskEpoch} turn=${turn} state_version=${this._adversaryStateVersion}`,
+          `user_intent=${intent.replace(/\s+/g, " ").slice(0, 700)}`,
+          `active_leaf=${String(activeLeaf?.content ?? this._taskState.currentStep ?? this._taskState.nextAction ?? "none").replace(/\s+/g, " ").slice(0, 360)}`,
+          `todo_counts=completed:${todoCounts.completed},in_progress:${todoCounts.inProgress},pending:${todoCounts.pending},blocked:${todoCounts.blocked}`,
           `verifier=${verifierState}`
         ];
+        const tier = this.options.modelTier ?? "large";
+        const directive = this._focusSupervisor?.snapshot().directive;
+        if (directive && tier !== "large") {
+          const expiresTurn = Math.max(turn + 1, directive.createdTurn + 6);
+          lines.push(`active_directive=next_action:${directive.requiredNextAction}; evidence:${directive.reason.replace(/\s+/g, " ").slice(0, 260)}; expires_turn:${expiresTurn}; exit_when:action_evidence_or_verified_mutation_or_user_redirect`);
+        }
         for (const entry of activePaths) {
           const action = /creat/i.test(entry.rawAction) ? "created" : /delet/i.test(entry.rawAction) ? "deleted" : "modified";
           const evidence = this._evidenceLedger.get(entry.path);
@@ -609318,8 +609284,20 @@ ${trimmedNew}`;
           const doNot = action === "created" ? "do_not_create_again" : action === "modified" ? "do_not_full_rewrite_without_fresh_read" : "do_not_recreate_without_authoritative_target";
           lines.push(`${action} path=${entry.path} hash=${hash} bytes=${bytes} ${resultState} stateVersion=${outcome?.stateVersion ?? this._adversaryStateVersion} turn=${outcome?.turn ?? turn} next_valid_action=${nextAction} ${doNot}`);
         }
-        lines.push("Use these facts over stale assistant plans, broad summaries, or controller artifacts.");
-        return lines.join("\n").slice(0, 5200);
+        lines.push("action_ground_truth=tool-derived only; controller artifacts and bookkeeping do not count as progress");
+        return lines.join("\n").slice(0, 4200);
+      }
+      /** Legacy REG/recovery prose is retained in telemetry only, never in model history. */
+      _isLegacyControlMessage(message2) {
+        if (message2.role !== "system" || typeof message2.content !== "string")
+          return false;
+        return /^(?:\[(?:FIRST-EDIT NUDGE|STAGNATION(?: REPLAN| RECIPE)|STUCK DETECTOR HALT|STUCK-STATE META-ANALYZER|WRITE-THRASH HALT|EDIT-FAIL-THRASH HALT|PROBLEM-FRAME VALIDATION|STICKY ESCALATION|INTRA-RUN LESSON|LEARNED FROM EXPERIENCE|FOCUS SUPERVISOR|REG-\d+ directive active|OPAQUE LOCAL ERROR|LOCAL ERROR-INFORMED NUDGE|PRIOR LESSONS|FAILURE-MODE INTAKE|REFLECTION|Associative Memory)|LOOP CIRCUIT BREAKER)/.test(message2.content);
+      }
+      _stripLegacyControlMessages(messages2) {
+        for (let index = messages2.length - 1; index >= 0; index--) {
+          if (this._isLegacyControlMessage(messages2[index]))
+            messages2.splice(index, 1);
+        }
       }
       /** Mark a workboard target complete when a confirmed creation satisfies it. */
       _reconcileCreationGroundTruth(toolName, args, result, turn) {