create-egregore 0.17.4 → 0.18.1

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

@@ -0,0 +1,25 @@
+---
+name: telemetry
+description: 'Fallback Codex adapter for the Egregore telemetry workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore telemetry 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/telemetry/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/test/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: test
+description: 'Fallback Codex adapter for the Egregore test workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore test 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/test/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/test/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/the-spiral/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: the-spiral
+description: Run a Codex-native structured Socratic dialogue when the user invokes /the-spiral or $the-spiral to turn an intuition into rigorous, communicable output.
+---
+
+# The Spiral
+
+Native Codex Egregore skill. The Spiral is a stateful Socratic process for
+developing, pressure-testing, and compressing a complex thesis.
+
+## Setup
+
+Gather three inputs, using structured Codex question tooling when available and
+plain one-at-a-time questions otherwise:
+
+1. Domain: what are we spiraling on?
+2. Purpose: what should the process produce?
+3. Known areas: what domains must be covered, if any?
+
+Create state files:
+
+```text
+spiral_state.json
+spiral_artifacts/ring1
+spiral_artifacts/ring2
+spiral_artifacts/ring3
+spiral_artifacts/ring4
+spiral_artifacts/ring5
+```
+
+State includes domain, purpose, addressable space, current ring, current loop,
+artifacts, emerged domains, parked threads, descents, and ring history.
+
+## Rings
+
+1. Seed: find the irreducible claim. Artifact:
+   `spiral_artifacts/ring1/seed.md`.
+2. Territory: map implications, tensions, contradictions, and open questions.
+   Artifact: `spiral_artifacts/ring2/territory.md`.
+3. Encounter: ground claims in reality. Research facts when needed and write
+   domain artifacts under `spiral_artifacts/ring3/`.
+4. Crucible: test objections and disconfirming evidence. Artifact:
+   `spiral_artifacts/ring4/crucible.md`.
+5. Compression: produce the final deliverables under
+   `spiral_artifacts/ring5/`.
+
+Ask one question at a time. After each alignment check, update
+`spiral_state.json`. Render a compact text progress view only at setup,
+alignment checks, ring transitions, descents, resume, and completion.
+
+## TUI Rendering
+
+Structured UX parity is required. The Spiral must present state as a structured
+terminal view at phase boundaries, not as loose paragraphs:
+
+- Show rings 1-5 with current/completed/parked status.
+- Show current thesis, emerged domains, parked threads, descents, and next
+  question or alignment check.
+- Render only at setup, alignment checks, ring transitions, descents, resume,
+  and completion.
+- On completion, render a final structured view with rings completed, loop
+  count, deliverable paths, emerged domains, and parked threads.
+- Do not render mid-flow while asking a Socratic question.
+
+## Flow Rules
+
+- If the user gives a marketing-like answer in Ring 1, push toward the real
+  conviction.
+- If an objection breaks an earlier assumption, offer a descent to the right
+  ring and record the reason.
+- Research is active only when factual claims need grounding or pressure.
+- Never force a domain that has not emerged from the user's answers.
+- If the user is tired or wants to pause, crystallize the current state and
+  stop at an alignment boundary.
+
+## Resume
+
+If `spiral_state.json` exists, summarize domain, ring, loop, and current
+artifacts, then ask whether to continue or start fresh.
+
+## Completion
+
+The process ends when Ring 5 deliverables satisfy the user. Report artifact
+paths, rings completed, loop count, emerged domains, and any parked threads.

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

