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

package/runtime/pi/manifest.json

@@ -77,11 +77,13 @@
     ".codex/skills/ingest-corpus/SKILL.md",
     ".codex/skills/ingest-notion/SKILL.md",
     ".codex/skills/ingest-user-interview/SKILL.md",
+    ".codex/skills/ingest-user-interview/references/analysis-contract.md",
     ".codex/skills/ingest/SKILL.md",
     ".codex/skills/invite/SKILL.md",
     ".codex/skills/issue/SKILL.md",
     ".codex/skills/me/SKILL.md",
     ".codex/skills/meeting/SKILL.md",
+    ".codex/skills/meeting/references/analysis-contract.md",
     ".codex/skills/note/SKILL.md",
     ".codex/skills/notion-connect/SKILL.md",
     ".codex/skills/onboarding/SKILL.md",
@@ -114,10 +116,15 @@
     ".pi/settings.json",
     ".pi/spec-manifest.json",
     "AGENTS.md",
+    "bin/activity-action.sh",
     "bin/activity-data.sh",
     "bin/agent.sh",
+    "bin/artifact-register.sh",
+    "bin/artifact-writeback.sh",
+    "bin/artifacts.sh",
     "bin/attendant.sh",
     "bin/autosave.sh",
+    "bin/build-sealed-dataroom.mjs",
     "bin/capture-reconcile.sh",
     "bin/capture-run.sh",
     "bin/codex-install-skills.sh",
@@ -127,21 +134,32 @@
     "bin/codex-sync-skills.sh",
     "bin/connect-refresh.sh",
     "bin/contribute-guard.sh",
+    "bin/corpus_map.py",
+    "bin/corpus_survey.py",
     "bin/dashboard-data.sh",
+    "bin/github-auth.sh",
     "bin/graph-batch.sh",
     "bin/graph-op.sh",
+    "bin/graph-projection.sh",
     "bin/graph-wal.sh",
     "bin/graph.sh",
+    "bin/handoff-lifecycle-job.sh",
+    "bin/handoff-lifecycle.sh",
     "bin/handoff-pr-backfill.sh",
+    "bin/handoff-preview.sh",
     "bin/handoff-run.sh",
     "bin/handoff-save-egregore.sh",
     "bin/index-handoff.sh",
     "bin/ingest-graph.sh",
+    "bin/ingest-item.sh",
     "bin/ingest-surface.html",
     "bin/ingest.py",
     "bin/ingest.sh",
     "bin/ingest_graph.py",
     "bin/ingest_surface.py",
+    "bin/invite.sh",
+    "bin/issue.sh",
+    "bin/knowledge.sh",
     "bin/lib/artifact-id.sh",
     "bin/lib/config.sh",
     "bin/lib/context.sh",
@@ -150,6 +168,7 @@
     "bin/lib/git-message.sh",
     "bin/lib/git-sync.sh",
     "bin/lib/greeting.sh",
+    "bin/lib/handoff-meta.sh",
     "bin/lib/hash.sh",
     "bin/lib/identity.sh",
     "bin/lib/metrics.sh",
@@ -157,23 +176,101 @@
     "bin/lib/permissions.sh",
     "bin/lib/time.sh",
     "bin/lib/worktree-links.sh",
+    "bin/node-run.sh",
+    "bin/notification.sh",
     "bin/notify.sh",
+    "bin/observe-context.sh",
+    "bin/onboarding.sh",
     "bin/person.py",
     "bin/person.sh",
     "bin/pi-branch-policy.mjs",
+    "bin/pi-observe-context.mjs",
     "bin/pi-product-workflows.mjs",
     "bin/pi-render-spec.mjs",
     "bin/pi-session-start.sh",
+    "bin/post-update.sh",
+    "bin/prime-render-spec.mjs",
     "bin/publish-artifact.sh",
     "bin/publish-references.sh",
