@cairnkeep/cli 2.11.0 → 2.12.0

package/scripts/test-bootstrap-untracked.sh

@@ -55,6 +55,7 @@ git -C "$tmp/repo" init -q
 [[ -f "$tmp/repo/.ai/start-claude.sh" ]] || fail "scaffold missing"
 [[ -x "$tmp/repo/.ai/start-kimi.sh" ]] || fail "Kimi launcher missing"
 [[ -x "$tmp/repo/.ai/start-qwen.sh" ]] || fail "Qwen launcher missing"
+[[ -x "$tmp/repo/.ai/start-codex.sh" ]] || fail "Codex launcher missing"
 [[ -f "$tmp/repo/.planning/config.json" ]] || fail "planning layer missing"
 graph_policy="$tmp/repo/.planning/graphs/policy.md"
 grep -qF '`uv tool install graphifyy`' "$graph_policy" ||
@@ -89,7 +90,7 @@ grep -qxF "/.agentfs/" "$tmp/repo/.git/info/exclude" || fail "missing /.agentfs/
 printf '%s\n' '{"schema_version":1,"capabilities":{"wiki":false},"logging":{"callbacks":true}}' >"$tmp/repo/.ai/capabilities.json"
 chmod 600 "$tmp/repo/.ai/capabilities.json"
 printf '%s\n' '# operator-owned environment' >"$tmp/repo/.ai/env.example"
-asset_paths='.ai/start-claude.sh .ai/start-opencode.sh .ai/start-pi.sh .ai/start-kimi.sh .ai/start-qwen.sh .ai/env.example .ai/trajectory-redaction.json .ai/capabilities.json .agentfs/.gitignore .planning/config.json .planning/wiki/index.md .planning/wiki/policy.md .planning/wiki/CONTRADICTIONS.md .planning/wiki/LOG.md .planning/alignment/policy.md .planning/alignment/gap-register.yaml .planning/graphs/policy.md .planning/graphs/.gitignore .planning/security/policy.md'
+asset_paths='.ai/start-claude.sh .ai/start-opencode.sh .ai/start-pi.sh .ai/start-kimi.sh .ai/start-qwen.sh .ai/start-codex.sh .ai/env.example .ai/trajectory-redaction.json .ai/capabilities.json .agentfs/.gitignore .planning/config.json .planning/wiki/index.md .planning/wiki/policy.md .planning/wiki/CONTRADICTIONS.md .planning/wiki/LOG.md .planning/alignment/policy.md .planning/alignment/gap-register.yaml .planning/graphs/policy.md .planning/graphs/.gitignore .planning/security/policy.md'
 mkdir -p "$tmp/assets-before"
 for path in $asset_paths; do
   cp "$tmp/repo/$path" "$tmp/assets-before/${path//\//__}"

package/scripts/test-completion.sh

@@ -87,10 +87,12 @@ grep -q '#compdef cairn' "$tmp/zsh"
 grep -q 'complete -c cairn' "$tmp/fish"
 for shell in bash zsh; do
   grep -q 'sync-pi' "$tmp/$shell"
+  grep -q 'codex' "$tmp/$shell"
   grep -q 'sync-kimi' "$tmp/$shell"
   grep -q -- '--live-root' "$tmp/$shell"
 done
 grep -q 'sync-pi' "$tmp/fish"
+grep -q 'codex' "$tmp/fish"
 grep -q 'sync-kimi' "$tmp/fish"
 grep -q 'not __fish_seen_subcommand_from .*sync-pi sync-kimi' "$tmp/fish"
 grep -q -- '-l live-root' "$tmp/fish"

