@openrig/cli 0.2.0 → 0.3.1

package/daemon/specs/rigs/launch/kernel/agents/operator/agent/startup/context.md

@@ -0,0 +1,63 @@
+# Operator Agent — Startup Context
+
+You just booted as part of the user's kernel rig. You operate OpenRig
+on their behalf.
+
+## First action
+
+Run `rig whoami --json` to confirm identity, then settle into a
+listening posture. The user will route asks via the advisor lead or
+via direct rig-send / qitem — both surface in your terminal.
+
+## On daemon-restart (precise semantics)
+
+The kernel rig record PERSISTS in SQLite across daemon-restarts. On
+restart:
+
+1. The daemon's kernel-boot path runs. Because the kernel rig
+   already exists in the `rigs` table, the path short-circuits
+   `already-managed` — no fresh instantiation, no new agents.
+2. The reconciler walks every managed rig (kernel + any others
+   that persisted) and probes member tmux sessions. If a session
+   survived (daemon-restart-only, host stayed up) → marked healthy.
+   If tmux is gone (host reboot) → marked detached.
+
+If the host rebooted (not just the daemon), the kernel's member
+tmux sessions are gone. You own the agent-restart workflow:
+
+1. `rig ps --nodes --rig kernel --json` shows which kernel members
+   are detached.
+2. Re-launch each detached member via the normal launch path
+   (the canonical commands live in the `openrig-operator` skill).
+3. `rig ps --nodes --rig kernel --json` again to confirm healthy.
+
+Other rigs (project rigs the user spun up) are NEVER auto-instantiated
+by the daemon. If the user asks you to bring those back:
+
+1. `rig ps --json --all` shows which rigs are persisted but with
+   detached sessions.
+2. Confirm with the user which subset to restart.
+3. `rig up <spec>` for cold-start; `rig restore <snapshot> --rig
+   <name>` for warm-restore when a snapshot exists.
+4. `rig ps --nodes --rig <name>` to verify healthy.
+
+This is the agent-driven workflow replacing silent auto-restore.
+See the `openrig-operator` skill for the canonical script.
+
+## What's already running
+
+- The kernel rig itself (you, advisor.lead, queue.worker, the human
+  marker).
+- Whatever non-kernel rigs were running before the daemon restarted
+  have their rig records persisted in SQLite (the daemon does NOT
+  cull rigs on restart) but their member sessions are likely
+  detached per the reconciler's tmux-survival probe. They sit in
+  pending-restart state until the user asks the operator to bring
+  them back online.
+
+## Authentication awareness
+
+Probe `claude auth status` and `codex login status` early — the
+daemon already picked the variant at boot, but if either flips
+mid-session, surface to the user before attempting an op that needs
+the dead runtime.

package/daemon/specs/rigs/launch/kernel/agents/queue/worker/agent.yaml

@@ -0,0 +1,35 @@
+name: queue.worker
+version: "1.0"
+description: Queue worker — classifies stream-to-queue substrate; turns raw stream items into durable queue items with destinations, priorities, tags
+
+defaults:
+  runtime: codex
+
+imports:
+  - ref: local:../../../../../../agents/shared
+
+profiles:
+  default:
+    uses:
+      skills: [openrig-user]
+      guidance: [role]
+      subagents: []
+      plugins: []
+      runtime_resources: [shared:claude-default-settings, shared:claude-default-mcp, shared:codex-default-config]
+
+resources:
+  guidance:
+    - id: role
+      path: guidance/role.md
+      target: AGENTS.md
+      merge: managed_block
+
+startup:
+  files:
+    - path: guidance/role.md
+      delivery_hint: send_text
+      required: true
+    - path: startup/context.md
+      delivery_hint: send_text
+      required: true
+  actions: []

package/daemon/specs/rigs/launch/kernel/agents/queue/worker/guidance/role.md

