@openrig/cli 0.6.14 → 0.7.1

package/daemon/dist/domain/startup-orchestrator.js

@@ -8,12 +8,16 @@ import { AppliedLaunchObservationStore } from "./applied-launch-observation-stor
 import { NativePermissionStore } from "./native-permission-store.js";
 import { RigRepository } from "./rig-repository.js";
 import { SessionTransport, inspectStartupStagedText } from "./session-transport.js";
-import { startupOwnCollapsedPaste, startupSubmissionEvidence } from "./startup-submission-evidence.js";
+import { claudeInputBoxDrawn, startupNoInputLine, startupOwnCollapsedPaste, startupSubmissionEvidence } from "./startup-submission-evidence.js";
 import { resolveReadinessTimeoutMs } from "./readiness-timeout.js";
 import { SettingsStore } from "./user-settings/settings-store.js";
 import { shellQuote } from "../adapters/shell-quote.js";
 import { observeClaudeResumeLaunch } from "./native-process-lineage.js";
 import { CommunityHarnessRuntimeAdapter } from "../adapters/community-harness-runtime-adapter.js";
+import { join } from "node:path";
+import { guidanceFileIsLink, readFootprintAnswer, readGuidanceFile, routerLineSkipReason } from "./footprint-choice.js";
+import { SEAT_SKILLS_BOOTSTRAP_BLOCK_ID, describeSkillRouterFootprint, seatSkillsLineEdited, refusedSeatSkillsRootForNode, seatCatalogKeptNote, seatRouterKeptNote, seatSkillPathsForNode, seatSkillPluginDirForNode, writeSeatSkillCatalog, writeSeatSkillRouter } from "./seat-skill-storage.js";
+import { recordConversationPromptForNode, recordForkConversationPromptForNode, seatLaunchAdditionsForLaunch, systemPromptPendingNoteForNode } from "./seat-launch-additions.js";
 // Expanded startup text can put the current input marker above 50 scrollback lines.
 const STARTUP_SUBMIT_CAPTURE_LINES = 200;
 // Claude Code 2.1.289 has taken Enter on a large startup paste after the first look, while the composer
@@ -23,6 +27,21 @@ const STARTUP_SUBMIT_SETTLE_LOOKS = 25;
 // A prompt still staged after a guarded retry is retried again, up to this many retries in all, each after
 // the 200 ms look. Every retry is guarded: Enter goes in only while the composer holds exactly the text we typed.
 const STARTUP_SUBMIT_RETRIES = 2;
