create-egregore 0.19.32 → 0.20.0

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

@@ -0,0 +1,29 @@
+---
+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 and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/emissary/SKILL.md

@@ -0,0 +1,45 @@
+---
+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 and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/handoff/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: handoff
+description: Create an internal Egregore team handoff when the user invokes /handoff or $handoff, 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 may prepare an
+external notification proposal. External runnable packets are emissaries; if the user
+asks for one or provides an `egregore.xyz/emissary/e/` link, use the emissary
+tooling instead.
+
+`/handoff` is pure addressed capture. Do not triage incoming handoffs here;
+route “show/close my handoffs” to `$activity`. Personal session closure without
+an addressed recipient belongs to `$wrap`.
+
+## 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. Classify the content before drafting:
+   - **Supplied content**: the user pasted substantial prose, supplied a
+     document, or approved exact wording. Preserve wording, order, headings,
+     lists, code, and links. Add only capture frontmatter with
+     `content_mode: supplied`. Do not create a composed JSON or attach session
+     artifacts unless the user asks.
+   - **Generated content**: the user supplied only a topic or fragmentary
+     notes. Draft the canonical markdown record with these sections:
+     - `## Briefing`
+     - `## Key Decisions`
+     - `## Current State`
+     - `## Open Threads`
+     - `## Next Steps`
+     - `## Entry Points`
+   Use this metadata contract even when the user supplied only prose:
+
+```markdown
+---
+capture_schema: egregore-capture/v1
+capture_mode: addressed
+kind: addressed
+from: <author>
+addressed_to: <recipient, if any>
+date: YYYY-MM-DD
+topic: <topic>
+intent: <action | feedback | fyi>
+content_mode: <supplied | generated>
+claim: <one-line claim>
+ask: <what the receiver should do>
+---
+```
+
+5. Build the preview. For supplied content, render the Markdown directly
+   through the native handoff renderer and verify fidelity:
+
+```bash
+node packages/egregore-artifacts/bin/cli.js handoff "$BODY_FILE" \
+  --verify-fidelity
+```
+
+   For generated content, compose the HTML view from that record. Markdown is
+   canonical; the JSON is
+   only a presentation map. Give every JSON section a stable `id` and add a
+   top-level `sourceMap` from every authored `##` heading to the section that
+   contains its complete text:
+
+```json
+{
+  "kind": "handoff",
+  "kicker": "Handoff",
+  "topic": "<topic>",
+  "claim": "<one-line claim>",
+  "sourceMap": {
+    "Briefing": "briefing",
+    "Key Decisions": "decisions",
+    "Current State": "current-state",
+    "Open Threads": "open-threads",
+    "Next Steps": "next-steps",
+    "Entry Points": "entry-points"
+  },
+  "sections": [
+    {"id":"briefing","label":"Briefing","component":"prose","body":"<complete Briefing text>"}
+  ]
+}
+```
+
+   Pick richer components when they fit, but copy all authored content into
+   the mapped destination. Never independently summarize the Markdown into the
+   JSON. For command-heavy sections, keep command headings, explanatory text,
+   fenced commands, and expected output verbatim.
+
+   Render generated content with semantic coverage enabled:
+
+```bash
+node packages/egregore-artifacts/bin/cli.js composed "$COMPOSED_FILE" \
+  --source "$BODY_FILE" --verify-fidelity
+```
+
+6. Show the actual browser HTML before publishing. This is the approval
+   surface—not a list of component names.
+
+   Stop for confirmation after the browser preview. If validation fails, fix
+   the mapping/content and render again. Skip confirmation only when the user
+   explicitly said to send without preview.
+
+7. After confirmation, run one orchestration command:
+
+```bash
+TMPDIR="$(mktemp -d -t codex-handoff-XXXXXX)"
+TMPDIR="$TMPDIR" bash bin/capture-run.sh --mode addressed --author "$AUTHOR" \
+  --topic "$TOPIC" ${RECIPIENT_ARG} --content-mode "$CONTENT_MODE" \
+  ${COMPOSED_ARG} < "$BODY_FILE"
+```
+
+Use `COMPOSED_ARG=(--composed "$COMPOSED_FILE")` only for generated content.
+
+Use `--recipient "$RECIPIENT"` only when a clear teammate or future-self
+recipient is known. Do not pass `--no-publish` unless the user explicitly
+asked for a dry run. The runner may plan a notification, but never dispatches.
+
+8. 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.
+
+9. If the result has `notifyStatus: "approval_required"`, follow
+   `.claude/context/notification-consent.md`. In a separate checkpoint, show
+   the exact organization, recipient/group, every channel/delivery, and exact
+   message from `notifyPlan`; offer Send / Edit / Cancel and wait. Only a Send
+   response to that preview permits one `approve` + `dispatch`. A local direct
+   message never falls back to a group.
+
+10. Fire the detached save helper when appropriate:
+
+```bash
+( bash bin/handoff-save-egregore.sh "$AUTHOR" "$TOPIC" >/dev/null 2>&1 & ) >/dev/null 2>&1
+```
+
+11. 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.
+- Supplied content is authoritative. Do not replace it with a session summary,
+  presentation JSON, related artifacts, or repo state.
+- The artifact is a view of the handoff, never a summary of it. Publishing
+  must fail when any non-empty authored section is unmapped or loses content.
+- 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.
+- Creating or approving the handoff is not notification consent. Never approve
+  or dispatch from detached work.

