@openrig/cli 0.2.0 → 0.3.1

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

@@ -0,0 +1,122 @@
+---
+name: queue-handoff
+description: Use when ending a turn, finishing a slice, blocked on another agent's work, or escalating to a human — durable work handoff via queue items so the system keeps moving across compactions, missed messages, and interruptions. Covers the hot-potato terminal-turn-rule (active work ends by passing the ball, not by going idle), default-nudge semantics, and when --no-nudge or --notify is required.
+metadata:
+  openrig:
+    stage: factory-approved
+    last_verified: "2026-05-04"
+    distribution_scope: product-bound
+    source_evidence: |
+      Daemon-backed `rig queue` shipped in v0.2.0 (PL-004 Phase A) with handed-off-to / handed-off-from / state field shape. `rig queue` is canonical for new work; `rigx queue` is recovery-only fallback. The daemon enforces hot-potato strict-rejection at the API.
+    sibling_skills: []
+    transfer_test: pending
+---
+
+# Queue Handoff
+
+> **CANONICAL SURFACE NOTE (2026-05-11)** — `rig queue` (daemon-backed SQLite) is the
+> canonical surface for all substantive work routing. `rigx queue` (filesystem v0
+> prototype) is **recovery-only fallback**; qitems written via `rigx queue` are
+> invisible to daemon-backed reads and break fleet-wide routing discipline.
+
+Durable work handoff via queue items. Lets the system keep moving
+through compactions, missed messages, and interruptions by passing the
+ball forward instead of leaving work suspended in chat or in-flight
+without an owner.
+
+## Use this when
+
+- **Ending a turn on substantive work.** Active work should end by
+  passing the ball to an owner or to the human — never by going idle
+  with the rig appearing dormant.
+- **Finishing a slice that has a clear next step.** Default-nudge:
+  receiver gets a wake-ping plus the durable queue item.
+- **Blocked on another agent's work.** Park the qitem with
+  `closure_reason: blocked_on` and the blocker qitem id.
+- **Escalating to the human.** Make the escalation a durable attention
+  item, not just a chat message.
+
+## Don't use this when
+
+- The work is genuinely complete and there's no follow-on owner. Use
+  `closure_reason: no-follow-on` (terminal completion) or
+  `canceled`/`denied` as appropriate.
+- The handoff would be too small and turn work into bureaucracy. Bundle
+  the work into a coherent slice instead of decomposing every step.
+- The handoff would be too broad and lose ownership/proof/closure
+  criteria. Shape the qitem so the receiver knows the expected next
+  action and closure evidence.
+
+## The hot-potato terminal-turn-rule
+
+Active work ends by passing the ball to a named next owner or to the
+human. The qitem state machine enforces this:
+
+`pending → in-progress → done` requires `closure_reason` from one of:
+
+- `handed_off_to` — work continues at a different seat (target = new owner)
+- `blocked_on` — parked pending another qitem (target = blocker qitem id)
+- `denied` — receiver rejected the work
+- `canceled` — sender or receiver withdrew
+- `no-follow-on` — terminal completion, nothing else needed
+- `escalation` — kicked up to a higher tier (target = escalation target)
+
+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.
+
+## Default-nudge semantics (the syntax footgun)
+
+| Command | Nudges by default? | When to use |
+|---|---|---|
+| `rig queue create` | yes | New qitem created from scratch |
+| `rig queue handoff` | yes | Transactional close-as-handed-off + create-new |
+| `rig queue handoff-and-complete` | **no — requires `--notify`** | Inside a self-driving loop where motion matters |
+| `rigx queue handoff` (filesystem v0 prototype; **recovery-only fallback since 2026-05-11**) | yes | Legacy artifact; qitems invisible to daemon-backed reads. Use `rig queue handoff` for all new substantive work. |
+
+**Footgun**: `handoff-and-complete` is cold unless `--notify` is passed.
+In a self-driving loop, an agent that closes with
+`handoff-and-complete` (no `--notify`) writes a durable qitem but does
+NOT wake the next owner — the rig stalls silently while the qitem sits
+in inbox.
+
+**Rule**: in a live loop, use `handoff-and-complete --notify` OR send
+a separate verified manual nudge. `--no-nudge` exists but should be
+used intentionally (e.g., explicit park or human-gate signal), not as
+an accidental stall.
+
+## Failure modes (5; verbatim)
+
+1. Agent ends a turn without a handoff, so the rig appears idle.
+2. Agent creates a queue item but suppresses or forgets the nudge when immediate motion was intended. This includes `handoff-and-complete` without `--notify` inside a live loop.
+3. Queue item is too small and turns work into bureaucracy.
+4. Queue item is too broad and loses ownership, proof, or closure criteria.
+5. Human escalation happens in chat but not as a durable attention item.
+
+## Durable handoff field shape
+
+Every qitem carries:
+
+- `handed_off_to` — destination session (qualified `pod-member@rig` form)
+- `handed_off_from` — source session
+- `state` — one of: `pending | in-progress | done | blocked | failed | denied | canceled | handed-off`
+- `closure_reason` + `closure_target` — set on terminal closure per hot-potato rule
+
+The same field shape exists in legacy `rigx queue` artifacts and the daemon-shipped
+`rig queue` surface, but new queue reads and writes should use `rig queue`. Watchdog
+policies and workflow runtime project new owners off these fields.
+
+## Two surfaces (same shape)
+
+| Surface | Status | When to use |
+|---|---|---|
+| `rig queue ...` (daemon-shipped, v0.2.0) | Active host coordination surface | Daemon-backed PL-004 work; SQLite-canonical |
+| `rigx queue ...` (filesystem v0 prototype) | Recovery-only fallback | Legacy recovery for artifacts that have not migrated; not for new substantive work because daemon-backed reads cannot see those qitems |
+
+Default posture: prefer daemon `rig queue` for new work. If a
+daemon-backed coordination command fails, debug the command/runtime/schema
+edge directly — don't fall back to stale pre-upgrade assumptions.
+
+## See also
+
+- `rig queue --help` — full CLI surface for queue items, handoffs, and closure-reason discipline

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

