create-egregore 0.20.2 → 0.21.0-runtime-mvp.2

package/runtime/claude/.claude/skills/notion-connect/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: notion-connect
+description: "Use for 'connect notion', 'notion status', or 'disconnect notion' — connects the current agent runtime directly to Notion's official hosted MCP for search and fetch, or checks/revokes that connection."
+---
+
+Connect the current agent runtime directly to Notion's official hosted MCP.
+
+Arguments: $ARGUMENTS (Optional: `status` or `revoke`)
+
+## When to invoke
+
+- "connect notion", "set up notion", "link notion" → run the connection flow
+- "notion status", "is notion connected" → status
+- "disconnect notion", "revoke notion" → revoke
+- `/ingest notion` also enters this flow automatically when the MCP tools are
+  missing. Users do not need to run this skill first.
+
+## Product boundary
+
+Notion provides the bridge. Egregore does not register a Notion OAuth app and
+does not receive or store the user's Notion OAuth token. The current agent
+runtime connects directly to `https://mcp.notion.com/mcp`; Notion owns the
+login and consent screen, and the runtime stores its own authorization.
+
+Say this before opening the login flow:
+
+> Notion will connect directly to this agent. Egregore Labs does not receive
+> your Notion login or token. The agent can see what your Notion account can
+> see. Search and fetched content pass through this session; pages you approve
+> are additionally saved as curated shared memory.
+
+Do not claim that the MCP is read-only or limited to selected pages. Notion MCP
+uses the signed-in user's permissions. Normal Egregore session capture may
+include tool results the agent inspected. The `/ingest notion` review step is
+the boundary for what becomes a curated Notion source in shared memory.
+
+## Readiness check
+
+First discover available tools using the runtime's tool registry:
+
+- Claude Code: use ToolSearch with `notion`.
+- Codex/OpenAI clients: search for Notion MCP tools. OpenAI may expose
+  `notion-search` and `notion-fetch` as `search` and `fetch`.
+- Other MCP-aware runtimes: inspect the loaded tools for the Notion server.
+
+The connection is ready when both search and fetch are available. Prefer a
+`notion-get-self`/`get-self` call for status when present; otherwise a small
+search is enough to verify access.
+
+## Setup
+
+Use the path for the current runtime. These commands register Notion's official
+remote MCP only; they do not install an Egregore connector.
+
+### Claude Code
+
+```bash
+claude mcp get notion >/dev/null 2>&1 || \
+  claude mcp add --transport http --scope project notion https://mcp.notion.com/mcp
+claude mcp login notion
+```
+
+If the tools do not appear after login, say:
+
+> Notion is connected. Restart this Claude Code session, then run `/ingest notion` again.
+
+### Codex
+
+The Egregore project config already declares the server. If it is absent in an
+older installation:
+
+```bash
+codex mcp get notion >/dev/null 2>&1 || \
+  codex mcp add notion --url https://mcp.notion.com/mcp
+codex mcp login notion
+```
+
+If the tools do not appear after login, say:
+
+> Notion is connected. Restart this Codex session, then run `$ingest notion` again.
+
+### Pi
+
+Pi does not provide MCP support. Do not fall back to the legacy REST connector.
+Say:
+
+> Notion MCP is not available in Pi yet. Open this Egregore in Claude Code or Codex to connect and import Notion pages.
+
+Stop.
+
+### Other MCP clients
+
+Add `https://mcp.notion.com/mcp` as a Streamable HTTP server named `notion`,
+then complete Notion's OAuth flow. If the client only loads new servers at
+startup, ask the user to restart and return to `/ingest notion`.
+
+## Continue into ingest
+
+Once search and fetch are available, return directly to the calling
+`/ingest notion` flow. When this skill was invoked on its own, close with:
+
+> Connected. Run `/ingest notion` and tell me what you want to bring into memory.
+
+## Status
+
+Discover the Notion tools and call `notion-get-self`/`get-self` when available.
+Report only connected workspace/user information returned by Notion. Do not
+read `.egregore-state.json`; MCP authorization belongs to the runtime.
+
+## Revoke
+
+- Claude Code: `claude mcp logout notion`
+- Codex: `codex mcp logout notion`
+- Other clients: disconnect Notion from that client's MCP settings.
+
+Confirm:
+
+> Disconnected here. Pages already imported into Egregore memory remain until you remove them.
+
+Telemetry, fire-and-forget:
+
+```bash
+bash bin/telemetry.sh emit "command" '{"command":"notion-connect","transport":"mcp"}' 2>/dev/null &
+```