+    "bin/quest.sh",
+    "bin/question.sh",
     "bin/repo-state.sh",
+    "bin/research-ingest.sh",
+    "bin/restore-owned-skills.sh",
+    "bin/retrieval_eval.py",
+    "bin/runtime-identity.sh",
+    "bin/runtime-upgrade.sh",
+    "bin/scroll.sh",
     "bin/search.sh",
     "bin/session-autosave.sh",
     "bin/session-log.sh",
     "bin/settings.sh",
+    "bin/startup-check.sh",
     "bin/telemetry.sh",
+    "bin/test-changes.sh",
+    "bin/thread.sh",
+    "bin/todo.sh",
+    "bin/view-render.sh",
     "bin/worktree-create.sh",
     "bin/worktree-remove.sh",
-    "bin/worktree.sh"
+    "bin/worktree.sh",
+    "egregore_runtime/__init__.py",
+    "egregore_runtime/adapters/__init__.py",
+    "egregore_runtime/adapters/invitation.py",
+    "egregore_runtime/adapters/notification.py",
+    "egregore_runtime/adapters/qmd.py",
+    "egregore_runtime/adapters/qmd_cli.py",
+    "egregore_runtime/adapters/qmd_embed_worker.py",
+    "egregore_runtime/admin_gate.py",
+    "egregore_runtime/artifacts.py",
+    "egregore_runtime/contracts.py",
+    "egregore_runtime/entitlements.py",
+    "egregore_runtime/errors.py",
+    "egregore_runtime/graph.py",
+    "egregore_runtime/handoff_lookup.py",
+    "egregore_runtime/harness_cli.py",
+    "egregore_runtime/identity.py",
+    "egregore_runtime/identity_cli.py",
+    "egregore_runtime/ingest.py",
+    "egregore_runtime/ingest_cli.py",
+    "egregore_runtime/ingest_index_cli.py",
+    "egregore_runtime/invitation_cli.py",
+    "egregore_runtime/invitations.py",
+    "egregore_runtime/issue_cli.py",
+    "egregore_runtime/issues.py",
+    "egregore_runtime/knowledge.py",
+    "egregore_runtime/knowledge_cli.py",
+    "egregore_runtime/lifecycle.py",
+    "egregore_runtime/lifecycle_cli.py",
+    "egregore_runtime/notification_cli.py",
+    "egregore_runtime/notifications.py",
+    "egregore_runtime/observe.py",
+    "egregore_runtime/onboarding.py",
+    "egregore_runtime/onboarding_cli.py",
+    "egregore_runtime/policy.py",
+    "egregore_runtime/profile.py",
+    "egregore_runtime/quest_cli.py",
+    "egregore_runtime/question_cli.py",
+    "egregore_runtime/questions.py",
+    "egregore_runtime/quests.py",
+    "egregore_runtime/readiness.py",
+    "egregore_runtime/research_ingest.py",
+    "egregore_runtime/research_ingest_cli.py",
+    "egregore_runtime/runtime.py",
+    "egregore_runtime/scroll_cli.py",
+    "egregore_runtime/scrolls.py",
+    "egregore_runtime/status.py",
+    "egregore_runtime/status_cli.py",
+    "egregore_runtime/sync.py",
+    "egregore_runtime/teamsync.py",
+    "egregore_runtime/telemetry.py",
+    "egregore_runtime/thread_cli.py",
+    "egregore_runtime/threads.py",
+    "egregore_runtime/todo_cli.py",
+    "egregore_runtime/todos.py",
+    "egregore_runtime/upgrade.py",
+    "egregore_runtime/upgrade_worker.py",
+    "egregore_runtime/writeback.py",
+    "egregore_runtime/writeback_cli.py"
   ]
 }

package/runtime/prime/.codex/hooks/search-hint.js

@@ -1,67 +1,36 @@
 #!/usr/bin/env node
 "use strict";
