oh-my-codex 0.15.2 → 0.16.0

package/src/scripts/codex-native-pre-post.ts

@@ -2,6 +2,7 @@ import {
   buildDocumentRefreshAdvisoryOutput,
   evaluateStagedDocumentRefresh,
 } from "../document-refresh/enforcer.js";
+import { isLoreCommitGuardEnabled } from "../config/commit-lore-guard.js";
 import { resolveCodexExecutionSurface } from "./codex-execution-surface.js";
 
 type CodexHookPayload = Record<string, unknown>;
@@ -284,8 +285,91 @@ function tokenizeShellCommand(commandText: string): string[] | null {
   return tokens.length > 0 ? tokens : null;
 }
 
+interface ShellToken {
+  value: string;
+  startsCommand: boolean;
+}
+
+function tokenizeShellCommandWithBoundaries(commandText: string): ShellToken[] | null {
+  const trimmed = commandText.trim();
+  if (!trimmed) return null;
+
+  const tokens: ShellToken[] = [];
+  let current = "";
+  let quote: "'" | "\"" | null = null;
+  let escaping = false;
+  let nextTokenStartsCommand = false;
+
+  const pushCurrent = () => {
+    if (!current) return;
+    tokens.push({ value: current, startsCommand: tokens.length === 0 || nextTokenStartsCommand });
+    current = "";
+    nextTokenStartsCommand = false;
+  };
+
+  for (let index = 0; index < trimmed.length; index += 1) {
+    const char = trimmed[index] ?? "";
+
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+
+    if (quote === "'") {
+      if (char === "'") {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (quote === "\"") {
+      if (char === "\"") quote = null;
+      else if (char === "\\") {
+        if (isDoubleQuotedShellEscapeTarget(trimmed[index + 1])) escaping = true;
+        else current += char;
+      }
+      else current += char;
+      continue;
+    }
+
+    if (char === "\n" || char === ";" || char === "&" || char === "|") {
+      pushCurrent();
+      nextTokenStartsCommand = true;
+      if ((char === "&" || char === "|") && trimmed[index + 1] === char) index += 1;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      pushCurrent();
+      continue;
+    }
+
+    if (char === "'" || char === "\"") {
+      quote = char;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (escaping || quote) return null;
+  pushCurrent();
+  return tokens.length > 0 ? tokens : null;
+}
+
 interface GitCommitCommandParseResult {
   isGitCommit: boolean;
+  inlineEnvironment: NodeJS.ProcessEnv;
+  environmentStartsClean: boolean;
+  unsetEnvironmentNames: string[];
   inlineMessage: string | null;
   repositorySelection: GitRepositorySelection;
   requiresExternalMessageSource: boolean;
@@ -322,38 +406,159 @@ function envOptionConsumesNextValue(token: string): boolean {
     || token === "--split-string";
 }
 
-function findGitCommandTokenIndex(tokens: string[]): number {
-  let index = 0;
+function tokenStartsCommand(tokens: ShellToken[], index: number): boolean {
+  return index <= 0 || (tokens[index]?.startsCommand ?? false);
+}
+
+function nextCommandStart(tokens: ShellToken[], startIndex: number): number {
+  let index = startIndex + 1;
+  while (index < tokens.length && !tokenStartsCommand(tokens, index)) {
+    index += 1;
+  }
+  return index;
+}
+
+function findGitCommandTokenIndex(tokens: ShellToken[]): number {
+  for (let commandStart = 0; commandStart < tokens.length; commandStart = nextCommandStart(tokens, commandStart)) {
+    let index = commandStart;
+    const commandEnd = nextCommandStart(tokens, commandStart);
+
+    while (index < commandEnd && isInlineShellEnvAssignment(tokens[index]?.value ?? "")) {
+      index += 1;
+    }
+
+    while (index < commandEnd && isEnvExecutableToken(tokens[index]?.value ?? "")) {
+      index += 1;
+      while (index < commandEnd) {
+        const token = tokens[index]?.value ?? "";
+        if (token === "--") {
+          index += 1;
+          break;
+        }
+        if (isInlineShellEnvAssignment(token)) {
+          index += 1;
+          continue;
+        }
+        if (token === "-i" || token === "--ignore-environment" || token.startsWith("--unset=")) {
+          index += 1;
+          continue;
+        }
+        if (token.startsWith("-")) {
+          index += envOptionConsumesNextValue(token) ? 2 : 1;
+          continue;
+        }
+        break;
+      }
+      while (index < commandEnd && isInlineShellEnvAssignment(tokens[index]?.value ?? "")) {
+        index += 1;
+      }
+    }
+
+    if (index < commandEnd && isGitExecutableToken(tokens[index]?.value ?? "")) return index;
+    if (commandEnd <= commandStart) break;
+    commandStart = commandEnd - 1;
+  }
+
+  return -1;
+}
+
+function tokenValues(tokens: ShellToken[]): string[] {
+  return tokens.map((token) => token.value);
+}
+
+function findCommandStart(tokens: ShellToken[], tokenIndex: number): number {
+  let index = tokenIndex;
+  while (index > 0 && !tokenStartsCommand(tokens, index)) {
+    index -= 1;
+  }
+  return index;
+}
+
+
+interface InlineEnvironmentRead {
+  inlineEnvironment: NodeJS.ProcessEnv;
+  environmentStartsClean: boolean;
+  unsetEnvironmentNames: string[];
+}
+
+function readUnsetEnvNameFromOption(token: string, nextToken: string | undefined): {
+  name: string | null;
+  consumedNext: boolean;
+} {
+  if (token === "-u" || token === "--unset") {
+    return { name: nextToken ?? null, consumedNext: true };
+  }
+  if (token.startsWith("--unset=")) {
+    return { name: token.slice("--unset=".length), consumedNext: false };
+  }
+  return { name: null, consumedNext: false };
+}
 
-  while (index < tokens.length && isInlineShellEnvAssignment(tokens[index] ?? "")) {
+function readInlineEnvironmentAssignments(tokens: ShellToken[], gitTokenIndex: number): InlineEnvironmentRead {
+  const inlineEnvironment: NodeJS.ProcessEnv = {};
+  const unsetEnvironmentNames = new Set<string>();
+  let environmentStartsClean = false;
+  const commandStart = findCommandStart(tokens, gitTokenIndex);
+  const recordAssignment = (token: string) => {
+    const separatorIndex = token.indexOf("=");
+    const name = token.slice(0, separatorIndex);
+    inlineEnvironment[name] = token.slice(separatorIndex + 1);
+    unsetEnvironmentNames.delete(name);
+  };
+  const recordUnset = (name: string | null) => {
+    if (!name) return;
+    delete inlineEnvironment[name];
+    unsetEnvironmentNames.add(name);
+  };
+
+  let index = commandStart;
+  while (index < gitTokenIndex && isInlineShellEnvAssignment(tokens[index]?.value ?? "")) {
+    recordAssignment(tokens[index]?.value ?? "");
     index += 1;
   }
 
-  while (index < tokens.length && isEnvExecutableToken(tokens[index] ?? "")) {
+  while (index < gitTokenIndex && isEnvExecutableToken(tokens[index]?.value ?? "")) {
     index += 1;
-    while (index < tokens.length) {
-      const token = tokens[index] ?? "";
+    while (index < gitTokenIndex) {
+      const token = tokens[index]?.value ?? "";
       if (token === "--") {
         index += 1;
         break;
       }
-      if (isInlineShellEnvAssignment(token) || token.startsWith("-")) {
-        if (envOptionConsumesNextValue(token)) {
-          index += 1;
-        }
+      if (isInlineShellEnvAssignment(token)) {
+        recordAssignment(token);
+        index += 1;
+        continue;
+      }
+      if (token === "-i" || token === "--ignore-environment") {
+        environmentStartsClean = true;
+        unsetEnvironmentNames.clear();
         index += 1;
         continue;
       }
+      const unset = readUnsetEnvNameFromOption(token, tokens[index + 1]?.value);
+      if (unset.name !== null || unset.consumedNext) {
+        recordUnset(unset.name);
+        index += unset.consumedNext ? 2 : 1;
+        continue;
+      }
+      if (token.startsWith("-")) {
+        index += envOptionConsumesNextValue(token) ? 2 : 1;
+        continue;
+      }
       break;
     }
-    while (index < tokens.length && isInlineShellEnvAssignment(tokens[index] ?? "")) {
+    while (index < gitTokenIndex && isInlineShellEnvAssignment(tokens[index]?.value ?? "")) {
+      recordAssignment(tokens[index]?.value ?? "");
       index += 1;
     }
   }
 
-  return index < tokens.length && isGitExecutableToken(tokens[index] ?? "")
-    ? index
-    : -1;
+  return {
+    inlineEnvironment,
+    environmentStartsClean,
+    unsetEnvironmentNames: [...unsetEnvironmentNames],
+  };
 }
 
 function gitOptionConsumesNextValue(token: string): boolean {
@@ -420,20 +625,27 @@ function readGitRepositorySelection(tokens: string[], gitTokenIndex: number, sub
 }
 
 export function parseGitCommitCommand(commandText: string): GitCommitCommandParseResult {
-  const tokens = tokenizeShellCommand(commandText);
+  const shellTokens = tokenizeShellCommandWithBoundaries(commandText);
+  const tokens = shellTokens ? tokenValues(shellTokens) : null;
   if (!tokens) {
     return {
       isGitCommit: false,
+      inlineEnvironment: {},
+      environmentStartsClean: false,
+      unsetEnvironmentNames: [],
       inlineMessage: null,
       repositorySelection: "current-cwd",
       requiresExternalMessageSource: false,
     };
   }
 
-  const gitTokenIndex = findGitCommandTokenIndex(tokens);
+  const gitTokenIndex = findGitCommandTokenIndex(shellTokens ?? []);
   if (gitTokenIndex < 0 || !isGitExecutableToken(tokens[gitTokenIndex] ?? "")) {
     return {
       isGitCommit: false,
+      inlineEnvironment: {},
+      environmentStartsClean: false,
+      unsetEnvironmentNames: [],
       inlineMessage: null,
       repositorySelection: "current-cwd",
       requiresExternalMessageSource: false,
@@ -444,6 +656,9 @@ export function parseGitCommitCommand(commandText: string): GitCommitCommandPars
   if (subcommandIndex < 0 || tokens[subcommandIndex]?.toLowerCase() !== "commit") {
     return {
       isGitCommit: false,
+      inlineEnvironment: {},
+      environmentStartsClean: false,
+      unsetEnvironmentNames: [],
       inlineMessage: null,
       repositorySelection: "current-cwd",
       requiresExternalMessageSource: false,
@@ -451,6 +666,7 @@ export function parseGitCommitCommand(commandText: string): GitCommitCommandPars
   }
 
   const repositorySelection = readGitRepositorySelection(tokens, gitTokenIndex, subcommandIndex);
+  const { inlineEnvironment, environmentStartsClean, unsetEnvironmentNames } = readInlineEnvironmentAssignments(shellTokens ?? [], gitTokenIndex);
   const messageParts: string[] = [];
   let requiresExternalMessageSource = false;
   const args = tokens.slice(subcommandIndex + 1);
@@ -492,12 +708,26 @@ export function parseGitCommitCommand(commandText: string): GitCommitCommandPars
 
   return {
     isGitCommit: true,
+    inlineEnvironment,
+    environmentStartsClean,
+    unsetEnvironmentNames,
     inlineMessage: messageParts.length > 0 ? messageParts.join("\n\n").trim() : null,
     repositorySelection,
     requiresExternalMessageSource,
   };
 }
 
+function buildEffectiveLoreCommitGuardEnv(parsed: GitCommitCommandParseResult): NodeJS.ProcessEnv {
+  const effectiveEnvironment: NodeJS.ProcessEnv = parsed.environmentStartsClean ? {} : { ...process.env };
+  for (const name of parsed.unsetEnvironmentNames) {
+    delete effectiveEnvironment[name];
+  }
+  for (const [name, value] of Object.entries(parsed.inlineEnvironment)) {
+    if (typeof value === "string") effectiveEnvironment[name] = value;
+  }
+  return effectiveEnvironment;
+}
+
 function isLoreTrailerLine(line: string): boolean {
   return line === OMX_COAUTHOR_TRAILER
     || LORE_TRAILER_PREFIXES.some((prefix) => line.startsWith(prefix));
@@ -578,6 +808,8 @@ function buildGitCommitEnforcementOutput(commandText: string): Record<string, un
   const parsed = parseGitCommitCommand(commandText);
   if (!parsed.isGitCommit) return null;
 
+  if (!isLoreCommitGuardEnabled(buildEffectiveLoreCommitGuardEnv(parsed))) return null;
+
   const errors = parsed.requiresExternalMessageSource
     ? [
       "Use inline `git commit -m ...` paragraphs for Lore-format commits in this path; file/editor/reuse/fixup message sources are not inspectable safely from pre-tool-use enforcement.",
@@ -616,6 +848,125 @@ function buildDocumentRefreshPreToolUseOutput(
   return buildDocumentRefreshAdvisoryOutput(warning, "PreToolUse");
 }
 
+
+export const SLOPPY_FALLBACK_PHRASE_PATTERNS = [
+  /\bquick hack\b/i,
+  /\bhacky\b/i,
+  /\bworkaround for now\b/i,
+  /\btemporary workaround\b/i,
+  /\btemporary fallback\b/i,
+  /\bjust bypass\b/i,
+  /\bjust skip\b/i,
+  /\bskip (?:the )?(?:failing )?(?:test|validation|checks?)\b/i,
+  /\bfallback if (?:it|this|that) fails\b/i,
+  /\bfor now,? just\b/i,
+  /\bbypass (?:the )?(?:failing )?(?:test|validation|checks?)\b/i,
+] as const;
+
+export const SLOPPY_FALLBACK_IMPLEMENTATION_CONTEXT_PATTERNS = [
+  /\badd\b/i,
+  /\bimplement\b/i,
+  /\bpatch\b/i,
+  /\bwrite\b/i,
+  /\bchange\b/i,
+  /\bfix\b/i,
+  /\bbypass\b/i,
+  /\bfallback\b/i,
+  /\bworkaround\b/i,
+  /\bskip\b/i,
+  /\bdisable\b/i,
+] as const;
+
+export const SLOPPY_FALLBACK_GROUNDING_PATTERNS = [
+  /\btested\b/i,
+  /\btests? pass(?:ed)?\b/i,
+  /\bnpm (?:run )?test\b/i,
+  /\bnode --test\b/i,
+  /\bunit tests?\b/i,
+  /\bintegration tests?\b/i,
+  /\bregression tests?\b/i,
+  /\bcoverage\b/i,
+  /\bspec(?:ification)?\b/i,
+  /\bADR\b/,
+  /\barchitecture\b/i,
+  /\barchitect\b/i,
+  /\bdesign\b/i,
+  /\bbecause\b/i,
+  /\bcompatib(?:le|ility)\b/i,
+  /\bbackward-compatible\b/i,
+  /\bfail-safe\b/i,
+  /\bfailsafe\b/i,
+  /\benvironment issue\b/i,
+  /\benv(?:ironment)? problem\b/i,
+  /\buser approved\b/i,
+  /\bapproved by (?:the )?user\b/i,
+  /(?:^|\s)#\d+\b/,
+  /\bPR\s*#?\d+\b/i,
+] as const;
+
+const READ_ONLY_COMMAND_TOKENS = new Set([
+  "cat",
+  "find",
+  "grep",
+  "head",
+  "less",
+  "ls",
+  "rg",
+  "sed",
+  "tail",
+]);
+
+function commandStartsWithReadOnlyInspection(command: string): boolean {
+  if (commandHasWriteLikeIntent(command)) return false;
+  const tokens = tokenizeShellCommand(command);
+  if (!tokens || tokens.length === 0) return false;
+  let commandToken = tokens[0] ?? "";
+  if (commandToken === "env") {
+    const nextCommand = tokens.find((token, index) => index > 0 && !token.startsWith("-") && !isInlineShellEnvAssignment(token));
+    commandToken = nextCommand ?? commandToken;
+  }
+  const basename = commandToken.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? commandToken.toLowerCase();
+  if (!READ_ONLY_COMMAND_TOKENS.has(basename)) return false;
+  if (basename === "sed" && tokens.some((token) => token === "-i" || token.startsWith("-i"))) return false;
+  if (basename === "cat" && /(?:^|[;&|]\s*)cat\b[\s\S]{0,200}>\s*[^\s&|;]+/.test(command)) return false;
+  return !/\|\s*(?:sh|bash|zsh|python3?|node|perl|ruby|apply_patch)\b/i.test(command);
+}
+
+function commandHasWriteLikeIntent(command: string): boolean {
+  return /\bapply_patch\b/.test(command)
+    || /(?:^|[;&|]\s*)(?:cat|printf|echo)\b[\s\S]{0,200}>\s*[^\s&|;]+/.test(command)
+    || /\btee\s+(?:-a\s+)?[^\s&|;]+/.test(command)
+    || /\bsed\s+(?:[^\n;&|]*\s)?-i(?:\b|['"])/.test(command)
+    || /\b(?:python3?|node|perl|ruby)\b[\s\S]{0,240}\b(?:writeFileSync|writeFile|write_text|open\([^)]*["']w|File\.write|Path\()/.test(command)
+    || /<<['"]?[A-Za-z0-9_ -]+['"]?[\s\S]*(?:^|\n)(?:\+\+\+\s|---\s|import\s|export\s|function\s|const\s|class\s|interface\s)/m.test(command);
+}
+
+export function hasAnyPattern(text: string, patterns: readonly RegExp[]): boolean {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function detectSloppyFallbackFraming(command: string): boolean {
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+  if (commandStartsWithReadOnlyInspection(trimmed)) return false;
+  if (!commandHasWriteLikeIntent(trimmed)) return false;
+  if (!hasAnyPattern(trimmed, SLOPPY_FALLBACK_PHRASE_PATTERNS)) return false;
+  if (!hasAnyPattern(trimmed, SLOPPY_FALLBACK_IMPLEMENTATION_CONTEXT_PATTERNS)) return false;
+  if (hasAnyPattern(trimmed, SLOPPY_FALLBACK_GROUNDING_PATTERNS)) return false;
+  return true;
+}
+
+function buildSloppyFallbackPreToolUseOutput(commandText: string): Record<string, unknown> | null {
+  if (!detectSloppyFallbackFraming(commandText)) return null;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+    },
+    systemMessage:
+      "Sloppy fallback/workaround framing detected: don't make potential slop. Consult an architect for a concrete architecture, or ask the user if this is an environment issue before adding bypass/fallback code.",
+  };
+}
+
 function commandInvokesOmxQuestion(command: string): boolean {
   const tokens = tokenizeShellCommand(command)?.map((token) => token.toLowerCase()) ?? [];
   for (let index = 0; index < tokens.length; index += 1) {
@@ -746,6 +1097,8 @@ export function buildNativePreToolUseOutput(
     safeString(payload.cwd).trim() || process.cwd(),
   );
   if (documentRefreshWarning) return documentRefreshWarning;
+  const sloppyFallbackWarning = buildSloppyFallbackPreToolUseOutput(normalized.normalizedCommand);
+  if (sloppyFallbackWarning) return sloppyFallbackWarning;
   if (!matchesDestructiveFixture(normalized.normalizedCommand)) return null;
 
   return {

package/src/scripts/hook-derived-watcher.ts

@@ -28,7 +28,8 @@ const runOnce = process.argv.includes('--once');
 const pollMs = Math.max(250, asNumber(argValue('--poll-ms', process.env.OMX_HOOK_DERIVED_POLL_MS || '800'), 800));
 const maxFileAgeMs = Math.max(10_000, asNumber(argValue('--file-age-ms', process.env.OMX_HOOK_DERIVED_FILE_AGE_MS || '90000'), 90000));
 
-const omxDir = join(cwd, '.omx');
+const runtimeRoot = resolve(process.env.OMX_ROOT || process.env.OMX_STATE_ROOT || cwd);
+const omxDir = join(runtimeRoot, '.omx');
 const logsDir = join(omxDir, 'logs');
 const stateDir = join(omxDir, 'state');
 const watcherStatePath = join(stateDir, 'hook-derived-watcher-state.json');

package/src/scripts/notify-fallback-watcher.ts

@@ -142,7 +142,8 @@ const maxLifetimeMs = runOnce
     )
   );
 
-const omxDir = join(cwd, '.omx');
+const runtimeRoot = resolve(process.env.OMX_ROOT || process.env.OMX_STATE_ROOT || cwd);
+const omxDir = join(runtimeRoot, '.omx');
 const logsDir = join(omxDir, 'logs');
 const stateDir = join(omxDir, 'state');
 const statePath = join(stateDir, 'notify-fallback-state.json');

package/src/scripts/notify-hook/orchestration-intent.ts

@@ -34,7 +34,6 @@ export function classifyLeaderActionState({
   allWorkersIdle = false,
   workerPanesAlive = false,
   taskCounts = {},
-  teamProgressStalled = false,
 } = {}) {
   const pending = Number.isFinite(taskCounts.pending) ? taskCounts.pending : 0;
   const blocked = Number.isFinite(taskCounts.blocked) ? taskCounts.blocked : 0;
@@ -43,10 +42,9 @@ export function classifyLeaderActionState({
   const pendingFollowUpTasks = allWorkersIdle && pending > 0 && blocked === 0 && inProgress === 0;
   const blockedWaitingOnLeader = allWorkersIdle && blocked > 0 && pending === 0 && inProgress === 0;
   const terminalWaitingOnLeader = allWorkersIdle && tasksComplete && workerPanesAlive;
-  const stalledWaitingOnLeader = blockedWaitingOnLeader || teamProgressStalled;
 
   if (terminalWaitingOnLeader) return 'done_waiting_on_leader';
-  if (stalledWaitingOnLeader) return 'stuck_waiting_on_leader';
+  if (blockedWaitingOnLeader) return 'stuck_waiting_on_leader';
   if (pendingFollowUpTasks) return 'still_actionable';
   return 'still_actionable';
 }

package/src/scripts/notify-hook/team-leader-nudge.ts

@@ -75,23 +75,6 @@ export function resolveLeaderStalenessThresholdMs() {
   return 180_000;
 }
 
-export function resolveFallbackProgressStallThresholdMs() {
-  const raw = safeString(process.env.OMX_TEAM_PROGRESS_STALL_MS || '');
-  const parsed = asNumber(raw);
-  // Fallback-only threshold used when worker turn-count signals are unavailable.
-  // Default: 2 minutes. Guard against unreasonable values.
-  if (parsed !== null && parsed >= 10_000 && parsed <= 60 * 60_000) return parsed;
-  return 120_000;
-}
-
-export function resolveWorkerTurnStallThresholdMs() {
-  const raw = safeString(process.env.OMX_TEAM_WORKER_TURN_STALL_MS || '');
-  const parsed = asNumber(raw);
-  // Default: 30 seconds. Guard against unreasonable values.
-  if (parsed !== null && parsed >= 10_000 && parsed <= 10 * 60_000) return parsed;
-  return 30_000;
-}
-
 function buildStatusCheckReminder(teamName) {
   return `Next: check messages; keep orchestrating; if done, gracefully shut down: omx team shutdown ${teamName}.`;
 }
@@ -104,27 +87,6 @@ function buildWorkerStartEvidenceReminder(teamName, workerName) {
   return `Next: check ${workerName} msg/output, confirm task in omx team status ${teamName}, then reassign/nudge.`;
 }
 
-function classifyLeaderActionState({
-  allWorkersIdle = false,
-  workerPanesAlive = false,
-  taskCounts = {},
-  teamProgressStalled = false,
-} = {}) {
-  const pending = Number.isFinite(taskCounts.pending) ? taskCounts.pending : 0;
-  const blocked = Number.isFinite(taskCounts.blocked) ? taskCounts.blocked : 0;
-  const inProgress = Number.isFinite(taskCounts.in_progress) ? taskCounts.in_progress : 0;
-  const tasksComplete = pending === 0 && blocked === 0 && inProgress === 0;
-  const pendingFollowUpTasks = allWorkersIdle && pending > 0 && blocked === 0 && inProgress === 0;
-  const blockedWaitingOnLeader = allWorkersIdle && blocked > 0 && pending === 0 && inProgress === 0;
-  const terminalWaitingOnLeader = allWorkersIdle && tasksComplete && workerPanesAlive;
-  const stalledWaitingOnLeader = blockedWaitingOnLeader || teamProgressStalled;
-
-  if (terminalWaitingOnLeader) return 'done_waiting_on_leader';
-  if (stalledWaitingOnLeader) return 'stuck_waiting_on_leader';
-  if (pendingFollowUpTasks) return 'still_actionable';
-  return 'still_actionable';
-}
-
 function buildLeaderActionGuidance(teamName, {
   allWorkersIdle = false,
   workerPanesAlive = false,
@@ -588,8 +550,6 @@ export async function maybeNudgeTeamLeader({
 }) {
   const intervalMs = resolveLeaderNudgeIntervalMs();
   const idleCooldownMs = resolveLeaderAllIdleNudgeCooldownMs();
-  const fallbackProgressStallThresholdMs = resolveFallbackProgressStallThresholdMs();
-  const workerTurnStallThresholdMs = resolveWorkerTurnStallThresholdMs();
   const nowMs = Date.now();
   const nowIso = new Date().toISOString();
   const omxDir = join(cwd, '.omx');
@@ -715,7 +675,6 @@ export async function maybeNudgeTeamLeader({
     const previousProgressAtMs = previousProgressAtIso ? Date.parse(previousProgressAtIso) : NaN;
     const previousTurnCounts = readPreviousWorkerTurnCounts(previousSignature);
     const workerTurnProgress = hasWorkerTurnProgress(progressSnapshot.workerSnapshot, previousTurnCounts);
-    const hasTrackableTurnSignals = hasTrackableActiveWorkerTurns(progressSnapshot.workerSnapshot, previousTurnCounts);
     const progressChanged = !previousSignature || previousSignature !== progressSnapshot.signature || workerTurnProgress;
     const extraProgressEvidenceMs = await readLatestTeamProgressEvidenceMs(cwd, teamName).catch(() => Number.NaN);
     const effectiveProgressAtMs = progressChanged || !Number.isFinite(previousProgressAtMs)
@@ -725,22 +684,15 @@ export async function maybeNudgeTeamLeader({
       ? Math.max(effectiveProgressAtMs, extraProgressEvidenceMs)
       : effectiveProgressAtMs;
     const effectiveProgressAtIso = new Date(latestProgressEvidenceMs).toISOString();
-    const stalledForMs = Math.max(0, nowMs - latestProgressEvidenceMs);
-    const stallThresholdMs = hasTrackableTurnSignals ? workerTurnStallThresholdMs : fallbackProgressStallThresholdMs;
-    const teamProgressStalled =
-      progressSnapshot.workRemaining
-      && paneStatus.alive
-      && !allWorkersIdle
-      && !progressChanged
-      && stalledForMs >= stallThresholdMs;
     const hasFreshProgressEvidence =
       progressSnapshot.workRemaining
-      && stalledForMs < stallThresholdMs;
+      && (progressChanged
+        || (Number.isFinite(extraProgressEvidenceMs)
+          && (nowMs - extraProgressEvidenceMs) < resolveLeaderStalenessThresholdMs()));
     const leaderActionState = classifyLeaderActionState({
       allWorkersIdle,
       workerPanesAlive: paneStatus.alive,
       taskCounts: progressSnapshot.taskCounts,
-      teamProgressStalled,
     });
     const leaderActionGuidance = buildLeaderActionGuidance(teamName, {
       allWorkersIdle,
@@ -773,8 +725,6 @@ export async function maybeNudgeTeamLeader({
     // Stale-leader follow-up is the only periodic visible nudge path.
     // This keeps the leader pane quieter when the leader is not actually stale.
     const stalePanesNudge = paneStatus.alive && leaderStale && !hasFreshProgressEvidence;
-    const previousStalledTeamNudge = prevReason === 'stuck_waiting_on_leader';
-    const stalledTeamNudge = teamProgressStalled && (dueByTime || !previousStalledTeamNudge);
     const staleFollowupDue = stalePanesNudge && dueByTime;
     const hasActionableNewMessage = hasNewMessage && (allowFreshMailboxNudges || leaderStale);
 
@@ -800,12 +750,6 @@ export async function maybeNudgeTeamLeader({
         `Team ${teamName}: ${ackWithoutStartEvidence.worker} said "${ackWithoutStartEvidence.body}" `
         + `but has no start evidence (status: ${ackWithoutStartEvidence.statusState}). `
         + buildWorkerStartEvidenceReminder(teamName, ackWithoutStartEvidence.worker);
-    } else if (stalledTeamNudge) {
-      nudgeReason = 'stuck_waiting_on_leader';
-      const stallPrefix = leaderStale ? 'leader stale, ' : 'worker panes stalled, ';
-      text =
-        `Team ${teamName}: ${stallPrefix}no progress ${formatDurationMs(stalledForMs)}. `
-        + leaderActionGuidance;
     } else if (stalePanesNudge && hasActionableNewMessage) {
       nudgeReason = 'stale_leader_with_messages';
       text =
@@ -838,7 +782,7 @@ export async function maybeNudgeTeamLeader({
         + (progressSnapshot.taskCounts.blocked || 0)
         + (progressSnapshot.taskCounts.in_progress || 0),
       unread_leader_message_count: unreadLeaderMessageCount,
-      stalled_for_ms: teamProgressStalled ? stalledForMs : null,
+      stalled_for_ms: null,
       source: source === 'notify_fallback_watcher' ? 'notify_hook' : source,
     };
     await writeTeamLeaderAttention(teamName, {
@@ -855,7 +799,7 @@ export async function maybeNudgeTeamLeader({
       leader_session_stopped_at: null,
       unread_leader_message_count: unreadLeaderMessageCount,
       work_remaining: progressSnapshot.workRemaining,
-      stalled_for_ms: teamProgressStalled ? stalledForMs : null,
+      stalled_for_ms: null,
     }, cwd).catch(() => {});
 
     if (!nudgeReason) continue;
@@ -1001,7 +945,7 @@ export async function maybeNudgeTeamLeader({
           pane_count: paneStatus.paneCount,
           leader_stale: leaderStale,
           message_count: messages.length,
-          stalled_for_ms: teamProgressStalled ? stalledForMs : undefined,
+          stalled_for_ms: undefined,
           missing_signal_workers: progressSnapshot.missingSignalWorkers,
           visible_injection_suppressed: true,
           suppression_reason: LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON,
@@ -1059,7 +1003,7 @@ export async function maybeNudgeTeamLeader({
           pane_count: paneStatus.paneCount,
           leader_stale: leaderStale,
           message_count: messages.length,
-          stalled_for_ms: teamProgressStalled ? stalledForMs : undefined,
+          stalled_for_ms: undefined,
           missing_signal_workers: progressSnapshot.missingSignalWorkers,
         });
       } catch { /* ignore */ }