package/runtime/claude/.claude/skills/onboarding/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: onboarding
+description: "Use for /onboarding, or when a new member's onboarding is incomplete — runs the resumable VERIFY, ORIENT, INVITE, FIRST_HANDOFF welcome flow through Egregore Runtime."
+---
+
+# Egregore onboarding
+
+Welcome a new member through the deterministic VERIFY → ORIENT → INVITE →
+FIRST_HANDOFF flow. This is a conversation, not setup narration.
+
+The Runtime adapter owns state migration, ActorContext authorization,
+Local/Connected detection, profile-witness verification, and identity
+reconciliation. AccountIdentity, ActorIdentity, and OrgMembership remain
+separate; GitHub fields are linked-provider aliases only. Never edit state or
+people files, call APIs/graph, or run Git from this skill.
+
+## When to invoke
+
+Use for /onboarding, or when a new member's onboarding is incomplete — runs the resumable VERIFY, ORIENT, INVITE, FIRST_HANDOFF welcome flow through Egregore Runtime.
+
+## Start or resume
+
+Run one bounded status command and suppress raw output:
+
+```bash
+ONBOARDING_JSON=$(bash bin/onboarding.sh status)
+```
+
+The receipt reports the phase, completion state, user type, collected fields,
+installer handoff, and canonical profile witness. It also migrates legacy
+phase names safely. Do not inspect `.egregore-state.json` yourself.
+
+- Complete with both `name` and `role` collected: say, "You're already set
+  up. What are you working on?" and stop.
+- Complete with role missing: ask only their role, run
+  `bash bin/onboarding.sh set-role "$ROLE"`, then ask what they are working on.
+- Installer-captured name: do not ask for it again.
+- Invite handled by installer: do not offer another invite.
+- Returning creator in `invite`: explain that their previous work should be
+  captured, then enter FIRST_HANDOFF.
+
+VERIFY is otherwise invisible. Adapter failures are rendered as one useful
+fix (GitHub authentication, missing Connected authentication, or missing
+memory), without exposing configuration fields or infrastructure details.
+
+## ORIENT
+
+Output exactly, with no preamble:
+
+```text
+✱ Insight ────────────────────────────────────────
+
+Every session leaves traces — decisions, patterns, context.
+Egregore makes those traces persistent and shared.
+
+You do your work. When you're done, you hand off what you
+learned. The next session — yours or someone else's — starts
+smarter.
+
+──────────────────────────────────────────────────
+```
+
+Then:
+
+```text
+It works best with someone on the other end.
+```
+
+Ask what they should be called, offering their returned provider display name
+and a free-form alternative. Validate through the Runtime command, not in
+skill-side state:
+
+```bash
+bash bin/onboarding.sh set-name "$CHOSEN_NAME"
+```
+
+Do not continue unless the receipt returns the chosen `display_name`.
+
+## INVITE
+
+The status receipt's `usage_type` is authoritative:
+
+- `founder_group`: unless the installer handled it, ask whether to invite
+  someone now or work solo. For a username, invoke the `invite` skill, then
+  run `bash bin/onboarding.sh record-invite invited`. On skip, run
+  `bash bin/onboarding.sh record-invite skipped`. Invite failure never blocks
+  onboarding; record the answer and continue.
+- `joiner_group`: never offer the invite question. Run
+  `bash bin/onboarding.sh record-invite skipped` and use the joiner fast-track
+  completion below.
+
+Teach only:
+
+```text
+Two things to know when you're done:
+  /save    — pushes your branch and opens a PR
+  /handoff — captures what you learned for next time
+```
+
+Then ask:
+
+```text
+What are you working on?
+```
+
+When they answer, use the ordinary branch skill. Show the normal onboarding
+technical orientation with the configured integration branch and actual
+working branch; do not implement branch mechanics here.
+
+For a joiner, complete immediately after their intent answer:
+
+```bash
+bash bin/onboarding.sh complete
+```
+
+Only a receipt with `complete: true` unlocks normal work.
+
+## FIRST_HANDOFF — creators only
+
+Trigger when a creator clearly ends the session, runs save/wrap/handoff, or
+returns in the `invite` phase. If "done" could mean a subtask, ask which.
+
+Say:
+
+> Before you close out — this is the part that makes the system work. A
+> handoff captures what you did so the organization remembers it. Not a
+> summary for a manager — a briefing for the next session, or the next person.
+
+Run the ordinary handoff skill. After it succeeds, complete onboarding once:
+
+```bash
+bash bin/onboarding.sh complete
+```
+
+The adapter upgrades an invite stub through the identity service, verifies the
+canonical profile witness, records canonical Git provenance, and only then
+sets completion. If the witness is absent, keep the phase resumable and say:
+"Almost done, but your profile didn't save. Try /handoff again next session."
+
+For creators who skipped inviting, add:
+
+```text
+This is what someone would see if you invited them —
+your handoff in /activity, ready to pick up. Run /invite
+anytime to bring someone in.
+```
+
+On success say: **"You're in."** Add the launcher alias only if the Runtime
+receipt returns one; do not mutate shell configuration from the skill.
+
+## Rules
+
+- Joiners never pass through FIRST_HANDOFF and are never prompted to recruit.
+- Creators prove the handoff loop before completion.
+- Local onboarding performs no graph, API, notification, or hosted-service
+  work. Connected reconciliation remains behind the identity adapter.
+- Inviting and notifying are separately authorized and separately consented.
+- Never ask more than one progressive profile question in a later session.
+- Raw command JSON is internal; render the user-facing flow above.

