create-egregore 0.17.4 → 0.18.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-egregore",
-  "version": "0.17.4",
-  "description": "Set up Egregore for your team in one command",
+  "version": "0.18.1",
+  "description": "Set up Egregore for your team in one command — installs the egregore launcher and your choice of Claude Code or Codex.",
   "license": "MIT",
   "bin": {
     "create-egregore": "./bin/cli.js"
@@ -9,13 +9,22 @@
   "engines": {
     "node": ">=18"
   },
+  "scripts": {
+    "build:runtime": "node scripts/build-runtime-bundle.mjs",
+    "test": "node scripts/build-runtime-bundle.mjs --check && node --test test/context.test.js test/parse-join-target.test.js test/skip-repos.test.js test/onboarding-shortcircuit.test.js test/welcome-screen.test.js test/runtime-selection.test.js test/command-generation.test.js test/auth-gh.test.js test/gauntlet-fixes.test.js test/codex-runtime.test.js test/installer-runtime-source.test.js",
+    "test:e2e": "node --test test/e2e-local.test.js",
+    "test:all": "node scripts/build-runtime-bundle.mjs --check && node --test test/"
+  },
   "files": [
     "bin/",
-    "lib/"
+    "lib/",
+    "assets/",
+    "runtime/"
   ],
   "keywords": [
     "egregore",
     "claude",
+    "codex",
     "ai",
     "collaboration"
   ],

package/runtime/codex/.codex/config.toml

@@ -0,0 +1,15 @@
+[features]
+hooks = true
+
+[tui]
+status_line = [
+  "model-with-reasoning",
+  "git-branch",
+  "current-dir",
+  "context-remaining",
+  "five-hour-limit",
+  "weekly-limit",
+  "permissions",
+  "approval-mode",
+]
+status_line_use_colors = true

package/runtime/codex/.codex/hooks/branch-guard.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function parseJson(raw) {
+  try {
+    return JSON.parse(raw || "{}");
+  } catch {
+    return {};
+  }
+}
+
+function run(cmd, args, cwd) {
+  const result = spawnSync(cmd, args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+  if (result.status !== 0) return "";
+  return String(result.stdout || "").trim();
+}
+
+function realish(filePath) {
+  const absolute = path.resolve(filePath);
+  let cursor = absolute;
+  while (!fs.existsSync(cursor)) {
+    const parent = path.dirname(cursor);
+    if (parent === cursor) return absolute;
+    cursor = parent;
+  }
+  try {
+    const resolved = fs.realpathSync(cursor);
+    return path.join(resolved, path.relative(cursor, absolute));
+  } catch {
+    return absolute;
+  }
+}
+
+function inside(child, parent) {
+  const rel = path.relative(parent, child);
+  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+function findProjectDir(input) {
+  // Tool payload cwd is the operation location. Codex launchers may keep
+  // EGREGORE_CODEX_PROJECT_DIR pointed at the main checkout even after the
+  // model continues in a task worktree, so using the env var first can make
+  // legitimate worktree writes look like writes on protected develop.
+  const cwd = input.cwd || process.cwd() || process.env.EGREGORE_CODEX_PROJECT_DIR;
+  const top = run("git", ["-C", cwd, "rev-parse", "--show-toplevel"], cwd);
+  if (top) return realish(top);
+
+  const envDir = process.env.EGREGORE_CODEX_PROJECT_DIR || "";
+  if (envDir) {
+    const envTop = run("git", ["-C", envDir, "rev-parse", "--show-toplevel"], envDir);
+    return realish(envTop || envDir);
+  }
+
+  return realish(cwd);
+}
+
+function currentBranch(projectDir) {
+  return run("git", ["-C", projectDir, "rev-parse", "--abbrev-ref", "HEAD"], projectDir);
+}
+
+function currentAuthor(projectDir) {
+  try {
+    const raw = fs.readFileSync(path.join(projectDir, ".egregore-state.json"), "utf-8");
+    const state = JSON.parse(raw);
+    const value = state.handle || state.display_name || state.name || "dev";
+    return String(value).trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "dev";
+  } catch {
+    return "dev";
+  }
+}
+
+function isProtectedBranch(branch) {
+  return branch === "develop" || branch === "main" || branch === "master";
+}
+
+function isExemptPath(rawPath, projectDir, memoryDir) {
+  if (!rawPath) return false;
+  const absolute = path.isAbsolute(rawPath) ? rawPath : path.join(projectDir, rawPath);
+  const resolved = realish(absolute);
+
+  for (const dir of [".claude", ".codex", "memory"]) {
+    const target = realish(path.join(projectDir, dir));
+    if (inside(resolved, target)) return true;
+  }
+
+  for (const file of [".egregore-state.json", ".env"]) {
+    if (resolved === realish(path.join(projectDir, file))) return true;
+  }
+
+  if (memoryDir && inside(resolved, memoryDir)) return true;
+
+  return !inside(resolved, projectDir);
+}
+
+function extractApplyPatchPaths(command) {
+  const paths = [];
+  for (const line of String(command || "").split(/\r?\n/)) {
+    const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) || line.match(/^\*\*\* Move to: (.+)$/);
+    if (match && match[1]) paths.push(match[1].trim());
+  }
+  return paths;
+}
+
+function commandTargetsOtherRepo(command, projectDir, memoryDir) {
+  const paths = [];
+  const patterns = [
+    /\bcd\s+["']?([^"';&|]+)["']?/g,
+    /\bgit\s+-C\s+["']?([^"';&|]+)["']?/g,
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(command))) paths.push(match[1]);
+  }
+
+  for (const raw of paths) {
+    const resolved = realish(path.isAbsolute(raw) ? raw : path.join(projectDir, raw));
+    if (memoryDir && inside(resolved, memoryDir)) return true;
+    if (!inside(resolved, projectDir)) return true;
+  }
+  return false;
+}
+
+function isBranchSetupCommand(command) {
+  return (
+    /\bbin\/agent\.sh\s+branch\b/.test(command) ||
+    /\bgit\s+(checkout|switch)\s+(-b|-c)\b/.test(command) ||
+    /\bgit\s+branch\s+(dev|feature|bugfix)\//.test(command) ||
+    /\bgit\s+worktree\s+add\b/.test(command) ||
+    /\bbin\/worktree\.sh\s+setup\b/.test(command)
+  );
+}
+
+function stagedOnlyFrameworkPaths(projectDir) {
+  const files = run("git", ["-C", projectDir, "diff", "--cached", "--name-only"], projectDir)
+    .split(/\r?\n/)
+    .filter(Boolean);
+  return files.length > 0 && files.every((file) => /^(bin\/|\.claude\/|\.codex\/|CLAUDE\.md$|AGENTS\.md$|skills\/)/.test(file));
+}
+
+function redirectLooksMutating(command, projectDir, memoryDir) {
+  const redirectPatterns = [
+    /(?:^|[\s;|&])(?:\d*)>>?\s*([^&\s;|]+)/g,
+    /\|\s*tee\s+(?:-a\s+)?([^&\s;|]+)/g,
+  ];
+
+  for (const pattern of redirectPatterns) {
+    let match;
+    while ((match = pattern.exec(command))) {
+      const target = String(match[1] || "").replace(/^["']|["']$/g, "");
+      if (!target || target === "/dev/null" || target.startsWith("$")) continue;
+      if (!isExemptPath(target, projectDir, memoryDir)) return true;
+    }
+  }
+  return false;
+}
+
+function shellLooksMutating(command, projectDir, memoryDir) {
+  if (!command.trim()) return false;
+  if (isBranchSetupCommand(command)) return false;
+
+  const mutatingPatterns = [
+    /\bgit\s+(add|commit|push|rm|mv|reset|restore|checkout\s+--|clean|rebase|merge|cherry-pick)\b/,
+    /\b(apply_patch|touch|mkdir|rm|mv|cp|chmod|chown|ln)\b/,
+    /\b(sed|perl)\b[^;&|]*\s-i(\s|$)/,
+    /\b(npm|pnpm|yarn|bun)\s+(install|add|remove|update|dedupe|ci)\b/,
+    /\b(go\s+mod\s+tidy|cargo\s+(fmt|fix|update)|rustfmt|prettier\s+--write|eslint\s+--fix)\b/,
+  ];
+
+  if (/\bgit\s+commit\b/.test(command) && stagedOnlyFrameworkPaths(projectDir)) return false;
+  return mutatingPatterns.some((pattern) => pattern.test(command)) || redirectLooksMutating(command, projectDir, memoryDir);
+}
+
+function deny(reason) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason,
+    },
+  }));
+}
+
+function main() {
+  const input = parseJson(readStdin());
+  const projectDir = findProjectDir(input);
+  const branch = currentBranch(projectDir);
+  if (!isProtectedBranch(branch)) return;
+
+  const toolName = input.tool_name || "";
+  const toolInput = input.tool_input || {};
+  const memoryDir = realish(path.join(projectDir, "memory"));
+  const author = currentAuthor(projectDir);
+  const reason = [
+    `Protected branch (${branch}).`,
+    "Create an Egregore work branch before writing:",
+    `  bin/agent.sh branch --topic "<work topic>"`,
+    "Then continue from the printed worktree: path.",
+    `Default branch prefix for this user: dev/${author}/...`,
+  ].join("\n");
+
+  if (toolName === "apply_patch") {
+    const changedPaths = extractApplyPatchPaths(toolInput.command || "");
+    if (changedPaths.length === 0 || changedPaths.some((p) => !isExemptPath(p, projectDir, memoryDir))) {
+      deny(reason);
+    }
+    return;
+  }
+
+  if (toolName === "Edit" || toolName === "Write") {
+    const target = toolInput.file_path || toolInput.path || "";
+    if (!target || !isExemptPath(target, projectDir, memoryDir)) deny(reason);
+    return;
+  }
+
+  if (toolName === "Bash") {
+    const command = String(toolInput.command || "");
+    if (commandTargetsOtherRepo(command, projectDir, memoryDir)) return;
+    if (shellLooksMutating(command, projectDir, memoryDir)) deny(reason);
+  }
+}
+
+main();

