create-egregore 0.19.23 → 0.19.24

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

@@ -22,13 +22,20 @@ an addressed recipient belongs to `$wrap`.
    `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 canonical markdown record with frontmatter and these sections:
-   - `## Briefing`
-   - `## Key Decisions`
-   - `## Current State`
-   - `## Open Threads`
-   - `## Next Steps`
-   - `## Entry Points`
+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
@@ -41,12 +48,22 @@ 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. Compose the HTML view from that record. Markdown is canonical; the JSON is
+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:
@@ -76,14 +93,16 @@ ask: <what the receiver should do>
    JSON. For command-heavy sections, keep command headings, explanatory text,
    fenced commands, and expected output verbatim.
 
-6. Render the actual HTML with semantic coverage enabled and show it before
-   publishing. This is the approval surface—not a list of component names:
+   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.
@@ -93,9 +112,12 @@ node packages/egregore-artifacts/bin/cli.js composed "$COMPOSED_FILE" \
 ```bash
 TMPDIR="$(mktemp -d -t codex-handoff-XXXXXX)"
 TMPDIR="$TMPDIR" bash bin/capture-run.sh --mode addressed --author "$AUTHOR" \
-  --topic "$TOPIC" ${RECIPIENT_ARG} --composed "$COMPOSED_FILE" < "$BODY_FILE"
+  --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.
@@ -132,6 +154,8 @@ asks for a summary.
 - 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.

package/runtime/codex/.codex/skills/save/SKILL.md

@@ -42,7 +42,42 @@ esac
    - Stop with "everything is already saved" only when there are no repo or
      memory changes and either the branch has no commits to integrate
      (`AHEAD=0`) or an open integration PR already exists.
-4. Synthesize:
+4. Run the skill distribution checkpoint before any commit or push when
+   `capability-distribution.json` exists:
+
+```bash
+node bin/capability-distribution.mjs validate --root .
+node bin/capability-distribution.mjs changes --root . --base "origin/$BASE" --json
+```
+
+   Inspect the diff as well as the receipt. Ask only when this work introduces
+   a new or unclassified Egregore skill, or changes a skill's placement without
+   an explicit user decision in the current conversation. Ordinary edits to an
+   already classified skill do not prompt. Packages, APIs, sites, workers,
+   infrastructure, and schemas remain outside this checkpoint.
+
+   Show the tracker before asking:
+
+   `artifacts/capability-pipeline.html`
+
+   Ask once using structured Codex question tooling when available. Otherwise
+   render the compact numbered question and wait:
+
+```text
+Where should {name} live?
+1. OSS + Connect — part of the open runtime; Connect inherits it
+2. Connect only — delivered only to authenticated Connect users
+3. Curve Labs / Egregore — used only in this development instance
+```
+
+   Record every new skill as `queued` under the selected placement. Availability
+   is changed separately through the tracker after review. Group skills into one
+   checkpoint only when they share the same placement. Apply the answer to
+   `capability-distribution.json`, regenerate `skill-distribution.json` and both
+   artifacts, then validate again. Rebuild runtime packs only when an available
+   skill changes placement. If the user already made this exact decision during
+   the current work, do not ask twice.
+5. Synthesize:
    - a short topic from the work,
    - a clear commit message,
    - a one-line user-facing scope summary,
@@ -50,7 +85,7 @@ esac
      `## What` (1–4 bullets), `## Why` (1–3 sentences), and
      `## Verification` (how the change was checked — required when the
      diff touches non-markdown files; be honest if unverified).
-5. If the scope is ambiguous or includes unrelated changes, ask for one compact
+6. If the scope is ambiguous or includes unrelated changes, ask for one compact
    confirmation. Use structured Codex question tooling when available;
    otherwise render:
 
@@ -61,7 +96,7 @@ Save these changes?
 Other:
 ```
 
-6. Run the bridge command:
+7. Run the bridge command:
 
 ```bash
 bin/agent.sh save --message "$MESSAGE" --topic "$TOPIC" --pr-body "$PR_BODY"