package/runtime/claude/.claude/skills/pr/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: pr
+description: "Use for /pr, or 'create a PR' / 'open a pull request' — creates a pull request for the current branch against the repo's base branch with a formatted title and body. Not for reviewing an existing PR (review-pr)."
+---
+
+Create a pull request for current branch targeting the repo's base branch.
+
+## When to invoke
+
+User says: "/pr", "create a PR", "open a pull request", "push this up for review", or the current branch is ready to be reviewed against the base branch.
+Not this: reviewing an existing PR → `/review-pr`.
+
+## Execution boundary
+
+The Git and GitHub mechanics are deterministic and run inline. The main loop
+keeps only the judgment work: summarize the diff, draft the review text, and
+show the exact title/body before the external PR creation.
+
+## What to do
+
+1. Determine which repo — if the user mentions a managed repo (listed in `egregore.json` → `repos[]`), create the PR there. Otherwise use the hub.
+2. Resolve the target base branch:
+   - **Egregore hub repo**: call `_get_base_branch`
+   - **Managed repos**: call `_get_base_branch "$REPO"`
+   - Both use the validated `base_branch` from `egregore.json`; a valid config
+     that omits it defaults to `"develop"`, while resolution errors stop
+     before Git changes.
+     ```bash
+     BASE_BRANCH=$(bash -c 'SCRIPT_DIR="$PWD"; CONFIG="$PWD/egregore.json"; . "$PWD/bin/lib/config.sh" && _get_base_branch "$1"' _ "${REPO:-}") ||
+       { echo "Could not resolve the configured base branch; stopping before Git changes." >&2; exit 1; }
+     ```
+3. Summarize branch changes vs base branch
+4. Draft title and body per `.claude/context/pr-format.md`:
+   - Title: `type(scope): imperative summary` (≤ 72 chars) — the same
+     grammar as commit subjects (`.claude/context/commit-format.md`).
+     A single-commit PR reuses its commit subject verbatim when it
+     describes the whole PR.
+   - Body: `## What` (1–4 bullets) · `## Why` (1–3 sentences) ·
+     `## Verification` (how it was checked — required when the diff touches
+     non-markdown files; be honest if unverified) · `## Risk` / `## Links`
+     when real · attribution footer of the harness that authored the body
+     (final non-blank line, e.g. `🤖 Generated with [Claude Code](https://claude.com/claude-code)`)
+   - Show the draft to the user; apply their edits before creating
+5. Create PR via GitHub CLI: `gh pr create --base "$BASE_BRANCH" --title "$TITLE" --body "$BODY"` — never `--fill`, never an empty body (the `pr-format` CI check fails bare PRs)
+6. Track PR in graph (fire-and-forget):
+   ```bash
+   PROJ_HASH=$(echo -n "$(pwd)" | md5 2>/dev/null || echo -n "$(pwd)" | md5sum 2>/dev/null | cut -d' ' -f1)
+   SID=$(cat "$HOME/.egregore/session-${PROJ_HASH}.id" 2>/dev/null || echo "")
+   GH_USER=$(jq -r '.github_username // empty' .egregore-state.json 2>/dev/null)
+   REPO_NAME=$(jq -r '.repo_name // "egregore"' egregore.json 2>/dev/null)
+   bash bin/graph-op.sh create-pr "$SID" "$PR_NUMBER" "$REPO_NAME" "$GH_USER" "$PR_TITLE" 2>/dev/null &
+   ```
+   Where `$PR_NUMBER` is extracted from the `gh pr create` output URL.
+7. Return PR URL
+8. Do NOT auto-merge — explicit `/pr` means "please review this"
+
+## Example
+
+```
+> /pr
+
+Creating pull request...
+
+Branch: feature/2026-01-20-mcp-authentication
+Base: main
+Commits: 3 commits ahead of main
+Changes: +78 lines, -5 lines, 3 files
+
+Title: feat(mcp): add API key authentication
+       (from your last commit — edit? y/n)
+> n
+
+Description — summarize what this PR does:
+> Adds API key validation to MCP server. Keys are checked against env var. Includes tests.
+
+  Creating PR via GitHub CLI...
+  gh pr create --base main --title "..."
+  ✓ PR #42 created: https://github.com/{github_org}/myapp/pull/42
+
+PR targeting main — ready for review.
+```
+
+## Next
+
+Share the PR link. Run `/handoff` if ending your session.

