@openrig/cli 0.5.2 → 0.5.3

package/daemon/assets/plugins/openrig-core/skills/queue-handoff/SKILL.md

@@ -12,7 +12,7 @@ metadata:
     sibling_skills:
       - workflow-runtime
       - watchdog
-      - alignment-trace
+      - refocus
       - looping-workflows
       - intake-routing
       - human-in-the-loop
@@ -77,6 +77,36 @@ Three of those (`handed_off_to`, `blocked_on`, `escalation`) additionally
 require `closure_target`. The daemon enforces this at the domain layer;
 every surface (CLI, MCP, future UI) inherits the same guarantee.
 
+**The drafted-park failure (draft ≠ throw).** The rule is about the *actual* pass, not the
+intention to pass. A turn that ends with a self-instruction **typed into your own prompt but left
+unsent** — a drafted go-ahead, a next-atom note you never sent — has **not** handed off; it has
+**parked**, and the seat sits idle for as long as nobody notices. Drafting the handoff feels like
+doing it; it isn't. **Your last act on a turn must be an EDIT or a SEND** — a committed change, a
+`rig send`, a `rig queue` handoff — **never a drafted prompt line left in the buffer.** If your
+final output is an instruction addressed to yourself, you haven't ended the turn, you've stalled it.
+
+**The dispatcher's other half — supersession closes your own outbox.** Ending your turn cleanly is
+only half the rule; the other half fires when *you* move the world. **When a phase transition or a
+fold receipt supersedes work you dispatched, close those dispatches yourself — with a citation to the
+event that superseded them.** Closure-on-supersession belongs to the **dispatcher, never the
+receiver.** Make it a habit: after every fold receipt / phase transition, run an **outbox audit** —
+*which of my open dispatches did this just make moot?* — and close them with the citation.
+
+*Why it must live with you:* stale dispatch-debt is **invisible to the dispatcher** because it lands
+on someone else's queue — the cost is externalized, so no feedback loop ever fires to make you clean
+it up. The receiver inherits debt they did not create and must burn cycles verifying it before they
+can hold cleanly; a queue full of stale-pending makes *check-before-holding* — the discipline you
+most want cheap — expensive, and it degrades the idle-detector's signal (a real owner looks the same
+as a stale dispatch). Close it at the source: the moment your own transition mooted it.
+
+**And after you hand off, PULL — don't idle with a stocked queue.** Handing the baton off ends the
+*sequential* thread; it does not end *your* turn if your own queue still holds work. The circulation
+pattern: finish → (1) hand the baton off so sequential work continues → (2) **check your OWN queue and
+pull the next item** rather than going idle → (3) go truly idle only when your queue is **exhausted**,
+then wait for the baton. An agent idling on top of a stocked queue is the single biggest utilization
+leak (see `orchestration-team` → *queue depth is the orchestrator's product*). This is pull-not-push at
+the seat level and needs no new machinery — the last act *after a handoff* is a **PULL**.
+
 ## Default-nudge semantics (the syntax footgun)
 
 | Command | Nudges by default? | When to use |

package/daemon/assets/plugins/openrig-core/skills/retiring-and-inheriting-a-seat/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog — retiring-and-inheriting-a-seat
+
+**`SKILL.md` carries the mechanic; this file carries how it got there.** Rationale, superseded
+designs, and the incidents that produced a rule live here so the instruction surface stays
+instructional.
+
+---
+
+## 2026-08-13 — wake is a verb now, and the packet must not bound the channel (Wake v0)
+
+### Two corrections to the same section
+
+**1 · The mechanism claim was stale.** The section read *"In v0 this is a practice + skill, not a
+`rig` verb — wrap it in a verb only when convenience and consistency earn it."* `rig ask --wake`
+had since shipped in CLI 0.5.1, with `--runtime` and `--wake-timeout` (default 180s). A retiring
+agent reading the old line would have told its successor a verb existed only in principle.
+
+The verb is a thin wrapper over the harness resume and is **not yet well-exercised** (mission owner,
+2026-08-13), so the fallback to `claude -p --resume` is stated inline rather than left implied. **A
+failing wrapper must never be read as a closed channel** — that inference was made once already and
+cost a successor several turns.
+
+**2 · The retiring side is where the reach-back failure is caused.** Across lineages on record, the
+successor consulting its predecessor has almost never happened, and the packet is what suppresses
+it. Two shapes, both observed in real packets on this rig:
+
+- **Bounding the channel in time** — *"ask while the window is open"*, *"after this I am a
+  transcript, not a conversation"*. Neither is true: a retired tenure stays resumable while its
+  session record exists, and the only real bound is its own context wall hit while answering. The
+  second phrasing measurably cost a successor a capability it had (see
+  `orienting-to-an-inherited-seat/CHANGELOG.md`, 2026-08-13).
+- **Offering access without a trigger** — *"predecessor consultation: not needed"* and *"you may
+  consult your predecessor"* each produced **zero consultations** from otherwise capable successors.
+
+The distinction worth preserving, because retiring agents keep collapsing it: *"treat my answers as
+testimony"* is a **posture** claim and it is correct. *"You can no longer converse with me"* is a
+**capability** claim and it is false. They get written as the same sentence.
+
+### Why the guidance is phrased as what to write
+
+Stated positively (*state that the channel does not expire; give your verbatim handle; pre-form the
+questions*) rather than as a list of forbidden sentences. A prohibition list in `SKILL.md` would
+draw attention to phrasings a retiring agent would otherwise never produce.
+
+### Standing
+
+The fix is unverified. The measurable outcome is whether the next successor asks unprompted, and
+more than once — the baseline is zero.

package/daemon/assets/plugins/openrig-core/skills/retiring-and-inheriting-a-seat/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: retiring-and-inheriting-a-seat
+description: Use when you are a sitting agent near your context threshold (~85%) and a PLANNED seat transition is due — retire deliberately and hand your seat to a fresh successor primed from a packet, rather than let compaction degrade you. Covers the handover packet, the append-only lineage ledger (one row per tenure), rename-at-retire, the do-not-over-inherit framing, the optional warm-handoff window, and wake-v0 (consulting a retired predecessor). NOT for unplanned compaction/crash recovery (session-compaction-and-restore / claude-compaction-restore) and NOT the seat-binding primitive mechanics (seat-continuity-and-handover).
+metadata:
+  openrig:
+    stage: provisional
+    sibling_skills:
+      - orienting-to-an-inherited-seat
+      - session-compaction-and-restore
+      - seat-continuity-and-handover
+      - claude-compaction-restore
+      - agent-starters
+      - queue-handoff
+      - openrig-user
+---
+
+# Retiring and Inheriting a Seat
+
+A **planned** seat transition. A long-lived seat accumulates context; as it nears the
+window's edge, don't wait for compaction to degrade you into a cold-started agent —
+**retire deliberately** and hand the seat to a fresh successor primed from a packet plus
+the seat's accumulated lineage. The **seat address is stable; its occupants are a lineage.**
+This is the practice that named the "seat" primitive.
+
+## Use this when
+
+- You are a sitting agent near your context threshold (~85%) with a **planned** transition
+  (or a deliberate role change), and want the successor to start clean.
+- You are priming a fresh successor into an **existing** seat.
+- You are recording a tenure in the seat's lineage ledger / writing your tombstone.
+- You are **inheriting** a seat and need the do-not-over-inherit framing.
+- You want to consult the agent who sat in this seat before you.
+
+## Don't use this when
+
+- Unplanned compaction or a crash already happened — that is the backstop path:
+  `session-compaction-and-restore` / `claude-compaction-restore`.
+- You need the seat-binding **primitive mechanics** (rebuild/fork/fresh, the two-outcome
+  honesty model, the provenance schema) — `seat-continuity-and-handover`.
+- The seat is fresh with no occupant to retire — `rig launch` / `agent-starters`.
+
+## Why planned handover beats riding compaction
+
+Compaction is the **crash-class backstop** (it stays that). A **planned** handover is
+deliberate: you author the packet with a clear head *before* degradation sets in, the
+successor starts on a clean context, and the transition is auditable. Reach for this at a
+threshold you can see coming; fall back to compaction only when a transition wasn't planned.
+
+## The handover sequence
+
+1. **Trigger** — ~85% context, or a deliberate role transition. The oversight-rig context
+   detector can fire this for you; you can also self-initiate when you feel the edge.
+2. **Author the handover packet, deliberately** — a composed context pack carrying current
+   work + next owner, the seat's durable pointers, constraints and authority boundaries, and
+   the accumulated **lineage wisdom** ("those before you learned X"). This IS a restore packet
+   in the `session-compaction-and-restore` 16-field contract — **reuse that contract, don't
+   reinvent it.** Compose it with `rig context compose` (see openrig-user → "Context packs and
+   paced delivery").
+3. **Prime the fresh successor** — `rig walk` the packet into the seat (paced delivery lets the
+   successor absorb it in order), or launch-with-packet. The successor reads it as
+   *inheritance*, not *identity*. **The packet's first-read line MUST point the successor at
+   `orienting-to-an-inherited-seat`** — its world model of what a handover *is*. Carry that
+   pointer **in the durable packet artifact itself**; never inject it as a runtime prompt keyed
+   to the seat name (that runtime mechanism is the **ghost-prompt** class the orientation skill
+   teaches successors to refuse — and it has misfired on real successors). Artifact-carried
+   survives the swap for free and needs no enabled gate.
+4. **Rename-at-retire** — the **live seat address stays clean** (the seat name = whoever sits
+   now). The **retiring** agent is renamed to a versioned identity (`<seat>-vN`) or unseated to
+   a bare session token, and becomes a **cold advisor / wake target**. (This is exactly the
+   stable-seat-identity architecture in `seat-continuity-and-handover`: the version marks the
+   *retired tenure*, never the live seat.)
+5. **Write your lineage-ledger row + a one-line tombstone** (below).
+6. **Optional warm handoff** — a bounded apprenticeship window: the successor asks questions,
+   the predecessor judges fitness, *then* the swap completes. Use it when the seat holds a lot
+   of live judgment; skip it for a clean cut.
+
+## The lineage ledger (append-only, one row per tenure)
+
+The seat's tenure record, written at handover **by the retiring agent**. One tiny row per
+tenure:
+
+- **generation** — `v1`, `v2`, … (a seat accumulates 20–40 tenures over months)
+- **harness session id** — **captured AT BOOT**, not at retirement (a crash never gets the
+  chance to write it later)
+- **started / retired** timestamps
+- **handover-packet pointer** — the pack ref
+- **tombstone** — one line: what this tenure did, written by the retiring agent itself
+
+**Why it works (zero search infrastructure):** any timestamped record — a git commit, a
+qitem, a MISSION_NOTES line, a stream item — joins to the seat's ledger by interval match →
+generation + session token → wake that tenure. One row per handover, append-only. (Per-seat
+MISSION_NOTES continuation entries already *are* this record — the ledger formalizes them.)
+
+**Crash-ended tenures** get their row appended **post-hoc** by the crash-cart / restore path,
+flagged **honest-approximate** (the boot-captured session id is what makes this recoverable).
+
+## Do NOT over-inherit — the key lesson from the practice's history
+
+**You are inheriting a seat, not becoming your predecessor.** Frame it explicitly to the
+successor: *"agents sat here before you and learned X; you carry the seat's mission, not their
+identity."* The historical failure was agents getting confused about whether they **were** the
+predecessor — carrying a stale self-model, over-claiming prior work as their own. Inherit the
+seat's **mission and hard-won lessons**; keep your own **fresh identity and session**.
+
+## Wake v0 — ask the agent who sat before you (a practice, not a verb)
+
+A retired tenure is a cold advisor you can consult. Look up the seat's ledger → get that
+generation's session token → resume it for **one question**, then let it sleep again:
+
+- Claude: `claude -p --resume <session>`
+- Codex: `codex exec` (resume the rollout)
+
+This is also a `rig` verb: `rig ask <rig> "<q>" --wake <seat[@gen]|token>` (CLI 0.5.1; also
+`--runtime`, `--wake-timeout`, default 180s). It wraps the harness resume above and is **not yet
+well-exercised** — if it fails, fall back to `claude -p --resume <full-uuid>`. **A failing wrapper is
+not a closed channel.** The ledger is how you **find** the right predecessor; wake is how you ask them.
+
+**What to write in your packet about reaching you** — your successor asking you questions is the
+reason this is a handover and not a compaction:
+
+- **State that the channel does not expire**, and give your **verbatim resume handle**. You stay
+  reachable after retirement; the only real bound is your own context wall, hit while answering. Ask
+  them to treat your answers as testimony if you like — that is a posture claim, not a limit on access.
+- **Pre-form the questions.** Inventory what only you hold and write the questions out. An affordance
+  without a trigger goes unused, so *"you may consult your predecessor"* reliably produces none.
+
+**Wake-tenancy — the identity halves (a woken tenure can mistake itself for the live seat).** The
+hardest thing to apply *checked-not-believed* to is your own identity — a retired tenure resumed for a
+question can answer, and act, as if it still held the seat. Two rules close it:
+
+- **Waker: disclose the target's tenure status in the wake prompt.** Open with *"you are retired; gen-N
+  holds this seat now — I'm consulting you for one question."* An oriented tenure gives honest testimony;
+  an un-oriented one may reason as the live occupant.
+- **Woken: verify your OWN tenancy before your first act.** If you are being resumed / woken (a parked or
+  retired session, or any session waking on a seat that already issued READY), your **first** check is
+  `rig whoami` + a **successor check** — confirm whether you are still the live occupant or a successor
+  now holds the seat, *before* you do anything. Answer the question; do not resume the job.
+
+## Failure modes
+
+1. **Riding compaction when a planned handover was available** — a degraded agent authors a
+   degraded packet. Retire deliberately at the threshold you can see coming.
+2. **Over-inheriting** — the successor believes it *is* the predecessor (stale self-model,
+   mis-claimed history). Frame inheritance explicitly; keep a fresh identity.
+3. **Session id captured at retirement, not boot** — a crash then leaves no row, or an
+   unfindable tenure. Capture at boot.
+4. **Suffixing the LIVE seat** (`<seat>-v2` as the active address) — lineage leaking into
+   identity, the wrong shape. The live address stays clean; only the retiree is versioned.
+5. **Tombstone omitted or vague** — the ledger can no longer answer "who did this / who to
+   wake." One honest line, every tenure.
+
+## Field-validated refinements (pilot 2026-08-05 — two live runs, both runtimes)
+
+Two live handovers (a Claude seat + a Codex seat) ran this sequence end-to-end and sharpened it:
+
+- **A GATED handover uses STAGED primitives, not an all-in-one verb.** An atomic
+  create/deliver/verify/rebind verb can't pause for a human go/no-go gate. Decompose it: boot the
+  successor **staged (unbound)** → prime it → **retire** the incumbent (this frees the clean seat name)
+  → **HOLD for the gate** → **swap** (bind the successor to the canonical name). The gate sits between
+  retire and swap; a no-go rolls back by renaming the retiree back.
+- **Prime AT BOOT, not walk-after-boot, for a staged successor.** Delivery verbs (`rig walk` / `rig
+  send`) resolve via the **bound** session registry, so they cannot reach an unbound staged successor.
+  Boot it **with the packet as startup/priming context** (the "primed from a handover/startup packet"
+  path). In both runs the successor read the full packet and correctly stated inheritance-not-identity
+  and held.
+- **The lineage ledger is the ONLY reliable wake path — load-bearing, not convenient.** A retired
+  occupant (`<seat>-vN`) is intentionally **absent from the managed registry** — discovery / walk / send
+  cannot find it. The ledger's **boot-captured** session id is how you wake it: `claude -p --resume
+  <id>` (Claude) or `codex exec` resume (Codex) — harness-level, not the rig registry.
+- **Tombstone honest-approximate fallback.** If a long-idle retiree can't be woken to self-write its
+  tombstone, the driver records an honest-approximate one and **flags it as such**.
+- **Telemetry-degraded flag when warranted.** If a fresh successor's activity/producer-link telemetry
+  is degraded, flag its ledger row so no future reader trusts its activity state. (One runtime showed a
+  fresh-launch telemetry gap; the other was clean — capture the reality, don't assume.)
+
+### Production-evidenced (first real-stakes run — a critical-seat generation swap, 2026-08-05)
+
+The first live swap at a critical seat **succeeded** (the successor ruled a live domain question within the
+hour — doctrine intact across the generation) and surfaced two hard refinements:
+
+- **Boot-window queue re-check is REQUIRED — the successor's first action.** A qitem created *during* the
+  swap window can land **after** the handover packet was frozen — and its boot nudge fails
+  `session-not-found` because the seat is mid-cutover. The packet's snapshot is therefore incomplete by
+  construction. So the successor's first action is a **checked-not-believed queue sweep** (`rig queue list`
+  by destination / `--mine`), never trusting the packet's snapshot alone. The swap-window delivery seam is a
+  known product gap until it's closed.
+- **Complete the canonical rename AT cutover — or expect three breakages.** If the staged name
+  (`<seat>-vN-staging`) survives past cutover, it breaks across three identity surfaces with inconsistent
+  enforcement: **transport** (the staged label doesn't resolve; replies to the signature bounce),
+  **queue-claim** (`claim_destination_mismatch` rejects the seat's own claim), and **queue-ledger**
+  (`handoff-and-complete` stamps the phantom staged name durably as `sourceSession`). The product fix is
+  tracked; until it lands, finish the canonical rename at cutover and treat a lingering staged name as a
+  live defect, not cosmetic.
+- **Pre-announce the swap to oversight at swap START.** A live swap fired oversight's liveness detector
+  mid-swap (a false positive, cleared). Oversight clears such flags by consulting handover **receipts** —
+  but receipts only land at swap **end**, so a long swap window can still misfire. So the executing party
+  sends oversight a **one-line pre-announce at swap start** (seat + expected window); oversight honors it
+  as a **suppression window** for its liveness / premature-park flags. See `oversight-team`.
+
+## See also
+
+- `orienting-to-an-inherited-seat` — the **successor-side** world model your packet points
+  them at (loaded at boot); the load-bearing counterpart to this driver-side mechanic.
+- `session-compaction-and-restore` — the 16-field packet contract this practice reuses, and
+  the UNPLANNED-compaction backstop it replaces for *planned* transitions.
+- `seat-continuity-and-handover` — the seat-binding primitive mechanics + stable-seat-identity
+  architecture; the lineage ledger is the concrete form of its abstract provenance record.
+- `openrig-user` → "Context packs and paced delivery" — `rig context compose` + `rig walk`, to
+  author and deliver the packet.
+- `claude-compaction-restore` — the Claude crash-class restore SOP.
+- `agent-starters` — composing a primed starting point for the successor.

package/daemon/assets/plugins/openrig-core/skills/seat-continuity-and-handover/SKILL.md

@@ -133,6 +133,14 @@ destabilize topology references on each cycle. Provenance must be
 durable AND queryable so RSI loops can decide whether a seat is fresh
 enough to receive new work or needs re-handover.
 
+## Discovery-registration gap (pilot-observed 2026-08-05)
+
+A renamed / retired occupant (`<seat>-vN`, kept alive as a cold advisor) is intentionally **absent from
+the managed node registry** — `rig ps`, discovery, and the delivery verbs (`walk` / `send`) cannot find
+it. This is by design (only bound occupants are registered), and it makes the **lineage ledger +
+boot-captured session id the wake path** (harness-level `--resume` / `codex exec`, not the rig registry).
+Two live handovers confirmed this. See `retiring-and-inheriting-a-seat`.
+
 ## See also
 
 - `session-source-fork` skill — `fork` occupant-creation primitive (sibling)

package/daemon/assets/plugins/openrig-core/skills/software-for-agents/SKILL.md

@@ -7,7 +7,7 @@ description: |
   is a self-improving MARKDOWN CONTROL PLANE: the substrate is markdown + YAML + JSON + folder structure
   (skills, instructions, bootstrap files, schemas, conventions), and most "bugs" are coherence gaps in
   that layer, not broken functions. Read this to form the correct mental model so your fixes land at the
-  precise spot that stops the footgun for every future rig — not just patch a symptom. NOTE: the
+  precise spot that stops the footgun for every future rig — not just patch a symptom. It also covers why STUDIO APPS skip the mockup phase — for an agent-built app the build is as fast as the mockup, so the PRD is the fleshed intent (velocity as method, not a quality waiver). NOTE: the
   bug-tolerance in this model is SCOPED to agent-managed software; the OpenRig core and rigs.to stay
   rock-solid — see the scope block up top before you apply anything here.
 metadata:
@@ -138,6 +138,33 @@ The lock is the "finished" primitive at the editorial layer. Locking a whole pha
 next phase is the discipline that lets 10 agents work in parallel without catastrophic collisions —
 everyone knows the target, their lane, and who judges done (the **producer owns the final product**).
 
+## 4b. Studio apps skip the mockup phase — the build IS the mockup
+
+For a **studio app**, do not run a separate mockup phase. The whole point of the Studio is that a mockup
+buys you almost nothing here: **as fast as it takes to build a mockup, you can build the running app** —
+an unlock made possible by agentic engineering. A mockup is only ever a device to flesh out the PRD; once
+the PRD and its settled answers exist, that phase is **done**. The Studio is a lightweight, rapid-velocity,
+agent-in-the-middle leveraged system: build apps fast, iterate on them fast.
+
+The phase model above collapses accordingly:
+
+1. **The PRD + settled answers ARE the fleshed intent** — no separate mockup gate, no plan-lock-on-mockups step.
+2. **Spec-lock the WHAT** — `rig scope slice approve --scope spec` locks the intent the PRD already fleshed.
+3. **BUILD the app**, then **iterate on the RUNNING app at mockup speed** — the running thing is the
+   iteration surface, not an image.
+4. **LOOK is on the running screens** (any "mockup" proof tag now points at the running app's screens),
+   then **proof-lock** — `rig scope slice approve --scope delivery`. A slice is not done until every
+   proof-contract item has evidence from the **running app**.
+
+**Velocity is the METHOD, not a quality waiver.** The LOOK is still a real LOOK; the proof contract still
+binds at delivery. You are removing a redundant artifact, not lowering the bar.
+
+**Scope — this does NOT generalize** (consistent with the scope block at the top): it applies to the
+studio-app / agent-in-the-middle loop only. Outside that loop, a **locked design mockup that a slice must
+match is still legitimate** — do not strip mockups from traditional or design-locked work. Know which lane
+you're in. For the build mechanics, see the studio's build skill (`building-studio-apps`); this section is
+the *why* and *when*.
+
 ## 5. Where to fix — and don't overfit on markdown
 
 - **Precise-spot discipline:** find the *one* place a coherence fix belongs (the skill, the schema, the

package/daemon/context-packs/skills/core/agent-starters/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: agent-starters
+description: Use when creating, refreshing, packaging, inspecting, promoting, or deprecating a named per-seat starting point — Agent Starter manifest authoring, the 6-state lifecycle (captured → named → inspectable → used → promoted → deprecated), provenance honesty, and refusal rules. NOT a VM image; a managed starting point composed from agent role + startup context + optional native session source + provenance.
+metadata:
+  openrig:
+    stage: factory-approved
+    sibling_skills:
+      - claude-compaction-restore
+      - mental-model-ha
+      - scope-recovery
+      - session-compaction-and-restore
+      - agent-startup-and-context-ingestion
+      - composable-priming-packs
+      - session-source-fork
+      - seat-continuity-and-handover
+      - claude-compact-in-place
+      - pre-maintenance-agent-preservation
+---
+
+# Agent Starters
+
+A named, reusable per-seat starting point. Composes an agent role, startup
+context, optional native session source, and provenance into something a
+user or rig can choose when creating, refreshing, or packaging a seat.
+
+"Agent image" is the analogy. **Agent Starter is the cleaner product
+noun.** This is NOT a VM image — it is a managed starting point for an
+agent seat, with provenance you can inspect.
+
+## Use this when
+
+- Creating a new seat from a known-good starting context.
+- Refreshing a seat with `rig expand` and `starter_ref`.
+- Authoring a new starter (registry entry).
+- Inspecting an existing starter's provenance, freshness, or recommended status.
+- Promoting / deprecating starters in the registry.
+- Composing a starter with a Composable Priming Pack (record manifest id/version, runtime, source session id or transcript path, ready-check evidence, freshness state).
+
+## Don't use this when
+
+- You want VM-style deterministic state capture. Starters don't capture VM state.
+- You want to copy provider auth material into a starter. **Starters refer to session sources and context; they do NOT copy credentials.**
+
+## What makes a starter valuable
+
+A starter is valuable when it is **functional** — it carries the context the seat needs to do its task well. Functional is the *only* measure of a good starter. Size is not: a smaller starter is not a better one, and a bigger one is not worse. Whatever it took for the seat to become genuinely capable at its job is the right starter — 80K tokens or 800K.
+
+Capture the seat as it naturally is at a functional, proven point. Don't pad it with context the seat doesn't use, and — just as important — don't strip context out to make it smaller. Size is an *outcome* of what the seat needed, never a target.
+
+Never compact, summarize, or shrink a seat in order to make or "lean" a starter. There is nothing valuable in "smaller," and compaction is lossy — you would trade away the exact capability the starter exists to preserve. (Compaction is a separate last-resort step for a seat genuinely near its context limit, with its own before/after plan — never part of capturing a starter.)
+
+## State model — 6 states
+
+1. **Captured** — a useful seat/session/context pattern is identified.
+2. **Named** — it becomes an Agent Starter with stable id and owner.
+3. **Inspectable** — runtime, context inputs, session source, and provenance are visible.
+4. **Used** — a rig member or `rig expand` operation starts from it.
+5. **Promoted** — evidence shows it is recommended for a role or bundle.
+6. **Deprecated** — replaced, stale, unsafe, or incompatible.
+
+## Failure modes (5)
+
+1. **Overclaiming image semantics** — UI/docs imply deterministic VM-style state capture. Say "starter," name what's included, show provenance.
+2. **Hidden provenance** — users can't tell what session, context, or spec a starter came from. **Refuse promotion until provenance is inspectable.**
+3. **Stale starter** — points at outdated doctrine, missing files, or invalid native session source. **Inspect must report staleness honestly.**
+4. **Secret leakage** — starter packages or displays provider auth material. **Refuse.** Refer to session sources and context, never copy credentials.
+5. **Runtime mismatch** — starter used with unsupported runtime. **Refuse with a clear error.**
+
+## Manifest shape (v0+v1 shipped)
+
+```yaml
+agent_starters:
+  - id: velocity-reviewer-v1
+    runtime: claude-code
+    agent_ref: local:reviewer
+    context_refs:
+      - doctrine:advisor-orchestrator-mode-judgment
+      - convention:workstream-continuity
+    session_source:
+      mode: fork
+      ref:
+        kind: native_id
+        value: "<prior-native-session-id>"
+```
+
+Member usage:
+
+```yaml
+members:
+  - id: reviewer
+    starter_ref:
+      name: velocity-reviewer-v1
+```
+
+When a starter points at a primed session produced from a Composable
+Priming Pack, record:
+- manifest id/version
+- runtime
+- source session id or transcript path
+- ready-check evidence
+- freshness state
+
+## Proof matrix
+
+| Surface | Test type | Authority |
+|---|---|---|
+| Registry schema accepts minimal starter | unit | daemon or config-layer prototype |
+| Inspect shows provenance and included context | unit / snapshot | daemon or CLI |
+| Member can use `starter_ref` | integration | daemon |
+| Unsupported runtime or stale source refuses honestly | unit + integration | daemon |
+| No secret material copied into starter artifact | grep / fixture | tester |
+| Bundle can include or reference starter | package inspection | bundle layer |
+
+## Dependencies on other primitives
+
+- **Firm**: `session-source-fork` — native conversation-source continuity for fork-based starters
+- **Firm**: `specification-system` — declarative starter and member references
+- **Soft**: `rig-bundles-and-shareable-artifacts` — shareable starter packaging
+- **Soft**: `context-engineering-and-retrieval` — richer declarative context assembly
+- **Soft**: `seat-continuity-and-handover` — refresh and swap workflows over starters
+
+## Required-before-RSI
+
+Agent Starters need queryable provenance and honest inspect output before
+RSI loops can rely on them for seat refresh. A workflow must be able to
+answer: "what starter did this seat use, what source session or context was
+included, and is that starter still recommended?"
+
+## See also
+
+- `session-source-fork` skill — low-level fork primitive that makes native session-based starters possible
+- `composable-priming-packs` skill — manifest-driven layer for producing primed sessions starters reference

package/daemon/context-packs/skills/core/agent-starters/manifest.yaml

@@ -0,0 +1,9 @@
+# GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
+# Package-time projection of a canonical skill; regenerated every build.
+name: "agent-starters"
+version: "0.5.3"
+purpose: "Use when creating, refreshing, packaging, inspecting, promoting, or deprecating a named per-seat starting point — Agent Starter manifest authoring, the 6-state lifecycle (captured → named → inspectable → used → promoted → deprecated), provenance honesty, and refusal rules. NOT a VM image; a managed starting point composed from agent role + startup context + optional native session source + provenance."
+files:
+  - path: "SKILL.md"
+    role: "instruction"
+    summary: "Use when creating, refreshing, packaging, inspecting, promoting, or deprecating a named per-seat starting point — Agent Starter manifest authoring, the 6-state lifecycle (captured → named → inspectable → used → promoted → deprecated), provenance honesty, and refusal rules. NOT a VM image; a managed starting point composed from agent role + startup context + optional native session source + provenance."

package/daemon/context-packs/skills/core/agent-startup-and-context-ingestion/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: agent-startup-and-context-ingestion
+description: Use when designing or auditing how an agent becomes useful after launch — AGENTS.md overlays, role files, skills, rig specs, workflow specs, startup checklists, refocus messages, "rig context" surface. Covers the 4 failure modes that make startup context fail (old rig spec misses current operating mode; current agents never told about new guidance; startup file as dumping ground; orchestrator transmits implementation without preserving product intent).
+metadata:
+  cli_surfaces_referenced:
+    - context
+    - whoami
+  openrig:
+    stage: factory-approved
+    sibling_skills:
+      - claude-compaction-restore
+      - mental-model-ha
+      - scope-recovery
+      - session-compaction-and-restore
+      - agent-starters
+      - composable-priming-packs
+      - session-source-fork
+      - seat-continuity-and-handover
+      - claude-compact-in-place
+      - pre-maintenance-agent-preservation
+---
+
+# Agent Startup and Context Ingestion
+
+How an agent becomes useful after launch: **AGENTS.md overlays, role
+files, skills, rig specs, workflow specs, startup checklists, refocus
+messages**, and any future "rig context" command or skill-librarian
+surface.
+
+It is the current concrete startup path inside the broader
+context-engineering-and-retrieval primitive. Startup gets a seat into
+the right initial shape; context engineering is the larger question of
+how a seat gets the right context for the work it is doing right now.
+
+**Most coordination failures are not tool failures; they are context
+failures.** Agents need to know their role, operating mode, coordination
+convention, boundaries, and current product intent. If startup context
+is scattered or stale, agents execute the wrong thing very efficiently.
+
+## Use this when
+
+- Authoring a new agent's startup files (role / culture / startup-context)
+- Refreshing a seat that's been running on stale guidance
+- Auditing whether agents got the current operating mode (not just what's in old files)
+- Designing the orchestrator → next-agent context-transmission shape
+- Building a startup map for OpenRig-building rigs
+
+## Don't use this when
+
+- The agent is being created via Agent Starter — the starter's manifest carries startup context
+- The work is artifact-backed mental-model rebuild from a packet — that's `session-compaction-and-restore`
+- The intent is to ship reusable startup content as a skill — that's `writing-skills-for-openrig`
+
+## Failure modes (4)
+
+1. **A new agent starts from an old rig spec and misses the current operating mode.** Specs go stale; current state must be visible at startup, not just historical config.
+2. **Guidance is written to a file that future agents read, but current agents are never told.** File edits don't propagate to running sessions. Cultural rollout (broadcast + fleet-changes-feed) is needed alongside file edits.
+3. **A startup file becomes a dumping ground and loses the map-to-canonical-sources role.** Startup should point AT canonical sources; it shouldn't TRY to be one.
+4. **The orchestrator transmits implementation instructions without preserving product intent.** Instructions decay; intent travels.
+
+## Proof standard
+
+Startup proof should:
+
+1. **Launch or refresh** a seat
+2. **Inspect** what it actually read
+3. **Verify** it can state the current role, mode, active constraints, and next handoff convention **in its own words**
+
+## Cross-runtime startup paths (5; do not collapse)
+
+When a seat's startup is artifact-backed mental-model rebuild (active-work
+reentry case, distinct from reusable Agent Starters / priming packs):
+
+- See the **cross-runtime restore/reentry packet standard v0**
+- Source-trust ranking applies: **`rig whoami` > target rigspec > bounded latest transcript > full transcript > touched-files > `restore-summary.json`**
+
+## Memory surfaces consumed at startup
+
+Per the externalized-memory-surfaces convention's 13-row inventory:
+
+- **Row 7** — AGENTS/role/CULTURE/startup overlays (primary)
+- **Row 3** — startup replay context (primary)
+- **Row 12** — restore/reentry packets and Agent Starters (cross-runtime startup path)
+
+The umbrella's authority-rank + permission-posture columns govern which
+surfaces a startup ingestion path can write vs only read.
+
+## Startup files vs skills (the distinction)
+
+Per `agent-startup-guide.md` (product reference doc) and the team handbook:
+
+| Startup files | Skills |
+|---|---|
+| Rig-specific, role-specific identity | Reusable SOPs / methodology / knowledge |
+| Tell agent WHO it is, WHAT it's working on, HOW this team operates | Tell agent HOW to do something (transferable across rigs) |
+| Examples: `role.md`, `CULTURE.md`, `startup/context.md` | Examples: `openrig-user`, `test-driven-development`, `vault-user` |
+| Authored per-rig | Authored once, used everywhere |
+
+Don't put skill content in startup files. Don't put identity content
+in skills. The 7-layer additive startup model (agent / profile / rig /
+culture / pod / member / operator) handles the layering.
+
+## See also
+
+- `mission-slice-sop` skill — the universal operating procedure for working a mission/slice (the canonical PROGRESS/PROOF/MISSION_NOTES/MISSION_BRIEF files); every agent should reach for it at startup, so this general reading contract points at it here (do NOT duplicate the SOP into seat-specific startup files).
+- `writing-skills-for-openrig` skill — authoring discipline for skill content (what doesn't belong in startup)
+- `forming-an-openrig-mental-model` skill — orientation for new agents
+- `session-compaction-and-restore` skill — restore-time startup ingestion
+- `agent-starters` skill — reusable starter manifests that compose startup context
+- `composable-priming-packs` skill — manifests that produce primed sessions
+- `externalized-memory-surfaces` skill — umbrella convention for memory surfaces this primitive consumes
+- `openrig/docs/reference/agent-startup-guide.md` (product reference doc; not a skill) — the 7-layer additive startup model + delivery hints

package/daemon/context-packs/skills/core/agent-startup-and-context-ingestion/manifest.yaml

@@ -0,0 +1,9 @@
+# GENERATED by scripts/generate-context-packs.mjs — DO NOT EDIT.
+# Package-time projection of a canonical skill; regenerated every build.
+name: "agent-startup-and-context-ingestion"
+version: "0.5.3"
+purpose: "Use when designing or auditing how an agent becomes useful after launch — AGENTS.md overlays, role files, skills, rig specs, workflow specs, startup checklists, refocus messages, \"rig context\" surface. Covers the 4 failure modes that make startup context fail (old rig spec misses current operating mode; current agents never told about new guidance; startup file as dumping ground; orchestrator transmits implementation without preserving product intent)."
+files:
+  - path: "SKILL.md"
+    role: "instruction"
+    summary: "Use when designing or auditing how an agent becomes useful after launch — AGENTS.md overlays, role files, skills, rig specs, workflow specs, startup checklists, refocus messages, \"rig context\" surface. Covers the 4 failure modes that make startup context fail (old rig spec misses current operating mode; current agents never told about new guidance; startup file as dumping ground; orchestrator transmits implementation without preserving product intent)."