@@ -0,0 +1,137 @@
+---
+name: seat-continuity-and-handover
+description: Use when replacing a seat's occupant (rebuild/handover/swap), reasoning about stable-seat-identity vs fluid-occupant-identity, choosing an old-occupant disposition (retire/advise/shadow), or recording provenance for an occupant change. Two independent outcomes (continuityOutcome + seatBindingOutcome) and the 5 failure modes that prevent silent dishonesty.
+metadata:
+  openrig:
+    stage: factory-approved
+    last_verified: "2026-05-04"
+    distribution_scope: product-bound
+    source_evidence: |
+      Option A rebuild MVP shipped 2026-04-30. Option B (full code-direct
+      seat handover via SeatHandoverService daemon module) is a future
+      follow-on.
+    sibling_skills:
+      - claude-compaction-restore
+      - agent-startup-and-context-ingestion
+    transfer_test: pending
+---
+
+# Seat Continuity and Handover
+
+A pair of primitive families that separate *who is sitting in a seat* from
+*what the seat itself is*:
+
+1. **Occupant-creation primitives** — `resume`, `fork`, `rebuild`, `fresh` — produce a candidate new occupant. Answer: "where did the new occupant come from?"
+2. **Seat-binding primitives** — `seat handover`, later `seat transfer` / `seat retire` / `seat swap` — bind a candidate occupant into the topology. Answer: "what happened to the stable seat identity?"
+
+Core architectural decision: **stable seat identity, fluid occupant
+identity, explicit provenance.** Today's `lead2`/`lead3`/`lead4`/`lead5`
+pattern encodes successor lineage into seat names — that's the wrong
+shape. Stable seat name + separately-recorded provenance trail is the
+right shape.
+
+## Use this when
+
+- Replacing a seat's occupant via rebuild, fork, fresh, or future seat-handover
+- Choosing old-occupant disposition: retire / advise / shadow
+- Reasoning about whether a seat's lineage is stable or has drifted
+- Reading or writing the provenance record for a seat
+- Designing or auditing topology stability across an occupant change
+
+## Don't use this when
+
+- The seat is freshly created (no occupant to replace) — use `rig launch` / `rig expand` directly
+- The intent is to change topology shape (add/remove seats), not replace an occupant — use topology-mutation primitives
+
+## The two-outcome honesty model
+
+Every seat-binding operation produces two **independent** outcomes:
+
+```yaml
+continuityOutcome: rebuilt | resumed | forked | fresh | failed
+seatBindingOutcome: handed_over | partial | failed | unchanged
+```
+
+These can disagree honestly. Examples:
+
+- `continuityOutcome: failed` + `seatBindingOutcome: unchanged` — new occupant didn't materialize; seat correctly retains old occupant.
+- `continuityOutcome: rebuilt` + `seatBindingOutcome: failed` — candidate created OK; bind failed mid-flight; provenance records the gap.
+
+**Don't collapse these into one outcome.** The system can describe what
+actually happened only if the two are recorded independently.
+
+## Provenance record (durable, queryable)
+
+Every handover writes:
+
+- seat id
+- old occupant id
+- new occupant id
+- creation mode (`resume`/`fork`/`rebuild`/`fresh`)
+- source artifacts used
+- whether old occupant remains alive as advisor/shadow
+- operator or loop that initiated the motion
+- timestamp
+- result (`handed_over` / `partial` / `failed`)
+
+This is the system's truth-source for "how did the current occupant get
+there." Without it, the control plane shows the current occupant but
+not the legitimacy of the transition.
+
+## State models — independent
+
+### Occupant-creation state (per candidate)
+
+1. **Requested** — input to rebuild/fork/fresh/resume
+2. **Realized** — runtime/artifact path produced an occupant with managed-seat shape
+3. **Failed** — candidate didn't materialize; `continuityOutcome: failed`
+
+### Seat-binding state (per seat)
+
+1. **Stable** — current occupant attached, no in-flight binding
+2. **Binding** — handover in progress
+3. **Bound** — handover succeeded; provenance record written
+4. **Unchanged** — bind failed before completion; seat retains old occupant
+
+A seat stays `Stable` even if multiple candidate-occupants were produced and discarded.
+
+## Failure modes (5)
+
+1. **Candidate creation failed** — `rebuild` couldn't synthesize from artifacts; `fork` couldn't resolve `session_source`; `fresh` couldn't launch. **Action**: bind operation does not begin; seat unchanged; provenance records the failed candidate-creation step.
+2. **Old occupant cannot be detached cleanly** — runtime hung, tmux locked, etc. **Action**: bind halts mid-flight; seat enters `Binding` state with explicit "halted" sub-status; operator alerted. **Do NOT auto-rollback by reattaching old-occupant if detach didn't complete cleanly.**
+3. **Bind succeeded but provenance write failed** — disk/db error. **Action**: not durable until provenance writes; treat as `Binding` halted, not `Bound`.
+4. **Old occupant disposition unfulfillable** — operator requested `advise` (keep alive as advisor) but runtime can't keep old alive. **Action**: degrade to `retire` with explicit notification, OR fail if operator passed strict-disposition flag.
+5. **Concurrent handover attempts** — two operations target the same seat. **Action**: serialize by seat-id lock; second attempt refuses with clear error.
+
+## Hard boundaries (do-not list; verbatim)
+
+- **Do NOT collapse `rebuild` and `seat handover` into one primitive.** The design specifically separates them so the system can describe what actually happened.
+- **Do NOT introduce successor-suffix seat names** (`lead2`/`lead3`). Stable seat identity is the architectural goal.
+- **Do NOT report `seatBindingOutcome: handed_over`** if the provenance record didn't write durably.
+- **Do NOT auto-rollback a half-completed handover** by re-attaching the old occupant unless detach completed cleanly first.
+
+## Composition: seat handover over fork
+
+Once `session_source` fork v1 lands (already shipped at openrig
+`c7b6df1`), the next composition is **seat handover over fork**:
+candidate occupant created via fork, bound into the existing seat via
+handover. Continuity outcome is `forked`; binding outcome is independent.
+
+## Currently shipped vs deferred
+
+- **Option A (rebuild) shipped** at openrig `578bd5c` (2026-04-30): `session_source.mode: rebuild` with `ref.kind: artifact_set`; identity-honesty bedrock at 4 layers (schema dispatch, orchestrator threading, SQLite read-back, negative-grep on resolver output). 26/26 Tier 1 cases green; full daemon regression 2146/2146 PASS.
+- **Option B partially shipped, partially deferred to Mode 3**: the `rig seat handover` CLI exists as a planning/observability surface — `status <seat>` reads the seat-handover observability tables (migration `021`); `handover <seat>` plans a safe two-phase handover sequence with actual execution flowing through existing seat-launch surfaces under operator gating. Full code-direct `SeatHandoverService` daemon module + `seat-binding-outcome` provenance record + nodes-table provenance migration remain deferred to Mode 3. MVP composition `seat handover over fork` is highest-leverage v1.
+
+## Why load-bearing for RSI
+
+Any recursive seat-refresh loop must be able to replace an occupant
+while keeping topology stable. Without these primitives, RSI loops will
+either accumulate suffixed seat names (lineage leaking into identity) or
+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.
+
+## See also
+
+- `claude-compaction-restore` skill — packet-driven restore after Claude compaction
+- `agent-startup-and-context-ingestion` skill — ingestion path for restore packets at agent boot

