@skrr-ai/cli 0.1.45 → 0.1.46

package/dist/commands/tasks/show.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskPointerLines = taskPointerLines;
+exports.blockerDetailLines = blockerDetailLines;
 exports.labelsLine = labelsLine;
 exports.taskExecutorLabel = taskExecutorLabel;
 exports.taskFailureLines = taskFailureLines;
@@ -52,6 +53,29 @@ function taskPointerLines(t, ref, bin = 'skrr') {
  * be read (or a label missing from it) degrades per entry rather than failing
  * the command or hiding the label.
  */
+/**
+ * The lines that say what a blocked Task is waiting on.
+ *
+ * Kept pure so the rule is testable without a network: the command fetches the
+ * newest `blocker` Update and hands its payload here.
+ */
+function blockerDetailLines(detail) {
+    if (!detail)
+        return [];
+    const lines = [];
+    const cause = typeof detail.cause === 'string' ? detail.cause.trim() : '';
+    const required = typeof detail.requiredAction === 'string' ? detail.requiredAction.trim() : '';
+    const owner = detail.nextOwner;
+    if (cause)
+        lines.push(`Blocked on:  ${cause}`);
+    if (required)
+        lines.push(`Needs:       ${required}`);
+    if (owner && typeof owner.kind === 'string' && owner.kind) {
+        const who = typeof owner.userId === 'string' && owner.userId ? ` ${owner.userId}` : '';
+        lines.push(`Next owner:  ${owner.kind}${who}`);
+    }
+    return lines;
+}
 function labelsLine(labelIds, nameById) {
     const ids = (labelIds ?? []).filter((id) => typeof id === 'string' && id.length > 0);
     if (ids.length === 0)
@@ -370,6 +394,7 @@ class TasksShow extends base_command_1.BaseCommand {
         if (actionability) {
             this.log(`Next action: ${actionability.nextActor ?? '-'} · ${actionability.state ?? '-'} · ${actionability.reasonCode ?? '-'}`);
             this.log(`Why:         ${actionability.reason ?? '-'}`);
+            await this.printBlockerDetail(t, actionability);
         }
         const delivery = t.delivery;
         if (delivery?.prNumber || delivery?.prUrl || delivery?.branch) {
@@ -493,5 +518,39 @@ class TasksShow extends base_command_1.BaseCommand {
         for (const line of taskPointerLines(t, ref, this.config.bin))
             this.log(line);
     }
+    /**
+     * What a blocked Task is actually waiting on.
+     *
+     * The workflow tells an agent to record a typed `blocker` Update —
+     * `{cause, requiredAction, nextOwner}` — and only then move the Task to
+     * blocked. The move writes its own exceptional hold, whose summary is the
+     * `--reason` flag or the literal fallback `Task was marked blocked`, and that
+     * is what `Why:` prints. So the one line a reader looks at restated the
+     * status, while the thing the writer was told to record sat one command away
+     * in `tasks updates list` (OSK-10391).
+     *
+     * Read only for a blocked Task, and only the newest blocker Update. A failure
+     * here prints nothing: this decorates an answer the caller already has, and
+     * must never be the reason `tasks show` cannot answer at all.
+     */
+    async printBlockerDetail(task, actionability) {
+        const looksBlocked = String(task.status ?? '') === 'blocked' || actionability.reasonCode === 'exceptional_hold';
+        if (!looksBlocked) {
+            return;
+        }
+        try {
+            const updates = await data_provider_1.dataService.listTaskUpdates(String(task.id), {
+                limit: 1,
+                type: 'blocker',
+            });
+            const detail = updates?.data?.[0]?.data;
+            for (const line of blockerDetailLines(detail)) {
+                this.log(line);
+            }
+        }
+        catch {
+            // The status line above already answered the question this decorates.
+        }
+    }
 }
 exports.default = TasksShow;

package/dist/lib/api-fetch.d.ts

@@ -30,7 +30,13 @@ export declare class ApiFetchError extends Error {
     readonly body?: string;
     readonly code?: string;
     readonly method?: string;
-    constructor(message: string, status: number, body?: string, code?: string, method?: string);
+    /**
+     * The server's `X-Request-ID` for the failing call, when it sent one. It is
+     * the id the server logs against, so a refusal can be looked up rather than
+     * attributed by guesswork — see `node-adapter.ts`.
+     */
+    readonly requestId?: string;
+    constructor(message: string, status: number, body?: string, code?: string, method?: string, requestId?: string);
 }
 /**
  * Call a skrr API endpoint with the current credential. Throws

package/dist/lib/api-fetch.js

@@ -54,13 +54,20 @@ class ApiFetchError extends Error {
     // (OSK-6765): `agents show` is a GET and had no body, and the advice was
     // impossible to follow.
     method;
-    constructor(message, status, body, code, method) {
+    /**
+     * The server's `X-Request-ID` for the failing call, when it sent one. It is
+     * the id the server logs against, so a refusal can be looked up rather than
+     * attributed by guesswork — see `node-adapter.ts`.
+     */
+    requestId;
+    constructor(message, status, body, code, method, requestId) {
         super(message);
         this.name = 'ApiFetchError';
         this.status = status;
         this.body = body;
         this.code = code;
         this.method = method;
+        this.requestId = requestId;
     }
 }
 exports.ApiFetchError = ApiFetchError;
@@ -209,7 +216,7 @@ async function apiFetch(pathOrUrl, opts = {}) {
         catch {
             /* ignore body read failures */
         }
-        throw new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code, method);
+        throw new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code, method, res.headers.get('x-request-id') || undefined);
     }
     // 204/205 carry no body by definition; an empty body has no content-type
     // worth judging. Neither is an error.