-// search-hint.js — UserPromptSubmit hook (Codex runtime).
-//
-// Mirror of .claude/hooks/search-hint.sh: when the user's prompt is
-// recall-shaped ("find the handoff about…", "did we decide…"), inject a
-// routing hint toward `bash bin/search.sh query` — one ranked call over
-// memory/ — instead of improvised ls/grep/graph exploration.
+
+// Linked-worktree compatibility bridge for Codex UserPromptSubmit.
 //
-// Advisory only, never blocks, rate-limited once per session, exits 0.
-// If the Codex runtime does not fire UserPromptSubmit, this file is inert.
+// Codex currently discovers project hooks from the primary checkout for a
+// linked Git worktree, then executes the configured command in the linked
+// worktree. Older Egregore primary checkouts therefore invoke this historical
+// filename. Keep it as a thin bridge into the same harness-neutral Observe
+// adapter used by current .codex/hooks.json; never implement retrieval here.
 
 const fs = require("node:fs");
 const path = require("node:path");
-const os = require("node:os");
+const { spawnSync } = require("node:child_process");
 
 function readStdin() {
   try { return fs.readFileSync(0, "utf-8"); } catch { return ""; }
 }
-function parseJson(raw) {
-  try { return JSON.parse(raw || "{}"); } catch { return {}; }
-}
-
-const input = parseJson(readStdin());
-const prompt = String(input.prompt || input.user_prompt || "");
-if (!prompt) process.exit(0);
-
-const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-if (!fs.existsSync(path.join(root, "bin", "search.sh"))) process.exit(0);
 
-// Already oriented toward search.
-if (/(\/search\b|search\.sh|\bsearch (the )?memory\b)/i.test(prompt)) process.exit(0);
+const input = readStdin();
+if (!input) process.exit(0);
 
-const RECALL = new RegExp(
-  [
-    "\\b(find|locate|dig up|look up|pull up)\\b.*\\b(handoff|decision|notes?|docs?|meeting|harvest|quest|reflection)s?\\b",
-    "\\bdid we (decide|discuss|agree|say|talk about|cover)\\b",
-    "\\bdo we have (any )?(notes?|docs?|anything|something)( on| about)?\\b",
-    "\\bwhat did we (decide|say|agree|discuss)\\b",
-    "\\bhave we (discussed|decided|covered|talked about|looked at)\\b",
-    "\\bnotes on\\b",
-    "\\bhandoff (from|about)\\b",
-    "\\bwho worked on\\b",
-    "\\bdidn.?t (someone|we) already\\b",
-    "\\bwas there (a|any) (handoff|decision|discussion|meeting)\\b",
-    "\\b(our|company|org|organization|team)\\b.*\\b(pricing|price|tiers?|plans?|paid|free|strategy|policy|positioning|ownership|decision)\\b",
-    "\\b(pricing|price|tiers?|plans?|paid|free)\\b.*\\b(our|company|org|organization|team)\\b",
-  ].join("|"),
-  "i"
-);
-if (!RECALL.test(prompt)) process.exit(0);
+const root = process.env.EGREGORE_ROOT || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const adapter = path.join(root, "bin", "observe-context.sh");
+if (!fs.existsSync(adapter)) process.exit(0);
 
-// Rate-limit once per session.
-let sid = "default";
-try { sid = fs.readFileSync(path.join(root, ".egregore-session-id"), "utf-8").trim() || "default"; } catch {}
-const flag = path.join(os.tmpdir(), `egregore-search-hint-${sid}`);
-if (fs.existsSync(flag)) process.exit(0);
-try { fs.writeFileSync(flag, "1"); } catch {}
+const result = spawnSync("bash", [adapter, "codex"], {
+  cwd: root,
+  env: { ...process.env, EGREGORE_ROOT: root },
+  input,
+  encoding: "utf-8",
+  timeout: 45_000,
+});
 