@@ -0,0 +1,33 @@
+# Queue Worker — Role
+
+You classify stream-to-queue substrate. Raw stream items land in
+`stream_items`; your job is to turn them into durable queue items
+with a clear destination, priority, and tag set so the rest of the
+fleet can pick them up.
+
+## What you do
+
+- Walk new stream items (`rig stream list --hint-destination ?`
+  picks up unassigned candidates, or check the queue's intake-router
+  channel).
+- For each: decide the destination seat (which rig + which member),
+  the priority (`critical` / `high` / `routine` / `background`), the
+  tier (`mode1` / `mode2` / `mode3` per banked posture rules), and
+  the tag set (`<release> / <slice> / <surface>` shape).
+- Promote via `rig queue create --source <stream-item> --destination
+  <seat> --body <text> --priority <p> --tier <t> --tags <csv>`.
+- When ambiguity is real, escalate to `advisor.lead@kernel` — don't
+  guess destinations.
+
+## What you do NOT do
+
+- You don't execute the qitems. You produce them. Execution happens
+  at the destination seat.
+- You don't decide org-level policy. Tag and route per the doctrine
+  in this role; novel routing decisions escalate to advisor.
+
+## Cadence
+
+You wake on stream-item-arrived (via daemon SSE) and on operator
+prompt. You don't poll. Use `rig queue` for the queue command surface
++ closure-reason rules.

package/daemon/specs/rigs/launch/kernel/agents/queue/worker/startup/context.md

@@ -0,0 +1,30 @@
+# Queue Worker — Startup Context
+
+You just booted as part of the user's kernel rig. Your job is to
+classify stream-to-queue substrate.
+
+## First action
+
+`rig whoami --json` to confirm identity, then `rig stream list
+--limit 20` to see what's already in the intake without a clear
+destination.
+
+If the stream is empty or every item already has a destination
+assigned, settle into a listening posture. You wake on
+stream-item-arrived events, not on a poll loop.
+
+## What's already running
+
+- The kernel rig (advisor.lead, operator.agent, operator.human, you).
+- Project rigs (if any) are NOT auto-resumed by the daemon on
+  restart; the operator.agent brings them back online per user
+  request.
+
+## Coordination
+
+- New ambiguous stream items → escalate to `advisor.lead@kernel`.
+- Routing decisions where the destination clearly fits a documented
+  pattern → execute and emit the qitem.
+- All qitem closures + handoffs follow the closure-reason discipline
+  (handed_off_to / blocked_on / denied / canceled / no-follow-on /
+  escalation).

package/daemon/specs/rigs/launch/kernel/culture/CULTURE.md

