oh-my-codex 0.12.4 → 0.12.6

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

@@ -5,13 +5,15 @@
 
 import { readFile, writeFile, mkdir, appendFile, readdir } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
+import { readUsableSessionState } from '../../hooks/session.js';
 import { asNumber, safeString, isTerminalPhase } from './utils.js';
 import { readJsonIfExists, getScopedStateDirsForCurrentSession } from './state-io.js';
 import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
 import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
 import { resolvePaneTarget } from './tmux-injection.js';
+import { listNotifyCanonicalActiveTeams } from './active-team.js';
 import {
   classifyLeaderActionState,
   resolveLeaderNudgeIntent,
@@ -20,8 +22,10 @@ import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
 import { isLeaderRuntimeStale } from '../../team/leader-activity.js';
 import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
 import { writeTeamLeaderAttention } from '../../team/state.js';
+import { readLatestTeamProgressEvidenceMs } from '../../team/progress-evidence.js';
 const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
+const LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON = 'pane_already_shows_same_classified_state';
 const LEADER_NOTIFICATION_DEFERRED_TYPE = 'leader_notification_deferred';
 const ACK_WITHOUT_START_EVIDENCE_REASON = 'ack_without_start_evidence';
 const ACK_LIKE_PATTERNS = [
@@ -248,16 +252,7 @@ async function resolveCurrentSessionId(stateDir) {
     || '',
   ).trim();
   if (fromEnv) return fromEnv;
-
-  const sessionPath = join(stateDir, 'session.json');
-  try {
-    if (!existsSync(sessionPath)) return '';
-    const parsed = JSON.parse(await readFile(sessionPath, 'utf-8'));
-    const sessionId = safeString(parsed && parsed.session_id ? parsed.session_id : '').trim();
-    return sessionId;
-  } catch {
-    return '';
-  }
+  return safeString((await readUsableSessionState(resolve(stateDir, '..', '..')))?.session_id).trim();
 }
 
 async function readWorkerStatusSnapshot(stateDir, teamName, workerName) {
@@ -445,6 +440,27 @@ function formatMailboxBodyForLeader(body, maxLength = 40) {
   return `${normalized.slice(0, maxLength - 1)}…`;
 }
 
+function normalizeVisibleLeaderStateText(text) {
+  return safeString(text)
+    .toLowerCase()
+    .replace(/\[omx_tmux_inject\]/g, ' ')
+    .replace(/\[omx_intent:[^\]]+\]/g, ' ')
+    .replace(/said\s+"[^"]*"/g, 'said "<content>"')
+    .replace(/said\s+'[^']*'/g, 'said "<content>"')
+    .replace(/\b\d+[smhd](?:\s+\d+[smhd])*\b/g, '<duration>')
+    .replace(/\b\d+\b/g, '<n>')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function paneAlreadyShowsVisibleLeaderState(paneCapture, visibleText) {
+  const normalizedVisibleText = normalizeVisibleLeaderStateText(visibleText);
+  if (!normalizedVisibleText) return false;
+  const normalizedPaneCapture = normalizeVisibleLeaderStateText(paneCapture);
+  if (!normalizedPaneCapture) return false;
+  return normalizedPaneCapture.includes(normalizedVisibleText);
+}
+
 async function workerHasOwnedStartedTask(stateDir, teamName, workerName) {
   const tasksDir = join(stateDir, 'team', teamName, 'tasks');
   if (!existsSync(tasksDir)) return false;
@@ -601,6 +617,11 @@ export async function maybeNudgeTeamLeader({
     // Non-critical
   }
 
+  const canonicalFallbackTeams = await listNotifyCanonicalActiveTeams(cwd, currentSessionId).catch(() => []);
+  for (const team of canonicalFallbackTeams) {
+    candidateTeamNames.add(team.teamName);
+  }
+
   // Use pre-computed staleness (captured before HUD state was updated this turn)
   const leaderStale = typeof preComputedLeaderStale === 'boolean' ? preComputedLeaderStale : false;
 
@@ -676,11 +697,15 @@ export async function maybeNudgeTeamLeader({
     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)
       ? nowMs
       : previousProgressAtMs;
-    const effectiveProgressAtIso = new Date(effectiveProgressAtMs).toISOString();
-    const stalledForMs = Math.max(0, nowMs - effectiveProgressAtMs);
+    const latestProgressEvidenceMs = Number.isFinite(extraProgressEvidenceMs)
+      ? 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
@@ -688,6 +713,9 @@ export async function maybeNudgeTeamLeader({
       && !allWorkersIdle
       && !progressChanged
       && stalledForMs >= stallThresholdMs;
+    const hasFreshProgressEvidence =
+      progressSnapshot.workRemaining
+      && stalledForMs < stallThresholdMs;
     const leaderActionState = classifyLeaderActionState({
       allWorkersIdle,
       workerPanesAlive: paneStatus.alive,
@@ -724,7 +752,7 @@ 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;
+    const stalePanesNudge = paneStatus.alive && leaderStale && !hasFreshProgressEvidence;
     const previousStalledTeamNudge = prevReason === 'stuck_waiting_on_leader';
     const stalledTeamNudge = teamProgressStalled && (dueByTime || !previousStalledTeamNudge);
     const staleFollowupDue = stalePanesNudge && dueByTime;
@@ -925,6 +953,55 @@ export async function maybeNudgeTeamLeader({
       continue;
     }
 
+    if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, capped)) {
+      nudgeState.last_nudged_by_team[teamName] = {
+        at: nowIso,
+        last_message_id: newestId || prevMsgId || '',
+        reason: nudgeReason,
+        orchestration_intent: orchestrationIntent,
+      };
+      if (shouldSendAllIdleNudge) {
+        nudgeState.last_idle_nudged_by_team[teamName] = {
+          at: nowIso,
+          worker_count: workerNames.length,
+          orchestration_intent: orchestrationIntent,
+        };
+      }
+
+      await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
+
+      try {
+        await logTmuxHookEvent(logsDir, {
+          timestamp: nowIso,
+          type: 'team_leader_nudge',
+          team: teamName,
+          tmux_target: tmuxTarget,
+          reason: nudgeReason,
+          orchestration_intent: orchestrationIntent,
+          pane_count: paneStatus.paneCount,
+          leader_stale: leaderStale,
+          message_count: messages.length,
+          stalled_for_ms: teamProgressStalled ? stalledForMs : undefined,
+          missing_signal_workers: progressSnapshot.missingSignalWorkers,
+          visible_injection_suppressed: true,
+          suppression_reason: LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON,
+        });
+      } catch { /* ignore */ }
+      await appendTeamDeliveryLog(logsDir, {
+        event: 'nudge_triggered',
+        source,
+        team: teamName,
+        to_worker: 'leader-fixed',
+        transport: 'send-keys',
+        result: 'suppressed',
+        reason: nudgeReason,
+        orchestration_intent: orchestrationIntent,
+        visible_injection_suppressed: true,
+        suppression_reason: LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON,
+      }).catch(() => {});
+      continue;
+    }
+
     try {
       const sendResult = await sendPaneInput({
         paneTarget: tmuxTarget,

package/src/scripts/notify-hook/tmux-injection.ts

@@ -8,6 +8,7 @@ import { readFile, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { safeString, asNumber } from './utils.js';
+import { sameFilePath } from '../../utils/paths.js';
 import {
   readJsonIfExists,
   normalizeTmuxState,
@@ -35,7 +36,7 @@ async function resolvePaneCwdMismatch(paneId: string, expectedCwd: any): Promise
   try {
     const paneCwdResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_current_path}']);
     const paneCwd = safeString(paneCwdResult.stdout).trim();
-    if (paneCwd && resolvePath(paneCwd) !== resolvePath(expectedCwd)) {
+    if (paneCwd && !sameFilePath(paneCwd, expectedCwd)) {
       return {
         paneTarget: null,
         reason: 'pane_cwd_mismatch',
@@ -210,7 +211,15 @@ export async function resolvePaneTarget(target: any, expectedCwd: any, modePane:
     const expectedSessionTarget = safeString(managedContext.expectedTmuxSessionName).trim();
     const sessionIdTarget = safeString(managedContext.invocationSessionId).trim();
     const stateSessionTarget = safeString(managedContext.sessionState?.session_id).trim();
-    const allowedSessionTargets = new Set([expectedSessionTarget, sessionIdTarget, stateSessionTarget].filter(Boolean));
+    const nativeSessionTarget = safeString(managedContext.nativeSessionId).trim();
+    const canonicalSessionTarget = safeString(managedContext.canonicalSessionId).trim();
+    const allowedSessionTargets = new Set([
+      expectedSessionTarget,
+      sessionIdTarget,
+      stateSessionTarget,
+      nativeSessionTarget,
+      canonicalSessionTarget,
+    ].filter(Boolean));
     if (!allowedSessionTargets.has(explicitSessionTarget)) {
       return { paneTarget: null, reason: 'target_session_not_managed' };
     }

package/src/scripts/notify-hook.ts

@@ -20,7 +20,7 @@
 
 import { writeFile, appendFile, mkdir, readFile } from 'fs/promises';
 import { existsSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
 
 import { safeString, asNumber } from './notify-hook/utils.js';
 import {
@@ -29,7 +29,9 @@ import {
   normalizeInputMessages,
 } from './notify-hook/payload-parser.js';
 import {
-  readJsonIfExists,
+  getScopedStatePath,
+  readCurrentSessionId,
+  readScopedJsonIfExists,
   getScopedStateDirsForCurrentSession,
   normalizeNotifyState,
   pruneRecentTurns,
@@ -181,10 +183,12 @@ async function main() {
   const logsDir = join(cwd, '.omx', 'logs');
   const omxDir = join(cwd, '.omx');
   let currentOmxSessionId = '';
+  const getEffectiveSessionId = () => currentOmxSessionId || payloadSessionId;
 
   // Ensure directories exist
   await mkdir(logsDir, { recursive: true }).catch(() => {});
   await mkdir(stateDir, { recursive: true }).catch(() => {});
+  currentOmxSessionId = await readCurrentSessionId(stateDir).catch(() => '') || '';
 
   // Turn-level dedupe prevents double-processing when native notify and fallback
   // watcher both emit the same completed turn.
@@ -195,14 +199,18 @@ async function main() {
       const threadId = safeString(payload['thread-id'] || payload.thread_id || '');
       const eventType = safeString(payload.type || 'agent-turn-complete');
       const key = `${threadId || 'no-thread'}|${turnId}|${eventType}`;
-      const dedupeStatePath = join(stateDir, 'notify-hook-state.json');
-      const dedupeState = normalizeNotifyState(await readJsonIfExists(dedupeStatePath, null));
+      const dedupeSessionId = getEffectiveSessionId();
+      const dedupeStatePath = await getScopedStatePath(stateDir, 'notify-hook-state.json', dedupeSessionId);
+      const dedupeState = normalizeNotifyState(
+        await readScopedJsonIfExists(stateDir, 'notify-hook-state.json', dedupeSessionId, null),
+      );
       dedupeState.recent_turns = pruneRecentTurns(dedupeState.recent_turns, now);
       if (dedupeState.recent_turns[key]) {
         process.exit(0);
       }
       dedupeState.recent_turns[key] = now;
       dedupeState.last_event_at = new Date().toISOString();
+      await mkdir(dirname(dedupeStatePath), { recursive: true }).catch(() => {});
       await writeFile(dedupeStatePath, JSON.stringify(dedupeState, null, 2)).catch(() => {});
     }
   } catch {
@@ -214,10 +222,10 @@ async function main() {
     try {
       const threadId = safeString(payload['thread-id'] || payload.thread_id || '');
       const turnId = safeString(payload['turn-id'] || payload.turn_id || '');
-      if (payloadSessionId && threadId) {
+      if (getEffectiveSessionId() && threadId) {
         const { recordSubagentTurnForSession } = await import('../subagents/tracker.js');
         await recordSubagentTurnForSession(cwd, {
-          sessionId: payloadSessionId,
+          sessionId: getEffectiveSessionId(),
           threadId,
           ...(turnId ? { turnId } : {}),
           timestamp: new Date().toISOString(),
@@ -417,18 +425,20 @@ async function main() {
 
   // 4. Write HUD state summary for `omx hud` (lead session only)
   if (!isTeamWorker) {
-    const hudStatePath = join(stateDir, 'hud-state.json');
     try {
-      let hudState = { last_turn_at: '', turn_count: 0 };
-      if (existsSync(hudStatePath)) {
-        hudState = JSON.parse(await readFile(hudStatePath, 'utf-8'));
-      }
+      const scopedSessionId = getEffectiveSessionId();
+      const hudStatePath = await getScopedStatePath(stateDir, 'hud-state.json', scopedSessionId);
+      let hudState = await readScopedJsonIfExists(stateDir, 'hud-state.json', scopedSessionId, {
+        last_turn_at: '',
+        turn_count: 0,
+      });
       const nowIso = new Date().toISOString();
       hudState.last_turn_at = nowIso;
       (hudState as any).last_progress_at = nowIso;
       hudState.turn_count = (hudState.turn_count || 0) + 1;
       (hudState as any).last_agent_output = (payload['last-assistant-message'] || payload.last_assistant_message || '')
         .slice(0, 100);
+      await mkdir(dirname(hudStatePath), { recursive: true }).catch(() => {});
       await writeFile(hudStatePath, JSON.stringify(hudState, null, 2));
     } catch {
       // Non-critical
@@ -451,19 +461,19 @@ async function main() {
   try {
     const { recordSkillActivation } = await import('../hooks/keyword-detector.js');
     if (latestUserInput) {
-      await recordSkillActivation({
-        stateDir,
-        text: latestUserInput,
-        sessionId: payloadSessionId,
-        threadId: payloadThreadId,
-        turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
-      });
+        await recordSkillActivation({
+          stateDir,
+          text: latestUserInput,
+          sessionId: getEffectiveSessionId(),
+          threadId: payloadThreadId,
+          turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
+        });
     }
   } catch {
     // Non-fatal: keyword detector module may not be built yet
   }
 
-  const deepInterviewStateActive = await isDeepInterviewStateActive(stateDir);
+  const deepInterviewStateActive = await isDeepInterviewStateActive(stateDir, getEffectiveSessionId());
 
   // 4.55. Notify leader when individual worker transitions to idle (worker session only)
   if (isTeamWorker && parsedTeamWorker && !deepInterviewStateActive) {
@@ -515,7 +525,7 @@ async function main() {
   try {
     const { buildNativeHookEvent, buildDerivedHookEvent } = await import('../hooks/extensibility/events.js');
     const { dispatchHookEvent } = await import('../hooks/extensibility/dispatcher.js');
-    const sessionIdForHooks = safeString(payload.session_id || payload['session-id'] || '');
+    const sessionIdForHooks = getEffectiveSessionId();
     const threadIdForHooks = safeString(payload['thread-id'] || payload.thread_id || '');
     const turnIdForHooks = safeString(payload['turn-id'] || payload.turn_id || '');
     const modeForHooks = safeString(payload.mode || '');
@@ -525,6 +535,8 @@ async function main() {
       type: safeString(payload.type || 'agent-turn-complete'),
       input_messages: normalizeInputMessages(payload),
       output_preview: outputPreview,
+      native_session_id: payloadSessionId || null,
+      omx_session_id: sessionIdForHooks || null,
       ...readRepositoryMetadata(cwd),
       session_name: resolveOperationalSessionName(cwd, sessionIdForHooks),
       project_path: cwd,
@@ -546,6 +558,8 @@ async function main() {
         status: signal.normalized_event,
         errorSummary: signal.error_summary,
         extra: {
+          native_session_id: payloadSessionId || null,
+          omx_session_id: sessionIdForHooks || null,
           source_event: safeString(payload.type || 'agent-turn-complete'),
         },
       }), {
@@ -650,7 +664,7 @@ async function main() {
         payload,
         stateDir,
         logsDir,
-        sessionId: currentOmxSessionId || payloadSessionId,
+        sessionId: getEffectiveSessionId(),
         turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
       });
     } catch (err) {
@@ -660,7 +674,7 @@ async function main() {
         level: 'warn',
         type: 'visual_verdict_import_failure',
         error: (err as any)?.message || String(err),
-        session_id: payloadSessionId,
+        session_id: getEffectiveSessionId(),
         turn_id: safeString(payload['turn-id'] || payload.turn_id || ''),
       });
       const warnFile = join(logsDir, `notify-hook-${new Date().toISOString().split('T')[0]}.jsonl`);

package/src/scripts/run-provider-advisor.ts

@@ -3,12 +3,18 @@ import { mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';
 import process from 'process';
 import { spawnSync } from 'child_process';
+import { CLAUDE_SKIP_PERMISSIONS_FLAG } from '../cli/constants.js';
 
 const PROVIDER_BINARIES: Record<string, string> = {
   claude: 'claude',
   gemini: 'gemini',
 };
 const ASK_ORIGINAL_TASK_ENV = 'OMX_ASK_ORIGINAL_TASK';
+const ISSUE_WORK_PROMPT_PATTERNS = [
+  /\bgh\s+issue\b/i,
+  /\b(?:fix|work on|work|investigate|implement|triage|debug|review|handle)\s+issue\s*#?\d+\b/i,
+  /\bissue\s*#\d+\b/i,
+];
 
 function usage(): void {
   console.error('Usage: omx ask <claude|gemini> "<prompt>"');
@@ -70,6 +76,13 @@ function ensureBinary(binary: string): void {
   }
 }
 
+function shouldUseClaudeIssuePermissionsBypass(provider: string, prompt: string): boolean {
+  if (provider !== 'claude') return false;
+  const trimmed = prompt.trim();
+  if (trimmed === '') return false;
+  return ISSUE_WORK_PROMPT_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+
 function buildSummary(exitCode: number, output: string): string {
   if (exitCode === 0) {
     return 'Provider completed successfully. Review the raw output for details.';
@@ -148,10 +161,15 @@ async function writeArtifact({ provider, originalTask, finalPrompt, rawOutput, e
 async function main(): Promise<void> {
   const { provider, prompt } = parseArgs(process.argv.slice(2));
   const binary = PROVIDER_BINARIES[provider];
+  const originalTask = process.env[ASK_ORIGINAL_TASK_ENV] ?? prompt;
 
   ensureBinary(binary);
 
-  const run = spawnSync(binary, ['-p', prompt], {
+  const launchArgs = shouldUseClaudeIssuePermissionsBypass(provider, originalTask)
+    ? [CLAUDE_SKIP_PERMISSIONS_FLAG, '-p', prompt]
+    : ['-p', prompt];
+
+  const run = spawnSync(binary, launchArgs, {
     encoding: 'utf8',
     maxBuffer: 10 * 1024 * 1024,
       windowsHide: true,
@@ -164,7 +182,7 @@ async function main(): Promise<void> {
 
   const artifactPath = await writeArtifact({
     provider,
-    originalTask: process.env[ASK_ORIGINAL_TASK_ENV] ?? prompt,
+    originalTask,
     finalPrompt: prompt,
     rawOutput,
     exitCode,

package/src/scripts/smoke-packed-install.ts

@@ -1,22 +1,21 @@
 import {
-  existsSync,
-  lstatSync,
   mkdtempSync,
   rmSync,
-  symlinkSync,
 } from 'node:fs';
 import { mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
+import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
+import {
+  ensureReusableNodeModules,
+} from '../utils/repo-deps.js';
 
-const REQUIRED_NODE_MODULE_MARKERS = [
-  join('typescript', 'package.json'),
-  join('@iarna', 'toml', 'package.json'),
-  join('@modelcontextprotocol', 'sdk', 'package.json'),
-  join('zod', 'package.json'),
-];
+export {
+  hasUsableNodeModules,
+  resolveGitCommonDir,
+  resolveReusableNodeModulesSource,
+} from '../utils/repo-deps.js';
 
 export const PACKED_INSTALL_SMOKE_CORE_COMMANDS = [
   ['--help'],
@@ -32,41 +31,10 @@ function usage(): string {
   ].join('\n');
 }
 
-function hasNodeModulesPath(nodeModulesPath: string): boolean {
-  try {
-    lstatSync(nodeModulesPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function hasUsableNodeModules(repoRoot: string): boolean {
-  return REQUIRED_NODE_MODULE_MARKERS.every((marker) => existsSync(join(repoRoot, 'node_modules', marker)));
-}
-
-export function resolveGitCommonDir(cwd: string, gitRunner = spawnSync): string | null {
-  const result = gitRunner('git', ['rev-parse', '--git-common-dir'], {
-    cwd,
-    encoding: 'utf-8',
-  });
-  if (result.status !== 0) {
-    return null;
-  }
-  const value = (result.stdout || '').trim();
-  if (!value) {
-    return null;
-  }
-  return resolve(cwd, value);
-}
-
 interface EnsureRepoDepsOptions {
   gitRunner?: typeof spawnSync;
   install?: (cwd: string) => void;
-  remove?: typeof rmSync;
-  symlink?: typeof symlinkSync;
   log?: (message: string) => void;
-  platformName?: string;
 }
 
 interface EnsureRepoDepsResult {
@@ -75,24 +43,6 @@ interface EnsureRepoDepsResult {
   sourceNodeModulesPath?: string;
 }
 
-export function resolveReusableNodeModulesSource(repoRoot: string, gitRunner = spawnSync): string | null {
-  const commonDir = resolveGitCommonDir(repoRoot, gitRunner);
-  if (!commonDir || basename(commonDir) !== '.git') {
-    return null;
-  }
-
-  const primaryRepoRoot = dirname(commonDir);
-  if (resolve(primaryRepoRoot) === resolve(repoRoot)) {
-    return null;
-  }
-
-  if (!hasUsableNodeModules(primaryRepoRoot)) {
-    return null;
-  }
-
-  return join(primaryRepoRoot, 'node_modules');
-}
-
 function formatCommandFailure(cmd: string, args: string[], result: { stdout?: string; stderr?: string }): string {
   return [
     `Command failed: ${cmd} ${args.join(' ')}`,
@@ -114,40 +64,23 @@ export function ensureRepoDependencies(repoRoot: string, options: EnsureRepoDeps
         throw new Error(formatCommandFailure('npm', ['ci'], result));
       }
     },
-    remove = rmSync,
-    symlink = symlinkSync,
     log = () => {},
-    platformName = process.platform,
   } = options;
 
-  if (hasUsableNodeModules(repoRoot)) {
-    return {
-      strategy: 'existing',
-      nodeModulesPath: join(repoRoot, 'node_modules'),
-    };
+  const reusable = ensureReusableNodeModules(repoRoot, { gitRunner });
+  if (reusable.strategy === 'existing') {
+    return reusable;
   }
-
-  const targetNodeModules = join(repoRoot, 'node_modules');
-  if (hasNodeModulesPath(targetNodeModules)) {
-    remove(targetNodeModules, { recursive: true, force: true });
-  }
-
-  const reusableNodeModules = resolveReusableNodeModulesSource(repoRoot, gitRunner);
-  if (reusableNodeModules) {
-    symlink(reusableNodeModules, targetNodeModules, platformName === 'win32' ? 'junction' : 'dir');
-    log(`[smoke:packed-install] Reusing node_modules from ${reusableNodeModules}`);
-    return {
-      strategy: 'symlink',
-      nodeModulesPath: targetNodeModules,
-      sourceNodeModulesPath: reusableNodeModules,
-    };
+  if (reusable.strategy === 'symlink') {
+    log(`[smoke:packed-install] Reusing node_modules from ${reusable.sourceNodeModulesPath}`);
+    return reusable;
   }
 
   log('[smoke:packed-install] Installing repo dependencies with npm ci');
   install(repoRoot);
   return {
     strategy: 'installed',
-    nodeModulesPath: targetNodeModules,
+    nodeModulesPath: join(repoRoot, 'node_modules'),
   };
 }
 

package/templates/AGENTS.md

@@ -168,7 +168,7 @@ Rules:
 <invocation_conventions>
 - `$name` — invoke a workflow skill
 - `/skills` — browse available skills
-- `/prompts:name` — advanced specialist role surface when the task already needs a specific agent
+- Prefer skill invocation and keyword routing as the primary user-facing workflow surface
 </invocation_conventions>
 
 <model_routing>
@@ -191,7 +191,7 @@ Key roles:
 - `executor` — implementation and refactoring
 - `verifier` — completion evidence and validation
 
-Specialists remain available through advanced role surfaces such as `/prompts:*` when the task clearly benefits from them.
+Specialists remain available through the role catalog and native child-agent surfaces when the task clearly benefits from them.
 </agent_catalog>
 
 ---
@@ -208,7 +208,7 @@ The `deep-interview` skill is the Socratic deep interview workflow and includes
 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.
+- 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`, or native subagents) unless the user explicitly wants you to launch OMX from the shell.
 
 | Keyword(s) | Skill | Action |
 |-------------|-------|--------|
@@ -234,7 +234,6 @@ Detection rules:
 - 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.
 
 Ralph / Ralplan execution gate: