create-egregore 0.18.0 → 0.18.2

package/runtime/codex/bin/handoff-run.sh

@@ -203,13 +203,14 @@ PID_GRAPH=$!
   ARTIFACTS_JSON="[]"
   if [ "$MODE" = "connected" ]; then
     YY=$(date +%Y); MM=$(date +%-m); DD_NUM=$(date +%-d)
+    PARAMS=$(jq -nc --arg gh "$AUTHOR" '{gh:$gh}')
     RAW=$(bash "$SCRIPT_DIR/bin/graph.sh" query "
       MATCH (a:Artifact)-[:CONTRIBUTED_BY]->(p:Person {github: \$gh})
       WHERE a.created >= datetime({year: $YY, month: $MM, day: $DD_NUM})
         AND NOT 'tutorial-generated' IN coalesce(a.topics, [])
       RETURN a.title AS title, a.type AS type, a.filePath AS path
       ORDER BY a.created DESC
-      LIMIT 5" "$(jq -nc --arg gh "$AUTHOR" '{gh:$gh}')" 2>/dev/null || echo '{}')
+      LIMIT 5" "$PARAMS" 2>/dev/null || echo '{}')
     # Response shape: {"fields":[...], "values":[[...], ...]}. Convert to
     # an array of {title, type, path} objects.
     ARTIFACTS_JSON=$(echo "$RAW" | jq -c '
@@ -281,145 +282,24 @@ PID_ARTIFACTS=$!
 PID_MEMORY=$!
 
 # --- Branch C: Publish artifact → Notify ---
-#
-# Strategy: handoffs publish ONCE, through the emissary write API, using
-# `render_mode: "custom"` so the server serves OUR pre-rendered HTML
-# verbatim (the same egregore-artifacts handoff template /view/ has
-# always used). This gives us:
-#   - one artifact, one URL (no legacy + new double-publish)
-#   - permanent egregore.xyz/emissary/e/<id> URL with /raw endpoint
-#   - handoff design fully owned client-side (egregore-artifacts) — the
-#     emissary server template is never invoked for handoffs and remains
-#     completely untouched
-#
-# Fallback: if emissary publish fails (token missing, network, size cap,
-# rendering failure), fall back to the legacy publish-artifact.sh path so
-# a handoff still gets a Telegram-able URL.
 (
-  V1URL=""
   AURL=""
-  if [ "$NO_PUBLISH" = "0" ]; then
-    EMISSARY_CONFIG="$HOME/.egregore/emissary-config.json"
-    EMISSARY_TOKEN=""
-    if [ -f "$EMISSARY_CONFIG" ]; then
-      EMISSARY_TOKEN=$(jq -r '.auth_token // empty' "$EMISSARY_CONFIG" 2>/dev/null)
-    fi
-    EMISSARY_API_URL="${EMISSARY_API_URL:-https://egregore-production-55f2.up.railway.app/api/v1/emissary}"
-
-    if [ -n "$EMISSARY_TOKEN" ]; then
-      # Step 1: render the handoff to HTML locally using egregore-artifacts.
-      # Same renderer + template publish-artifact.sh uses today — handoffs
-      # keep their familiar look.
-      RENDERED_HTML="$TMPD/handoff.html"
-      RENDER_OK=0
-      LOCAL_CLI="$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js"
-      if [ "${EGREGORE_USE_PUBLISHED:-0}" != "1" ] && [ -f "$LOCAL_CLI" ] && [ -d "$SCRIPT_DIR/packages/egregore-artifacts/node_modules/react" ]; then
-        if node "$LOCAL_CLI" handoff "$ABS_FILE" --output "$RENDERED_HTML" >/dev/null 2>&1; then
-          RENDER_OK=1
-        fi
-      else
-        if npx egregore-artifacts handoff "$ABS_FILE" --output "$RENDERED_HTML" >/dev/null 2>&1; then
-          RENDER_OK=1
-        fi
-      fi
-
-      # Step 2: build the emissary payload. If rendering succeeded AND the
-      # HTML fits the server's 100KB cap, send it with render_mode=custom.
-      # If not, fall through to the structured-only path (server-rendered
-      # via the emissary template — undesirable for handoffs but still
-      # better than no URL).
-      if [ "$RENDER_OK" = "1" ] && [ -f "$RENDERED_HTML" ]; then
-        RENDER_SIZE=$(wc -c < "$RENDERED_HTML" | tr -d ' ')
-        if [ "$RENDER_SIZE" -gt 0 ] && [ "$RENDER_SIZE" -lt 100000 ]; then
-          # Author display name
-          DISPLAY_NAME="$AUTHOR"
-          PERSON_FILE="$SCRIPT_DIR/memory/people/${AUTHOR}.md"
-          if [ -f "$PERSON_FILE" ]; then
-            DISPLAY_NAME=$(head -1 "$PERSON_FILE" | sed 's/^# //')
-          fi
-
-          # addressed_to: only set if there's a recipient
-          ADDRESSED_TO="[]"
-          if [ -n "$RECIPIENT" ]; then
-            RECIP_HANDLE=$(echo "$RECIPIENT" | tr '[:upper:]' '[:lower:]' | awk '{print $1}')
-            ADDRESSED_TO=$(jq -nc --arg h "$RECIP_HANDLE" --arg d "$RECIPIENT" '[{"handle":$h,"display":$d}]')
-          fi
-
-          CLAIM=$(echo "$BRIEFING_LEAD" | cut -c1-200)
-
-          # body.prose is schema-required non-empty even when render_mode is
-          # "custom" (server validates structurally regardless of render
-          # mode). The visible page is the custom HTML; prose just needs to
-          # be non-empty plain text for /raw consumers and validation. Use
-          # the briefing lead (which the lead/claim is already derived from).
-          PROSE_TEXT="${BRIEFING_LEAD:-$TOPIC}"
-
-          # Use --rawfile so the rendered HTML is read directly from disk
-          # into a JSON-string. Faster than shell-var roundtrip and avoids
-          # any quoting headaches for HTML.
-          V1JSON=$(jq -nc \
-            --arg topic "$TOPIC" \
-            --arg claim "$CLAIM" \
-            --arg summary "$CLAIM" \
-            --arg prose "$PROSE_TEXT" \
-            --argjson addressed "$ADDRESSED_TO" \
-            --rawfile render_html "$RENDERED_HTML" \
-            '{
-              kind: "continuation",
-              topic: $topic,
-              claim: $claim,
-              summary: $summary,
-              body: { prose: $prose },
-              audience: {
-                addressed_to: $addressed,
-                visible_to: "public",
-                extendable_by: "anyone"
-              },
-              parents: [],
-              render_mode: "custom",
-              render_html: $render_html
-            }')
-
-          V1RESULT=$(curl -sf -X POST "$EMISSARY_API_URL/emissaries" \
-            -H "Content-Type: application/json" \
-            -H "Authorization: Bearer $EMISSARY_TOKEN" \
-            -d "$V1JSON" 2>/dev/null || echo '{}')
-
-          V1URL=$(echo "$V1RESULT" | jq -r '.url // ""' 2>/dev/null || echo "")
-        fi
-      fi
-    fi
-  fi
-
-  # Fallback: if the emissary publish didn't produce a URL (no token, no
-  # network, size cap, render failure), fire the legacy publish-artifact.sh
-  # so handoffs still get a Telegram-able URL.
-  if [ -z "$V1URL" ] && [ "$NO_PUBLISH" = "0" ] && [ -x "$SCRIPT_DIR/bin/publish-artifact.sh" ]; then
+  if [ "$NO_PUBLISH" = "0" ] && [ -x "$SCRIPT_DIR/bin/publish-artifact.sh" ]; then
     AURL=$(bash "$SCRIPT_DIR/bin/publish-artifact.sh" handoff "$ABS_FILE" \
       --title "$TOPIC" \
       --author "$AUTHOR" \
       --description "$BRIEFING_LEAD" 2>/dev/null || echo "")
   fi
-
-  # Prefer v1 (emissary-rendered) URL when available; fall back to the
-  # legacy egregore-artifacts URL only if the v1 publish failed.
-  NOTIFY_URL=""
-  if [ -n "$V1URL" ]; then
-    echo "$V1URL" > "$TMPD/artifact"
-    NOTIFY_URL="$V1URL"
-  else
-    echo "$AURL" > "$TMPD/artifact"
-    NOTIFY_URL="$AURL"
-  fi
+  echo "$AURL" > "$TMPD/artifact"
 
   NS="skipped"
   if [ "$NO_NOTIFY" = "0" ]; then
-    if [ -n "$NOTIFY_URL" ]; then
+    if [ -n "$AURL" ]; then
       MSG_NOTIFY="Handoff from ${AUTHOR}: ${TOPIC}
 
 \"${BRIEFING_SHORT}\"
 
-View: ${NOTIFY_URL}"
+View: ${AURL}"
     else
       MSG_NOTIFY="Handoff from ${AUTHOR}: ${TOPIC}
 
@@ -465,27 +345,9 @@ if [ -s "$TMPD/graph" ]; then
   GRAPH_STATUS=$(sed -n '3p' "$TMPD/graph")
 fi
 [ -z "$RESOLVED" ] && RESOLVED=0
-# Sanitize: --argjson requires a number. If RESOLVED came back as a slug or
-# anything non-numeric (the index-handoff.sh output format has drifted in
-# the past — defensive guard), fall back to 0 so the result file still builds.
-if ! echo "$RESOLVED" | grep -qE '^[0-9]+$'; then
-  RESOLVED=0
-fi
 
 SUBGRAPH_JSON=$(cat "$TMPD/subgraph" 2>/dev/null || echo "null")
 [ -z "$SUBGRAPH_JSON" ] && SUBGRAPH_JSON="null"
-# Sanitize: --argjson requires valid JSON. Multiple writes to the same
-# tmpfile have produced concatenated values in the past (e.g. "null\n{...}"),
-# which jq rejects on multi-document input. Validate; on failure, take the
-# LAST non-empty line and re-validate; if still bad, fall back to null.
-if ! printf '%s' "$SUBGRAPH_JSON" | jq -s 'length == 1' 2>/dev/null | grep -q '^true$'; then
-  LAST_LINE=$(printf '%s\n' "$SUBGRAPH_JSON" | awk 'NF{last=$0} END{print last}')
-  if printf '%s' "$LAST_LINE" | jq -e '.' >/dev/null 2>&1; then
-    SUBGRAPH_JSON="$LAST_LINE"
-  else
-    SUBGRAPH_JSON="null"
-  fi
-fi
 
 MEMORY_STATUS=$(cat "$TMPD/memory"   2>/dev/null || echo "skipped")
 ARTIFACT_URL=$(cat "$TMPD/artifact"  2>/dev/null || echo "")

package/runtime/codex/bin/lib/context.sh

@@ -364,54 +364,6 @@ fi
   echo "$RICH" > "$CTX_DIR/addressed_rich"
 ) &
 
-# 6.5. Pending questions addressed to user (background)
-(
-  PENDING_JSON="[]"
-  QDIR="$SCRIPT_DIR/memory/knowledge/questions"
-  if [ -d "$QDIR" ]; then
-    # Match against the same identity variants used for handoffs (display name,
-    # github first-name, people-file name) so "to: oz" matches author "oguzhan".
-    _DISPLAY_Q=$(jq -r '.display_name // empty' "$STATE_FILE" 2>/dev/null)
-    _GH_NAME_Q=$(jq -r '.github_name // empty' "$STATE_FILE" 2>/dev/null)
-    _FIRST_NAME_Q=$(echo "$_GH_NAME_Q" | awk '{print tolower($1)}')
-    _PEOPLE_FILE_Q="$SCRIPT_DIR/memory/people/$(echo "$AUTHOR" | tr '[:upper:]' '[:lower:]').md"
-    _PEOPLE_NAME_Q=""
-    [ -f "$_PEOPLE_FILE_Q" ] && _PEOPLE_NAME_Q=$(sed -n 's/^# *//p' "$_PEOPLE_FILE_Q" 2>/dev/null | head -1 | awk '{print tolower($1)}')
-
-    LINES=""
-    for QF in "$QDIR"/*.md; do
-      [ -f "$QF" ] || continue
-      Q_TO=$(sed -n 's/^to:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"' | tr '[:upper:]' '[:lower:]' | awk '{print $1}')
-      [ -z "$Q_TO" ] && continue
-      _MATCH="false"
-      for _V in "$AUTHOR" "$_DISPLAY_Q" "$_FIRST_NAME_Q" "$_PEOPLE_NAME_Q"; do
-        [ -z "$_V" ] && continue
-        _V_LC=$(echo "$_V" | tr '[:upper:]' '[:lower:]')
-        [ "$Q_TO" = "$_V_LC" ] && _MATCH="true" && break
-      done
-      [ "$_MATCH" = "true" ] || continue
-      Q_STATUS=$(sed -n 's/^status:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
-      [ "$Q_STATUS" = "pending" ] || continue
-      Q_FROM=$(sed -n 's/^from:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
-      Q_TOPIC=$(sed -n 's/^topic:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
-      Q_HID=$(sed -n 's/^harvest_id:[[:space:]]*//p' "$QF" 2>/dev/null | head -1 | tr -d '"')
-      Q_REL="${QF#$SCRIPT_DIR/}"
-      LINE=$(jq -nc \
-        --arg from "$Q_FROM" \
-        --arg topic "$Q_TOPIC" \
-        --arg hid "$Q_HID" \
-        --arg file "$Q_REL" \
-        '{from:$from, topic:$topic, harvest_id:$hid, file:$file}' 2>/dev/null)
-      [ -n "$LINE" ] && LINES="$LINES$LINE
-"
-    done
-    if [ -n "$LINES" ]; then
-      PENDING_JSON=$(echo "$LINES" | jq -sc '.' 2>/dev/null || echo "[]")
-    fi
-  fi
-  echo "$PENDING_JSON" > "$CTX_DIR/pending_questions"
-) &
-
 # 7. Graph health (background — zero added latency, runs in parallel)
 (
   if [ "$LOCAL_MODE" = "true" ]; then

package/runtime/codex/bin/lib/greeting.sh

@@ -112,26 +112,8 @@ if [ "$ADDRESSED_COUNT" -gt 0 ] 2>/dev/null && [ "$ADDRESSED_COUNT" != "0" ]; th
   done
 fi
 
-# Pending questions addressed to you (one summary line — /answer to engage)
-PENDING_Q=$(cat "$CTX_DIR/pending_questions" 2>/dev/null || echo "[]")
-PENDING_Q_COUNT=$(echo "$PENDING_Q" | jq 'length' 2>/dev/null || echo "0")
-if [ "$PENDING_Q_COUNT" -gt 0 ] 2>/dev/null && [ "$PENDING_Q_COUNT" != "0" ]; then
-  PQ_SENDERS=$(echo "$PENDING_Q" | jq -r '[.[].from] | unique | join(", ")' 2>/dev/null)
-  if [ "$PENDING_Q_COUNT" = "1" ]; then
-    PQ_NOUN="question"
-  else
-    PQ_NOUN="questions"
-  fi
-  if [ -n "$PQ_SENDERS" ]; then
-    printf "  ◐ %s pending %s from %s — /answer to engage\n" "$PENDING_Q_COUNT" "$PQ_NOUN" "$PQ_SENDERS"
-  else
-    printf "  ◐ %s pending %s — /answer to engage\n" "$PENDING_Q_COUNT" "$PQ_NOUN"
-  fi
-fi
-
-# Fallback: last activity if no handoffs and no pending questions
-if { [ "$ADDRESSED_COUNT" = "0" ] || [ -z "$ADDRESSED_COUNT" ]; } \
-   && { [ "$PENDING_Q_COUNT" = "0" ] || [ -z "$PENDING_Q_COUNT" ]; }; then
+# Fallback: last activity if no handoffs
+if [ "$ADDRESSED_COUNT" = "0" ] || [ -z "$ADDRESSED_COUNT" ]; then
   LAST_ACTIVITY=$(cat "$CTX_DIR/activity" 2>/dev/null || echo "")
   if [ -n "$LAST_ACTIVITY" ]; then
     LA_TIME=$(echo "$LAST_ACTIVITY" | cut -d'|' -f1)

package/runtime/codex/bin/publish-artifact.sh

@@ -72,7 +72,6 @@ fi
 if [ -f "$SCRIPT_DIR/.env" ]; then
   EGREGORE_API_URL="${EGREGORE_API_URL:-$(grep '^EGREGORE_API_URL=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
   EGREGORE_API_KEY="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
-  EGREGORE_USE_PUBLISHED="${EGREGORE_USE_PUBLISHED:-$(grep '^EGREGORE_USE_PUBLISHED=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
 fi
 
 API_URL="${EGREGORE_API_URL:-$(jq -r '.api_url // empty' "$CONFIG" 2>/dev/null)}"
@@ -80,16 +79,6 @@ API_KEY="${EGREGORE_API_KEY:-}"
 ORG_SLUG="$(jq -r '.slug // empty' "$CONFIG" 2>/dev/null)"
 VIEW_BASE="https://egregore.xyz/view"
 
-# Resolve "use published renderer" from env first, then egregore.json. The
-# env var lets individuals override per-shell; egregore.json lets an
-# instance (e.g. the upstream dev repo) opt in for every teammate.
-if [ -z "${EGREGORE_USE_PUBLISHED:-}" ]; then
-  CONFIG_USE_PUBLISHED="$(jq -r '.prefer_published_artifacts // empty' "$CONFIG" 2>/dev/null)"
-  if [ "$CONFIG_USE_PUBLISHED" = "true" ]; then
-    EGREGORE_USE_PUBLISHED=1
-  fi
-fi
-
 # Public relay for OSS share endpoint
 RELAY_URL="https://egregore-production-55f2.up.railway.app"
 
@@ -114,11 +103,8 @@ else
   # have been installed — that way local edits to packages/egregore-artifacts
   # are exercised without waiting for an npm release. Fall back to the
   # published `npx egregore-artifacts` otherwise.
-  # Set EGREGORE_USE_PUBLISHED=1 to force the npm-published renderer even
-  # when a local install is present — useful in the upstream dev repo to
-  # dogfood what teammates and OSS users actually run.
   LOCAL_CLI="$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js"
-  if [ "${EGREGORE_USE_PUBLISHED:-0}" != "1" ] && [ -f "$LOCAL_CLI" ] && [ -d "$SCRIPT_DIR/packages/egregore-artifacts/node_modules/react" ]; then
+  if [ -f "$LOCAL_CLI" ] && [ -d "$SCRIPT_DIR/packages/egregore-artifacts/node_modules/react" ]; then
     if ! node "$LOCAL_CLI" "${RENDER_ARGS[@]}" >/dev/null 2>&1; then
       exit 0
     fi

package/runtime/codex/bin/worktree-create.sh

@@ -58,12 +58,15 @@ git -C "$REPO_ROOT" worktree add "$WT_PATH" "$BRANCH" --quiet 2>/dev/null || {
 }
 
 # --- Symlinks (same as worktree.sh setup) ---
-# Memory
-if [ -L "$REPO_ROOT/memory" ] || [ -d "$REPO_ROOT/memory" ]; then
+# Memory — may be a symlink (follow to its target) or a real directory.
+MEMORY_TARGET=""
+if [ -L "$REPO_ROOT/memory" ]; then
   MEMORY_TARGET=$(realpath "$REPO_ROOT/memory" 2>/dev/null)
-  if [ -n "$MEMORY_TARGET" ] && [ -d "$MEMORY_TARGET" ]; then
-    ln -sfn "$MEMORY_TARGET" "$WT_PATH/memory"
-  fi
+elif [ -d "$REPO_ROOT/memory" ]; then
+  MEMORY_TARGET="$REPO_ROOT/memory"
+fi
+if [ -n "$MEMORY_TARGET" ] && [ -d "$MEMORY_TARGET" ]; then
+  ln -sfn "$MEMORY_TARGET" "$WT_PATH/memory"
 fi
 
 # .env

package/runtime/codex/bin/worktree.sh

@@ -41,11 +41,10 @@ case "$CMD" in
       SRC="$MAIN_DIR/$FILE"
       DST="$WT_PATH/$FILE"
       if [ "$FILE" = "memory" ]; then
-        # Follow the shared memory symlink or direct directory to get an
-        # absolute path. Most installs use a symlink; local/dev fixtures may
-        # use a directory.
-        [ -L "$SRC" ] || [ -d "$SRC" ] || continue
-        SRC=$(realpath "$SRC" 2>/dev/null) || continue
+        # memory may be a symlink (follow to its target) or a real directory.
+        if [ -L "$SRC" ]; then
+          SRC=$(realpath "$SRC" 2>/dev/null) || continue
+        fi
         [ -d "$SRC" ] || continue
       else
         [ -f "$SRC" ] || continue

package/runtime/codex/manifest.json

@@ -1,8 +1,7 @@
 {
-  "generatedAt": "2026-06-15T13:36:14.132Z",
   "source": "egregore-runtime",
-  "policy": "public-safe subset derived from .syncignore; internal .codex/skills exclusions omitted",
-  "skillCount": 55,
+  "policy": "public-safe subset derived from .syncignore; built by scripts/build-runtime-bundle.mjs",
+  "skillCount": 51,
   "skills": [
     "activity",
     "add",
@@ -12,21 +11,17 @@
     "ask",
     "branch",
     "checkup",
-    "comment",
     "commit",
     "contribute",
     "dark-mode",
     "dashboard",
     "deep-reflect",
     "delete-user",
-    "edit",
-    "edit-process",
     "egregore-voice",
     "emissary",
     "env",
     "handoff",
     "harvest",
-    "infra",
     "ingest",
     "ingest-google",
     "ingest-user-interview",
@@ -61,6 +56,7 @@
     "wrap"
   ],
   "files": [
+    ".agents/skills",
     ".codex/config.toml",
     ".codex/hooks.json",
     ".codex/hooks/branch-guard.js",
@@ -72,21 +68,17 @@
     ".codex/skills/ask/SKILL.md",
     ".codex/skills/branch/SKILL.md",
     ".codex/skills/checkup/SKILL.md",
-    ".codex/skills/comment/SKILL.md",
     ".codex/skills/commit/SKILL.md",
     ".codex/skills/contribute/SKILL.md",
     ".codex/skills/dark-mode/SKILL.md",
     ".codex/skills/dashboard/SKILL.md",
     ".codex/skills/deep-reflect/SKILL.md",
     ".codex/skills/delete-user/SKILL.md",
-    ".codex/skills/edit-process/SKILL.md",
-    ".codex/skills/edit/SKILL.md",
     ".codex/skills/egregore-voice/SKILL.md",
     ".codex/skills/emissary/SKILL.md",
     ".codex/skills/env/SKILL.md",
     ".codex/skills/handoff/SKILL.md",
     ".codex/skills/harvest/SKILL.md",
-    ".codex/skills/infra/SKILL.md",
     ".codex/skills/ingest-google/SKILL.md",
     ".codex/skills/ingest-user-interview/SKILL.md",
     ".codex/skills/ingest/SKILL.md",
@@ -141,7 +133,6 @@
     "bin/lib/config.sh",
     "bin/lib/context.sh",
     "bin/lib/dashboard-artifact.sh",
-    "bin/lib/edit-loopback.mjs",
     "bin/lib/ensure-develop.sh",
     "bin/lib/git-sync.sh",
     "bin/lib/greeting.sh",

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

@@ -1,25 +0,0 @@
----
-name: comment
-description: 'Fallback Codex adapter for the Egregore comment workflow.'
----
-
-<!-- generated-by: bin/codex-sync-skills.sh -->
-
-# Egregore comment 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/comment/SKILL.md` for the workflow details.
-2. Run the referenced `bin/` scripts directly from Codex.
-3. Treat graph, publish, and notify steps as best-effort unless that workflow
-   explicitly says they are required.
-4. Keep local-mode behavior filesystem-first and avoid graph or notification
-   calls when `egregore.json` declares `"mode": "local"`.
-5. Never call the deprecated `egregore-handoff` CLI for Egregore project
-   handoffs.

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

@@ -1,25 +0,0 @@
----
-name: edit
-description: 'Fallback Codex adapter for the Egregore edit workflow.'
----
-
-<!-- generated-by: bin/codex-sync-skills.sh -->
-
-# Egregore edit 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/edit/SKILL.md` for the workflow details.
-2. Run the referenced `bin/` scripts directly from Codex.
-3. Treat graph, publish, and notify steps as best-effort unless that workflow
-   explicitly says they are required.
-4. Keep local-mode behavior filesystem-first and avoid graph or notification
-   calls when `egregore.json` declares `"mode": "local"`.
-5. Never call the deprecated `egregore-handoff` CLI for Egregore project
-   handoffs.

package/runtime/codex/.codex/skills/edit-process/SKILL.md

@@ -1,25 +0,0 @@
----
-name: edit-process
-description: 'Fallback Codex adapter for the Egregore edit-process workflow.'
----
-
-<!-- generated-by: bin/codex-sync-skills.sh -->
-
-# Egregore edit-process 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/edit-process/SKILL.md` for the workflow details.
-2. Run the referenced `bin/` scripts directly from Codex.
-3. Treat graph, publish, and notify steps as best-effort unless that workflow
-   explicitly says they are required.
-4. Keep local-mode behavior filesystem-first and avoid graph or notification
-   calls when `egregore.json` declares `"mode": "local"`.
-5. Never call the deprecated `egregore-handoff` CLI for Egregore project
-   handoffs.

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

@@ -1,41 +0,0 @@
----
-name: infra
-description: 'Fallback Codex adapter for the Egregore infra workflow.'
----
-
-<!-- generated-by: bin/codex-sync-skills.sh -->
-
-# Egregore infra 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/infra/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/infra/SKILL.md` for the workflow details.
-2. Run the referenced `bin/` scripts directly from Codex.
-3. Treat graph, publish, and notify steps as best-effort unless that workflow
-   explicitly says they are required.
-4. Keep local-mode behavior filesystem-first and avoid graph or notification
-   calls when `egregore.json` declares `"mode": "local"`.
-5. Never call the deprecated `egregore-handoff` CLI for Egregore project
-   handoffs.