package/daemon/assets/vm-preview-fixtures/README.md

@@ -0,0 +1,48 @@
+# VM Preview Fixtures
+
+Sample data the Tart preview VM uses to populate the "populated" daemon with
+a representative "lived-in" environment. See
+`<substrate-shared-docs>/openrig-work/conventions/vm-preview/README.md` for the
+operator workflow and the rationale behind the two-daemon model.
+
+## Contents
+
+- `workflows/` — workflow_spec YAML files. The operator copies these into the
+  populated daemon's `<workspace.specs_root>/workflows/` directory; slice 11's
+  folder-discovery scanner auto-discovers them on the next
+  `GET /api/specs/library` call.
+
+- `queue-items/` — placeholder for future qitem fixture content (TODO; slice
+  follow-up will add).
+
+- `rigs/` — placeholder for future rig-instance fixtures (TODO; slice
+  follow-up will add). For v0, the operator manually instantiates a sample
+  rig via `rig up product-team` against the populated daemon (see bootstrap
+  script).
+
+## Conventions
+
+Fixture YAML files use the canonical placeholder paths per banked
+`feedback_test_fixture_example_path_placeholder.md`:
+
+- Username-bearing paths: `/Users/example/...` (never a real contributor
+  username)
+- Substrate-relative refs: `<substrate-shared-docs>/...`
+
+## v0 scope
+
+Slice 22 (release-0.3.1) ships the INFRASTRUCTURE for the two-daemon model:
+
+- **Process-env pattern**: `OPENRIG_HOME=<dir> rig daemon start ...` — each
+  `rig` invocation gets its own state directory at process import time.
+  No CLI flag (an earlier attempt at `--openrig-home` was dropped because
+  it only threaded into the spawned child, not the parent-side lifecycle
+  bookkeeping; see substrate convention doc for the architecture note).
+- Bootstrap script (`scripts/vm-bootstrap/two-daemon-start.sh`)
+- This fixtures directory + a sample workflow YAML
+- Convention doc in substrate
+
+Authoring rich populated content (~13-node openrig-velocity rig + 20 qitems
++ getting-started mission narrative) is deferred to follow-up content slices
+that have clearer ownership (slice 21 onboarding-conveyor will likely
+contribute getting-started mission content).