-process.stdout.write(JSON.stringify({
-  hookSpecificOutput: {
-    hookEventName: "UserPromptSubmit",
-    additionalContext:
-      "Routing hint: this prompt asks for recall from org memory. FIRST action: `bash bin/search.sh query \"<the concept, not the literal sentence>\"` — one ranked call over all of memory/ (hybrid keyword+semantic; graph-state annotations attach automatically in connected mode). Read the top hits and cite paths. Do NOT improvise ls/grep/graph exploration first — hand-written graph queries against invented labels (e.g. :Handoff — handoffs are :Session nodes) return empty. Full spec: the search skill.",
-  },
-}) + "\n");
+if (result.stdout) process.stdout.write(result.stdout);
 process.exit(0);

package/runtime/prime/.codex/hooks.json

@@ -6,9 +6,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/search-hint.js\"",
-            "timeout": 5,
-            "statusMessage": "Checking recall routing"
+            "command": "bash \"$(git rev-parse --show-toplevel)/bin/observe-context.sh\" codex",
+            "timeout": 45,
+            "statusMessage": "Compiling organizational context"
           }
         ]
       }

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

@@ -1,82 +1,39 @@
 ---
 name: activity
-description: Show Egregore team activity, pending handoffs, and open questions when the user invokes /activity or $activity, or asks what is happening in an Egregore checkout.
+description: Explicit Activity card only. Use when the user names /activity or $activity, or directly asks to show, open, or render the Activity dashboard/card. Never use it to answer or synthesize what the team is focused on, busy with, prioritizing, or doing; analytical organizational questions use Search/Runtime QMD.
 ---
 
 # Egregore Activity
 
-Native Codex Egregore skill. Use this only inside an Egregore checkout.
+Use this bounded status card only when the user names Activity or directly asks
+to display its dashboard/card. "Explicit" means display intent, not merely a
+question about the team. Questions asking for explanation or synthesis of
+current focus, themes, priorities, or work use attached
+`EGREGORE_ORG_CONTEXT_V1` evidence or exactly one Search workflow query when
+that evidence is absent. The same applies to returning to earlier work. Never
+use Activity as discovery or analysis fallback.
 
-Show the live team activity view without sending the user through Claude Code.
-The graph API is useful when reachable, but the filesystem and memory repo must
-remain enough to render a useful answer.
-
-## Flow
-
-1. Verify `bin/agent.sh` exists. If it does not, say this is not an Egregore
-   checkout.
-2. If the request is `activity done N`, `activity expire N`, or
-   `activity reopen N`, fetch `bin/activity-data.sh` to a temporary JSON file,
-   map `N` to the corresponding `handoffs_to_me[N-1].sessionId`, and run:
-
-```bash
-bash bin/activity-action.sh <done|expire|reopen> "<session-id>"
-```
-
-Report the resulting topic and state. Never accept a raw session ID from the
-visible command when a numbered activity item is available; the number keeps
-the mutation tied to what the user just saw. In local mode, preserve the
-script's explicit unavailable result.
-3. Run `bin/agent.sh sync`.
-4. Resolve the requested handle:
-   - If the user named a person, match it against `memory/people/*.md`.
-   - Otherwise use `.egregore-state.json` `github_username`, then git user
-     fallback.
-5. Run `bash bin/activity-data.sh [handle]` 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.
-6. Classify the graph status:
+Inside an Egregore checkout, fetch and render exactly one authorized Runtime
+snapshot:
 
 ```bash
-node bin/codex-skill-render.mjs classify-graph --mode connected
+bash bin/activity-data.sh 2>/dev/null \
+  | bash bin/node-run.sh bin/codex-skill-render.mjs activity-card -
 ```
 
-If the network-enabled command still returns `retry` because `graph_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. Do not retry for `missing_config`, `auth_error`, or
-`server_error`; render the clear reason instead.
+Paste the card exactly and stop. Never expose raw JSON, sync repositories, or
+call QMD, graph, GitHub, Supabase, or control-plane APIs. Canonical Markdown
+and Runtime lifecycle state are authoritative.
 
-7. Render the card with:
+For `done N`, `expire N`, or `reopen N`, map the number from that one snapshot
+and run:
 
 ```bash