@@ -0,0 +1,41 @@
+---
+name: todo
+description: 'Fallback Codex adapter for the Egregore todo workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore todo 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/todo/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/todo/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/tui-design/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: tui-design
+description: 'Fallback Codex adapter for the Egregore tui-design workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore tui-design 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/tui-design/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/tui-design/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/tutorial/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: tutorial
+description: 'Fallback Codex adapter for the Egregore tutorial workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore tutorial 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/tutorial/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/tutorial/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/update/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: update
+description: 'Fallback Codex adapter for the Egregore update workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore update 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/update/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/view/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: view
+description: 'Fallback Codex adapter for the Egregore view workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore view 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/view/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/view/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/visual-explain/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: visual-explain
+description: 'Explain concepts visually using ASCII diagrams, flow charts, tables, and structural maps. Use when asked to explain, compare, or show how something works.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore visual-explain 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/visual-explain/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/visual-explain/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/wrap/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: wrap
+description: Wrap an Egregore session when the user invokes /wrap or $wrap, or says they are done, wrapping up, or at a stopping point in Codex.
+---
+
+# Egregore Wrap
+
+Native Codex Egregore skill. Use this inside an Egregore checkout with
+`bin/agent.sh`.
+
+## Flow
+
+1. Synthesize a topic, a one to three sentence summary, and concise open notes
+   from the current session.
+2. If the session has ambiguous or potentially misleading state, confirm with
+   the user. Use structured Codex question tooling when available; otherwise
+   show numbered choices plus `Other:` and wait.
+3. Resolve the author from `.egregore-state.json` `github_username`, then
+   `name`, then git config.
+4. Write the notes to a temp markdown file.
+5. Run:
+
+```bash
+bin/agent.sh wrap --from "$AUTHOR" --topic "$TOPIC" --summary "$SUMMARY" --body-file "$BODY_FILE"
+```
+
+6. If `git status --porcelain` reports repo changes after the wrap, run:
+
+```bash
+bin/agent.sh save --message "Wrap: $TOPIC" --topic "$TOPIC"
+```
+
+7. Report the `memory/wraps/...` path and whether code changes were saved.
+
+## Output
+
+Structured UX parity is required. Finish with the standard Egregore wrap
+confirmation TUI, not a prose-only summary:
+
+- Use a 72-column outer box with only the four standard line patterns:
+  top rule, separator rule, content line, bottom rule.
+- Header: `WRAP`, author, and date.
+- Body: topic, one compact summary, open threads or "No open threads", and
+  the `memory/wraps/...` path.
+- Footer: saved/pushed status. If code changes were saved, show that. If the
+  wrap only touched memory, say so.
+- Output the box directly, preferably in a `text` fenced block, with no
+  narration before it.
+
+## Rules
+
+- Do not use Claude Code commands.
+- Do not invent finished work. Separate completed work, verification, and open
+  follow-ups.
+- If save fails, report the failure and leave the local commits untouched.

package/runtime/codex/.codex/spec-manifest.json