package/runtime/claude/.claude/skills/pull/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: pull
+description: "Use for /pull when you need to sync the current branch and shared memory. Activity and dashboard are read-only and never sync repositories."
+---
+
+Pull latest for current repo and shared memory.
+
+**Note:** `/activity` and `/dashboard` are read-only. Use `/pull` for explicit
+synchronization.
+
+## When to invoke
+
+User says: "/pull", "pull latest", "sync my branch", "get the latest changes", "update memory", or needs to sync without also viewing activity.
+Not this: only want to see recent activity → `/activity` (read-only).
+
+## Execution boundary
+
+This is a deterministic sync-transport operation. Run it inline; do not spend
+a Loom/model-routing call or delegate it to another agent.
+
+## What to do
+
+1. Resolve the validated base branch with `bin/lib/config.sh` → `_get_base_branch`, then sync it with remote
+2. If on a `dev/*` working branch, rebase onto the base branch (fallback: merge)
+3. Check memory symlink exists — if not, derive directory from `egregore.json` and create symlink
+4. Pull memory repo via symlink
+
+## Execution
+
+```bash
+# 1. Update local base branch ref without switching branches (safe for concurrent sessions)
+# Pass a managed repo name to _get_base_branch when operating on one.
+BASE_BRANCH=$(bash -c 'SCRIPT_DIR="$PWD"; CONFIG="$PWD/egregore.json"; . "$PWD/bin/lib/config.sh" && _get_base_branch "$1"' _ "${REPO:-}") ||
+  { echo "Could not resolve the configured base branch; stopping before Git changes." >&2; exit 1; }
+git fetch origin "$BASE_BRANCH:$BASE_BRANCH" --quiet
+
+# 2. If on a working branch, rebase onto the base branch
+CURRENT=$(git branch --show-current)
+if [[ "$CURRENT" == dev/* ]]; then
+  git rebase "$BASE_BRANCH" --quiet || (git rebase --abort && git merge "$BASE_BRANCH" -m "Sync with $BASE_BRANCH")
+fi
+
+# 3. Memory — derive directory from egregore.json, never hardcode
+MEMORY_DIR=$(basename "$(jq -r '.memory_repo' egregore.json)" .git)
+if [ ! -L memory ]; then
+  ln -s "../$MEMORY_DIR" memory
+fi
+
+# 4. Pull memory and capture what arrived
+MEMORY_BEFORE=$(git -C memory rev-parse HEAD 2>/dev/null)
+git -C memory pull origin main --quiet
+MEMORY_AFTER=$(git -C memory rev-parse HEAD 2>/dev/null)
+
+# 5. Show what arrived in memory (new/changed files since last pull)
+if [ "$MEMORY_BEFORE" != "$MEMORY_AFTER" ]; then
+  MEMORY_FILES=$(git -C memory diff --name-only "$MEMORY_BEFORE" "$MEMORY_AFTER")
+  MEMORY_COUNT=$(echo "$MEMORY_FILES" | wc -l | tr -d ' ')
+fi
+```
+
+## Output
+
+Show what arrived — don't leave the user wondering if things synced:
+
+```
+Pulling...
+  configured base ↓ 3 commits → synced
+  dev/oz/...      ✓ rebased onto configured base
+  memory         ↓ 2 commits — 4 files updated
+                   handoffs/2026-02/12-renckorzay-giza-docs.md (new)
+                   handoffs/index.md
+                   artifacts/giza-architecture.md (new)
+                   artifacts/giza-api-spec.md (new)
+```
+
+If memory is already up to date:
+```
+  memory         ✓ up to date
+```