-node bin/codex-skill-render.mjs activity-card <json-file>
+bash bin/activity-action.sh <done|expire|reopen> "<sessionId>" \
+  --expected-revision "<lifecycleRevision>"
 ```
 
-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.
-
-8. Offer one compact focus prompt:
-   - `Handoffs` - open pending handoffs.
-   - `Questions` - answer or inspect pending questions.
-   - `Recent work` - inspect sessions and wraps.
-   - `Dashboard` - switch to the personal dashboard.
-   - `Done` - stop.
-
-Use structured Codex question tooling when it is available. Otherwise render a
-numbered list plus `Other:` and wait for the user.
-
-## 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 activity TUI card,
-  no preamble, no prose-only replacement, and no raw collector output.
-- Do not call `egregore-handoff`.
-- Do not use Claude Code commands.
-- Keep graph, pull request, and publish data best-effort; local memory remains
-  the source of truth when connected services are down.
+Connected enrichment is optional and explicit: set
+`EGREGORE_STATUS_CONNECTED_ENRICH=1` only when the user requests projected
+Connected status. It is capability/permission gated and cannot override the
+canonical fields.

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

@@ -1,67 +1,44 @@
 ---
 name: announce
-description: Draft, confirm, and send an Egregore group announcement from Codex when the user invokes /announce or $announce.
+description: Draft, preview, and explicitly send an Egregore group announcement with $announce. Use for telling the team or notifying everyone—not a direct message or handoff.
 ---
 
-# Egregore Announce
+# Egregore announce
 
-Native Codex Egregore skill. Use this to send concise team announcements
-through the existing Egregore notification path.
+Draft one concise group message. The request authorizes drafting, never
+dispatch or artifact publication. Reuse sufficient `EGREGORE_ORG_CONTEXT_V1`;
+do not repeat organizational retrieval merely to decorate the message.
 
-## Flow
+Preserve quoted wording exactly. Otherwise use 2–5 lines: what changed, an
+already-authorized link when useful, and the requested action. Artifact
+Notification consent and publication consent are separate. Publication remains
+a separate `SHARE` workflow with separate approval.
 
-1. Draft a message from the user request and current context. Keep it under
-   500 characters unless the user provided exact text.
-2. If the announcement references a memory artifact, publish it first and add
-   the returned URL only when publication succeeds:
+Write the exact draft to a mode-0600 temporary file, then create one
+actor-bound Runtime plan:
 
 ```bash
-bash bin/publish-artifact.sh document "$FILE_PATH" --title "$TITLE" --author "$AUTHOR" --description "$DESCRIPTION"
+MESSAGE_FILE="$(mktemp "${TMPDIR:-/tmp}/egregore-announce.XXXXXX")"
+chmod 600 "$MESSAGE_FILE"
+printf '%s' "$MESSAGE" > "$MESSAGE_FILE"
+PLAN_JSON=$(bash bin/notification.sh plan --kind group --message-file "$MESSAGE_FILE")
+rm -f "$MESSAGE_FILE"
 ```
 
-Use `handoff`, `quest`, or `document` as the artifact type when appropriate.
-Never fabricate a URL.
+Show **Send / Edit / Cancel** with the exact organization, group, every
+delivery/channel, and message from that plan. Edit cancels the old plan and
+creates a new digest. Cancel runs `bash bin/notification.sh cancel "$PLAN_ID"`.
 
-3. Follow `.claude/context/notification-consent.md`. Create a plan without
-   sending:
+Only a fresh **Send** response for that exact checkpoint authorizes:
 
 ```bash
