@skrr-ai/cli 0.1.44 → 0.1.46

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/initiatives.d.ts

@@ -29,10 +29,22 @@ export type InitiativeView = {
         label?: string;
     };
 };
+/**
+ * The shape `GET /api/initiatives` actually returns. It is NOT the
+ * `{data, has_more, next_cursor}` envelope the Task routes use, and typing it
+ * that way is how `skrr initiatives list` came to print "Nothing is waiting on
+ * you." against 411 pending proposals — `response.data` was always undefined.
+ *
+ * `nextCursor` is an opaque keyset token; hand it straight back as `cursor`.
+ */
 export type InitiativeListResponse = {
-    data?: InitiativeView[];
-    has_more?: boolean;
-    next_cursor?: string | null;
+    initiatives?: InitiativeView[];
+    counts?: {
+        total?: number;
+        active?: number;
+        byState?: Record<string, number>;
+    };
+    nextCursor?: string | null;
 };
 export declare const initiativeApi: {
     list: (query?: Parameters<typeof withQuery>[1]) => Promise<InitiativeListResponse>;

package/dist/lib/label-ref.d.ts

@@ -47,6 +47,8 @@ export interface LabelRow {
     color?: string;
     applicableTo?: string[];
     usageCount?: number;
+    /** The vocabulary's own order — the tie-break when two labels are used equally. */
+    position?: number;
     archivedAt?: string | null;
     [key: string]: unknown;
 }

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>;

package/dist/lib/task-extras.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskChatApi = exports.taskSelfScheduleApi = exports.taskLookupApi = exports.taskWorkflowApi = void 0;
 exports.taskCompletePath = taskCompletePath;
+exports.taskRunHandover = taskRunHandover;
+exports.taskRunFork = taskRunFork;
+exports.taskRunPromote = taskRunPromote;
+exports.parseExecutionTargetRef = parseExecutionTargetRef;
 /**
  * task-extras.ts — the `/api/tasks` endpoints that have no `dataService.*`
  * wrapper, gathered so every one of them is reachable from `skrr`.
@@ -18,6 +22,7 @@ exports.taskCompletePath = taskCompletePath;
  */
 const data_provider_1 = require("@skrr-ai/data-provider");
 const triggers_1 = require("./triggers");
+const api_fetch_1 = require("./api-fetch");
 const MOUNT = '/api/tasks';
 const base = (id) => `${MOUNT}/${encodeURIComponent(id)}`;
 exports.taskWorkflowApi = {
@@ -78,6 +83,74 @@ exports.taskSelfScheduleApi = {
 function taskCompletePath(taskId) {
     return `${base(taskId)}/complete`;
 }
+/**
+ * `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.
+ */
+function taskRunHandover(taskId, runId, body) {
+    return (0, api_fetch_1.apiFetch)(`${base(taskId)}/runs/${encodeURIComponent(runId)}/handover`, {
+        method: 'POST',
+        body,
+    });
+}
+/**
+ * `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.
+ */
+function taskRunFork(taskId, runId, body) {
+    return (0, api_fetch_1.apiFetch)(`${base(taskId)}/runs/${encodeURIComponent(runId)}/fork`, {
+        method: 'POST',
+        body,
+    });
+}
+/**
+ * `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.
+ */
+function taskRunPromote(taskId, runId, body) {
+    return (0, api_fetch_1.apiFetch)(`${base(taskId)}/runs/${encodeURIComponent(runId)}/promote`, {
+        method: 'POST',
+        body,
+    });
+}
+/** Selectors the platform reserves for its own managed targets. */
+const AGENT_WORKER_SELECTORS = new Set(['agent-worker', '__oversky_worker__']);
+const HOSTED_MACHINE_SELECTORS = new Set(['hosted-machine', '__oversky_hosted_machine__']);
+/**
+ * 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.
+ */
+function parseExecutionTargetRef(value) {
+    const trimmed = value.trim();
+    if (AGENT_WORKER_SELECTORS.has(trimmed))
+        return { kind: 'agent-worker' };
+    if (HOSTED_MACHINE_SELECTORS.has(trimmed))
+        return { kind: 'hosted-machine' };
+    const hosted = /^hosted-machine:(.+)$/.exec(trimmed);
+    if (hosted)
+        return { kind: 'hosted-machine', ref: hosted[1] };
+    const harness = /^harness:(.+)$/.exec(trimmed);
+    return { kind: 'harness', ref: harness ? harness[1] : trimmed };
+}
 exports.taskChatApi = {
     transcriptSources: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/transcript/sources`, query)),
     reindexTranscript: (id) => data_provider_1.request.post(`${base(id)}/transcript/reindex`, {}),

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/credentialEnvelopeBridge.d.ts

@@ -36,6 +36,14 @@ export declare function initCredEnvelope(profile: string): Promise<void>;
  * Reset state. With `clearOnDisk` deletes the wrapped DEK file too —
  * used by `oversky logout` / `sky logout`. Zeroes the in-memory DEK
  * before dropping state for forward secrecy on the active credential.
+ *
+ * It deletes EVERY location this profile's key can occupy, plus the
+ * consolidation marker. `profileStateDir.ts` never deletes anything and says so;
+ * this is the one caller that must, and the reason is not symmetry — a logout
+ * that removed only the canonical copy would leave the pre-consolidation copy
+ * behind, and the next init would adopt it straight back. That is a deleted
+ * credential key resurrecting itself, which is a worse bug than the one this
+ * whole change is fixing.
  */
 export declare function resetCredEnvelope(opts?: {
     profile?: string;
@@ -49,6 +57,17 @@ export declare function __resetShutdownGuardForTest(): void;
  * predicate used by sync transforms; never throws.
  */
 export declare function isCredEnvelopeActive(): boolean;
+/**
+ * True while this profile holds two usable and different wrapped DEKs.
+ *
+ * Read by `deviceIdentityBridge` before it migrates anything of its own. The
+ * device private key is sealed with whichever DEK is active, so moving it to the
+ * canonical directory while the two binaries are still on DIFFERENT DEKs hands
+ * the other one a key it cannot open — it regenerates, overwrites, and the two
+ * processes then destroy each other's device identity on every start. Unresolved
+ * conflicts freeze the whole profile's layout, not just the DEK's.
+ */
+export declare function hasCredEnvelopePathConflict(): boolean;
 /**
  * Operator-readable summary of envelope state. Used by `oversky status`
  * and CLI debug commands. Never includes the DEK or any key material.
@@ -65,6 +84,16 @@ export declare function describeCredEnvelopeState(): {
     kekKind?: string | null;
     profile?: string;
     kekRotated?: boolean;
+    /**
+     * Set when this profile holds two usable and DIFFERENT wrapped DEKs and the
+     * consolidation refused to pick one (OSK-10314). The envelope is fully
+     * operational — this process reads the key it has always read — but the other
+     * binary is holding a different one and cannot read what this one seals.
+     */
+    pathConflict?: {
+        canonicalPath: string;
+        legacyPath: string;
+    };
 };
 /**
  * Sync write transform. Returns the wrapped serialized form when active.