package/runtime/prime/.codex/skills/harvest/QUESTION_PALETTE.md

@@ -0,0 +1,76 @@
+# Harvest — Question Palette
+
+> Ask for the kind of judgment the harvest actually needs.
+
+This document is the single canonical home for choosing a question move
+and answer shape from `questionIntent`. `PROCESS.md` owns the conversational
+rhythm and evaluation; `SKILL.md` owns rendered-surface wiring; scrolls
+consume this palette directly. They point here instead of restating it.
+The byte-identical `.codex/skills/harvest/QUESTION_PALETTE.md` file is a
+packaging mirror for Codex and Pi; tests reject drift from this source.
+
+The palette is a decision aid, not a checklist. It never requires a mix or
+minimum number of shapes. An all-`single` surface is correct when every
+question is truly an enumerable fork; it is wrong when rankings, subsets,
+graded positions, or unmapped spaces were flattened into option cards.
+
+## Selection rule
+
+For every question:
+
+1. State the `questionIntent`: what the answer must reveal or change.
+2. Choose the closest intent row below.
+3. Use its move and answer shape when available.
+4. If another shape fits better, record one sentence explaining why.
+5. In a new rendered surface, declare `mode` explicitly. An absent mode
+   falls back to `single` only for backward compatibility.
+
+The author must be able to explain both why the question is being asked
+and why its answer shape fits. There is no shape quota or preset flow.
+
+## Intent → move → answer shape
+
+| Elicitation intent | Question move / answer shape | Guard |
+|---|---|---|
+| Decide among enumerable, mutually exclusive alternatives | Run the **enumerability test**: the author can state the full space. Use option cards, mode `single`, with 2–4 options, an “other, in your own words” escape, honest ± tradeoffs, and at most one argued lean. | If the full space cannot be stated, it is not a single-pick fork. |
+| Place a graded position or intensity between two honest poles | Name the evaluated dimension and both poles concretely. Use mode `spectrum` with 5–7 discrete, fully labeled stops; follow a midpoint with a clarifying probe. | Nothing is preselected. Untouched, midpoint, and UNDECIDED remain distinct. Never use a continuous slider. |
+| Set priority or sequence over a small set | Use mode `rank`; allow ties or top-k when a total order would invent precision. | Keep to at most 5 items. |
+| Compare importance across a longer list | Run **best-worst** as dialogue: show 3–4 items, ask most and least, then rotate subsets. | Do not turn a long list into a rating battery. |
+| Choose a non-exclusive subset | In an artifact, use mode `multi` with an explicit `max`. In live dialogue, walk items one at a time as explicit include / leave-out judgments. | Cap the subset and keep the candidate set small enough to inspect. “Select all that apply” without a cap invites shallow selection. |
+| Allocate relative magnitude or resources | Use mode `weight` with coarse 5–10% steps and an explicit untouched state. | Use at most 5 buckets; do not imply false precision or prefill an even split. |
+| Weight decision dimensions with different ranges | Ask a **swing question**: with every dimension at its worst, which swing to best would the respondent buy first? Continue against the concrete ranges. | Do not substitute context-free importance ratings. |
+| Elicit a quantity plus confidence | Ask, in order: lowest plausible, highest plausible, best guess, then sureness. Prefer frequency framing. | This needs the four-field interval card; until that renderer addition exists, run it conversationally. |
+| Explore an unmapped answer space, rationale, or discovery question | Use an open prompt anchored in the respondent’s own words. Acknowledge the answer, then probe only when it is insufficient. | Ask at most 1–2 probes per question; do not use a bare “why?” when a specific clarifier is available. |
+| Discover tacit taste dimensions before minting a fork | Run a **triad**: present three concrete elements and ask which two are alike and how the third differs. The named difference becomes a candidate axis. | Do not supply the taste taxonomy in advance. |
+| Reach tacit expertise behind a general claim | Run a **critical-incident sequence**: one concrete incident, a co-built timeline, deepening probes, then “what if X had been absent?” | Generalities are elicited through a real case, not requested directly. |
+| Deepen a thin why-note | **Ladder up** with “why does that matter to you?” or **ladder down** with “give me a concrete example.” | Stop after at most 3 consecutive ladder steps. |
+| Verify the interviewer’s interpretation | Run a **mirrored-inference check**: “My read of your position is X — what is wrong in that?” End a harvest with a member check of each respondent’s own synthesis when useful. | Mirror the sharpest reading, including tensions; do not smooth disagreement into affirmation. |
+| Get concrete feedback after abstract forks run dry, or when the respondent asks to see the work | Show only the relevant draft or excerpt in the decisions view and ask an open prompt naming what the answer will change. | This is selective authoring, not a mode: no default per-section controls, no generic ready/not-ready verdict, and no interaction added to the readable face. |
+| Elicit multi-respondent preferences, positions, or estimates | Default to blind independent collection. Freeze one shared artifact and question set when everyone should answer the same inquiry; otherwise adapt only from the seed, RoleSheet, and that respondent’s own prior turns. | Attribute every position and preserve its reasoning. Append pre-seal corrections and let the latest supersede; after sealing, a changed position starts a new round. Never report an anonymous aggregate such as “most of the team thinks.” |
+| Preserve honest nonresponse | Offer explicit `UNDECIDED`, distinct from untouched. | Never force an answer. A scroll may carry it once, then must reframe or demote the question. |
+| Handle an escape-hatch answer that names a missing option | At review, treat it as a candidate option or fork for the next version. | The creator decides whether it enters the pool; never silently coerce it into an existing option. |
+
+## Conversational moves
+
+These moves need no widget. They run inside PROCESS’s generate → evaluate
+rhythm:
+
+- **Ladder up / down** moves between value and concrete example.
+- **Critical incident** reconstructs one real episode before generalizing.
+- **Triad** lets the respondent name the comparison axis.
+- **Best-worst** extracts discrimination from rotating small subsets.
+- **Swing question** ties importance to the actual range of change.
+- **Mirrored-inference check** asks the respondent to correct the model’s
+  strongest interpretation.
+- **One-at-a-time forced choice** replaces an unbounded check-all with
+  inspectable include / leave-out judgments.
+
+## Hard bans
+
+These are lintable rules:
+
+- No agree/disagree, true/false, or yes/no stems — rewrite as explicit alternatives or an item-specific scale.
+- No draggable sliders with a preset thumb; no numbers-only or endpoint-only scales.
+- No batteries of stacked identical gauges; one question per fold-point, adjacent to its motivating prose.
+- Nothing pre-selected, ever — including spectrum position and weight splits; the lean argues, it never pre-picks.
+- No dropdowns in surfaces; >4 genuine options means an unsplit fork — split it.

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