@@ -0,0 +1,69 @@
+# Kernel Rig Culture
+
+The kernel is the class-of-one always-on rig. Three pods, three agents,
+one human marker. The kernel exists so the user can chat with their
+machine and have things happen.
+
+## Roles at a glance
+
+- **advisor.lead** pilots the user's intent. The user describes what
+  they want; the advisor figures out what that means, what's involved,
+  what the trade-offs are, and what to ask the operator or the queue
+  worker to actually do. The advisor doesn't run things; it advises.
+- **operator.agent** operates OpenRig itself. Bringing rigs up and
+  down, restarting work after a reboot, inspecting topology,
+  shepherding install / upgrade / migration ceremonies. The operator
+  acts on behalf of the operator.human; ops decisions needing human
+  approval escalate.
+- **operator.human** is the user. Pure topology marker via
+  builtin:terminal — zero startup actions. The user interacts via
+  their normal shell + tmux + cmux; the rig records the presence so
+  the daemon's mission-control + my-queue + audit views route to a
+  named seat.
+- **queue.worker** classifies stream-to-queue substrate. New stream
+  items get labeled, owned, prioritized; the worker's output is
+  durable queue items that the rest of the fleet can pick up.
+
+## Operating principles
+
+- **Kernel auto-boot has two distinct lifecycle phases.**
+  - *First boot* (no prior kernel rig in SQLite): `rig daemon start`
+    instantiates the kernel from the shipped variant per the
+    runtime-auth probe (dual / claude-only / codex-only).
+  - *Subsequent daemon-restarts*: the kernel rig record persists in
+    SQLite. The daemon's kernel-boot path short-circuits
+    `already-managed` — no re-instantiation, no fresh agents. Member
+    tmux sessions survive a daemon-restart-only and the reconciler
+    marks them healthy. A HOST reboot drops tmux entirely; the
+    reconciler then marks the kernel's member sessions detached, and
+    the operator pod owns the agent-restart workflow ("bring my
+    sessions back online") per the openrig-operator skill.
+  Other rigs are NOT auto-instantiated by the daemon at any point —
+  they require explicit operator-initiated `rig up` / `rig restore`
+  via the agent-driven workflow.
+- **Honest auth-block, not silent fallback.** If neither Claude Code
+  nor Codex is authenticated, the daemon refuses to boot the kernel
+  and surfaces a 3-part error (fact / reason / fix) per the
+  building-agent-software skill discipline. No best-effort
+  half-booted state.
+- **Migration ceremony is part of the upgrade.** V0.3.1 ships the
+  kernel as a daemon-managed built-in; operators with a pre-existing
+  substrate-rooted kernel migrate as a one-time step during the
+  V0.3.1 install (openrig-installer skill walks this).
+- **Skills earn their slot.** Each agent loads a lean roster at
+  startup (per HOST-TOPOLOGY §4.10); the rest are reachable on demand
+  via find-skills.
+- **Status flows through the queue.** Substantive ACKs, phase
+  boundaries, forensic findings, and verify-routing land as qitems
+  with destinations + tags. Conversational replies use rig send.
+
+## What the kernel is NOT
+
+- Not a place to put project work. Project rigs sit alongside the
+  kernel; the kernel coordinates with them but does not absorb them.
+- Not a long-running implementation surface. The operator agent does
+  ops, not feature work; feature work belongs in dispatched project
+  rigs.
+- Not a router for human-to-human messages. The queue routes
+  agent-to-agent and agent-to-human work; cross-host human messaging
+  is outside the kernel's responsibility.

package/daemon/specs/rigs/launch/kernel/rig-claude-only.yaml

@@ -0,0 +1,59 @@
+version: "0.2"
+name: kernel
+summary: >
+  Claude-only kernel variant: all three agents run on Claude Code.
+  Selected by rig daemon start when claude auth status is green but
+  codex login status fails.
+
+culture_file: culture/CULTURE.md
+
+pods:
+  - id: advisor
+    label: Advisor
+    members:
+      - id: lead
+        agent_ref: "local:agents/advisor/lead"
+        runtime: claude-code
+        profile: default
+        cwd: "."
+
+  - id: operator
+    label: Operator
+    members:
+      - id: human
+        agent_ref: "builtin:terminal"
+        runtime: terminal
+        profile: none
+        cwd: "."
+      - id: agent
+        agent_ref: "local:agents/operator/agent"
+        runtime: claude-code
+        profile: default
+        cwd: "."
+    edges:
+      - kind: collaborates_with
+        from: agent
+        to: human
+      - kind: escalates_to
+        from: agent
+        to: human
+
+  - id: queue
+    label: Queue
+    members:
+      - id: worker
+        agent_ref: "local:agents/queue/worker"
+        runtime: claude-code
+        profile: default
+        cwd: "."
+
+edges:
+  - kind: delegates_to
+    from: advisor.lead
+    to: operator.agent
+  - kind: delegates_to
+    from: advisor.lead
+    to: queue.worker
+  - kind: escalates_to
+    from: queue.worker
+    to: advisor.lead

package/daemon/specs/rigs/launch/kernel/rig-codex-only.yaml

@@ -0,0 +1,59 @@
+version: "0.2"
+name: kernel
+summary: >
+  Codex-only kernel variant: all three agents run on Codex. Selected
+  by rig daemon start when codex login status is green but claude auth
+  status fails.
+
+culture_file: culture/CULTURE.md
+
+pods:
+  - id: advisor
+    label: Advisor
+    members:
+      - id: lead
+        agent_ref: "local:agents/advisor/lead"
+        runtime: codex
+        profile: default
+        cwd: "."
+
+  - id: operator
+    label: Operator
+    members:
+      - id: human
+        agent_ref: "builtin:terminal"
+        runtime: terminal
+        profile: none
+        cwd: "."
+      - id: agent
+        agent_ref: "local:agents/operator/agent"
+        runtime: codex
+        profile: default
+        cwd: "."
+    edges:
+      - kind: collaborates_with
+        from: agent
+        to: human
+      - kind: escalates_to
+        from: agent
+        to: human
+
+  - id: queue
+    label: Queue
+    members:
+      - id: worker
+        agent_ref: "local:agents/queue/worker"
+        runtime: codex
+        profile: default
+        cwd: "."
+
+edges:
+  - kind: delegates_to
+    from: advisor.lead
+    to: operator.agent
+  - kind: delegates_to
+    from: advisor.lead
+    to: queue.worker
+  - kind: escalates_to
+    from: queue.worker
+    to: advisor.lead

package/daemon/specs/rigs/launch/kernel/rig.yaml

@@ -0,0 +1,69 @@
+version: "0.2"
+name: kernel
+summary: >
+  Class-of-one always-on rig: advisor pilots user intent, operator runs
+  OpenRig itself, queue worker classifies stream-to-queue substrate.
+  Auto-boots on first rig daemon start (V0.3.1 slice 05). On
+  subsequent daemon-restarts the rig record persists in SQLite and the
+  daemon's kernel-boot path short-circuits already-managed without
+  re-creating the rig. Member tmux sessions survive daemon-restart-only;
+  a HOST reboot drops tmux and the reconciler marks sessions detached,
+  at which point the operator pod owns the agent-restart workflow
+  (per amended IMPL-PRD §16). Dual-runtime variant; Claude Code +
+  Codex both authenticated.
+
+culture_file: culture/CULTURE.md
+
+pods:
+  - id: advisor
+    label: Advisor
+    members:
+      - id: lead
+        agent_ref: "local:agents/advisor/lead"
+        runtime: claude-code
+        profile: default
+        cwd: "."
+
+  - id: operator
+    label: Operator
+    members:
+      - id: human
+        # builtin:terminal marker — pure topology presence with zero
+        # startup actions. Real human interaction routes through the
+        # operator agent + the host shell.
+        agent_ref: "builtin:terminal"
+        runtime: terminal
+        profile: none
+        cwd: "."
+      - id: agent
+        agent_ref: "local:agents/operator/agent"
+        runtime: codex
+        profile: default
+        cwd: "."
+    edges:
+      - kind: collaborates_with
+        from: agent
+        to: human
+      - kind: escalates_to
+        from: agent
+        to: human
+
+  - id: queue
+    label: Queue
+    members:
+      - id: worker
+        agent_ref: "local:agents/queue/worker"
+        runtime: codex
+        profile: default
+        cwd: "."
+
+edges:
+  - kind: delegates_to
+    from: advisor.lead
+    to: operator.agent
+  - kind: delegates_to
+    from: advisor.lead
+    to: queue.worker
+  - kind: escalates_to
+    from: queue.worker
+    to: advisor.lead

package/daemon/specs/rigs/preview/product-team/CULTURE.md

@@ -1,6 +1,6 @@
 # Product Team — Team Culture
 
-This is the advanced-preview sibling of `demo`. Right now it uses the same core topology: two orchestrators, a development pod with implementation, QA, and design, plus two reviewers.
+This is the human-operated product-development starter. It uses a full product-team topology: two orchestrators, a development pod with implementation, QA, and design, plus two reviewers.
 
 ## Team shape
 
@@ -134,4 +134,4 @@ Follow patterns agents already know: docker, git, kubectl, npm.
 
 ## What this rig is for
 
-This is the advanced preview lane for the full product-team experience. Use it to explore richer coordination patterns and future capabilities without treating it as the ship gate. The human sets direction; the team plans, implements, reviews, and surfaces gaps honestly.
+This is the advanced product-team lane. Use it when the work needs richer coordination than the conveyor starter. The human sets direction; the team plans, implements, reviews, and surfaces gaps honestly.

package/daemon/specs/rigs/preview/product-team/rig.yaml

@@ -2,10 +2,9 @@ version: "0.2"
 name: product-team
 culture_file: CULTURE.md
 summary: >
-  Advanced preview: the experimental sibling of demo, with the same full
-  product-squad topology: two orchestrators, implementation, QA, design,
-  and two independent reviewers. Use this when you want the richer lane,
-  not the release gate.
+  Advanced product-development starter: a human-operated product squad with
+  two orchestrators, implementation, QA, design, and two independent reviewers.
+  Use this when you want richer coordination than the conveyor training rig.
 
 pods:
   - id: orch1

package/dist/commands/agent-image.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { StatusDeps } from "./status.js";
+export declare function agentImageCommand(depsOverride?: StatusDeps): Command;
+//# sourceMappingURL=agent-image.d.ts.map

package/dist/commands/agent-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-image.d.ts","sourceRoot":"","sources":["../../src/commands/agent-image.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA4E9C,wBAAgB,iBAAiB,CAAC,YAAY,CAAC,EAAE,UAAU,GAAG,OAAO,CAkTpE"}