package/daemon/assets/vm-preview-fixtures/workflows/sample-basic-loop.yaml

@@ -0,0 +1,79 @@
+# VM-preview fixture for slice 22 founder-walk-vm-populated-env.
+# Derived from the 0.3.0 basic-loop starter; renamed to avoid colliding
+# with the built-in spec when this fixture file is dropped into a
+# populated daemon's workspace.specs_root/workflows/ directory.
+# Slice 11's folder-discovery scanner auto-discovers it on next list.
+workflow:
+  id: vm-preview-basic-loop
+  version: 1
+  objective: >
+    Walk one work packet through the conveyor rig slowly enough for a new user
+    to inspect each handoff.
+  target:
+    rig: conveyor
+  entry:
+    role: intake
+  coordination_terminal_turn_rule: hot_potato
+  roles:
+    intake:
+      skill_refs: [openrig-user, backlog-capture]
+      preferred_targets: [intake-lead@conveyor]
+    planner:
+      skill_refs: [openrig-user, writing-plans]
+      preferred_targets: [plan-planner@conveyor]
+    builder:
+      skill_refs: [openrig-user, executing-plans]
+      preferred_targets: [build-builder@conveyor]
+    reviewer:
+      skill_refs: [openrig-user, review-team]
+      preferred_targets: [review-reviewer@conveyor]
+    closer:
+      skill_refs: [openrig-user, verification-before-completion]
+      preferred_targets: [intake-lead@conveyor]
+  steps:
+    - id: intake
+      actor_role: intake
+      objective: Restate the objective and hand off one packet.
+      allowed_exits: [handoff, waiting, failed]
+      next_hop:
+        mode: require
+        suggested_roles: [planner]
+    - id: plan
+      actor_role: planner
+      objective: Produce a short plan for one build turn.
+      allowed_exits: [handoff, waiting, failed]
+      next_hop:
+        mode: require
+        suggested_roles: [builder]
+    - id: build
+      actor_role: builder
+      objective: Build or draft the planned output.
+      allowed_exits: [handoff, waiting, failed]
+      next_hop:
+        mode: require
+        suggested_roles: [reviewer]
+    - id: review
+      actor_role: reviewer
+      objective: Check the output and clear it for close.
+      allowed_exits: [handoff, waiting, failed]
+      next_hop:
+        mode: require
+        suggested_roles: [closer]
+    - id: close
+      actor_role: closer
+      objective: Close the walkthrough packet.
+      allowed_exits: [done, failed]
+      next_hop:
+        mode: forbid
+  invariants:
+    continuation_required: true
+    preserve_lineage: true
+    closure_required: true
+    allowed_exits: [handoff, waiting, done, failed]
+  loop_guards:
+    max_hops: 10
+    spawn_budget: 0
+  closure:
+    success: Walkthrough packet closed.
+    degraded: Walkthrough stopped with a named blocker.
+    failed: Walkthrough failed with evidence.