@@ -0,0 +1,108 @@
+{
+  "generatedBy": "bin/codex-render-spec.mjs",
+  "source": "CLAUDE.md",
+  "sections": [
+    {
+      "section": "(intro)",
+      "action": "replace",
+      "sourceHash": "3992e3abfcdd",
+      "note": "Reframed for Codex: names AGENTS.md as the delivery surface and the manifest; \"organizations using Claude Code\" generalized."
+    },
+    {
+      "section": "Identity & Upstream",
+      "action": "keep",
+      "sourceHash": "4acbf9bc2866",
+      "note": "Kept; /update, /contribute, /save tokens rendered as $skill tokens."
+    },
+    {
+      "section": "On Launch — MANDATORY FIRST ACTION",
+      "action": "replace",
+      "sourceHash": "d2f6595756c8",
+      "note": "Claude SessionStart hook does not run on Codex; the egregore launcher renders the card via bin/codex-session-start.sh before the session. Greeting-replay instruction dropped (card is already on screen)."
+    },
+    {
+      "section": "After Greeting — BRANCH ON FIRST RESPONSE",
+      "action": "replace",
+      "sourceHash": "09c2618759bd",
+      "note": "EnterWorktree -> bin/agent.sh branch with git checkout fallback; AskUserQuestion -> numbered options in plain text; branch-guard mapped to .codex/hooks/branch-guard.js with instruction fallback; plan-mode note dropped (no plan mode on Codex); /branch + /onboarding -> skill tokens. Handoff claiming and repoState auto-checkout kept verbatim (pure git)."
+    },
+    {
+      "section": "Config Files",
+      "action": "keep",
+      "sourceHash": "81b7bf09901b",
+      "note": "Kept verbatim — shell facts, runtime-neutral."
+    },
+    {
+      "section": "Knowledge Graph",
+      "action": "keep",
+      "sourceHash": "5c0953aee955",
+      "note": "Kept verbatim — bin/graph.sh is runtime-neutral."
+    },
+    {
+      "section": "Notifications",
+      "action": "keep",
+      "sourceHash": "e155d669f5bd",
+      "note": "Kept verbatim — bin/notify.sh is runtime-neutral."
+    },
+    {
+      "section": "Onboarding",
+      "action": "keep",
+      "sourceHash": "ee3ecb296252",
+      "note": "Kept; /onboarding rendered as $onboarding."
+    },
+    {
+      "section": "Transparency Beat",
+      "action": "keep",
+      "sourceHash": "e06da653d3ad",
+      "note": "Kept verbatim."
+    },
+    {
+      "section": "Memory",
+      "action": "keep",
+      "sourceHash": "d75dc9f6d88c",
+      "note": "Kept verbatim."
+    },
+    {
+      "section": "Git Workflow",
+      "action": "keep",
+      "sourceHash": "d058d1f8da11",
+      "note": "Kept; slash tokens rendered as $skill tokens. Branch diagram unchanged (code fence)."
+    },
+    {
+      "section": "Working Conventions",
+      "action": "keep",
+      "sourceHash": "37a5318e9ee0",
+      "note": "Kept verbatim."
+    },
+    {
+      "section": "Command Awareness",
+      "action": "keep",
+      "sourceHash": "d3ea48ebf938",
+      "note": "Prepended the Codex command surface (skill tokens, native vs adapter split, $save abstraction); disambiguation map kept with /x -> $x token rendering. Tokens with no Codex skill (e.g. /loop, a Claude Code harness feature) are left as-is."
+    },
+    {
+      "section": "Socratic Questioning (MANDATORY)",
+      "action": "replace",
+      "sourceHash": "febe45868016",
+      "note": "AskUserQuestion -> numbered plain-text question batches with explicit stop-and-wait; multiSelect -> \"pick any that apply\"."
+    },
+    {
+      "section": "Telemetry",
+      "action": "keep",
+      "sourceHash": "f8b242d0fd64",
+      "note": "Kept verbatim — bin/telemetry.sh is runtime-neutral."
+    },
+    {
+      "section": "Mode",
+      "action": "keep",
+      "sourceHash": "ae5cbb9c5d30",
+      "note": "Kept; /env and /checkup rendered as $skill tokens."
+    },
+    {
+      "section": "Environment Isolation",
+      "action": "replace",
+      "sourceHash": "ed47e96248bd",
+      "note": "boundary-check is a Claude PreToolUse hook with no .codex equivalent — behavior stated as a standing instruction; AskUserQuestion remediation -> numbered options."
+    }
+  ]
+}

package/runtime/codex/AGENTS.md

@@ -0,0 +1,40 @@
+# Egregore Agent Protocol
+
+Egregore is no longer only a Claude Code workspace. Claude Code remains the
+first-class integrated runtime through `.claude/`, but any agent that can run
+shell commands in this checkout can participate through the portable memory
+protocol.
+
+## Startup
+
+1. Read `egregore.json` for the instance name, GitHub owner, and managed repos.
+2. Run `bin/agent.sh sync` to pull the latest shared memory.
+3. Read `memory/people/` to learn collaborator handles.
+4. Run `bin/agent.sh activity --for <your-handle>` to inspect handoffs and
+   pending questions addressed to you.
+
+## Communication
+
+Use the runtime-neutral bridge instead of Claude Code slash commands:
+
+```bash
+bin/agent.sh handoff --from alice --to bob --topic "auth review" \
+  --body "Implemented the OAuth callback parser. Bob should review error cases."
+
+bin/agent.sh ask --from bob --to alice --topic "auth review" \
+  --question "Should invalid state redirect to login or return 400?"
+
+bin/agent.sh answer --from alice \
+  --question memory/knowledge/questions/2026-04-26-bob-to-alice-auth-review.md \
+  --body "Return 400 in the API path; redirect only in browser routes."
+```
+
+Each command writes to the existing Git-backed `memory/` repository and pushes
+when the memory repo has an `origin` remote. Agents that cannot run shell may
+write the same markdown files directly, following `docs/AGENT-PROTOCOL.md`.
+
+## Compatibility
+
+Claude Code users can continue using `/handoff`, `/activity`, `/ask`, and
+other skills. Non-Claude agents should use `bin/agent.sh` and the file protocol.
+Both paths converge on the same `memory/` files.