package/runtime/claude/.claude/skills/push/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: push
+description: "Use for /push, or 'push my branch' — pushes the current branch to origin, setting upstream on first push, before opening a PR with /pr."
+---
+
+Push current branch to remote.
+
+## When to invoke
+
+User says: "/push", "push my branch", "push this up", "get my branch onto GitHub", or needs the current branch pushed to origin before opening a PR.
+Not this: ready to open the PR itself → `/pr` (run after push).
+
+## Execution boundary
+
+This is a deterministic Git transport operation. Run it inline; do not spend a
+Loom/model-routing call or delegate it to another agent.
+
+## Before anything else
+
+Resolve `BASE_BRANCH` through `bin/lib/config.sh` → `_get_base_branch` (pass the managed repo name when applicable). Check `git branch --show-current`. If on a protected branch (`$BASE_BRANCH`, `develop`, `main`, or `master`):
+  → Use the resolved base branch (default `"develop"`)
+  → Create a working branch: `git fetch origin $BASE_BRANCH --quiet && git checkout --no-track -b dev/{author}/{topic-slug} origin/$BASE_BRANCH`
+  → Tell the user: "Creating a working branch for this..." — never mention git commands to the user.
+  → Then proceed with the push.
+
+## What to do
+
+1. Push current branch to origin
+2. Set upstream if first push
+
+## Example
+
+```
+> /push
+
+Pushing feature/2026-01-20-mcp-authentication...
+
+  git push -u origin feature/2026-01-20-mcp-authentication
+  ✓ Pushed
+
+Branch is now on GitHub.
+Run /pr when ready for review.
+```
+
+## Next
+
+Run `/pr` when ready for review.