package/daemon/dist/adapters/claude-code-adapter.d.ts

@@ -25,7 +25,7 @@ export declare class ClaudeCodeAdapter implements RuntimeAdapter {
     private sleep;
     private stateDir;
     private collectorAssetPath;
-    private activityHookRelayAssetPath;
+    private autoDriveProviderPrompts;
     constructor(deps: {
         tmux: TmuxAdapter;
         fsOps: ClaudeAdapterFsOps;
@@ -33,7 +33,7 @@ export declare class ClaudeCodeAdapter implements RuntimeAdapter {
         sleep?: (ms: number) => Promise<void>;
         stateDir?: string;
         collectorAssetPath?: string;
-        activityHookRelayAssetPath?: string;
+        autoDriveProviderPrompts?: boolean;
     });
     listInstalled(binding: NodeBinding): Promise<InstalledResource[]>;
     project(plan: ProjectionPlan, binding: NodeBinding): Promise<ProjectionResult>;
@@ -56,6 +56,7 @@ export declare class ClaudeCodeAdapter implements RuntimeAdapter {
     }): void;
     private verifyResumeLaunch;
     private projectEntry;
+    private pluginAppliesToClaude;
     private resolveTargetDir;
     private applyRuntimeResource;
     private mergeJsonFragment;
@@ -72,6 +73,14 @@ export declare class ClaudeCodeAdapter implements RuntimeAdapter {
      * Finds the session file whose name matches the expected session name.
      * Returns the sessionId if found, undefined otherwise.
      */
+    /**
+     * PL-016 hardening v0+1 — poll captureResumeToken on the
+     * verifyResumeLaunch cadence. Returns the token as soon as the
+     * session file appears, or undefined after attempts × delayMs ceiling.
+     * Used by the fork branch where the new session-name file appears
+     * 1-3s after the Enter key is sent (cold-start fork-file write).
+     */
+    private pollForResumeToken;
     private captureResumeToken;
     private detectDeliveryHint;
     private provisionManagedBootstrap;
@@ -96,6 +105,5 @@ export declare class ClaudeCodeAdapter implements RuntimeAdapter {
      * Idempotent: safe to call multiple times (merge preserves existing settings).
      */
     private provisionContextCollector;
-    private provisionActivityHooks;
 }
 //# sourceMappingURL=claude-code-adapter.d.ts.map

package/daemon/dist/adapters/claude-code-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-code-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/claude-code-adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"claude-code-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/claude-code-adapter.ts"],"names":[],"mappings":"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"}

package/daemon/dist/adapters/claude-code-adapter.js

@@ -5,6 +5,12 @@ import { resolveConcreteHint } from "../domain/runtime-adapter.js";
 import { assessNativeResumeProbe } from "../domain/native-resume-probe.js";
 import { mergeManagedBlock } from "../domain/managed-blocks.js";
 const SHELL_COMMANDS = new Set(["bash", "fish", "nu", "sh", "tmux", "zsh"]);