-PLAN_JSON=$(bash bin/notify.sh plan group "$MESSAGE")
-```
-
-4. Preview the plan's exact organization, all deliveries/channels, and exact
-   final message. Confirm in a separate checkpoint with structured Codex
-   question tooling when available; otherwise render those fields followed by:
-
-```text
-Send this announcement?
-1. Send
-2. Edit
-3. Cancel
-```
-
-5. If the user edits, cancel the old plan, redraft, plan, and preview again.
-   If they cancel, cancel the plan and stop. Only after they select Send for
-   that exact preview, run:
-
-```bash
-APPROVAL_JSON=$(bash bin/notify.sh approve "$PLAN_ID" "$DIGEST" APPROVE_EXACT_NOTIFICATION)
+APPROVAL_JSON=$(bash bin/notification.sh approve \
+  "$PLAN_ID" "$DIGEST" APPROVE_EXACT_NOTIFICATION)
 APPROVAL_TOKEN=$(printf '%s' "$APPROVAL_JSON" | jq -r '.approval_token')
-bash bin/notify.sh dispatch "$PLAN_ID" "$APPROVAL_TOKEN"
+bash bin/notification.sh dispatch "$PLAN_ID" "$APPROVAL_TOKEN"
 ```
 
-6. Emit telemetry in the background:
-
-```bash
-bash bin/telemetry.sh emit "command" '{"command":"announce"}' >/dev/null 2>&1 &
-```
-
-7. Confirm whether the exact approved group send succeeded.
-
-## Rules
-
-- The request to announce is not dispatch consent. Always use a dedicated
-  exact-delivery checkpoint.
-- Do not expose notification credentials.
-- Use `bin/notify.sh`; do not call Telegram directly.
-- Do not use Claude Code commands.
+Report the returned receipt. Never retry old approval, change destination, or
+fall back to another channel. Local instances without notification capability
+stop after preview and return the text for manual use. Runtime owns
+ActorContext permissions, exact-plan binding, transport, and telemetry.

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

@@ -1,45 +1,30 @@
 ---
 name: archive
-description: 'Capture an effective prompting technique or steering pattern as reusable knowledge. Use for /archive, or when a prompt worked especially well and is worth reusing — not insight about the work itself (/reflect).'
+description: "Capture an effective prompting or steering technique as a reusable canonical pattern. Use when a prompt chain worked especially well; use $reflect for work insights and $note for private thoughts."
 ---
 
-<!-- generated-by: bin/codex-sync-skills.sh -->
+# Archive
 
-# Egregore archive Adapter
+Extract a reusable steering chain from the session or the user's description.
+Record each move's type, trigger, intervention, effect, and principle, plus the
+chain's when-to-use guidance and outcome. Reuse attached
+`EGREGORE_ORG_CONTEXT_V1`; retrieve once only for a named gap or likely
+duplicate, and open exact evidence through `bin/search.sh`.
 
-This is fallback coverage for a long-tail Egregore workflow that has not been
-ported to a hand-written Codex-native skill yet.
+Show the proposed chain and wait for acceptance or edits. Render the accepted
+body to a temporary file, then call exactly once:
 
-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.
+```bash
+bash bin/knowledge.sh create --type pattern --subtype prompt-chain \
+  --title "{chain name}" --input "$TMP_ARTIFACT" \
+  --topic prompt-chain --topic "{topic}" --workstream "{workstream}"
+```
 
-## Structured UX parity
+This Runtime command owns ActorContext authorization, stable identity and
+provenance, canonical Markdown, Git provenance, retrieval refresh, background
+embedding, and content-free telemetry. Add relationships only when explicit.
 
-This workflow has a Claude skill with user-visible structured output. After
-reading `.claude/skills/archive/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/archive/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.
+Do not call Git, QMD, graph, control-plane storage, telemetry, publishing,
+sharing, or notification mechanics directly. Graph is optional and advisory;
+canonical Markdown wins. External effects require separate permission and
+explicit consent. Report the canonical path and writeback status.