+// Why a startup prompt's submission could not be confirmed, as told to the operator when the
+// proof line is held back.
+const UNCONFIRMED_STAGED = "the prompt still looked staged in the input box";
+const UNCONFIRMED_UNOBSERVABLE = "the input box could not be observed";
+const UNCONFIRMED_UNCLEAR = "the input box did not clearly show the prompt as submitted";
+const UNCONFIRMED_RETRY_REFUSED = "the guarded Enter retry did not go through";
+/**
+ * The proof line is held back on purpose when the startup prompt isn't confirmed submitted. Say that
+ * only this one line was skipped, so it doesn't read as the agent or the rig failing to start.
+ */
+export function startupProofHeldBackWarning(reason) {
+    return "Startup proof instruction held back: only the extra line asking the agent to run its startup check "
+        + "was not sent, so nothing is typed over input that may still be in the box. The startup prompt itself was "
+        + `sent, but its submission could not be confirmed: ${reason ?? "it was not observed submitted"}.`;
+}
 /** Pending context belongs to this occupant and is consumed before delivery starts. */
 export function readPendingStartupContext(db, nodeId, sessionId) {
     const row = db.prepare("SELECT seq, payload FROM events WHERE node_id = ? AND type IN ('node.startup_pending', 'node.startup_ready', 'node.startup_failed') ORDER BY seq DESC LIMIT 1").get(nodeId);
@@ -111,6 +130,12 @@ export function isRecoverableStartupFailure(db, nodeId, sessionId) {
         return false;
     return true;
 }
+// -- Types --
+/** The seat-skills bootstrap line among a seat's startup files: the built-in guidance merged into its managed block
+ *  (never the Codex catalog, which shares the logical name but is sent as text). */
+export function isSeatSkillsBootstrapLine(file) {
+    return file.path === SEAT_SKILLS_BOOTSTRAP_BLOCK_ID && file.deliveryHint === "guidance_merge";
+}
 /**
  * Drives one node from projected resources to startup_status: ready.
  *
@@ -206,7 +231,38 @@ export class StartupOrchestrator {
         const claudeManagedBlockFile = rigRepo.getRigClaudeManagedBlockFile(input.rigId);
         if (claudeManagedBlockFile)
             input = { ...input, binding: { ...input.binding, claudeManagedBlockFile } };
+        // OPR.0.7.0.13: a Claude seat whose plugin OpenRig keeps (already on its CLAUDE_CODE_PLUGIN_DIRS) gets every skill
+        // there, profile resources and startup skill files too. A seat without one keeps the project, as before, so a
+        // skill never lands where nothing points.
+        if (input.adapter.runtime === "claude-code" && !input.binding.seatSkillsRoot) {
+            const seatPlugin = seatSkillPluginDirForNode(this.db, input.nodeId);
+            if (seatPlugin)
+                input = { ...input, binding: { ...input.binding, seatSkillsRoot: join(seatPlugin, "skills") } };
+        }
+        // OPR.0.7.0.13 (Codex C2): a Codex seat with its own storage gets its skills there, and its catalog, rebuilt after
+        // this launch's projection, is what its per-seat startup text delivers.
+        const codexSeatSkills = input.adapter.runtime === "codex" ? seatSkillPathsForNode(this.db, input.nodeId) : undefined;
+        if (codexSeatSkills && !input.binding.seatSkillsRoot)
+            input = { ...input, binding: { ...input.binding, seatSkillsRoot: codexSeatSkills.skillsRoot } };
+        // A seat whose storage a link refused keeps its skills' target there, where each is refused and named; they never
+        // fall back into the project.
+        if (!input.binding.seatSkillsRoot && (input.adapter.runtime === "claude-code" || input.adapter.runtime === "codex")) {
+            const refused = refusedSeatSkillsRootForNode(this.db, input.nodeId);
+            if (refused)
+                input = { ...input, binding: { ...input.binding, seatSkillsRoot: refused.skillsRoot, seatSkillsRefused: refused.reason } };
+        }
+        // OPR.0.7.0.9: a Claude seat's own launch additions, the copies present in its seat storage; a missing copy is named.
+        if (input.adapter.runtime === "claude-code" && !input.binding.launchAdditions) {
+            const { additions, missing, refused } = seatLaunchAdditionsForLaunch(this.db, input.nodeId);
+            if (additions)
+                input = { ...input, binding: { ...input.binding, launchAdditions: additions } };
+            for (const file of missing)
+                warnings.push(`${input.sessionName ?? input.nodeId}: seat_launch_addition_missing: ${file} is not in this seat's storage; launched without it`);
+            for (const reason of refused)
+                warnings.push(`${input.sessionName ?? input.nodeId}: seat_launch_addition_refused: ${reason}; launched without it`);
+        }
         const deliveryInput = { ...input, warnings, submissionWarnings: [], startupAttemptId: randomUUID(), sendOrder: 0, submissionDiagnostics: [] };
+        const startupAssisted = input.adapter instanceof CommunityHarnessRuntimeAdapter && input.adapter.startupAssisted();
         const errors = [];
         let continuityOutcome = input.resumeToken
             ? "resumed"
@@ -216,6 +272,7 @@ export class StartupOrchestrator {
                     ? "rebuilt"
                     : "fresh";
         let appliedLaunch;
+        let resumedProcess;
         const forkContext = input.adapter.runtime === "codex"
             && input.forkSource?.kind === "native_id" && input.forkSource.value?.trim()
             ? { parentToken: input.forkSource.value.trim(), isRestore: input.isRestore } : undefined;
@@ -238,7 +295,11 @@ export class StartupOrchestrator {
         let projectionResult;
         if (!(input.preserveStartupContext && input.adapter.runtime === "claude-code" && input.plan.entries.length === 0))
             try {
-                projectionResult = await input.adapter.project(input.plan, input.binding);
+                const skip = input.replaySkip;
+                const projectedPlan = skip && skip.entryIds.size > 0
+                    ? { ...input.plan, entries: input.plan.entries.filter((e) => !(e.category === "skill" && skip.entryIds.has(e.effectiveId))) }
+                    : input.plan;
+                projectionResult = await input.adapter.project(projectedPlan, input.binding);
                 warnings.push(...(projectionResult.warnings ?? []));
                 if (projectionResult.failed.length > 0) {
                     for (const f of projectionResult.failed) {
@@ -262,12 +323,18 @@ export class StartupOrchestrator {
         const sourceFiles = input.rebuildArtifacts && input.rebuildArtifacts.length > 0
             ? [...input.rebuildArtifacts, ...input.resolvedStartupFiles]
             : input.resolvedStartupFiles;
-        const applicableFiles = sourceFiles.filter((f) => f.appliesOn.includes(context));
+        // OPR.0.7.0.13 (router, R1.1): the one-line bootstrap is delivered on its own (below), only with a yes, and never
+        // stops the launch. Every start reads the answer, so a saved context from before the line was opt-in (or from while
+        // it was on) delivers it only while the yes stands. Nothing already written is removed.
+        const bootstrapLine = sourceFiles.filter((f) => f.appliesOn.includes(context) && !input.replaySkip?.files.has(f.absolutePath)
+            && isSeatSkillsBootstrapLine(f));
+        const applicableFiles = sourceFiles.filter((f) => f.appliesOn.includes(context) && !input.replaySkip?.files.has(f.absolutePath)
+            && !isSeatSkillsBootstrapLine(f));
         const preLaunchFiles = [];
         let postLaunchFiles = [];
         for (const f of applicableFiles) {
             const hint = f.deliveryHint === "auto"
-                ? resolveConcreteHint(f.path, this.safeReadFile(f.absolutePath))
+                ? resolveConcreteHint(f.path, this.safeReadFile(f.absolutePath), f.orientation)
                 : f.deliveryHint;
             if (hint === "send_text") {
                 postLaunchFiles.push(f);
@@ -292,6 +359,74 @@ export class StartupOrchestrator {
             errors.push(`Pre-launch delivery error: ${err.message}`);
             return this.fail(input, "failed", errors, undefined, false, undefined, false, "pre_launch_files", true);
         }
+        // OPR.0.7.0.13 (router, R1.1): the bootstrap line, on its own: with a yes it is delivered into the seat's guidance file;
+        // otherwise it is skipped with the answer's reason. A line that can't be written is this start's named result (from
+        // the delivery's own error), never a failed launch.
+        let routerLine;
+        if (bootstrapLine.length > 0) {
+            let answer = null;
+            try {
+                answer = readFootprintAnswer(this.readinessSettings);
+            }
+            catch { /* unreadable: reported as such */ }
+            const target = describeSkillRouterFootprint([{ seat: input.sessionName ?? input.nodeId, runtime: input.adapter.runtime,
+                    cwd: input.binding.cwd ?? ".", claudeManagedBlockFile: input.binding.claudeManagedBlockFile ?? null }]).files[0]?.path;
+            if (target) {
+                const skip = routerLineSkipReason(answer);
+                if (skip)
+                    routerLine = { answer, files: [{ path: target, outcome: "skipped", reason: skip }] };
+                else if (guidanceFileIsLink(target)) {
+                    // A linked guidance file is someone's layout, often a file outside the project: the line isn't written through it.
+                    routerLine = { answer, files: [{ path: target, outcome: "linked" }] };
+                    warnings.push(`seat_skills_line_linked: ${target} is a link, so the line wasn't written through it; the seat started without it`);
+                }
+                else if (seatSkillsLineEdited(readGuidanceFile(target))) {
+                    // Someone edited the line: a start leaves their block as it is, as rig down does.
+                    routerLine = { answer, files: [{ path: target, outcome: "edited" }] };
+                    warnings.push(`seat_skills_line_edited: ${target} holds an edited seat-skills line, so this start left it as it is`);
+                }
+                else {
+                    try {
+                        // The saved line is optional, and the adapters swallow an optional file's write error; for this one isolated
+                        // call, mark it required so the adapter reports the real error, which is handled here without failing the start.
+                        const delivered = await input.adapter.deliverStartup(bootstrapLine.map((f) => ({ ...f, required: true })), input.binding);
+                        const failed = delivered.failed.find((f) => f.path === bootstrapLine[0].path) ?? delivered.failed[0];
+                        routerLine = { answer, files: [failed ? { path: target, outcome: "unwritable", error: failed.error } : { path: target, outcome: "delivered" }] };
+                    }
+                    catch (err) {
+                        routerLine = { answer, files: [{ path: target, outcome: "unwritable", error: err.message }] };
+                    }
+                    const unwritable = routerLine.files.find((f) => f.outcome === "unwritable");
+                    if (unwritable && unwritable.outcome === "unwritable")
+                        warnings.push(`seat_skills_line_unwritable: ${unwritable.path}: ${unwritable.error}; the seat started without it`);
+                }
+            }
+        }
+        // OPR.0.7.0.13 (router): the seat's one generated router skill, after every pre-launch skill writer, so it lists
+        // every skill the seat starts with. A router that can't be written is this seat's named result; the launch goes on.
+        const routerSeatSkills = input.adapter.runtime === "claude-code" ? seatSkillPathsForNode(this.db, input.nodeId) : codexSeatSkills;
+        if (routerSeatSkills) {
+            try {
+                const router = writeSeatSkillRouter(routerSeatSkills);
+                if (router.kept)
+                    warnings.push(seatRouterKeptNote(router));
+            }
+            catch (err) {
+                warnings.push(`seat_router_not_written: ${err.message}`);
+            }
+        }
+        // OPR.0.7.0.13 (Codex C2): the seat's catalog, built after every pre-launch skill writer (projection and startup
+        // skill files) and before the post-launch text that sends it, so it lists every skill the seat starts with.
+        if (codexSeatSkills) {
+            try {
+                const catalog = writeSeatSkillCatalog(codexSeatSkills);
+                if (catalog.kept)
+                    warnings.push(`${seatCatalogKeptNote(catalog)}${catalog.reason === "edited" ? ", and that file is what the seat's startup text sends" : ""}`);
+            }
+            catch (err) {
+                warnings.push(`seat skill catalog not written: ${err.message}`);
+            }
+        }
         // 7. Persist startup context for restore replay
         if (!input.preserveStartupContext)
             try {
@@ -327,23 +462,51 @@ export class StartupOrchestrator {
                     const launchResult = await input.adapter.launchHarness(input.binding, {
                         name: input.sessionName ?? input.binding.tmuxSession ?? "",
                         resumeToken: launchResumeToken,
+                        ...(launchResumeToken && input.resumeType ? { resumeType: input.resumeType } : {}),
                         ...(input.forkSource && !launchResumeToken ? { forkSource: input.forkSource } : {}),
                     });
                     if (launchResult.ok) {
                         appliedLaunch = launchResult.appliedLaunch;
+                        resumedProcess = launchResult.resumedProcess;
                         if (input.adapter.runtime === "claude-code" && launchResumeToken?.trim()) {
                             await this.recordClaudeResumeLaunch(input.sessionId, input.binding.tmuxPane ?? input.binding.tmuxSession, launchResumeToken.trim(), launchResult.launchedProcess);
                         }
                         const notice = nonInterruptiveNotice(input.adapter.runtime, input.binding);
                         if (notice)
                             warnings.push(`${input.sessionName ?? input.nodeId}: ${notice}`);
+                        for (const note of launchResult.warnings ?? [])
+                            warnings.push(`${input.sessionName ?? input.nodeId}: ${note}`);
                         const normalizedResumeToken = launchResult.resumeToken?.trim();
                         if (normalizedResumeToken) {
                             try {
-                                this.sessionRegistry.updateResumeToken(input.sessionId, launchResult.resumeType ?? "", normalizedResumeToken, "scrape");
+                                if (launchResult.resumeProvenance) {
+                                    this.sessionRegistry.recordLauncherReportedToken(input.sessionId, launchResult.resumeType ?? "", normalizedResumeToken, launchResult.resumeProvenance);
+                                }
+                                else {
+                                    this.sessionRegistry.updateResumeToken(input.sessionId, launchResult.resumeType ?? "", normalizedResumeToken, "scrape");
+                                }
                             }
                             catch { /* best-effort */ }
                         }
+                        // OPR.0.7.0.9: the prompt a new conversation starts with; on a resume, a changed prompt is pending.
+                        if (input.adapter.runtime === "claude-code" && input.binding.launchAdditions?.appendSystemPromptFile) {
+                            const resumed = launchResumeToken?.trim();
+                            if (resumed) {
+                                const pending = systemPromptPendingNoteForNode(this.db, input.nodeId, resumed);
+                                if (pending)
+                                    warnings.push(`${input.sessionName ?? input.nodeId}: ${pending}`);
+                            }
+                            else if (normalizedResumeToken) {
+                                // A fork starts from its parent's conversation: it takes the parent's recorded start (or none).
+                                try {
+                                    if (input.forkSource?.value)
+                                        recordForkConversationPromptForNode(this.db, input.nodeId, normalizedResumeToken, input.forkSource.value);
+                                    else
+                                        recordConversationPromptForNode(this.db, input.nodeId, normalizedResumeToken);
+                                }
+                                catch { /* best-effort */ }
+                            }
+                        }
                         break;
                     }
                     const shouldRetryFresh = !!launchResumeToken
@@ -383,10 +546,10 @@ export class StartupOrchestrator {
                         // isRestore selects context, not native continuity: pod-aware exact
                         // resume also uses false. Only an actual fresh launch may re-prime; an
                         // unverified fork keeps its unsent context for a verified continuation.
-                        return this.fail(input, "attention_required", errors, launchResult.evidence, launchResult.forkIdentityPending ? forkContext ?? false : continuityOutcome === "fresh", undefined, false, "harness_launch", true);
+                        return this.fail(input, "attention_required", errors, launchResult.evidence, launchResult.forkIdentityPending ? forkContext ?? false : continuityOutcome === "fresh", undefined, false, "harness_launch", true, launchResult.probe);
                     }
                     errors.push(`Harness launch failed: ${launchResult.error}`);
-                    return this.fail(input, "failed", errors, undefined, false, launchResult.recovery, launchResult.missingConversation === true, "harness_launch", true);
+                    return this.fail(input, "failed", errors, undefined, false, launchResult.recovery, launchResult.missingConversation === true, "harness_launch", true, launchResult.probe);
                 }
             }
             catch (err) {
@@ -397,6 +560,10 @@ export class StartupOrchestrator {
         // A successful new lean launch replaces the occupant's proof boundary even
         // if readiness later fails. Failed launches and resume/adopt retain history.
         const isFreshLaunch = continuityOutcome === "fresh" && (!input.skipHarnessLaunch || input.continueFreshStartup === true);
+        // Once a startup turn was refused, the result says what's owed, whatever error comes later. Continuing replays the
+        // whole fresh startup, so it's offered only for a fresh start (not a restore) that typed no one-shot action.
+        const owed = (also = [], refused = deliveryInput.refusedTurn) => refused
+            ? this.owedStartup(deliveryInput, refused, continuityOutcome, isFreshLaunch && !input.isRestore && !deliveryInput.oneShotSent, also) : null;
         const shouldChallenge = isFreshLaunch
             && input.adapter.runtime !== "terminal" && startupProof.mode === "authenticated";
         if (isFreshLaunch && !shouldChallenge) {
@@ -544,12 +711,12 @@ export class StartupOrchestrator {
                     for (const f of deliveryResult.failed) {
                         errors.push(`Post-launch file delivery failed: ${f.path}: ${f.error}`);
                     }
-                    return this.fail(deliveryInput, "failed", errors, undefined, false, undefined, false, "post_launch_files", true);
+                    return owed(errors) ?? this.fail(deliveryInput, "failed", errors, undefined, false, undefined, false, "post_launch_files", true);
                 }
             }
             catch (err) {
                 errors.push(`Post-launch delivery error: ${err.message}`);
-                return this.fail(deliveryInput, "failed", errors, undefined, false, undefined, false, "post_launch_files", true);
+                return owed(errors) ?? this.fail(deliveryInput, "failed", errors, undefined, false, undefined, false, "post_launch_files", true);
             }
         }
         // Challenge-only delivery remains best-effort. Staging is reported without
@@ -562,14 +729,17 @@ export class StartupOrchestrator {
         // 8. Execute after_files actions
         const afterFilesResult = await this.executeActions(deliveryInput, "after_files");
         if (!afterFilesResult.ok) {
-            return this.fail(deliveryInput, "failed", afterFilesResult.errors, undefined, false, undefined, false, "after_files", true);
+            return owed(afterFilesResult.errors) ?? this.fail(deliveryInput, "failed", afterFilesResult.errors, undefined, false, undefined, false, "after_files", true);
         }
         // 9. Execute after_ready actions (skipping any preload actions already
         // delivered ahead of role.md by the restore-order bundling above).
         const afterReadyResult = await this.executeActions(deliveryInput, "after_ready", consumedActions);
         if (!afterReadyResult.ok) {
-            return this.fail(deliveryInput, "failed", afterReadyResult.errors, undefined, false, undefined, false, "after_ready", true);
+            return owed(afterReadyResult.errors) ?? this.fail(deliveryInput, "failed", afterReadyResult.errors, undefined, false, undefined, false, "after_ready", true);
         }
+        const held = owed();
+        if (held)
+            return held;
         // Delivering the first native prompt can reveal a provider refusal or
         // interactive gate. Bundled identity/preload prompts consume their files,
         // so the remaining file list alone does not tell us whether context was sent.
@@ -577,6 +747,11 @@ export class StartupOrchestrator {
             try {
                 const readiness = await input.adapter.checkReady(input.binding);
                 if (!readiness.ready && isAttentionRequiredReadinessCode(readiness.code)) {
+                    // A fresh Claude start whose last startup turn was refused hasn't read what that turn sent: it's owed too.
+                    const refusedLast = input.adapter.runtime === "claude-code" && isFreshLaunch && deliveryInput.sendOrder > 0
+                        ? owed([], readiness) : null;
+                    if (refusedLast)
+                        return refusedLast;
                     const hasRemainingIdentityWork = hasClaudeResumeIdentityWork(this.sessionRegistry, input.sessionId, input.adapter.runtime, input.resumeToken, input.resumeType, input.skipHarnessLaunch, continuityOutcome);
                     return this.fail(deliveryInput, "attention_required", [readiness.reason ?? "The native provider prerequisite failed after context delivery."], undefined, false, undefined, false, "post_delivery_readiness", hasRemainingIdentityWork);
                 }
@@ -596,6 +771,15 @@ export class StartupOrchestrator {
                 "Native resume was observed but its requested type or current session metadata conflicts or could not be retained; session preserved.",
             ], undefined, false, undefined, false, "identity_verification", false);
         }
+        // Keep the running conversation, but don't call an explicitly assisted startup ready.
+        // The paste and Enter were attempted; continuing startup must not paste that context a second time.
+        if (deliveryInput.sendOrder > 0 && startupAssisted) {
+            return this.fail(deliveryInput, "attention_required", [
+                `Startup assisted for community harness "${input.adapter.runtime}" in ${input.binding.tmuxSession}: text and Enter were sent, but submission isn't confirmed. `
+                    + `Check the pane and submit any staged startup text; don't resend it. Once the seat has responded, acknowledge it with `
+                    + `rig seat clear-attention ${shellQuote(input.binding.tmuxSession)} --reason ${shellQuote("Startup submission checked; seat responded")}.`,
+            ], undefined, false, undefined, false, "assisted_startup", false);
+        }
         // 8. Mark ready
         this.sessionRegistry.updateStartupStatus(input.sessionId, "ready", new Date().toISOString());
         const submission = deliveryInput.submissionWarnings.length
@@ -605,10 +789,11 @@ export class StartupOrchestrator {
                 ...(deliveryInput.stagedSubmissionWarning ? { warning: deliveryInput.stagedSubmissionWarning } : {}) }
             : undefined;
         this.eventBus.emit({ type: "node.startup_ready", rigId: input.rigId, nodeId: input.nodeId, ...(submission ? { submission } : {}) });
-        return { ok: true, startupStatus: "ready", continuityOutcome, ...(submission ? { submission } : {}) };
+        return { ok: true, startupStatus: "ready", continuityOutcome, ...(submission ? { submission } : {}), ...(routerLine ? { routerLine } : {}), ...(resumedProcess ? { resumedProcess } : {}) };
     }
-    /** A failed attempt can continue only when it stopped before sending context.
-     * Any newer pending/ready/failure event consumes that permission, including a
+    /** A failed attempt can continue only when it stopped before sending context, or when the runtime positively refused
+     * the turn its context went to (an attention code after it) and no one-shot action was typed: a refused turn wasn't
+     * read. Any newer pending/ready/failure event consumes that permission, including a
      * daemon loss during delivery: uncertain delivery is never blindly replayed.
      */
     canContinueStartup(nodeId, sessionId) {
@@ -648,7 +833,7 @@ export class StartupOrchestrator {
             return "";
         }
     }
-    fail(input, status, errors, evidence, pendingContext = false, recovery, missingConversation = false, stage, hasPendingWork) {
+    fail(input, status, errors, evidence, pendingContext = false, recovery, missingConversation = false, stage, hasPendingWork, probe) {
         if (status === "attention_required" && typeof pendingContext === "object") {
             // The reasons above stay visible; this only says what the status means for the fork.
             errors.push("The fork's startup context is waiting to be sent: this attention status doesn't mean the forked conversation is healthy");
@@ -670,8 +855,10 @@ export class StartupOrchestrator {
             ...(hasPendingWork !== undefined ? { hasPendingWork } : {}),
             requestedResumeToken: input.resumeToken ?? null,
             requestedResumeType: input.resumeType ?? null,
+            ...(probe ? { probe } : {}),
         });
         return { ok: false, startupStatus: status, errors, evidence, ...(recovery ? { recovery } : {}),
+            ...(probe ? { probe } : {}),
             ...(missingConversation ? { missingConversation: true } : {}) };
     }
     async executeActions(input, phase, skip) {
@@ -694,6 +881,7 @@ export class StartupOrchestrator {
             if (input.isRestore && !action.idempotent)
                 continue;
             // Execute via tmux
+            const heldBefore = input.heldInputs ?? 0;
             try {
                 if (!input.binding.tmuxSession) {
                     errors.push(`No tmux session for action: ${action.value}`);
@@ -707,6 +895,10 @@ export class StartupOrchestrator {
             catch (err) {
                 errors.push(`Action error (${action.type}): ${err.message}`);
             }
+            // A one-shot that wasn't held may have reached the seat even when its send reported an error (the text typed, the
+            // Enter failed): uncertain delivery is never replayed.
+            if (!action.idempotent && (input.heldInputs ?? 0) === heldBefore)
+                input.oneShotSent = true;
         }
         return errors.length > 0 ? { ok: false, errors } : { ok: true };
     }
@@ -719,14 +911,15 @@ export class StartupOrchestrator {
             return { ok: false, error: "No tmux session for the initial session identity prompt" };
         }
         const firstSendTextIndex = postLaunchFiles.findIndex((file) => file.deliveryHint === "send_text");
-        let prompt = identityAction.value;
+        const identityContext = `OpenRig-generated identity context (not a project task):\n${identityAction.value}\nEnd of generated identity context.`;
+        let prompt = identityContext;
         let remainingFiles = postLaunchFiles;
         if (firstSendTextIndex !== -1) {
             const firstSendText = postLaunchFiles[firstSendTextIndex];
             try {
                 const content = this.readFile(firstSendText.absolutePath);
                 if (content.length > 0) {
-                    prompt = `${identityAction.value}\n\n${content}`;
+                    prompt = `${identityContext}\n\n${content}`;
                     remainingFiles = postLaunchFiles.filter((_, index) => index !== firstSendTextIndex);
                 }
             }
@@ -735,6 +928,9 @@ export class StartupOrchestrator {
                 // the original startup file using its normal failure semantics.
             }
         }
+        if (firstSendTextIndex === -1 && !input.isRestore && !includeDurableObligations && !challengeBlock) {
+            prompt += "\n\nFor this identity-only startup, run rig whoami --json and reply with your identity and readiness for an assignment. Repository history, tool descriptions and your own replies are not assignments.";
+        }
         if (includeDurableObligations)
             prompt += `\n\nThis is a fresh conversation. Before choosing work, derive your identity with rig whoami --json and read durable obligations with rig queue list --destination ${binding.tmuxSession} --state pending,in-progress,blocked --limit 10000 --full --json. Report truncation at the limit; a destination row is not permission to claim unrelated work.`;
         // OPR.0.4.3.06 — the per-launch orientation challenge rides along with the
@@ -795,7 +991,7 @@ export class StartupOrchestrator {
         if (input.adapter.runtime !== "claude-code" || !input.binding.tmuxSession)
             return;
         if (!input.lastSubmissionConfirmed) {
-            this.recordSubmissionWarning(input, "Startup proof instruction was not sent: the startup prompt was not confirmed submitted.");
+            this.recordSubmissionWarning(input, startupProofHeldBackWarning(input.lastSubmissionUnconfirmedReason));
             return;
         }
         const failure = await this.sendInteractiveText(input, STARTUP_PROOF_INSTRUCTION_LINE, "startup_proof_instruction");
@@ -808,10 +1004,49 @@ export class StartupOrchestrator {
         input.warnings.push(displayWarning ?? (reason === input.stagedSubmissionWarning ? reason
             : `Startup submission unverified in ${input.binding.tmuxSession}: ${reason}`));
     }
+    /** The result of a start whose turn the runtime refused: the seat hasn't read its startup context, which never reads as
+     *  delivered. `continuable` keeps it pending for `rig seat continue` (the whole startup again). Otherwise the seat says
+     *  why not: a new conversation names the fresh launch that delivers it; a resumed or forked one keeps its conversation,
+     *  and is never told to relaunch blank. Later errors (`also`) are listed, never in its place. */
+    owedStartup(input, refused, continuity, continuable, also) {
+        const held = input.heldInputs
+            ? `${input.heldInputs} later startup input${input.heldInputs === 1 ? " wasn't" : "s weren't"} sent. ` : "";
+        const why = input.oneShotSent ? "a one-shot startup action already ran and must not run twice"
+            : "this start was a restore, and continuing delivers a fresh start's context";
+        return this.fail(input, "attention_required", [
+            refused.reason ?? "The runtime refused a startup turn.",
+            ...also,
+            continuable
+                ? `${held}The seat hasn't read its startup context. Continuing delivers the whole startup again, the refused turn included.`
+                : continuity !== "fresh"
+                    ? `${held}The seat's conversation is kept, but it hasn't read ${input.heldInputs ? (input.heldInputs === 1 ? "that input" : "those inputs") : "all of its startup context"}; continuing isn't offered for a ${continuity} start.`
+                    : `${held}The seat hasn't read all of its startup context, and continuing isn't offered: ${why}. To deliver it, launch the seat fresh: rig seat launch ${shellQuote(input.binding.tmuxSession ?? "<seat>")} --fresh --stop --reason "<why>".`,
+        ], undefined, continuable, undefined, false, "post_delivery_readiness", true);
+    }
+    /** Whether the runtime refused the last startup turn: an attention readiness code now (Claude's "Login expired ·
+     *  Please run /login" as its latest response reads login_required). An unavailable observation holds nothing back. */
+    async refusedTurn(input) {
+        try {
+            const readiness = await input.adapter.checkReady(input.binding);
+            return !readiness.ready && isAttentionRequiredReadinessCode(readiness.code) ? readiness : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async sendInteractiveText(input, text, source, actionIndex) {
+        // After a refused turn nothing more is typed into the seat. The held input is counted, and startNode reports it as
+        // owed (ahead of any later error) before it would mark the seat ready, so returning here never reads as delivered.
+        if (input.adapter.runtime === "claude-code" && input.sendOrder > 0 && (input.refusedTurn ??= await this.refusedTurn(input))) {
+            input.heldInputs = (input.heldInputs ?? 0) + 1;
+            return null;
+        }
         const sendOrder = ++input.sendOrder;
         const tmuxSession = input.binding.tmuxSession;
         input.lastSubmissionConfirmed = false;
+        input.lastSubmissionUnconfirmedReason = undefined;
+        if (input.adapter.runtime === "claude-code" && sendOrder === 1 && !input.isRestore)
+            await this.awaitClaudeInputBox(input.binding.tmuxPane);
         const textResult = await this.tmuxAdapter.sendText(tmuxSession, text);
         if (!textResult.ok) {
             return { error: textResult.message ?? "unknown" };
@@ -832,7 +1067,8 @@ export class StartupOrchestrator {
                 diagnostic.observations.push({ ...evidence, phase, ...(look === undefined ? {} : { look }) });
             return evidence;
         };
-        const unverified = (reason) => {
+        const unverified = (reason, operatorReason) => {
+            input.lastSubmissionUnconfirmedReason = operatorReason;
             this.recordSubmissionWarning(input, reason);
             return null; // An unavailable observation is not a failed delivery.
         };
@@ -843,7 +1079,7 @@ export class StartupOrchestrator {
             const first = await this.tmuxAdapter.capturePaneContent(tmuxSession, STARTUP_SUBMIT_CAPTURE_LINES);
             if (!first?.trim()) {
                 record(first);
-                return unverified("Startup submission capture is unavailable after Enter.");
+                return unverified("Startup submission capture is unavailable after Enter.", UNCONFIRMED_UNOBSERVABLE);
             }
             const { pane, state: before, looks } = await this.settleOwnPaste(tmuxSession, first, text, input.adapter.runtime);
             if (before === "clear") {
@@ -856,7 +1092,7 @@ export class StartupOrchestrator {
                 const evidence = record(pane, looks || undefined);
                 return unverified(evidence?.reason === "unrecognized_composer_boundary"
                     ? "Startup submission is unverified: the current composer boundary was not recognized."
-                    : "Startup submission is unverified: the current composer does not positively match the complete prompt.");
+                    : "Startup submission is unverified: the current composer does not positively match the complete prompt.", UNCONFIRMED_UNCLEAR);
             }
             let retry;
             let after;
@@ -866,6 +1102,7 @@ export class StartupOrchestrator {
                 phase = "guarded_retry";
                 diagnostic.retry = "threw"; // Replaced when the transport returns normally.
                 retry = await this.sessionTransport.send(tmuxSession, "", {
+                    openrigNotice: true,
                     submitOnly: true,
                     expectedStagedText: text,
                     submitOnlyCaptureLines: STARTUP_SUBMIT_CAPTURE_LINES,
@@ -878,7 +1115,7 @@ export class StartupOrchestrator {
                 after = await this.tmuxAdapter.capturePaneContent(tmuxSession, STARTUP_SUBMIT_CAPTURE_LINES);
                 if (!after?.trim()) {
                     record(after);
-                    return unverified("Startup submission capture is unavailable after the guarded retry.");
+                    return unverified("Startup submission capture is unavailable after the guarded retry.", UNCONFIRMED_UNOBSERVABLE);
                 }
                 observed = inspectStartupStagedText(after, text, input.adapter.runtime);
                 // A refused retry is not repeated; only a retry whose Enter went in and was lost again is.
@@ -886,6 +1123,7 @@ export class StartupOrchestrator {
             if (observed === "staged") {
                 const warning = `Startup prompt still staged in ${tmuxSession}; press Enter in that pane.`;
                 input.stagedSubmissionWarning = warning;
+                input.lastSubmissionUnconfirmedReason = UNCONFIRMED_STAGED;
                 this.recordSubmissionWarning(input, warning);
                 if (!retry.ok)
                     this.recordSubmissionWarning(input, `Guarded retry did not submit: ${retry.error ?? retry.reason}`);
@@ -895,17 +1133,17 @@ export class StartupOrchestrator {
                 const evidence = record(after);
                 return unverified(evidence?.reason === "unrecognized_composer_boundary"
                     ? "Startup submission is unverified after the guarded retry: the current composer boundary was not recognized."
-                    : "Startup submission is unverified after the guarded retry: the current composer is ambiguous.");
+                    : "Startup submission is unverified after the guarded retry: the current composer is ambiguous.", UNCONFIRMED_UNCLEAR);
             }
             if (!retry.ok)
-                return unverified(`Guarded startup retry did not submit: ${retry.error ?? retry.reason}; matching staged text is no longer visible.`);
+                return unverified(`Guarded startup retry did not submit: ${retry.error ?? retry.reason}; matching staged text is no longer visible.`, UNCONFIRMED_RETRY_REFUSED);
             input.lastSubmissionConfirmed = true;
             return null;
         }
         catch (error) {
             if (!diagnostic.observations.some(observation => observation.phase === phase))
                 record(null);
-            return unverified(`Startup submission observation is unavailable: ${error.message}`);
+            return unverified(`Startup submission observation is unavailable: ${error.message}`, UNCONFIRMED_UNOBSERVABLE);
         }
         finally {
             if (diagnostic.observations.length)
@@ -913,16 +1151,40 @@ export class StartupOrchestrator {
         }
     }
     /**
-     * Claude can take the startup Enter after the first look while the composer still shows our paste collapsed.
-     * Only that transient is looked at again, until the composer reads clear or staged, shows anything else, or
-     * the looks run out. A draft, ghost text or any other mismatch keeps its first-look verdict. Observation only.
+     * A fresh launch can read ready before Claude has drawn its input box: on Linux the pane names `claude` the moment
+     * Claude starts, and startup text pasted then sat unsent. Before a fresh start's first send, look at the visible
+     * screen until the input box the startup check reads is drawn, at most STARTUP_SUBMIT_SETTLE_LOOKS looks 200 ms
+     * apart. A screen that never shows one within that, or can't be read, is sent to as before. Observation only.
+     */
+    async awaitClaudeInputBox(pane) {
+        if (!pane)
+            return;
+        for (let look = 0; look < STARTUP_SUBMIT_SETTLE_LOOKS; look++) {
+            let screen;
+            try {
+                screen = await this.tmuxAdapter.capturePaneScreen(pane);
+            }
+            catch {
+                return;
+            }
+            if (screen === null || claudeInputBoxDrawn(screen))
+                return;
+            await this.sleep(200);
+        }
+    }
+    /**
+     * Claude can take the startup Enter after the first look while the composer still shows our paste collapsed, and a
+     * fresh Claude can still be drawing its screen, with no input line at all, when the first look comes. Only those
+     * two transients are looked at again, until the composer reads clear or staged, shows anything else, or the looks
+     * run out. A draft, ghost text, a dialog or any other mismatch keeps its verdict. Observation only.
      * Remaining ambiguity: a person who clears a collapsed paste with the same line count inside the window reads
      * as submitted.
      */
     async settleOwnPaste(tmuxSession, pane, text, runtime) {
         let state = inspectStartupStagedText(pane, text, runtime);
         let looks = 0;
-        while (state === "unverified" && looks < STARTUP_SUBMIT_SETTLE_LOOKS && startupOwnCollapsedPaste(pane, text, runtime)) {
+        while (state === "unverified" && looks < STARTUP_SUBMIT_SETTLE_LOOKS
+            && (startupOwnCollapsedPaste(pane, text, runtime) || startupNoInputLine(pane, runtime))) {
             await this.sleep(200);
             // A failed re-look adds nothing; the last usable observation stands.
             const next = await this.tmuxAdapter.capturePaneContent(tmuxSession, STARTUP_SUBMIT_CAPTURE_LINES).catch(() => null);