oh-my-codex 0.21.0 → 0.21.2

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

@@ -53,6 +53,8 @@ import {
   assertCodexBatchWriteResult,
   assertGeneratedTrustMatchesCodex,
   managedCodexHooksByEvent,
+  assertNativeHookAdvisoryPreToolUse,
+  listPersistedStateFiles,
 } from '../smoke-packed-install.js';
 import { parseNativeSubagentResultDisposition } from '../../leader/contract.js';
 
@@ -1106,7 +1108,7 @@ test('packed install smoke covers directive activation and terminal false-activa
     { name: 'compact-explicit-negation', prompt: '$ralplan,$autopilot are prohibited', expectedSkill: null, expectedStopBlock: false },
     { name: 'compact-implicit-negation', prompt: 'Autopilot mode،deep interview are prohibited.', expectedSkill: null, expectedStopBlock: false },
     { name: 'doc-clause-local-prefix', prompt: '$ralplan; $autopilot is documented in the guide.', expectedSkill: 'ralplan', expectedStopBlock: true },
-    { name: 'doc-chain-described', prompt: 'use $ralplan is the workflow command; autopilot mode is documented in the guide; $team execute it', expectedSkill: 'team', expectedStopBlock: false, insideTmux: true },
+    { name: 'doc-chain-described', prompt: 'use $ralplan is the workflow command; autopilot mode is documented in the guide; $team execute it', expectedSkill: 'team', expectedStopBlock: true, insideTmux: true },
     { name: 'doc-chain-workflow', prompt: 'use $ralplan is the workflow command; autopilot mode is workflow documentation; use $ralph execute it', expectedSkill: 'ralph', expectedStopBlock: true },
     { name: 'ref-inline-explicit', prompt: '[docs]: $ralplan\n$autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true },
     { name: 'ref-inline-prompts', prompt: '[docs]: /prompts:architect\n$autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true },
@@ -1132,10 +1134,10 @@ test('packed install smoke covers directive activation and terminal false-activa
     { name: 'neg-fw-dot-reopen', prompt: 'Do not run $ralplan． use $autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true },
     { name: 'neg-greek-q-reopen', prompt: 'Do not run $ralplan; use $autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true },
     { name: 'unicode-attached-contrast', prompt: 'Do not use deep interview яbut use autopilot mode.', expectedSkill: null, expectedStopBlock: false },
-    { name: 'prefix-list-followup', prompt: 'Do not run $ralplan, $autopilot; use $team execute it', expectedSkill: 'team', expectedStopBlock: false, insideTmux: true },
+    { name: 'prefix-list-followup', prompt: 'Do not run $ralplan, $autopilot; use $team execute it', expectedSkill: 'team', expectedStopBlock: true, insideTmux: true },
     { name: 'mixed-postposed-chain', prompt: '$ralplan, autopilot mode, $team are prohibited.', expectedSkill: null, expectedStopBlock: false },
-    { name: 'implicit-first-doc-chain', prompt: 'Autopilot mode and $ralplan are workflow commands; use $team execute it', expectedSkill: 'team', expectedStopBlock: false, insideTmux: true },
-    { name: 'both-mixed-doc-followup', prompt: 'Both autopilot mode and $ralplan are workflow commands; use $team execute it', expectedSkill: 'team', expectedStopBlock: false, insideTmux: true },
+    { name: 'implicit-first-doc-chain', prompt: 'Autopilot mode and $ralplan are workflow commands; use $team execute it', expectedSkill: 'team', expectedStopBlock: true, insideTmux: true },
+    { name: 'both-mixed-doc-followup', prompt: 'Both autopilot mode and $ralplan are workflow commands; use $team execute it', expectedSkill: 'team', expectedStopBlock: true, insideTmux: true },
     { name: 'doc-semicolon-preserves-earlier', prompt: 'Use autopilot mode; use $ralplan is the workflow command.', expectedSkill: 'autopilot', expectedStopBlock: true },
     { name: 'doc-independent-comma', prompt: 'Use autopilot mode, and $ralplan is documented in the guide.', expectedSkill: 'autopilot', expectedStopBlock: true },
     { name: 'reference-unclosed-quote-destination', prompt: '[docs]: "target\n$autopilot build it', expectedSkill: null, expectedStopBlock: false },
@@ -1183,14 +1185,14 @@ test('packed install smoke covers directive activation and terminal false-activa
     { name: 'percent-suffix', prompt: '$ralplan%docs', expectedSkill: null, expectedStopBlock: false },
     { name: 'fullwidth-percent-suffix', prompt: '$ralplan％docs', expectedSkill: null, expectedStopBlock: false },
     { name: 'g1a-ordered-multi-skill', prompt: '$ralplan, $autopilot; $team', expectedSkill: 'ralplan', expectedStopBlock: true, expectedDeferredSkills: ['autopilot', 'team'], expectedActiveSkills: ['ralplan'], insideTmux: true },
-    { name: 'g1c-duplicate-alias', prompt: '$autopilot $oh-my-codex:autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true, expectedDeferredSkills: [], expectedActiveSkills: [] },
+    { name: 'g1c-duplicate-alias', prompt: '$autopilot $oh-my-codex:autopilot build it', expectedSkill: 'autopilot', expectedStopBlock: true, expectedDeferredSkills: [], expectedActiveSkills: ['autopilot'] },
     { name: 'b3-longer-valid-fence', prompt: '```text\n$autopilot build it\n````\n$ralplan plan it', expectedSkill: 'ralplan', expectedStopBlock: true },
     { name: 'b4-shorter-invalid-fence', prompt: '````text\n$autopilot build it\n```\n$ralplan plan it', expectedSkill: null, expectedStopBlock: false },
     { name: 'b5-different-marker-invalid-fence', prompt: '```text\n$autopilot build it\n~~~\n$ralplan plan it', expectedSkill: null, expectedStopBlock: false },
   ]);
 });
 
-test('packed regression workflow expectations require active Autopilot and Ralplan activation', () => {
+test('packed regression workflow expectations require active supported skills and failed retired ralph receipts', () => {
   assert.doesNotThrow(() => assertPackedRegressionWorkflowState(
     { name: 'active-ralplan', expectedSkill: 'ralplan' },
     { active: true, skill: 'ralplan' },
@@ -1203,11 +1205,26 @@ test('packed regression workflow expectations require active Autopilot and Ralpl
     { name: 'failed-autopilot', expectedSkill: 'autopilot' },
     { active: false, skill: 'autopilot', phase: 'failed', active_skills: [] },
   ), /persisted unexpected workflow state/);
+  assert.doesNotThrow(() => assertPackedRegressionWorkflowState(
+    { name: 'retired-ralph', expectedSkill: 'ralph' },
+    {
+      active: false,
+      skill: 'ralph',
+      phase: 'failed',
+      transition_error: 'Skill "$ralph" has been removed. Use "$ultragoal" instead. The `omx ralph` CLI and ralph persistence runtime are unaffected.',
+      active_skills: [],
+    },
+  ));
+  assert.throws(() => assertPackedRegressionWorkflowState(
+    { name: 'active-retired-ralph', expectedSkill: 'ralph' },
+    { active: true, skill: 'ralph', phase: 'executing' },
+  ), /unexpected retired ralph state/);
 });
 
-test('packed regression Stop expectations keep active Autopilot continuation enabled', () => {
+test('packed regression Stop expectations keep active workflows blocked but retired ralph terminal', () => {
   assert.equal(shouldPackedRegressionStopBlock({ expectedSkill: 'ralplan', expectedStopBlock: true }), true);
   assert.equal(shouldPackedRegressionStopBlock({ expectedSkill: 'autopilot', expectedStopBlock: true }), true);
+  assert.equal(shouldPackedRegressionStopBlock({ expectedSkill: 'ralph', expectedStopBlock: true }), false);
 });
 
 test('packed regression environment clears inherited Team routing state', () => {
@@ -1695,3 +1712,99 @@ test('ensureRepoDependencies falls back to npm ci when no reusable node_modules
     await rm(root, { recursive: true, force: true });
   }
 });
+test('assertNativeHookAdvisoryPreToolUse accepts the two documented advisory shapes', () => {
+  // Empty no-op: the hook intentionally produced no advisory content (#3497).
+  assertNativeHookAdvisoryPreToolUse('advisory-empty', {});
+
+  // Documented advisory context with the PreToolUse event name.
+  assertNativeHookAdvisoryPreToolUse('advisory-context', {
+    systemMessage: 'advisory guidance',
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: 'advisory guidance',
+    },
+  });
+
+  // systemMessage alone, without a hookSpecificOutput envelope, is also advisory.
+  assertNativeHookAdvisoryPreToolUse('advisory-system-message', { systemMessage: 'guidance only' });
+});
+
+test('assertNativeHookAdvisoryPreToolUse rejects outputs that would hide a regression', () => {
+  const rejections: Array<[string, Record<string, unknown>, RegExp]> = [
+    ['hard block', { decision: 'block', reason: 'nope' }, /hard block/],
+    ['stopped continuation', { continue: false }, /stopped continuation/],
+    ['stopReason', { stopReason: 'native_hook_stdin_parse_error' }, /emitted stopReason/],
+    ['permission deny', {
+      hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny' },
+    }, /permissionDecision "deny"/],
+    ['permission allow', {
+      hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' },
+    }, /permissionDecision "allow"/],
+    ['wrong event name', {
+      systemMessage: 'x',
+      hookSpecificOutput: { hookEventName: 'Stop', additionalContext: 'x' },
+    }, /hookSpecificOutput names "Stop"/],
+    ['non-string system message', { systemMessage: 1 }, /malformed systemMessage/],
+    ['empty system message', { systemMessage: '' }, /malformed systemMessage/],
+    ['empty envelope', { hookSpecificOutput: {} }, /malformed PreToolUse advisory envelope/],
+    ['system message plus empty envelope', {
+      systemMessage: 'x',
+      hookSpecificOutput: {},
+    }, /malformed PreToolUse advisory envelope/],
+    ['envelope without event name', {
+      systemMessage: 'x',
+      hookSpecificOutput: { additionalContext: 'x' },
+    }, /malformed PreToolUse advisory envelope/],
+    ['envelope without context', {
+      systemMessage: 'x',
+      hookSpecificOutput: { hookEventName: 'PreToolUse' },
+    }, /malformed PreToolUse advisory envelope/],
+    ['mismatched envelope content', {
+      systemMessage: 'x',
+      hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: 'y' },
+    }, /does not mirror systemMessage/],
+    ['unexpected top-level field', { systemMessage: 'x', reason: 'stray' }, /unexpected top-level field "reason"/],
+    ['unexpected hook field', {
+      systemMessage: 'x',
+      hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecisionReason: 'stray' },
+    }, /emitted unexpected field "permissionDecisionReason"/],
+    ['malformed hookSpecificOutput', { hookSpecificOutput: 'nope' }, /malformed hookSpecificOutput/],
+    ['array hookSpecificOutput', { hookSpecificOutput: [] }, /malformed hookSpecificOutput/],
+  ];
+  for (const [label, output, pattern] of rejections) {
+    assert.throws(
+      () => assertNativeHookAdvisoryPreToolUse(`probe-${label}`, output),
+      pattern,
+      `${label} must be rejected`,
+    );
+  }
+});
+
+test('listPersistedStateFiles permits empty state directory bootstrap but detects persisted artifacts', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'omx-packed-state-artifacts-'));
+  try {
+    const stateRoot = join(root, '.omx', 'state');
+    await mkdir(join(stateRoot, 'sessions', 'nested'), { recursive: true });
+    assert.deepEqual(listPersistedStateFiles(stateRoot), []);
+
+    const persistedFile = join(stateRoot, 'sessions', 'nested', 'skill-active-state.json');
+    await writeFile(persistedFile, '{}\n');
+    assert.deepEqual(listPersistedStateFiles(stateRoot), [persistedFile]);
+    await rm(persistedFile);
+
+    const symlinkPath = join(stateRoot, 'sessions', 'state-link');
+    await symlink(join(root, 'missing-target'), symlinkPath);
+    assert.deepEqual(listPersistedStateFiles(stateRoot), [symlinkPath]);
+    await rm(symlinkPath);
+
+    const rootLink = join(root, 'state-link');
+    await symlink(stateRoot, rootLink);
+    assert.deepEqual(listPersistedStateFiles(rootLink), [rootLink]);
+
+    const rootFile = join(root, 'state-file');
+    await writeFile(rootFile, '{}\n');
+    assert.deepEqual(listPersistedStateFiles(rootFile), [rootFile]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

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

@@ -1,6 +1,6 @@
 import { execFileSync } from "child_process";
 import { accessSync, closeSync, constants as fsConstants, existsSync, lstatSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from "fs";
-import { appendFile, lstat, mkdir, open, readFile, readdir, stat, unlink, writeFile } from "fs/promises";
+import { appendFile, lstat, mkdir, open, readFile, readdir, realpath, stat, unlink, writeFile } from "fs/promises";
 import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "path";
 import { createHash } from "crypto";
 
@@ -32,6 +32,12 @@ import {
 } from "../subagents/tracker.js";
 
 import { readRoleRoutingMarker, writeRoleRoutingMarker } from "../subagents/role-routing-marker.js";
+import {
+  readCurrentRalplanAdvisory,
+  reconcileRalplanAdvisory,
+  observeRalplanAdvisoryPrompt,
+} from "../ralplan/advisory.js";
+import { activateOrResumeRalplanAdvisory } from "../ralplan/advisory-activation.js";
 import {
   resolveCanonicalTeamStateRoot,
   resolveWorkerTeamStateRootPath,
@@ -57,6 +63,7 @@ import {
   readUsableSessionState,
   reconcileNativeSessionStart,
   resolveSessionPointerContext,
+  sessionOwnerFileIdentityMatches,
   type SessionStartOptions,
   writeNativeSessionOwner,
   type SessionState
@@ -210,6 +217,9 @@ interface NativeHookDispatchOptions {
   /** @internal Scoped deterministic SessionStart durability seam for native-hook tests. */
   sessionStartOptions?: Pick<SessionStartOptions, 'platform' | 'regularFileSync'>;
   reconcileHudForPromptSubmitFn?: typeof reconcileHudForPromptSubmit;
+  /** @internal Deterministic Advisory reconciliation failure seam for hook tests. */
+  reconcileRalplanAdvisoryFn?: typeof reconcileRalplanAdvisory;
+  /** @internal Deterministic Advisory detect/read race seam for native-hook tests. */
 }
 
 export interface NativeHookDispatchResult {
@@ -3735,7 +3745,11 @@ function hookCancelIdentity(stats: { dev: number; ino: number; mode: number; uid
   return { dev: stats.dev, ino: stats.ino, mode: stats.mode, uid: stats.uid, size: stats.size, mtimeMs: stats.mtimeMs };
 }
 function hookCancelIdentityMatches(left: HookCancelTargetIdentity, right: HookCancelTargetIdentity): boolean {
-  return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.uid === right.uid && left.size === right.size && left.mtimeMs === right.mtimeMs;
+  return sessionOwnerFileIdentityMatches(left, right, hookCancelPlatform())
+    && left.mode === right.mode
+    && left.uid === right.uid
+    && left.size === right.size
+    && left.mtimeMs === right.mtimeMs;
 }
 function hookCancelTargetMatches(left: HookCancelTargetIdentity, right: HookCancelTargetIdentity): boolean {
   return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.uid === right.uid;
@@ -5552,6 +5566,7 @@ const NATIVE_CODEX_GOAL_READ_TOOL_NAMES = new Set([
   "get_goal",
   "functions.get_goal",
   "functionsget_goal",
+  "mcp__omx_goal__get_goal",
 ]);
 const NATIVE_CODEX_GOAL_LIFECYCLE_TOOL_NAMES = new Set([
   "create_goal",
@@ -5560,6 +5575,8 @@ const NATIVE_CODEX_GOAL_LIFECYCLE_TOOL_NAMES = new Set([
   "functions.update_goal",
   "functionscreate_goal",
   "functionsupdate_goal",
+  "mcp__omx_goal__create_goal",
+  "mcp__omx_goal__update_goal",
 ]);
 
 function canonicalizeNativeCodexGoalToolName(name: string): string {
@@ -10133,6 +10150,111 @@ function directOmxCancelCommandHasTrustedExecutionContext(command: string, cwd:
   return omxOrGjcExecutionContextIsTrusted(command, cwd, ["omx"]);
 }
 
+export type RalplanAdvisoryStateDetection =
+  | { status: "normal"; root: string }
+  | { status: "missing"; root: string; reason: "advisory_binding_without_state_root" }
+  | { status: "unreadable"; root: string; reason: string }
+  | { status: "none"; root: string };
+
+async function sessionHasAdvisoryBinding(cwd: string, sessionId: string): Promise<boolean> {
+  const path = join(getBaseStateDir(cwd), "sessions", sessionId, "ralplan-state.json");
+  let handle: Awaited<ReturnType<typeof open>>;
+  try {
+    handle = await open(path, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || info.nlink !== 1 || info.size > 1024 * 1024) throw new Error("ralplan_advisory_binding_file_invalid");
+    const value = JSON.parse((await handle.readFile()).toString("utf8")) as unknown;
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("ralplan_advisory_binding_json_invalid");
+    return (value as Record<string, unknown>).workflow_variant === "advisory";
+  } finally {
+    await handle.close();
+  }
+}
+
+export async function detectRalplanAdvisoryState(cwd: string, sessionId: string): Promise<RalplanAdvisoryStateDetection> {
+  let canonicalCwd: string;
+  try { canonicalCwd = await realpath(cwd); }
+  catch (error) {
+    const root = join(getBaseStateDir(cwd), "sessions", sessionId, "ralplan-advisory");
+    return { status: "unreadable", root, reason: `cwd_realpath_${(error as NodeJS.ErrnoException).code ?? "failed"}` };
+  }
+  const root = join(getBaseStateDir(canonicalCwd), "sessions", sessionId, "ralplan-advisory");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(sessionId)) {
+    return { status: "unreadable", root, reason: "session_id_invalid" };
+  }
+  try {
+    const info = await lstat(root);
+    let canonical: string;
+    try { canonical = await realpath(root); }
+    catch (error) { return { status: "unreadable", root, reason: `state_root_realpath_${(error as NodeJS.ErrnoException).code ?? "failed"}` }; }
+    if (!info.isDirectory()) return { status: "unreadable", root, reason: "state_root_not_canonical_directory" };
+    if (canonical !== root) return { status: "unreadable", root, reason: "state_root_not_canonical" };
+    return { status: "normal", root };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+      return { status: "unreadable", root, reason: `state_root_lstat_${(error as NodeJS.ErrnoException).code ?? "failed"}` };
+    }
+  }
+  try {
+    return await sessionHasAdvisoryBinding(canonicalCwd, sessionId)
+      ? { status: "missing", root, reason: "advisory_binding_without_state_root" }
+      : { status: "none", root };
+  } catch (error) {
+    return { status: "unreadable", root, reason: `binding_${(error as NodeJS.ErrnoException).code ?? "invalid"}` };
+  }
+}
+
+export function buildRalplanAdvisoryRoutingObservation(
+  intent: string,
+  projection: Awaited<ReturnType<typeof readCurrentRalplanAdvisory>>,
+  binding: Record<string, unknown> | null,
+): string | null {
+  if (intent !== "execute" || !projection) return null;
+  if (projection.corruption) {
+    return `Ralplan Advisory evidence is not a valid lifecycle projection (${projection.corruption}); this non-authoritative diagnostic does not grant or deny host tool permission.`;
+  }
+  const fence = projection.fence;
+  if (!fence) return "Ralplan Advisory planning has not reached a terminal lifecycle state; no automatic execution handoff was created.";
+  const matchingAdvisoryBinding = binding?.workflow_variant === "advisory"
+    && binding.advisory_generation_id === projection.activation.generation_id;
+  const conflictingWorkflow = binding?.active === true && !matchingAdvisoryBinding;
+  if (conflictingWorkflow) return null;
+  if (fence.state === "pending_closeout") {
+    return "Ralplan Advisory closeout is still pending; no automatic execution handoff was created.";
+  }
+  if (fence.state === "recovery_required") {
+    return "Ralplan Advisory evidence requires lifecycle recovery; no automatic execution handoff was created.";
+  }
+  if (fence.state === "abandoned") {
+    return `Ralplan Advisory ended as ${fence.outcome ?? "abandoned"}, not as an approved planning result; later instructions follow normal host rules.`;
+  }
+  const lifecycle = projection.journal?.terminal_mode_updates?.ralplan_review_lifecycle;
+  const lifecycleRecord = lifecycle && typeof lifecycle === "object" && !Array.isArray(lifecycle)
+    ? lifecycle as Record<string, unknown>
+    : null;
+  const complete = fence.state === "closed" && fence.outcome === "approved" && fence.integrity_status === "proven"
+    && projection.journal?.phase === "committed" && projection.journal.outcome === "approved"
+    && lifecycleRecord?.complete === true
+    && lifecycleRecord.sequence_valid === true
+    && lifecycleRecord.iteration === fence.iteration
+    && lifecycleRecord.iteration_id === fence.iteration_id
+    && lifecycleRecord.plan_manifest_sha256 === fence.plan_manifest_sha256
+    && lifecycleRecord.architect_review_sha256 === fence.architect_review_sha256
+    && lifecycleRecord.critic_review_sha256 === fence.critic_review_sha256
+    && lifecycleRecord.evidence_bundle_sha256 === fence.evidence_bundle_sha256
+    && lifecycleRecord.evidence_scope === "local_runtime"
+    && lifecycleRecord.host_observable === false
+    && lifecycleRecord.host_verified === false;
+  return complete
+    ? "Ralplan Advisory planning is complete and its byte-bound evidence remains auditable. This execution request is a non-authoritative routing observation only; no local Advisory file or classifier grants tool permission or an automatic execution handoff."
+    : "Ralplan Advisory does not contain a complete approved and proven planning lifecycle; no automatic execution handoff was created.";
+}
+
 function isCommandResolutionSensitiveEnvironmentName(name: string): boolean {
   // Variables that redirect where the shell resolves the executable itself.
   // A leading PATH/PATHEXT override can point a bare `omx`/`rtk` at an
@@ -21769,6 +21891,7 @@ export async function dispatchCodexNativeHook(
 ): Promise<NativeHookDispatchResult> {
   const hookEventName = readHookEventName(payload);
   const cwd = options.cwd ?? (safeString(payload.cwd).trim() || process.cwd());
+  const reconcileAdvisory = options.reconcileRalplanAdvisoryFn ?? reconcileRalplanAdvisory;
   const omxEventName = mapCodexHookEventToOmxEvent(hookEventName);
   // #3497 / C1 boundary: documented-leader PreToolUse hard gate removed.
   if (hookEventName === "PreToolUse" && safeString(payload.tool_name).trim() === "Bash") {
@@ -21820,6 +21943,7 @@ export async function dispatchCodexNativeHook(
   let goalWorkflowAdditionalContext: string | null = null;
   let ultragoalSteeringAdditionalContext: string | null = null;
   let teamNoticeAdditionalContext: string | null = null;
+  let advisoryAdditionalContext: string | null = null;
   let teamNoticeTargetKey: string | null = null;
   let promptClassification: KeywordInputClassification | null = null;
 
@@ -22183,13 +22307,84 @@ export async function dispatchCodexNativeHook(
     (isSubagentSessionStart || isSubagentStop)
     && shouldSuppressSubagentLifecycleHookDispatch();
 
+  const advisoryStateDetection = canonicalSessionId
+    && (hookEventName === "SessionStart" || hookEventName === "Stop" || hookEventName === "UserPromptSubmit")
+    ? await detectRalplanAdvisoryState(policyCwd, canonicalSessionId)
+    : null;
+  if ((hookEventName === "SessionStart" || hookEventName === "Stop") && canonicalSessionId
+    && advisoryStateDetection?.status === "normal") {
+    try {
+      const reconciledAdvisory = await reconcileAdvisory(policyCwd, canonicalSessionId);
+      if (reconciledAdvisory?.corruption === "live_session_binding_conflict"
+        || reconciledAdvisory?.corruption === "live_session_binding_unreadable") {
+        throw new Error(reconciledAdvisory.corruption);
+      }
+    } catch (error) {
+      const diagnostic = `Ralplan Advisory lifecycle reconciliation reported a non-authoritative diagnostic: ${error instanceof Error ? error.message : String(error)}. It does not grant or deny host tool permission.`;
+      if (hookEventName === "SessionStart") {
+        advisoryAdditionalContext = diagnostic;
+      } else {
+        await appendToLog(cwd, {
+          event: "ralplan_advisory_reconciliation_diagnostic",
+          hook_event_name: "Stop",
+          session_id: canonicalSessionId,
+          reason: error instanceof Error ? error.message : String(error),
+          non_authoritative: true,
+          timestamp: new Date().toISOString(),
+        }).catch(() => {});
+      }
+    }
+  }
+
   if (hookEventName === "UserPromptSubmit") {
     const prompt = readPromptText(payload);
-    if (!isSubagentPromptSubmit) {
-      teamNoticeTargetKey = parseTeamNoticeLedgerPrompt(prompt);
+    const advisoryThreadKind = promptTurnContext?.status === "authorized"
+      && promptTurnContext.authorization.targetRelation !== "explicit-independent"
+      && promptTurnContext.authorization.thread.kind === "root-or-drift"
+      ? "root-or-drift" : "unknown";
+    if (!isSubagentPromptSubmit) promptClassification = classifyKeywordInput(prompt);
+    if (canonicalSessionId && !isSubagentPromptSubmit && advisoryStateDetection?.status === "normal") {
+      try {
+        await activateOrResumeRalplanAdvisory({
+          cwd: policyCwd, sessionId: canonicalSessionId, rootThreadId: threadId,
+          activationTurnId: turnId, prompt, resumeOnly: true, producer: "native", threadKind: advisoryThreadKind,
+        });
+        const advisory = await observeRalplanAdvisoryPrompt({
+          cwd: policyCwd,
+          sessionId: canonicalSessionId,
+          turnId,
+          threadId,
+          prompt,
+          producer: "native",
+          threadKind: promptTurnContext?.status === "authorized"
+            && promptTurnContext.authorization.targetRelation !== "explicit-independent"
+            ? "root-or-drift" : "unknown",
+          isSubagentPromptSubmit,
+          markedContinuation: payload.continuation === true
+            || payload.is_continuation === true
+            || safeString(payload.source).toLowerCase().includes("continuation"),
+          synthetic: payload.synthetic === true
+            || payload.auto_nudge === true
+            || safeString(payload.source).toLowerCase().includes("nudge"),
+          reservedInput: promptClassification?.reservedInput ?? null,
+        });
+        if ((advisory.intent === "replan" || advisory.intent === "new_advisory")
+          && advisory.projection?.activation) {
+          const activated = await activateOrResumeRalplanAdvisory({
+            cwd: policyCwd, sessionId: canonicalSessionId, rootThreadId: threadId,
+            activationTurnId: turnId, prompt, producer: "native", threadKind: advisoryThreadKind,
+            predecessorGenerationId: advisory.projection.activation.generation_id,
+          });
+          if (activated) advisory.projection = activated.projection;
+        }
+        const advisoryBinding = await readModeStateForSession("ralplan", canonicalSessionId, policyCwd);
+        advisoryAdditionalContext = buildRalplanAdvisoryRoutingObservation(advisory.intent, advisory.projection, advisoryBinding);
+      } catch (error) {
+        advisoryAdditionalContext = `Ralplan Advisory lifecycle reconciliation reported a non-authoritative diagnostic: ${error instanceof Error ? error.message : String(error)}. It does not grant or deny host tool permission.`;
+      }
     }
     if (!isSubagentPromptSubmit) {
-      promptClassification = classifyKeywordInput(prompt);
+      teamNoticeTargetKey = parseTeamNoticeLedgerPrompt(prompt);
     }
     goalWorkflowAdditionalContext = allowGlobalSideEffects
       ? await buildCompletedGoalCleanupPromptWarning(cwd, prompt).catch(() => null)
@@ -22198,13 +22393,26 @@ export async function dispatchCodexNativeHook(
     ultragoalSteeringAdditionalContext = prompt && !isSubagentPromptSubmit && allowImplicitSessionSideEffects && allowGlobalSideEffects
       ? await applyUserPromptUltragoalSteering(cwd, prompt).catch((error) => `OMX native UserPromptSubmit rejected bounded .omx/ultragoal steering for G002-cli-and-prompt-submit-bridge: ${error instanceof Error ? error.message : String(error)}`)
       : null;
-    let suppressActivationSeeding = !allowImplicitSessionSideEffects;
+    // An explicit independent payload session is safe to seed in its own
+    // session-scoped state even when global side effects (HUD/root mirrors) are
+    // suppressed because a stale selected pointer exists.
+    let suppressActivationSeeding = !allowImplicitSessionSideEffects
+      || (!allowGlobalSideEffects
+        && promptTurnContext?.status !== "authorized");
     if (promptTurnContext?.status === "authorized") {
       sessionIdForState = promptTurnContext.authorization.targetSessionId;
     } else if (prompt && !isSubagentPromptSubmit && allowImplicitSessionSideEffects) {
       const rawHookSessionId = canonicalSessionId || nativeSessionId;
       const normalizedHookSessionId = normalizeSessionId(rawHookSessionId);
-      const explicitHookSessionId = currentSessionState ? undefined : normalizedHookSessionId;
+      // An explicit payload session must win over a stale selected pointer.
+      // Preserve the pointer only for its authenticated session/native alias;
+      // otherwise seed state in the payload's session rather than silently
+      // mutating the selected session.
+      const explicitHookSessionId = currentSessionState
+        && normalizedHookSessionId
+        && payloadMatchesSessionPointer(normalizedHookSessionId, currentSessionState)
+        ? undefined
+        : normalizedHookSessionId;
       if (rawHookSessionId && !normalizedHookSessionId) {
         suppressActivationSeeding = true;
       } else {
@@ -22378,7 +22586,8 @@ export async function dispatchCodexNativeHook(
       allowTeamWorkerSideEffects: false,
     });
   }
-  if (hookEventName === "UserPromptSubmit" && !isSubagentPromptSubmit && teamNoticeTargetKey) {
+  if (hookEventName === "UserPromptSubmit" && !isSubagentPromptSubmit && teamNoticeTargetKey
+    && allowGlobalSideEffects) {
     const reconciled = await reconcileTeamNoticeLedger({ stateRoot: stateDir, targetKey: teamNoticeTargetKey }).catch(() => null);
     if (!reconciled || reconciled.context.length === 0) {
       teamNoticeAdditionalContext = "OMX invalidated this queued Team wake immediately before model input because no active source-proven Team notices remain. Do not infer or reference a removed Team from the generic wake.";
@@ -22411,16 +22620,17 @@ export async function dispatchCodexNativeHook(
     buildWikiPreCompactContext({ cwd });
   } else if ((hookEventName === "SessionStart" && !skipCanonicalSessionStartContext) || hookEventName === "UserPromptSubmit") {
     const additionalContext = hookEventName === "SessionStart"
-      ? await buildSessionStartContext(cwd, canonicalSessionId || nativeSessionId, {
+      ? [await buildSessionStartContext(cwd, canonicalSessionId || nativeSessionId, {
         hookEventName,
         payload,
         canonicalSessionId,
         nativeSessionId: resolvedNativeSessionId || nativeSessionId,
-      })
+      }), advisoryAdditionalContext].filter((entry): entry is string => Boolean(entry)).join("\n\n") || null
       : isSubagentPromptSubmit
         ? null
         : [
           teamNoticeAdditionalContext,
+          advisoryAdditionalContext,
           promptClassification ? buildAdditionalContextMessage(promptClassification, skillState, cwd, payload) : null,
           ultragoalSteeringAdditionalContext,
           goalWorkflowAdditionalContext,

package/src/scripts/postinstall.ts

@@ -8,6 +8,7 @@ import {
   writeUserInstallStamp,
 } from './postinstall-advisory.js';
 import { getPackageRoot } from "../utils/package.js";
+import { hydrateNativeBinary } from "../cli/native-assets.js";
 
 type PostinstallStatus =
   | "noop-local"
@@ -24,10 +25,40 @@ interface PostinstallDependencies {
   env: NodeJS.ProcessEnv;
   getCurrentVersion: () => Promise<string | null>;
   log: (message: string) => void;
+  hydrateRuntime: () => Promise<string | undefined>;
   readStamp: () => Promise<UserInstallStamp | null>;
   writeStamp: (stamp: UserInstallStamp) => Promise<void>;
 }
 
+const RUNTIME_HYDRATION_TIMEOUT_MS = 15_000;
+
+export async function hydrateOmxRuntimeNonFatal(options: {
+  packageRoot?: string;
+  env?: NodeJS.ProcessEnv;
+  log?: (message: string) => void;
+  timeoutMs?: number;
+} = {}): Promise<string | undefined> {
+  const log = options.log ?? ((message: string) => console.log(message));
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? RUNTIME_HYDRATION_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const runtimePath = await hydrateNativeBinary("omx-runtime", {
+      packageRoot: options.packageRoot,
+      env: options.env,
+      signal: controller.signal,
+    });
+    if (runtimePath) log(`[omx] Hydrated omx-runtime for this platform: ${runtimePath}`);
+    else log("[omx] omx-runtime was not available for this platform; native runtime features remain disabled.");
+    return runtimePath;
+  } catch (error) {
+    log(`[omx] omx-runtime hydration failed non-fatally: ${error instanceof Error ? error.message : String(error)}`);
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 function stripLeadingV(version: string): string {
   return version.trim().replace(/^v/i, "");
 }
@@ -55,6 +86,7 @@ const defaultDependencies: PostinstallDependencies = {
   env: process.env,
   getCurrentVersion,
   log: (message) => console.log(message),
+  hydrateRuntime: () => hydrateOmxRuntimeNonFatal(),
   readStamp: () => readUserInstallStamp(),
   writeStamp: (stamp) => writeUserInstallStamp(stamp),
 };
@@ -75,6 +107,20 @@ export async function runPostinstall(
   }
 
   const currentStampVersion = stripLeadingV(currentVersion);
+  try {
+    const runtimePath = await resolved.hydrateRuntime();
+    if (runtimePath) {
+      resolved.log(`[omx] Hydrated omx-runtime for this platform: ${runtimePath}`);
+    } else {
+      resolved.log(
+        "[omx] omx-runtime was not available for this platform; native runtime features remain disabled.",
+      );
+    }
+  } catch (error) {
+    resolved.log(
+      `[omx] omx-runtime hydration failed non-fatally: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
   const existingStamp = await resolved.readStamp();
   if (!isInstallVersionBump(currentVersion, existingStamp)) {
     return { status: "noop-same-version", version: currentStampVersion };