oh-my-codex 0.11.13 → 0.12.0

package/src/scripts/notify-hook/team-worker.ts

@@ -3,14 +3,19 @@
  * Team worker: heartbeat, idle detection, and leader notification.
  */
 
-import { readFile, writeFile, mkdir, appendFile, rename, stat } from 'fs/promises';
+import { readFile, writeFile, mkdir, appendFile, rename, stat, readdir } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { asNumber, safeString, isTerminalPhase } from './utils.js';
 import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
-import { checkPaneReadyForTeamSendKeys, sendPaneInput } from './team-tmux-guard.js';
+import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
 import { resolvePaneTarget } from './tmux-injection.js';
+import {
+  classifyLeaderActionState,
+  resolveAllWorkersIdleIntent,
+  resolveWorkerIdleIntent,
+} from './orchestration-intent.js';
 import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
 
@@ -258,6 +263,31 @@ export async function readTeamWorkersForIdleCheck(stateDir, teamName) {
   }
 }
 
+async function readTeamTaskCounts(stateDir, teamName) {
+  const tasksDir = join(stateDir, 'team', teamName, 'tasks');
+  const taskCounts = { pending: 0, blocked: 0, in_progress: 0, completed: 0, failed: 0 };
+  if (!existsSync(tasksDir)) return taskCounts;
+
+  try {
+    const taskFiles = (await readdir(tasksDir))
+      .filter((entry) => /^task-\d+\.json$/.test(entry))
+      .sort();
+    for (const entry of taskFiles) {
+      try {
+        const parsed = JSON.parse(await readFile(join(tasksDir, entry), 'utf-8'));
+        const status = safeString(parsed?.status || 'pending').trim() || 'pending';
+        if (Object.hasOwn(taskCounts, status)) taskCounts[status] += 1;
+      } catch {
+        // ignore malformed task files
+      }
+    }
+  } catch {
+    return taskCounts;
+  }
+
+  return taskCounts;
+}
+
 async function resolveCanonicalLeaderPaneId(_tmuxSession, leaderPaneId) {
   const normalizedLeaderPaneId = safeString(leaderPaneId).trim();
   if (normalizedLeaderPaneId) {
@@ -273,6 +303,18 @@ async function resolveCanonicalLeaderPaneId(_tmuxSession, leaderPaneId) {
   return '';
 }
 
+async function checkLeaderPaneReadyForWorkerStateReminder(paneTarget) {
+  return evaluatePaneInjectionReadiness(paneTarget, {
+    skipIfScrolling: true,
+    // Worker-state reminders are their own trigger path. They should still
+    // queue into a live Codex pane even while the leader is busy or not
+    // visibly input-ready; only shell/copy-mode style safety guards remain.
+    requireRunningAgent: true,
+    requireReady: false,
+    requireIdle: false,
+  });
+}
+
 async function emitLeaderPaneMissingDeferred({
   stateDir,
   logsDir,
@@ -283,6 +325,7 @@ async function emitLeaderPaneMissingDeferred({
   reason = 'leader_pane_missing_no_injection',
   paneCurrentCommand = '',
   sourceType = 'unknown',
+  orchestrationIntent = '',
 }) {
   const nowIso = new Date().toISOString();
   await logTmuxHookEvent(logsDir, {
@@ -294,6 +337,7 @@ async function emitLeaderPaneMissingDeferred({
     reason,
     leader_pane_id: leaderPaneId || null,
     tmux_session: tmuxSession || null,
+    orchestration_intent: orchestrationIntent || null,
     tmux_injection_attempted: false,
     pane_current_command: paneCurrentCommand || null,
     source_type: sourceType,
@@ -312,6 +356,7 @@ async function emitLeaderPaneMissingDeferred({
     created_at: nowIso,
     leader_pane_id: leaderPaneId || null,
     tmux_session: tmuxSession || null,
+    orchestration_intent: orchestrationIntent || null,
     tmux_injection_attempted: false,
     pane_current_command: paneCurrentCommand || null,
     source_type: sourceType,
@@ -381,12 +426,21 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   );
   if (!allIdle) return;
 
+  const taskCounts = await readTeamTaskCounts(stateDir, teamName);
+  const leaderActionState = classifyLeaderActionState({
+    allWorkersIdle: allIdle,
+    workerPanesAlive: snapshots.length > 0,
+    taskCounts,
+  });
+  const orchestrationIntent = resolveAllWorkersIdleIntent(leaderActionState);
+
   if (!canonicalLeaderPaneId) {
     const nextIdleState = {
       ...idleState,
       last_notified_at_ms: nowMs,
       last_notified_at: nowIso,
       worker_count: workers.length,
+      orchestration_intent: orchestrationIntent,
       delivery: 'deferred',
     };
     await writeFile(idleStatePath, JSON.stringify(nextIdleState, null, 2)).catch(() => {});
@@ -398,6 +452,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       sourceType: 'all_workers_idle',
       tmuxSession,
       leaderPaneId: canonicalLeaderPaneId,
+      orchestrationIntent,
     });
     return;
   }
@@ -406,13 +461,14 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
   const nextAction = `Next: run omx team status ${teamName}, read unread worker messages, then decide whether to assign the next concrete task, reconcile results, or shut the team down.`;
   const message = `[OMX] All ${N} worker${N === 1 ? '' : 's'} idle. ${nextAction} ${DEFAULT_MARKER}`;
   const tmuxTarget = canonicalLeaderPaneId;
-  const paneGuard = await checkPaneReadyForTeamSendKeys(tmuxTarget);
+  const paneGuard = await checkLeaderPaneReadyForWorkerStateReminder(tmuxTarget);
   if (!paneGuard.ok) {
     const nextIdleState = {
       ...idleState,
       last_notified_at_ms: nowMs,
       last_notified_at: nowIso,
       worker_count: N,
+      orchestration_intent: orchestrationIntent,
       delivery: 'deferred_shell',
       pane_current_command: paneGuard.paneCurrentCommand || null,
     };
@@ -427,6 +483,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       sourceType: 'all_workers_idle',
       tmuxSession,
       leaderPaneId: canonicalLeaderPaneId,
+      orchestrationIntent,
     });
     return;
   }
@@ -445,6 +502,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       last_notified_at_ms: nowMs,
       last_notified_at: nowIso,
       worker_count: N,
+      orchestration_intent: orchestrationIntent,
     };
     await writeFile(idleStatePath, JSON.stringify(nextIdleState, null, 2)).catch(() => {});
 
@@ -458,6 +516,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
         type: 'all_workers_idle',
         worker: workerName,
         worker_count: N,
+        orchestration_intent: orchestrationIntent,
         created_at: nowIso,
       };
       await appendFile(eventsPath, JSON.stringify(event) + '\n');
@@ -470,6 +529,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       tmux_target: tmuxTarget,
       worker: workerName,
       worker_count: N,
+      orchestration_intent: orchestrationIntent,
     });
   } catch (err) {
     await logTmuxHookEvent(logsDir, {
@@ -478,6 +538,7 @@ export async function maybeNotifyLeaderAllWorkersIdle({ cwd, stateDir, logsDir,
       team: teamName,
       tmux_target: tmuxTarget,
       worker: workerName,
+      orchestration_intent: orchestrationIntent,
       error: err instanceof Error ? err.message : safeString(err),
     }).catch(() => {});
   }
@@ -545,6 +606,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
   if (currentState !== 'idle' && currentState !== 'done') return;
   if (!statusFresh) return;
   if (prevState === 'idle' || prevState === 'done') return;
+  const orchestrationIntent = resolveWorkerIdleIntent(currentState);
 
   const heartbeat = await readWorkerHeartbeatSnapshot(stateDir, teamName, workerName, nowMs);
   if (!heartbeat.fresh) return;
@@ -576,11 +638,12 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       sourceType: 'worker_idle',
       tmuxSession,
       leaderPaneId: canonicalLeaderPaneId,
+      orchestrationIntent,
     });
     return;
   }
   const tmuxTarget = canonicalLeaderPaneId;