package/runtime/codex/.codex/hooks.json

@@ -0,0 +1,17 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash|apply_patch|Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/branch-guard.js\"",
+            "timeout": 5,
+            "statusMessage": "Checking Egregore branch policy"
+          }
+        ]
+      }
+    ]
+  }
+}

package/runtime/codex/.codex/skills/activity/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: activity
+description: Show Egregore team activity, pending handoffs, and open questions when the user invokes /activity or $activity, or asks what is happening in an Egregore checkout.
+---
+
+# Egregore Activity
+
+Native Codex Egregore skill. Use this only inside an Egregore checkout.
+
+Show the live team activity view without sending the user through Claude Code.
+The graph API is useful when reachable, but the filesystem and memory repo must
+remain enough to render a useful answer.
+
+## Flow
+
+1. Verify `bin/agent.sh` exists. If it does not, say this is not an Egregore
+   checkout.
+2. Run `bin/agent.sh sync`.
+3. Resolve the requested handle:
+   - If the user named a person, match it against `memory/people/*.md`.
+   - Otherwise use `.egregore-state.json` `github_username`, then git user
+     fallback.
+4. Run `bash bin/activity-data.sh [handle]` with network escalation and capture
+   stdout as JSON. This command performs the graph API call internally; a
+   normal sandboxed Codex shell can make a healthy graph look unreachable.
+5. Classify the graph status:
+
+```bash
+node bin/codex-skill-render.mjs classify-graph --mode connected
+```
+
+If the network-enabled command still returns `retry` because `graph_reason` is
+`unreachable`, render the filesystem fallback and mention that the graph service
+was unreachable after a network-enabled attempt. If network escalation is denied
+or unavailable, run the command without escalation, render the fallback, and
+say Codex graph network access was not granted; do not claim the graph itself
+was unreachable. Do not retry for `missing_config`, `auth_error`, or
+`server_error`; render the clear reason instead.
+
+6. Render the card with:
+
+```bash
+node bin/codex-skill-render.mjs activity-card <json-file>
+```
+
+Paste the rendered card exactly in the visible response, preferably in a
+`text` fenced block. Do not paraphrase the card into bullets unless the user
+asks for a summary.
+
+7. Offer one compact focus prompt:
+   - `Handoffs` - open pending handoffs.
+   - `Questions` - answer or inspect pending questions.
+   - `Recent work` - inspect sessions and wraps.
+   - `Dashboard` - switch to the personal dashboard.
+   - `Done` - stop.
+
+Use structured Codex question tooling when it is available. Otherwise render a
+numbered list plus `Other:` and wait for the user.
+
+## Rules
+
+- Never show raw JSON.
+- Do not narrate each command step unless something blocks the workflow; the
+  final visible response should lead with the rendered card.
+- Structured UX parity is required: preserve the rendered activity TUI card,
+  no preamble, no prose-only replacement, and no raw collector output.
+- Do not call `egregore-handoff`.
+- Do not use Claude Code commands.
+- Keep graph, pull request, and publish data best-effort; local memory remains
+  the source of truth when connected services are down.