@@ -0,0 +1,131 @@
+---
+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. Read `QUESTION_PALETTE.md` completely. Ask situated questions with an
+   explicit `question_intent`, an answer shape that fits it, and grounding in
+   the role sheet, seed, the respondent's own prior answers, or attributed
+   positions allowed by the disclosure setting. Blind mode must not use
+   another respondent's answer content, even invisibly. Record a one-sentence
+   reason when departing from the palette's closest intent row.
+6. Persist every turn immediately with turn number, question, intent, answer,
+   and evaluation. Apply the palette's satisficing and sycophancy guards when
+   evaluating. 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, follow `.claude/context/notification-consent.md` for
+   each async respondent: prepare one direct notification, show its exact
+   recipient/channel/message in a separate checkpoint, and dispatch once only
+   after that approval. Selecting respondents is not notification consent and
+   approvals cannot be batched.
+8. Continue until present respondents reach diminishing returns and async
+   respondents are either answered, pending, or explicitly skipped.
+
+## Multi-respondent rounds
+
+Preference, estimate, and position intents default to `blind`. When everyone
+should answer the same inquiry, freeze one source version and question set
+before collection and send the identical artifact to each respondent.
+
+While collection is open, a respondent may correct their own response. Append
+the correction, use their latest finalized response as canonical, and count
+distinct finalized respondents rather than submissions. After the declared
+completion condition seals the evidence, it is immutable; a changed position
+starts a new round. There is no automatic second pass after disclosure.
+
+Attribute disclosed positions and preserve their reasoning. Never turn them
+into an anonymous aggregate such as "most of the team thinks." A majority may
+be named with its respondents, but it is not collective alignment.
+
+## 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.
+- Never impose an answer-shape quota or preset question flow.
+- 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/prime/.codex/skills/ingest/SKILL.md