package/dist/lib/code-handover.d.ts

@@ -41,6 +41,12 @@ export interface HandoverPromptInput {
     headSha?: string | null;
     recentCommits?: string | null;
     localWorkNotCarried: boolean;
+    /**
+     * A `renderSessionTranscript` block — the exported engine session, carried
+     * by `--carry-session`. Pre-rendered so this function stays a composer: it
+     * owns ordering, the renderer owns the envelope and the budget.
+     */
+    sessionTranscript?: string;
 }
 /**
  * Compose what the receiving agent reads.
@@ -51,6 +57,60 @@ export interface HandoverPromptInput {
  * is machine-collected context the agent would otherwise have to ask for.
  */
 export declare function composeHandoverPrompt(input: HandoverPromptInput): string;
+/** The contract envelope, read defensively — C2 pins the keys, not the innards. */
+export interface EngineSessionExport {
+    version?: unknown;
+    sessionId?: string;
+    messages?: unknown[];
+    /** Explicit, never inferred from length (C3). */
+    truncated?: boolean;
+    /** C4: anything the engine redacted, declared in the envelope. */
+    redactions?: unknown;
+}
+/**
+ * Parse the export envelope, or null when the output is not the contract —
+ * an engine that predates `session export` cannot produce `{version, messages[]}`.
+ */
+export declare function parseSessionExportEnvelope(stdout: string): EngineSessionExport | null;
+export type SessionExportFailureKind = 'unsupported' | 'unknown-session';
+/**
+ * Classify a failed `session export` spawn (an `execFileSync` throw).
+ *
+ * C6 makes an unknown session id a distinct outcome from a broken engine, and
+ * the distinction matters to the operator: "the engine predates the contract"
+ * is an upgrade, "that session is not there" is a different id. The contract
+ * does not pin exit codes, so the signal is the engine's own stderr — which is
+ * also what the refusal relays verbatim either way.
+ */
+export declare function classifySessionExportError(err: {
+    status?: number | null;
+    stderr?: string;
+    message?: string;
+}): {
+    kind: SessionExportFailureKind;
+    detail: string;
+};
+export interface SessionTranscriptRender {
+    /** The block to fold into the handover prompt. */
+    text: string;
+    carriedCount: number;
+    totalCount: number;
+    /** The engine declared the export itself incomplete (C3). */
+    engineTruncated: boolean;
+    /** This side dropped oldest messages to fit the prompt budget — declared. */
+    clipped: boolean;
+}
+/**
+ * Render the exported session into the handover prompt, bounded.
+ *
+ * `POST /api/cloud-coding/tasks` has no transcript field — `prompt` is the only
+ * channel that reaches the receiving agent (the zod schema strips unknown keys
+ * and caps prompt at 50000 chars). So the transcript rides inside the prompt,
+ * clipped from the FRONT: the recent tail is what continuation needs, and the
+ * clip is declared in the block itself, never inferred (C3's rule applied to
+ * our own truncation too).
+ */
+export declare function renderSessionTranscript(exported: EngineSessionExport, budget: number): SessionTranscriptRender;
 export interface AgentCandidate {
     id: string;
     name?: string;

package/dist/lib/code-handover.js

@@ -12,6 +12,9 @@ exports.parseGitHubRepo = parseGitHubRepo;
 exports.evaluateHandoverSafety = evaluateHandoverSafety;
 exports.formatUnsafeHandover = formatUnsafeHandover;
 exports.composeHandoverPrompt = composeHandoverPrompt;
+exports.parseSessionExportEnvelope = parseSessionExportEnvelope;
+exports.classifySessionExportError = classifySessionExportError;
+exports.renderSessionTranscript = renderSessionTranscript;
 exports.matchAgent = matchAgent;
 const auth_core_1 = require("@skrr-ai/auth-core");
 /** `owner/name` from any GitHub remote URL shape. */
@@ -72,6 +75,7 @@ function composeHandoverPrompt(input) {
         '---',
         `Handed over from a local ${auth_core_1.FIRST_PARTY_HARNESS.displayName} session in ${input.repoFullName} on ${input.branch}${at}.`,
         input.recentCommits ? `Recent commits:\n${input.recentCommits}` : null,
+        input.sessionTranscript ?? null,
         input.localWorkNotCarried
             ? 'NOTE: local uncommitted or unpushed work was NOT carried over — you are working from the pushed state of this branch.'
             : null,
@@ -79,6 +83,122 @@ function composeHandoverPrompt(input) {
         .filter(Boolean)
         .join('\n');
 }
+/**
+ * Parse the export envelope, or null when the output is not the contract —
+ * an engine that predates `session export` cannot produce `{version, messages[]}`.
+ */
+function parseSessionExportEnvelope(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const env = parsed;
+    if (env.version === undefined || env.version === null)
+        return null;
+    if (!Array.isArray(env.messages))
+        return null;
+    return env;
+}
+/**
+ * Classify a failed `session export` spawn (an `execFileSync` throw).
+ *
+ * C6 makes an unknown session id a distinct outcome from a broken engine, and
+ * the distinction matters to the operator: "the engine predates the contract"
+ * is an upgrade, "that session is not there" is a different id. The contract
+ * does not pin exit codes, so the signal is the engine's own stderr — which is
+ * also what the refusal relays verbatim either way.
+ */
+function classifySessionExportError(err) {
+    const stderr = (err.stderr ?? '').trim();
+    // "session <id> not found" is an unknown session; "unknown command: session"
+    // is an engine that predates the contract. Both contain the words 'session'
+    // and 'unknown', so the command-not-understood phrasing is excluded FIRST.
+    const commandNotUnderstood = /unknown (command|subcommand)|unrecognized|not a valid|did you mean|usage:/i.test(stderr);
+    const sessionMissing = /(no such|cannot find|could not find|not found|does not exist|unknown)[\s\S]{0,60}session/i.test(stderr) || /session[\s\S]{0,60}(no such|not found|does not exist|missing|unknown)/i.test(stderr);
+    if (!commandNotUnderstood && sessionMissing) {
+        return { kind: 'unknown-session', detail: stderr || (err.message ?? '') };
+    }
+    return { kind: 'unsupported', detail: stderr || err.message || 'session export failed' };
+}
+/** Best-effort text of one exported message, tolerant of the fork's shape. */
+function sessionMessageText(message) {
+    const m = (message ?? {});
+    const role = typeof m.role === 'string' && m.role ? m.role : 'message';
+    const content = m.content ?? m.text;
+    if (typeof content === 'string')
+        return { role, text: content };
+    if (Array.isArray(content)) {
+        const parts = content
+            .map((p) => p && typeof p === 'object' && typeof p.text === 'string'
+            ? p.text
+            : '')
+            .filter(Boolean);
+        if (parts.length)
+            return { role, text: parts.join('\n') };
+    }
+    // A message with no readable text is still a fact of the transcript; keep a
+    // marker rather than silently dropping it (the C4 honesty rule).
+    return { role, text: '[non-text content]' };
+}
+/**
+ * Render the exported session into the handover prompt, bounded.
+ *
+ * `POST /api/cloud-coding/tasks` has no transcript field — `prompt` is the only
+ * channel that reaches the receiving agent (the zod schema strips unknown keys
+ * and caps prompt at 50000 chars). So the transcript rides inside the prompt,
+ * clipped from the FRONT: the recent tail is what continuation needs, and the
+ * clip is declared in the block itself, never inferred (C3's rule applied to
+ * our own truncation too).
+ */
+function renderSessionTranscript(exported, budget) {
+    const messages = exported.messages ?? [];
+    const rendered = messages.map((m) => {
+        const { role, text } = sessionMessageText(m);
+        return `${role}:\n${text}`;
+    });
+    const sid = exported.sessionId ? ` ${exported.sessionId}` : '';
+    const version = exported.version !== undefined ? `, export v${String(exported.version)}` : '';
+    const header = `Carried session transcript (engine session${sid}${version}):`;
+    const notes = [];
+    if (exported.truncated) {
+        notes.push('The engine marked this export TRUNCATED — earlier session content is not in it.');
+    }
+    if (exported.redactions) {
+        notes.push(`The engine declared redactions: ${JSON.stringify(exported.redactions)}`);
+    }
+    let carried = rendered.length;
+    let clipped = false;
+    const assemble = () => {
+        const clipNote = clipped
+            ? `(${rendered.length - carried} earlier message(s) clipped to fit the handover prompt budget.)\n`
+            : '';
+        const body = [
+            header,
+            ...notes,
+            clipNote + rendered.slice(rendered.length - carried).join('\n\n'),
+        ]
+            .filter(Boolean)
+            .join('\n');
+        return body;
+    };
+    // Drop oldest first — the tail is what a continuation needs.
+    while (carried > 0 && assemble().length > budget) {
+        carried -= 1;
+        clipped = true;
+    }
+    return {
+        text: assemble(),
+        carriedCount: carried,
+        totalCount: rendered.length,
+        engineTruncated: exported.truncated === true,
+        clipped,
+    };
+}
 /** Resolve `--to` against the agents this user can see: exact id wins, then name. */
 function matchAgent(needle, agents) {
     const query = needle.trim();

package/dist/lib/commitments.d.ts

@@ -277,6 +277,18 @@ export declare const commitmentApi: {
     executeActionProposal: (id: string, proposalId: string) => Promise<Record<string, unknown>>;
     preflight: (id: string, nextRunCount?: number) => Promise<CommitmentPreflightReport>;
     effectivePolicy: (id: string) => Promise<Record<string, unknown>>;
+    /**
+     * Executor rebind — `POST /api/commitments/:id/executor` (impl contract B4,
+     * docs/architecture/execution-handover-2026-09-17.md P4).
+     *
+     * `commitment.agentId` is single-valued by design, so moving it is an
+     * explicit recorded act: the server appends an `executorHandovers` entry
+     * rather than letting a bare PATCH rewrite who owns the loop without a trail.
+     */
+    setExecutor: (id: string, body: {
+        agentId: string;
+        reason?: string;
+    }) => Promise<Record<string, unknown>>;
     pause: (id: string) => Promise<Commitment>;
     resume: (id: string) => Promise<Commitment>;
     complete: (id: string) => Promise<Commitment>;
@@ -557,6 +569,16 @@ export declare function describeAutonomyLine(commitment: CommitmentView, latestC
         policyTrace?: Array<Record<string, unknown>>;
     } | null;
 } | null): string;
+/**
+ * One-line rendering of `commitment.executorBlocked` — the B4/A7 signal that
+ * the executor's targets are all unusable: `{reason:'quota'|'offline', until?,
+ * provider?}`.
+ *
+ * Defensive by contract: the field is being added server-side, so its absence
+ * is the normal case and means "no information", not "not blocked". Returns
+ * null rather than printing a guess.
+ */
+export declare function describeExecutorBlocked(commitment: CommitmentView): string | null;
 export declare function renderCommitmentSummary(commitment: CommitmentView, log: (line: string) => void, 
 /**
  * The most recent check, when the caller has one. Optional because pause /

package/dist/lib/commitments.js

@@ -19,6 +19,7 @@ exports.renderCommitmentList = renderCommitmentList;
 exports.effectiveAutonomyMode = effectiveAutonomyMode;
 exports.extractStandstillFromCheck = extractStandstillFromCheck;
 exports.describeAutonomyLine = describeAutonomyLine;
+exports.describeExecutorBlocked = describeExecutorBlocked;
 exports.renderCommitmentSummary = renderCommitmentSummary;
 exports.describeWakeDecision = describeWakeDecision;
 exports.renderCheckList = renderCheckList;
@@ -176,6 +177,15 @@ exports.commitmentApi = {
         ...(typeof nextRunCount === 'number' ? { nextRunCount } : {}),
     }),
     effectivePolicy: (id) => data_provider_1.request.get(`${base(id)}/effective-policy`),
+    /**
+     * Executor rebind — `POST /api/commitments/:id/executor` (impl contract B4,
+     * docs/architecture/execution-handover-2026-09-17.md P4).
+     *
+     * `commitment.agentId` is single-valued by design, so moving it is an
+     * explicit recorded act: the server appends an `executorHandovers` entry
+     * rather than letting a bare PATCH rewrite who owns the loop without a trail.
+     */
+    setExecutor: (id, body) => data_provider_1.request.post(`${base(id)}/executor`, body),
     pause: (id) => data_provider_1.request.post(`${base(id)}/pause`, {}),
     resume: (id) => data_provider_1.request.post(`${base(id)}/resume`, {}),
     complete: (id) => data_provider_1.request.post(`${base(id)}/complete`, {}),
@@ -738,6 +748,30 @@ function describeAutonomyLine(commitment, latestCheck) {
     }
     return (0, commitment_product_1.productModeLabel)(stated);
 }
+/**
+ * One-line rendering of `commitment.executorBlocked` — the B4/A7 signal that
+ * the executor's targets are all unusable: `{reason:'quota'|'offline', until?,
+ * provider?}`.
+ *
+ * Defensive by contract: the field is being added server-side, so its absence
+ * is the normal case and means "no information", not "not blocked". Returns
+ * null rather than printing a guess.
+ */
+function describeExecutorBlocked(commitment) {
+    const blocked = commitment.executorBlocked;
+    if (!blocked || typeof blocked !== 'object')
+        return null;
+    const b = blocked;
+    const reason = typeof b.reason === 'string' ? b.reason : '';
+    const provider = typeof b.provider === 'string' ? b.provider : '';
+    const until = typeof b.until === 'string' ? b.until : '';
+    const label = reason === 'quota'
+        ? `quota exhausted${provider ? ` on ${provider}` : ''}`
+        : reason === 'offline'
+            ? 'executor runtime offline'
+            : reason || 'blocked';
+    return `${label}${until ? ` until ${until}` : ''}`;
+}
 function renderCommitmentSummary(commitment, log, 
 /**
  * The most recent check, when the caller has one. Optional because pause /
@@ -750,6 +784,14 @@ latestCheck) {
     log(`Kind:      ${commitment.kind ?? 'achieve'}`);
     log(`Status:    ${commitment.status ?? '-'}`);
     log(`Agent:     ${commitment.agentId ?? '-'}`);
+    // A commitment whose executor cannot run anywhere should say so on the
+    // header, not as a silent skip series — "executor cannot run until <date> —
+    // reassign or add a fallback target" (design doc P4).
+    const executorBlocked = describeExecutorBlocked(commitment);
+    if (executorBlocked) {
+        log(`Executor:  blocked — ${executorBlocked}`);
+        log(`           Fix: reassign with \`skrr commitments handover ${commitment.id ?? '<id>'} --to <agent>\` or add a fallback target`);
+    }
     if (commitment.goalId)
         log(`Goal:      ${commitment.goalId}`);
     if (commitment.northstarId)

package/dist/lib/dedicated-wait.js

@@ -27,9 +27,30 @@ const PLANNED_REPLACEMENT_PROGRESS = {
     dedicated_runtime_image_update: 'replacing the machine',
     dedicated_runtime_image_update_rolling_back: 'replacing the machine again',
 };
+/**
+ * The same two labels, keyed by the image move's OWN status.
+ *
+ * `stateReason` describes the state a lease is in, so anything that moves it
+ * again during the move can leave it behind: a watched `update-image --wait`
+ * still printed the unplanned-recovery hint through the `recovering` phase it
+ * had itself asked for (OSK-9933, live 2026-09-17, after a provision attempt
+ * lost its fence and was retried). `health.image.lastUpdate.status` says the
+ * move is under way for as long as it is, which is the question being asked.
+ */
+const IN_FLIGHT_IMAGE_UPDATE_PROGRESS = {
+    applying: 'replacing the machine',
+    rolling_back: 'replacing the machine again',
+};
+function plannedReplacementProgress(lease) {
+    const byReason = lease.stateReason ? PLANNED_REPLACEMENT_PROGRESS[lease.stateReason] : undefined;
+    if (byReason)
+        return byReason;
+    const imageStatus = lease.health?.image?.lastUpdate?.status;
+    return imageStatus ? IN_FLIGHT_IMAGE_UPDATE_PROGRESS[imageStatus] : undefined;
+}
 function progressOf(lease) {
     const state = (0, dedicated_machines_1.dedicatedLeaseState)(lease);
-    const planned = lease.stateReason ? PLANNED_REPLACEMENT_PROGRESS[lease.stateReason] : undefined;
+    const planned = plannedReplacementProgress(lease);
     if (state === 'recovering' && planned)
         return planned;
     if (state === 'recovering') {

package/dist/lib/followups.d.ts

@@ -20,6 +20,24 @@ export declare function settledLine(id: string, result: Record<string, unknown>,
 export declare const followUpIdArg: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
 export { FOLLOWUP_KINDS, FOLLOWUP_STATES, FOLLOWUP_RESOLVE_OUTCOMES, type FollowUpKind, } from '@skrr-ai/data-provider';
 export declare const WATCH_WAIT_KINDS: readonly ["clock", "event", "poll_until"];
+export type WatchWaitKind = (typeof WATCH_WAIT_KINDS)[number];
+/**
+ * OSK-10407 — `--deadline`, `--check-every` and `--max-checks` are predicate-form
+ * flags. `skrr followups watch` accepted them on a recipe watch and dropped
+ * them, so a caller who wrote `--deadline 3h` was told the watch was armed and
+ * held a stopping condition that was never stored.
+ *
+ * Dropping them is right; dropping them SILENTLY is the defect. Refuse instead,
+ * and name the flag that bounds THIS wait kind — a refusal that only says "not
+ * here" leaves the caller with no way to express the thing they wanted.
+ *
+ * @returns the refusal message, or null when nothing predicate-shaped was passed.
+ */
+export declare function recipeWatchBoundsRefusal(waitKind: string | undefined, passed: {
+    deadline?: unknown;
+    checkEvery?: unknown;
+    maxChecks?: unknown;
+}): string | null;
 export interface FollowUpRow {
     id: string;
     kind?: string;

package/dist/lib/followups.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.followupsApi = exports.WATCH_WAIT_KINDS = exports.FOLLOWUP_RESOLVE_OUTCOMES = exports.FOLLOWUP_STATES = exports.FOLLOWUP_KINDS = exports.followUpIdArg = void 0;
 exports.settledLine = settledLine;
+exports.recipeWatchBoundsRefusal = recipeWatchBoundsRefusal;
 exports.resolveFollowUpAgent = resolveFollowUpAgent;
 exports.parseSubjectRef = parseSubjectRef;
 exports.followupSummaryLine = followupSummaryLine;
@@ -71,6 +72,49 @@ Object.defineProperty(exports, "FOLLOWUP_KINDS", { enumerable: true, get: functi
 Object.defineProperty(exports, "FOLLOWUP_STATES", { enumerable: true, get: function () { return data_provider_2.FOLLOWUP_STATES; } });
 Object.defineProperty(exports, "FOLLOWUP_RESOLVE_OUTCOMES", { enumerable: true, get: function () { return data_provider_2.FOLLOWUP_RESOLVE_OUTCOMES; } });
 exports.WATCH_WAIT_KINDS = ['clock', 'event', 'poll_until'];
+/**
+ * What actually bounds a recipe watch, per wait kind. A recipe watch ends
+ * through its `--wait`, never through the predicate form's `--deadline` /
+ * `--check-every` / `--max-checks`: the create route stores none of those for
+ * `form: 'recipe'`, so the row comes back `deadlineAt: null`.
+ */
+const RECIPE_WATCH_BOUND_BY_WAIT = Object.freeze({
+    clock: '--wait-at, the instant it fires',
+    event: '--wait-fallback, the SLA backstop for an event that never arrives',
+    poll_until: '--wait-max-attempts and --wait-fallback',
+});
+/**
+ * OSK-10407 — `--deadline`, `--check-every` and `--max-checks` are predicate-form
+ * flags. `skrr followups watch` accepted them on a recipe watch and dropped
+ * them, so a caller who wrote `--deadline 3h` was told the watch was armed and
+ * held a stopping condition that was never stored.
+ *
+ * Dropping them is right; dropping them SILENTLY is the defect. Refuse instead,
+ * and name the flag that bounds THIS wait kind — a refusal that only says "not
+ * here" leaves the caller with no way to express the thing they wanted.
+ *
+ * @returns the refusal message, or null when nothing predicate-shaped was passed.
+ */
+function recipeWatchBoundsRefusal(waitKind, passed) {
+    const offenders = [
+        ['--deadline', passed.deadline],
+        ['--check-every', passed.checkEvery],
+        ['--max-checks', passed.maxChecks],
+    ]
+        .filter(([, value]) => value !== undefined)
+        .map(([flag]) => flag);
+    if (offenders.length === 0)
+        return null;
+    const bound = RECIPE_WATCH_BOUND_BY_WAIT[waitKind];
+    const list = offenders.join(offenders.length === 2 ? ' and ' : ', ');
+    const verb = offenders.length === 1 ? 'bounds' : 'bound';
+    return [
+        `${list} ${verb} a predicate watch (--url + --until) and ${offenders.length === 1 ? 'is' : 'are'} not stored on a recipe watch.`,
+        bound
+            ? `A recipe watch ends through its --wait ${waitKind}: ${bound}.`
+            : 'A recipe watch ends through its --wait.',
+    ].join(' ');
+}
 /**
  * Which agent a follow-up belongs to.
  *

package/dist/lib/node-adapter.js

@@ -332,6 +332,12 @@ function createNodeAdapter(opts = {}) {
             err.status = res.status;
             err.body = text;
             err.method = method;
+            // The server stamps every response with the id it logs against
+            // (`requestLogger`). Carrying it means a refused call can be found in
+            // the logs instead of guessed at: with several clients on one account,
+            // "which of these requests was mine" is otherwise unanswerable, and a
+            // 409 that belonged to another session was nearly filed as a CLI bug.
+            err.requestId = res.headers.get('x-request-id') || undefined;
             throw err;
         }
         if (options?.responseType === 'arraybuffer') {

package/dist/lib/task-extras.d.ts

@@ -57,6 +57,50 @@ export declare const taskSelfScheduleApi: {
  * parity check.
  */
 export declare function taskCompletePath(taskId: string): string;
+/**
+ * `POST /api/tasks/:taskId/runs/:runId/handover` — the B1 admission path
+ * (docs/architecture/execution-handover-impl-contracts.md): mint a new run on a
+ * different agent/target, resumed from the source run's Resume Point.
+ *
+ * `apiFetch` rather than `request.post`: a handover ADMITS a run, so the write
+ * needs the shared `X-Idempotency-Key` stamping apiFetch applies — a retried
+ * request must not double-admit. Kept in the lib so `domain-api-parity` sees
+ * the endpoint — a command that builds its own `/api/tasks/...` string is
+ * invisible to the coverage check.
+ */
+export declare function taskRunHandover(taskId: string, runId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+/**
+ * `POST /api/tasks/:taskId/runs/:runId/fork` — B8. Admits a SIBLING run from
+ * the same Resume Point, so both attempts are live and neither is canonical
+ * until `promote`. Distinct from handover, which continues the work once.
+ */
+export declare function taskRunFork(taskId: string, runId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+/**
+ * `POST /api/tasks/:taskId/runs/:runId/promote` — B8. Fixes one branch of a
+ * parallel group as canonical and CANCELS the live losers, which is why it has
+ * a surface of its own rather than riding a flag on fork.
+ */
+export declare function taskRunPromote(taskId: string, runId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+/** The wire shape of an execution target: `{kind, ref?}`, never a bare string. */
+export interface ExecutionTargetRef {
+    kind: 'harness' | 'hosted-machine' | 'agent-worker';
+    ref?: string;
+}
+/**
+ * Turn a `--harness` value into the `executionTargetRef` the API parses.
+ *
+ * The route validates an OBJECT (`{kind, ref?}`); passing the flag through as a
+ * string failed its zod parse, so every `--harness` invocation returned
+ * `400 Invalid request data` — the harness axis, which is half of what handover
+ * is for, was unreachable from the CLI and untested.
+ *
+ * The kind is INFERRED rather than asked for, because an operator naming a
+ * machine should not also have to name its category: the two managed selectors
+ * are reserved words, a `hosted-machine:<sessionId>` form addresses one
+ * session, and everything else is a harness id — which is what the flag is
+ * called.
+ */
+export declare function parseExecutionTargetRef(value: string): ExecutionTargetRef;
 export declare const taskChatApi: {
     transcriptSources: (id: string, query?: Query) => Promise<Json>;
     reindexTranscript: (id: string) => Promise<Json>;