package/runtime/codex/.codex/skills/add/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: add
+description: 'Fallback Codex adapter for the Egregore add workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore add Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/add/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/codex/.codex/skills/announce/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: announce
+description: Draft, confirm, and send an Egregore group announcement from Codex when the user invokes /announce or $announce.
+---
+
+# Egregore Announce
+
+Native Codex Egregore skill. Use this to send concise team announcements
+through the existing Egregore notification path.
+
+## Flow
+
+1. Draft a message from the user request and current context. Keep it under
+   500 characters unless the user provided exact text.
+2. If the announcement references a memory artifact, publish it first and add
+   the returned URL only when publication succeeds:
+
+```bash
+bash bin/publish-artifact.sh document "$FILE_PATH" --title "$TITLE" --author "$AUTHOR" --description "$DESCRIPTION"
+```
+
+Use `handoff`, `quest`, or `document` as the artifact type when appropriate.
+Never fabricate a URL.
+
+3. Preview the exact message. Confirm with structured Codex question tooling
+   when available; otherwise render:
+
+```text
+Send this announcement?
+1. Send
+2. Edit
+Other:
+```
+
+4. If the user edits, redraft and preview again. If they approve, run:
+
+```bash
+bash bin/notify.sh group "$MESSAGE"
+```
+
+5. Emit telemetry in the background:
+
+```bash
+bash bin/telemetry.sh emit "command" '{"command":"announce"}' >/dev/null 2>&1 &
+```
+
+6. Confirm whether the group send succeeded.
+
+## Rules
+
+- Always preview before sending.
+- Do not expose notification credentials.
+- Use `bin/notify.sh`; do not call Telegram directly.
+- Do not use Claude Code commands.