@@ -72,7 +107,7 @@ commit repo changes, push, and create or reuse a pull request when available.
 Always pass the synthesized `--pr-body` — the bridge only auto-generates a
 skeleton body as a last resort, and the CI `pr-format` check gates every PR.
 
-7. Parse the output and report only useful user information:
+8. Parse the output and report only useful user information:
    - branch name,
    - whether a commit was created,
    - whether push succeeded,

package/runtime/codex/.codex/spec-manifest.json

@@ -29,13 +29,13 @@
     {
       "section": "On Launch — MANDATORY FIRST ACTION",
       "action": "replace",
-      "sourceHash": "d2f6595756c8",
+      "sourceHash": "3def4421213a",
       "note": "Claude SessionStart hook does not run on Codex; the egregore launcher renders the card via bin/codex-session-start.sh before the session. Greeting-replay instruction dropped (card is already on screen)."
     },
     {
       "section": "After Greeting — BRANCH ON FIRST RESPONSE",
       "action": "replace",
-      "sourceHash": "f3bce52b9ade",
+      "sourceHash": "88410d7c6c00",
       "note": "EnterWorktree -> bin/agent.sh branch with git checkout fallback; AskUserQuestion -> numbered options in plain text; branch-guard mapped to .codex/hooks/branch-guard.js with instruction fallback; plan-mode note dropped (no plan mode on Codex); /branch + /onboarding -> skill tokens. Handoff claiming and repoState auto-checkout kept verbatim (pure git)."
     },
     {

package/runtime/codex/AGENTS.md

@@ -132,7 +132,13 @@ integration branch.
 
 1. Derive a topic slug from what the user said (kebab-case, 2–4 words)
 2. Run `bin/agent.sh branch --topic "<topic>"` — it resolves the configured base and creates a work branch from `origin/{base}` in a task worktree (`dev/{author}/{slug}`, or `feature/{slug}` / `bugfix/{slug}` when the topic reads as a feature or fix). Continue all file work from the printed path.
-3. Confirm: `On {branch} (worktree).`
+3. Give a value-first workspace receipt. Do not lead with Git terminology:
+
+   `Your stable project is protected. I’m working in a separate workspace for **{topic}**, where changes stay isolated, reviewable, and reversible.`
+
+   Then expose the implementation as secondary detail:
+
+   `Workspace: {branch} (worktree).`
 
 **Fallback:** If `bin/agent.sh branch` fails, resolve `{base}` with
 `_get_base_branch`, then use
@@ -140,6 +146,17 @@ integration branch.
 
 4. Update graph (fire-and-forget): `bash bin/graph-op.sh set-topic "$(cat .egregore-session-id 2>/dev/null)" "topic from slug" "dev/author/slug" 2>/dev/null &`
 
+### Starting-work UX contract
+
+Before execution begins, make Egregore's useful structure legible without turning every task start into a tutorial:
+
+- **Workspace** — use the value-first receipt above for a newly created workspace or topic pivot. If already on the appropriate working branch, do not repeat it.
+- **Context** — when organizational retrieval materially informs the work, keep the required Egregore Retrieval Beat and then add one compact result receipt: `↳ Context restored: {decision, handoff, or prior work} · {source/date}`. Never claim context was restored when retrieval found nothing useful.
+- **Assumptions** — surface only consequential assumptions that could change the implementation. Use `Assumption: {assumption} — based on {evidence}.` Add a correction path when cheap; do not narrate obvious operational choices.
+- **Transition** — once workspace, context, and assumptions are settled, state the outcome you are starting toward in one short sentence and begin.
+
+The intended sequence is: **intent → safe workspace → relevant context → consequential assumptions → execution**. Keep technical identifiers available but subordinate them to user value.
+
 ### Handoff claiming
 
 If `addressed_to_user` handoffs exist and the user is picking one up, create the IMPLEMENTS link after branch creation:

package/runtime/codex/bin/agent.sh

@@ -506,7 +506,7 @@ cmd_wrap() {
 cmd_handoff() {
   ensure_memory
   local from="" to="" topic="" body="" body_file="" project="" intent="action"
-  local no_publish=0 no_notify=0 json=0
+  local no_publish=0 no_notify=0 json=0 body_supplied=0 content_mode="generated"
   NO_PUSH=0
 
   while [ $# -gt 0 ]; do
@@ -536,12 +536,16 @@ cmd_handoff() {
   if [ -n "$body_file" ]; then
     [ -f "$body_file" ] || die "body file not found: $body_file"
     body="$(cat "$body_file")"
+    body_supplied=1
   elif [ -z "$body" ] && [ ! -t 0 ]; then
     body="$(cat)"
+    [ -n "$body" ] && body_supplied=1
+  elif [ -n "$body" ]; then
+    body_supplied=1
   fi
-  [ -n "$body" ] || body="No briefing provided."
+  [ "$body_supplied" = "1" ] && content_mode="supplied"
 
-  local today tmpd result result_out rel project_line stdout_file
+  local today tmpd result result_out rel stdout_file
   local handoff_args=()
   today="$(date +%Y-%m-%d)"
   tmpd="$(mktemp -d -t egregore-agent-handoff-XXXXXX)"
@@ -549,24 +553,34 @@ cmd_handoff() {
   result_out="$(mktemp -t egregore-agent-handoff-result-XXXXXX.json)"
   stdout_file="$tmpd/stdout"
 
-  project_line=""
-  [ -n "$project" ] && project_line="**Project**: $project"
   [ -n "$to" ] && handoff_args+=(--recipient "$to")
   [ -n "$project" ] && handoff_args+=(--project "$project")
-  handoff_args+=(--intent "$intent")
+  handoff_args+=(--intent "$intent" --content-mode "$content_mode")
+  [ "$content_mode" = "generated" ] && handoff_args+=(--include-session-artifacts)
   [ "$NO_PUSH" = "1" ] && handoff_args+=(--no-push)
   [ "$no_publish" = "1" ] && handoff_args+=(--no-publish)
   [ "$no_notify" = "1" ] && handoff_args+=(--no-notify)
 
   {
-    printf '# Handoff: %s\n\n' "$topic"
-    printf '**Date**: %s\n' "$today"
-    printf '**Author**: %s\n' "$from"
-    [ -n "$to" ] && printf '**To**: %s\n' "$to"
-    printf '**Intent**: %s\n' "$intent"
-    [ -n "$project_line" ] && printf '%s\n' "$project_line"
-    printf '\n## Briefing\n\n%s\n\n' "$body"
-    printf '## Next Steps\n\n- Continue from this handoff using the shared Egregore memory protocol.\n'
+    printf '%s\n' '---'
+    printf 'capture_schema: egregore-capture/v1\n'
+    printf 'capture_mode: addressed\n'
+    printf 'kind: addressed\n'
+    printf 'content_mode: %s\n' "$content_mode"
+    printf 'from: %s\n' "$(yaml_str "$from")"
+    [ -n "$to" ] && printf 'addressed_to: %s\n' "$(yaml_str "$to")"
+    printf 'date: %s\n' "$today"
+    printf 'topic: %s\n' "$(yaml_str "$topic")"
+    printf 'intent: %s\n' "$intent"
+    [ -n "$project" ] && printf 'project: %s\n' "$(yaml_str "$project")"
+    printf '%s\n\n' '---'
+    if [ "$content_mode" = "supplied" ]; then
+      printf '%s\n' "$body"
+    else
+      printf '# Handoff: %s\n\n' "$topic"
+      printf '## Briefing\n\nNo briefing was supplied.\n\n'
+      printf '## Next Steps\n\n1. Continue from this handoff using the shared Egregore memory protocol.\n'
+    fi
   } | TMPDIR="$tmpd" bash "$SCRIPT_DIR/bin/capture-run.sh" \
         --mode addressed \
         --author "$from" \

package/runtime/codex/bin/attendant.sh

@@ -387,26 +387,57 @@ Co-Authored-By: Egregore Attendant <noreply@egregore.xyz>" 2>/dev/null
 WARM_MIN="${ATTENDANT_WARM_MIN:-5}"
 WARM_MARKER="$STATE_DIR/$KEY.warm-ts"
 
+# Non-secret fingerprint of the effective graph endpoint + credential, matching
+# bin/graph.sh's resolution order exactly (process env → .env → committed
+# api_url). Scopes the graph cache and the snapshot provenance to the tenant
+# answers actually come from, not just the tenant the committed config names.
+_effective_scope() {
+  local url key
+  url="${EGREGORE_API_URL:-$(grep '^EGREGORE_API_URL=' "$MAIN_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
+  key="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "$MAIN_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
+  [ -n "$url" ] || url=$(jq -r '.api_url // empty' "$CONFIG" 2>/dev/null)
+  echo -n "${url}|${key}" | cksum | cut -d' ' -f1
+}
+
 _warm() {
   local now last
   now=$(date +%s)
   last=$(cat "$WARM_MARKER" 2>/dev/null || echo 0)
+  # Numeric + not-future guard: a malformed legacy marker must not abort
+  # warming, and a future timestamp must not suppress it indefinitely.
+  case "$last" in ''|*[!0-9]*) last=0 ;; esac
+  [ "$last" -gt "$now" ] && last=0
   [ $(( now - last )) -lt $(( WARM_MIN * 60 )) ] && return 0
   [ "$DRY_RUN" = "1" ] && { log "DRY warm"; return 0; }
 
-  git -C "$MAIN_DIR" fetch origin --quiet 2>/dev/null &
+  # --prune keeps remote-tracking refs honest so the launch path can answer
+  # "does my branch still exist on origin?" from local refs (worktree stale
+  # check in git-sync.sh) instead of a ~2s ls-remote round-trip.
+  local _origin_pid _origin_ok="false"
+  git -C "$MAIN_DIR" fetch origin --prune --quiet 2>/dev/null &
+  _origin_pid=$!
   [ -d "$MEMORY_DIR/.git" ] || [ -f "$MEMORY_DIR/.git" ] && git -C "$MEMORY_DIR" fetch origin --quiet 2>/dev/null &
   local repo
   jq -r '(.repos[]? // empty) | if type == "object" then .name else . end' "$CONFIG" 2>/dev/null | while read -r repo; do
     [ -d "$MAIN_DIR/../$repo/.git" ] && git -C "$MAIN_DIR/../$repo" fetch origin --quiet 2>/dev/null
   done &
+  wait "$_origin_pid" 2>/dev/null && _origin_ok="true"
   wait
-  date +%s > "$WARM_MARKER"
+  # Stamp the marker ONLY when the origin fetch actually succeeded, and stamp
+  # it atomically (tmp+mv): the launch path treats a fresh marker as "local
+  # refs are authoritative", so a failed fetch must not silence live fetches
+  # for ten minutes, and a reader must never catch a half-written timestamp.
+  if [ "$_origin_ok" = "true" ]; then
+    date +%s > "$WARM_MARKER.tmp" && mv "$WARM_MARKER.tmp" "$WARM_MARKER"
+  fi
 
   # Replay graph cache entries touched in the last 24h (connected mode only —
   # in local mode graph.sh exits instantly and no cache exists).
   local cache_dir f q p
-  cache_dir="$HOME/.egregore/graph-cache/$(echo -n "$MAIN_DIR" | cksum | cut -d' ' -f1)"
+  # Key must match graph.sh's _CACHE_DIR derivation exactly: repo root plus
+  # the effective endpoint/credential fingerprint, so entries never cross
+  # tenants when the same checkout is repointed at a different org/API.
+  cache_dir="$HOME/.egregore/graph-cache/$(echo -n "${MAIN_DIR}|$(_effective_scope)" | cksum | cut -d' ' -f1)"
   if [ -d "$cache_dir" ]; then
     for f in $(find "$cache_dir" -name '*.json' -mmin -1440 2>/dev/null); do
       q=$(jq -r '.query // empty' "$f" 2>/dev/null)
@@ -414,7 +445,90 @@ _warm() {
       [ -n "$q" ] && EGREGORE_GRAPH_CACHE_TTL=1 bash "$MAIN_DIR/bin/graph.sh" query "$q" "$p" >/dev/null 2>&1 || true
     done
   fi
-  log "warm: refs fetched, graph cache replayed"
+  _prebake_context
+  log "warm: refs fetched, graph cache replayed, context baked"
+}
+
+# --- Pre-bake the session-start context snapshot -----------------------------
+# Runs the same context gather session-start would (bin/lib/context.sh) and
+# stores the result as a single tar at $STATE_DIR/$KEY.ctx.tar. On boot,
+# context.sh reuses the baked graph-bound results (todos, lifecycle, pulse,
+# metrics, service health) when the bake is <15min old and its provenance
+# matches (author, mode, config), re-running the local collectors live —
+# taking the greeting's graph work off the launch path entirely.
+#
+# One tar + atomic rename, not a directory swap: readers open either the whole
+# old bake or the whole new one, never a half-replaced directory. The tmp name
+# carries $$ so two attendants racing (possible before the run-loop self-check
+# converges them) never write through each other's file.
+_prebake_context() {
+  [ -f "$MAIN_DIR/bin/lib/context.sh" ] || return 0
+  local snap="$STATE_DIR/$KEY.ctx.tar"
+  (
+    set +u +e
+    unset CTX_SEED_TAR CTX_SEED_DIR   # never let a bake seed itself from an old bake
+    SCRIPT_DIR="$MAIN_DIR"
+    CONFIG="$MAIN_DIR/egregore.json"
+    STATE_FILE="$MAIN_DIR/.egregore-state.json"
+    ENV_FILE="$MAIN_DIR/.env"
+    AUTHOR=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null)
+    [ -n "$AUTHOR" ] || exit 0
+    # Canonical mode semantics (config.sh _detect_mode): local when the config
+    # says so OR api_url is absent — legacy OSS configs carry no mode key, and
+    # a bare '.mode == local' test would bake failed connected health for them.
+    LOCAL_MODE="false"
+    source "$MAIN_DIR/bin/lib/config.sh" 2>/dev/null || true
+    if type _detect_mode >/dev/null 2>&1; then
+      [ "$(_detect_mode)" = "local" ] && LOCAL_MODE="true"
+    elif ! jq -e '(.mode // "") != "local" and ((.api_url // "") | length > 0)' "$CONFIG" >/dev/null 2>&1; then
+      LOCAL_MODE="true"
+    fi
+    # Capture ALL provenance BEFORE gathering, then publish only if it is
+    # unchanged AFTER — a user, config, or credential switch mid-gather would
+    # otherwise produce mixed-tenant/mixed-user data labeled with whatever the
+    # final values happened to be (TOCTOU).
+    _PRE_CONFIG=$(cksum "$CONFIG" 2>/dev/null | cut -d' ' -f1)
+    _PRE_SCOPE=$(_effective_scope)
+    _PRE_SCHEMA=$(cksum "$MAIN_DIR/bin/lib/context.sh" 2>/dev/null | cut -d' ' -f1)
+    # PIN the effective credentials for the entire gather: graph.sh re-reads
+    # env/.env in every subprocess, so without pinning, an A→B→A .env flip
+    # during the gather could fetch B-tenant data that the pre/post scope
+    # samples cannot see. With the pin, every graph call in this bake uses
+    # the credentials the provenance stamp names. Empty values stay empty
+    # (local mode) — graph.sh treats them as unset.
+    export EGREGORE_API_URL="${EGREGORE_API_URL:-$(grep '^EGREGORE_API_URL=' "$MAIN_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
+    export EGREGORE_API_KEY="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "$MAIN_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
+    export EGREGORE_GRAPH_CACHE_TTL=600
+    source "$MAIN_DIR/bin/lib/context.sh"
+    [ -n "$CTX_DIR" ] && [ -d "$CTX_DIR" ] || exit 0
+    _POST_AUTHOR=$(jq -r '.github_username // empty' "$STATE_FILE" 2>/dev/null)
+    _POST_CONFIG=$(cksum "$CONFIG" 2>/dev/null | cut -d' ' -f1)
+    _POST_SCOPE=$(_effective_scope)
+    _POST_SCHEMA=$(cksum "$MAIN_DIR/bin/lib/context.sh" 2>/dev/null | cut -d' ' -f1)
+    if [ "$_POST_AUTHOR" != "$AUTHOR" ] || [ "$_POST_CONFIG" != "$_PRE_CONFIG" ] \
+      || [ "$_POST_SCOPE" != "$_PRE_SCOPE" ] || [ "$_POST_SCHEMA" != "$_PRE_SCHEMA" ]; then
+      rm -rf "$CTX_DIR"
+      exit 0
+    fi
+    # Provenance the reader validates before trusting the bake.
+    date +%s > "$CTX_DIR/.baked-ts"
+    printf '%s\n' "$AUTHOR" > "$CTX_DIR/.baked-author"
+    printf '%s\n' "$LOCAL_MODE" > "$CTX_DIR/.baked-local-mode"
+    printf '%s\n' "$_PRE_CONFIG" > "$CTX_DIR/.baked-config"
+    # Effective endpoint/credential + the context.sh revision that produced
+    # this bake: a seed from a different tenant or a different collector
+    # schema must never be trusted.
+    printf '%s\n' "$_PRE_SCOPE" > "$CTX_DIR/.baked-scope"
+    printf '%s\n' "$_PRE_SCHEMA" > "$CTX_DIR/.baked-schema"
+    if (cd "$CTX_DIR" && tar -cf "$snap.tmp.$$" .) 2>/dev/null; then
+      mv -f "$snap.tmp.$$" "$snap" 2>/dev/null || rm -f "$snap.tmp.$$" 2>/dev/null
+    else
+      rm -f "$snap.tmp.$$" 2>/dev/null
+    fi
+    rm -rf "$CTX_DIR"
+  ) >/dev/null 2>&1 || true
+  # Clean up the directory-format snapshot from the previous iteration
+  rm -rf "$STATE_DIR/$KEY.ctx" 2>/dev/null || true
 }
 
 # --- Handoff lifecycle: recurring close / nudge / expiry --------------------
@@ -482,6 +596,11 @@ cmd_run() {
   log "attendant up (pid $$, stale=${STALE_MIN}m, $MAIN_DIR)"
   while true; do
     [ -d "$MAIN_DIR" ] || { log "project gone — exiting"; break; }
+    # Duplicate-daemon convergence: cmd_ensure's check-then-spawn is lockless,
+    # so two concurrent cold starts can both launch a run loop. Whoever owns
+    # the pidfile keeps running; the other notices within one cycle and exits
+    # without touching shared state.
+    [ "$(cat "$PIDFILE" 2>/dev/null)" = "$$" ] || { log "superseded (pid $$) — exiting"; exit 0; }
     cmd_sweep
     sleep 60
   done
@@ -498,8 +617,52 @@ cmd_ensure() {
     kill "$(cat "$PIDFILE")" 2>/dev/null || true
     rm -f "$PIDFILE"
   fi
-  nohup bash "$MAIN_DIR/bin/attendant.sh" run >> "$LOGFILE" 2>&1 &
-  disown 2>/dev/null || true
+  # Atomic spawn gate: the pidfile check above is check-then-spawn, so two
+  # concurrent cold starts could both reach here and launch two daemons that
+  # overlap for a full cycle (lifecycle jobs, ripcord, auto-push). mkdir is
+  # the portable atomic primitive; a crashed spawner's stale lock breaks
+  # after 5 minutes. Losing the race means someone else is spawning — done.
+  local _spawn_lock="$STATE_DIR/$KEY.spawn-lock"
+  if ! mkdir "$_spawn_lock" 2>/dev/null; then
+    local _lock_age
+    _lock_age=$(( $(date +%s) - $(stat -f %m "$_spawn_lock" 2>/dev/null || stat -c %Y "$_spawn_lock" 2>/dev/null || echo 0) ))
+    # Stale reap by atomic rename, never rmdir+mkdir: two reapers doing
+    # remove-then-recreate can alternately delete each other's FRESH lock and
+    # both spawn. Exactly one mv succeeds; losing the mv or the follow-up
+    # mkdir means someone else owns a fresh lock — back off.
+    if [ "$_lock_age" -gt 300 ] && mv "$_spawn_lock" "$_spawn_lock.reap.$$" 2>/dev/null; then
+      rm -rf "$_spawn_lock.reap.$$" 2>/dev/null
+      mkdir "$_spawn_lock" 2>/dev/null || exit 0
+    else
+      exit 0
+    fi
+  fi
+  # Re-check under the lock — the racing ensure may already have spawned.
+  if ! { [ -f "$PIDFILE" ] && kill -0 "$(cat "$PIDFILE" 2>/dev/null)" 2>/dev/null; }; then
+    nohup bash "$MAIN_DIR/bin/attendant.sh" run >> "$LOGFILE" 2>&1 &
+    disown 2>/dev/null || true
+    # Hold the lock until the child's ownership is durably visible (it writes
+    # its pidfile first thing in cmd_run). Releasing earlier reopens the race:
+    # another ensure passes the pidfile re-check before the child registers
+    # and spawns a second daemon whose first sweep overlaps this one.
+    local _i _spawned="false"
+    for _i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25; do
+      if [ -f "$PIDFILE" ] && kill -0 "$(cat "$PIDFILE" 2>/dev/null)" 2>/dev/null; then
+        _spawned="true"
+        break
+      fi
+      sleep 0.2
+    done
+    if [ "$_spawned" != "true" ]; then
+      # Child still hasn't registered: KEEP the lock rather than reopen the
+      # spawn window — a merely-delayed child may yet come up, and the stale
+      # reaper above frees the lock in 5 minutes if it never does. Fail
+      # closed: no attendant for a few minutes beats two attendants sweeping.
+      log "ensure: spawned child slow to register — holding spawn lock (pid $$)"
+      exit 0
+    fi
+  fi
+  rmdir "$_spawn_lock" 2>/dev/null || true
 }
 
 cmd_status() {

package/runtime/codex/bin/codex-render-spec.mjs

@@ -186,7 +186,13 @@ integration branch.
 
 1. Derive a topic slug from what the user said (kebab-case, 2–4 words)
 2. Run \`bin/agent.sh branch --topic "<topic>"\` — it resolves the configured base and creates a work branch from \`origin/{base}\` in a task worktree (\`dev/{author}/{slug}\`, or \`feature/{slug}\` / \`bugfix/{slug}\` when the topic reads as a feature or fix). Continue all file work from the printed path.
-3. Confirm: \`On {branch} (worktree).\`
+3. Give a value-first workspace receipt. Do not lead with Git terminology:
+
+   \`Your stable project is protected. I’m working in a separate workspace for **{topic}**, where changes stay isolated, reviewable, and reversible.\`
+
+   Then expose the implementation as secondary detail:
+
+   \`Workspace: {branch} (worktree).\`
 
 **Fallback:** If \`bin/agent.sh branch\` fails, resolve \`{base}\` with
 \`_get_base_branch\`, then use
@@ -194,6 +200,17 @@ integration branch.
 
 4. Update graph (fire-and-forget): \`bash bin/graph-op.sh set-topic "$(cat .egregore-session-id 2>/dev/null)" "topic from slug" "dev/author/slug" 2>/dev/null &\`
 
+### Starting-work UX contract
+
+Before execution begins, make Egregore's useful structure legible without turning every task start into a tutorial:
+
+- **Workspace** — use the value-first receipt above for a newly created workspace or topic pivot. If already on the appropriate working branch, do not repeat it.
+- **Context** — when organizational retrieval materially informs the work, keep the required Egregore Retrieval Beat and then add one compact result receipt: \`↳ Context restored: {decision, handoff, or prior work} · {source/date}\`. Never claim context was restored when retrieval found nothing useful.
+- **Assumptions** — surface only consequential assumptions that could change the implementation. Use \`Assumption: {assumption} — based on {evidence}.\` Add a correction path when cheap; do not narrate obvious operational choices.
+- **Transition** — once workspace, context, and assumptions are settled, state the outcome you are starting toward in one short sentence and begin.
+
+The intended sequence is: **intent → safe workspace → relevant context → consequential assumptions → execution**. Keep technical identifiers available but subordinate them to user value.
+
 ### Handoff claiming
 
 If \`addressed_to_user\` handoffs exist and the user is picking one up, create the IMPLEMENTS link after branch creation:

package/runtime/codex/bin/codex-session-start.sh

@@ -68,7 +68,20 @@ if [ "$LOCAL_MODE" != "true" ]; then
 fi
 
 source "$SCRIPT_DIR/bin/lib/git-sync.sh" >/dev/null 2>/dev/null
+# Warm-state parity with the Claude SessionStart path: hand context.sh the
+# pre-baked snapshot and route greeting reads through the warm graph cache.
+# The attendant daemon is deliberately NOT started from the Codex/Pi path —
+# its dead-session detection reads Claude transcripts only, so a live Codex
+# or Pi session with 12 quiet minutes would look dead and could have its
+# unfinished work ripcorded/auto-pushed. Codex sessions still benefit from
+# any snapshot a Claude session's attendant maintains; runtime-neutral
+# liveness tracking is the prerequisite for starting the daemon here.
+if [ -n "${_ATT_KEY:-}" ]; then
+  export CTX_SEED_TAR="${ATTENDANT_HOME:-$HOME/.egregore/attendant}/${_ATT_KEY}.ctx.tar"
+fi
+export EGREGORE_GRAPH_CACHE_TTL=600
 source "$SCRIPT_DIR/bin/lib/context.sh" >/dev/null 2>/dev/null
+unset EGREGORE_GRAPH_CACHE_TTL CTX_SEED_TAR
 source "$SCRIPT_DIR/bin/lib/metrics.sh" >/dev/null 2>/dev/null
 trap 'rm -rf "${CTX_DIR:-}"' EXIT
 

package/runtime/codex/bin/codex-sync-skills.sh

@@ -22,6 +22,7 @@ NATIVE_SKILLS=(
   search
   view
   scroll
+  plate
 )
 
 STRUCTURED_UX_SKILLS=(

package/runtime/codex/bin/graph.sh

@@ -48,7 +48,27 @@ _millis() {
 # greeting) pay zero network round-trips when warm. TTL in seconds; unset/0
 # disables. Mutating queries are never cached.
 _CACHE_TTL="${EGREGORE_GRAPH_CACHE_TTL:-0}"
-_CACHE_DIR="$HOME/.egregore/graph-cache/$(echo -n "$SCRIPT_DIR" | cksum | cut -d' ' -f1)"
+# Key the cache by the MAIN checkout so worktree sessions hit the same warm
+# cache the attendant maintains (its replay uses the same derivation).
+# Worktrees have .git as a FILE pointing into the main repo's .git/worktrees/.
+# api_url + slug are part of the key so entries never cross tenants when the
+# same checkout is repointed at a different org/API (cache entries are keyed
+# only by query+params below, so the directory must carry the tenant).
+_CACHE_ROOT="$SCRIPT_DIR"
+if [ -f "$SCRIPT_DIR/.git" ]; then
+  _WT_GITDIR=$(sed 's/^gitdir: //' "$SCRIPT_DIR/.git" 2>/dev/null || true)
+  if [ -n "$_WT_GITDIR" ]; then
+    _CACHE_ROOT=$(cd "$_WT_GITDIR/../../.." 2>/dev/null && pwd || echo "$SCRIPT_DIR")
+  fi
+fi
+# The scope is a non-secret fingerprint of the EFFECTIVE endpoint + credential
+# (already resolved above: process env → .env → committed api_url). Committed
+# config alone is not enough — an EGREGORE_API_URL/KEY override or a swapped
+# .env can point this checkout at a different tenant than egregore.json names,
+# and the entry key below carries only query+params. cksum output is a CRC,
+# not a reversible or usable credential.
+_CACHE_SCOPE=$(echo -n "${API_URL:-}|${API_KEY:-}" | cksum | cut -d' ' -f1)
+_CACHE_DIR="$HOME/.egregore/graph-cache/$(echo -n "${_CACHE_ROOT}|${_CACHE_SCOPE}" | cksum | cut -d' ' -f1)"
 
 _cache_key() {
   echo -n "$1|${2:-}" | cksum | cut -d' ' -f1