oh-my-codex 0.16.4 → 0.17.1

package/src/scripts/codex-native-hook.ts

@@ -33,7 +33,7 @@ import {
   writeTeamLeaderAttention,
   writeTeamPhase,
 } from "../team/state.js";
-import { omxNotepadPath, omxProjectMemoryPath } from "../utils/paths.js";
+import { omxNotepadPath, resolveProjectMemoryPath } from "../utils/paths.js";
 import { findGitLayout } from "../utils/git-layout.js";
 import { getBaseStateDir, getStateFilePath, getStatePath } from "../mcp/state-paths.js";
 import {
@@ -127,6 +127,9 @@ const SKILL_STOP_BLOCKERS = new Set(["ralplan"]);
 const TEAM_STOP_BLOCKING_TASK_STATUSES = new Set(["pending", "in_progress", "blocked"]);
 const TEAM_WORKER_TERMINAL_RUN_STATES = new Set(["done", "complete", "completed", "failed", "stopped", "cancelled"]);
 const NATIVE_STOP_STATE_FILE = "native-stop-state.json";
+const ORDINARY_STOP_NO_PROGRESS_DEFAULT_MAX_REPEATS = 8;
+const ORDINARY_STOP_NO_PROGRESS_DEFAULT_IDLE_MS = 10 * 60_000;
+const ORDINARY_STOP_NO_PROGRESS_MAX_MESSAGE_LENGTH = 240;
 const STABLE_FINAL_RECOMMENDATION_PATTERNS = [
   /^\s*(?:launch|release|ship)-?ready\s*:\s*(?:yes|no)\b[^\n\r]*/im,
   /^\s*ready to release\s*:\s*(?:yes|no)\b[^\n\r]*/im,
@@ -157,6 +160,12 @@ function safeObject(value: unknown): Record<string, unknown> {
   return value && typeof value === "object" ? value as Record<string, unknown> : {};
 }
 
+function safeContextSnippet(value: unknown, maxLength = 300): string {
+  const text = safeString(value).replace(/\s+/g, " ").trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}
+
 interface NativeSubagentSessionStartMetadata {
   parentThreadId: string;
   agentNickname?: string;
@@ -1122,28 +1131,31 @@ async function buildSessionStartContext(
     sections.push(["[Active OMX modes]", ...modeSummaries].join("\n"));
   }
 
-  const projectMemory = await readJsonIfExists(omxProjectMemoryPath(cwd));
-  if (projectMemory) {
+  const projectMemoryPath = resolveProjectMemoryPath(cwd);
+  const projectMemory = projectMemoryPath ? await readJsonIfExists(projectMemoryPath) : null;
+  if (projectMemory && projectMemoryPath) {
     const directives = Array.isArray(projectMemory.directives) ? projectMemory.directives : [];
     const notes = Array.isArray(projectMemory.notes) ? projectMemory.notes : [];
-    const techStack = safeString(projectMemory.techStack).trim();
-    const conventions = safeString(projectMemory.conventions).trim();
-    const build = safeString(projectMemory.build).trim();
+    const techStack = safeContextSnippet(projectMemory.techStack);
+    const conventions = safeContextSnippet(projectMemory.conventions);
+    const build = safeContextSnippet(projectMemory.build);
     const summary: string[] = [];
+    const relativeMemoryPath = relative(cwd, projectMemoryPath).replace(/\\/g, "/");
+    summary.push(`- source: ${relativeMemoryPath === "project-memory.json" ? "project-memory.json" : ".omx/project-memory.json"}`);
     if (techStack) summary.push(`- stack: ${techStack}`);
     if (conventions) summary.push(`- conventions: ${conventions}`);
     if (build) summary.push(`- build: ${build}`);
     if (directives.length > 0) {
       const firstDirective = directives[0] as Record<string, unknown>;
-      const directive = safeString(firstDirective.directive).trim();
+      const directive = safeContextSnippet(firstDirective.directive);
       if (directive) summary.push(`- directive: ${directive}`);
     }
     if (notes.length > 0) {
       const firstNote = notes[0] as Record<string, unknown>;
-      const note = safeString(firstNote.content).trim();
+      const note = safeContextSnippet(firstNote.content);
       if (note) summary.push(`- note: ${note}`);
     }
-    if (summary.length > 0) {
+    if (summary.length > 1) {
       sections.push(["[Project memory]", ...summary].join("\n"));
     }
   }
@@ -1695,20 +1707,33 @@ async function buildModeBasedStopOutput(
   };
 }
 
-function looksLikeGoalCompletionPrompt(text: string): boolean {
-  return /\b(?:complete|checkpoint|finish|close|mark)\b.{0,80}\b(?:goal|ultragoal|performance-goal|autoresearch-goal)\b/i.test(text)
-    || /\bupdate_goal\s*\(/i.test(text)
-    || /\bomx\s+(?:ultragoal|performance-goal|autoresearch-goal)\s+(?:checkpoint|complete)\b/i.test(text);
+export function looksLikeGoalCompletionPrompt(text: string): boolean {
+  return /\bupdate_goal\s*\(/i.test(text)
+    || /\bomx\s+(?:ultragoal|performance-goal|autoresearch-goal)\s+(?:checkpoint|complete)\b/i.test(text)
+    || /\b(?:complete|checkpoint|finish|close|mark)\b.{0,80}\b(?:goal|ultragoal|performance[-\s]goal|autoresearch[-\s]goal)\b/i.test(text)
+    || /\b(?:ultragoal|performance[-\s]goal|autoresearch[-\s]goal)\b.{0,80}\b(?:complete|checkpoint|finish|close|mark)\b/i.test(text)
+    || /(?:^|[.!?]\s+)(?:the\s+)?goal\s+(?:is\s+|now\s+|has\s+been\s+)?(?:complete|completed|finished|closed)(?:\s*(?:[.!?]|$)|\s*[:;]\s*\S|\s*[—–-]\s*\S)/i.test(text);
 }
 
-async function findActiveGoalWorkflowReconciliationRequirement(cwd: string): Promise<{ workflow: string; command: string } | null> {
+async function findActiveGoalWorkflowReconciliationRequirement(cwd: string): Promise<{ workflow: string; command: string; remediation?: string } | null> {
   const ultragoal = await readJsonIfExists(join(cwd, ".omx", "ultragoal", "goals.json"));
+  const aggregateCompletion = safeObject(ultragoal?.aggregateCompletion);
+  const aggregateProductComplete = safeString(aggregateCompletion.status) === "complete";
   const ultragoals = Array.isArray(ultragoal?.goals) ? ultragoal.goals.map(safeObject) : [];
-  const activeUltragoal = ultragoals.find((goal) => safeString(goal.status) === "in_progress" || safeString(goal.id) === safeString(ultragoal?.activeGoalId));
+  const activeUltragoal = aggregateProductComplete
+    ? undefined
+    : ultragoals.find((goal) => safeString(goal.status) === "in_progress" || safeString(goal.id) === safeString(ultragoal?.activeGoalId));
   if (activeUltragoal) {
+    const goalId = safeString(activeUltragoal.id) || "<goal-id>";
     return {
       workflow: "ultragoal",
-      command: `omx ultragoal checkpoint --goal-id ${safeString(activeUltragoal.id) || "<goal-id>"} --status complete --codex-goal-json '<get_goal JSON or path>' --evidence '<evidence>'`,
+      command: `omx ultragoal checkpoint --goal-id ${goalId} --status complete --codex-goal-json '<get_goal JSON or path>' --evidence '<evidence>'`,
+      remediation: [
+        `If get_goal returns a completed task-scoped objective for the same aggregate ultragoal plan, checkpoint ${goalId} with evidence naming ${goalId} plus .omx/ultragoal/goals.json or ledger.jsonl and pass final quality-gate JSON; OMX will reconcile the completed planned scope without mutating Codex goal state.`,
+        `If get_goal instead returns a different completed legacy objective and complete checkpointing fails, do not repeat --status complete in this thread.`,
+        `Record the non-terminal blocker with: omx ultragoal checkpoint --goal-id ${goalId} --status blocked --codex-goal-json '<different completed get_goal JSON or path>' --evidence '<completed legacy Codex goal blocks create_goal in this thread>'.`,
+        "Then continue this ultragoal from a fresh Codex thread in the same repo/worktree and create the intended goal there.",
+      ].join(" "),
     };
   }
 
@@ -1752,7 +1777,8 @@ async function buildGoalWorkflowReconciliationPromptWarning(cwd: string, prompt:
     `OMX ${requirement.workflow} goal workflow requires Codex goal snapshot reconciliation before completion.`,
     "Call get_goal, pass the resulting JSON or a path with --codex-goal-json, and do not rely on hooks or shell commands to mutate Codex-owned goal state.",
     `Required command shape: ${requirement.command}.`,
-  ].join(" ");
+    requirement.remediation,
+  ].filter(Boolean).join(" ");
 }
 
 async function buildGoalWorkflowReconciliationStopOutput(
@@ -1764,7 +1790,11 @@ async function buildGoalWorkflowReconciliationStopOutput(
   const requirement = await findActiveGoalWorkflowReconciliationRequirement(cwd);
   if (!requirement) return null;
   const systemMessage =
-    `OMX ${requirement.workflow} requires get_goal snapshot reconciliation before completion; call get_goal and pass --codex-goal-json to ${requirement.command}. Hooks must not mutate Codex goal state.`;
+    [
+      `OMX ${requirement.workflow} requires get_goal snapshot reconciliation before completion; call get_goal and pass --codex-goal-json to ${requirement.command}.`,
+      requirement.remediation,
+      "Hooks must not mutate Codex goal state.",
+    ].filter(Boolean).join(" ");
   return {
     decision: "block",
     reason: systemMessage,
@@ -2323,6 +2353,109 @@ function readPreviousNativeStopSignature(
   return safeString(sessionState.last_signature).trim();
 }
 
+function parseBoundedPositiveInteger(value: unknown, fallback: number): number {
+  const parsed = Math.trunc(Number(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function parseBoundedNonNegativeInteger(value: unknown, fallback: number): number {
+  const parsed = Math.trunc(Number(value));
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function normalizeOrdinaryStopProgressText(value: unknown): string {
+  return safeString(value)
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function shortenOrdinaryStopProgressText(value: string): string {
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  if (trimmed.length <= ORDINARY_STOP_NO_PROGRESS_MAX_MESSAGE_LENGTH) return trimmed;
+  return `${trimmed.slice(0, ORDINARY_STOP_NO_PROGRESS_MAX_MESSAGE_LENGTH - 1).trimEnd()}…`;
+}
+
+function ordinaryStopProgressFingerprint(payload: CodexHookPayload): string {
+  const message = normalizeOrdinaryStopProgressText(
+    payload.last_assistant_message ?? payload.lastAssistantMessage,
+  ) || "<no assistant message>";
+  const mode = normalizeOrdinaryStopProgressText(payload.mode) || "ordinary";
+  return `${mode}|${message}`;
+}
+
+function readIsoTimeMs(value: unknown): number | null {
+  const parsed = Date.parse(safeString(value));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+async function maybeBuildOrdinaryStopNoProgressOutput(
+  payload: CodexHookPayload,
+  stateDir: string,
+  canonicalSessionId?: string,
+): Promise<Record<string, unknown> | null> {
+  const statePath = join(stateDir, NATIVE_STOP_STATE_FILE);
+  const state = await readJsonIfExists(statePath) ?? {};
+  const sessions = safeObject(state.sessions);
+  const sessionKey = readNativeStopSessionKey(payload, canonicalSessionId);
+  const sessionState = safeObject(sessions[sessionKey]);
+  const previousGuard = safeObject(sessionState.ordinary_no_progress_guard);
+  const fingerprint = ordinaryStopProgressFingerprint(payload);
+  const nowIso = new Date().toISOString();
+  const previousFingerprint = safeString(previousGuard.fingerprint).trim();
+  const sameFingerprint = previousFingerprint === fingerprint;
+  const firstSeenAt = sameFingerprint
+    ? safeString(previousGuard.first_seen_at).trim() || nowIso
+    : nowIso;
+  const repeatCount = sameFingerprint
+    ? parseBoundedPositiveInteger(previousGuard.repeat_count, 1) + 1
+    : 1;
+
+  sessions[sessionKey] = {
+    ...sessionState,
+    ordinary_no_progress_guard: {
+      fingerprint,
+      first_seen_at: firstSeenAt,
+      last_seen_at: nowIso,
+      repeat_count: repeatCount,
+      last_turn_id: readPayloadTurnId(payload) || null,
+      last_thread_id: readPayloadThreadId(payload) || null,
+    },
+  };
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(statePath, JSON.stringify({ ...state, sessions }, null, 2));
+
+  const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
+  if (!stopHookActive) return null;
+
+  const maxRepeats = parseBoundedPositiveInteger(
+    process.env.OMX_NATIVE_STOP_NO_PROGRESS_MAX_REPEATS,
+    ORDINARY_STOP_NO_PROGRESS_DEFAULT_MAX_REPEATS,
+  );
+  const idleMs = parseBoundedNonNegativeInteger(
+    process.env.OMX_NATIVE_STOP_NO_PROGRESS_IDLE_MS,
+    ORDINARY_STOP_NO_PROGRESS_DEFAULT_IDLE_MS,
+  );
+  const firstSeenMs = readIsoTimeMs(firstSeenAt) ?? Date.now();
+  const elapsedMs = Math.max(0, Date.now() - firstSeenMs);
+  if (repeatCount < maxRepeats || elapsedMs < idleMs) return null;
+
+  const message = shortenOrdinaryStopProgressText(
+    safeString(payload.last_assistant_message ?? payload.lastAssistantMessage) || "no assistant message recorded",
+  );
+  const elapsedSeconds = Math.round(elapsedMs / 1000);
+  const diagnostic =
+    `OMX ordinary task no-progress guard triggered after ${repeatCount} repeated Stop-hook pass(es) over ~${elapsedSeconds}s with unchanged status: "${message}". ` +
+    "Emit a concise diagnostic summary now: state the last concrete progress/evidence, whether the task is complete, blocked, failed, or needs missing information, and stop instead of continuing a vague working loop.";
+
+  return {
+    decision: "block",
+    reason: diagnostic,
+    stopReason: "ordinary_task_no_progress_guard",
+    systemMessage: diagnostic,
+  };
+}
+
 async function persistNativeStopSignature(
   stateDir: string,
   payload: CodexHookPayload,
@@ -2651,8 +2784,14 @@ async function buildStopHookOutput(
   if (ralphCompletionAuditBlock) {
     await reopenRalphCompletionAuditBlock(ralphCompletionAuditBlock);
     const blockingPath = formatStopStatePath(cwd, ralphCompletionAuditBlock.path);
-    const systemMessage =
-      `OMX Ralph completion audit is missing required evidence (${ralphCompletionAuditBlock.reason}; state: ${blockingPath}); continue verification, record a prompt-to-artifact checklist plus verification evidence, and do not report complete yet.`;
+    const systemMessage = [
+      `OMX Ralph completion audit is missing required evidence (${ralphCompletionAuditBlock.reason}; state: ${blockingPath}).`,
+      "Continue verification and do not report complete yet.",
+      "Record machine-readable completion evidence before stopping:",
+      "- either set state.completion_audit = { passed: true, prompt_to_artifact_checklist: [...], verification_evidence: [...] }",
+      "- or set completion_audit_path / completion_audit_evidence_path to a repo-relative JSON file with those same fields.",
+      "Markdown artifacts and flat top-level checklist/evidence fields are not accepted by the Ralph Stop gate.",
+    ].join(" ");
     return await returnPersistentStopBlock(
       payload,
       stateDir,
@@ -2843,6 +2982,13 @@ async function buildStopHookOutput(
         { allowRepeatDuringStopHook: true },
       );
     }
+    const ordinaryNoProgressOutput = await maybeBuildOrdinaryStopNoProgressOutput(
+      payload,
+      stateDir,
+      canonicalSessionId,
+    );
+    if (ordinaryNoProgressOutput) return ordinaryNoProgressOutput;
+
     const autoNudgeConfig = await loadAutoNudgeConfig();
     const autoNudgePhase = await readStopAutoNudgePhase(cwd, stateDir, canonicalSessionId, threadId);
 

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

@@ -793,14 +793,20 @@ function buildGitCommitComplianceErrors(message: string | null): string[] {
     errors.push("Add a blank line after the subject before the narrative body.");
   }
 
+  const hasSubject = (lines[0]?.trim() ?? "") !== "";
+  const hasBlankSeparator = lines.length >= 2 && lines[1]?.trim() === "";
   const { bodyText, trailerLines } = splitBodyAndTrailerLines(lines.slice(2).join("\n"));
-  if (!bodyText) {
-    errors.push("Add a narrative body paragraph explaining the decision context.");
-  }
-  if (!trailerLines.some((line) => LORE_TRAILER_PREFIXES.some((prefix) => line.startsWith(prefix)))) {
-    errors.push("Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.");
+  const hasOmxCoauthorTrailer = trailerLines.includes(OMX_COAUTHOR_TRAILER);
+  const usesCompactLorePath = hasSubject && hasBlankSeparator && !bodyText && hasOmxCoauthorTrailer;
+  if (!usesCompactLorePath) {
+    if (!bodyText) {
+      errors.push("Add a narrative body paragraph explaining the decision context.");
+    }
+    if (!trailerLines.some((line) => LORE_TRAILER_PREFIXES.some((prefix) => line.startsWith(prefix)))) {
+      errors.push("Add at least one Lore trailer such as `Constraint:`, `Confidence:`, or `Tested:`.");
+    }
   }
-  if (!trailerLines.includes(OMX_COAUTHOR_TRAILER)) {
+  if (!hasOmxCoauthorTrailer) {
     errors.push(`Add the required co-author trailer: \`${OMX_COAUTHOR_TRAILER}\`.`);
   }
 

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

@@ -99,7 +99,7 @@ async function resolveCanonicalPaneFromPaneTarget(paneTarget: any, expectedCwd:
   return finalizeResolvedPane(healedPaneId, 'healed_hud_pane_target', expectedCwd);
 }
 
-async function resolvePreferredModePane(stateDir: string, allowedModes: string[]): Promise<{ mode: string; state: any; pane: string } | null> {
+async function resolvePreferredModePane(stateDir: string, allowedModes: string[]): Promise<{ mode: string; state: any; pane: string; stateDir: string } | null> {
   const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir).catch(() => [stateDir]);
   const dirs = [...scopedDirs];
   if (!dirs.map((dir) => resolvePath(dir)).includes(resolvePath(stateDir))) {
@@ -111,13 +111,84 @@ async function resolvePreferredModePane(stateDir: string, allowedModes: string[]
       const parsed = await readJsonIfExists(path, null);
       const pane = safeString(parsed?.tmux_pane_id || '').trim();
       if (parsed?.active && pane) {
-        return { mode, state: parsed, pane };
+        return { mode, state: parsed, pane, stateDir: dir };
       }
     }
   }
   return null;
 }
 
+function modeStateMatchesInvocationOwner(modeState: any, payload: any, managedContext: any): { ok: true } | { ok: false; reason: string } {
+  const invocationSessionId = resolveInvocationSessionId(payload);
+  const canonicalSessionId = safeString(managedContext?.canonicalSessionId || managedContext?.sessionState?.session_id).trim();
+  const nativeSessionId = safeString(managedContext?.nativeSessionId || managedContext?.sessionState?.native_session_id || managedContext?.sessionState?.codex_session_id).trim();
+  const allowedSessionIds = new Set([
+    invocationSessionId,
+    canonicalSessionId,
+    nativeSessionId,
+  ].filter(Boolean));
+
+  const ownerOmxSessionId = safeString(modeState?.owner_omx_session_id).trim();
+  if (ownerOmxSessionId && !allowedSessionIds.has(ownerOmxSessionId)) {
+    return { ok: false, reason: 'mode_owner_session_mismatch' };
+  }
+
+  const stateSessionId = safeString(modeState?.session_id).trim();
+  if (!ownerOmxSessionId && stateSessionId && !allowedSessionIds.has(stateSessionId)) {
+    return { ok: false, reason: 'mode_session_mismatch' };
+  }
+
+  const ownerCodexSessionId = safeString(modeState?.owner_codex_session_id || modeState?.codex_session_id).trim();
+  if (ownerCodexSessionId && !allowedSessionIds.has(ownerCodexSessionId)) {
+    return { ok: false, reason: 'mode_codex_session_mismatch' };
+  }
+
+  return { ok: true };
+}
+
+async function validateResolvedInjectionOwnership({
+  paneTarget,
+  cwd,
+  payload,
+  modeState,
+  modePane,
+  managedCurrentPane,
+}: any): Promise<{ ok: true } | { ok: false; reason: string; managedContext?: any }> {
+  const ownership = await verifyManagedPaneTarget(paneTarget, cwd, payload, { allowTeamWorker: false });
+  if (!ownership.ok) {
+    return { ok: false, reason: ownership.reason || 'pane_not_managed_session', managedContext: ownership.managedContext };
+  }
+
+  const modeOwner = modeStateMatchesInvocationOwner(modeState, payload, ownership.managedContext);
+  if (!modeOwner.ok) return { ...modeOwner, managedContext: ownership.managedContext };
+
+  const statePane = safeString(modePane || modeState?.tmux_pane_id).trim();
+  const currentPane = safeString(managedCurrentPane).trim();
+  if (statePane && currentPane && statePane !== currentPane) {
+    return { ok: false, reason: 'mode_pane_current_pane_mismatch', managedContext: ownership.managedContext };
+  }
+
+  const expectedWindowId = safeString(modeState?.tmux_window_id || modeState?.tmuxWindowId).trim();
+  if (!expectedWindowId) {
+    return { ok: true };
+  }
+
+  try {
+    const windowResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#{window_id}'], 2000);
+    const paneWindowId = safeString(windowResult.stdout).trim();
+    if (!paneWindowId) {
+      return { ok: false, reason: 'pane_window_unverified', managedContext: ownership.managedContext };
+    }
+    if (paneWindowId !== expectedWindowId) {
+      return { ok: false, reason: 'pane_window_mismatch', managedContext: ownership.managedContext };
+    }
+  } catch {
+    return { ok: false, reason: 'pane_window_unverified', managedContext: ownership.managedContext };
+  }
+
+  return { ok: true };
+}
+
 async function readVisibleAllowedModes(
   cwd: string,
   stateDir: string,
@@ -460,7 +531,22 @@ export async function handleTmuxInjection({
     turnId,
     timestamp: nowIso,
   }), sourceText);
-  const preferredPaneTarget = modePane || await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker: false });
+  const managedCurrentPane = await resolveManagedCurrentPane(cwd, payload, { allowTeamWorker: false });
+  if (modePane && managedCurrentPane && modePane !== managedCurrentPane) {
+    state.last_reason = 'mode_pane_current_pane_mismatch';
+    state.last_event_at = nowIso;
+    await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+    await logTmuxHookEvent(logsDir, {
+      ...baseLog,
+      event: 'injection_skipped',
+      reason: 'mode_pane_current_pane_mismatch',
+      mode_pane: modePane,
+      current_pane: managedCurrentPane,
+    });
+    return;
+  }
+
+  const preferredPaneTarget = modePane || managedCurrentPane;
   let resolution = preferredModePane
     ? await resolvePaneTarget({ type: 'pane', value: preferredModePane.pane }, cwd, preferredModePane.pane, cwd, payload)
     : preferredPaneTarget
@@ -484,6 +570,27 @@ export async function handleTmuxInjection({
   }
   const paneTarget = resolution.paneTarget;
 
+  const ownership = await validateResolvedInjectionOwnership({
+    paneTarget,
+    cwd,
+    payload,
+    modeState,
+    modePane,
+    managedCurrentPane,
+  });
+  if (!ownership.ok) {
+    state.last_reason = ownership.reason;
+    state.last_event_at = nowIso;
+    await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+    await logTmuxHookEvent(logsDir, {
+      ...baseLog,
+      event: 'injection_skipped',
+      reason: ownership.reason,
+      pane_target: paneTarget,
+    });
+    return;
+  }
+
   // Final guard phase: pane is canonical identity for quota/cooldown.
   const guard = evaluateInjectionGuards({
     config,

package/src/scripts/run-test-files.ts

@@ -6,6 +6,12 @@ const DEFAULT_TEST_TIMEOUT_MS = 0;
 const DEFAULT_RUNNER_TIMEOUT_MS = 30 * 60 * 1_000;
 const DEFAULT_CI_TEST_CONCURRENCY = 1;
 
+function parseBooleanEnv(value: string | undefined): boolean {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+
 function collectTests(path: string, out: string[]): void {
   let stats;
   try {
@@ -61,6 +67,7 @@ if (files.length === 0) {
 const testTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_TIMEOUT_MS, DEFAULT_TEST_TIMEOUT_MS);
 const runnerTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_RUNNER_TIMEOUT_MS, DEFAULT_RUNNER_TIMEOUT_MS);
 const testConcurrency = parseTestConcurrency(process.env);
+const forceExit = parseBooleanEnv(process.env.OMX_NODE_TEST_FORCE_EXIT);
 const testArgs = ['--test'];
 if (testTimeoutMs > 0) {
   testArgs.push(`--test-timeout=${testTimeoutMs}`);
@@ -68,14 +75,17 @@ if (testTimeoutMs > 0) {
 if (testConcurrency) {
   testArgs.push(`--test-concurrency=${testConcurrency}`);
 }
+if (forceExit) {
+  testArgs.push('--test-force-exit');
+}
 testArgs.push(...files);
 
 console.error(
   `[run-test-files] running ${files.length} test file(s) from ${targets.join(', ')}${
     testTimeoutMs > 0 ? ` with per-test timeout ${testTimeoutMs}ms` : ' with per-test timeout disabled'
   }${testConcurrency ? `, test concurrency ${testConcurrency}` : ', default test concurrency'}${
-    runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'
-  }`,
+    forceExit ? ', force exit enabled' : ', force exit disabled'
+  }${runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'}`,
 );
 
 const childEnv = { ...process.env };
@@ -101,6 +111,7 @@ console.error(
     + `Roots: ${targets.join(', ')}. Test files: ${files.length}. `
     + `Per-test timeout: ${testTimeoutMs > 0 ? `${testTimeoutMs}ms` : 'disabled'}. `
     + `Test concurrency: ${testConcurrency ?? 'default'}. `
+    + `Force exit: ${forceExit ? 'enabled' : 'disabled'}. `
     + `Runner timeout: ${runnerTimeoutMs > 0 ? `${runnerTimeoutMs}ms` : 'disabled'}.`,
 );
 process.exit(1);

package/templates/catalog-manifest.json

@@ -181,13 +181,20 @@
       "internalRequired": false
     },
     {
-      "name": "frontend-ui-ux",
+      "name": "design",
       "category": "shortcut",
-      "status": "alias",
+      "status": "active",
       "canonical": "designer",
       "core": false,
       "internalRequired": false
     },
+    {
+      "name": "frontend-ui-ux",
+      "category": "shortcut",
+      "status": "deprecated",
+      "core": false,
+      "internalRequired": false
+    },
     {
       "name": "git-master",
       "category": "shortcut",

package/dist/planning/__tests__/context-pack-status.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=context-pack-status.test.d.ts.map

package/dist/planning/__tests__/context-pack-status.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-pack-status.test.d.ts","sourceRoot":"","sources":["../../../src/planning/__tests__/context-pack-status.test.ts"],"names":[],"mappings":""}