-  const paneGuard = await checkPaneReadyForTeamSendKeys(tmuxTarget);
+  const paneGuard = await checkLeaderPaneReadyForWorkerStateReminder(tmuxTarget);
   if (!paneGuard.ok) {
     try {
       const tmpPath = cooldownPath + '.tmp.' + process.pid;
@@ -588,6 +651,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
         last_notified_at_ms: nowMs,
         last_notified_at: nowIso,
         prev_state: prevState,
+        orchestration_intent: orchestrationIntent,
         delivery: 'deferred_shell',
         pane_current_command: paneGuard.paneCurrentCommand || null,
       }, null, 2));
@@ -603,6 +667,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       sourceType: 'worker_idle',
       tmuxSession,
       leaderPaneId: canonicalLeaderPaneId,
+      orchestrationIntent,
     });
     return;
   }
@@ -631,6 +696,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
         last_notified_at_ms: nowMs,
         last_notified_at: nowIso,
         prev_state: prevState,
+        orchestration_intent: orchestrationIntent,
       }, null, 2));
       await rename(tmpPath, cooldownPath);
     } catch { /* best effort */ }
@@ -648,6 +714,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
         prev_state: prevState,
         task_id: currentTaskId || null,
         reason: currentReason || null,
+        orchestration_intent: orchestrationIntent,
         created_at: nowIso,
       };
       await appendFile(eventsPath, JSON.stringify(event) + '\n');
