omnius 1.0.380 → 1.0.381

package/dist/index.js

@@ -1033,8 +1033,8 @@ var init_model_broker = __esm({
       }
       /** Restore a set of previously evicted Ollama models, oldest first. */
       async restoreOllamaModels(models, options2 = {}) {
-        const unique2 = dedupeLoadedModels(models.filter((m2) => m2.host === "ollama")).sort((a2, b) => a2.lastUsedAt - b.lastUsedAt);
-        for (const model of unique2) {
+        const unique3 = dedupeLoadedModels(models.filter((m2) => m2.host === "ollama")).sort((a2, b) => a2.lastUsedAt - b.lastUsedAt);
+        for (const model of unique3) {
           await this.warmOllamaModel(model.name, options2.keepAlive ?? "30m").catch(() => false);
         }
       }
@@ -14187,8 +14187,8 @@ var init_unifiedMemoryStore = __esm({
         return matches.filter((match) => match.score >= (options2.minScore ?? 0)).sort((a2, b) => b.score - a2.score).slice(0, limit).map((match, index) => ({ ...match, rank: index + 1 }));
       }
       recordAccess(itemIds) {
-        const unique2 = [...new Set(itemIds)].filter(Boolean);
-        if (unique2.length === 0)
+        const unique3 = [...new Set(itemIds)].filter(Boolean);
+        if (unique3.length === 0)
           return;
         const update2 = this.db.prepare(`
       UPDATE memory_item
@@ -14198,7 +14198,7 @@ var init_unifiedMemoryStore = __esm({
     `);
         const now2 = this.nowIso();
         const txn = this.db.transaction(() => {
-          for (const id of unique2)
+          for (const id of unique3)
             update2.run(now2, id);
         });
         txn();
@@ -498530,11 +498530,11 @@ ${options2.prefix}` : "\n" : options2.prefix
           return true;
         }
         const set = /* @__PURE__ */ new Map();
-        let unique2 = 0;
+        let unique3 = 0;
         for (const v of arr1) {
           if (set.get(v) !== true) {
             set.set(v, true);
-            unique2++;
+            unique3++;
           }
         }
         for (const v of arr2) {
@@ -498544,10 +498544,10 @@ ${options2.prefix}` : "\n" : options2.prefix
           }
           if (isSet === true) {
             set.set(v, false);
-            unique2--;
+            unique3--;
           }
         }
-        return unique2 === 0;
+        return unique3 === 0;
       }
       function typeAcquisitionChanged(opt1, opt2) {
         return opt1.enable !== opt2.enable || !setIsEqualTo(opt1.include, opt2.include) || !setIsEqualTo(opt1.exclude, opt2.exclude);
@@ -559210,9 +559210,9 @@ function deriveClaimsFromProposedText(input) {
   if (!raw)
     return [];
   const segments = raw.replace(/\b(?:done|completed|verified)\s*:\s*/gi, "").split(/(?:\n+|;\s+|,\s+(?=(?:and\s+)?(?:sent|built|created|updated|published|verified|tested|fixed|added|removed|deployed|wrote)\b)|\.\s+)/i).map((part) => cleanText(part, 300)).filter((part) => part.length > 0);
-  const unique2 = Array.from(new Set(segments.length > 0 ? segments : [cleanText(raw, 300)]));
+  const unique3 = Array.from(new Set(segments.length > 0 ? segments : [cleanText(raw, 300)]));
   const existingIds = new Set((input.existing ?? []).map((claim) => claim.id));
-  return unique2.map((text2, index) => {
+  return unique3.map((text2, index) => {
     const base3 = normalizeCompletionKey(text2, `claim_${index + 1}`).slice(0, 64);
     let id = base3 || `claim_${index + 1}`;
     let suffix = 2;
@@ -568681,6 +568681,7 @@ function recordContextWindowDump(input) {
     ...input.model ? { model: input.model } : {},
     cwd: cwd4,
     ...input.note ? { note: input.note } : {},
+    ...input.focusSupervisor ? { focusSupervisor: compactFocusSupervisor(input.focusSupervisor) } : {},
     metrics: analyzeContextWindowDumpRequest(input.request),
     request: input.request
   };
@@ -568838,6 +568839,31 @@ function toSummary(record, path12) {
   const { request: _request, ...summary } = record;
   return { ...summary, path: path12 };
 }
+function compactFocusSupervisor(input) {
+  const directive = input.directive ? {
+    id: input.directive.id,
+    state: input.directive.state,
+    reason: trimString(input.directive.reason, 500),
+    requiredNextAction: input.directive.requiredNextAction,
+    forbiddenActionFamilies: input.directive.forbiddenActionFamilies?.slice(0, 12),
+    createdTurn: input.directive.createdTurn,
+    ignoredCount: input.directive.ignoredCount
+  } : input.directive ?? null;
+  return {
+    mode: input.mode,
+    enabled: input.enabled,
+    state: input.state,
+    lastDecision: input.lastDecision,
+    lastReason: trimString(input.lastReason, 500),
+    directive,
+    ...input.context ? { context: input.context } : {}
+  };
+}
+function trimString(value2, max) {
+  if (typeof value2 !== "string" || !value2.trim())
+    return void 0;
+  return value2.trim().slice(0, max);
+}
 function safeId(value2) {
   return String(value2 || "unknown").replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 160);
 }
@@ -569216,6 +569242,338 @@ var init_adversaryStream = __esm({
   }
 });
 
+// packages/orchestrator/dist/focusSupervisor.js
+function resolveFocusSupervisorMode(configured, envValue = process.env["OMNIUS_FOCUS_SUPERVISOR"]) {
+  if (configured)
+    return configured;
+  const normalized = String(envValue ?? "").trim().toLowerCase();
+  if (normalized === "off" || normalized === "0" || normalized === "false") {
+    return "off";
+  }
+  if (normalized === "strict")
+    return "strict";
+  return "auto";
+}
+function violatesDirective(directive, input) {
+  if (input.toolName === "task_complete") {
+    return directive.state === "terminal_incomplete";
+  }
+  const family = actionFamily(input.toolName, input.args);
+  if (directive.forbiddenActionFamilies.includes(family))
+    return true;
+  if (directive.forbiddenActionFamilies.includes(input.toolName))
+    return true;
+  switch (directive.requiredNextAction) {
+    case "update_todos":
+      return input.toolName !== "todo_write";
+    case "read_authoritative_target":
+      return input.toolName !== "file_read";
+    case "run_verification":
+      return input.toolName !== "shell";
+    case "report_blocked":
+    case "report_incomplete":
+      return input.toolName !== "task_complete";
+    case "edit_different_target":
+      return input.toolName === "shell" || input.isReadLike || directive.forbiddenActionFamilies.includes(family);
+    case "use_cached_evidence":
+      return directive.forbiddenActionFamilies.includes(family);
+    default:
+      return false;
+  }
+}
+function actionFamily(toolName, args) {
+  const target = args?.["path"] ?? args?.["file"] ?? args?.["filePath"] ?? args?.["file_path"] ?? args?.["command"] ?? args?.["cmd"] ?? "";
+  return `${toolName}:${normalizeTarget(String(target ?? "")) || "no-target"}`;
+}
+function failureFamilyKey(toolName, args, error, output) {
+  const sample = cleanFailureSample(error || output || "");
+  return `${actionFamily(toolName, args)}:${sample}`;
+}
+function cleanFailureSample(text2) {
+  return String(text2 || "").replace(/\s+/g, " ").trim().slice(0, 180);
+}
+function normalizeTarget(text2) {
+  return text2.replace(/\s+/g, " ").trim().slice(0, 220);
+}
+function unique2(values) {
+  return [...new Set(values.filter((value2) => value2.trim().length > 0))];
+}
+var directiveCounter, FocusSupervisor;
+var init_focusSupervisor = __esm({
+  "packages/orchestrator/dist/focusSupervisor.js"() {
+    "use strict";
+    directiveCounter = 0;
+    FocusSupervisor = class {
+      mode;
+      modelTier;
+      repeatGateMax;
+      state = "observe";
+      directive = null;
+      lastDecision = "pass";
+      lastReason = "";
+      lastContext = null;
+      failureFamilies = /* @__PURE__ */ new Map();
+      constructor(options2 = {}) {
+        this.mode = options2.mode ?? "auto";
+        this.modelTier = options2.modelTier ?? "large";
+        this.repeatGateMax = Math.max(0, Math.floor(options2.repeatGateMax ?? 3));
+      }
+      get enabled() {
+        return this.mode !== "off";
+      }
+      get currentDirective() {
+        return this.directive;
+      }
+      snapshot() {
+        return {
+          mode: this.mode,
+          enabled: this.enabled,
+          state: this.state,
+          directive: this.directive,
+          lastDecision: this.lastDecision,
+          lastReason: this.lastReason,
+          ...this.lastContext ? { context: this.lastContext } : {}
+        };
+      }
+      observeContext(snapshot) {
+        this.lastContext = snapshot;
+      }
+      renderFrame() {
+        if (!this.enabled || !this.directive)
+          return null;
+        const d2 = this.directive;
+        return [
+          "[FOCUS SUPERVISOR]",
+          `state=${d2.state}`,
+          `directive_id=${d2.id}`,
+          `required_next_action=${d2.requiredNextAction}`,
+          `reason=${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."
+        ].filter(Boolean).join("\n");
+      }
+      evaluateProposedCall(input) {
+        this.lastContext = input.context ?? this.lastContext;
+        if (!this.enabled)
+          return this.pass();
+        const family = actionFamily(input.toolName, input.args);
+        const prior = this.directive;
+        if (prior && violatesDirective(prior, input)) {
+          prior.ignoredCount++;
+          const strict = this.shouldStrictlyIntervene(input.context);
+          if (strict && prior.ignoredCount >= 1) {
+            const directive = this.setDirective({
+              turn: input.turn,
+              state: "single_next_action",
+              reason: `model ignored prior directive ${prior.id}: ${prior.reason}`,
+              requiredNextAction: prior.requiredNextAction,
+              forbiddenActionFamilies: unique2([
+                ...prior.forbiddenActionFamilies,
+                family
+              ])
+            });
+            return this.block(directive, [
+              `[FOCUS SUPERVISOR BLOCK] The previous directive was ignored: ${prior.reason}`,
+              `Required next action: ${directive.requiredNextAction}.`,
+              `Blocked action family: ${family}.`,
+              "Take the required next action, or report blocked/incomplete with evidence."
+            ].join("\n"), false);
+          }
+        }
+        if (input.stalePreflightMessage) {
+          const directive = this.setDirective({
+            turn: input.turn,
+            state: "single_next_action",
+            reason: "stale edit preflight detected a repeated stale target",
+            requiredNextAction: "read_authoritative_target",
+            forbiddenActionFamilies: [family]
+          });
+          return this.block(directive, `${input.stalePreflightMessage}
+
+[FOCUS SUPERVISOR] Required next action: file_read the authoritative current target once, then build a new edit from current evidence or report incomplete.`, false);
+        }
+        const duplicateHitCount = input.duplicateHitCount ?? 0;
+        if (input.cachedResult && duplicateHitCount > 0) {
+          const strict = this.shouldStrictlyIntervene(input.context);
+          const advisoryOnly = this.repeatGateMax === 0;
+          const hitLimit = input.cachedResultFailed ? 1 : Math.max(1, this.repeatGateMax - 1);
+          const state = input.cachedResultFailed || duplicateHitCount >= hitLimit ? "cached_evidence" : "warn";
+          const directive = this.setDirective({
+            turn: input.turn,
+            state,
+            reason: input.cachedResultFailed ? `cached failed ${input.toolName} evidence already exists` : `duplicate ${input.toolName} call has cached evidence`,
+            requiredNextAction: input.cachedResultFailed ? "edit_different_target" : "use_cached_evidence",
+            forbiddenActionFamilies: [family]
+          });
+          if (strict && !advisoryOnly && (input.cachedResultFailed || duplicateHitCount >= hitLimit)) {
+            return this.block(directive, [
+              input.cachedResultFailed ? "[FOCUS SUPERVISOR: CACHED FAILURE]" : "[FOCUS SUPERVISOR: CACHED EVIDENCE]",
+              `This ${input.toolName} action family has already produced evidence and should not be re-executed unchanged.`,
+              `Required next action: ${directive.requiredNextAction}.`,
+              "",
+              input.cachedResult.slice(0, 8e3)
+            ].join("\n"), !input.cachedResultFailed);
+          }
+          return this.inject(directive, `[FOCUS SUPERVISOR] ${directive.reason}. Required next action: ${directive.requiredNextAction}.`);
+        }
+        if (this.hasLowSignalContext(input.context) && input.isReadLike) {
+          const directive = this.setDirective({
+            turn: input.turn,
+            state: "forced_replan",
+            reason: "raw discovery is dominating active evidence in the context window",
+            requiredNextAction: "update_todos",
+            forbiddenActionFamilies: [family]
+          });
+          return this.inject(directive, "[FOCUS SUPERVISOR] Discovery noise is crowding the live context. Update the todo decomposition, then act on active evidence instead of broad rereads.");
+        }
+        this.lastDecision = "pass";
+        this.lastReason = "";
+        return this.pass();
+      }
+      observeToolResult(input) {
+        if (!this.enabled)
+          return;
+        if (input.mutated) {
+          this.clearSatisfiedDirective("mutation landed", input.turn);
+          return;
+        }
+        if (input.toolName === "todo_write" && input.success) {
+          this.clearSatisfiedDirective("todo plan updated", input.turn);
+          return;
+        }
+        if (input.toolName === "file_read" && input.success) {
+          if (this.directive?.requiredNextAction === "read_authoritative_target" || this.directive?.requiredNextAction === "use_cached_evidence") {
+            this.clearSatisfiedDirective("authoritative evidence refreshed", input.turn);
+          }
+          return;
+        }
+        if (input.toolName === "shell" && input.success) {
+          if (this.directive?.requiredNextAction === "run_verification") {
+            this.clearSatisfiedDirective("verification ran successfully", input.turn);
+          }
+          return;
+        }
+        if (input.success)
+          return;
+        const family = failureFamilyKey(input.toolName, input.args, input.error, input.output);
+        const existing = this.failureFamilies.get(family);
+        const next = {
+          count: (existing?.count ?? 0) + 1,
+          lastTurn: input.turn,
+          sample: cleanFailureSample(input.error || input.output || "")
+        };
+        this.failureFamilies.set(family, next);
+        if (next.count >= 2 && this.shouldStrictlyIntervene(this.lastContext)) {
+          this.setDirective({
+            turn: input.turn,
+            state: "forced_replan",
+            reason: `same ${input.toolName} failure family repeated ${next.count} times: ${next.sample}`,
+            requiredNextAction: input.toolName === "shell" ? "read_authoritative_target" : "update_todos",
+            forbiddenActionFamilies: [actionFamily(input.toolName, input.args)]
+          });
+        }
+      }
+      markCompletionBlocked(input) {
+        if (!this.enabled)
+          return;
+        this.setDirective({
+          turn: input.turn,
+          state: "verify_or_block",
+          reason: input.reason,
+          requiredNextAction: input.requiredNextAction ?? "run_verification",
+          forbiddenActionFamilies: ["task_complete"]
+        });
+      }
+      markTerminalIncomplete(reason, turn) {
+        if (!this.enabled)
+          return;
+        this.setDirective({
+          turn,
+          state: "terminal_incomplete",
+          reason,
+          requiredNextAction: "report_incomplete",
+          forbiddenActionFamilies: ["brute_force", "task_complete"]
+        });
+      }
+      shouldStrictlyIntervene(context2) {
+        if (this.mode === "strict")
+          return true;
+        if (this.mode === "off")
+          return false;
+        if (this.modelTier === "small" || this.modelTier === "medium")
+          return true;
+        if (!context2)
+          return false;
+        const pressure = context2.pressureRatio ?? 0;
+        const ratio = context2.signalToNoiseRatio;
+        return pressure >= 0.85 || ratio !== null && ratio !== void 0 && ratio < 1.2;
+      }
+      hasLowSignalContext(context2) {
+        if (!context2)
+          return false;
+        const raw = context2.rawDiscoveryChars ?? 0;
+        const evidence = (context2.activeEvidenceChars ?? 0) + (context2.activeFrameChars ?? 0);
+        if (raw < 2e3)
+          return false;
+        if (evidence === 0)
+          return true;
+        return raw > evidence * 2;
+      }
+      setDirective(input) {
+        const existing = this.directive;
+        const stable = existing && existing.state === input.state && existing.reason === input.reason && existing.requiredNextAction === input.requiredNextAction;
+        const directive = stable ? {
+          ...existing,
+          forbiddenActionFamilies: unique2([
+            ...existing.forbiddenActionFamilies,
+            ...input.forbiddenActionFamilies
+          ])
+        } : {
+          id: `focus_${++directiveCounter}`,
+          state: input.state,
+          reason: input.reason,
+          requiredNextAction: input.requiredNextAction,
+          forbiddenActionFamilies: unique2(input.forbiddenActionFamilies),
+          createdTurn: input.turn,
+          ignoredCount: 0
+        };
+        this.directive = directive;
+        this.state = directive.state;
+        this.lastReason = directive.reason;
+        return directive;
+      }
+      clearSatisfiedDirective(reason, _turn) {
+        if (!this.directive)
+          return;
+        this.lastDecision = "directive_satisfied";
+        this.lastReason = reason;
+        this.directive = null;
+        this.state = "observe";
+      }
+      pass() {
+        return { kind: "pass", state: this.state, ...this.directive ? { directive: this.directive } : {} };
+      }
+      inject(directive, message2) {
+        this.lastDecision = "inject_guidance";
+        this.lastReason = directive.reason;
+        return { kind: "inject_guidance", state: directive.state, directive, message: message2 };
+      }
+      block(directive, message2, success) {
+        this.lastDecision = "block_tool_call";
+        this.lastReason = directive.reason;
+        return {
+          kind: "block_tool_call",
+          state: directive.state,
+          directive,
+          message: message2,
+          success
+        };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/completion-resolution-verifier.js
 function resolutionSystemPrompt() {
   return [
@@ -571727,6 +572085,7 @@ var init_agenticRunner = __esm({
     init_evidenceLedger();
     init_adversaryStream();
     init_contextWindowDump();
+    init_focusSupervisor();
     init_completion_resolution_verifier();
     init_todoTruth();
     init_evidenceBranch();
@@ -572240,6 +572599,10 @@ var init_agenticRunner = __esm({
       // adjacent to the main loop. Initialized per run when the step critic is
       // enabled and a backend is available. See adversaryStream.ts.
       _adversaryStream = null;
+      // Stateful small-model focus supervisor. It consolidates repeat gates,
+      // stale edit loops, completion holds, and context pressure into a single
+      // next-action contract injected through the active context frame.
+      _focusSupervisor = null;
       // Generic, cross-session failure→resolution learning: learns the token-level
       // change that turned a failed command into a working one (e.g. python→python3)
       // from observed pairs, and surfaces it before a matching command runs — so
@@ -572443,6 +572806,10 @@ ${parts.join("\n")}
           completionProvenanceGuard: options2?.completionProvenanceGuard ?? true,
           backwardPassReview: options2?.backwardPassReview,
           completionVerifyCommand: options2?.completionVerifyCommand,
+          focusSupervisor: resolveFocusSupervisorMode(options2?.focusSupervisor),
+          supervisorModel: options2?.supervisorModel ?? process.env["OMNIUS_SUPERVISOR_MODEL"] ?? "",
+          supervisorTimeoutMs: options2?.supervisorTimeoutMs ?? Number(process.env["OMNIUS_SUPERVISOR_TIMEOUT_MS"] ?? 2e4),
+          supervisorMaxTokens: options2?.supervisorMaxTokens ?? 900,
           disableAdversaryCritic,
           disableStepCritic: disableAdversaryCritic,
           modelTier: options2?.modelTier ?? "large",
@@ -572512,10 +572879,48 @@ ${parts.join("\n")}
           attempt,
           model: this._backendModelLabel(this.backend),
           cwd: this._workingDirectory || process.cwd(),
-          request
+          request,
+          focusSupervisor: this._focusSupervisor?.snapshot()
         });
+        if (record) {
+          this._focusSupervisor?.observeContext({
+            estimatedTokens: record.metrics.estimatedTokens,
+            rawDiscoveryChars: record.metrics.rawDiscoveryToolChars,
+            activeEvidenceChars: record.metrics.activeEvidenceChars,
+            activeFrameChars: record.metrics.activeContextFrameChars,
+            signalToNoiseRatio: record.metrics.signalToNoise.ratio,
+            pressureRatio: this._lastContextPressureSnapshot?.rawRatio ?? (this.options.contextWindowSize ? record.metrics.estimatedTokens / this.options.contextWindowSize : 0),
+            droppedSignals: this._lastContextFrameDiagnostics?.droppedSignals ?? this._lastContextPressureSnapshot?.droppedSignals,
+            truncatedSignals: this._lastContextFrameDiagnostics?.truncatedSignals ?? this._lastContextPressureSnapshot?.truncatedSignals
+          });
+        }
         return record?.id ?? null;
       }
+      _emitFocusSupervisorEvent(input) {
+        this.emit({
+          type: "focus_supervisor",
+          content: `${input.decision}: ${input.reason}`,
+          turn: input.turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          focusSupervisor: {
+            state: input.state ?? this._focusSupervisor?.snapshot().state ?? "observe",
+            decision: input.decision,
+            ...input.directiveId ? { directiveId: input.directiveId } : {},
+            reason: input.reason,
+            ...input.requiredNextAction ? { requiredNextAction: input.requiredNextAction } : {},
+            ...input.blockedTool ? { blockedTool: input.blockedTool } : {}
+          }
+        });
+      }
+      _buildFocusContextSnapshot() {
+        return {
+          pressureRatio: this._lastContextPressureSnapshot?.rawRatio ?? 0,
+          estimatedTokens: this._lastContextPressureSnapshot?.rawTokens,
+          activeFrameChars: this._lastContextFrameDiagnostics?.totalChars,
+          droppedSignals: this._lastContextFrameDiagnostics?.droppedSignals ?? this._lastContextPressureSnapshot?.droppedSignals,
+          truncatedSignals: this._lastContextFrameDiagnostics?.truncatedSignals ?? this._lastContextPressureSnapshot?.truncatedSignals
+        };
+      }
       _emitModelResolutionTelemetry(purpose, turn) {
         try {
           const backendName = this.backend.constructor?.name ?? "unknown";
@@ -574772,6 +575177,7 @@ ${_checks}`
               completionScenarioDecomposition
             ].join("\n")
           };
+          this._focusSupervisor?.markTerminalIncomplete(reason, turn);
           this.emit({
             type: "status",
             content: `REG-47 backward-pass runner threw: ${e2 instanceof Error ? e2.message : String(e2)}. Ending as incomplete_verification instead of completing.`,
@@ -574835,6 +575241,7 @@ ${_checks}`
               feedback
             ].join("\n")
           };
+          this._focusSupervisor?.markTerminalIncomplete(reason, turn);
           this.emit({
             type: "status",
             content: `REG-47 critic BLOCKED completion. Rationale: ${result.verdict.rationale.slice(0, 200)}`,
@@ -576023,21 +576430,21 @@ ${sections.join("\n")}` : sections.join("\n");
           sections.push(`Compacted cached entries still count as already-known results (${compactedCount}); an exact repeat will be served from cache or skipped, not produce new information.`);
         }
         if (filesRead.length > 0) {
-          const unique2 = [...new Set(filesRead)].slice(0, 30);
-          sections.push(`Files already read (${unique2.length}): ${unique2.join(", ")}`);
+          const unique3 = [...new Set(filesRead)].slice(0, 30);
+          sections.push(`Files already read (${unique3.length}): ${unique3.join(", ")}`);
         }
         if (dirsListed.length > 0) {
-          const unique2 = [...new Set(dirsListed)].slice(0, 15);
-          sections.push(`Directories already listed (${unique2.length}): ${unique2.join(", ")}`);
+          const unique3 = [...new Set(dirsListed)].slice(0, 15);
+          sections.push(`Directories already listed (${unique3.length}): ${unique3.join(", ")}`);
           sections.push(`Do not call list_directory again on these exact directories unless you changed their contents. Use the listed child paths directly with file_read/edit/delegation.`);
         }
         if (searches.length > 0) {
-          const unique2 = [...new Set(searches)].slice(0, 15);
-          sections.push(`Searches already run (${unique2.length}): ${unique2.join(", ")}`);
+          const unique3 = [...new Set(searches)].slice(0, 15);
+          sections.push(`Searches already run (${unique3.length}): ${unique3.join(", ")}`);
         }
         if (shells.length > 0) {
-          const unique2 = [...new Set(shells)].slice(0, 15);
-          sections.push(`Shell commands already executed (${unique2.length}): ${unique2.join(", ")}`);
+          const unique3 = [...new Set(shells)].slice(0, 15);
+          sections.push(`Shell commands already executed (${unique3.length}): ${unique3.join(", ")}`);
         }
         if (sections.length <= 1)
           return null;
@@ -576370,6 +576777,7 @@ ${chunk.content}`, {
         const todoBlock = this._renderTodoStateBlock(turn);
         const failureBlock = this._renderRecentFailuresBlock(turn);
         const churnBlock = this._renderWriteChurnBlock(turn);
+        const focusBlock = this._focusSupervisor?.renderFrame() ?? null;
         const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
         const anchorsBlock = this.surfaceAnchors(messages2);
         const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
@@ -576414,6 +576822,13 @@ ${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",
+            priority: 98,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
           signalFromBlock("recent_failure", "turn.failures", failureBlock, {
             id: "recent-failures",
             dedupeKey: "turn.failures",
@@ -577703,6 +578118,41 @@ Respond with your assessment, then take action.`;
         const cleanedTask = cleanForStorage(task) || task.slice(0, 500);
         const start2 = Date.now();
         const taskTimeoutMs = this.options.taskTimeoutMs;
+        const hardDeadlineMs = Number.isFinite(taskTimeoutMs) && taskTimeoutMs > 0 ? start2 + taskTimeoutMs : Number.POSITIVE_INFINITY;
+        let timedOut = false;
+        let timeoutSummary = "";
+        const remainingTaskMs = () => Number.isFinite(hardDeadlineMs) ? Math.max(0, hardDeadlineMs - Date.now()) : Number.POSITIVE_INFINITY;
+        const boundedRequestTimeoutMs = () => {
+          const configured = Number.isFinite(this.options.requestTimeoutMs) && this.options.requestTimeoutMs > 0 ? this.options.requestTimeoutMs : 3e5;
+          const remaining = remainingTaskMs();
+          return Number.isFinite(remaining) ? Math.max(1, Math.min(configured, remaining)) : configured;
+        };
+        const markTaskTimedOut = (phase, turn) => {
+          if (timedOut)
+            return;
+          timedOut = true;
+          timeoutSummary = `Incomplete: task timed out after ${taskTimeoutMs}ms during ${phase}.`;
+          this.emit({
+            type: "error",
+            content: timeoutSummary,
+            ...typeof turn === "number" ? { turn } : {},
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          this._onTypedEvent?.({
+            type: "run_failed",
+            runId: this._sessionId ?? "unknown",
+            error: timeoutSummary,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        };
+        const checkTaskTimeout = (phase, turn) => {
+          if (!Number.isFinite(hardDeadlineMs))
+            return false;
+          if (Date.now() < hardDeadlineMs)
+            return false;
+          markTaskTimedOut(phase, turn);
+          return true;
+        };
         const selfEvalInterval = taskTimeoutMs;
         let nextSelfEval = start2 + selfEvalInterval;
         let selfEvalCount = 0;
@@ -577723,6 +578173,11 @@ Respond with your assessment, then take action.`;
         this._lastActiveForgettingReport = null;
         this._lastContextConsolidationTurn = -1e3;
         this._contextFrameBuilder = new ContextFrameBuilder();
+        this._focusSupervisor = this.options.focusSupervisor === "off" ? null : new FocusSupervisor({
+          mode: this.options.focusSupervisor,
+          modelTier: this.options.modelTier,
+          repeatGateMax: this._resolveRepeatGateMax()
+        });
         if (!this._workingDirectory) {
           this._workingDirectory = _pathResolve(process.cwd());
         }
@@ -578471,6 +578926,23 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             lastCompletionGateCode = "";
             return false;
           }
+          this._focusSupervisor?.markCompletionBlocked({
+            turn,
+            reason: lastCompletionGateReason || "completion requested before required evidence was present",
+            requiredNextAction: lastCompletionGateCode === "todo_verification" ? "run_verification" : "update_todos"
+          });
+          const focusDirective = this._focusSupervisor?.snapshot().directive;
+          if (focusDirective) {
+            this._emitFocusSupervisorEvent({
+              decision: "completion_blocked",
+              state: focusDirective.state,
+              directiveId: focusDirective.id,
+              reason: focusDirective.reason,
+              requiredNextAction: focusDirective.requiredNextAction,
+              blockedTool: "task_complete",
+              turn
+            });
+          }
           const key = lastCompletionGateCode || (extractTaskCompleteSummary(args) || "").trim().slice(0, 200);
           if (key && key === this._completionHoldState.lastKey) {
             this._completionHoldState.count += 1;
@@ -578497,6 +578969,19 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               reason,
               summary: incompleteSummary
             };
+            this._focusSupervisor?.markTerminalIncomplete(reason, turn);
+            const terminalDirective = this._focusSupervisor?.snapshot().directive;
+            if (terminalDirective) {
+              this._emitFocusSupervisorEvent({
+                decision: "terminal_incomplete",
+                state: terminalDirective.state,
+                directiveId: terminalDirective.id,
+                reason: terminalDirective.reason,
+                requiredNextAction: terminalDirective.requiredNextAction,
+                blockedTool: "task_complete",
+                turn
+              });
+            }
             messages2.push({
               role: "system",
               content: `[INCOMPLETE VERIFICATION TERMINAL STATE] task_complete was held ${this._completionHoldState.count} times by the same completion gate without new evidence. The run is ending as incomplete_verification, not completed. Report the missing evidence plainly.`
@@ -578540,6 +579025,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         };
         const turnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
         for (let turn = 0; turn < turnCap; turn++) {
+          if (checkTaskTimeout("primary turn", turn))
+            break;
           clearTurnState(this._appState);
           this._maybeApplyThinkGuard();
           if (this._paused) {
@@ -580049,7 +580536,7 @@ ${memoryLines.join("\n")}`
             tools: toolDefs,
             temperature: this.options.temperature,
             maxTokens: effectiveMaxTokens,
-            timeoutMs: this.options.requestTimeoutMs
+            timeoutMs: boundedRequestTimeoutMs()
           };
           if ((this.options.contextWindowSize ?? 0) > 0) {
             chatRequest.numCtx = this.options.contextWindowSize;
@@ -580161,8 +580648,10 @@ ${memoryLines.join("\n")}`
                 break;
               }
             } else {
-              const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
+              const recovered = await this.retryOnTransient(reqErr, chatRequest, turn, hardDeadlineMs);
               if (!recovered) {
+                if (checkTaskTimeout("backend request", turn))
+                  break;
                 const errMsg = reqErr instanceof Error ? reqErr.message : String(reqErr);
                 const cause = reqErr instanceof Error && reqErr.cause ? ` (${reqErr.cause.message ?? ""} ${reqErr.cause?.code ?? ""})` : "";
                 this.emit({
@@ -580873,6 +581362,27 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
               }
               const staleEditBlock = this.staleEditPreflightBlock(tc.name, tc.arguments ?? {});
               if (staleEditBlock) {
+                const focusDecision2 = this._focusSupervisor?.evaluateProposedCall({
+                  turn,
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  fingerprint: toolFingerprint,
+                  isReadLike: false,
+                  stalePreflightMessage: staleEditBlock,
+                  context: this._buildFocusContextSnapshot()
+                });
+                const staleBlockOutput = focusDecision2?.kind === "block_tool_call" ? focusDecision2.message : staleEditBlock;
+                if (focusDecision2 && focusDecision2.kind !== "pass") {
+                  this._emitFocusSupervisorEvent({
+                    decision: focusDecision2.kind,
+                    state: focusDecision2.state,
+                    directiveId: focusDecision2.directive.id,
+                    reason: focusDecision2.directive.reason,
+                    requiredNextAction: focusDecision2.directive.requiredNextAction,
+                    blockedTool: tc.name,
+                    turn
+                  });
+                }
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -580884,7 +581394,7 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   type: "tool_result",
                   toolName: tc.name,
                   success: false,
-                  content: staleEditBlock.slice(0, 120),
+                  content: staleBlockOutput.slice(0, 120),
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -580896,20 +581406,41 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   this._completionLedger = recordToolEvidence(this._completionLedger, {
                     name: tc.name,
                     success: false,
-                    outputPreview: staleEditBlock.slice(0, 500),
+                    outputPreview: staleBlockOutput.slice(0, 500),
                     argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
                   });
                   this._saveCompletionLedgerSafe();
                 }
                 return {
                   tc,
-                  output: staleEditBlock,
+                  output: staleBlockOutput,
                   success: false,
-                  systemGuidance: staleEditBlock
+                  systemGuidance: staleBlockOutput
                 };
               }
               const staleRewriteBlock = this.staleEditOverwritePreflightBlock(tc.name, tc.arguments ?? {});
               if (staleRewriteBlock) {
+                const focusDecision2 = this._focusSupervisor?.evaluateProposedCall({
+                  turn,
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  fingerprint: toolFingerprint,
+                  isReadLike: false,
+                  stalePreflightMessage: staleRewriteBlock,
+                  context: this._buildFocusContextSnapshot()
+                });
+                const staleRewriteOutput = focusDecision2?.kind === "block_tool_call" ? focusDecision2.message : staleRewriteBlock;
+                if (focusDecision2 && focusDecision2.kind !== "pass") {
+                  this._emitFocusSupervisorEvent({
+                    decision: focusDecision2.kind,
+                    state: focusDecision2.state,
+                    directiveId: focusDecision2.directive.id,
+                    reason: focusDecision2.directive.reason,
+                    requiredNextAction: focusDecision2.directive.requiredNextAction,
+                    blockedTool: tc.name,
+                    turn
+                  });
+                }
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -580921,7 +581452,7 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   type: "tool_result",
                   toolName: tc.name,
                   success: false,
-                  content: staleRewriteBlock.slice(0, 120),
+                  content: staleRewriteOutput.slice(0, 120),
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -580933,16 +581464,16 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   this._completionLedger = recordToolEvidence(this._completionLedger, {
                     name: tc.name,
                     success: false,
-                    outputPreview: staleRewriteBlock.slice(0, 500),
+                    outputPreview: staleRewriteOutput.slice(0, 500),
                     argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
                   });
                   this._saveCompletionLedgerSafe();
                 }
                 return {
                   tc,
-                  output: staleRewriteBlock,
+                  output: staleRewriteOutput,
                   success: false,
-                  systemGuidance: staleRewriteBlock
+                  systemGuidance: staleRewriteOutput
                 };
               }
               const baseIsReadLike = ![
@@ -581075,7 +581606,8 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   });
                 }
                 const _repeatGateMax = this._resolveRepeatGateMax();
-                const repeatGateEligible = isReadLike || tc.name === "memory_write";
+                const isFailedShellRepeat = tc.name === "shell" && typeof _existingFp?.result === "string" && _existingFp.result.includes("status: failure");
+                const repeatGateEligible = isReadLike || tc.name === "memory_write" || isFailedShellRepeat;
                 if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
                   if (criticDecision.hitNumber >= _repeatGateMax) {
                     if (isReadLike) {
@@ -581086,6 +581618,13 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
 
 ` + cachedResult
                       };
+                    } else if (isFailedShellRepeat) {
+                      repeatShortCircuit = {
+                        success: false,
+                        output: this.sanitizeCachedToolResult(tc.name, _existingFp.result),
+                        error: this._buildRepeatGateBlock(tc.name, tc.arguments ?? {}, criticDecision.hitNumber),
+                        runtimeAuthored: true
+                      };
                     } else {
                       repeatShortCircuit = {
                         success: false,
@@ -581095,7 +581634,14 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                     }
                   } else {
                     const cachedResult = this.sanitizeCachedToolResult(tc.name, _existingFp.result);
-                    repeatShortCircuit = {
+                    repeatShortCircuit = isFailedShellRepeat ? {
+                      success: false,
+                      output: `[STOP RE-RUNNING FAILED COMMAND — this exact shell command already failed and no real file mutation has invalidated that evidence. It was NOT executed again. Use the cached failure below to change approach, inspect a different target, or report incomplete.]
+
+${cachedResult}`,
+                      error: "Repeated failing shell command was not re-executed.",
+                      runtimeAuthored: true
+                    } : {
                       success: true,
                       output: cachedResult
                     };
@@ -581109,6 +581655,40 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
               }
+              const focusCachedEntry = recentToolResults.get(toolFingerprint);
+              const focusDuplicateHits = criticDecision.decision === "guidance" ? criticDecision.hitNumber : dedupHitCount.get(toolFingerprint) ?? 0;
+              const focusDecision = this._focusSupervisor?.evaluateProposedCall({
+                turn,
+                toolName: tc.name,
+                args: tc.arguments ?? {},
+                fingerprint: toolFingerprint,
+                isReadLike,
+                cachedResult: focusCachedEntry?.result,
+                cachedResultFailed: tc.name === "shell" && typeof focusCachedEntry?.result === "string" && focusCachedEntry.result.includes("status: failure"),
+                duplicateHitCount: focusDuplicateHits,
+                context: this._buildFocusContextSnapshot()
+              });
+              if (focusDecision && focusDecision.kind !== "pass") {
+                this._emitFocusSupervisorEvent({
+                  decision: focusDecision.kind,
+                  state: focusDecision.state,
+                  directiveId: focusDecision.directive.id,
+                  reason: focusDecision.directive.reason,
+                  requiredNextAction: focusDecision.directive.requiredNextAction,
+                  blockedTool: focusDecision.kind === "block_tool_call" ? tc.name : void 0,
+                  turn
+                });
+                if (focusDecision.kind === "inject_guidance") {
+                  pushSoftInjection("system", focusDecision.message);
+                } else if (!repeatShortCircuit) {
+                  repeatShortCircuit = {
+                    success: focusDecision.success,
+                    output: focusDecision.message,
+                    error: focusDecision.success ? void 0 : focusDecision.message,
+                    runtimeAuthored: true
+                  };
+                }
+              }
               this.emit({
                 type: "tool_call",
                 toolName: tc.name,
@@ -582510,6 +583090,31 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               const filePath = typeof tc.arguments?.path === "string" ? tc.arguments.path : "";
               recordToolExecution(this._appState, tc.name, performance.now() - toolStart, result.success, filePath || void 0);
               this.noteStaleEditGuardOutcome(tc.name, tc.arguments ?? {}, result, turn);
+              {
+                const beforeDirective = this._focusSupervisor?.snapshot().directive?.id ?? null;
+                this._focusSupervisor?.observeToolResult({
+                  turn,
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  fingerprint: toolFingerprint,
+                  success: result.success,
+                  output: result.output ?? result.llmContent ?? "",
+                  error: result.error ?? "",
+                  mutated: realFileMutation,
+                  isReadLike
+                });
+                const afterDirective = this._focusSupervisor?.snapshot().directive ?? null;
+                if (afterDirective && afterDirective.id !== beforeDirective) {
+                  this._emitFocusSupervisorEvent({
+                    decision: "directive_created",
+                    state: afterDirective.state,
+                    directiveId: afterDirective.id,
+                    reason: afterDirective.reason,
+                    requiredNextAction: afterDirective.requiredNextAction,
+                    turn
+                  });
+                }
+              }
               if (tc.name === "todo_write") {
                 this._lastTodoWriteTurn = turn;
               }
@@ -583403,7 +584008,9 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
           }
         }
         let prevCycleToolCalls = toolCallCount;
-        while (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
+        while (!completed && !this.aborted && !this._completionIncompleteVerification && !timedOut && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
+          if (checkTaskTimeout("brute-force re-engagement"))
+            break;
           bruteForceCycle++;
           const totalTurns = messages2.filter((m2) => m2.role === "assistant").length;
           if (bruteForceCycle > 1 && toolCallCount === prevCycleToolCalls) {
@@ -583467,6 +584074,10 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
           }
           const restartTurnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
           for (let turn = 0; turn < restartTurnCap; turn++) {
+            if (checkTaskTimeout("brute-force turn", turn))
+              break;
+            if (this._completionIncompleteVerification)
+              break;
             this._maybeApplyThinkGuard();
             if (this._paused) {
               const shouldContinue = await this.waitIfPaused();
@@ -583548,7 +584159,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               tools: toolDefs,
               temperature: this.options.temperature,
               maxTokens: this.options.maxTokens,
-              timeoutMs: this.options.requestTimeoutMs,
+              timeoutMs: boundedRequestTimeoutMs(),
               numCtx: this.options.contextWindowSize || void 0
             };
             this._recordContextWindowDump("brute_force_turn", chatRequest, turn);
@@ -583590,8 +584201,10 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   break;
                 }
               } else {
-                const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
+                const recovered = await this.retryOnTransient(reqErr, chatRequest, turn, hardDeadlineMs);
                 if (!recovered) {
+                  if (checkTaskTimeout("brute-force backend request", turn))
+                    break;
                   const errMsg2 = reqErr instanceof Error ? reqErr.message : String(reqErr);
                   const cause2 = reqErr instanceof Error && reqErr.cause ? ` (${reqErr.cause.message ?? ""} ${reqErr.cause?.code ?? ""})` : "";
                   this.emit({
@@ -584067,6 +584680,9 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
         }
         const durationMs = Date.now() - start2;
         const incompleteVerification = this._completionIncompleteVerification;
+        if (timedOut && !summary) {
+          summary = timeoutSummary || `Incomplete: task timed out after ${taskTimeoutMs}ms.`;
+        }
         if (incompleteVerification && !summary) {
           summary = incompleteVerification.summary;
         }
@@ -588547,7 +589163,7 @@ ${description}`
        * until recovery; other transient backend errors use bounded backoff.
        * Returns the response on success, or null if recovery did not apply.
        */
-      async retryOnTransient(initialErr, chatRequest, turn) {
+      async retryOnTransient(initialErr, chatRequest, turn, hardDeadlineMs) {
         if (!this.isTransientError(initialErr))
           return null;
         const errMsg = flattenErrorText(initialErr);
@@ -588562,6 +589178,15 @@ ${description}`
         while (attempt <= (maxRetries === Infinity ? Number.MAX_SAFE_INTEGER : maxRetries)) {
           if (this.aborted)
             return null;
+          if (Number.isFinite(hardDeadlineMs) && Date.now() >= hardDeadlineMs) {
+            this.emit({
+              type: "error",
+              content: "Task timeout reached during backend retry",
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            return null;
+          }
           if (this.isPaymentRequiredError(initialErr) && typeof backend.rotateKey === "function") {
             const rotated = backend.rotateKey();
             if (rotated) {
@@ -588611,6 +589236,7 @@ ${description}`
             }
           }
           const delay3 = isGpuSlotUnavailable ? baseDelayMs : Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
+          const effectiveDelay = Number.isFinite(hardDeadlineMs) ? Math.max(0, Math.min(delay3, hardDeadlineMs - Date.now())) : delay3;
           const attemptLabel = maxRetries === Infinity ? `${attempt}` : `${attempt}/${maxRetries}`;
           if (isGpuSlotUnavailable) {
             this.emit({
@@ -588621,13 +589247,22 @@ ${description}`
           } else {
             this.emit({
               type: "status",
-              content: `Backend error — retrying in ${(delay3 / 1e3).toFixed(0)}s (attempt ${attemptLabel})`,
+              content: `Backend error — retrying in ${(effectiveDelay / 1e3).toFixed(0)}s (attempt ${attemptLabel})`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          await new Promise((r2) => setTimeout(r2, delay3));
+          await new Promise((r2) => setTimeout(r2, effectiveDelay));
           if (this.aborted)
             return null;
+          if (Number.isFinite(hardDeadlineMs) && Date.now() >= hardDeadlineMs) {
+            this.emit({
+              type: "error",
+              content: "Task timeout reached before backend retry could resume",
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            return null;
+          }
           try {
             this._recordContextWindowDump("agent_turn_transient_retry", chatRequest, turn, attempt);
             const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
@@ -595514,6 +596149,7 @@ __export(dist_exports3, {
   EditorRunner: () => EditorRunner,
   FLOWSTATE_PROMPT: () => FLOWSTATE_PROMPT,
   FRONTEND_WORKER_SKILL: () => FRONTEND_WORKER_SKILL,
+  FocusSupervisor: () => FocusSupervisor,
   HookManager: () => HookManager,
   INFRA_WORKER_SKILL: () => INFRA_WORKER_SKILL,
   ImportanceBudget: () => ImportanceBudget,
@@ -595712,6 +596348,7 @@ __export(dist_exports3, {
   resetPluginRegistry: () => resetPluginRegistry,
   resolveAgentTools: () => resolveAgentTools,
   resolveDefaultPoolConfig: () => resolveDefaultPoolConfig,
+  resolveFocusSupervisorMode: () => resolveFocusSupervisorMode,
   resolveModelProfile: () => resolveModelProfile,
   restoreAgentTasks: () => restoreAgentTasks,
   retentionStrength: () => retentionStrength,
@@ -595780,6 +596417,7 @@ var init_dist8 = __esm({
     init_flowstatePrompt();
     init_contextEngine();
     init_contextWindowDump();
+    init_focusSupervisor();
     init_completionLedger();
     init_runEvents();
     init_costTracker();
@@ -653310,14 +653948,14 @@ function loadFailurePatterns(store2) {
     const unresolved = store2.listUnresolved();
     if (unresolved.length === 0) return "";
     const seen = /* @__PURE__ */ new Set();
-    const unique2 = unresolved.filter((f2) => {
+    const unique3 = unresolved.filter((f2) => {
       if (seen.has(f2.fingerprint)) return false;
       seen.add(f2.fingerprint);
       return true;
     });
-    if (unique2.length === 0) return "";
+    if (unique3.length === 0) return "";
     const lines = ["Known failure patterns (avoid repeating these):"];
-    for (const f2 of unique2.slice(0, 8)) {
+    for (const f2 of unique3.slice(0, 8)) {
       const file = f2.filePath ? ` in ${f2.filePath}` : "";
       lines.push(`- [${f2.failureType}]${file}: ${f2.errorMessage.slice(0, 150)}`);
     }
@@ -656101,8 +656739,8 @@ function generateDescriptors(repoRoot) {
   if (repoName2 && !tags.includes(repoName2)) {
     tags.push(repoName2);
   }
-  const unique2 = [...new Set(tags.map((t2) => t2.toLowerCase().trim()).filter((t2) => t2.length > 1 && t2.length < 60))];
-  const phrases = unique2.map((text2) => ({
+  const unique3 = [...new Set(tags.map((t2) => t2.toLowerCase().trim()).filter((t2) => t2.length > 1 && t2.length < 60))];
+  const phrases = unique3.map((text2) => ({
     text: text2,
     color: weightedColor(profile)
   }));
@@ -656123,7 +656761,7 @@ function generateDescriptors(repoRoot) {
     ];
     for (const fb of fallbacks) {
       if (phrases.length >= 20) break;
-      if (!unique2.includes(fb)) {
+      if (!unique3.includes(fb)) {
         phrases.push({ text: fb, color: weightedColor(profile) });
       }
     }
@@ -661454,13 +662092,13 @@ function buildScopedToolList(scope) {
   const commandSigs = commands.flatMap((cmd) => cmd.signatures);
   const allSigs = [...syntheticSigs, ...commandSigs];
   const seen = /* @__PURE__ */ new Set();
-  const unique2 = allSigs.filter((sig) => {
+  const unique3 = allSigs.filter((sig) => {
     if (seen.has(sig.signature)) return false;
     seen.add(sig.signature);
     return true;
   });
   const entries = [];
-  for (const sig of unique2) {
+  for (const sig of unique3) {
     const matchingCmd = commands.find(
       (cmd) => cmd.signatures.some((s2) => s2.signature === sig.signature)
     );
@@ -666402,14 +667040,14 @@ function parseTelegramReplyPreferenceUpdate(parsed) {
 }
 function uniqueTelegramJsonCandidates(candidates) {
   const seen = /* @__PURE__ */ new Set();
-  const unique2 = [];
+  const unique3 = [];
   for (const candidate of candidates) {
     const clean5 = candidate.trim();
     if (!clean5 || seen.has(clean5)) continue;
     seen.add(clean5);
-    unique2.push(clean5);
+    unique3.push(clean5);
   }
-  return unique2;
+  return unique3;
 }
 function extractBalancedTelegramJsonObjects(text2) {
   const objects = [];
@@ -667408,10 +668046,10 @@ function telegramHistoryTime(entry) {
   });
 }
 function formatTelegramIdentitySignals(signals) {
-  const unique2 = [
+  const unique3 = [
     ...new Set(signals.map((signal) => signal.trim()).filter(Boolean))
   ];
-  return unique2.length > 0 ? unique2.join(", ") : "none";
+  return unique3.length > 0 ? unique3.join(", ") : "none";
 }
 function summarizeTelegramMessageAttachments(msg) {
   const parts = [];
@@ -667932,12 +668570,12 @@ function buildTelegramHelpHTML(scope, maxPublicCommands = 24) {
     ...commands.flatMap((cmd) => cmd.signatures)
   ];
   const seen = /* @__PURE__ */ new Set();
-  const unique2 = signatures.filter((sig) => {
+  const unique3 = signatures.filter((sig) => {
     if (seen.has(sig.signature)) return false;
     seen.add(sig.signature);
     return true;
   });
-  const visible = scope === "public" ? unique2.slice(0, maxPublicCommands) : unique2;
+  const visible = scope === "public" ? unique3.slice(0, maxPublicCommands) : unique3;
   const lines = [
     `<b>Commands (${scope === "admin" ? "admin full scope" : "public secure scope"})</b>`,
     "",
@@ -667945,7 +668583,7 @@ function buildTelegramHelpHTML(scope, maxPublicCommands = 24) {
       (sig) => `<code>${escapeTelegramHTML(sig.signature)}</code> - ${escapeTelegramHTML(sig.description)}`
     )
   ];
-  if (scope === "public" && unique2.length > visible.length) {
+  if (scope === "public" && unique3.length > visible.length) {
     lines.push("");
     lines.push(
       `Public scope truncated to ${visible.length} safe commands. Authenticate as admin for full command help.`
@@ -682177,20 +682815,20 @@ Scoped workspace: ${scopedRoot}`,
         };
       }
       async deleteTelegramMessages(chatId, messageIds, currentMsg) {
-        const unique2 = [...new Set(messageIds)].filter((id) => Number.isFinite(id));
-        if (unique2.length === 0)
+        const unique3 = [...new Set(messageIds)].filter((id) => Number.isFinite(id));
+        if (unique3.length === 0)
           throw new Error(
             "deleteTelegramMessages requires at least one message id."
           );
         await this.assertTelegramBotRightsForAction(
           "delete_messages",
           chatId,
-          unique2,
+          unique3,
           currentMsg
         );
         const chunks = [];
-        for (let idx = 0; idx < unique2.length; idx += 100)
-          chunks.push(unique2.slice(idx, idx + 100));
+        for (let idx = 0; idx < unique3.length; idx += 100)
+          chunks.push(unique3.slice(idx, idx + 100));
         const results = [];
         for (const chunk of chunks) {
           const result = await this.apiCall("deleteMessages", {
@@ -682208,9 +682846,9 @@ Scoped workspace: ${scopedRoot}`,
           telegram_method: "deleteMessages",
           ok: true,
           chat_id: chatId,
-          message_ids: unique2,
+          message_ids: unique3,
           batches: results,
-          bot_rights_checked: !this.telegramTargetLooksPrivate(chatId, currentMsg) && !unique2.every((id) => this.isKnownAssistantTelegramMessage(chatId, id)),
+          bot_rights_checked: !this.telegramTargetLooksPrivate(chatId, currentMsg) && !unique3.every((id) => this.isKnownAssistantTelegramMessage(chatId, id)),
           policy_scope: this.telegramToolPolicy.chatOverrides?.[String(chatId)] ? "chat" : "global/default"
         };
       }