package/scripts/test-harness-registry.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+node --input-type=module - "$ROOT" "$tmp" <<'NODE'
+import assert from "node:assert/strict";
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+
+const [root, sandbox] = process.argv.slice(2);
+const registry = await import(pathToFileURL(join(root, "scripts", "harness-registry.mjs")).href);
+assert.deepEqual(registry.HARNESS_IDS, ["claude", "opencode", "pi", "kimi", "qwen", "codex"]);
+assert.equal(new Set(registry.HARNESS_IDS).size, registry.HARNESS_IDS.length);
+for (const id of registry.HARNESS_IDS) {
+  const definition = registry.harnessDefinition(id);
+  assert.equal(definition.id, id);
+  assert.ok(definition.title);
+  assert.match(definition.launcher.path, new RegExp(`^\\.ai/start-${id}\\.sh$`));
+}
+assert.deepEqual(registry.harnessProjectAssets("codex", "local").map(({ path }) => path), [
+  ".ai/start-codex.sh",
+  ".codex/config.toml",
+]);
+assert.deepEqual(registry.requiredHarnessAssetPaths(["codex"], "local"), [".ai/start-codex.sh"]);
+assert.deepEqual(registry.requiredHarnessAssetPaths(["codex"], "none"), [".ai/start-codex.sh"]);
+assert.equal(registry.machineSyncCommand(["codex"]), null);
+
+const schema = JSON.parse(readFileSync(join(root, "schemas", "cairnkeep-setup.schema.json"), "utf8"));
+assert.deepEqual(schema.properties.harnesses.items.enum, registry.HARNESS_IDS, "setup schema drifted from harness registry");
+const policySchema = JSON.parse(readFileSync(join(root, "schemas", "cairnkeep-setup-policy.schema.json"), "utf8"));
+assert.deepEqual(policySchema.properties.defaults.properties.harnesses.items.enum, registry.HARNESS_IDS);
+assert.deepEqual(policySchema.properties.constraints.properties.harnesses.items.enum, registry.HARNESS_IDS);
+assert.deepEqual(policySchema.properties.constraints.properties.required_harnesses.items.enum, registry.HARNESS_IDS);
+
+const target = join(sandbox, "codex-project");
+const setup = spawnSync(join(root, "bin", "cairn"), [
+  "setup", target, "--git", "init", "--harness", "codex", "--memory", "local", "--yes", "--json",
+], { encoding: "utf8", shell: false });
+assert.equal(setup.status, 0, setup.stderr);
+const result = JSON.parse(setup.stdout);
+assert.deepEqual(result.harnesses, ["codex"]);
+assert.equal(result.machine_sync.command, null);
+assert.deepEqual(result.launch_commands, [".ai/start-codex.sh"]);
+assert.match(readFileSync(join(target, ".codex", "config.toml"), "utf8"), /\[mcp_servers\.cairn-memory\][\s\S]*command = "cairn"[\s\S]*args = \["memory-server"\]/);
+
+const fakeBin = join(sandbox, "bin");
+mkdirSync(fakeBin);
+const fakeCodex = join(fakeBin, "codex");
+writeFileSync(fakeCodex, "#!/bin/sh\nprintf '%s\\n' \"$PWD\" \"${CAIRN_REGISTRY_TEST:-}\" \"$*\"\n");
+chmodSync(fakeCodex, 0o755);
+writeFileSync(join(target, ".ai", ".env"), "CAIRN_REGISTRY_TEST=loaded\n", { mode: 0o600 });
+const launch = spawnSync(join(target, ".ai", "start-codex.sh"), ["--fixture"], {
+  encoding: "utf8",
+  shell: false,
+  env: { ...process.env, PATH: `${fakeBin}:${process.env.PATH}` },
+});
+assert.equal(launch.status, 0, launch.stderr);
+assert.deepEqual(launch.stdout.trim().split("\n"), [target, "loaded", "--fixture"]);
+
+const noMemory = join(sandbox, "codex-no-memory");
+const noMemorySetup = spawnSync(join(root, "bin", "cairn"), [
+  "setup", noMemory, "--git", "init", "--harness", "codex", "--memory", "none", "--yes",
+], { encoding: "utf8", shell: false });
+assert.equal(noMemorySetup.status, 0, noMemorySetup.stderr);
+assert.throws(() => readFileSync(join(noMemory, ".codex", "config.toml")), /ENOENT/);
+
+const collision = join(sandbox, "codex-existing-config");
+mkdirSync(join(collision, ".codex"), { recursive: true });
+writeFileSync(join(collision, ".codex", "config.toml"), "[features]\nfixture = true\n");
+const collisionSetup = spawnSync(join(root, "bin", "cairn"), [
+  "setup", collision, "--git", "init", "--harness", "codex", "--memory", "local", "--yes", "--json",
+], { encoding: "utf8", shell: false });
+assert.equal(collisionSetup.status, 0, collisionSetup.stderr);
+assert.equal(JSON.parse(collisionSetup.stdout).counts.skipped, 1);
+assert.equal(readFileSync(join(collision, ".codex", "config.toml"), "utf8"), "[features]\nfixture = true\n");
+const setupModule = await import(pathToFileURL(join(root, "scripts", "setup.mjs")).href);
+assert.equal(setupModule.diagnoseSetup(collision).status, "incomplete");
+writeFileSync(join(collision, ".codex", "config.toml"), [
+  "[features]", "fixture = true", "", "[mcp_servers.cairn-memory]", 'command = "cairn"', 'args = ["memory-server"]', "",
+].join("\n"));
+assert.equal(setupModule.diagnoseSetup(collision).status, "complete");
+const uninstall = spawnSync(join(root, "bin", "cairn"), ["uninstall", "--yes", collision], {
+  encoding: "utf8", shell: false, env: { ...process.env, HOME: join(sandbox, "home") },
+});
+assert.equal(uninstall.status, 0, uninstall.stderr);
+assert.match(readFileSync(join(collision, ".codex", "config.toml"), "utf8"), /fixture = true/);
+NODE
+
+echo "PASS: declarative harness registry and first-class Codex setup contract"