@@ -661,6 +728,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       worker: workerName,
       prev_state: prevState,
       task_id: currentTaskId || null,
+      orchestration_intent: orchestrationIntent,
     });
   } catch (err) {
     await logTmuxHookEvent(logsDir, {
@@ -669,6 +737,7 @@ export async function maybeNotifyLeaderWorkerIdle({ cwd, stateDir, logsDir, pars
       team: teamName,
       tmux_target: tmuxTarget,
       worker: workerName,
+      orchestration_intent: orchestrationIntent,
       error: err instanceof Error ? err.message : safeString(err),
     }).catch(() => {});
   }

package/src/scripts/notify-hook/utils.ts

@@ -26,6 +26,6 @@ export function clampPct(value: any): number | null {
   return Math.round(value);
 }
 
-export function isTerminalPhase(phase: any): boolean {
+export function isTerminalPhase(phase: string): boolean {
   return phase === 'complete' || phase === 'failed' || phase === 'cancelled';
 }

package/src/scripts/notify-hook.ts

@@ -145,6 +145,11 @@ function buildIdleNotificationFingerprint(payload: Record<string, unknown>): str
   });
 }
 
+function isTurnCompletePayload(payload: Record<string, unknown>): boolean {
+  const type = safeString(payload.type || '').trim().toLowerCase();
+  return type === '' || type === 'agent-turn-complete' || type === 'turn-complete';
+}
+
 async function main() {
   const rawPayload = process.argv[process.argv.length - 1];
   if (!rawPayload || rawPayload.startsWith('-')) {
@@ -163,6 +168,7 @@ async function main() {
   const payloadThreadId = safeString(payload['thread-id'] || payload.thread_id || '');
   const inputMessages = normalizeInputMessages(payload);
   const latestUserInput = safeString(inputMessages.length > 0 ? inputMessages[inputMessages.length - 1] : '');
+  const isTurnComplete = isTurnCompletePayload(payload);
 
   // Team worker detection via environment variable
   const teamWorkerEnv = process.env.OMX_TEAM_WORKER; // e.g., "fix-ts/worker-1"
@@ -239,6 +245,10 @@ async function main() {
   const logFile = join(logsDir, `turns-${new Date().toISOString().split('T')[0]}.jsonl`);
   await appendFile(logFile, JSON.stringify(logEntry) + '\n').catch(() => {});
 
+  if (!isTurnComplete) {
+    return;
+  }
+
   // Reconcile Ralph ownership for same-Codex-session continuation before
   // lifecycle counters or injection read the active scope.
   if (!isTeamWorker) {
@@ -556,7 +566,12 @@ async function main() {
   if (!isTeamWorker) {
     try {
       const { notifyLifecycle } = await import('../notifications/index.js');
-      const { shouldSendIdleNotification, recordIdleNotificationSent } = await import('../notifications/idle-cooldown.js');
+      const {
+        shouldSendIdleNotification,
+        recordIdleNotificationSent,
+        shouldSendSessionIdleHookEvent,
+        recordSessionIdleHookEventSent,
+      } = await import('../notifications/idle-cooldown.js');
       const sessionJsonPath = join(stateDir, 'session.json');
       const idleFingerprint = buildIdleNotificationFingerprint(payload);
       let notifySessionId = '';
@@ -565,37 +580,50 @@ async function main() {
         notifySessionId = safeString(sessionData && sessionData.session_id ? sessionData.session_id : '');
       } catch { /* no session file */ }
 
-      if (notifySessionId && shouldSendIdleNotification(stateDir, notifySessionId, idleFingerprint)) {
-        const idleResult = await notifyLifecycle('session-idle', {
-          sessionId: notifySessionId,
-          projectPath: cwd,
-        });
-        if (idleResult && idleResult.anySuccess) {
-          recordIdleNotificationSent(stateDir, notifySessionId, idleFingerprint);
-        }
-        try {
-          const { buildNativeHookEvent } = await import('../hooks/extensibility/events.js');
-          const { dispatchHookEvent } = await import('../hooks/extensibility/dispatcher.js');
-          const event = buildNativeHookEvent('session-idle', {
-            ...buildOperationalContext({
-              cwd,
-              normalizedEvent: 'blocked',
-              sessionId: notifySessionId,
-              status: 'blocked',
-              extra: {
-                project_path: cwd,
-                reason: 'post_turn_idle_notification',
-              },
-            }),
-          }, {
-            session_id: notifySessionId,
-            thread_id: safeString(payload['thread-id'] || payload.thread_id || ''),
-            turn_id: safeString(payload['turn-id'] || payload.turn_id || ''),
-            mode: safeString(payload.mode || ''),
+      const shouldNotifyLifecycle = notifySessionId
+        && shouldSendIdleNotification(stateDir, notifySessionId, idleFingerprint);
+      const shouldDispatchSessionIdleHookEvent = notifySessionId
+        && shouldSendSessionIdleHookEvent(stateDir, notifySessionId, idleFingerprint);
+
+      if (shouldNotifyLifecycle || shouldDispatchSessionIdleHookEvent) {
+        if (shouldNotifyLifecycle) {
+          const idleResult = await notifyLifecycle('session-idle', {
+            sessionId: notifySessionId,
+            projectPath: cwd,
           });
-          await dispatchHookEvent(event, { cwd });
-        } catch {
-          // Non-fatal
+          if (idleResult && idleResult.anySuccess) {
+            recordIdleNotificationSent(stateDir, notifySessionId, idleFingerprint);
+          }
+        }
+
+        if (shouldDispatchSessionIdleHookEvent) {
+          try {
+            const { buildNativeHookEvent } = await import('../hooks/extensibility/events.js');
+            const { dispatchHookEvent } = await import('../hooks/extensibility/dispatcher.js');
+            const event = buildNativeHookEvent('session-idle', {
+              ...buildOperationalContext({
+                cwd,
+                normalizedEvent: 'blocked',
+                sessionId: notifySessionId,
+                status: 'blocked',
+                extra: {
+                  project_path: cwd,
+                  reason: 'post_turn_idle_notification',
+                },
+              }),
+            }, {
+              session_id: notifySessionId,
+              thread_id: safeString(payload['thread-id'] || payload.thread_id || ''),
+              turn_id: safeString(payload['turn-id'] || payload.turn_id || ''),
+              mode: safeString(payload.mode || ''),
+            });
+            const hookDispatchResult = await dispatchHookEvent(event, { cwd });
+            if (hookDispatchResult.results.some((result) => result.ok)) {
+              recordSessionIdleHookEventSent(stateDir, notifySessionId, idleFingerprint);
+            }
+          } catch {
+            // Non-fatal
+          }
         }
       }
     } catch {
@@ -685,4 +713,8 @@ async function main() {
   }
 }
 
-main().catch(() => process.exit(0));
+main().catch((err) => {
+  process.exitCode = 1;
+  // eslint-disable-next-line no-console
+  console.error('[notify-hook] fatal error:', err);
+});

package/templates/AGENTS.md

@@ -36,10 +36,12 @@ Keep runtime marker contracts stable and non-destructive when overlays are appli
 - Check official documentation before implementing with unfamiliar SDKs, frameworks, or APIs.
 - Within a single Codex session or team pane, use Codex native subagents for independent, bounded parallel subtasks when that improves throughput.
 <!-- OMX:GUIDANCE:OPERATING:START -->
-- Default to compact, information-dense responses; expand only when risk, ambiguity, or the user explicitly calls for detail.
+- Default to quality-first, intent-deepening responses; think one more step before replying or asking for clarification, and use as much detail as needed for a strong result without empty verbosity.
 - Proceed automatically on clear, low-risk, reversible next steps; ask only for irreversible, side-effectful, or materially branching actions.
 - Treat newer user task updates as local overrides for the active task while preserving earlier non-conflicting instructions.
+- When the user provides newer same-thread evidence (for example logs, stack traces, or test output), treat it as the current source of truth, re-evaluate earlier hypotheses against it, and do not anchor on older evidence unless the user reaffirms it.
 - Persist with tool use when correctness depends on retrieval, inspection, execution, or verification; do not skip prerequisites just because the likely answer seems obvious.
+- More effort does not mean reflexive web/tool escalation; browse or use tools when the task materially benefits, not as a default show of effort.
 <!-- OMX:GUIDANCE:OPERATING:END -->
 </operating_principles>
 
@@ -203,19 +205,26 @@ The `deep-interview` skill is the Socratic deep interview workflow and includes
 
 | Keyword(s) | Skill | Action |
 |-------------|-------|--------|
-| "ralph", "don't stop", "must complete", "keep going" | `$ralph` | Read `~/.codex/skills/ralph/SKILL.md`, execute persistence loop |
-| "autopilot", "build me", "I want a" | `$autopilot` | Read `~/.codex/skills/autopilot/SKILL.md`, execute autonomous pipeline |
-| "ultrawork", "ulw", "parallel" | `$ultrawork` | Read `~/.codex/skills/ultrawork/SKILL.md`, execute parallel agents |
-| "ultraqa" | `$ultraqa` | Read `~/.codex/skills/ultraqa/SKILL.md`, run QA cycling workflow |
-| "analyze", "investigate" | `$analyze` | Read `~/.codex/skills/analyze/SKILL.md`, run deep analysis |
+Runtime availability gate:
+- Treat `autopilot`, `ralph`, `ultrawork`, `ultraqa`, `team`/`swarm`, and `ecomode` as **OMX runtime workflows**, not generic prompt aliases.
+- Auto-activate those runtime workflows only when the current session is actually running under OMX CLI/runtime (for example, launched via `omx`, with OMX session overlay/runtime state available, or when the user explicitly asks to run `omx ...` in the shell).
+- In Codex App or plain Codex sessions without OMX runtime, do **not** treat those keywords alone as activation. Explain that they require OMX CLI runtime support, and continue with the nearest App-safe surface (`deep-interview`, `ralplan`, `plan`, `/prompts:*`, or native subagents) unless the user explicitly wants you to launch OMX from the shell.
+
+| Keyword(s) | Skill | Action |
+|-------------|-------|--------|
+| "ralph", "don't stop", "must complete", "keep going" | `$ralph` | Runtime-only: read `~/.codex/skills/ralph/SKILL.md`, execute persistence loop only inside OMX CLI/runtime |
+| "autopilot", "build me", "I want a" | `$autopilot` | Runtime-only: read `~/.codex/skills/autopilot/SKILL.md`, execute autonomous pipeline only inside OMX CLI/runtime |
+| "ultrawork", "ulw", "parallel" | `$ultrawork` | Runtime-only: read `~/.codex/skills/ultrawork/SKILL.md`, execute parallel agents only inside OMX CLI/runtime |
+| "ultraqa" | `$ultraqa` | Runtime-only: read `~/.codex/skills/ralph/SKILL.md`, run persistent completion and verification loop only inside OMX CLI/runtime (UltraQA compatibility alias) |
+| "analyze", "investigate" | `$analyze` | Read `~/.codex/prompts/debugger.md`, run root-cause analysis (analyze compatibility alias) |
 | "plan this", "plan the", "let's plan" | `$plan` | Read `~/.codex/skills/plan/SKILL.md`, start planning workflow |
 | "interview", "deep interview", "gather requirements", "interview me", "don't assume", "ouroboros" | `$deep-interview` | Read `~/.codex/skills/deep-interview/SKILL.md`, run Ouroboros-inspired Socratic ambiguity-gated interview workflow |
 | "ralplan", "consensus plan" | `$ralplan` | Read `~/.codex/skills/ralplan/SKILL.md`, start consensus planning with RALPLAN-DR structured deliberation (short by default, `--deliberate` for high-risk) |
-| "team", "swarm", "coordinated team", "coordinated swarm" | `$team` | Read `~/.codex/skills/team/SKILL.md`, start team orchestration (swarm compatibility alias) |
-| "ecomode", "eco", "budget" | `$ecomode` | Read `~/.codex/skills/ecomode/SKILL.md`, enable token-efficient mode |
+| "team", "swarm", "coordinated team", "coordinated swarm" | `$team` | Runtime-only: read `~/.codex/skills/team/SKILL.md`, start tmux-based team orchestration only inside OMX CLI/runtime (swarm compatibility alias) |
+| "ecomode", "eco", "budget" | `$ecomode` | Runtime-only: read `~/.codex/skills/ultrawork/SKILL.md`, execute cost-aware parallel workflow only inside OMX CLI/runtime (ecomode compatibility alias) |
 | "cancel", "stop", "abort" | `$cancel` | Read `~/.codex/skills/cancel/SKILL.md`, cancel active modes |
-| "tdd", "test first" | `$tdd` | Read `~/.codex/skills/tdd/SKILL.md`, start test-driven workflow |
-| "fix build", "type errors" | `$build-fix` | Read `~/.codex/skills/build-fix/SKILL.md`, fix build errors |
+| "tdd", "test first" | `$tdd` | Read `~/.codex/prompts/test-engineer.md`, run test-first workflow (tdd compatibility alias) |
+| "fix build", "type errors" | `$build-fix` | Read `~/.codex/prompts/build-fixer.md`, fix build errors with minimal diff (build-fix compatibility alias) |
 | "review code", "code review", "code-review" | `$code-review` | Read `~/.codex/skills/code-review/SKILL.md`, run code review |
 | "security review" | `$security-review` | Read `~/.codex/skills/security-review/SKILL.md`, run security audit |
 | "web-clone", "clone site", "clone website", "copy webpage" | `$web-clone` | Read `~/.codex/skills/web-clone/SKILL.md`, start website cloning pipeline |
@@ -224,6 +233,7 @@ Detection rules:
 - Keywords are case-insensitive and match anywhere in the user message.
 - Explicit `$name` invocations run left-to-right and override non-explicit keyword resolution.
 - If multiple non-explicit keywords match, use the most specific match.
+- Runtime-only keywords must pass the runtime availability gate before activation.
 - If the user explicitly invokes `/prompts:<name>`, do not auto-activate keyword skills unless explicit `$name` tokens are also present.
 - The rest of the user message becomes the task description.
 
@@ -286,7 +296,7 @@ Sizing guidance:
 - Large or security/architectural changes: thorough verification
 
 <!-- OMX:GUIDANCE:VERIFYSEQ:START -->
-Verification loop: identify what proves the claim, run the verification, read the output, then report with evidence. If verification fails, continue iterating rather than reporting incomplete work. Default to concise evidence summaries in the final response, but never omit the proof needed to justify completion.
+Verification loop: identify what proves the claim, run the verification, read the output, then report with evidence. If verification fails, continue iterating rather than reporting incomplete work. Default to quality-first evidence summaries: think one more step before declaring completion, and include enough detail to make the proof actionable without padding.
 
 - Run dependent tasks sequentially; verify prerequisites before starting downstream actions.
 - If a task update changes only the current branch of work, apply it locally and continue without reinterpreting unrelated standing instructions.