@@ -0,0 +1,29 @@
+---
+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 and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/ingest-notion/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: ingest-notion
+description: 'Fallback Codex adapter for the Egregore ingest-notion workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore ingest-notion 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-notion/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/ingest-user-interview/SKILL.md

@@ -0,0 +1,45 @@
+---
+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 and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/invite/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: invite
+description: Invite a GitHub user into this Egregore instance from Codex when the user invokes /invite or $invite, or asks to invite someone without exposing credentials.
+---
+
+# Egregore Invite
+
+Native Codex Egregore skill. Invite a GitHub username to the configured repos
+and, in connected mode, create the Egregore join link.
+
+## Flow
+
+1. Require a GitHub username. If missing, ask for it and stop.
+2. Read mode and config from `egregore.json`. Never print secrets from `.env`.
+3. Run credential-sensitive work in a single shell command that reads
+   `GITHUB_TOKEN` and `EGREGORE_API_KEY` internally and only prints sanitized
+   JSON.
+4. Connected mode:
+   - POST to the configured Egregore invite API with the GitHub username,
+     org, repo, slug, API key, and GitHub token.
+   - Parse the response and show invite status, memory access status, and the
+     returned invite URL.
+   - Best-effort graph record with `bin/graph.sh`.
+   - If a contact channel exists, follow
+     `.claude/context/notification-consent.md`: prepare a direct-message plan
+     and show the exact organization, recipient, channel, and message in a
+     separate Send / Edit / Cancel checkpoint. The invite request is not
+     notification consent.
+5. Local mode:
+   - Use GitHub API collaborator endpoints for the core repo, memory repo, and
+     managed repos.
+   - Create or update `memory/people/{username}.md`.
+   - Commit and push memory.
+   - Show the join command using `npx -y create-egregore@latest join`.
+6. If remote hosting is enabled, provision hosting best-effort in a detached
+   command and include the status only when it succeeds.
+
+## Rules
+
+- Never expose tokens, request bodies containing tokens, or raw API JSON.
+- Only org admins can complete the connected invite flow; report API denial
+  clearly and give the manual GitHub access URL.
+- Do not use Claude Code commands.
+- Never fall back from an invite DM to a group or dispatch from detached work.

package/runtime/prime/.codex/skills/issue/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: issue
+description: 'Fallback Codex adapter for the Egregore issue workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore issue 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/issue/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/issue/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.