@lyupro/codex-bridge 0.4.0 → 0.5.1

package/cli/uninstall.mjs

@@ -1,31 +1,27 @@
-/** Uninstalls only recorded codex-bridge files while preserving host data and foreign files. */
+/** Uninstalls only recorded files from both roots while preserving host data and foreign files. */
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import {
   definitionForRecordedHook,
   fileFingerprint,
   installRecordPath,
+  legacyInstallRecordPath,
   readInstallRecord,
+  recordTarget,
 } from './manifest.mjs';
 import { removePermissionRules } from './permissions.mjs';
-import { commandFor, removeHook, withSettingsRun } from './settings-merge.mjs';
+import {
+  commandFor,
+  removeHook,
+  withSettingsRun,
+} from './settings-merge.mjs';
 import { readRulesRegistry, removeRulesOwner, remainingRulesOwners } from './rules-owners.mjs';
-
-async function removeEmpty(directory) {
-  try {
-    if ((await fs.readdir(directory)).length === 0) await fs.rmdir(directory);
-  } catch (err) {
-    if (err.code !== 'ENOENT') throw err;
-  }
-}
-
-async function removeEmptyParents(target, boundary) {
-  let current = path.dirname(target);
-  while (current !== boundary && current.startsWith(`${boundary}${path.sep}`)) {
-    await removeEmpty(current);
-    current = path.dirname(current);
-  }
-}
+import {
+  claudeBoundary,
+  removeEmpty,
+  removeEmptyLayout,
+  removeEmptyParents,
+} from './remove-layout.mjs';
 
 function remainingOwnersText(count) {
   return `${count} other owner${count === 1 ? '' : 's'} ${count === 1 ? 'remains' : 'remain'}`;
@@ -37,6 +33,23 @@ function permissionOutput(host, removed, dryRun) {
   return `${verb} ${removed} permission rule ${plural} from ${host.settingsPath}.`;
 }
 
+function displayFile(file) {
+  return `${file.root}/${file.path}`;
+}
+
+function hookRemovalSpec(host, hook) {
+  const definition = definitionForRecordedHook(hook);
+  const target = recordTarget(host, hook);
+  const full = commandFor(target);
+  const short = `codex-bridge hook ${definition.name}`;
+  return {
+    event: hook.event,
+    matcher: definition.matcher,
+    command: hook.command || full,
+    alternateCommands: [full, short],
+  };
+}
+
 async function uninstallInRun({ host, dryRun = false } = {}) {
   // Preflight before removing the hook: package removal on a broken registry left the host without its watchdog.
   let registry = null;
@@ -50,13 +63,13 @@ async function uninstallInRun({ host, dryRun = false } = {}) {
   const permissionLine = permissionOutput(host, permissionResult.removed, dryRun);
   const record = await readInstallRecord(host);
   const preservation = `Run artifacts in ${path.join(host.root, 'codex-runs')} and the run `
-    + `configuration in ${path.join(host.agentsDir, 'run-config.json')} are preserved.`;
+    + `configuration in ${host.brandConfigPath} are preserved.`;
   if (!record) {
     return { exitCode: 1, output: `${permissionLine}\ncodex-bridge is not installed.\n${preservation}` };
   }
 
   if (dryRun) {
-    const lines = [permissionLine, ...record.files.map((file) => `Would remove ${file}`)];
+    const lines = [permissionLine, ...record.files.map((file) => `Would remove ${displayFile(file)}`)];
     if (record.rules) {
       if (registryError) {
         lines.push(`Would leave ${record.rules.path} because the rules ownership registry is invalid; ownership is unknown.`);
@@ -81,19 +94,15 @@ async function uninstallInRun({ host, dryRun = false } = {}) {
       const definition = definitionForRecordedHook(hook);
       lines.push(`Would remove the ${hook.event} hook for matcher ${definition.matcher}.`);
     }
-    lines.push('Would remove the installation record.');
+    lines.push('Would remove the installation record from the brand root.');
     lines.push(preservation);
     return { exitCode: 0, output: lines.join('\n') };
   }
 
   for (const hook of record.hooks) {
-    const definition = definitionForRecordedHook(hook);
-    const target = path.join(host.root, hook.path);
-    await removeHook(host.settingsPath, {
-      event: hook.event,
-      matcher: definition.matcher,
-      command: commandFor(target),
-    }, { createdGroup: hook.createdGroup === true });
+    await removeHook(host.settingsPath, hookRemovalSpec(host, hook), {
+      createdGroup: hook.createdGroup === true,
+    });
   }
   let ownership = null;
   if (!registryError) {
@@ -123,18 +132,24 @@ async function uninstallInRun({ host, dryRun = false } = {}) {
       }
     }
   }
-  for (const relative of record.files) {
-    const target = path.join(host.root, relative);
+  for (const file of record.files) {
+    const target = recordTarget(host, file);
     await fs.rm(target, { force: true });
-    const boundary = target.startsWith(`${host.commandsDir}${path.sep}`) ? host.commandsDir : host.agentsDir;
+    const boundary = file.root === 'brand'
+      ? host.brandRoot
+      : claudeBoundary(host, target);
     await removeEmptyParents(target, boundary);
   }
   await removeEmpty(host.commandsDir);
   await fs.rm(installRecordPath(host), { force: true });
+  await fs.rm(legacyInstallRecordPath(host), { force: true });
   await removeEmpty(host.agentsDir);
+  await removeEmptyLayout(host.legacyAgentsDir);
+  await removeEmptyLayout(host.legacyCommandsDir);
+  await removeEmpty(host.brandRoot);
   return {
     exitCode: 0,
-    output: [`Uninstalled codex-bridge.`, permissionLine, ...rulesOutput, preservation].join('\n'),
+    output: ['Uninstalled codex-bridge.', permissionLine, ...rulesOutput, preservation].join('\n'),
   };
 }
 

package/cli/update.mjs

@@ -1,4 +1,4 @@
-/** Updates a recorded codex-bridge installation without overwriting unapproved host changes. */
+/** Updates a recorded installation without overwriting unapproved host changes. */
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { install } from './install.mjs';
@@ -7,14 +7,26 @@ import {
   fileFingerprint,
   HOOK_DEFINITIONS,
   installedHookPath,
+  legacyInstallRecordPath,
   packageInfo,
+  recordFileKey,
   readInstallRecord,
   recordMatchesPackage,
+  recordTarget,
   rulesPlan,
 } from './manifest.mjs';
 import { targetMatches } from './copy.mjs';
-import { commandFor, inspectHook } from './settings-merge.mjs';
+import { hookTargets } from './hook-targets.mjs';
+import { definitionForRecordedHook, fileEntry, fingerprintFor } from './install-record.mjs';
+import {
+  commandFor,
+  hookRegistration,
+  inspectHook,
+  removeHook,
+  withSettingsRun,
+} from './settings-merge.mjs';
 import { addRulesOwner, readRulesRegistry } from './rules-owners.mjs';
+import { claudeBoundary, removeEmptyLayout, removeEmptyParents } from './remove-layout.mjs';
 
 async function exists(target) {
   try {
@@ -25,7 +37,19 @@ async function exists(target) {
   }
 }
 
-function classifyPlanned(state, record) {
+/** Drops the previous layout's record and its emptied directories; safe to run when both are gone. */
+async function retireLegacyLayout(host) {
+  await fs.rm(legacyInstallRecordPath(host), { force: true });
+  await removeEmptyLayout(host.legacyAgentsDir);
+  await removeEmptyLayout(host.legacyCommandsDir);
+}
+
+function displayFile(file) {
+  const entry = fileEntry(file);
+  return `${entry.root}/${entry.path}`;
+}
+
+function classifyPlanned(state) {
   if (!state.recorded) return 'new';
   if (!state.exists) return 'missing';
   if (state.matchesPackage) return 'up-to-date';
@@ -33,40 +57,24 @@ function classifyPlanned(state, record) {
   return 'modified';
 }
 
-function classifyOrphan(state, record) {
+function classifyOrphan(state) {
   if (!state.exists) return 'orphaned';
-  if (record.fingerprints?.[state.relative] === state.fingerprint) return 'orphaned';
+  if (state.recordedFingerprint === state.fingerprint) return 'orphaned';
   return 'modified';
 }
 
-function hookTargets(host) {
-  return HOOK_DEFINITIONS.map((definition) => {
-    const target = installedHookPath(host, definition);
-    return {
-      definition,
-      relative: path.relative(host.root, target).split(path.sep).join('/'),
-      spec: { event: definition.event, matcher: definition.matcher, command: commandFor(target) },
-    };
-  });
-}
-
 function recordHasHooks(record, targets) {
   return Boolean(record)
     && targets.every(({ definition, relative }) => record.hooks?.some((hook) =>
-      hook.event === definition.event && hook.path === relative));
+      hook.event === definition.event && hook.root === 'brand' && hook.path === relative));
 }
 
-/**
- * What the run actually did, counted by outcome. `Updated codex-bridge.` alone told the operator
- * nothing about the files that were rewritten or removed on their behalf.
- */
 function appliedOutput(states) {
   const count = (status) => states.filter((state) => state.status === status).length;
   const parts = [
     [count('outdated'), 'updated'],
     [count('new'), 'added'],
     [count('missing'), 'restored'],
-    // A modified orphan is preserved rather than rewritten, so it is not counted here.
     [states.filter((state) => state.status === 'modified' && state.item).length, 'overwritten'],
     [states.filter((state) => state.status === 'orphaned' && state.exists).length, 'removed'],
   ].filter(([total]) => total > 0).map(([total, label]) => `${total} ${label}`);
@@ -81,7 +89,7 @@ function conflictOutput(conflicts, legacy, dryRun) {
   return [heading, ...lines].join('\n');
 }
 
-function dryRunOutput(states, hookStates, legacy) {
+function dryRunOutput(states, hookStates, legacy, oldHooks) {
   const lines = [];
   for (const state of states) {
     if (state.status === 'outdated') lines.push(`Would update ${state.relative}.`);
@@ -91,18 +99,47 @@ function dryRunOutput(states, hookStates, legacy) {
     if (state.status === 'orphaned' && state.exists) lines.push(`Would remove ${state.relative}.`);
     if (state.status === 'modified' && !state.item) lines.push(`Would preserve modified orphan ${state.relative}.`);
   }
+  // previousHooks() returns {hook, definition, spec}, and reading .event off that wrapper printed
+  // "the previous undefined hook registration" five times during the Plan_25 migration — the one
+  // dry run where the operator most needed to see which registrations were about to be taken away.
+  oldHooks.forEach(({ hook, definition }) => lines.push(
+    `Would remove the previous ${hook.event} hook registration for matcher ${definition.matcher}.`,
+  ));
   hookStates.forEach(({ state, target }) => {
-    const { definition } = target;
-    if (!state.present) lines.push(`Would register ${definition.event} hook for matcher ${definition.matcher}.`);
+    const { definition, registration } = target;
+    if (!state.present) {
+      lines.push(`Would register ${definition.event} hook for matcher ${definition.matcher} with ${registration.form} command.`);
+    }
   });
-  lines.push('Would write installation record with new fingerprints.');
+  lines.push('Would write installation record with new fingerprints in both roots.');
   if (legacy && states.some((state) => state.status === 'modified')) {
     lines.push('Installation record has no fingerprints; differing files are treated as modified.');
   }
   return lines.join('\n');
 }
 
-export async function update({ host, dryRun = false, force = false, packageRoot } = {}) {
+function previousHooks(host, record, targets) {
+  return record.hooks.filter((hook) => {
+    const current = targets.find(({ definition, relative }) =>
+      definition.event === hook.event && hook.root === 'brand' && relative === hook.path);
+    return !current;
+  }).map((hook) => {
+    const definition = definitionForRecordedHook(hook);
+    const target = recordTarget(host, hook);
+    return {
+      hook,
+      definition,
+      spec: {
+        event: hook.event,
+        matcher: definition.matcher,
+        command: hook.command || commandFor(target),
+        alternateCommands: [commandFor(target), `codex-bridge hook ${definition.name}`],
+      },
+    };
+  });
+}
+
+async function updateInRun({ host, dryRun = false, force = false, packageRoot, env = process.env } = {}) {
   await readRulesRegistry(host);
   const record = await readInstallRecord(host);
   if (!record) {
@@ -111,20 +148,20 @@ export async function update({ host, dryRun = false, force = false, packageRoot
 
   const plan = await buildInstallPlan(host, packageRoot);
   const rule = { ...rulesPlan(host, packageRoot), processing: 'copy' };
-  const planned = new Map(plan.map((item) => [item.relativeToHost, item]));
+  const planned = new Map(plan.map((item) => [recordFileKey(item), item]));
   const plannedStates = await Promise.all(plan.map(async (item) => {
-    const relative = item.relativeToHost;
+    const relative = displayFile(item);
     const targetExists = await exists(item.target);
     const state = {
       relative,
       item,
-      recorded: record.files.includes(relative),
-      recordedFingerprint: record.fingerprints?.[relative],
+      recorded: record.files.some((file) => recordFileKey(file) === recordFileKey(item)),
+      recordedFingerprint: fingerprintFor(record, item),
       exists: targetExists,
-      matchesPackage: targetExists && await targetMatches(item, host.agentsDir),
+      matchesPackage: targetExists && await targetMatches(item, host.brandRoot),
       fingerprint: targetExists ? await fileFingerprint(item.target) : null,
     };
-    return { ...state, status: classifyPlanned(state, record) };
+    return { ...state, status: classifyPlanned(state) };
   }));
   const ruleExists = await exists(rule.target);
   const ruleState = {
@@ -133,22 +170,24 @@ export async function update({ host, dryRun = false, force = false, packageRoot
     recorded: Boolean(record.rules),
     recordedFingerprint: record.rules?.fingerprint,
     exists: ruleExists,
-    matchesPackage: ruleExists && await targetMatches(rule, host.agentsDir),
+    matchesPackage: ruleExists && await targetMatches(rule, host.brandRoot),
     fingerprint: ruleExists ? await fileFingerprint(rule.target) : null,
   };
-  ruleState.status = classifyPlanned(ruleState, record);
+  ruleState.status = classifyPlanned(ruleState);
   const orphanStates = await Promise.all(record.files
-    .filter((relative) => !planned.has(relative))
-    .map(async (relative) => {
-      const target = path.join(host.root, relative);
+    .filter((file) => !planned.has(recordFileKey(file)))
+    .map(async (file) => {
+      const target = recordTarget(host, file);
       const targetExists = await exists(target);
       const state = {
-        relative,
+        relative: displayFile(file),
+        entry: fileEntry(file),
         item: null,
         exists: targetExists,
+        recordedFingerprint: fingerprintFor(record, file),
         fingerprint: targetExists ? await fileFingerprint(target) : null,
       };
-      return { ...state, status: classifyOrphan(state, record) };
+      return { ...state, status: classifyOrphan(state) };
     }));
   const states = [...plannedStates, ruleState, ...orphanStates];
   const conflicts = states.filter((state) => state.status === 'modified' || state.status === 'missing');
@@ -157,29 +196,51 @@ export async function update({ host, dryRun = false, force = false, packageRoot
     return { exitCode: 1, output: conflictOutput(conflicts, legacy, dryRun) };
   }
 
-  const targets = hookTargets(host);
+  const currentPackage = await packageInfo(packageRoot);
+  const targets = hookTargets(host, env, currentPackage.version);
   const inspectedHooks = await Promise.all(targets.map(async (target) => ({
     target,
     state: await inspectHook(host.settingsPath, target.spec),
   })));
-  const currentPackage = await packageInfo(packageRoot);
+  const oldHooks = previousHooks(host, record, targets);
   const recordCurrent = recordMatchesPackage(record, plan, currentPackage,
-    new Map(plannedStates.map((state) => [state.relative, state.fingerprint])),
+    new Map(plannedStates.map((state) => [recordFileKey(state.item), state.fingerprint])),
     { path: rule.target, fingerprint: ruleState.fingerprint });
-  const changed = states.some((state) => state.status !== 'up-to-date');
+  const changed = states.some((state) => state.status !== 'up-to-date') || oldHooks.length > 0;
   if (!changed && inspectedHooks.every(({ state }) => state.present)
     && recordHasHooks(record, targets) && recordCurrent) {
-    if (!dryRun) await addRulesOwner(host);
+    if (!dryRun) {
+      await addRulesOwner(host);
+      // An update that installed the new layout but stopped before retiring the old one used to
+      // land here forever after: everything it compares is current, so it reported "up to date"
+      // while agents/codex sat next to agents/codex-bridge. Retirement is idempotent, so running
+      // it on this path costs nothing when there is nothing left to retire.
+      await retireLegacyLayout(host);
+    }
     return { exitCode: 0, output: 'codex-bridge is up to date' };
   }
   if (dryRun) {
-    return { exitCode: 0, output: dryRunOutput(states, inspectedHooks, legacy) };
+    return { exitCode: 0, output: dryRunOutput(states, inspectedHooks, legacy, oldHooks) };
   }
 
   for (const state of orphanStates) {
-    if (state.status === 'orphaned' && state.exists) await fs.rm(path.join(host.root, state.relative));
+    if (state.status !== 'orphaned' || !state.exists) continue;
+    const target = recordTarget(host, state.entry);
+    await fs.rm(target, { force: true });
+    const boundary = state.entry.root === 'brand' ? host.brandRoot : claudeBoundary(host, target);
+    await removeEmptyParents(target, boundary);
+  }
+  for (const { spec, hook } of oldHooks) {
+    await removeHook(host.settingsPath, spec, { createdGroup: hook.createdGroup === true });
   }
-  const installed = await install({ host, force: true, packageRoot });
+  const installed = await install({ host, force: true, packageRoot, env });
   if (installed.exitCode !== 0) return installed;
+  await retireLegacyLayout(host);
   return { exitCode: 0, output: appliedOutput(states) };
 }
+
+export async function update(options = {}) {
+  const host = options?.host;
+  if (!host?.settingsPath) return updateInRun(options);
+  return withSettingsRun(host.settingsPath, () => updateInRun(options));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lyupro/codex-bridge",
-  "version": "0.4.0",
-  "description": "Delegate implementation, reconnaissance and code review from Claude Code to the Codex CLI: dispatcher agents, a runner that survives a dropped call, and a verdict that checks the report against the worktree.",
+  "version": "0.5.1",
+  "description": "Claude Code-to-Codex delegation with 5 guards, 604 tests, zero runtime dependencies, and zero build steps.",
   "keywords": [
     "claude-code",
     "codex",

package/scripts/isolated-roots.mjs

@@ -0,0 +1,13 @@
+/** Names every root outside the repository that the suite must never run against for real. */
+
+/**
+ * A fixture that does not name a root falls back to one of these variables, so the suite runner
+ * replaces all of them and the isolation test asserts each one. Two incidents put entries here:
+ * `~/.codex` collected a rules file on 2026-08-03, and `~/.lyupro/.codex-bridge` collected a
+ * config, conventions and an obsolete-file fixture on 2026-08-11, where the stray config then
+ * stood in the way of the seeded-file migration the release was about.
+ *
+ * It sits in its own module because the isolation test imports it, and importing the runner would
+ * start a second suite inside the first.
+ */
+export const ISOLATED_ROOTS = Object.freeze(['CODEX_HOME', 'CODEX_BRIDGE_HOME']);

package/scripts/run-tests.mjs

@@ -1,26 +1,36 @@
 /**
- * Runs the test suite with a Codex home of its own.
+ * Runs the test suite with every root it can install into replaced by a throwaway one.
  *
  * The installer writes its execpolicy file under `$CODEX_HOME/rules`, so a test that builds a host
  * without naming a Codex home installs into the real one: on 2026-08-03 the suite dropped
  * `codex-bridge.rules` into the operator's `~/.codex/rules/` and the next run failed on the file it
  * had left behind. Passing the isolation through the one command that starts the suite is what
  * makes it unforgettable — a fixture can omit it, this cannot.
+ *
+ * Plan_25 gave the package a second root outside the repository, and this file was not extended
+ * with it: on 2026-08-11 the suite wrote config.json, conventions.md and a lib/obsolete.txt fixture
+ * straight into the operator's real `~/.lyupro/.codex-bridge/`, where the stray config then stood
+ * in the way of the very migration the release was about. Roots live in one list here so a third
+ * one cannot be added without this file being the place it is declared.
  */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { ISOLATED_ROOTS } from './isolated-roots.mjs';
 
-const codexHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-bridge-test-home-'));
+const created = ISOLATED_ROOTS.map((name) => [
+  name,
+  fs.mkdtempSync(path.join(os.tmpdir(), `codex-bridge-test-${name.toLowerCase()}-`)),
+]);
 const pattern = process.argv[2] || 'tests/**/*.test.mjs';
 
 try {
   const result = spawnSync(process.execPath, ['--test', pattern], {
     stdio: 'inherit',
-    env: { ...process.env, CODEX_HOME: codexHome },
+    env: { ...process.env, ...Object.fromEntries(created) },
   });
   process.exitCode = result.status ?? 1;
 } finally {
-  fs.rmSync(codexHome, { recursive: true, force: true });
+  for (const [, directory] of created) fs.rmSync(directory, { recursive: true, force: true });
 }

package/src/agents/codex-build.md

@@ -1,6 +1,6 @@
 ---
 name: codex-build
-description: Имплементация ВНЕ подписки Claude — правки кода, новые модули, рефакторинг по образцу, починка тестов. Работу выполняет Codex CLI (подписка ChatGPT) с правом записи в репозиторий строго в пределах обязательного `scope`, Claude платит только за постановку задачи и ≤5 строк выжимки. Отчёт и полный лог кладёт в ~/.claude/codex-runs/, в чат — короткая выжимка + путь. Ревью и приёмку делает отдельный агент Claude, не этот. {{CODEX_REQUIRED_INPUTS_SUMMARY}}
+description: Имплементация ВНЕ подписки Claude — правки кода, новые модули, рефакторинг по образцу, починка тестов. Работу выполняет Codex CLI (подписка ChatGPT) с правом записи в репозиторий строго в пределах обязательного `scope`, Claude платит только за постановку задачи и ≤5 строк выжимки. Отчёт и полный лог кладёт в ~/.claude/codex-runs/, в чат — короткая выжимка + путь. Ревью и приёмку делает отдельный агент Claude, не этот. {{CODEX_REQUIRED_INPUTS_SUMMARY}} {{CODEX_STOP_SUMMARY}}
 model: haiku
 tools: Bash
 ---
@@ -35,15 +35,15 @@ job is to report the run status honestly, including failure.
   reuse an order id from another order — the runner chains runs by that label, and a made-up label
   is how a repeat run hides. If the orchestrator did not give a required input, do not guess: start
   the runner without its flag and return the runner's refusal exactly.
-- `continue` — pass the `--continue` flag only when the orchestrator gave the matching `continue:`
-  grant explicitly; do not add or guess it yourself. A continuation is assigned by the
-  orchestrator, never chosen by you. After the verdict, return the exact attaching output and stop;
-  do not issue or invent another continuation. The contract is the same kind as `--scope`: if this
-  task (the same `slug` and the same repository) already had a run, the runner will refuse to start
-  without `--continue` — before starting Codex, so no quota is spent. If the orchestrator did not
-  grant a repeat, return the runner's refusal exactly.
-- Optional: `effort: <none|minimal|low|medium|high|xhigh|max>`, `slug:`, `verify: <verification
-  command>` (for example `npm test`, `tsc --noEmit`).
+- `continue` — when the task text contains a line beginning with the `continue:` label, pass the
+  bare `--continue` flag even when its run name or reason looks malformed. Do not inspect, repair,
+  or swallow this grant; pass it through and let the runner issue the refusal. A continuation is
+  assigned by the orchestrator, never chosen by you. After the verdict, return the exact attaching
+  output and stop; do not issue or invent another continuation. If no such grant line is present,
+  the flag must not be present.
+- Optional: `effort: <none|minimal|low|medium|high|xhigh|max>`, `slug:` (by default, the slug is
+  taken from the order id), `verify: <verification command>` (for example `npm test`,
+  `tsc --noEmit`).
 
 ## The only thing you do
 
@@ -61,8 +61,10 @@ Add `--effort "<value>"` only when the orchestrator named a depth, and only with
 decides, which is the intended default — a placeholder copied from this template is refused before
 Codex starts.
 
-If the orchestrator gave the matching `continue:` grant, add the bare `--continue` flag to the
-command, with no value.
+If the task text contains a line beginning with the `continue:` label, add the bare `--continue`
+flag even when its run name or reason looks malformed. Do not inspect, repair, or swallow the line;
+the runner parses it and issues the refusal. If no such grant line is present, the flag must not be
+present in the command.
 No value
 is passed to it: the runner accepts only `1/true/yes/0/false/no`, while a placeholder string left in
 the
@@ -132,7 +134,7 @@ are designed for interactive work and cause harm in a delegated run — a failin
 and the task
 was not done; without them, 23k and the task was done. The flags affect one call; `~/.codex` is
 unchanged.
-The operator switches the mode through `/codex:env` (file `agents/codex/run-config.json`), and it
+The operator switches the mode through `/codex-bridge:env` (file `~/.lyupro/.codex-bridge/config.json`), and it
 is recorded in the run's `meta.json` — do not guess it or add flags yourself.
 `--dangerously-bypass-approvals-and-sandbox` is never used. `--model` is not
 passed: model IDs are volatile. The script fixes this once, so silent

package/src/agents/codex-review.md

@@ -1,6 +1,6 @@
 ---
 name: codex-review
-description: Независимое второе мнение по коду от другой модели — ревью незакоммиченных правок, ветки или коммита силами Codex CLI (подписка ChatGPT). Не заменяет приёмку на стороне Claude, а дополняет её взглядом со стороны. Выдаёт строгий JSON с severity и confidence по каждой находке, в чат — ≤5 строк со счётчиком по важности. {{CODEX_REQUIRED_INPUTS_SUMMARY}}
+description: Независимое второе мнение по коду от другой модели — ревью незакоммиченных правок, ветки или коммита силами Codex CLI (подписка ChatGPT). Не заменяет приёмку на стороне Claude, а дополняет её взглядом со стороны. Выдаёт строгий JSON с severity и confidence по каждой находке, в чат — ≤5 строк со счётчиком по важности. {{CODEX_REQUIRED_INPUTS_SUMMARY}} {{CODEX_STOP_SUMMARY}}
 model: haiku
 tools: Bash
 ---
@@ -34,12 +34,14 @@ opinion, not a verdict.
   another order — the runner chains runs by that label, and a made-up label is how a repeat run
   hides. If the orchestrator did not give a required input, do not guess — start the runner without
   its flag and return the runner's refusal verbatim.
-- `continue` is conditional — pass the `--continue` flag only when the orchestrator gave the
-  matching `continue:` grant explicitly; do not add or guess it yourself. A continuation is
+- `continue` — when the task text contains a line beginning with the `continue:` label, pass the
+  bare `--continue` flag even when its run name or reason looks malformed. Do not inspect, repair,
+  or swallow this grant; pass it through and let the runner issue the refusal. A continuation is
   assigned by the orchestrator, never chosen by you. After the verdict, return the exact attaching
-  output and stop; do not issue or invent another continuation.
-- Optional: review focus as text ("look for races and error handling"), `slug:`, `effort:
-  <none|minimal|low|medium|high|xhigh|max>`.
+  output and stop; do not issue or invent another continuation. If no such grant line is present,
+  the flag must not be present.
+- Optional: review focus as text ("look for races and error handling"), `slug:` (by default, the
+  slug is taken from the order id), `effort: <none|minimal|low|medium|high|xhigh|max>`.
 
 ## The only thing you do
 
@@ -61,8 +63,10 @@ line. To get the verdict, run the **identical command a second time** — same `
 `--slug`, same flags. That second call does not start a second run and costs no quota: it attaches
 to the run already in flight, prints `ATTACH=<path>`, blocks until the verdict exists and prints it.
 
-If the orchestrator gave the matching `continue:` grant, add the bare `--continue` flag to the
-command, with no value. If it was not given, the flag must not be present in the command at all.
+If the task text contains a line beginning with the `continue:` label, add the bare `--continue`
+flag even when its run name or reason looks malformed. Do not inspect, repair, or swallow the line;
+the runner parses it and issues the refusal. If no such grant line is present, the flag must not be
+present in the command at all.
 
 Background execution (`run_in_background`, `&`, `nohup`) is prohibited. Interruption is no longer a
 problem worth handling: if the attaching call is killed by a time ceiling, repeat it — every repeat
@@ -114,7 +118,7 @@ properties that broke the contract.
 Regular `codex exec` follows the schema (verified during scouting), so the review uses it: with
 `--ignore-user-config` (structurally read-only, half the startup ballast), `--sandbox
 read-only`, `--disable hooks --disable plugins` (operator extensions do not affect the run;
-the default, switched through `/codex:env`), and without `--model` — model IDs are volatile. The
+the default, switched through `/codex-bridge:env`), and without `--model` — model IDs are volatile. The
 runner determines the review scope
 itself through git: the exact file list and diff command go into the prompt and are saved in the run
 folder's