package/runtime/claude/.claude/skills/quest/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: quest
+description: "Manage shared open-ended quests through one canonical Markdown lifecycle. Use for /quest, listing or opening quests, starting an exploration, contributing, prioritizing, pausing, or completing a quest."
+---
+
+# Quest
+
+Manage collaborative explorations without making a graph or harness prompt an
+authority.
+
+## When to invoke
+
+Manage shared open-ended quests through one canonical Markdown lifecycle. Use for /quest, listing or opening quests, starting an exploration, contributing, prioritizing, pausing, or completing a quest.
+
+## Runtime contract
+
+- `memory/quests/<slug>.md` is canonical in Local and Connected modes.
+- Resolve identity and permissions through `ActorContext` before reading or
+  changing quest state.
+- `bin/quest.sh` is the only lifecycle adapter. It authorizes, validates,
+  writes canonical Markdown, records Git provenance, refreshes retrieval,
+  schedules changed-hash embedding, emits content-free telemetry, and may
+  update an optional graph projection downstream.
+- A projection failure never rolls back or overrides canonical Markdown/Git.
+- `memory/quests/index.md`, dashboards, and graph records are rebuildable
+  views, not state the ritual edits.
+
+Arguments: `$ARGUMENTS`.
+
+## Routes
+
+| Input | Runtime action |
+|---|---|
+| empty | `bash bin/quest.sh list` |
+| `all` | `bash bin/quest.sh list --all` |
+| `<name>` | resolve one listed slug, then `bash bin/quest.sh show <slug>` |
+| `new` | collect the minimum fields, then one `new` call |
+| `contribute <name>` | resolve the slug and record one contribution |
+| `prioritize <name> <level>` | set `none`, `low`, `medium`, or `high` |
+| `pause <name>` | explicitly pause one active quest |
+| `complete <name>` | require an outcome, then complete one active quest |
+
+Suppress raw JSON. Render only the fields returned by the adapter.
+
+## List and show
+
+Run one list call and use that snapshot for display and name resolution. Show
+active quests first, ordered by priority and recency; show paused separately.
+Include title, slug, projects, priority, starter, and canonical path. For a
+detail request, call `show` once after resolution and render its question,
+threads, contributions, artifacts, entry points, and outcome from the returned
+canonical body.
+
+Do not run a graph query to enrich the view. Linked todos and relationships may
+appear only when a future Runtime read model returns them with freshness and
+provenance.
+
+## Create
+
+Collect:
+
+1. title
+2. the open question or goal
+3. optional slug, projects, and initial threads
+
+Then make one call:
+
+```bash
+bash bin/quest.sh new \
+  --title "<title>" \
+  --question "<question>" \
+  [--slug "<slug>"] \
+  [--project "<project>"]... \
+  [--thread "<thread>"]...
+```
+
+Confirm the stable quest id, canonical path, and writeback status. Do not run a
+second Git, index, graph, save, or publish action.
+
+## Update
+
+Resolve a user-supplied name against one list snapshot. If ambiguous, show the
+bounded choices. Then mutate by stable slug:
+
+```bash
+bash bin/quest.sh contribute "<slug>" "<contribution>"
+bash bin/quest.sh prioritize "<slug>" "<none|low|medium|high>"
+bash bin/quest.sh pause "<slug>"
+bash bin/quest.sh complete "<slug>" --outcome "<outcome>"
+```
+
+Only an active quest accepts contributions, pause, or completion. Completion
+requires an explicit outcome. Never infer completion from inactivity, age,
+closed todos, or graph state.
+
+## Failure behavior
+
+- Authorization denial: return no quest content and perform no write.
+- Writeback partial: canonical Markdown/Git wins; surface projection,
+  retrieval, or telemetry warnings without retrying the entire write.
+- Concurrent edit: stop on the Runtime conflict, re-list, then retry only with
+  current user intent.
+- Graph/control-plane unavailable: quest lifecycle remains functional.
+
+## Rules
+
+- Markdown/Git is authoritative in every mode.
+- One list snapshot per route; one canonical write per transition.
+- Never edit quest files or their index directly.
+- Never call Git, QMD, Neo4j, Supabase, or notification APIs from this skill.
+- Quest participation is not notification consent. Any later notification is
+  a separate exact recipient/message approval after canonical writeback.
+- Do not include titles, questions, contributions, outcomes, or paths in
+  telemetry.
+
+Emit content-free command telemetry only if Runtime writeback did not already
+record the operation:
+
+```bash
+bash bin/telemetry.sh emit "command" '{"command":"quest","subcommand":"<route>"}' 2>/dev/null &
+```

