create-egregore 0.19.5 → 0.19.7

package/runtime/pi/.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/pi/.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.

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

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

@@ -0,0 +1,25 @@
+---
+name: dark-mode
+description: 'Use when generating or modifying any visual output that renders in a browser or artifact viewer: HTML pages, CSS, React SSR components, Egregore artifacts, markdown renderers, web components, design-system tokens, Tailwind themes, or standalone demos. Triggers on requests involving dark mode, theme toggles, color systems, card surfaces, browser rendering, or visual polish. The load-bearing lesson: if React SSR emits an inline hex color through `style={}`, CSS dark-mode overrides cannot reach it, so every theme-sensitive color must be emitted as `var(--token)` rather than a resolved hex. Do not use for TUI output, plain markdown files, or non-visual code.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore dark-mode 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/dark-mode/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/dashboard/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: dashboard
+description: Show the current user's Egregore dashboard, recent sessions, open threads, and current work from Codex when the user invokes /dashboard or $dashboard, or asks for their dashboard.
+---
+
+# Egregore Dashboard
+
+Native Codex Egregore skill. Render the personal dashboard immediately from
+`bin/dashboard-data.sh` and the shared renderer.
+
+## Flow
+
+1. Map user range words to ISO-ish ranges:
+   - empty or `week` -> `P7D`
+   - `today` -> `P1D`
+   - `month` -> `P30D`
+   - `all` -> `P365D`
+2. Run `bash bin/dashboard-data.sh "" "$TIME_RANGE"` 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.
+3. Classify graph status:
+
+```bash
+node bin/codex-skill-render.mjs classify-graph --mode connected
+```
+
+If the network-enabled command still returns `retry` because the 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.
+
+4. Render:
+
+```bash
+node bin/codex-skill-render.mjs dashboard-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.
+
+5. End with a compact next-action prompt. Use structured Codex question
+   tooling when available; otherwise render numbered choices plus `Other:`.
+
+## 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 dashboard TUI card,
+  no preamble, no prose-only replacement, and no raw collector output.
+- Do not call `bin/graph.sh` directly; `bin/dashboard-data.sh` is the data
+  boundary.
+- In local mode, do not mention graph setup; memory files are the source of
+  truth.
+- Do not use Claude Code commands.

package/runtime/pi/.codex/skills/deep-reflect/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: deep-reflect
+description: Cross-reference an insight against the Egregore knowledge base using Codex-native staged analysis when the user invokes /deep-reflect or $deep-reflect.
+---
+
+# Egregore Deep Reflect
+
+Native Codex Egregore skill. Use this for evidence-based analysis of how a new
+insight relates to the existing knowledge base.
+
+## Modes
+
+- empty request: deep mode.
+- `focused ...`: focused topic mode.
+- `quick ...` or `category: content`: quick mode.
+
+Detect directed questions when the user asks how, why, what something means, or
+about a relationship. Preserve the user's lens while still surfacing important
+signals outside the lens.
+
+## Flow
+
+1. Check `egregore.json` mode first. In local mode, do a lightweight reflection
+   from memory files and do not call graph, batch graph, or notification
+   scripts.
+2. In all modes, run `bin/agent.sh search "$TOPIC" -n 6` — hybrid content
+   recall over the whole memory repo. Feed strong hits into the candidate
+   set; in local mode this is the primary context source.
+3. In connected mode, additionally gather graph context with `bin/graph.sh`
+   and suppress raw JSON. Query recent sessions, active quests, recent
+   artifacts, decisions, the topic landscape, and the full artifact
+   landscape.
+4. If the graph is unavailable or has fewer than about ten artifacts, fall back
+   to lightweight reflection and say why in one line.
+5. Select candidate artifacts. Prefer title, type, topics, quest, author, and
+   date metadata first; fetch file contents only for the selected subset.
+6. Use Codex multi-agent or subagent tooling only if it is available in the
+   current session. If not, run a single-model staged analysis:
+   - candidate selection summary
+   - evidence extraction summary
+   - signal analysis
+   - final synthesis
+7. Classify signals as tension, convergence, gap, dependency, phase shift,
+   redundancy, emergence, reinforcement, or a named custom type.
+8. Write a markdown artifact under `memory/knowledge/deep-reflect/` with
+   frontmatter for run id, mode, lens, author, created time, and selected
+   evidence paths.
+9. In connected mode, write best-effort graph edges with `bin/graph.sh` or
+   `bin/graph-batch.sh`. Use `TENSION_WITH` for conflict signals and
+   `RELATES_TO` for other signals.
+10. Save memory and repo changes with `bin/agent.sh save --message "Deep reflect: $TOPIC" --topic "$TOPIC"`.
+
+## Output
+
+Lead with the strongest finding, then list primary signals, evidence paths, and
+recommended next action. Keep secondary and ambient signals short.
+
+Structured UX parity is required. Then render the Egregore deep-reflect
+confirmation TUI:
+
+- Use a 72-column outer box with standard top/separator/content/bottom lines.
+- Header: `DEEP REFLECT`, author, and date.
+- Body: lens/topic, strongest finding, signal counts by type, selected evidence
+  count, artifact path, and recommended next action.
+- Footer: saved/pushed state. In connected mode include graph-link state when
+  available; in local mode omit graph language.
+- Do not show raw graph JSON or replace the confirmation box with plain prose.
+
+## Rules
+
+- Never show raw graph JSON.
+- Do not claim evidence you did not inspect.
+- Keep intermediate summaries explicit so the user can audit the reasoning.
+- Do not use Claude Code commands.

package/runtime/pi/.codex/skills/delete-user/SKILL.md

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

@@ -0,0 +1,25 @@
+---
+name: egregore-voice
+description: 'Use when writing any external communication for Egregore — essays, launch posts, website copy, announcements, README prose, social content, or any text that represents Egregore to the world. Triggers on: ''write this for the site'', ''draft the announcement'', ''help me write this essay'', ''landing page copy'', ''external post'', ''blog post'', ''Archive Fever'', ''write in my voice'', or any task producing text that an outside reader will see. Do NOT use for internal docs, CLAUDE.md files, handoffs, code comments, or technical specs — those have their own conventions. This skill prevents vanilla AI slop and ensures all external output reflects the manuscriptic, architecturally precise, philosophically grounded voice of Egregore.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore egregore-voice 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/egregore-voice/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/emissary/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: emissary
+description: 'Compose, send, or run an Egregore emissary — portable handoff v1 artifacts with server-rendered HTML at egregore.xyz. Use for `/emissary`, "make/send/run an emissary", or when a user pastes an `egregore.xyz/emissary/e/<id>` link.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore emissary 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/emissary/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/emissary/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/env/SKILL.md

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

@@ -0,0 +1,67 @@
+---
+name: handoff
+description: Create an internal Egregore team handoff when the user invokes /handoff or $handoff, says they are done, asks to hand off work, or wants to pass context to a teammate or future self.
+---
+
+# Egregore Handoff
+
+Native Codex Egregore skill. This creates an internal team handoff in
+`memory/handoffs/`, indexes it, publishes it when possible, and notifies through
+the Egregore scripts. External runnable packets are emissaries; if the user
+asks for one or provides an `egregore.xyz/emissary/e/` link, use the emissary
+tooling instead.
+
+## Flow
+
+1. Run `bin/agent.sh sync`.
+2. Resolve the author from `.egregore-state.json` `github_username`, then
+   `name`, then git config.
+3. Parse a short topic and optional recipient from the user request. Match the
+   recipient against `memory/people/*.md`; omit the recipient when uncertain.
+4. Draft the markdown body with these sections:
+   - `## Briefing`
+   - `## Key Decisions`
+   - `## Current State`
+   - `## Open Threads`
+   - `## Next Steps`
+   - `## Entry Points`
+5. Write the body to a temp file, then run one orchestration command:
+
+```bash
+TMPDIR="$(mktemp -d -t codex-handoff-XXXXXX)"
+TMPDIR="$TMPDIR" bash bin/handoff-run.sh --author "$AUTHOR" --topic "$TOPIC" ${RECIPIENT_ARG} < "$BODY_FILE"
+```
+
+Use `--recipient "$RECIPIENT"` only when a clear teammate or future-self
+recipient is known. Do not pass `--no-publish` or `--no-notify` unless the user
+explicitly asked for a dry run.
+
+6. Read `$TMPDIR/handoff-run-result.json` and render:
+
+```bash
+node bin/codex-skill-render.mjs handoff-card "$TMPDIR/handoff-run-result.json"
+```
+
+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. Fire the detached save helper when appropriate:
+
+```bash
+( bash bin/handoff-save-egregore.sh "$AUTHOR" "$TOPIC" >/dev/null 2>&1 & ) >/dev/null 2>&1
+```
+
+8. Report the `memory/...` path and hosted link from the result JSON when a
+   link exists.
+
+## Rules
+
+- Do not call `egregore-handoff` for project handoffs.
+- Do not use Claude Code commands.
+- Keep the briefing concise and operational; include exact files, branches,
+  commands, open questions, and verification state when relevant.
+- Structured UX parity is required: the rendered card is the acknowledgment.
+  Do not add a preamble such as "Handoff created successfully." Preserve the
+  72-column TUI/card shape, status footer, links below the box, and warning
+  placement used by the Egregore handoff workflow.

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

@@ -0,0 +1,107 @@
+---
+name: harvest
+description: Run an adaptive Egregore harvest from Codex when the user invokes /harvest or $harvest to elicit tacit context, preferences, positions, and team judgment.
+---
+
+# Egregore Harvest
+
+Native Codex Egregore skill. A harvest is a structured elicitation process that
+turns tacit context into durable organizational memory.
+
+## Parse
+
+Accept a topic plus optional flags:
+
+- `--respondents a,b`
+- `--seed path`
+- `--resume id`
+- `--mode blind|disclosed|comparative`
+
+Resolve the initiator from `.egregore-state.json`, then git config. Mint IDs as
+`harvest-YYYY-MM-DD-topic-slug` and
+`harvest-YYYY-MM-DD-topic-slug-respondent`.
+
+## State
+
+Markdown is canonical. Persist under:
+
+```text
+memory/knowledge/harvests/{date}-{slug}/
+  manifest.md
+  sessions/{handle}.md
+  synthesis.md
+```
+
+Single-respondent harvests may use one flat markdown file when that is simpler.
+Every manifest records topic, intent, initiator, respondents, disclosure mode,
+status, seed paths, and role-sheet assumptions.
+
+Connected mode may also call `bin/graph-op.sh` helpers, but graph writes are
+best-effort and must never block markdown state.
+
+## Process
+
+1. Sync memory with `bin/agent.sh sync`.
+2. If `--resume` is present, reload the manifest, sessions, and prior
+   evaluations before asking anything new.
+3. Build a role sheet for each respondent from `memory/people/*.md`, recent
+   handoffs, wraps, quests, and optionally graph context.
+4. Clarify the harvest intent when topic, respondents, dimensions, or
+   disclosure mode are under-specified. Use structured Codex question tooling
+   when available; otherwise ask one numbered question at a time with `Other:`.
+5. Ask situated questions. Each question must have an explicit
+   `question_intent` and must be grounded in the role sheet, seed, or prior
+   answers.
+6. Persist every turn immediately with turn number, question, intent, answer,
+   and evaluation. For absent respondents, create async questions with:
+
+```bash
+bin/agent.sh ask --from "$INITIATOR" --to "$RESPONDENT" --topic "$TOPIC" --question "$QUESTION" --harvest-id "$HARVEST_ID" --harvest-session-id "$HARVEST_SESSION_ID" --turn "$TURN" --question-intent "$QUESTION_INTENT" --context-mode "$DISCLOSURE_MODE"
+```
+
+7. In connected mode, notify async respondents best-effort with
+   `bin/notify.sh send`.
+8. Continue until present respondents reach diminishing returns and async
+   respondents are either answered, pending, or explicitly skipped.
+
+## Synthesis
+
+Write `synthesis.md` with:
+
+- L0: compact portrait of the harvest.
+- L1: useful patterns, preferences, constraints, and positions.
+- L2: respondent or theme slices, chosen based on the material.
+- L3: decisions, open questions, follow-ups, and reusable context.
+
+Evidence should be attributed. Quotes support synthesized positions; they do
+not replace them.
+
+After synthesis, mark the manifest complete, commit and push memory:
+
+```bash
+git -C memory add knowledge/harvests
+git -C memory commit -m "harvest: $TOPIC" --quiet
+git -C memory push origin main --quiet
+```
+
+Emit telemetry best-effort in the background.
+
+## Output
+
+Structured UX parity is required. When a harvest completes or checkpoints,
+render the Egregore harvest TUI instead of a prose-only recap:
+
+- Use a 72-column outer box with standard top/separator/content/bottom lines.
+- Header: `HARVEST`, initiator, and date.
+- Body: topic, respondents, disclosure mode, synthesis path, and a one-line
+  layer summary when available.
+- Footer: harvested/synthesized/saved/pushed state and `Visible in /activity.`
+- If graph writes are skipped or unavailable, reflect that in the footer
+  without saying the harvest failed when markdown was saved.
+
+## Rules
+
+- Ask one question at a time for present respondents.
+- Make low-confidence role assumptions visible when they shape questions.
+- Local mode skips graph and notification calls.
+- Do not use Claude Code commands.

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

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

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

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