+// Real Claude Code binary needs 1-3s to write the new fork session-name
+// file under ~/.claude/sessions/. Poll instead of single-shot lookup.
+// 12 × 500ms = 6s ceiling — comfortably above the observed cold-start
+// fork-file write window without making a bad-token error feel slow.
+const FORK_POLL_ATTEMPTS = 12;
+const FORK_POLL_DELAY_MS = 500;
 /**
  * Claude Code runtime adapter. Projects resources to .claude/ targets
  * and delivers startup files via guidance merge, skill install, or tmux send-text.
@@ -17,7 +23,7 @@ export class ClaudeCodeAdapter {
     sleep;
     stateDir;
     collectorAssetPath;
-    activityHookRelayAssetPath;
+    autoDriveProviderPrompts;
     constructor(deps) {
         this.tmux = deps.tmux;
         this.fs = deps.fsOps;
@@ -25,7 +31,7 @@ export class ClaudeCodeAdapter {
         this.sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
         this.stateDir = deps.stateDir ?? null;
         this.collectorAssetPath = deps.collectorAssetPath ?? null;
-        this.activityHookRelayAssetPath = deps.activityHookRelayAssetPath ?? null;
+        this.autoDriveProviderPrompts = deps.autoDriveProviderPrompts ?? false;
     }
     async listInstalled(binding) {
         const results = [];
@@ -76,14 +82,6 @@ export class ClaudeCodeAdapter {
             // Log but don't fail — collector provisioning is best-effort
             console.error(`[openrig] context collector provisioning warning: ${err.message}`);
         }
-        // Best-effort: provision project-local activity hooks. The hook token is
-        // supplied through tmux session env, never written to provider settings.
-        try {
-            this.provisionActivityHooks(binding);
-        }
-        catch (err) {
-            console.error(`[openrig] claude activity hook provisioning warning: ${err.message}`);
-        }
         let delivered = 0;
         const failed = [];
         for (const file of files) {
@@ -158,12 +156,16 @@ export class ClaudeCodeAdapter {
             if (!enterResult.ok) {
                 return { ok: false, error: `Failed to send Enter: ${enterResult.message}` };
             }
-            // Capture the NEW session id post-fork. Parent id is NOT persisted.
-            const newToken = this.captureResumeToken(opts.name);
+            // claude needs 1-3s to write the new fork session-name file under
+            // ~/.claude/sessions/. The original implementation captured the
+            // token IMMEDIATELY after Enter, which always returned undefined
+            // against a real binary. Poll on the
+            // verifyResumeLaunch cadence (12 × 500ms = 6s ceiling).
+            const newToken = await this.pollForResumeToken(opts.name, FORK_POLL_ATTEMPTS, FORK_POLL_DELAY_MS);
             if (!newToken) {
                 return {
                     ok: false,
-                    error: "claude-code fork: could not capture new post-fork session id from claude session storage",
+                    error: `claude-code fork: could not capture new post-fork session id from claude session storage after ${FORK_POLL_ATTEMPTS} polls (${(FORK_POLL_ATTEMPTS * FORK_POLL_DELAY_MS) / 1000}s ceiling)`,
                 };
             }
             return { ok: true, resumeToken: newToken, resumeType: "claude_id" };
@@ -240,6 +242,14 @@ export class ClaudeCodeAdapter {
             if (probe.status === "resumed") {
                 return { ok: true };
             }
+            if (this.autoDriveProviderPrompts && probe.code === "trust_gate") {
+                const enterResult = await this.tmux.sendKeys(tmuxSession, ["Enter"]);
+                if (!enterResult.ok) {
+                    return { ok: false, error: `Claude trust prompt auto-drive failed: ${enterResult.message}` };
+                }
+                await this.sleep(200);
+                continue;
+            }
             if (attempt < attempts - 1) {
                 await this.sleep(200);
             }
@@ -272,6 +282,13 @@ export class ClaudeCodeAdapter {
             const content = this.fs.readFile(entry.absolutePath);
             return this.mergeGuidance(targetPath, entry.effectiveId, content);
         }
+        // HG-1.3 plugin runtime applicability filter (per DESIGN.md §5.1):
+        // explicit pluginType="codex" → skip Claude projection;
+        // pluginType="auto" (or unset) + no .claude-plugin/ manifest dir → skip;
+        // explicit pluginType="claude" → project regardless of manifest presence.
+        if (entry.category === "plugin" && !this.pluginAppliesToClaude(entry)) {
+            return false;
+        }
         const targetDir = this.resolveTargetDir(entry, cwd);
         if (!targetDir)
             return true;
@@ -299,12 +316,21 @@ export class ClaudeCodeAdapter {
         }
         return true;
     }
+    pluginAppliesToClaude(entry) {
+        const explicit = entry.pluginType ?? "auto";
+        if (explicit === "claude")
+            return true;
+        if (explicit === "codex")
+            return false;
+        // auto: detect via .claude-plugin/plugin.json presence in the source tree
+        return this.fs.exists(nodePath.join(entry.absolutePath, ".claude-plugin", "plugin.json"));
+    }
     resolveTargetDir(entry, cwd) {
         switch (entry.category) {
             case "skill": return nodePath.join(cwd, ".claude", "skills", entry.effectiveId);
             case "guidance": return null; // handled via merge
             case "subagent": return nodePath.join(cwd, ".claude", "agents");
-            case "hook": return nodePath.join(cwd, ".claude", "hooks");
+            case "plugin": return nodePath.join(cwd, ".claude", "plugins", entry.effectiveId);
             case "runtime_resource": return nodePath.join(cwd, ".claude", "extensions", entry.effectiveId);
             default: return null;
         }
@@ -356,6 +382,24 @@ export class ClaudeCodeAdapter {
      * Finds the session file whose name matches the expected session name.
      * Returns the sessionId if found, undefined otherwise.
      */