package/scripts/test-package-install.sh

@@ -46,6 +46,7 @@ bootstrap_output=$(cairn bootstrap "$tmp/project")
 [[ -x "$tmp/project/.ai/start-pi.sh" ]] || fail "bootstrap did not install an executable Pi launcher"
 [[ -x "$tmp/project/.ai/start-kimi.sh" ]] || fail "bootstrap did not install an executable Kimi launcher"
 [[ -x "$tmp/project/.ai/start-qwen.sh" ]] || fail "bootstrap did not install an executable Qwen launcher"
+[[ -x "$tmp/project/.ai/start-codex.sh" ]] || fail "bootstrap did not install an executable Codex launcher"
 [[ -f "$tmp/project/.planning/config.json" ]] || fail "bootstrap did not install the planning scaffold"
 
 (cd "$tmp/project" && cairn doctor) >/dev/null || fail "installed package failed cairn doctor"
@@ -267,6 +268,10 @@ NODE
   fail "npm tarball omitted the Kimi launcher template"
 [[ -f "$installed_root/templates/start-qwen.sh.template" ]] || \
   fail "npm tarball omitted the Qwen launcher template"
+[[ -f "$installed_root/templates/start-codex.sh.template" ]] || \
+  fail "npm tarball omitted the Codex launcher template"
+[[ -f "$installed_root/templates/codex-config.toml.template" ]] || \
+  fail "npm tarball omitted the Codex MCP configuration template"
 [[ -f "$installed_root/schemas/note.schema.json" ]] || \
   fail "npm tarball omitted the note schema"
 [[ -f "$installed_root/schemas/memory-node.schema.json" ]] || \

package/scripts/test-phase19-eval-lifecycle.sh

@@ -336,8 +336,18 @@ const cancelTask={...tasks[0],id:"task-cancel",input:"cancel"};
 const cancelPlan=makePlan([cancelTask]);
 const cancelStore=await reports.createEvalReportStore({root:join(fixtureRoot,"reports"),experiment_id:"cancel-fixture"});
 const controller=new AbortController();
-setTimeout(()=>controller.abort(),100);
-const cancelled=await runner.runTwoPassExperiment({plan:cancelPlan,report_store:cancelStore,temporary_root:fixtureRoot,signal:controller.signal,distill_command:{program:process.execPath,args:[distillerScript]}});
+const cancellation=runner.runTwoPassExperiment({plan:cancelPlan,report_store:cancelStore,temporary_root:fixtureRoot,signal:controller.signal,distill_command:{program:process.execPath,args:[distillerScript]}});
+let adapterStarted=false;
+for (let attempt=0; attempt<200; attempt+=1) {
+  await new Promise((resolve)=>setTimeout(resolve,25));
+  if (existsSync(invocationLog) && readFileSync(invocationLog,"utf8").includes("task-cancel:run1")) {
+    adapterStarted=true;
+    break;
+  }
+}
+assert.equal(adapterStarted,true,"cancellation fixture adapter did not start");
+controller.abort();
+const cancelled=await cancellation;
 assert.equal(cancelled.report.status,"partial");
 assert.deepEqual(cancelled.report.observations.map(({terminal_state})=>terminal_state),["cancelled"]);
 assert.equal(cancelled.report.observations[0].process.cleanup!=="pending",true);