package/runtime/codex/.codex/skills/answer/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: answer
+description: 'Fallback Codex adapter for the Egregore answer workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore answer Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/answer/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/codex/.codex/skills/archive/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: archive
+description: 'Fallback Codex adapter for the Egregore archive workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore archive Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+## Structured UX parity
+
+This workflow has a Claude skill with user-visible structured output. After
+reading `.claude/skills/archive/SKILL.md`, reproduce the same visible UX in Codex:
+
+- Preserve TUI boxes, markdown tables, rich cards, browser artifact rendering,
+  exact confirmation blocks, and "no preamble" rules from the source skill.
+- Use the source skill's frame width, section order, labels, status footer,
+  and examples as the contract for the final response.
+- Never replace a required box/table/card/artifact view with a prose summary
+  unless the user explicitly asks for a summary.
+- When the source says to output a TUI box directly, paste that box as the
+  visible response, preferably in a `text` fenced block.
+- Never show raw JSON, raw command output, or unformatted script output when
+  the source skill requires formatted status or rendered output.
+
+1. Read `.claude/skills/archive/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/codex/.codex/skills/ask/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: ask
+description: Ask an asynchronous Egregore question to a teammate when the user invokes /ask or $ask, or help the current user formulate inward reflection questions.
+---
+
+# Egregore Ask
+
+Native Codex Egregore skill. Use this when the user wants to ask a teammate a
+question, run a topic by someone, or inspect pending questions for themselves.
+
+## Flow
+
+1. Run `bin/agent.sh sync`.
+2. Resolve the current author from `.egregore-state.json`, then git config.
+3. Load people from `memory/people/*.md`. Match target names against filename,
+   `name:`, `github:`, and heading text, case-insensitively. Strip leading `@`.
+4. If the user named a target, draft one to four concrete questions. In
+   connected mode, optionally gather context with `bin/graph.sh` queries, but
+   suppress raw JSON and continue from memory files if graph access fails.
+5. Preview the exact questions and target. Use structured Codex question
+   tooling when available; otherwise render:
+
+```text
+Send these questions?
+1. Send as-is
+2. Edit
+Other:
+```
+
+6. For each approved question, run:
+
+```bash
+bin/agent.sh ask --from "$AUTHOR" --to "$TARGET" --topic "$TOPIC" --question "$QUESTION"
+```
+
+Add harvest flags only when this ask is part of a harvest:
+`--harvest-id`, `--harvest-session-id`, `--turn`, `--question-intent`, and
+`--context-mode`.
+
+7. In connected mode, notify best-effort with:
+
+```bash
+bash bin/notify.sh send "$TARGET" "$AUTHOR has a question about \"$TOPIC\". Ask for \$activity to answer."
+```
+
+8. Report the created `memory/knowledge/questions/...` path.
+
+## Inward Mode
+
+If no target matches, do not create a question file. Generate a small set of
+questions for the user to answer in-session, grounded in current conversation
+and memory context. Offer to save the result as a reflection only after the user
+answers.
+
+## Rules
+
+- Person-targeted asks are asynchronous: store, optionally notify, then stop.
+- Local mode is filesystem-only; skip graph and notification calls.
+- Do not use Claude Code commands.

package/runtime/codex/.codex/skills/branch/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: branch
+description: 'Fallback Codex adapter for the Egregore branch workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore branch Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/branch/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/codex/.codex/skills/checkup/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: checkup
+description: 'Fallback Codex adapter for the Egregore checkup workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore checkup Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+## Structured UX parity
+
+This workflow has a Claude skill with user-visible structured output. After
+reading `.claude/skills/checkup/SKILL.md`, reproduce the same visible UX in Codex:
+
+- Preserve TUI boxes, markdown tables, rich cards, browser artifact rendering,
+  exact confirmation blocks, and "no preamble" rules from the source skill.
+- Use the source skill's frame width, section order, labels, status footer,
+  and examples as the contract for the final response.
+- Never replace a required box/table/card/artifact view with a prose summary
+  unless the user explicitly asks for a summary.
+- When the source says to output a TUI box directly, paste that box as the
+  visible response, preferably in a `text` fenced block.
+- Never show raw JSON, raw command output, or unformatted script output when
+  the source skill requires formatted status or rendered output.
+
+1. Read `.claude/skills/checkup/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/codex/.codex/skills/commit/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: commit
+description: 'Fallback Codex adapter for the Egregore commit workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore commit Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/commit/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.