+    /**
+     * PL-016 hardening v0+1 — poll captureResumeToken on the
+     * verifyResumeLaunch cadence. Returns the token as soon as the
+     * session file appears, or undefined after attempts × delayMs ceiling.
+     * Used by the fork branch where the new session-name file appears
+     * 1-3s after the Enter key is sent (cold-start fork-file write).
+     */
+    async pollForResumeToken(expectedName, attempts, delayMs) {
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            const token = this.captureResumeToken(expectedName);
+            if (token)
+                return token;
+            if (attempt < attempts - 1) {
+                await this.sleep(delayMs);
+            }
+        }
+        return undefined;
+    }
     captureResumeToken(expectedName) {
         try {
             const home = this.fs.homedir ?? (typeof process !== "undefined" ? process.env.HOME : undefined);
@@ -520,23 +564,6 @@ export class ClaudeCodeAdapter {
         };
         this.fs.writeFile(settingsPath, JSON.stringify(existing, null, 2));
     }
-    provisionActivityHooks(binding) {
-        if (!binding.cwd || !this.activityHookRelayAssetPath)
-            return;
-        const relayDest = nodePath.join(binding.cwd, ".openrig", "activity-hook-relay.cjs");
-        this.fs.mkdirp(nodePath.dirname(relayDest));
-        this.fs.writeFile(relayDest, this.fs.readFile(this.activityHookRelayAssetPath));
-        const settingsPath = nodePath.join(binding.cwd, ".claude", "settings.local.json");
-        this.fs.mkdirp(nodePath.dirname(settingsPath));
-        const settings = this.readJsonObject(settingsPath);
-        const hooks = this.readJsonObjectField(settings, "hooks");
-        const command = `node ${shellQuote(relayDest)}`;
-        for (const event of ["SessionStart", "UserPromptSubmit", "Stop", "Notification"]) {
-            upsertCommandHook(hooks, event, command);
-        }
-        settings["hooks"] = hooks;
-        this.fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
-    }
 }
 function hashContent(content) {
     return createHash("sha256").update(content).digest("hex");
@@ -581,33 +608,4 @@ function stableJsonKey(value) {
     }
     return JSON.stringify(sorted);
 }
-/** Shell-quote a string using single quotes (POSIX-safe). */
-function shellQuote(s) {
-    return "'" + s.replace(/'/g, "'\"'\"'") + "'";
-}
-function upsertCommandHook(hooks, event, command) {
-    const eventEntries = Array.isArray(hooks[event]) ? hooks[event] : [];
-    if (eventEntries.some((entry) => hookEntryContainsCommand(entry, command))) {
-        hooks[event] = eventEntries;
-        return;
-    }
-    eventEntries.push({
-        hooks: [
-            { type: "command", command, timeout: 5 },
-        ],
-    });
-    hooks[event] = eventEntries;
-}
-function hookEntryContainsCommand(entry, command) {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry))
-        return false;
-    const hooks = entry["hooks"];
-    if (!Array.isArray(hooks))
-        return false;
-    return hooks.some((hook) => typeof hook === "object" &&
-        hook !== null &&
-        !Array.isArray(hook) &&
-        hook["type"] === "command" &&
-        hook["command"] === command);
-}
 //# sourceMappingURL=claude-code-adapter.js.map