package/scripts/test-setup-compatibility.mjs

@@ -18,6 +18,7 @@ import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { bootstrapWindows } from "./windows-platform.mjs";
+import { HARNESS_IDS } from "./harness-registry.mjs";
 
 const EXPECTED_RED_EXIT = 86;
 const RED_MARKER = "PHASE26_RED:SETUP_RECONCILE_MISSING";
@@ -25,8 +26,8 @@ const here = dirname(fileURLToPath(import.meta.url));
 const root = resolve(here, "..");
 const setupCorePath = join(here, "setup-core.mjs");
 const setupReconcilePath = join(here, "setup-reconcile.mjs");
-const HARNESSES = ["claude", "opencode", "pi", "kimi", "qwen"];
-const MANAGED_ROOTS = [".ai", ".planning", ".agentfs"];
+const HARNESSES = HARNESS_IDS;
+const MANAGED_ROOTS = [".ai", ".codex", ".planning", ".agentfs"];
 
 function run(executable, args, options = {}) {
   const result = spawnSync(executable, args, {
@@ -141,9 +142,9 @@ async function testSetupCompatibility(production, sandbox, legacy) {
     choices: Object.freeze({ git: "existing", harnesses: HARNESSES, memory: "local", confirmed: true }),
   });
   const result = await production.reconcile.reconcileSetupPlan(plan);
-  assert.deepEqual(result.counts, { created: legacy.posixBefore.size, updated: 0, unchanged: 0, skipped: 0 });
+  assert.deepEqual(result.counts, { created: legacy.posixBefore.size + 1, updated: 0, unchanged: 0, skipped: 0 });
   const current = snapshot(target);
-  assertSnapshotEqual(current, legacy.posixBefore, "deterministic setup", [".ai/cairnkeep.json"]);
+  assertSnapshotEqual(current, legacy.posixBefore, "deterministic setup", [".ai/cairnkeep.json", ".codex/config.toml"]);
   assert.ok(current.has(".ai/cairnkeep.json"), "setup state missing");
   const state = JSON.parse(current.get(".ai/cairnkeep.json").bytes.toString("utf8"));
   assert.deepEqual(state.harnesses, HARNESSES);

package/scripts/test-windows-native.mjs

@@ -16,6 +16,7 @@ import {
   runWindowsCommand,
 } from "./windows-platform.mjs";
 import { runNativeContainer } from "./cairn-container-cli.mjs";
+import { HARNESS_IDS } from "./harness-registry.mjs";
 
 const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
 const sandbox = mkdtempSync(join(tmpdir(), "cairn-windows-native-"));
@@ -28,7 +29,7 @@ try {
   const project = join(sandbox, "Project with spaces – Unicode");
   mkdirSync(project, { recursive: true });
   bootstrapWindows(root, [project]);
-  for (const harness of ["claude", "opencode", "pi", "kimi", "qwen"]) {
+  for (const harness of HARNESS_IDS) {
     assert.ok(existsSync(join(project, ".ai", `start-${harness}.cmd`)), `${harness} cmd launcher`);
   }
   assert.match(readFileSync(join(project, ".ai", "start-claude.cmd"), "utf8"), /start-harness\.ps1/);
@@ -125,6 +126,28 @@ try {
     assert.match(powershellCompletion(), /--policy/);
     assert.match(powershellCompletion(), /--yes/);
     assert.match(powershellCompletion(), /--json/);
+    assert.match(powershellCompletion(), /codex/);
+
+    const codexProject = join(sandbox, "Guided Codex Project");
+    let codexOutput = "";
+    process.stdout.write = ((chunk) => {
+      codexOutput += String(chunk);
+      return true;
+    });
+    try {
+      await runWindowsCommand({
+        command: "setup",
+        args: [codexProject, "--git", "none", "--harness", "codex", "--memory", "local", "--yes", "--json"],
+        root,
+      });
+    } finally {
+      process.stdout.write = originalWrite;
+    }
+    const codexResult = JSON.parse(codexOutput);
+    assert.deepEqual(codexResult.harnesses, ["codex"]);
+    assert.equal(codexResult.machine_sync.command, null);
+    assert.ok(existsSync(join(codexProject, ".ai", "start-codex.cmd")));
+    assert.match(readFileSync(join(codexProject, ".codex", "config.toml"), "utf8"), /mcp_servers\.cairn-memory/);
     console.log("PASS: simulated Windows setup parity, private state, recovery, and completion contract");
   }
 } finally {

package/scripts/uninstall.sh

@@ -45,6 +45,7 @@ PROJECT_AI_FILES=(
   start-pi.sh
   start-kimi.sh
   start-qwen.sh
+  start-codex.sh
   env.example
   trajectory-redaction.json
   capabilities.json
@@ -129,9 +130,11 @@ remove_path() {
 # record. The record identifies candidates, but never grants authority to an
 # arbitrary path. Modified candidates are still backed up before removal.
 setup_owned_paths() {
-  node --input-type=module - "$1" <<'NODE'
+  node --input-type=module - "$1" "$CAIRN_ROOT/scripts/harness-registry.mjs" <<'NODE'
 import { lstatSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 const path = process.argv[2];
+const registry = await import(pathToFileURL(process.argv[3]).href);
 const info = lstatSync(path);
 if (!info.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) process.exit(1);
 if (process.platform !== "win32" && (info.mode & 0o777) !== 0o600) process.exit(1);
@@ -153,7 +156,8 @@ const allowed = new Set([
   ".planning/wiki/LOG.md", ".planning/alignment/policy.md", ".planning/alignment/gap-register.yaml",
   ".planning/graphs/policy.md", ".planning/graphs/.gitignore", ".planning/security/policy.md",
   ".ai/start-harness.mjs", ".ai/start-harness.ps1",
-  ...["claude", "opencode", "pi", "kimi", "qwen"].flatMap((name) => [`.ai/start-${name}.sh`, `.ai/start-${name}.cmd`]),
+  ...registry.HARNESS_IDS.flatMap((name) => [`.ai/start-${name}.sh`, `.ai/start-${name}.cmd`]),
+  ...registry.HARNESS_IDS.flatMap((name) => registry.harnessProjectAssets(name, "local").map(({ path }) => path)),
 ]);
 for (const [asset, record] of Object.entries(state.assets)) {
   if (!allowed.has(asset)
@@ -321,7 +325,7 @@ for proj in "${PROJECTS[@]:-}"; do
       if [[ $DRY_RUN -eq 0 ]]; then
         for managed_dir in \
           "$proj/.planning/wiki" "$proj/.planning/alignment" "$proj/.planning/graphs" \
-          "$proj/.planning/security" "$proj/.planning" "$proj/.ai" "$proj/.agentfs"; do
+          "$proj/.planning/security" "$proj/.planning" "$proj/.codex" "$proj/.ai" "$proj/.agentfs"; do
           rmdir "$managed_dir" 2>/dev/null || true
         done
       fi

package/scripts/windows-platform.mjs

@@ -20,6 +20,7 @@ import { gzipSync, gunzipSync } from "node:zlib";
 import { spawnSync } from "node:child_process";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
+import { HARNESS_IDS, harnessProjectAssets } from "./harness-registry.mjs";
 
 const BOOTSTRAP_FILES = [
   ["env.example.template", ".ai/env.example"],
@@ -39,7 +40,7 @@ const BOOTSTRAP_FILES = [
   ["security-policy.md.template", ".planning/security/policy.md"],
 ];
 
-const HARNESSES = ["claude", "opencode", "pi", "kimi", "qwen"];
+const HARNESSES = HARNESS_IDS;
 const HOOK_EVENTS = new Map([
   ["memory-wakeup", ["SessionStart", ""]],
   ["memory-capture", ["SessionEnd", ""]],
@@ -249,7 +250,8 @@ export function bootstrapWindows(root, args) {
     installFile(join(templates, source), join(target, ...destination.split("/")), destination.endsWith("capabilities.json") ? 0o600 : 0o644);
   }
   for (const harness of HARNESSES) {
-    installFile(join(templates, `start-${harness}.sh.template`), join(target, ".ai", `start-${harness}.sh`), 0o755);
+    const asset = harnessProjectAssets(harness, "local")[0];
+    installFile(join(templates, asset.template), join(target, ...asset.path.split("/")), asset.mode);
     const cmdPath = join(target, ".ai", `start-${harness}.cmd`);
     if (!existsSync(cmdPath)) atomicWrite(cmdPath, windowsLauncher(harness), 0o755);
   }
@@ -267,7 +269,9 @@ export function bootstrapWindows(root, args) {
   }
 
   console.log(`\nCairnkeep bootstrapped into ${target}`);
-  console.log(`Launch from PowerShell or Command Prompt with ${join(target, ".ai", "start-claude.cmd")}`);
+  console.log(`Codex: run 'cairn setup' in the project and select Codex, review trust, then use ${join(target, ".ai", "start-codex.cmd")}`);
+  console.log(`Claude: register 'cairn memory-server', run 'cairn sync --apply', then use ${join(target, ".ai", "start-claude.cmd")}`);
+  console.log("For new projects, prefer 'cairn setup'; guide: docs/quickstart.md");
 }
 
 function walkFiles(root, predicate = () => true, prefix = "") {
@@ -616,7 +620,10 @@ function uninstallWindows(root, args) {
   for (const project of projects) {
     const base = resolve(project);
     for (const [, rel] of BOOTSTRAP_FILES) targets.push(join(base, ...rel.split("/")));
-    for (const harness of HARNESSES) targets.push(join(base, ".ai", `start-${harness}.cmd`));
+    for (const harness of HARNESSES) {
+      for (const asset of harnessProjectAssets(harness, "local")) targets.push(join(base, ...asset.path.split("/")));
+      targets.push(join(base, ".ai", `start-${harness}.cmd`));
+    }
     targets.push(join(base, ".ai", "start-harness.mjs"));
     targets.push(join(base, ".ai", "start-harness.ps1"));
     if (options.has("--purge-memory")) targets.push(join(base, ".agentfs"));
@@ -685,10 +692,11 @@ foreach ($Item in $Manifest.items) {
 }
 
 export function powershellCompletion() {
+  const harnesses = HARNESS_IDS.map((id) => `'${id}'`).join(",");
   return `Register-ArgumentCompleter -Native -CommandName cairn -ScriptBlock {
   param($wordToComplete, $commandAst, $cursorPosition)
   $commands = 'bootstrap','setup','memory-server','sync','sync-pi','sync-kimi','doctor','trajectory','artifact','capabilities','mcp-tools','pack','notes','eval','skill','graph','memory','audit-timer','uninstall','completion','version','help'
-  $setup = '--git','--harness','--memory','--policy','--yes','--json','init','existing','none','claude','opencode','pi','kimi','qwen','local'
+  $setup = '--git','--harness','--memory','--policy','--yes','--json','init','existing','none',${harnesses},'local'
   $candidates = if ($commandAst.ToString() -match '^\\s*cairn\\s+setup(?:\\s|$)') { $setup } else { $commands }
   $candidates | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
     [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)

package/templates/codex-config.toml.template

@@ -0,0 +1,5 @@
+# Cairnkeep project-scoped memory server. Codex loads project configuration only
+# after the project has been trusted.
+[mcp_servers.cairn-memory]
+command = "cairn"
+args = ["memory-server"]

package/templates/start-codex.sh.template

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# Cairnkeep launcher for Codex CLI. Loads this project's private .ai/.env and
+# starts Codex in the project root. The project-scoped MCP registration lives in
+# .codex/config.toml and is only loaded after Codex trusts the project.
+set -euo pipefail
+ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+
+if [[ -f "$ROOT_DIR/.ai/.env" ]]; then
+  set -a
+  # shellcheck disable=SC1091
+  . "$ROOT_DIR/.ai/.env"
+  set +a
+fi
+if [[ -f "$ROOT_DIR/.ai/pre-launch.sh" ]]; then
+  # shellcheck disable=SC1091
+  . "$ROOT_DIR/.ai/pre-launch.sh"
+fi
+cd "$ROOT_DIR"
+
+if [[ -f "$ROOT_DIR/.ai/post-exit.sh" ]]; then
+  set +e
+  codex "$@"
+  CAIRN_EXIT_STATUS=$?
+  set -e
+  export CAIRN_EXIT_STATUS
+  # shellcheck disable=SC1091
+  . "$ROOT_DIR/.ai/post-exit.sh" || true
+  exit "$CAIRN_EXIT_STATUS"
+fi
+exec codex "$@"