create-egregore 0.19.5 → 0.19.7

package/runtime/codex/manifest.json

@@ -153,6 +153,7 @@
     "bin/lib/greeting.sh",
     "bin/lib/hash.sh",
     "bin/lib/identity.sh",
+    "bin/lib/metrics.sh",
     "bin/lib/permissions.sh",
     "bin/lib/time.sh",
     "bin/lib/worktree-links.sh",
@@ -160,6 +161,7 @@
     "bin/publish-artifact.sh",
     "bin/publish-references.sh",
     "bin/repo-state.sh",
+    "bin/settings.sh",
     "bin/telemetry.sh",
     "bin/worktree-create.sh",
     "bin/worktree-remove.sh",

package/runtime/pi/.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/pi/.codex/hooks/branch-guard.js

@@ -0,0 +1,242 @@
+#!/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;
+
+  // Consent bypass: the user explicitly chose to work on this protected branch.
+  // Written only after they pick "Proceed on <branch>"; cleared on session start,
+  // so consent is asked once per session, not per write.
+  try {
+    const consent = fs.readFileSync(path.join(projectDir, ".egregore-branch-consent"), "utf-8").trim();
+    if (consent === branch) return;
+  } catch {}
+
+  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}). Ask the user how to proceed — do NOT auto-branch silently.`,
+    "Offer a choice (numbered or structured): Branch off (default) / Proceed on this branch / Cancel.",
+    `  • Branch off:        bin/agent.sh branch --topic "<work topic>"  (prefix dev/${author}/...)`,
+    `  • Proceed on ${branch}: echo '${branch}' > .egregore-branch-consent  then retry`,
+    "Proceeding records consent for this branch for the rest of the session (cleared on next session start).",
+  ].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/pi/.codex/hooks/search-hint.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+"use strict";
+// search-hint.js — UserPromptSubmit hook (Codex runtime).
+//
+// Mirror of .claude/hooks/search-hint.sh: when the user's prompt is
+// recall-shaped ("find the handoff about…", "did we decide…"), inject a
+// routing hint toward `bin/agent.sh search` — one ranked call over
+// memory/ — instead of improvised ls/grep/graph exploration.
+//
+// Advisory only, never blocks, rate-limited once per session, exits 0.
+// If the Codex runtime does not fire UserPromptSubmit, this file is inert.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+function readStdin() {
+  try { return fs.readFileSync(0, "utf-8"); } catch { return ""; }
+}
+function parseJson(raw) {
+  try { return JSON.parse(raw || "{}"); } catch { return {}; }
+}
+
+const input = parseJson(readStdin());
+const prompt = String(input.prompt || input.user_prompt || "");
+if (!prompt) process.exit(0);
+
+const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+if (!fs.existsSync(path.join(root, "bin", "search.sh"))) process.exit(0);
+
+// Already oriented toward search.
+if (/(\/search\b|search\.sh|\bsearch (the )?memory\b)/i.test(prompt)) process.exit(0);
+
+const RECALL = new RegExp(
+  [
+    "\\b(find|locate|dig up|look up|pull up)\\b.*\\b(handoff|decision|notes?|docs?|meeting|harvest|quest|reflection)s?\\b",
+    "\\bdid we (decide|discuss|agree|say|talk about|cover)\\b",
+    "\\bdo we have (any )?(notes?|docs?|anything|something)( on| about)?\\b",
+    "\\bwhat did we (decide|say|agree|discuss)\\b",
+    "\\bhave we (discussed|decided|covered|talked about|looked at)\\b",
+    "\\bnotes on\\b",
+    "\\bhandoff (from|about)\\b",
+    "\\bwho worked on\\b",
+    "\\bdidn.?t (someone|we) already\\b",
+    "\\bwas there (a|any) (handoff|decision|discussion|meeting)\\b",
+  ].join("|"),
+  "i"
+);
+if (!RECALL.test(prompt)) process.exit(0);
+
+// Rate-limit once per session.
+let sid = "default";
+try { sid = fs.readFileSync(path.join(root, ".egregore-session-id"), "utf-8").trim() || "default"; } catch {}
+const flag = path.join(os.tmpdir(), `egregore-search-hint-${sid}`);
+if (fs.existsSync(flag)) process.exit(0);
+try { fs.writeFileSync(flag, "1"); } catch {}
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "UserPromptSubmit",
+    additionalContext:
+      "Routing hint: this prompt asks for recall from org memory. FIRST action: `bin/agent.sh search \"<the concept, not the literal sentence>\"` — one ranked call over all of memory/ (hybrid keyword+semantic; graph-state annotations attach automatically in connected mode). Read the top hits and cite paths. Do NOT improvise ls/grep/graph exploration first — hand-written graph queries against invented labels (e.g. :Handoff — handoffs are :Session nodes) return empty. Full spec: the search skill.",
+  },
+}) + "\n");
+process.exit(0);

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

@@ -0,0 +1,30 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/search-hint.js\"",
+            "timeout": 5,
+            "statusMessage": "Checking recall routing"
+          }
+        ]
+      }
+    ],
+    "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/pi/.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/pi/.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/pi/.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/pi/.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/pi/.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/pi/.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/pi/.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.