halfcycle 0.4.17 → 0.5.0

package/dist/cli.js

@@ -493,6 +493,7 @@ var TASK_PLAN_FILE = "docs/build-records/task-plan.json";
 var TASK_LIST_FILE = "docs/build-records/build-tasks.json";
 var TASK_PLAN_TASKS_MAX = 500;
 var TASK_PLAN_ID_MAX = 64;
+var TASK_PLAN_BUILDS_NONE = "none";
 var TASK_PLAN_KINDS = ["build", "review", "spec", "walk", "check"];
 var TASK_PLAN_INTERFACE_KINDS = [
   "route",
@@ -517,7 +518,8 @@ var taskPlanTaskSchema = z2.object({
     interfaces: z2.array(planText).optional()
   }).strict().optional(),
   wholeProject: z2.literal(true).optional(),
-  ships: z2.enum(["deploy", "release"]).optional()
+  ships: z2.enum(["deploy", "release"]).optional(),
+  builds: z2.union([z2.literal(TASK_PLAN_BUILDS_NONE), z2.array(planText)]).optional()
 }).strict().superRefine((task, ctx) => {
   if (task.reviews !== void 0 && task.kind !== "review") {
     ctx.addIssue({
@@ -564,6 +566,7 @@ var taskPlanLineText = {
   O5: (difference) => `The task list in ${TASK_LIST_FILE} does not match the plan: ${difference}. Make the two agree, then run this again.`,
   N1: (asked) => `The task list in ${TASK_LIST_FILE} is not for "${asked}", so it was not compared.`,
   O6: (phase, asked) => `The plan is for "${phase}", not "${asked}".`,
+  O7: (a, file, partIds) => `"${a}" does not say which parts of the system it builds. Add "builds" with the ids of the parts it builds, from ${file}: ${partIds.join(", ")}. If it builds none of them, write "builds": "${TASK_PLAN_BUILDS_NONE}".`,
   K1: (a) => `"${a}" is in no batch: no whole-project check waits for it. Add it to the dependsOn of the first whole-project check that it does not already wait for and that waits for every build task it waits for, or add a whole-project check after it.`,
   K2: (a, b) => `"${a}" and "${b}" are both whole-project checks and neither waits for the other. Make the later one wait for the earlier.`,
   K3: (b, a, c) => `"${b}" builds on "${a}" before "${c}" has checked it. Add "${c}" to the dependsOn of "${b}".`,
@@ -810,6 +813,12 @@ function refusal(code, text) {
 function isBuildTask(task) {
   return task.kind === "build" && ((task.touches?.files?.length ?? 0) > 0 || (task.touches?.interfaces?.length ?? 0) > 0);
 }
+function mustNameParts(task) {
+  return task.kind === "build" && task.heldBy === void 0 && task.ships === void 0;
+}
+function namesNoPart(task) {
+  return task.builds === void 0 || Array.isArray(task.builds) && task.builds.length === 0;
+}
 function isWholeProjectCheck(task) {
   return task.kind === "check" && task.wholeProject === true;
 }
@@ -944,6 +953,7 @@ function checkTaskPlan(plan, request) {
   }
   const tasks = plan.tasks;
   const lines = [];
+  const system = request.system;
   const ids = new Set(tasks.map((task) => task.id));
   const seen = /* @__PURE__ */ new Set();
   const reportedTwice = /* @__PURE__ */ new Set();
@@ -981,6 +991,9 @@ function checkTaskPlan(plan, request) {
         }
       }
     }
+    if (system !== void 0 && system.partIds.length > 0 && mustNameParts(task) && namesNoPart(task)) {
+      lines.push(refusal("O7", taskPlanLineText.O7(task.id, system.file, system.partIds)));
+    }
   }
   const { before, cycles } = waitsFor(tasks);
   for (const path of cycles)
@@ -1019,6 +1032,101 @@ function checkTaskPlan(plan, request) {
   return { lines, refused: refused3 };
 }
 
+// ../core/dist/agent-profile.js
+var AGENT_IDS = ["claude-code", "codex"];
+var CLAUDE_CODE_PROFILE = {
+  id: "claude-code",
+  settingsFiles: [SETTINGS_REL, LOCAL_SETTINGS_REL],
+  wiring: HALFCYCLE_HOOK_WIRING,
+  commands: HALFCYCLE_HOOK_COMMANDS,
+  wiringPaths: HALFCYCLE_HOOK_WIRING_PATHS,
+  writeCapableTools: WRITE_CAPABLE_TOOLS,
+  projectRoot: "claude-project-dir",
+  configFolder: "claude-config",
+  mcpRegistration: { file: MCP_REGISTRATION_REL, serversKey: "mcpServers", serverKey: MCP_SERVER_KEY },
+  tierModels: {
+    deep: { model: "opus" },
+    standard: { model: "sonnet" },
+    fast: { model: "haiku" }
+  }
+};
+var CODEX_HOOKS_REL = ".codex/hooks.json";
+var CODEX_CONFIG_REL = ".codex/config.toml";
+function codexHookCommand(script, args2) {
+  const invocation = `cd "$(git rev-parse --show-toplevel)" && bash ./${script}`;
+  return args2 === void 0 ? invocation : `${invocation} ${args2}`;
+}
+var CODEX_WINDOWS_NOT_SET_UP = "Halfcycle checks did not run because Halfcycle is not set up in this folder or any folder above it; run npx halfcycle in the project folder.";
+var CODEX_WINDOWS_NO_GIT_BASH = "Halfcycle checks did not run because Git for Windows was not found; install Git for Windows, then open a new session.";
+function codexHookCommandWindows(script, args2) {
+  const tick = (text) => "`" + text + "`";
+  const argv = [script, ...args2 === void 0 ? [] : args2.split(" ")].map(tick).join(",");
+  const program = [
+    "const p=require(`path`),f=require(`fs`),c=require(`child_process`);",
+    "let d=process.cwd();",
+    `for(;;){if(f.existsSync(p.join(d,${tick(VENDORED_BIN_REL)})))break;`,
+    "const u=p.dirname(d);",
+    "if(u===d){d=``;break}",
+    "d=u}",
+    `if(d===\`\`){console.error(${tick(CODEX_WINDOWS_NOT_SET_UP)})}else{`,
+    "const g=c.spawnSync(`git`,[`--exec-path`],{encoding:`utf8`});",
+    "const b=g.status===0?p.join(g.stdout.trim(),`..`,`..`,`..`,`bin`,`bash.exe`):``;",
+    `if(b===\`\`||!f.existsSync(b)){console.error(${tick(CODEX_WINDOWS_NO_GIT_BASH)})}else{`,
+    `const r=c.spawnSync(b,[${argv}],{cwd:d,stdio:\`inherit\`});`,
+    "process.exitCode=typeof r.status===`number`?r.status:1}}"
+  ].join("");
+  return `node -e '${program}'`;
+}
+function codexHookRow(event, matcher, timeout, script, args2) {
+  return {
+    event,
+    matcher,
+    timeout,
+    command: codexHookCommand(script, args2),
+    script,
+    commandWindows: codexHookCommandWindows(script, args2)
+  };
+}
+var CODEX_WRITE_CAPABLE_TOOLS = ["apply_patch", "Edit", "Write"];
+var CODEX_PRE_TOOL_USE_MATCHER = "^(Bash|apply_patch)$";
+var CODEX_HOOK_WIRING = [
+  codexHookRow("SessionStart", null, 5, SESSION_START_MARKER_REL),
+  codexHookRow("SessionStart", null, 10, GUARD_RUNNER_REL, "refresh-credential --agent codex"),
+  codexHookRow("UserPromptSubmit", null, 5, USER_PROMPT_REMINDER_REL),
+  codexHookRow("UserPromptSubmit", null, 10, USER_PROMPT_SCOPE_REL, "--agent codex"),
+  codexHookRow("UserPromptSubmit", null, 10, USER_PROMPT_FINDINGS_REL, "--agent codex"),
+  codexHookRow("PreToolUse", CODEX_PRE_TOOL_USE_MATCHER, 10, GUARD_RUNNER_REL, "hook pre-tool-use --agent codex"),
+  codexHookRow("PostToolUse", CODEX_WRITE_CAPABLE_TOOLS.join("|"), 60, GUARD_RUNNER_REL, "hook post-tool-use --agent codex"),
+  codexHookRow("Stop", null, 60, GUARD_RUNNER_REL, "hook stop --agent codex"),
+  codexHookRow("SubagentStop", null, 60, GUARD_RUNNER_REL, "hook subagent-stop --agent codex"),
+  codexHookRow("SessionEnd", null, 3, SESSION_END_MARKER_REL)
+];
+var RETIRED_CODEX_HOOK_COMMANDS = [];
+function codexHookCommandSet(retired) {
+  return /* @__PURE__ */ new Set([...CODEX_HOOK_WIRING.map((entry) => entry.command), ...retired]);
+}
+var CODEX_PROFILE = {
+  id: "codex",
+  settingsFiles: [CODEX_HOOKS_REL],
+  wiring: CODEX_HOOK_WIRING,
+  commands: codexHookCommandSet(RETIRED_CODEX_HOOK_COMMANDS),
+  wiringPaths: [.../* @__PURE__ */ new Set([CODEX_HOOKS_REL, ...CODEX_HOOK_WIRING.map((entry) => entry.script), VENDORED_BIN_REL])],
+  writeCapableTools: CODEX_WRITE_CAPABLE_TOOLS,
+  projectRoot: "git-toplevel",
+  configFolder: "codex-home",
+  mcpRegistration: { file: CODEX_CONFIG_REL, serversKey: "mcp_servers", serverKey: MCP_SERVER_KEY },
+  tierModels: {
+    deep: { model: "gpt-6-luna", effort: "high" },
+    standard: { model: "gpt-6-luna", effort: "medium" },
+    fast: { model: "gpt-6-luna", effort: "low" }
+  }
+};
+var AGENT_PROFILES = {
+  "claude-code": CLAUDE_CODE_PROFILE,
+  codex: CODEX_PROFILE
+};
+var ALL_HOOK_COMMANDS = new Set(AGENT_IDS.flatMap((id) => [...AGENT_PROFILES[id].commands]));
+
 // ../events/dist/result.js
 import { z as z3 } from "zod";
 var firedGuardSchema = z3.object({
@@ -2102,7 +2210,10 @@ var buildSnapshotReportResultSchema = z8.object({
   // Which phase the graph was recorded against.
   phase: buildPhaseSchema,
   // When it was recorded.
-  reportedAt: utcIso8601
+  reportedAt: utcIso8601,
+  // One sentence to pass on to the developer about the graph just stored. Absent
+  // when there is nothing to say.
+  warning: z8.string().min(1).max(400).optional()
 }).strict();
 
 // ../events/dist/phase-plan.js
@@ -4851,7 +4962,8 @@ var chatReviewAcceptRequestSchema = z30.object({
   act: z30.literal("accept"),
   reference: phaseIdentitySchema,
   reviewVersion: z30.number().int().min(0),
-  parts: z30.array(systemPartIdSchema).max(REVIEW_PARTS_MAX)
+  parts: z30.array(systemPartIdSchema).max(REVIEW_PARTS_MAX),
+  waitingClaims: z30.literal(true).optional()
 }).strict();
 function notedRequest(act) {
   return z30.object({
@@ -4866,12 +4978,20 @@ var chatReviewQuestionRequestSchema = notedRequest("question");
 var chatReviewSendBackRequestSchema = notedRequest("send-back");
 var chatReviewCarryRequestSchema = notedRequest("carry");
 var chatReviewDropRequestSchema = notedRequest("drop");
+var chatReviewRejectRequestSchema = z30.object({
+  act: z30.literal("reject"),
+  reference: phaseIdentitySchema,
+  reviewVersion: z30.number().int().min(0),
+  task: buildTaskIdSchema,
+  note: reviewNoteWireSchema
+}).strict();
 var chatReviewRequestSchema = z30.discriminatedUnion("act", [
   chatReviewAcceptRequestSchema,
   chatReviewQuestionRequestSchema,
   chatReviewSendBackRequestSchema,
   chatReviewCarryRequestSchema,
-  chatReviewDropRequestSchema
+  chatReviewDropRequestSchema,
+  chatReviewRejectRequestSchema
 ]);
 function bareOutcome2(outcome) {
   return z30.object({ outcome: z30.literal(outcome) }).strict();
@@ -4884,7 +5004,8 @@ var chatReviewResultSchema = z30.discriminatedUnion("outcome", [
   ...reviewDecisionResultSchema.options.filter(notTheConsoleNotDecidable),
   bareOutcome2("show-first"),
   bareOutcome2("not-offered"),
-  chatAmbiguousSchema
+  chatAmbiguousSchema,
+  bareOutcome2("nothing-waiting")
 ]);
 var reviewAnswerRequestSchema = z30.object({
   part: systemPartIdSchema,
@@ -5348,8 +5469,8 @@ function autonomyA13(accepted, carried) {
   return `Your autonomy setting accepted the ${String(accepted)} built parts and carried ${String(carried)} unbuilt parts forward. The phase is closed.`;
 }
 function autonomyA14(count, parts, acceptLine) {
-  const typed = acceptLine === null ? 'say "review what was built" and type the lines it gives.' : `say "review what was built", then type ${acceptLine}.`;
-  return `The phase waits for you: ${String(count)} tests the agents said pass were not run by Halfcycle, so ${namesOf(parts)} wait for you too. Only you can accept or reject those tests, in the console's review; that cannot be done by typing in chat. Then decide those parts there, or in your own Claude Code session: ` + typed;
+  const typed = acceptLine === null ? 'say "review what was built" and type the lines it gives.' : `say "review what was built", then type ${acceptLine} to accept them with those parts, or type the reject line it gives for a task's tests.`;
+  return `The phase waits for you: ${String(count)} tests the agents said pass were not run by Halfcycle, so ${namesOf(parts)} wait for you too. Only you can accept or reject those tests. In your own Claude Code session, ` + typed;
 }
 function autonomyA15(count) {
   return `The phase waits for you: ${String(count)} parts were built without an approved scope, and only you can decide them.`;
@@ -5853,7 +5974,14 @@ function serializeManifest(manifest) {
     files: [...manifest.files].sort((a, b) => byString(a.path, b.path)),
     createdDirs: [...manifest.createdDirs].sort(byString),
     leftAlone: [...manifest.leftAlone].sort(byString),
-    settings
+    settings,
+    ...manifest.codexHooks !== void 0 ? {
+      codexHooks: {
+        ...manifest.codexHooks,
+        hookCommands: [...manifest.codexHooks.hookCommands].sort(byString),
+        eventsCreated: [...manifest.codexHooks.eventsCreated].sort(byString)
+      }
+    } : {}
   };
   return JSON.stringify(canonicalJson2(ordered), null, 2) + "\n";
 }
@@ -5907,7 +6035,7 @@ function parseManifest(text) {
   }
   if (!isRecord2(raw))
     throw new UnreadableManifestError("it is not a JSON object");
-  onlyKeys(raw, ["format", "files", "createdDirs", "leftAlone", "settings", "mcp", "gitignore", "gitattributes"], "the manifest");
+  onlyKeys(raw, ["format", "files", "createdDirs", "leftAlone", "settings", "mcp", "codexHooks", "codexConfig", "gitignore", "gitattributes"], "the manifest");
   if (raw["format"] !== INSTALL_MANIFEST_FORMAT) {
     throw new UnreadableManifestError(`its format is not ${INSTALL_MANIFEST_FORMAT}`);
   }
@@ -5973,6 +6101,30 @@ function parseManifest(text) {
       ...typeof m["entrySha256"] === "string" ? { entrySha256: m["entrySha256"] } : {}
     };
   }
+  let codexHooks;
+  if (raw["codexHooks"] !== void 0) {
+    const c = raw["codexHooks"];
+    if (!isRecord2(c))
+      throw new UnreadableManifestError('"codexHooks" is not an object');
+    onlyKeys(c, ["created", "adopted", "hookCommands", "eventsCreated", "hooksCreated"], '"codexHooks"');
+    codexHooks = {
+      created: bool(c["created"], "codexHooks.created"),
+      adopted: bool(c["adopted"], "codexHooks.adopted"),
+      hookCommands: stringArray(c["hookCommands"], "codexHooks.hookCommands"),
+      eventsCreated: stringArray(c["eventsCreated"], "codexHooks.eventsCreated"),
+      hooksCreated: bool(c["hooksCreated"], "codexHooks.hooksCreated")
+    };
+  }
+  let codexConfig;
+  if (raw["codexConfig"] !== void 0) {
+    const c = raw["codexConfig"];
+    if (!isRecord2(c))
+      throw new UnreadableManifestError('"codexConfig" is not an object');
+    onlyKeys(c, ["created", "block"], '"codexConfig"');
+    if (typeof c["block"] !== "string")
+      throw new UnreadableManifestError('"codexConfig.block" is not a string');
+    codexConfig = { created: bool(c["created"], "codexConfig.created"), block: c["block"] };
+  }
   if (raw["gitignore"] === void 0)
     throw new UnreadableManifestError('"gitignore" is missing');
   const gitignore = appendedTextRecord(raw["gitignore"], "gitignore");
@@ -5991,6 +6143,8 @@ function parseManifest(text) {
     leftAlone,
     settings,
     ...mcp !== void 0 ? { mcp } : {},
+    ...codexHooks !== void 0 ? { codexHooks } : {},
+    ...codexConfig !== void 0 ? { codexConfig } : {},
     gitignore,
     ...gitattributes !== void 0 ? { gitattributes } : {}
   };
@@ -6008,6 +6162,8 @@ function startManifest(previous, isMember, isMemberDir) {
     createdDirs: new Set((previous?.createdDirs ?? []).filter(isMemberDir)),
     settings: previous?.settings,
     mcp: previous?.mcp,
+    codexHooks: previous?.codexHooks,
+    codexConfig: previous?.codexConfig,
     gitignore: previous?.gitignore,
     gitattributes: previous?.gitattributes
   };
@@ -6068,6 +6224,19 @@ function recordMcp(draft, observed) {
     ...entrySha256 !== void 0 ? { entrySha256 } : {}
   };
 }
+function recordCodexHooks(draft, observed) {
+  const prev = draft.codexHooks;
+  draft.codexHooks = prev === void 0 ? observed : {
+    created: prev.created,
+    adopted: prev.adopted,
+    hookCommands: union(prev.hookCommands, observed.hookCommands),
+    eventsCreated: union(prev.eventsCreated, observed.eventsCreated),
+    hooksCreated: prev.hooksCreated
+  };
+}
+function recordCodexConfig(draft, observed) {
+  draft.codexConfig = { created: draft.codexConfig?.created ?? observed.created, block: observed.block };
+}
 function recordGitignore(draft, created, appended) {
   draft.gitignore = carryAppended(draft.gitignore, created, appended);
 }
@@ -6101,6 +6270,8 @@ function finishManifest(draft) {
       denyCreated: false
     },
     ...draft.mcp !== void 0 ? { mcp: draft.mcp } : {},
+    ...draft.codexHooks !== void 0 ? { codexHooks: draft.codexHooks } : {},
+    ...draft.codexConfig !== void 0 ? { codexConfig: draft.codexConfig } : {},
     gitignore: draft.gitignore ?? { created: false, appended: [] },
     ...draft.gitattributes !== void 0 ? { gitattributes: draft.gitattributes } : {}
   };
@@ -6225,6 +6396,30 @@ var PREVIEW_WORDS = Object.freeze({
     change: "takes out an older Halfcycle sign-in; your own lines stay as they are",
     leave: "an older Halfcycle sign-in that cannot be moved yet; left as it is",
     yours: YOURS
+  },
+  "codex-checks": {
+    add: "Codex's checks, the same ones Halfcycle runs for Claude Code",
+    change: "adds the checks Halfcycle needs; your own entries stay as they are",
+    leave: "already has the checks Halfcycle needs",
+    yours: YOURS
+  },
+  "codex-server": {
+    add: "tells Codex how to reach Halfcycle's service",
+    change: "adds Halfcycle's entry; your own entries stay as they are",
+    leave: "already has Halfcycle's entry",
+    yours: YOURS
+  },
+  skill: {
+    add: "a skill your coding agent can run to take the next Halfcycle step",
+    change: "a newer version of this Halfcycle skill",
+    leave: SAME,
+    yours: YOURS
+  },
+  "crew-profile": {
+    add: "a member of your build crew, so your coding agent shows who is working",
+    change: "a newer version of this build-crew member",
+    leave: SAME,
+    yours: YOURS
   }
 });
 var kindTable;
@@ -6249,13 +6444,21 @@ function kinds() {
     [RETIRED_MCP_HEADERS_HELPER_REL, "halfcycle-folder"],
     [LEGACY_CI_STANZA_REL, "halfcycle-folder"],
     [CAPTURED_INDEX_REL, "captured-index"],
-    [LEGACY_ENV_LOCAL_REL, "old-sign-in"]
+    [LEGACY_ENV_LOCAL_REL, "old-sign-in"],
+    [CODEX_HOOKS_REL2, "codex-checks"],
+    [CODEX_CONFIG_REL2, "codex-server"]
   ]);
   return kindTable;
 }
 function previewKindOf(rel) {
   if (/^\.claude\/commands\/[^/]+\.md$/.test(rel))
     return "command";
+  if (/^\.agents\/skills\/[^/]+\/SKILL\.md$/.test(rel))
+    return "skill";
+  if (/^\.claude\/agents\/[^/]+\.md$/.test(rel))
+    return "crew-profile";
+  if (/^\.codex\/agents\/[^/]+\.toml$/.test(rel))
+    return "crew-profile";
   return kinds().get(rel);
 }
 function kindOf(rel) {
@@ -6281,6 +6484,7 @@ function planInstall(options) {
   const previous = readPreviousManifest(targetRepo);
   const dirsBefore = new Set([...writeSet.dirs].filter((dir) => existsSync3(join5(targetRepo, dir))));
   const { version, commands } = planCommandStubs(targetRepo, previous, writeSet);
+  const codexSkills = planCodexSkills(targetRepo, previous, writeSet);
   const vendored = planVendoredBinary(targetRepo);
   let settings;
   try {
@@ -6294,6 +6498,8 @@ function planInstall(options) {
   const ciStanza = planLegacyCiStanzaRemoval(targetRepo);
   const mcp = planMcpRegistration(targetRepo, preview ? "pending" : credential);
   const mcpHelper = mcp.kind === "none" ? null : planMcpHeadersHelperRemoval(targetRepo);
+  const codexHooks = planCodexHooks(targetRepo);
+  const codexConfig = planCodexConfig(targetRepo, preview ? "pending" : credential);
   const gitignore = planGitignore(targetRepo);
   const gitattributes = planGitattributes(targetRepo);
   const identity = planProjectIdentity(targetRepo);
@@ -6305,6 +6511,7 @@ function planInstall(options) {
   const legacy = migrateLegacyEnvLocal(targetRepo, storedAfter);
   const pin = preview ? planBundlePinPreview(targetRepo, version, home) : planBundlePin(targetRepo, version, engagementId, engagementType, createdByAccountId, credential?.methodVersion);
   const crew = planCrewRoster(targetRepo);
+  const crewProfiles = planCrewProfiles(targetRepo, previous, writeSet);
   const scan = { text: planBootstrapScan(targetRepo).text };
   const steps = {
     targetRepo,
@@ -6317,12 +6524,15 @@ function planInstall(options) {
     previous,
     dirsBefore,
     commands,
+    codexSkills,
     vendored,
     settings,
     hooks,
     ciStanza,
     mcp,
     mcpHelper,
+    codexHooks,
+    codexConfig,
     gitignore,
     gitattributes,
     identity,
@@ -6330,6 +6540,7 @@ function planInstall(options) {
     legacy,
     pin,
     crew,
+    crewProfiles,
     scan
   };
   const record2 = preview ? null : planInstallRecord(targetRepo, accountInstall(steps, predicted(steps)).manifestText);
@@ -6355,16 +6566,24 @@ function predicted(steps) {
       lands(planned.rel, planned.text, planned.outcome === "written");
   };
   steps.commands.forEach(file);
+  steps.codexSkills.forEach(file);
   file(steps.vendored);
   file(steps.settings.file);
   steps.hooks.forEach(file);
   if (steps.mcp.kind === "write")
     lands(MCP_REGISTRATION_REL, steps.mcp.text, steps.mcp.outcome !== "skipped");
+  if (steps.codexHooks.outcome === "written" && steps.codexHooks.text !== null) {
+    lands(CODEX_HOOKS_REL2, steps.codexHooks.text, true);
+  }
+  if (steps.codexConfig.outcome === "written" && steps.codexConfig.text !== null) {
+    lands(CODEX_CONFIG_REL2, steps.codexConfig.text, true);
+  }
   if (steps.identity.after !== null)
     lands(PROJECT_IDENTITY_REL, steps.identity.after, steps.identity.action === "add");
   if (steps.pin !== null)
     file(steps.pin);
   file(steps.crew);
+  steps.crewProfiles.forEach(file);
   if (steps.scan.text !== null)
     lands(BOOTSTRAP_STATE_REL, steps.scan.text, true);
   const mergeAfter = (planned) => planned.outcome === "written" ? planned.after : planned.before;
@@ -6422,6 +6641,7 @@ function entriesOf(steps, record2) {
     entries.push({ path: rel, action: there ? "change" : "add", kind: kindOf(rel), bytes: PENDING });
   };
   steps.commands.forEach(fromFile);
+  steps.codexSkills.forEach(fromFile);
   fromFile(steps.vendored);
   const settings = steps.settings;
   entries.push(settings.file.outcome === "written" ? { path: SETTINGS_REL, action: settings.preexisted ? "change" : "add", kind: "settings", bytes: settings.file.text } : { path: SETTINGS_REL, action: "leave", kind: "settings", bytes: null });
@@ -6437,6 +6657,38 @@ function entriesOf(steps, record2) {
     entries.push({ path: MCP_REGISTRATION_REL, action: "leave", kind: "server-entry", bytes: null });
   }
   retired(RETIRED_MCP_HEADERS_HELPER_REL, steps.mcpHelper);
+  const codexHooks = steps.codexHooks;
+  if (codexHooks.outcome === "written") {
+    entries.push({ path: CODEX_HOOKS_REL2, action: codexHooks.before === null ? "add" : "change", kind: "codex-checks", bytes: codexHooks.text });
+  } else if (codexHooks.outcome === "current") {
+    entries.push({ path: CODEX_HOOKS_REL2, action: "leave", kind: "codex-checks", bytes: null });
+  } else {
+    entries.push({ path: CODEX_HOOKS_REL2, action: "leave", kind: "codex-checks", bytes: null, yours: true });
+  }
+  const codexConfig = steps.codexConfig;
+  switch (codexConfig.outcome) {
+    case "written":
+      entries.push({ path: CODEX_CONFIG_REL2, action: codexConfig.before === null ? "add" : "change", kind: "codex-server", bytes: codexConfig.text });
+      break;
+    case "pending":
+      pending(CODEX_CONFIG_REL2);
+      break;
+    case "current":
+    case "no-credential":
+      entries.push({ path: CODEX_CONFIG_REL2, action: "leave", kind: "codex-server", bytes: null });
+      break;
+    case "conflict":
+    case "link":
+    case "refused-address":
+      entries.push({
+        path: CODEX_CONFIG_REL2,
+        action: "leave",
+        kind: "codex-server",
+        bytes: null,
+        ...existsSync3(join5(targetRepo, CODEX_CONFIG_REL2)) ? { yours: true } : {}
+      });
+      break;
+  }
   merge(GITIGNORE_REL, steps.gitignore);
   merge(GITATTRIBUTES_REL, steps.gitattributes);
   const identity = steps.identity;
@@ -6459,6 +6711,7 @@ function entriesOf(steps, record2) {
   else
     fromFile(steps.pin);
   fromFile(steps.crew);
+  steps.crewProfiles.forEach(fromFile);
   entries.push(steps.scan.text !== null ? { path: BOOTSTRAP_STATE_REL, action: "add", kind: "halfcycle-folder", bytes: steps.scan.text } : { path: BOOTSTRAP_STATE_REL, action: "leave", kind: "halfcycle-folder", bytes: null });
   if (record2 === null)
     pending(INSTALL_MANIFEST_REL);
@@ -6499,6 +6752,8 @@ function applyInstallPlan(plan) {
   }
   for (const command of steps.commands)
     putPlannedFile(targetRepo, command);
+  for (const skill of steps.codexSkills)
+    putPlannedFile(targetRepo, skill);
   putPlannedFile(targetRepo, steps.vendored);
   putPlannedFile(targetRepo, steps.settings.file);
   for (const hook of steps.hooks)
@@ -6506,6 +6761,8 @@ function applyInstallPlan(plan) {
   const ciStanza = steps.ciStanza === "removed" ? removePlannedRetiredFile(targetRepo, LEGACY_CI_STANZA_REL) : steps.ciStanza;
   putPlannedMcp(targetRepo, steps.mcp);
   const mcpHelper = steps.mcpHelper === "removed" ? removePlannedRetiredFile(targetRepo, RETIRED_MCP_HEADERS_HELPER_REL) : steps.mcpHelper;
+  putPlannedCodexHooks(targetRepo, steps.codexHooks);
+  putPlannedCodexConfig(targetRepo, steps.codexConfig);
   const gitignore = putPlannedGitignore(targetRepo, steps.gitignore);
   const gitignorePath = join5(targetRepo, GITIGNORE_REL);
   const gitignoreAfter = existsSync3(gitignorePath) ? readFileSync5(gitignorePath, "utf-8") : null;
@@ -6518,6 +6775,8 @@ function applyInstallPlan(plan) {
   const legacy = applyLegacyMigration(targetRepo, migrateLegacyEnvLocal(targetRepo, stored));
   writeBundlePin(targetRepo, pin, []);
   putPlannedFile(targetRepo, steps.crew);
+  for (const profile of steps.crewProfiles)
+    putPlannedFile(targetRepo, profile);
   if (steps.scan.text !== null)
     writeBootstrapState(targetRepo, steps.scan.text);
   const { report, installManifest, manifestText } = accountInstall(steps, {
@@ -6547,9 +6806,15 @@ function applyInstallPlan(plan) {
     replacedPaths: report.replacedPaths,
     bootstrapScanRan: steps.scan.text !== null,
     legacyCredentialKept: legacy.outcome === "kept" ? { keys: legacy.unbacked, missing: legacy.missingForAdoption } : null,
-    notShared
+    notShared,
+    codex: { hooks: steps.codexHooks.outcome, config: appliedCodexConfig(steps.codexConfig.outcome) }
   };
 }
+function appliedCodexConfig(outcome) {
+  if (outcome === "pending")
+    throw new Error("[halfcycle] a preview cannot be applied: it is still waiting for the service.");
+  return outcome;
+}
 
 // dist/mcp-endpoint.js
 var MCP_ENDPOINT_PATH = "/mcp";
@@ -6560,8 +6825,8 @@ function mcpEndpointUrl(origin) {
 // dist/node-floor.js
 var NODE_FLOOR_MAJOR = 18;
 var NODE_FLOOR_SENTENCE_HEAD = `Halfcycle needs Node ${NODE_FLOOR_MAJOR} or newer; you have `;
-function nodeFloorProgram(guarded) {
-  return `if(+process.versions.node.split('.')[0]<${NODE_FLOOR_MAJOR}){console.error('${NODE_FLOOR_SENTENCE_HEAD}'+process.versions.node);process.exitCode=1}else{${guarded}}`;
+function nodeFloorProgram(guarded, belowFloor = "process.exitCode=1") {
+  return `if(+process.versions.node.split('.')[0]<${NODE_FLOOR_MAJOR}){console.error('${NODE_FLOOR_SENTENCE_HEAD}'+process.versions.node);` + belowFloor + `}else{${guarded}}`;
 }
 
 // dist/merge-settings.js
@@ -6608,6 +6873,75 @@ function mergeSettings(existing, generated, retiredOurs, statusLine) {
   }
   return merged;
 }
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCodexHooks(existing, generated, ours) {
+  const existingHooks = isPlainRecord(existing["hooks"]) ? existing["hooks"] : {};
+  const events = [
+    ...Object.keys(existingHooks),
+    ...Object.keys(generated.hooks).filter((event) => !(event in existingHooks))
+  ];
+  const mergedHooks = {};
+  for (const event of events) {
+    const rows = generated.hooks[event] ?? [];
+    const current = existingHooks[event];
+    if (current === void 0) {
+      mergedHooks[event] = rows.map(cloneGroup);
+      continue;
+    }
+    if (!Array.isArray(current)) {
+      mergedHooks[event] = current;
+      continue;
+    }
+    const wanted = new Map(rows.map((row) => [row.hooks[0].command, row]));
+    const placed = /* @__PURE__ */ new Set();
+    const next = [];
+    for (const group of current) {
+      if (!isPlainRecord(group) || !Array.isArray(group["hooks"]) || !isHalfcycleEntry({ hooks: group["hooks"] }, ours)) {
+        next.push(group);
+        continue;
+      }
+      const hooks = group["hooks"];
+      if (hooks.length === 1) {
+        const command = hooks[0].command;
+        const row = wanted.get(command);
+        if (row !== void 0 && !placed.has(command)) {
+          placed.add(command);
+          next.push(cloneGroup(row));
+        }
+        continue;
+      }
+      const kept = [];
+      for (const hook of hooks) {
+        if (!isHalfcycleCommand(hook, ours)) {
+          kept.push(hook);
+          continue;
+        }
+        const command = hook.command;
+        const row = wanted.get(command);
+        if (row !== void 0 && !placed.has(command) && group["matcher"] === row.matcher) {
+          placed.add(command);
+          kept.push({ ...row.hooks[0] });
+        }
+      }
+      if (kept.length > 0)
+        next.push({ ...group, hooks: kept });
+    }
+    for (const row of rows) {
+      if (!placed.has(row.hooks[0].command))
+        next.push(cloneGroup(row));
+    }
+    mergedHooks[event] = next;
+  }
+  return { ...existing, hooks: mergedHooks };
+}
+function cloneGroup(group) {
+  return {
+    ...group.matcher === void 0 ? {} : { matcher: group.matcher },
+    hooks: group.hooks.map((hook) => ({ ...hook }))
+  };
+}
 function mergePermissions(existing, generated, retiredOurs) {
   if (existing === void 0 && generated === void 0)
     return void 0;
@@ -6630,6 +6964,168 @@ function mergePermissions(existing, generated, retiredOurs) {
   return result;
 }
 
+// dist/toml-lines.js
+var BARE_KEY_CHAR = /[A-Za-z0-9_-]/;
+var Unreadable = class extends Error {
+};
+function skipBlank(line, i) {
+  while (i < line.length && (line[i] === " " || line[i] === "	"))
+    i += 1;
+  return i;
+}
+function readKey(line, start) {
+  const segments = [];
+  let i = start;
+  for (; ; ) {
+    i = skipBlank(line, i);
+    const c = line[i];
+    if (c === '"') {
+      const close = line.indexOf('"', i + 1);
+      if (close < 0)
+        throw new Unreadable();
+      const segment = line.slice(i + 1, close);
+      if (segment.includes("\\"))
+        throw new Unreadable();
+      segments.push(segment);
+      i = close + 1;
+    } else if (c === "'") {
+      const close = line.indexOf("'", i + 1);
+      if (close < 0)
+        throw new Unreadable();
+      segments.push(line.slice(i + 1, close));
+      i = close + 1;
+    } else {
+      let j = i;
+      while (j < line.length && BARE_KEY_CHAR.test(line[j]))
+        j += 1;
+      if (j === i)
+        throw new Unreadable();
+      segments.push(line.slice(i, j));
+      i = j;
+    }
+    i = skipBlank(line, i);
+    if (line[i] !== ".")
+      return { segments, end: i };
+    i += 1;
+  }
+}
+function readValue(line, start, state) {
+  let i = start;
+  while (i < line.length) {
+    if (state.multiline !== null) {
+      const delimiter3 = state.multiline;
+      const escapes = delimiter3 === '"""';
+      while (i < line.length) {
+        if (escapes && line[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (line.startsWith(delimiter3, i)) {
+          i += 3;
+          let extra = 0;
+          while (extra < 2 && line[i] === delimiter3[0]) {
+            i += 1;
+            extra += 1;
+          }
+          state.multiline = null;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    const c = line[i];
+    if (c === "#")
+      return;
+    if (c === '"' || c === "'") {
+      const triple = c.repeat(3);
+      if (line.startsWith(triple, i)) {
+        state.multiline = triple;
+        i += 3;
+        continue;
+      }
+      let j = i + 1;
+      for (; ; ) {
+        if (j >= line.length)
+          throw new Unreadable();
+        if (c === '"' && line[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (line[j] === c)
+          break;
+        j += 1;
+      }
+      i = j + 1;
+      continue;
+    }
+    if (c === "[" || c === "{")
+      state.depth += 1;
+    else if (c === "]" || c === "}") {
+      state.depth -= 1;
+      if (state.depth < 0)
+        throw new Unreadable();
+    }
+    i += 1;
+  }
+}
+function scanTomlStatements(lines, skip) {
+  const statements = [];
+  const state = { multiline: null, depth: 0 };
+  let table = [];
+  let index = 0;
+  try {
+    for (index = 0; index < lines.length; index += 1) {
+      const inValue = state.multiline !== null || state.depth > 0;
+      if (skip !== void 0 && index === skip.from) {
+        if (inValue)
+          throw new Unreadable();
+        table = skip.tableAfter;
+        index = skip.to;
+        continue;
+      }
+      let line = lines[index];
+      if (index === 0 && line.startsWith("\uFEFF"))
+        line = line.slice(1);
+      if (inValue) {
+        readValue(line, 0, state);
+        continue;
+      }
+      let i = skipBlank(line, 0);
+      if (i >= line.length || line[i] === "#")
+        continue;
+      if (line[i] === "[") {
+        const array = line[i + 1] === "[";
+        i += array ? 2 : 1;
+        const key2 = readKey(line, i);
+        i = key2.end;
+        if (line[i] !== "]" || array && line[i + 1] !== "]")
+          throw new Unreadable();
+        i = skipBlank(line, i + (array ? 2 : 1));
+        if (i < line.length && line[i] !== "#")
+          throw new Unreadable();
+        table = key2.segments;
+        statements.push({ line: index, kind: array ? "array-table" : "table", path: key2.segments });
+        continue;
+      }
+      const key = readKey(line, i);
+      if (line[key.end] !== "=")
+        throw new Unreadable();
+      statements.push({ line: index, kind: "key", path: [...table, ...key.segments] });
+      readValue(line, key.end + 1, state);
+    }
+    if (state.multiline !== null || state.depth > 0) {
+      index = lines.length - 1;
+      throw new Unreadable();
+    }
+  } catch (err) {
+    if (err instanceof Unreadable)
+      return { ok: false, line: index };
+    throw err;
+  }
+  return { ok: true, statements };
+}
+
 // dist/install.js
 function renderNotShared(finding) {
   const rule = `rule "${finding.pattern}" in ${finding.source}, line ${finding.line}`;
@@ -6639,6 +7135,97 @@ function renderNotShared(finding) {
   return `[halfcycle] Not shared: git ignores ${finding.path} (${rule}) and ${finding.others} other file${finding.others === 1 ? "" : "s"} Halfcycle set up here, so they will not reach anyone else who gets a copy of this project.`;
 }
 var ZONE_B_DIR = ".workbench";
+var CODEX_HOOKS_REL2 = AGENT_PROFILES.codex.settingsFiles[0];
+var CODEX_CONFIG_REL2 = AGENT_PROFILES.codex.mcpRegistration.file;
+var CLAUDE_AGENTS_DIR = ".claude/agents";
+var CODEX_AGENTS_DIR = ".codex/agents";
+var CREW_CALLSIGN_PATTERN = /^[A-Z][A-Z0-9]*$/;
+function crewProfileRel(agent, callsign) {
+  if (!CREW_CALLSIGN_PATTERN.test(callsign)) {
+    throw new Error(`[halfcycle] crew callsign "${callsign}" is not a valid profile name (must match ^[A-Z][A-Z0-9]*$).`);
+  }
+  return agent === "claude-code" ? `${CLAUDE_AGENTS_DIR}/${callsign}.md` : `${CODEX_AGENTS_DIR}/${callsign.toLowerCase()}.toml`;
+}
+function crewProfileTarget(targetRepo, rel) {
+  const folder = rel.startsWith(`${CLAUDE_AGENTS_DIR}/`) ? CLAUDE_AGENTS_DIR : CODEX_AGENTS_DIR;
+  const target = resolve(join6(targetRepo, rel));
+  if (dirname3(target) !== resolve(targetRepo, folder)) {
+    throw new Error(`[halfcycle] crew profile "${rel}" does not sit directly in ${folder}.`);
+  }
+  return target;
+}
+var CREW_ROLE_WORDS = {
+  "business-analyst": "business analyst",
+  architect: "architect",
+  "spec-writer": "spec writer",
+  builder: "builder",
+  "context-docs": "context and docs writer",
+  "spec-reviewer": "spec reviewer",
+  "code-test-reviewer": "code and test reviewer",
+  "delivery-lead": "delivery lead",
+  "quality-lead": "quality lead"
+};
+var CREW_TIER_WORDS = {
+  deep: "You think carefully and deeply before you act, and take the time the work needs.",
+  standard: "You think each step through at a steady pace before you act.",
+  fast: "You work quickly on clear, well-defined work, and say so when a task needs more thought."
+};
+var CREW_REVIEWER_WORDS = "You check the work you are given and never change it: you read it, run what you need to, and report what you find.";
+var CREW_REVIEWER_TOOLS = "Read, Grep, Glob, Bash";
+var CREW_MEMBER_TOOLS = "Read, Edit, Write, Bash, Grep, Glob";
+function crewProfileBody(role, group, tier) {
+  const lines = [`You are a ${CREW_ROLE_WORDS[role]} on this project's build crew.`, CREW_TIER_WORDS[tier]];
+  if (group === "reviewer")
+    lines.push(CREW_REVIEWER_WORDS);
+  return `${lines.join("\n")}
+`;
+}
+function crewProfileDescription(member) {
+  return `${member.callsign}, ${CREW_ROLE_WORDS[member.role]} (${member.discipline}), a member of this project's build crew.`;
+}
+function plainYamlValue(value) {
+  if (/[\r\n]|: | #|^[-?:,[\]{}#&*!|>'"%@`\s]|\s$/.test(value)) {
+    throw new Error(`[halfcycle] a crew profile value cannot be written as plain text: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function claudeCrewProfile(member) {
+  const tools = member.group === "reviewer" ? CREW_REVIEWER_TOOLS : CREW_MEMBER_TOOLS;
+  return [
+    "---",
+    `name: ${plainYamlValue(member.callsign)}`,
+    `description: ${plainYamlValue(crewProfileDescription(member))}`,
+    `model: ${plainYamlValue(AGENT_PROFILES["claude-code"].tierModels[member.tier].model)}`,
+    `tools: ${tools}`,
+    "---",
+    "",
+    crewProfileBody(member.role, member.group, member.tier)
+  ].join("\n");
+}
+function codexCrewProfile(member) {
+  const { model, effort } = AGENT_PROFILES.codex.tierModels[member.tier];
+  if (effort === void 0)
+    throw new Error(`[halfcycle] Codex's ${member.tier} tier names no reasoning effort.`);
+  const body = crewProfileBody(member.role, member.group, member.tier);
+  if (/[\\"]|[\u0000-\u0009\u000b-\u001f\u007f]/.test(body)) {
+    throw new Error("[halfcycle] a crew profile body holds a character a Codex role cannot carry as written.");
+  }
+  return [
+    `name = ${tomlBasicString(member.callsign.toLowerCase())}`,
+    `description = ${tomlBasicString(crewProfileDescription(member))}`,
+    `model = ${tomlBasicString(model)}`,
+    `model_reasoning_effort = ${tomlBasicString(effort)}`,
+    `developer_instructions = """`,
+    `${body}"""`,
+    ""
+  ].join("\n");
+}
+function renderCrewProfiles(roster = CREW_ROSTER) {
+  return [
+    ...roster.map((member) => ({ rel: crewProfileRel("claude-code", member.callsign), text: claudeCrewProfile(member) })),
+    ...roster.filter((member) => member.group !== "reviewer").map((member) => ({ rel: crewProfileRel("codex", member.callsign), text: codexCrewProfile(member) }))
+  ];
+}
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname3(__filename);
 function findBundleRoot(startDir) {
@@ -6690,13 +7277,23 @@ var WRITE_ALLOWLIST = [
   "test/fixtures/captured",
   MCP_REGISTRATION_REL,
   ".gitattributes",
-  ZONE_B_DIR
+  ZONE_B_DIR,
+  // Codex's twin of '.claude/commands' (`codex-install-target` AC4, T-14): one
+  // `.agents/skills/<name>/SKILL.md` per command, same collision rule.
+  ".agents/skills",
+  // Codex's checks file, merged beside a developer's own entries.
+  CODEX_HOOKS_REL2,
+  // Codex's settings file: one marked block is added, and the rest of the file is left as it is.
+  CODEX_CONFIG_REL2,
+  // Each crew member's own profile, by its exact name; no other file in those folders is written.
+  ...renderCrewProfiles().map((profile) => profile.rel)
 ];
+var CREW_PROFILE_RELS = new Set(renderCrewProfiles().map((p) => p.rel));
 function isAllowlisted(targetRelPath) {
   const normalised = targetRelPath.replace(/\\/g, "/");
   return WRITE_ALLOWLIST.some((prefix) => {
     const p = prefix.replace(/\\/g, "/");
-    return normalised === p || normalised.startsWith(p + "/");
+    return normalised === p || !CREW_PROFILE_RELS.has(p) && normalised.startsWith(p + "/");
   });
 }
 var CREW_ROSTER_REL = ".halfcycle/crew.json";
@@ -6709,6 +7306,12 @@ var GITATTRIBUTES_REL = ".gitattributes";
 function commandStubRel(name) {
   return `.claude/commands/${name}.md`;
 }
+function skillRel(name) {
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error(`[halfcycle] plugin.json command "${name}" is not a valid skill name (must match ^[a-z][a-z0-9-]*$).`);
+  }
+  return `.agents/skills/${name}/SKILL.md`;
+}
 var RETIRED_MCP_HEADERS_HELPER_REL = ".halfcycle/mcp-headers.sh";
 var RETIRED_WRITE_SET_FILES = [RETIRED_MCP_HEADERS_HELPER_REL];
 var RETIRED_DENY_PATTERNS = [
@@ -6727,6 +7330,9 @@ function closedWriteSet() {
   const commands = readPluginManifest().commands ?? [];
   const files = /* @__PURE__ */ new Set([
     ...commands.map((cmd) => commandStubRel(cmd.name)),
+    // Codex's twin of the stubs (`codex-install-target` AC4, T-14), derived from the
+    // same manifest array the stubs come from — one closed-set source for both.
+    ...commands.map((cmd) => skillRel(cmd.name)),
     ...Object.keys(OWNED_GENERATED_HEADERS),
     VENDORED_BIN_REL,
     CREW_ROSTER_REL,
@@ -6735,9 +7341,12 @@ function closedWriteSet() {
     BOOTSTRAP_STATE_REL,
     CAPTURED_INDEX_REL,
     INSTALL_MANIFEST_REL,
+    // The crew profiles (`crew-agent-profiles` AC6), from the same generator the
+    // allowlist and the plan read, so uninstall's set and the writer's cannot differ.
+    ...renderCrewProfiles().map((profile) => profile.rel),
     ...RETIRED_WRITE_SET_FILES
   ]);
-  const merged = /* @__PURE__ */ new Set([SETTINGS_REL, MCP_REGISTRATION_REL, GITIGNORE_REL, GITATTRIBUTES_REL]);
+  const merged = /* @__PURE__ */ new Set([SETTINGS_REL, MCP_REGISTRATION_REL, CODEX_HOOKS_REL2, CODEX_CONFIG_REL2, GITIGNORE_REL, GITATTRIBUTES_REL]);
   const dirs = /* @__PURE__ */ new Set();
   for (const path of [...files, ...merged]) {
     for (let dir = posix2.dirname(path); dir !== "."; dir = posix2.dirname(dir))
@@ -6750,6 +7359,7 @@ function closedWriteSet() {
     dirs,
     ownedDirs,
     hookCommands: new Set(HALFCYCLE_HOOK_COMMANDS),
+    codexHookCommands: new Set(AGENT_PROFILES.codex.commands),
     denyRuleSha256: new Set([...DENY_PATTERNS, ...RETIRED_DENY_PATTERNS].map((rule) => sha256Hex(rule))),
     settingsSchema: SETTINGS_SCHEMA,
     gitignoreLines: /* @__PURE__ */ new Set([GITIGNORE_HEADER, ...REQUIRED_GITIGNORE_ENTRIES, LEGACY_ENV_LOCAL_REL]),
@@ -6767,10 +7377,17 @@ function sha256OfWhatThisVersionWrites(commands) {
     if (existsSync4(src))
       out.set(rel, fileSha256(readFileSync6(src)));
   };
-  for (const cmd of commands)
-    fromFile(commandStubRel(cmd.name), join6(BUNDLE_ROOT, ".claude-plugin", cmd.path));
+  for (const cmd of commands) {
+    const srcFile = join6(BUNDLE_ROOT, ".claude-plugin", cmd.path);
+    fromFile(commandStubRel(cmd.name), srcFile);
+    if (existsSync4(srcFile)) {
+      out.set(skillRel(cmd.name), fileSha256(Buffer.from(codexSkillContent(cmd.name, readFileSync6(srcFile, "utf-8")), "utf-8")));
+    }
+  }
   for (const [rel, content] of hookScriptsThisVersionWrites())
     out.set(rel, fileSha256(content));
+  for (const profile of renderCrewProfiles())
+    out.set(profile.rel, fileSha256(Buffer.from(profile.text, "utf-8")));
   fromFile(CAPTURED_INDEX_REL, capturedIndexScaffold());
   return out;
 }
@@ -6874,6 +7491,8 @@ function findNotShared(targetRepo, manifest, collidedPaths) {
   const merged = [
     SETTINGS_REL,
     ...manifest.mcp !== void 0 ? [MCP_REGISTRATION_REL] : [],
+    ...manifest.codexHooks !== void 0 ? [CODEX_HOOKS_REL2] : [],
+    ...manifest.codexConfig !== void 0 ? [CODEX_CONFIG_REL2] : [],
     ...manifest.gitignore.created || manifest.gitignore.appended.length > 0 ? [GITIGNORE_REL] : [],
     ...manifest.gitattributes !== void 0 && (manifest.gitattributes.created || manifest.gitattributes.appended.length > 0) ? [GITATTRIBUTES_REL] : []
   ];
@@ -6934,6 +7553,55 @@ function readPluginManifest() {
   const raw = readFileSync6(manifestPath, "utf-8");
   return JSON.parse(raw);
 }
+function parseCommandStub(raw, name) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(raw);
+  if (match === null) {
+    throw new Error(`[halfcycle] commands/${name}.md has no frontmatter block; cannot build its Codex skill.`);
+  }
+  const [, frontmatter, body] = match;
+  const desc = /^description:\s*(.+)$/m.exec(frontmatter);
+  if (desc === null) {
+    throw new Error(`[halfcycle] commands/${name}.md's frontmatter has no description; cannot build its Codex skill.`);
+  }
+  return { description: desc[1].trim(), body };
+}
+var TRUST_SENTENCE_WORDS = "Claude Code does not trust this folder yet, open it there and accept the workspace-trust prompt";
+var CODEX_TRUST_SENTENCE = "Codex does not trust this folder yet, open it there and trust it when asked";
+function trustSentencePattern() {
+  const words = TRUST_SENTENCE_WORDS.split(" ").map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(words.join("(?: |\\n> )"));
+}
+var MCP_RECONNECT_WORDS = "run `/mcp` and reconnect it";
+var CODEX_MCP_FALLBACK = "start a new Codex session";
+function mcpReconnectPattern() {
+  const words = MCP_RECONNECT_WORDS.split(" ").map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(words.join("(?: |\\n> )"));
+}
+function codexSkillBody(name, sourceBody) {
+  const slashForm = "`/" + name + "`";
+  if (!sourceBody.includes(slashForm)) {
+    throw new Error(`[halfcycle] commands/${name}.md never names itself as ${slashForm}; cannot build its Codex skill.`);
+  }
+  const pattern = trustSentencePattern();
+  if (!pattern.test(sourceBody)) {
+    throw new Error(`[halfcycle] commands/${name}.md is missing the Claude Code trust sentence; cannot build its Codex skill.`);
+  }
+  const bareName = "`" + name + "`";
+  const transformed = sourceBody.split(slashForm).join(bareName).replace(trustSentencePattern(), CODEX_TRUST_SENTENCE).replace(mcpReconnectPattern(), CODEX_MCP_FALLBACK);
+  if (transformed.includes("/mcp")) {
+    throw new Error(`[halfcycle] commands/${name}.md's Codex skill still names /mcp; cannot build.`);
+  }
+  return transformed;
+}
+function codexSkillContent(name, sourceRaw) {
+  const { description, body } = parseCommandStub(sourceRaw, name);
+  const transformed = codexSkillBody(name, body);
+  return `---
+name: ${name}
+description: ${description}
+---
+${transformed}`;
+}
 function planManifestCommands(manifest, targetRepo, previous, writeSet) {
   const recordedFiles = new Map((previous?.files ?? []).filter((file) => writeSet.files.has(file.path)).map((file) => [file.path, file]));
   return (manifest.commands ?? []).map((cmd) => {
@@ -7112,6 +7780,16 @@ function generateSettingsJson() {
   };
   return JSON.stringify(settings, null, 2) + "\n";
 }
+function codexHooksValue() {
+  const hooks = {};
+  for (const { event, matcher, timeout, command, commandWindows } of AGENT_PROFILES.codex.wiring) {
+    (hooks[event] ??= []).push({
+      ...matcher === null ? {} : { matcher },
+      hooks: [{ type: "command", command, timeout, ...commandWindows === void 0 ? {} : { commandWindows } }]
+    });
+  }
+  return { hooks };
+}
 var GENERATED_GUARD_RUNNER_HEADER = "# Governance hook wrapper \u2014 generated by";
 function generateGuardRunnerWrapper(preFilter = resolvePreFilterShell()) {
   return `#!/usr/bin/env bash
@@ -7164,9 +7842,11 @@ ${preFilter.trimEnd()}
 # Before a tool runs, on a bash new enough for the cheap pass: read the call
 # once; when no risky action can be in it, answer here (the pass writes the
 # time line) and do not start Node. Otherwise hand the same input on below.
+# The pass is given the hook's own arguments, so it knows which coding agent's
+# input it reads, and hands on any agent's call it has no test for.
 if [ "$1" = hook ] && [ "$2" = pre-tool-use ] && [ "\${BASH_VERSINFO[0]:-0}" -ge 5 ]; then
   hc_input=$(cat 2>/dev/null) || IFS= read -r -d '' hc_input
-  ${PRE_FILTER_FUNCTION} && exit 0
+  ${PRE_FILTER_FUNCTION} "$@" && exit 0
   node -e "${nodeFloorProgram("")}" || {
     printf '%s' "$hc_input" | halfcycle_pre_tool_use_fallback
     exit 0
@@ -7406,27 +8086,33 @@ exit 0
 var GENERATED_USER_PROMPT_SCOPE_HEADER = "# Typed scope approval \u2014 generated by";
 function generateUserPromptScopeHook() {
   return `#!/usr/bin/env bash
-${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer, now also for the close review.
+${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer, now also for the close review and Codex.
 #
 # Lets the owner of this project approve a phase's scope, or send it back,
 # decide one part of a phase's close review, or turn builds running on their
 # own on or off, by typing one line as the whole prompt in their own Claude
 # Code session: "approve <phase>", "send back <phase>: <note>", "accept
 # <phase>/<part>", "question <phase>/<part>: <words>", "carry <phase>/<part>:
-# <words>", "drop <phase>/<part>: <words>", "autonomy on" or "autonomy off".
+# <words>", "drop <phase>/<part>: <words>", "reject <phase>/<task>: <words>",
+# "autonomy on" or "autonomy off". Also lets the person who is typing let one
+# step Halfcycle paused run once, by typing "allow" as the whole prompt.
 #
 # AN ORDINARY PROMPT STARTS NOTHING. This script reads the hook input once and
 # looks only at the start of the prompt's value. Unless the prompt begins, after
 # any whitespace (typed, or escaped in the input), with "approve ", "send back ",
-# "accept ", "question ", "carry ", "drop " or "autonomy ", in any case, it exits
-# 0 with no output, and Node never starts. A quote inside any other field arrives
+# "accept ", "question ", "carry ", "drop ", "reject " or "autonomy ", in any case,
+# or is "allow" and nothing else but whitespace, it exits 0 with no output, and
+# Node never starts. A quote inside any other field arrives
 # escaped, so no other field (the folder the session is in, for one) can read as
 # the start of the prompt.
 #
 # Otherwise it finds the project root from its own location, never from the
 # folder the session has moved to, and hands the same input to the guard
 # wrapper beside it. That decides whether the line counts and prints at most
-# one plain line. Nothing here ever blocks a prompt.
+# one line. Nothing here ever blocks a prompt. Any arguments this script was
+# given (a Codex row passes its agent's name) are handed on after the verb; in
+# Codex a typed line never counts, because Codex cannot tell a person's line
+# from one a program sent.
 #
 # FAILS OPEN up to that hand-over: any error before it exits 0 with no output.
 # After it, the wrapper's own exit stands.
@@ -7442,7 +8128,7 @@ IFS= read -r -d '' HC_INPUT || true
 # \\u escape, or as the UTF-8 bytes of a Unicode space. Compared byte for byte.
 HC_LEAD='[[:space:]]|\\\\[nrtf]|\\\\u(000[9a-d]|0020|00a0|1680|200[0-9a]|202[89f]|205f|3000|feff)'
 HC_LEAD="$HC_LEAD|"$'\\xc2\\xa0|\\xe1\\x9a\\x80|\\xe2\\x80[\\x80-\\x8a\\xa8\\xa9\\xaf]|\\xe2\\x81\\x9f|\\xe3\\x80\\x80|\\xef\\xbb\\xbf'
-if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*(approve|send back|accept|question|carry|drop|autonomy) "; then
+if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*((approve|send back|accept|question|carry|drop|reject|autonomy) |allow($HC_LEAD)*\\")"; then
   exit 0
 fi
 
@@ -7452,16 +8138,17 @@ export CLAUDE_PROJECT_DIR="$HC_PROJECT_ROOT"
 
 trap - ERR
 set +e
-exec bash "$HC_PROJECT_ROOT/.claude/hooks/guard-runner.sh" hook user-prompt-submit <<<"$HC_INPUT"
+exec bash "$HC_PROJECT_ROOT/.claude/hooks/guard-runner.sh" hook user-prompt-submit <<<"$HC_INPUT" "$@"
 `;
 }
 var GENERATED_USER_PROMPT_FINDINGS_HEADER = "# Findings hand-over \u2014 generated by";
 function generateUserPromptFindingsHook() {
   return `#!/usr/bin/env bash
-${GENERATED_USER_PROMPT_FINDINGS_HEADER} the Halfcycle installer.
+${GENERATED_USER_PROMPT_FINDINGS_HEADER} the Halfcycle installer, now also for Codex.
 #
 # At the person's next message, before the agent starts, hands it the details of
-# whatever Halfcycle's checks found at an earlier turn end, once.
+# whatever Halfcycle's checks found at an earlier turn end, once. Any arguments
+# this script was given (a Codex row passes its agent's name) are handed on.
 #
 # AN ORDINARY PROMPT STARTS NOTHING. With no findings file for this session, this
 # script reads its session id with a bash regex (no node) and exits 0 with no
@@ -7498,7 +8185,7 @@ export CLAUDE_PROJECT_DIR="$HC_PROJECT_ROOT"
 
 trap - ERR
 set +e
-exec bash "$HC_PROJECT_ROOT/.claude/hooks/guard-runner.sh" hook user-prompt-findings <<<"$HC_INPUT"
+exec bash "$HC_PROJECT_ROOT/.claude/hooks/guard-runner.sh" hook user-prompt-findings <<<"$HC_INPUT" "$@"
 `;
 }
 var CI_STANZA_KNOWN_HEADER_HASHES = [
@@ -7577,6 +8264,160 @@ var MCP_HEADERS_HELPER_COMMAND = `node -e "${nodeFloorProgram([
   `console.error('halfcycle: no ${VENDORED_BIN_REL} at or above '+process.cwd()+'; run npx halfcycle in the project folder');`,
   `process.exit(1)`
 ].join(""))}"`;
+var CODEX_ADDRESS_PATTERN = /^https?:\/\/[A-Za-z0-9.-]+(:[0-9]{1,5})?(\/[A-Za-z0-9._-]+)*\/mcp$/;
+function codexAddressAllowed(address) {
+  return CODEX_ADDRESS_PATTERN.test(address);
+}
+var CODEX_NO_CREDENTIAL_STATEMENT = `console.log(JSON.stringify({Authorization:'Bearer ${NO_CREDENTIAL_PLACEHOLDER}'}))`;
+function codexMcpHeadersHelperCommand(address) {
+  if (!codexAddressAllowed(address))
+    return null;
+  return `node -e "${nodeFloorProgram([
+    `let o=0;`,
+    `const n=function(){if(o)return;o=1;${CODEX_NO_CREDENTIAL_STATEMENT}};`,
+    `try{`,
+    `const p=require('path'),f=require('fs'),c=require('child_process');`,
+    `let d=process.cwd(),b='';`,
+    `for(;;){`,
+    `const t=p.join(d,'${VENDORED_BIN_REL}');`,
+    `if(f.existsSync(t)){b=t;break}`,
+    `const u=p.dirname(d);`,
+    `if(u===d)break;`,
+    `d=u}`,
+    `if(b===''){`,
+    `console.error('halfcycle: no ${VENDORED_BIN_REL} at or above '+process.cwd()+'; run npx halfcycle in the project folder');`,
+    `n()}else{`,
+    `const r=c.spawnSync(process.execPath,[b,'mcp-headers','--url','${address}'],{stdio:['ignore','pipe','inherit']});`,
+    `if(r.status===0&&r.stdout&&r.stdout.length){o=1;process.stdout.write(r.stdout)}else{n()}}`,
+    `}catch(e){n()}`
+  ].join(""), CODEX_NO_CREDENTIAL_STATEMENT)}"`;
+}
+var CODEX_CONFIG_OPEN_MARKER = "# >>> Halfcycle \u2014 generated by the Halfcycle installer; replaced on every install";
+var CODEX_CONFIG_CLOSE_MARKER = "# <<< Halfcycle";
+function tomlBasicString(value) {
+  if (/[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error("[halfcycle] a value for Codex's settings holds a control character.");
+  }
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function codexServerPath() {
+  const { serversKey, serverKey } = AGENT_PROFILES.codex.mcpRegistration;
+  return [serversKey, serverKey];
+}
+function generateCodexConfigBlock(address) {
+  return codexConfigBlockWith(address, codexMcpHeadersHelperCommand);
+}
+function codexConfigBlockWith(address, helperFor) {
+  if (!codexAddressAllowed(address))
+    return null;
+  const helper = helperFor(address);
+  if (helper === null)
+    return null;
+  const [serversKey, serverKey] = codexServerPath();
+  return [
+    CODEX_CONFIG_OPEN_MARKER,
+    `[${serversKey}.${serverKey}]`,
+    `url = ${tomlBasicString(address)}`,
+    `http_headers_helper = ${tomlBasicString(helper)}`,
+    CODEX_CONFIG_CLOSE_MARKER
+  ].join("\n");
+}
+var RETIRED_CODEX_MCP_HEADERS_HELPERS = [];
+function regeneratesCodexBlock(block, retired = RETIRED_CODEX_MCP_HEADERS_HELPERS) {
+  const lines = linesOf(block);
+  while (lines.length > 0 && lines[lines.length - 1] === "")
+    lines.pop();
+  const url = /^url = "((?:[^"\\]|\\.)*)"$/.exec(lines[2] ?? "");
+  if (url === null)
+    return false;
+  const address = url[1].replace(/\\(["\\])/g, "$1");
+  const text = lines.join("\n");
+  return [codexMcpHeadersHelperCommand, ...retired].some((helperFor) => codexConfigBlockWith(address, helperFor) === text);
+}
+function locateCodexBlock(lines) {
+  const opens = [];
+  const closes = [];
+  for (const [index, line] of lines.entries()) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# >>> Halfcycle")) {
+      if (line !== CODEX_CONFIG_OPEN_MARKER)
+        return { kind: "broken" };
+      opens.push(index);
+    } else if (trimmed.startsWith("# <<< Halfcycle")) {
+      if (line !== CODEX_CONFIG_CLOSE_MARKER)
+        return { kind: "broken" };
+      closes.push(index);
+    }
+  }
+  if (opens.length === 0 && closes.length === 0)
+    return { kind: "none" };
+  if (opens.length === 1 && closes.length === 1 && opens[0] < closes[0]) {
+    return { kind: "one", open: opens[0], close: closes[0] };
+  }
+  return { kind: "broken" };
+}
+function definesCodexServer(statement, servers, server) {
+  const [first, second] = statement.path;
+  if (first !== servers)
+    return false;
+  if (statement.kind === "table")
+    return second === server;
+  return statement.path.length === 1 || second === server;
+}
+function linesOf(text) {
+  return text.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+function codexConfigConflict(existing) {
+  const lines = linesOf(existing);
+  const at = locateCodexBlock(lines);
+  if (at.kind === "broken")
+    return "broken-markers";
+  const [servers, server] = codexServerPath();
+  const scan = scanTomlStatements(lines, at.kind === "one" ? { from: at.open, to: at.close, tableAfter: [servers, server] } : void 0);
+  if (!scan.ok)
+    return "unreadable";
+  return scan.statements.some((statement) => definesCodexServer(statement, servers, server)) ? "server-named" : null;
+}
+function holdsCodexBlock(existing) {
+  return locateCodexBlock(linesOf(existing)).kind === "one";
+}
+function codexBlockSpan(text) {
+  const at = locateCodexBlock(linesOf(text));
+  if (at.kind !== "one")
+    return at.kind;
+  const raw = text.split("\n");
+  let start = 0;
+  for (let i = 0; i < at.open; i += 1)
+    start += raw[i].length + 1;
+  let end = start;
+  for (let i = at.open; i <= at.close; i += 1)
+    end += raw[i].length + 1;
+  return { start, end: Math.min(end, text.length) };
+}
+function reconcileCodexConfig(existing, block) {
+  if (existing === null || existing === "") {
+    const text2 = `${block}
+`;
+    return { kind: "new", text: text2, appended: existing === null ? null : text2, block: text2 };
+  }
+  const conflict = codexConfigConflict(existing);
+  if (conflict !== null)
+    return { kind: "conflict", reason: conflict };
+  const eol = lineEndingOf(existing);
+  const blockText = block.split("\n").join(eol);
+  const span = codexBlockSpan(existing);
+  if (span === "broken")
+    return { kind: "conflict", reason: "broken-markers" };
+  if (span === "none") {
+    const appended = `${existing.endsWith("\n") ? "" : eol}${eol}${blockText}${eol}`;
+    return { kind: "new", text: existing + appended, appended, block: `${blockText}${eol}` };
+  }
+  const old = existing.slice(span.start, span.end);
+  const ending = old.endsWith("\r\n") ? "\r\n" : old.endsWith("\n") ? "\n" : "";
+  const inFile = `${blockText}${ending}`;
+  const text = existing.slice(0, span.start) + inFile + existing.slice(span.end);
+  return text === existing ? { kind: "unchanged", block: inFile } : { kind: "new", text, appended: null, block: inFile };
+}
 var MCP_HEADERS_KNOWN_HEADER_HASHES = [
   "37a733ea588b3361b2bbfd86c44e0c95da30d7af6acffd1243ece83c811f0af2",
   "6732ec6d2d2bf7cb33017749a3d021b59af653dcd07c3811693b5a242d44b1a1"
@@ -7991,6 +8832,21 @@ function planCommandStubs(targetRepo, previous, writeSet) {
   const manifest = readPluginManifest();
   return { version: manifest.version, commands: planManifestCommands(manifest, targetRepo, previous, writeSet) };
 }
+function planCodexSkills(targetRepo, previous, writeSet) {
+  const manifest = readPluginManifest();
+  const recordedFiles = new Map((previous?.files ?? []).filter((file) => writeSet.files.has(file.path)).map((file) => [file.path, file]));
+  return (manifest.commands ?? []).map((cmd) => {
+    const srcFile = join6(BUNDLE_ROOT, ".claude-plugin", cmd.path);
+    if (!existsSync4(srcFile)) {
+      throw new Error(`[halfcycle] plugin.json declares command "${cmd.name}" at "${cmd.path}", but no file exists there (${srcFile}). The manifest and commands/ must agree.`);
+    }
+    const rel = skillRel(cmd.name);
+    const content = codexSkillContent(cmd.name, readFileSync6(srcFile, "utf-8"));
+    const recorded = recordedFiles.get(rel);
+    const planned = decideCollisionSafe(join6(targetRepo, rel), targetRepo, content, (current) => bytesAreOurs(rel, current, recorded, writeSet));
+    return { ...planned, editedCollided: planned.outcome === "collided" && recorded !== void 0 };
+  });
+}
 function planVendoredBinary(targetRepo) {
   return decideOwned(join6(targetRepo, ".halfcycle", "bin", "bin.bundle.mjs"), targetRepo, readFileSync6(resolveVendoredBinary(), "utf-8"));
 }
@@ -8038,9 +8894,156 @@ function putPlannedMcp(targetRepo, planned) {
     return;
   writeAllowlisted(join6(targetRepo, MCP_REGISTRATION_REL), targetRepo, planned.text, []);
 }
+function fileInFolderPlace(root, rel) {
+  for (let dir = posix2.dirname(rel); dir !== "."; dir = posix2.dirname(dir)) {
+    const found = lstatOrNull(join6(root, dir));
+    if (found !== null && !found.isDirectory())
+      return true;
+  }
+  return false;
+}
+function symlinkOnPath(root, rel) {
+  let current = root;
+  for (const segment of rel.split("/")) {
+    current = join6(current, segment);
+    try {
+      if (lstatSync(current).isSymbolicLink())
+        return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function planCodexHooks(targetRepo) {
+  const generated = codexHooksValue();
+  const leave = (outcome, before2) => ({
+    outcome,
+    before: before2,
+    existing: null,
+    generated,
+    text: null
+  });
+  if (symlinkOnPath(targetRepo, CODEX_HOOKS_REL2))
+    return leave("link", null);
+  const folder = lstatOrNull(join6(targetRepo, posix2.dirname(CODEX_HOOKS_REL2)));
+  if (folder !== null && !folder.isDirectory())
+    return leave("unreadable", null);
+  const path = join6(targetRepo, CODEX_HOOKS_REL2);
+  let before = null;
+  if (lstatOrNull(path) !== null) {
+    try {
+      before = readFileSync6(path, "utf-8");
+    } catch {
+      return leave("unreadable", null);
+    }
+  }
+  let existing = {};
+  if (before !== null) {
+    let value;
+    try {
+      value = JSON.parse(before);
+    } catch {
+      return leave("unreadable", before);
+    }
+    if (!isPlainObject2(value))
+      return leave("unreadable", before);
+    const hooks = value["hooks"];
+    if (hooks !== void 0 && !isPlainObject2(hooks))
+      return leave("unreadable", before);
+    const ourEvents = Object.keys(generated.hooks);
+    if (hooks !== void 0 && ourEvents.some((event) => event in hooks && !Array.isArray(hooks[event]))) {
+      return leave("unreadable", before);
+    }
+    existing = value;
+  }
+  const merged = mergeCodexHooks(existing, generated, AGENT_PROFILES.codex.commands);
+  if (before !== null && JSON.stringify(merged) === JSON.stringify(existing)) {
+    return { outcome: "current", before, existing, generated, text: null };
+  }
+  const text = inLineEndingOf(before, JSON.stringify(merged, null, 2) + "\n");
+  return { outcome: "written", before, existing: before === null ? null : existing, generated, text };
+}
+function putPlannedCodexHooks(targetRepo, planned) {
+  if (planned.outcome !== "written" || planned.text === null)
+    return;
+  writeAllowlisted(join6(targetRepo, CODEX_HOOKS_REL2), targetRepo, planned.text, []);
+}
+function readCodexConfig(targetRepo) {
+  const folder = lstatOrNull(join6(targetRepo, posix2.dirname(CODEX_CONFIG_REL2)));
+  if (folder !== null && !folder.isDirectory())
+    return "unreadable";
+  const path = join6(targetRepo, CODEX_CONFIG_REL2);
+  const stat = lstatOrNull(path);
+  if (stat === null)
+    return { text: null };
+  if (!stat.isFile())
+    return "unreadable";
+  let bytes;
+  try {
+    bytes = readFileSync6(path);
+  } catch {
+    return "unreadable";
+  }
+  const text = bytes.toString("utf-8");
+  return Buffer.from(text, "utf-8").equals(bytes) ? { text } : "unreadable";
+}
+function planCodexConfig(targetRepo, credential) {
+  const plan = (outcome, extra = {}) => ({
+    outcome,
+    before: null,
+    text: null,
+    appended: null,
+    inFile: null,
+    conflict: null,
+    blockKept: false,
+    ...extra
+  });
+  if (credential === void 0)
+    return plan("no-credential");
+  if (symlinkOnPath(targetRepo, CODEX_CONFIG_REL2))
+    return plan("link");
+  const read = readCodexConfig(targetRepo);
+  if (read === "unreadable")
+    return plan("conflict", { conflict: "unreadable" });
+  const before = read.text;
+  if (credential === "pending") {
+    const conflict = before === null ? null : codexConfigConflict(before);
+    return conflict === null ? plan("pending", { before }) : plan("conflict", { before, conflict });
+  }
+  const block = generateCodexConfigBlock(mcpEndpointUrl(credential.mcpUrl));
+  if (block === null)
+    return plan("refused-address", { before, blockKept: before !== null && holdsCodexBlock(before) });
+  const reconciled = reconcileCodexConfig(before, block);
+  switch (reconciled.kind) {
+    case "conflict":
+      return plan("conflict", { before, conflict: reconciled.reason });
+    case "unchanged":
+      return plan("current", { before, inFile: reconciled.block });
+    case "new":
+      return plan("written", { before, text: reconciled.text, appended: reconciled.appended, inFile: reconciled.block });
+  }
+}
+function putPlannedCodexConfig(targetRepo, planned) {
+  if (planned.outcome !== "written" || planned.text === null)
+    return;
+  writeAllowlisted(join6(targetRepo, CODEX_CONFIG_REL2), targetRepo, planned.text, []);
+}
 function planCrewRoster(targetRepo) {
   return decideOwned(join6(targetRepo, CREW_ROSTER_REL), targetRepo, renderCrewRoster());
 }
+function planCrewProfiles(targetRepo, previous, writeSet) {
+  const recordedFiles = new Map((previous?.files ?? []).filter((file) => writeSet.files.has(file.path)).map((file) => [file.path, file]));
+  return renderCrewProfiles().map(({ rel, text }) => {
+    const target = crewProfileTarget(targetRepo, rel);
+    if (symlinkOnPath(targetRepo, rel) || fileInFolderPlace(targetRepo, rel)) {
+      return { rel, text, outcome: "collided", replacedExisting: false, editedCollided: false };
+    }
+    const recorded = recordedFiles.get(rel);
+    const planned = decideCollisionSafe(target, targetRepo, text, (current) => bytesAreOurs(rel, current, recorded, writeSet));
+    return { ...planned, editedCollided: planned.outcome === "collided" && recorded !== void 0 };
+  });
+}
 function planInstallRecord(targetRepo, text) {
   return decideOwned(join6(targetRepo, INSTALL_MANIFEST_REL), targetRepo, text);
 }
@@ -8064,6 +9067,12 @@ function accountInstall(steps, actual) {
       report.editedCollidedPaths.push(command.rel);
     noteFile(draft, command.rel, command.outcome, actual.bytesAfter);
   }
+  for (const skill of steps.codexSkills) {
+    recordOwnedGenerated(report, skill);
+    if (skill.editedCollided)
+      report.editedCollidedPaths.push(skill.rel);
+    noteFile(draft, skill.rel, skill.outcome, actual.bytesAfter);
+  }
   noteFile(draft, VENDORED_BIN_REL, recordOwnedGenerated(report, steps.vendored), actual.bytesAfter);
   const settings = steps.settings;
   recordSettingsMerge(draft, settings.existing, settings.generated, settings.preexisted, settings.merged);
@@ -8121,6 +9130,8 @@ function accountInstall(steps, actual) {
     if (mcp.existing !== null)
       recordMcpAdoptionOnly(draft, mcp.existing);
   }
+  recordCodexHooksStep(report, draft, steps.codexHooks);
+  recordCodexConfigStep(report, draft, steps.codexConfig);
   recordGitignoreReconcile(draft, steps.gitignore.before, actual.gitignoreAfter, writeSet);
   if (actual.gitignore === "failed") {
     report.skippedPaths.push(".gitignore (write failed \u2014 see credential refusal)");
@@ -8163,6 +9174,12 @@ function accountInstall(steps, actual) {
     report.writtenPaths.push(BUNDLE_PIN_REL);
   noteFile(draft, BUNDLE_PIN_REL, "written", actual.bytesAfter);
   noteFile(draft, CREW_ROSTER_REL, recordOwnedGenerated(report, steps.crew), actual.bytesAfter);
+  for (const profile of steps.crewProfiles) {
+    recordOwnedGenerated(report, profile);
+    if (profile.editedCollided)
+      report.editedCollidedPaths.push(profile.rel);
+    noteFile(draft, profile.rel, profile.outcome, actual.bytesAfter);
+  }
   if (actual.stateExistsAfter)
     recordPerMachineFile(draft, BOOTSTRAP_STATE_REL);
   for (const dir of writeSet.dirs) {
@@ -8173,11 +9190,79 @@ function accountInstall(steps, actual) {
   assertManifestInWriteSet(installManifest, writeSet);
   return { report, installManifest, manifestText: serializeManifest(installManifest) };
 }
+function recordCodexHooksStep(report, draft, planned) {
+  switch (planned.outcome) {
+    case "unreadable":
+      report.skippedPaths.push(`${CODEX_HOOKS_REL2} (left as it is \u2014 it could not be read, so Codex's checks were not added)`);
+      return;
+    case "link":
+      report.skippedPaths.push(`${CODEX_HOOKS_REL2} (left as it is \u2014 it is a link Halfcycle does not follow)`);
+      return;
+    case "written":
+      (planned.before === null ? report.writtenPaths : report.mergedPaths).push(CODEX_HOOKS_REL2);
+      break;
+    case "current":
+      report.skippedPaths.push(CODEX_HOOKS_REL2);
+      break;
+  }
+  const existingHooks = planned.existing !== null && isPlainObject2(planned.existing["hooks"]) ? planned.existing["hooks"] : void 0;
+  const ours = AGENT_PROFILES.codex.commands;
+  const heldOurs = Object.values(existingHooks ?? {}).some((groups) => Array.isArray(groups) && groups.some((group) => isPlainObject2(group) && Array.isArray(group["hooks"]) && isHalfcycleEntry({ hooks: group["hooks"] }, ours)));
+  recordCodexHooks(draft, {
+    created: planned.before === null,
+    adopted: draft.previous === null && heldOurs,
+    hookCommands: Object.values(planned.generated.hooks).flatMap((groups) => groups.flatMap((group) => group.hooks.map((h) => h.command))),
+    eventsCreated: Object.keys(planned.generated.hooks).filter((event) => !(existingHooks && event in existingHooks)),
+    hooksCreated: planned.existing === null || planned.existing["hooks"] === void 0
+  });
+}
+function recordCodexConfigStep(report, draft, planned) {
+  const prev = draft.codexConfig;
+  const separatorOf = (block) => {
+    const at = block.indexOf(CODEX_CONFIG_OPEN_MARKER);
+    return at > 0 ? block.slice(0, at) : "";
+  };
+  switch (planned.outcome) {
+    case "written": {
+      (planned.before === null ? report.writtenPaths : report.mergedPaths).push(CODEX_CONFIG_REL2);
+      const block = planned.appended !== null ? planned.appended : planned.before === null ? planned.text : `${prev === void 0 ? "" : separatorOf(prev.block)}${planned.inFile}`;
+      recordCodexConfig(draft, { created: planned.before === null, block });
+      return;
+    }
+    case "current":
+      report.skippedPaths.push(CODEX_CONFIG_REL2);
+      if (prev === void 0)
+        recordCodexConfig(draft, { created: false, block: planned.inFile });
+      return;
+    case "no-credential":
+      report.skippedPaths.push(`${CODEX_CONFIG_REL2} (no MCP origin \u2014 no credential supplied)`);
+      return;
+    case "link":
+      report.skippedPaths.push(`${CODEX_CONFIG_REL2} (left as it is \u2014 it is a link Halfcycle does not follow)`);
+      return;
+    case "conflict":
+      report.skippedPaths.push(planned.conflict === "server-named" ? `${CODEX_CONFIG_REL2} (left as it is \u2014 it already names a "halfcycle" server, so Halfcycle did not add its own)` : planned.conflict === "broken-markers" ? `${CODEX_CONFIG_REL2} (left as it is \u2014 the lines marking Halfcycle's part of it are incomplete or repeated)` : `${CODEX_CONFIG_REL2} (left as it is \u2014 it could not be read, so Halfcycle did not add its entry)`);
+      return;
+    case "refused-address":
+      report.skippedPaths.push(planned.blockKept ? `${CODEX_CONFIG_REL2} (left as it is \u2014 the Halfcycle address cannot be passed to Codex safely; Halfcycle's existing entry in it was kept unchanged)` : `${CODEX_CONFIG_REL2} (not written \u2014 the Halfcycle address cannot be passed to Codex safely)`);
+      return;
+    case "pending":
+      throw new Error("[halfcycle] a plan still waiting for the service cannot be applied or recorded.");
+  }
+}
 function recordInstallRecord(report, planned) {
   recordOwnedGenerated(report, planned);
 }
 var SELF_BUILD_GITIGNORE_REL = ".halfcycle/.gitignore";
 var SELF_BUILD_GITIGNORE_TEXT = "bin/\n";
+var SELF_BUILD_WRITE_SET = [
+  BUNDLE_PIN_REL,
+  VENDORED_BIN_REL,
+  SELF_BUILD_GITIGNORE_REL,
+  CREW_ROSTER_REL,
+  MCP_REGISTRATION_REL,
+  ...renderCrewProfiles().map((profile) => profile.rel)
+];
 function mcpHasHalfcycleEntry(text) {
   const parsed = JSON.parse(text);
   if (parsed === null || typeof parsed !== "object")
@@ -8185,6 +9270,14 @@ function mcpHasHalfcycleEntry(text) {
   const servers = parsed.mcpServers;
   return servers !== null && typeof servers === "object" && MCP_SERVER_KEY in servers;
 }
+function writeMissingSelfBuildCrewProfiles(targetRepoRoot, report) {
+  for (const { rel, text } of renderCrewProfiles()) {
+    const target = crewProfileTarget(targetRepoRoot, rel);
+    if (existsSync4(target))
+      continue;
+    writeAllowlisted(target, targetRepoRoot, text, report.writtenPaths);
+  }
+}
 function installSelfBuild(options) {
   const { targetRepo, engagementId, credential, freshlyMinted, home } = options;
   assertEngagementId(engagementId);
@@ -8219,6 +9312,7 @@ function installSelfBuild(options) {
   if (!existsSync4(at(CREW_ROSTER_REL))) {
     writeCrewRoster(targetRepo, report);
   }
+  writeMissingSelfBuildCrewProfiles(targetRepo, report);
   if (!existsSync4(at(BUNDLE_PIN_REL))) {
     writeBundlePin(targetRepo, planBundlePin(targetRepo, version, engagementId, "self-build", void 0, credential.methodVersion), report.writtenPaths);
   }
@@ -9778,7 +10872,8 @@ function renderPreview(plan, missingGitForWindows, claudeMdWords) {
 
 // dist/doctor.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10, realpathSync as realpathSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
 import { join as join10 } from "node:path";
 var GUARD_RUNNER_REL2 = ".claude/hooks/guard-runner.sh";
 var CONNECTION_VERB = "check-connection";
@@ -9802,8 +10897,10 @@ function runDoctor(root, options) {
   const lines = [setUp.line, connection.signedIn, connection.connected, checksRunning, version];
   const failing = lines.filter((line) => !line.ok && !line.cascading).length;
   const closing = failing === 0 ? "Everything is working." : `${failing} of these ${failing === 1 ? "needs" : "need"} fixing; each line above says what to do.`;
+  const codex = codexLine(root, options);
+  const printed = codex === void 0 ? lines : [...lines.slice(0, 4), codex, ...lines.slice(4)];
   return {
-    text: [...lines.map((line) => line.text), closing].join("\n"),
+    text: [...printed.map((line) => line.text), closing].join("\n"),
     exitCode: failing === 0 ? 0 : 1
   };
 }
@@ -9993,6 +11090,88 @@ function versionNoLine(installed, current) {
   }
   return `Up to date: no. This folder has Halfcycle ${installed}; the newest is ${current}. To update, run ${HALFCYCLE_COMMAND} here.`;
 }
+var CODEX_EVENT_SNAKE = {
+  SessionStart: "session_start",
+  UserPromptSubmit: "user_prompt_submit",
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  Stop: "stop",
+  SubagentStop: "subagent_stop",
+  SessionEnd: "session_end"
+};
+function codexLine(root, options) {
+  const hooksPath = join10(root, CODEX_HOOKS_REL2);
+  if (!existsSync7(hooksPath))
+    return void 0;
+  const positions = codexEntryPositions(hooksPath);
+  if (positions === void 0) {
+    return { ok: false, text: `Codex: not complete. To repair it, run ${HALFCYCLE_COMMAND} here.` };
+  }
+  return codexApprovalStatus(root, positions, options) === "approved" ? { ok: true, text: "Codex: set up, and its checks are approved." } : {
+    ok: false,
+    text: "Codex: set up, but its checks are not approved yet. Open this folder in Codex and type /hooks to approve each Halfcycle entry."
+  };
+}
+function codexEntryPositions(hooksPath) {
+  const parsed = readJson(hooksPath);
+  if (!isObject(parsed) || !isObject(parsed["hooks"]))
+    return void 0;
+  const positions = [];
+  for (const entry of AGENT_PROFILES.codex.wiring) {
+    const groups = parsed["hooks"][entry.event];
+    if (!Array.isArray(groups))
+      return void 0;
+    let found;
+    for (let g = 0; g < groups.length && found === void 0; g += 1) {
+      const group = groups[g];
+      if (!isObject(group) || !Array.isArray(group["hooks"]))
+        continue;
+      for (let h = 0; h < group["hooks"].length; h += 1) {
+        const hook = group["hooks"][h];
+        if (isObject(hook) && hook["command"] === entry.command) {
+          found = { group: g, hook: h };
+          break;
+        }
+      }
+    }
+    if (found === void 0)
+      return void 0;
+    positions.push({ event: entry.event, group: found.group, hook: found.hook });
+  }
+  return positions;
+}
+function codexApprovalStatus(root, positions, options) {
+  const codexHome = options.env["CODEX_HOME"];
+  const configPath = join10(codexHome !== void 0 && codexHome !== "" ? codexHome : join10(homedir4(), ".codex"), "config.toml");
+  let text;
+  try {
+    text = readFileSync10(configPath, "utf-8");
+  } catch {
+    return "not-approved";
+  }
+  let hooksPath;
+  try {
+    hooksPath = join10(realpathSync3(root), CODEX_HOOKS_REL2);
+  } catch {
+    return "not-approved";
+  }
+  const fileLines = text.split("\n");
+  for (const { event, group, hook } of positions) {
+    const key = `${hooksPath}:${CODEX_EVENT_SNAKE[event] ?? event}:${group}:${hook}`;
+    const headers = [`[hooks.state."${key}"]`, `[hooks.state.'${key}']`];
+    const start = fileLines.findIndex((line) => headers.includes(line.trim()));
+    if (start === -1)
+      return "not-approved";
+    for (let i = start + 1; i < fileLines.length; i += 1) {
+      const trimmed = fileLines[i].trim();
+      if (trimmed.startsWith("["))
+        break;
+      if (trimmed === "enabled = false")
+        return "not-approved";
+    }
+  }
+  return "approved";
+}
 function notChecked(check, earlier) {
   return { ok: false, cascading: true, text: `${check}: not checked, because ${earlier} is not working yet.` };
 }
@@ -10167,19 +11346,18 @@ async function probeMcpOrigin(mcpUrl, token) {
 
 // dist/claude-version-probe.js
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync8, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync8, realpathSync as realpathSync4 } from "node:fs";
 import { delimiter as delimiter2, join as join12 } from "node:path";
-function probeClaudeCodeVersion(timeoutMs, deps = {}) {
+function execVersionCommand(command, timeoutMs, deps) {
   const platform6 = deps.platform ?? process.platform;
   const exec = deps.exec ?? execFileSync3;
-  let raw;
   try {
-    raw = platform6 === "win32" ? exec("cmd.exe", ["/d", "/s", "/c", '"claude --version"'], {
+    return platform6 === "win32" ? exec("cmd.exe", ["/d", "/s", "/c", `"${command} --version"`], {
       encoding: "utf-8",
       timeout: timeoutMs,
       stdio: ["ignore", "pipe", "ignore"],
       windowsVerbatimArguments: true
-    }) : exec("claude", ["--version"], {
+    }) : exec(command, ["--version"], {
       encoding: "utf-8",
       timeout: timeoutMs,
       stdio: ["ignore", "pipe", "ignore"]
@@ -10187,7 +11365,14 @@ function probeClaudeCodeVersion(timeoutMs, deps = {}) {
   } catch {
     return void 0;
   }
-  return /(\d+\.\d+\.\d+)/.exec(raw)?.[1];
+}
+function probeClaudeCodeVersion(timeoutMs, deps = {}) {
+  const raw = execVersionCommand("claude", timeoutMs, deps);
+  return raw === void 0 ? void 0 : /(\d+\.\d+\.\d+)/.exec(raw)?.[1];
+}
+function probeCodexVersion(timeoutMs, deps = {}) {
+  const raw = execVersionCommand("codex", timeoutMs, deps);
+  return raw === void 0 ? void 0 : /^codex-cli (\d+\.\d+\.\d+)/.exec(raw)?.[1];
 }
 var CLAUDE_CODE_INSTALL_PAGE = "https://claude.com/claude-code";
 var UPGRADE_COMMANDS = {
@@ -10208,7 +11393,7 @@ function probeClaudeCodeInstallMethod(deps = {}) {
   const exists = deps.exists ?? existsSync8;
   const realpath = deps.realpath ?? ((file) => {
     try {
-      return realpathSync3(file);
+      return realpathSync4(file);
     } catch {
       return file;
     }
@@ -10227,6 +11412,30 @@ function probeClaudeCodeInstallMethod(deps = {}) {
   return void 0;
 }
 
+// dist/codex-install-lines.js
+var CODEX_APPROVAL_LINE = "[halfcycle] Using Codex? Open this folder in Codex and trust it when asked. Then type /hooks and approve each Halfcycle entry \u2014 until you do, Codex works without Halfcycle checking its edits. Then type $halfcycle-setup and answer what it asks about your project.";
+var CODEX_LINK_LINE = "[halfcycle] Codex: this project's Codex settings are a link Halfcycle does not follow, so Codex is not set up here. Codex sessions here will not reach Halfcycle.";
+var CODEX_CONFLICT_LINE = `[halfcycle] Codex: this project's Codex settings already name a "halfcycle" server, so Halfcycle did not add its own. Codex sessions here will not reach Halfcycle until that entry is removed and this is run again.`;
+var CODEX_REFUSED_ADDRESS_LINE = "[halfcycle] Codex: this project's Halfcycle address cannot be passed to Codex safely, so Codex sessions here will not reach Halfcycle.";
+var CODEX_UNREADABLE_HOOKS_LINE = "[halfcycle] Codex: this project's Codex checks file could not be read, so Halfcycle did not add its checks. Codex sessions here will not be checked until it is fixed and this is run again.";
+var CODEX_MIN_VERSION = "0.166.0";
+function codexVersionWarningLine(version) {
+  return `[halfcycle] WARNING: Codex ${version} is older than ${CODEX_MIN_VERSION}, which Halfcycle needs. Update Codex, then reopen this folder.`;
+}
+function codexInstallLine(codex) {
+  if (codex.hooks === "link" || codex.config === "link")
+    return CODEX_LINK_LINE;
+  if (codex.hooks === "unreadable")
+    return CODEX_UNREADABLE_HOOKS_LINE;
+  if (codex.config === "conflict")
+    return CODEX_CONFLICT_LINE;
+  if (codex.config === "refused-address")
+    return CODEX_REFUSED_ADDRESS_LINE;
+  if (codex.config === "no-credential")
+    return void 0;
+  return CODEX_APPROVAL_LINE;
+}
+
 // dist/build-record/write.js
 import { existsSync as existsSync9, mkdirSync as mkdirSync7, rmSync as rmSync4 } from "node:fs";
 import { basename as basename2, join as join13, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "node:path";
@@ -10969,7 +12178,7 @@ import { existsSync as existsSync11, readFileSync as readFileSync16 } from "node
 import { join as join19 } from "node:path";
 
 // dist/draw/write.js
-import { closeSync as closeSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync8, openSync as openSync2, readFileSync as readFileSync13, readSync, realpathSync as realpathSync4, rmSync as rmSync5 } from "node:fs";
+import { closeSync as closeSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync8, openSync as openSync2, readFileSync as readFileSync13, readSync, realpathSync as realpathSync5, rmSync as rmSync5 } from "node:fs";
 import { dirname as dirname6, isAbsolute as isAbsolute4, join as join14, relative as relative3, resolve as resolve4, sep } from "node:path";
 var DOCS_DIR = "docs";
 var DIAGRAMS_DIR = "diagrams";
@@ -11057,7 +12266,7 @@ function isInside(outer, inner) {
 function checkDiagramPlace(paths) {
   let root;
   try {
-    root = realpathSync4(paths.repoRoot);
+    root = realpathSync5(paths.repoRoot);
   } catch {
     return { ok: false, why: `the folder ${paths.repoRoot} could not be opened. Check the path, then run this again.` };
   }
@@ -11070,7 +12279,7 @@ function checkDiagramPlace(paths) {
   }
   let real;
   try {
-    real = realpathSync4(ancestor);
+    real = realpathSync5(ancestor);
   } catch {
     return {
       ok: false,
@@ -12927,23 +14136,36 @@ function typedLine(act, reference, part) {
       return `drop ${reference}/${part}: <why>`;
   }
 }
-function rv7Lines(view) {
+function rv7aLine(reference) {
+  return `The line accept ${reference} also accepts every check nobody ran that is listed below. Reject a task's checks first if you do not accept them.`;
+}
+function tasksWithWaitingClaims(claims) {
+  return [...new Set(claims.filter((c) => c.answer === null).map((c) => c.task))];
+}
+function rv7Lines(view, claims) {
   const reference = typedPhaseReference(view.phase, view.number);
-  if (view.parts.length === 0)
-    return [`This phase has no parts to review. To close it, type: accept ${reference}`];
+  const claimTasks = tasksWithWaitingClaims(claims);
   const decidable = view.parts.filter((p) => p.decidable);
-  if (decidable.length === 0)
-    return ["No part waits for your decision now."];
+  if (claimTasks.length === 0) {
+    if (view.parts.length === 0)
+      return [`This phase has no parts to review. To close it, type: accept ${reference}`];
+    if (decidable.length === 0)
+      return ["No part waits for your decision now."];
+  }
   const lines = ["To decide, type one of these lines in your own Claude Code session:"];
   for (const part of decidable) {
     for (const act of reviewActsFor(part.built))
       lines.push(`  ${typedLine(act, reference, part.part)}`);
   }
-  if (decidable.some((p) => p.built))
+  for (const task of claimTasks)
+    lines.push(`  reject ${reference}/${task}: <why>`);
+  if (decidable.some((p) => p.built) || claimTasks.length > 0)
     lines.push(`  accept ${reference}`);
+  if (claimTasks.length > 0)
+    lines.push(rv7aLine(reference));
   return lines;
 }
-function reviewListingLines(view) {
+function reviewListingLines(view, claims = []) {
   const lines = [rv1Line(view)];
   if (!view.counted)
     lines.push(RV1A_LINE);
@@ -12951,7 +14173,7 @@ function reviewListingLines(view) {
     lines.push(...observedPhaseLines(view.observed));
   for (const part of view.parts)
     lines.push(...partLines(part, view));
-  lines.push(...rv7Lines(view));
+  lines.push(...rv7Lines(view, claims));
   return lines;
 }
 var CALLS_HEADING2 = "Calls made without asking you";
@@ -12976,21 +14198,17 @@ var CHECKS_SUBHEADING = "An agent says these pass and Halfcycle never ran them.
 function uncheckedClaimLine(test) {
   return `Unchecked: ${test.claimedBy} says "${test.label}" passes. Halfcycle never ran it.`;
 }
-function answerClaimsInSystemViewLine(engagementId, phase) {
-  const address = systemViewUrl(engagementId, phase);
-  const only = "Accept or reject each one in the System view; this cannot be done by typing in chat";
-  return address === void 0 ? `${only}.` : `${only}: ${address}`;
-}
-function checksSectionLines(work, engagementId) {
+var ANSWER_CLAIMS_BY_TYPING_LINE = "To answer them, type the reject or accept line listed above in your own Claude Code session.";
+function checksSectionLines(work) {
   const unchecked = work.tasks.flatMap((task) => task.tests.filter((t) => t.state === "unchecked"));
   if (unchecked.length === 0)
     return [];
-  return [CHECKS_HEADING, CHECKS_SUBHEADING, ...unchecked.map(uncheckedClaimLine), answerClaimsInSystemViewLine(engagementId, work.phase)];
+  return [CHECKS_HEADING, CHECKS_SUBHEADING, ...unchecked.map(uncheckedClaimLine), ANSWER_CLAIMS_BY_TYPING_LINE];
 }
-function workSectionLines(work, engagementId) {
+function workSectionLines(work, _engagementId) {
   if (work === null)
     return [];
-  return [...callsSectionLines(work.calls), ...checksSectionLines(work, engagementId)];
+  return [...callsSectionLines(work.calls), ...checksSectionLines(work)];
 }
 function rv8Line(view) {
   if (view.state === "closed") {
@@ -13132,7 +14350,8 @@ async function runReviewShow(repoRoot, phase, deps) {
   if (view.state !== "open")
     return refused(rv8Line(view));
   const work = await deps.readWork(credential, phase);
-  const stdout = `${[...reviewListingLines(view), ...workSectionLines(work.kind === "work" ? work.work : null, credential.engagementId)].join("\n")}
+  const phaseWork = work.kind === "work" ? work.work : null;
+  const stdout = `${[...reviewListingLines(view, phaseWork?.uncheckedClaims ?? []), ...workSectionLines(phaseWork, credential.engagementId)].join("\n")}
 `;
   const written = deps.recordShown(credential.engagementId, shownReviewEntry(view, deps.now().toISOString()));
   if (!written.ok)
@@ -14234,6 +15453,35 @@ function readJsonFile(repoRoot, rel, parse) {
   }
   return { kind: "ok", value: parsed.data };
 }
+function readSystemParts(repoRoot) {
+  const file = readDescriptionFile(repoRoot);
+  if (file.kind === "missing")
+    return { kind: "none" };
+  if (file.kind === "unreadable") {
+    return {
+      kind: "bad",
+      line: `${SYSTEM_DESCRIPTION_REL} could not be read. Check that it is a file you can open, then run this again.
+`
+    };
+  }
+  if (file.kind === "not-json") {
+    return {
+      kind: "bad",
+      line: `${SYSTEM_DESCRIPTION_REL} is not valid JSON (${file.error}). Fix it, then run this again.
+`
+    };
+  }
+  const checked = checkSystemDescription(file.value);
+  if (!checked.ok) {
+    const n = checked.problems.length;
+    return {
+      kind: "bad",
+      line: `${SYSTEM_DESCRIPTION_REL} has ${n} ${n === 1 ? "problem" : "problems"}, so the plan could not be checked against it:
+` + problemLines(file.value, checked.problems)
+    };
+  }
+  return { kind: "ok", partIds: checked.description.parts.map((part) => part.id) };
+}
 function runCheckTasks(repoRoot, phase, withTaskList) {
   const p = "halfcycle check-tasks:";
   const planRead = readJsonFile(repoRoot, TASK_PLAN_FILE, (raw) => taskPlanSchema.safeParse(raw));
@@ -14259,7 +15507,15 @@ function runCheckTasks(repoRoot, phase, withTaskList) {
     }
     taskList = { file: listRead.kind === "ok" ? listRead.value : null };
   }
-  const result = checkTaskPlan(plan, { phase, taskList });
+  const system = readSystemParts(repoRoot);
+  if (system.kind === "bad") {
+    return { stdout: "", stderr: `${p} ${system.line}`, exitCode: 2 };
+  }
+  const result = checkTaskPlan(plan, {
+    phase,
+    taskList,
+    ...system.kind === "ok" ? { system: { file: SYSTEM_DESCRIPTION_REL, partIds: system.partIds } } : {}
+  });
   const stdout = result.lines.map((line) => `${line.text}
 `).join("");
   return { stdout, stderr: "", exitCode: result.refused ? 1 : 0 };
@@ -14318,7 +15574,7 @@ function runProveChild(binary, credential, repoRoot, words, deps = {}) {
 
 // dist/uninstall.js
 import { lstatSync as lstatSync3, readFileSync as readFileSync19, readdirSync, rmSync as rmSync6, rmdirSync, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { dirname as dirname7, join as join22, relative as relative6, sep as sep2 } from "node:path";
 var REMOVE_CREDENTIAL_FLAG = "--remove-credential";
 function parseUninstallArgs(args2) {
@@ -14342,19 +15598,6 @@ function lexists(path) {
     return false;
   }
 }
-function symlinkOnPath(root, rel) {
-  let current = root;
-  for (const segment of rel.split("/")) {
-    current = join22(current, segment);
-    try {
-      if (lstatSync3(current).isSymbolicLink())
-        return true;
-    } catch {
-      return false;
-    }
-  }
-  return false;
-}
 function isPlainObject3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -14432,7 +15675,7 @@ function validate(options, rules) {
       throw new Refusal(`the project id in ${BUNDLE_PIN_REL} is not a valid Halfcycle project id, so it cannot name a folder on this machine. Nothing was removed, here or under ~/.halfcycle.`);
     }
     if (engagementId !== void 0) {
-      const expectedParent = join22(home ?? homedir4(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
+      const expectedParent = join22(home ?? homedir5(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
       if (dirname7(engagementStateDir(engagementId, home)) !== expectedParent) {
         throw new Refusal(`the project id in ${BUNDLE_PIN_REL} does not name a folder under ~/.halfcycle/engagements. Nothing was removed.`);
       }
@@ -14443,14 +15686,16 @@ function validate(options, rules) {
     engagementId,
     idValid,
     settings: readMergedJson(targetRepo, rules.settings),
-    mcp: readMergedJson(targetRepo, rules.mcp)
+    mcp: readMergedJson(targetRepo, rules.mcp),
+    codexHooks: readMergedJson(targetRepo, rules.codexHooks)
   };
 }
 function mergedFileRules(writeSet) {
   const spelledIn = (spellings) => (text) => spellings.some((spelling) => text.includes(spelling));
   return {
     settings: { rel: SETTINGS_REL, holdsOurs: spelledIn([...writeSet.hookCommands].map((c) => JSON.stringify(c))) },
-    mcp: { rel: MCP_REGISTRATION_REL, holdsOurs: spelledIn([JSON.stringify(MCP_SERVER_KEY)]) }
+    mcp: { rel: MCP_REGISTRATION_REL, holdsOurs: spelledIn([JSON.stringify(MCP_SERVER_KEY)]) },
+    codexHooks: { rel: CODEX_HOOKS_REL2, holdsOurs: spelledIn([...writeSet.codexHookCommands].map((c) => JSON.stringify(c))) }
   };
 }
 function writeBack(targetRepo, rel, current, next, lists, name) {
@@ -14539,48 +15784,12 @@ function ourMcpServers(value) {
   return isPlainObject3(servers) && MCP_SERVER_KEY in servers ? servers : null;
 }
 function unmergeSettings(value, rec, writeSet) {
-  let changed = false;
   const refused3 = [];
-  const commands = new Set(writeSet.hookCommands);
   const denyHashes = rec.denyAddedSha256.filter((h) => writeSet.denyRuleSha256.has(h));
   if (denyHashes.length < rec.denyAddedSha256.length) {
     refused3.push(`${SETTINGS_REL}: a deny rule the install record names but Halfcycle never adds (it was kept)`);
   }
-  const hooks = value["hooks"];
-  if (isPlainObject3(hooks)) {
-    const ours = new Set(ourHookEntries(value, commands).map(({ entry }) => entry));
-    let emptiedAnEvent = false;
-    for (const event of Object.keys(hooks)) {
-      const entries = hooks[event];
-      if (!Array.isArray(entries))
-        continue;
-      let touched = false;
-      const next = [];
-      for (const entry of entries) {
-        if (!ours.has(entry)) {
-          next.push(entry);
-          continue;
-        }
-        touched = true;
-        const remaining = withoutHalfcycleCommands(entry, commands);
-        if (remaining !== null)
-          next.push(remaining);
-      }
-      if (touched)
-        changed = true;
-      if (next.length === 0 && (rec.eventsCreated.includes(event) || rec.adopted && touched)) {
-        delete hooks[event];
-        changed = true;
-        emptiedAnEvent = true;
-      } else if (touched) {
-        hooks[event] = next;
-      }
-    }
-    if (Object.keys(hooks).length === 0 && (rec.hooksCreated || rec.adopted && emptiedAnEvent)) {
-      delete value["hooks"];
-      changed = true;
-    }
-  }
+  let changed = unmergeHooks(value, rec, new Set(writeSet.hookCommands));
   const permissions = value["permissions"];
   if (isPlainObject3(permissions) && Array.isArray(permissions["deny"])) {
     const deny = permissions["deny"];
@@ -14616,6 +15825,52 @@ function unmergeSettings(value, rec, writeSet) {
   }
   return { changed, refused: refused3 };
 }
+function unmergeHooks(value, rec, commands) {
+  const hooks = value["hooks"];
+  if (!isPlainObject3(hooks))
+    return false;
+  let changed = false;
+  const ours = new Set(ourHookEntries(value, commands).map(({ entry }) => entry));
+  let emptiedAnEvent = false;
+  for (const event of Object.keys(hooks)) {
+    const entries = hooks[event];
+    if (!Array.isArray(entries))
+      continue;
+    let touched = false;
+    const next = [];
+    for (const entry of entries) {
+      if (!ours.has(entry)) {
+        next.push(entry);
+        continue;
+      }
+      touched = true;
+      const remaining = withoutHalfcycleCommands(entry, commands);
+      if (remaining !== null)
+        next.push(remaining);
+    }
+    if (touched)
+      changed = true;
+    if (next.length === 0 && (rec.eventsCreated.includes(event) || rec.adopted && touched)) {
+      delete hooks[event];
+      changed = true;
+      emptiedAnEvent = true;
+    } else if (touched) {
+      hooks[event] = next;
+    }
+  }
+  if (Object.keys(hooks).length === 0 && (rec.hooksCreated || rec.adopted && emptiedAnEvent)) {
+    delete value["hooks"];
+    changed = true;
+  }
+  return changed;
+}
+var BEFORE_UNKNOWN_CODEX_HOOKS = {
+  created: false,
+  adopted: true,
+  hookCommands: [],
+  eventsCreated: [],
+  hooksCreated: false
+};
 function unmergeMcp(value, rec) {
   const servers = value["mcpServers"];
   if (!isPlainObject3(servers))
@@ -14723,7 +15978,8 @@ function coveredPathExists(targetRepo, line) {
 function selfBuildMergedFileRules() {
   return {
     settings: { rel: SETTINGS_REL, holdsOurs: () => false },
-    mcp: { rel: MCP_REGISTRATION_REL, holdsOurs: (text) => text.includes(JSON.stringify(MCP_SERVER_KEY)) }
+    mcp: { rel: MCP_REGISTRATION_REL, holdsOurs: (text) => text.includes(JSON.stringify(MCP_SERVER_KEY)) },
+    codexHooks: { rel: CODEX_HOOKS_REL2, holdsOurs: () => false }
   };
 }
 function removeSelfBuildOwnedFile(targetRepo, rel, lists, name) {
@@ -14777,6 +16033,33 @@ function removeSelfBuildCrewRoster(targetRepo, lists, name) {
     name(lists.failed, rel, rel);
   }
 }
+function removeSelfBuildCrewProfile(targetRepo, rel, text, lists, name) {
+  if (symlinkOnPath(targetRepo, rel)) {
+    name(lists.leftAlone, `${rel} (a symbolic link, or inside one \u2014 not followed)`, rel);
+    return;
+  }
+  const abs = join22(targetRepo, rel);
+  let bytes;
+  try {
+    bytes = readFileSync19(abs);
+  } catch {
+    return;
+  }
+  if (!lstatSync3(abs).isFile()) {
+    name(lists.leftAlone, `${rel} (not a file)`, rel);
+    return;
+  }
+  if (bytes.toString("utf-8") !== text) {
+    name(lists.kept, rel, rel);
+    return;
+  }
+  try {
+    rmSync6(abs);
+    name(lists.removed, rel, rel);
+  } catch {
+    name(lists.failed, rel, rel);
+  }
+}
 function removeSelfBuildEmptyDir(targetRepo, dir, lists, name) {
   if (symlinkOnPath(targetRepo, dir))
     return;
@@ -14826,8 +16109,13 @@ function uninstallSelfBuild(options) {
     removeSelfBuildOwnedFile(targetRepo, rel, result, name);
   }
   removeSelfBuildCrewRoster(targetRepo, result, name);
+  for (const { rel, text } of renderCrewProfiles()) {
+    removeSelfBuildCrewProfile(targetRepo, rel, text, result, name);
+  }
   removeSelfBuildEmptyDir(targetRepo, ".halfcycle/bin", result, name);
   removeSelfBuildEmptyDir(targetRepo, ".halfcycle", result, name);
+  removeSelfBuildEmptyDir(targetRepo, ".codex/agents", result, name);
+  removeSelfBuildEmptyDir(targetRepo, ".codex", result, name);
   const foundNothing = result.removed.length + result.restored.length + result.kept.length + result.failed.length === 0;
   if (!pinExisted && foundNothing) {
     return { outcome: "not-installed", exitCode: 0, ...result, credential: nothingToSay };
@@ -14863,6 +16151,7 @@ function uninstall(options) {
   const { targetRepo } = options;
   const manifest = checked.manifest ?? noRecord(targetRepo, writeSet);
   const deleteWhenEmpty = (created) => created || checked.manifest === null;
+  const deleteCodexWhenEmpty = (record2) => record2 === void 0 || deleteWhenEmpty(record2.created);
   const named = /* @__PURE__ */ new Set();
   const name = (list2, text, path) => {
     list2.push(text);
@@ -14881,6 +16170,13 @@ function uninstall(options) {
     changed: unmergeMcp(value, mcpRecord).changed,
     adopted: false
   }));
+  const codexRecord = manifest.codexHooks ?? BEFORE_UNKNOWN_CODEX_HOOKS;
+  const codexCommands = new Set(writeSet.codexHookCommands);
+  applyMergedJson(targetRepo, rules.codexHooks, checked.codexHooks, deleteCodexWhenEmpty(manifest.codexHooks), result, name, (value) => ({
+    changed: unmergeHooks(value, codexRecord, codexCommands),
+    adopted: false
+  }));
+  removeCodexConfigBlock(targetRepo, manifest.codexConfig, deleteCodexWhenEmpty(manifest.codexConfig), result, name);
   const deferred = /* @__PURE__ */ new Set([BUNDLE_PIN_REL, INSTALL_MANIFEST_REL]);
   const recorded = new Map(manifest.files.map((entry) => [entry.path, entry]));
   for (const path of [.../* @__PURE__ */ new Set([...recorded.keys(), ...writeSet.files])].sort()) {
@@ -14964,6 +16260,44 @@ function applyMergedJson(targetRepo, rule, file, deleteWhenEmpty, lists, name, e
     name(lists.leftAlone, `${rel} (Halfcycle's hooks were taken out. There is no record of this file from before the install, so a permission rule or "$schema" Halfcycle added may still be there \u2014 it cannot be told apart from your own)`, rel);
   }
 }
+function removeCodexConfigBlock(targetRepo, record2, deleteWhenEmpty, lists, name) {
+  const rel = CODEX_CONFIG_REL2;
+  const path = join22(targetRepo, rel);
+  if (symlinkOnPath(targetRepo, rel)) {
+    if (lexists(path))
+      name(lists.leftAlone, `${rel} (a symbolic link, or inside one \u2014 not followed)`, rel);
+    return;
+  }
+  let text;
+  try {
+    if (!lstatSync3(path).isFile())
+      return;
+    text = readFileSync19(path, "utf-8");
+  } catch {
+    return;
+  }
+  const span = codexBlockSpan(text);
+  if (span === "none")
+    return;
+  const changed = () => name(lists.kept, `${rel} (Halfcycle's part of it was changed after it was written, so it was kept)`, rel);
+  if (span === "broken")
+    return changed();
+  let cut = null;
+  const at = record2 === void 0 ? -1 : record2.block.indexOf(CODEX_CONFIG_OPEN_MARKER);
+  if (record2 !== void 0 && at >= 0) {
+    const found = regeneratesCodexBlock(record2.block.slice(at)) ? lastOccurrence(text, record2.block) : null;
+    if (found !== null)
+      cut = found;
+  } else if (regeneratesCodexBlock(text.slice(span.start, span.end))) {
+    cut = span;
+  }
+  if (cut === null)
+    return changed();
+  const head = text.slice(0, cut.start);
+  const tail = text.slice(cut.end);
+  const next = head + (head !== "" && tail !== "" && !head.endsWith("\n") ? lineEndingOf(text) : "") + tail;
+  writeBack(targetRepo, rel, text, next === "" && deleteWhenEmpty ? null : next, lists, name);
+}
 function removeInstalledFile(targetRepo, path, entry, writeSet, lists, name) {
   if (!writeSet.files.has(path)) {
     name(lists.leftAlone, `${path} (Halfcycle never writes this path, so it was not removed)`, path);
@@ -15095,7 +16429,7 @@ function filesUnder(root, rel) {
   return out;
 }
 function shownPath(path, home) {
-  const base = home ?? homedir4();
+  const base = home ?? homedir5();
   const rel = relative6(base, path);
   const under = rel !== "" && !rel.startsWith("..") && !rel.startsWith(sep2);
   return `${under ? `~/${rel.split(sep2).join("/")}` : path}/`;
@@ -15177,9 +16511,13 @@ function bundleVersion() {
 function claudeCodeVersion(deps = {}) {
   return probeClaudeCodeVersion(3e3, deps);
 }
+function codexVersion(deps = {}) {
+  return probeCodexVersion(3e3, deps);
+}
 var REAL_PROBES = {
   bundleVersion,
   claudeCodeVersion,
+  codexVersion,
   projectName: (dir) => {
     try {
       return deriveProjectName(dir);
@@ -15227,6 +16565,9 @@ function openingBannerContent(projectDir, env = process.env, probes = REAL_PROBE
   const facts = [
     fact("Version", version, version),
     fact("Claude Code", probes.claudeCodeVersion()),
+    // Beside the `Claude Code` row, same rule: a probe that cannot answer omits the
+    // row rather than guessing (`codex-install-target`, *The Codex version*).
+    fact("Codex", probes.codexVersion()),
     fact("Project", project, name),
     fact("Status", status, installed === void 0 ? "new" : "installed"),
     // `Website`, NOT `Plane` — see this function's docblock. (No issue number here:
@@ -15399,8 +16740,8 @@ async function runPace(repoRoot, start, deps) {
 
 // dist/restore.js
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { closeSync as closeSync3, fchmodSync, lstatSync as lstatSync4, mkdirSync as mkdirSync11, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync21, readlinkSync, realpathSync as realpathSync5, rmSync as rmSync7, symlinkSync, writeSync as writeSync2 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { closeSync as closeSync3, fchmodSync, lstatSync as lstatSync4, mkdirSync as mkdirSync11, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync21, readlinkSync, realpathSync as realpathSync6, rmSync as rmSync7, symlinkSync, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import { join as join24, resolve as resolve7 } from "node:path";
 var RESTORE_USAGE = `${HALFCYCLE_COMMAND} restore [<id>]`;
 function parseRestoreArgs(rest) {
@@ -15423,7 +16764,7 @@ function runRestore(cwd, id, options = {}) {
   if (engagementId === null) {
     return refused2(`Halfcycle is not set up in this project, so it has saved nothing here. To set it up, run: ${HALFCYCLE_COMMAND}`);
   }
-  const folder = join24(options.home ?? homedir5(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
+  const folder = join24(options.home ?? homedir6(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
   const refs = savedRefs(root);
   if (refs === null)
     return refused2("Halfcycle could not read the saved copies in this project, so nothing was put back.");
@@ -15809,7 +17150,7 @@ function lstatOrNull3(p) {
 }
 function realOrSelf(p) {
   try {
-    return realpathSync5(p);
+    return realpathSync6(p);
   } catch {
     return p;
   }
@@ -15856,6 +17197,15 @@ function reportClaudeCodeVersion(verbose2, deps = {}) {
   process.stdout.write(`[halfcycle] WARNING: Claude Code ${version} is older than ${MIN_HEADERS_HELPER_VERSION}, which ignores the credential helper this install wrote. The Halfcycle server will connect with no credential and every call will fail \u2014 ${upgradeInstruction}, then re-open this folder.
 `);
 }
+function reportCodexVersion(deps = {}) {
+  const version = probeCodexVersion(5e3, deps);
+  if (version === void 0)
+    return;
+  if (compareVersions(version, CODEX_MIN_VERSION) < 0) {
+    process.stdout.write(`${codexVersionWarningLine(version)}
+`);
+  }
+}
 function shortId(id) {
   return id.length > 10 ? `${id.slice(0, 8)}\u2026` : id;
 }
@@ -16289,6 +17639,7 @@ ${PROJECT_RESET_LINE}
 `);
       }
       reportClaudeCodeVersion(verbose);
+      reportCodexVersion();
       const identity = actingIdentity ?? heldAnswer?.identity ?? (credential && heldAnswer === void 0 ? await describeAccount(credential.serviceUrl, credential.token) : void 0);
       const written = result.writtenPaths.length;
       const merged = result.mergedPaths.length;
@@ -16315,6 +17666,10 @@ ${PROJECT_RESET_LINE}
         process.stdout.write(`[halfcycle] Next: open this folder in Claude Code \u2014 accept the workspace-trust prompt, it is expected \u2014 then say "set up this project" and answer what it asks about your project
 `);
         process.stdout.write(`[halfcycle] Claude Code will then ask you to approve the new "halfcycle" MCP server. If it is the only one listed, the cursor starts on "Continue without using this MCP server" \u2014 choose "Use this MCP server" instead. If several are listed together, halfcycle is already checked \u2014 leave it that way. Either way, without it Halfcycle will not connect.
+`);
+        const codexLine2 = codexInstallLine(result.codex);
+        if (codexLine2 !== void 0)
+          process.stdout.write(`${codexLine2}
 `);
       }
       const consoleUrl = credential?.consoleUrl ?? (reusedWithoutFreshAnswer ? readBundlePin(targetRepo)?.projectPage : void 0);