create-egregore 0.19.5 → 0.19.7

package/runtime/pi/.codex/skills/summon/SKILL.md

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

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

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

@@ -0,0 +1,25 @@
+---
+name: thread
+description: 'Threads — directed work-stream primitive: store the intent, project the state. Use for /thread new|view|dash|fold|review — creating a thread, viewing one, regenerating the heat-ring dashboard, folding a confirmed decision into stored intent, or running the iteration review. Also triggers when a #thread-<slug>-foldin:v1 block is pasted.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore thread 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/thread/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/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/pi/.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/pi/.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/pi/.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/pi/.codex/skills/view/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: view
+description: 'Render Egregore data and documents as branded browser artifacts. Use when the user invokes /view or $view, asks to show something visually, open it in a browser, make a document readable or presentable, render a quest/handoff/activity/board/network, or synthesize a visual artifact from a topic.'
+---
+
+# Egregore View
+
+Native Codex Egregore skill. Use only inside an Egregore checkout.
+
+Resolve a file or live Egregore surface, render it with the in-repo artifact
+tooling, open it, and report the concrete output path. Run the workflow inline;
+do not invoke Claude Code commands or delegate through Loom.
+
+## Structured UX parity
+
+The visible result is the browser artifact and a compact receipt. Preserve the
+typed artifact templates, designed document composition, exact file path, and
+stable board URL when available. Do not replace the artifact with a prose
+summary or expose raw renderer output.
+
+## Resolve the request
+
+1. Verify `bin/agent.sh` exists. If not, say this is not an Egregore checkout.
+2. Parse an optional type followed by a name:
+   - `quest` from `memory/quests/`
+   - `handoff` from `memory/handoffs/` recursively
+   - `activity`, `board`, or `network` with no source file
+   - `document` for any markdown file
+3. Treat an argument containing `/` or ending in `.md` as a direct path. Use it
+   if it exists and infer the type from its directory.
+4. With no explicit type, search in this order: quests, handoffs, knowledge.
+   Prefer exact basename matches, then case-insensitive partial matches. For
+   handoffs, prefer the newest matching dated path.
+5. If several files match, use structured Codex question tooling when
+   available; otherwise ask one concise plain-text question listing the paths.
+6. If no file matches and the input is a topic or question, synthesize a
+   temporary markdown document from relevant memory, repository files, and
+   conversation context at
+   `/tmp/egregore-artifacts/synthesized-<slug>.md`. If the input clearly names
+   a missing file, report it as missing instead of inventing a document.
+
+## Select the renderer
+
+Prefer the checked-out package so local changes are exercised and no package
+download is needed:
+
+```bash
+RENDER="npx egregore-artifacts@latest"
+if [ -f packages/egregore-artifacts/bin/cli.js ] && \
+   [ -d packages/egregore-artifacts/node_modules/react ]; then
+  RENDER="node packages/egregore-artifacts/bin/cli.js"
+fi
+```
+
+If the local package exists without dependencies, install its dependencies or
+use the `npx` fallback. Do not block a render on optional connected services.
+
+## Render typed artifacts
+
+Run the matching command:
+
+```bash
+$RENDER quest <quest-file>
+$RENDER handoff <handoff-file>
+$RENDER activity
+$RENDER board
+$RENDER network
+$RENDER document <markdown-file>
+```
+
+Use the renderer's reported HTML path rather than guessing it.
+
+For documents, walk the generative-UI synthesis graph in
+`packages/design-system/generative-ui/skill/SKILL.md`: select one id each for
+objective, audience, register, palette, and grammar from the document's
+substance, record one line of judgment for each, resolve the brief, and pass it
+with `--brief`. If that layer is unavailable, render without the brief.
+
+## Compose flagship documents
+
+Composition is the default for a multi-section strategy, briefing, explainer,
+analysis, decision document, or anything explicitly requested as composed,
+presentable, client-facing, designed, or `--compose`. Use the fast renderer for
+typed artifacts, short utility documents, `--fast`, or `--floor`.
+
+For composition:
+
+1. Read the source document in full.
+2. Copy `.codex/skills/view/assets/compose-scaffold.html` to
+   `/tmp/egregore-artifacts/composed-<slug>.html`.
+3. Fill every placeholder and walk the generative-UI graph for the manifest's
+   register, palette, grammar, and trail.
+4. Transform rather than mirror the markdown:
+   - write a two-tone claim-led hero and italic standfirst;
+   - make section headings state findings, not repeat source headings;
+   - choose components by meaning: ledger for Q/A, claims for numbers, panels
+     for options, steps for sequences, feature rows for capability/status,
+     threads for decisions, gap cards for negatives, and a readout for the
+     honest bottom line;
+   - create one anchored navigation item per composed section.
+5. Keep every theme-sensitive color as `var(--token)`. Never emit inline hex
+   colors in composed content. Preserve the scaffold's no-flash theme restore,
+   `<html data-theme>`, and light/auto/dark behavior.
+6. Verify no placeholders remain, open the HTML with the platform browser
+   opener, and report `Renderer: composed (band 5, inline)`.
+
+## Publish the stable board
+
+After `$RENDER board`, publish best-effort only when `egregore.json` declares a
+connected configuration:
+
+```bash
+_API_URL=$(jq -r '.api_url // empty' egregore.json 2>/dev/null)
+_MODE=$(jq -r '.mode // empty' egregore.json 2>/dev/null)
+if [ -n "$_API_URL" ] && [ "$_MODE" != "local" ]; then
+  ORG_NAME=$(jq -r '.org_name // .slug' egregore.json)
+  bash bin/publish-artifact.sh board memory/board/board.json \
+    --id board \
+    --title "Project Board — $ORG_NAME" \
+    --author "$ORG_NAME" \
+    --description "Latest board for $ORG_NAME" 2>/dev/null &
+fi
+```
+
+The local artifact remains the successful result if publishing fails. In local
+mode, do not call graph or notification services.
+
+## Report
+
+Return only the useful receipt after the browser opens:
+
+```text
+✓ Artifact opened in browser
+  File: /tmp/egregore-artifacts/<rendered-file>.html
+```
+
+For a connected board, append:
+
+```text
+◆ https://egregore.xyz/view/<org-slug>/board   (stable — refresh for latest)
+```
+
+Emit telemetry best-effort after completion:
+
+```bash
+bash bin/telemetry.sh emit "command" '{"command":"view"}' 2>/dev/null &
+```
+
+## Rules
+
+- Keep filesystem resolution sufficient in local mode; the graph is optional.
+- Preserve auto-linked backtick references handled by
+  `bin/publish-references.sh` when publishing markdown.
+- Never install a global renderer package as the first choice.
+- Never call the deprecated `egregore-handoff` CLI.
+- Never claim publishing succeeded unless a URL was actually returned.

package/runtime/pi/.codex/skills/view/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Egregore View"
+  short_description: "Render Egregore artifacts in the browser"
+  default_prompt: "Use $view to render this as a branded browser artifact."