package/runtime/claude/.claude/skills/reflect/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: reflect
+description: "Use when the user says 'we decided', 'I realized', or 'that's a pattern' — captures a share-ready decision, finding, or pattern in canonical organizational memory. Use /note for private or half-baked thoughts and /archive for reusable AI-steering techniques."
+---
+
+# Reflect
+
+Turn a settled insight into one to three typed, share-ready knowledge artifacts.
+
+## When to invoke
+
+Use when the user says 'we decided', 'I realized', or 'that's a pattern' — captures a share-ready decision, finding, or pattern in canonical organizational memory. Use /note for private or half-baked thoughts and /archive for reusable AI-steering techniques.
+
+## Modes
+
+- No arguments: use a short Socratic flow grounded in this session.
+- `about <topic>`: focus the flow on that topic.
+- `[decision|finding|pattern]: <content>`: honor the explicit type.
+- Other arguments: quick capture; infer the type, defaulting to `finding`.
+
+## Context
+
+Reuse attached `EGREGORE_ORG_CONTEXT_V1` evidence. When it is sufficient, do
+not search or reopen sources. If a named gap remains, make one
+`bash bin/search.sh query "<concept>" -n 6` call and open only the missing
+canonical source through `bash bin/search.sh open`. Never query implementation
+infrastructure or storage directly.
+
+## Flow
+
+1. Extract the title, exact insight, context, rationale, two to four topics,
+   workstream, explicit relationships, and superseded artifact IDs when known.
+2. Classify each distinct insight as `decision`, `finding`, or `pattern`.
+   Create at most three. Do not infer supersession or authority from recency.
+3. Use already-returned evidence for dedupe. If a likely duplicate exists,
+   open it through the Runtime boundary and ask whether to supersede it or
+   create a distinct artifact.
+4. Preview the proposed artifacts and wait for `y`, edits, or `skip`. Nothing
+   is canonical before this acceptance.
+5. For each accepted artifact, render its complete Markdown body to a temporary
+   file and call exactly one domain command:
+
+```bash
+bash bin/knowledge.sh create \
+  --type "{decision|finding|pattern}" \
+  --title "{title}" \
+  --input "$TMP_ARTIFACT" \
+  --topic "{topic}" \
+  --workstream "{workstream}"
+```
+
+Add repeated `--topic`, `--relationship "RELATION:TARGET"`, or
+`--supersedes "ARTIFACT_ID"` arguments only when explicit. The Runtime resolves
+ActorContext, authorizes, assigns stable identity/provenance, persists canonical
+Markdown, records Git provenance, refreshes retrieval, starts background
+embedding, and emits content-free telemetry. Treat `partial` projection
+warnings honestly; the canonical artifact remains authoritative.
+
+## Boundaries
+
+- Reflection is share-ready organizational knowledge, not a private note.
+- Do not run `/save`, Git, index, embedding, graph, telemetry, publish, share,
+  or notification mechanics separately.
+- A graph is an optional downstream projection and cannot override Markdown.
+- Publishing, external sharing, and notification each require their own action
+  permission and explicit consent; reflection never implies them.
+
+Report the artifact type, title, canonical path, and writeback status. Keep the
+existing compact `◎ REFLECTION` confirmation style when rendering rich output.