@skrr-ai/cli 0.1.109 → 0.1.111

package/dist/lib/harnesses.js

@@ -13,6 +13,9 @@ exports.listQuotaAccounts = listQuotaAccounts;
 exports.getQuotaHistory = getQuotaHistory;
 exports.updateHarness = updateHarness;
 exports.forgetHarness = forgetHarness;
+exports.pruneHarnesses = pruneHarnesses;
+exports.parseHarnessPruneAge = parseHarnessPruneAge;
+exports.harnessPruneReasonSentence = harnessPruneReasonSentence;
 exports.setHarnessAlias = setHarnessAlias;
 exports.setDefaultHarness = setDefaultHarness;
 exports.mintInstallToken = mintInstallToken;
@@ -173,6 +176,73 @@ async function updateHarness(id, patch) {
 async function forgetHarness(id) {
     return (0, api_fetch_1.apiFetch)(`/api/harnesses/${encodeURIComponent(id)}`, { method: 'DELETE' });
 }
+/**
+ * Remove the caller's superseded harness rows - or, by default, say which would go.
+ *
+ * ONE route for both: the server makes the decision once and this only asks for it
+ * to be shown (`dryRun: true`, also its own default) or carried out. The caller
+ * never lists rows and picks, so there is no client-side rule to drift from the
+ * server's. A write, so `apiFetch` gives it an idempotency key and a retried
+ * request replays the recorded answer instead of running again.
+ */
+async function pruneHarnesses(options = { dryRun: true }) {
+    return (0, api_fetch_1.apiFetch)('/api/harnesses/prune', {
+        method: 'POST',
+        body: {
+            dryRun: options.dryRun,
+            ...(options.limit !== undefined ? { limit: options.limit } : {}),
+            ...(options.minUnseenMs !== undefined ? { minUnseenMs: options.minUnseenMs } : {}),
+        },
+    });
+}
+/**
+ * `--older-than` takes a whole number with a unit: `90m`, `36h`, `7d`. A bare
+ * number is hours. Returns milliseconds. The server never goes below its offline
+ * window whatever this says.
+ */
+function parseHarnessPruneAge(value) {
+    const match = value.trim().match(/^(\d+)\s*(m|h|d)?$/i);
+    if (!match) {
+        throw new Error(`Invalid --older-than value "${value}". Use a number with m, h or d, such as 90m, 36h or 7d.`);
+    }
+    const amount = Number(match[1]);
+    const unit = (match[2] || 'h').toLowerCase();
+    const perUnit = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : 60_000;
+    return amount * perUnit;
+}
+/** One sentence per reason a row was kept. The only place they are worded. */
+function harnessPruneReasonSentence(row) {
+    switch (row.reason) {
+        case 'recent':
+            return 'seen too recently to be sure it is gone';
+        case 'latest_registration':
+            return 'the newest registration of its provider on that machine';
+        case 'no_live_sibling':
+            return 'nothing has replaced it - no daemon on that machine is online for this provider';
+        case 'pinned': {
+            const names = (row.detail?.agents ?? []).map((a) => a.name ?? a.id);
+            const more = row.detail?.moreAgents ?? 0;
+            const others = row.detail?.otherAuthors ?? 0;
+            const parts = [];
+            if (names.length > 0) {
+                parts.push(`${names.join(', ')}${more > 0 ? ` and ${more} more` : ''}`);
+            }
+            if (others > 0)
+                parts.push(`${others} agent${others === 1 ? '' : 's'} of other people`);
+            return `agents are pinned to it${parts.length > 0 ? ` (${parts.join('; ')})` : ''}`;
+        }
+        case 'granted':
+            return 'it is lent to a workspace';
+        case 'default':
+            return 'it is your default harness';
+        case 'aliased':
+            return 'you gave it a name';
+        case 'changed_since_plan':
+            return 'it changed while this ran (came back online, or was pinned)';
+        default:
+            return String(row.reason ?? 'kept');
+    }
+}
 /**
  * A per-USER display name. Distinct from `updateHarness({name})`, which renames
  * the harness for everyone it is shared with — this only changes what YOU see,

package/dist/lib/json-output.d.ts

@@ -53,4 +53,37 @@ export declare function stripStorageFieldsFromText(text: string): string;
 export declare function withOk<T>(value: T, ok?: boolean): T | ({
     ok: boolean;
 } & Record<string, unknown>);
+export type CliOperationMode = 'execute' | 'dry_run' | 'verify';
+export type CliWriteState = 'confirmed' | 'not_attempted' | 'unknown';
+export type CliResourceIdentity = {
+    kind: string;
+    id?: string | null;
+};
+export type CliTaskIdentity = {
+    id?: string | null;
+};
+export type CliOperationOptions = {
+    command: string;
+    mode: CliOperationMode;
+    /** Command outcome, not a claim that an unsuccessful write did not commit. */
+    outcome: 'succeeded' | 'failed';
+    /** Use only the identity returned by a native read/write, never a requested ref. */
+    resource?: CliResourceIdentity | null;
+    task?: CliTaskIdentity | null;
+    /** Include only when the native response explicitly establishes replay. */
+    replayed?: boolean;
+    writeState?: CliWriteState;
+};
+/**
+ * An opt-in result contract for commands whose native record is not the Task.
+ * Legacy payload paths remain in place; `_cli` is the CLI-owned v1 namespace.
+ * In particular, an Update's id never becomes the enclosing Task's id. Missing
+ * native identities stay null rather than being guessed from positional refs.
+ *
+ * Arrays/primitives remain unchanged. This helper never wraps arbitrary `log`
+ * output, inspects a command name to infer a record, or invents a created ID
+ * for dry-run/verification. `writeState:unknown` on an error is deliberate:
+ * a failed HTTP response is not proof that a server-side write did not commit.
+ */
+export declare function withCliOperation<T>(value: T, options: CliOperationOptions): T | Record<string, unknown>;
 export {};

package/dist/lib/json-output.js

@@ -21,6 +21,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripStorageFields = stripStorageFields;
 exports.stripStorageFieldsFromText = stripStorageFieldsFromText;
 exports.withOk = withOk;
+exports.withCliOperation = withCliOperation;
 function usableId(value) {
     return (typeof value === 'string' && value.length > 0) || typeof value === 'number';
 }
@@ -106,3 +107,39 @@ function withOk(value, ok = true) {
         return value;
     return { ok, ...value };
 }
+/**
+ * An opt-in result contract for commands whose native record is not the Task.
+ * Legacy payload paths remain in place; `_cli` is the CLI-owned v1 namespace.
+ * In particular, an Update's id never becomes the enclosing Task's id. Missing
+ * native identities stay null rather than being guessed from positional refs.
+ *
+ * Arrays/primitives remain unchanged. This helper never wraps arbitrary `log`
+ * output, inspects a command name to infer a record, or invents a created ID
+ * for dry-run/verification. `writeState:unknown` on an error is deliberate:
+ * a failed HTTP response is not proof that a server-side write did not commit.
+ */
+function withCliOperation(value, options) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const id = (candidate) => typeof candidate === 'string' && candidate.trim() ? candidate : null;
+    const resourceId = id(options.resource?.id);
+    const taskId = id(options.task?.id);
+    const outcome = value.ok === false ? 'failed' : options.outcome;
+    return {
+        ...withOk(value, outcome === 'succeeded'),
+        _cli: {
+            schemaVersion: 1,
+            command: options.command,
+            mode: options.mode,
+            outcome,
+            resource: resourceId && options.resource?.kind
+                ? { kind: options.resource.kind, id: resourceId }
+                : null,
+            task: taskId ? { id: taskId } : null,
+            ...(options.replayed !== undefined ? { replayed: options.replayed } : {}),
+            writeState: options.mode !== 'execute'
+                ? 'not_attempted'
+                : options.writeState ?? (outcome === 'succeeded' ? 'confirmed' : 'unknown'),
+        },
+    };
+}

package/dist/lib/list-output.d.ts

@@ -18,7 +18,8 @@ export type ListEnvelope = {
  * Documented in docs/cli/SKRR_TASKS.md (List output for agents).
  */
 export declare const COMPACT_FIELDS: {
-    readonly task: readonly ["id", "identifier", "ref", "title", "status", "statusType", "priority", "estimate", "assigneeAgentIds", "assigneeUserIds", "parentId", "spaceId", "projectId", "goalId", "dueDate", "scheduledFor", "labelIds", "tags", "externalKey", "version", "executionMode", "nextAction", "createdAt", "updatedAt", "url"];
+    readonly agent: readonly ["id", "name", "description", "harnessId", "harnessName", "harnessProvider", "harnessStatus", "executionReadiness", "updatedAt", "url"];
+    readonly task: readonly ["id", "identifier", "ref", "title", "status", "statusType", "priority", "estimate", "assigneeAgentIds", "assigneeUserIds", "parentId", "spaceId", "projectId", "goalId", "dueDate", "scheduledFor", "labelIds", "tags", "externalKey", "version", "executionMode", "nextAction", "actionability", "execution", "economicsRank", "createdAt", "updatedAt", "url"];
     readonly space: readonly ["id", "identifier", "title", "status", "parentSpaceId", "leadAgentId", "labelIds", "archivedAt", "createdAt", "updatedAt", "url"];
     readonly project: readonly ["id", "identifier", "title", "spaceId", "externalKey", "taskCounts", "archivedAt", "createdAt", "updatedAt", "url"];
 };
@@ -38,11 +39,15 @@ export type ListOutputFlags = {
 export declare function parseFields(raw: string | undefined): string[] | undefined;
 export declare function projectRow(row: Record<string, unknown>, fields: readonly string[]): Record<string, unknown>;
 /**
- * Normalize any list response to the shared envelope. `data` is where rows live
- * for every list command; `projects` (an older serialization) is folded into it.
+ * Normalize a list response to the shared envelope. Each command explicitly
+ * supplies its legacy row key when needed; named keys remain compatible.
+ * The original projects adapter continues folding its old key into `data`.
  * A response that is not list-shaped is returned untouched (never invent rows).
  */
-export declare function toListEnvelope(response: unknown): ListEnvelope | undefined;
+export declare function toListEnvelope(response: unknown, rowKey?: string): ListEnvelope | undefined;
+/** Explicit command boundary: retain unknown responses rather than inventing empty rows.
+ * Named row keys remain available for existing consumers during migration. */
+export declare function listResult(response: unknown, rowKey?: string): unknown;
 export type ShapeListOptions = ListOutputFlags & {
     resource: ListResource;
     /** What the caller asked for with --limit (undefined when the command has none). */

package/dist/lib/list-output.js

@@ -4,6 +4,7 @@ exports.listOutputFlags = exports.COMPACT_FIELDS = void 0;
 exports.parseFields = parseFields;
 exports.projectRow = projectRow;
 exports.toListEnvelope = toListEnvelope;
+exports.listResult = listResult;
 exports.shapeListResponse = shapeListResponse;
 exports.limitNote = limitNote;
 exports.warningLines = warningLines;
@@ -38,6 +39,7 @@ const json_output_1 = require("./json-output");
  * Documented in docs/cli/SKRR_TASKS.md (List output for agents).
  */
 exports.COMPACT_FIELDS = {
+    agent: ['id', 'name', 'description', 'harnessId', 'harnessName', 'harnessProvider', 'harnessStatus', 'executionReadiness', 'updatedAt', 'url'],
     task: [
         'id',
         'identifier',
@@ -61,6 +63,10 @@ exports.COMPACT_FIELDS = {
         'version',
         'executionMode',
         'nextAction',
+        'actionability',
+        'execution',
+        // Present only on a `--rank economics` page: the score the row was sorted by (OSK-16476).
+        'economicsRank',
         'createdAt',
         'updatedAt',
         'url',
@@ -144,13 +150,15 @@ function projectRow(row, fields) {
     return out;
 }
 /**
- * Normalize any list response to the shared envelope. `data` is where rows live
- * for every list command; `projects` (an older serialization) is folded into it.
+ * Normalize a list response to the shared envelope. Each command explicitly
+ * supplies its legacy row key when needed; named keys remain compatible.
+ * The original projects adapter continues folding its old key into `data`.
  * A response that is not list-shaped is returned untouched (never invent rows).
  */
-function toListEnvelope(response) {
+function toListEnvelope(response, rowKey) {
     if (Array.isArray(response)) {
         return {
+            ok: true,
             object: 'list',
             data: response,
             has_more: false,
@@ -160,25 +168,44 @@ function toListEnvelope(response) {
     if (!response || typeof response !== 'object')
         return undefined;
     const r = response;
-    const rows = Array.isArray(r.data) ? r.data : Array.isArray(r.projects) ? r.projects : undefined;
+    const rows = Array.isArray(r.data)
+        ? r.data
+        : rowKey && Array.isArray(r[rowKey])
+            ? r[rowKey]
+            : Array.isArray(r.projects)
+                ? r.projects
+                : undefined;
     if (!rows)
         return undefined;
+    const nextCursor = r.next_cursor ?? r.nextCursor ?? r.nextAfterId ?? r.after;
     const { projects: _legacy, ...rest } = r;
     void _legacy;
     return {
-        ...rest,
+        ...(0, json_output_1.withOk)(rest),
         object: 'list',
         data: rows,
-        has_more: typeof r.has_more === 'boolean' ? r.has_more : Boolean(r.next_cursor),
-        next_cursor: typeof r.next_cursor === 'string' ? r.next_cursor : null,
+        has_more: typeof r.has_more === 'boolean'
+            ? r.has_more
+            : typeof r.hasMore === 'boolean'
+                ? r.hasMore
+                : Boolean(nextCursor),
+        next_cursor: typeof nextCursor === 'string' ? nextCursor : null,
     };
 }
+/** Explicit command boundary: retain unknown responses rather than inventing empty rows.
+ * Named row keys remain available for existing consumers during migration. */
+function listResult(response, rowKey) {
+    return toListEnvelope(response, rowKey) ?? (0, json_output_1.withOk)(response);
+}
 /** Pure: envelope + projection + notes. Returns the response untouched if not a list. */
 function shapeListResponse(response, options) {
     const envelope = toListEnvelope(response);
     if (!envelope)
         return response;
-    const warnings = [...(options.warnings ?? [])];
+    const warnings = [
+        ...(Array.isArray(envelope.warnings) ? envelope.warnings : []),
+        ...(options.warnings ?? []),
+    ];
     const fields = parseFields(options.fields);
     let data = envelope.data;
     if (fields) {
@@ -277,7 +304,9 @@ function renderListOutput(shaped, ndjson) {
     if (!envelope || !Array.isArray(envelope.data)) {
         return { stdout: [JSON.stringify(shaped)], stderr: [] };
     }
-    const { data, ...meta } = envelope;
+    const { data, ...metadata } = envelope;
+    // Compatibility row aliases are not metadata and must not duplicate the rows.
+    const meta = Object.fromEntries(Object.entries(metadata).filter(([, value]) => value !== data));
     return {
         stdout: data.map((row) => JSON.stringify(row)),
         stderr: [JSON.stringify({ _meta: meta })],

package/dist/lib/lookbackPlans.d.ts

@@ -0,0 +1,13 @@
+import { lookbackPlansApi, type CreateLookbackPlanRequest, type LookbackPlan, type LookbackPlanInput } from '@skrr-ai/data-provider';
+export { lookbackPlansApi };
+export declare const lookbackPlanIdArg: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+/** JSON can be the plan itself or the canonical create envelope. Never copy identity fields. */
+export declare function lookbackCreateBody(input: Record<string, unknown>, explicitAgentId?: string): CreateLookbackPlanRequest;
+/** Validate time forms locally; admission time and authorization remain server authoritative. */
+export declare function lookbackInput(raw: unknown, allowPast?: boolean): LookbackPlanInput;
+export declare function lookbackPlanSummary(plan: LookbackPlan): string;
+export declare function lookbackArmingLine(result: {
+    plan: LookbackPlan;
+    reused?: boolean;
+    armed: boolean;
+}): string;

package/dist/lib/lookbackPlans.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookbackPlanIdArg = exports.lookbackPlansApi = void 0;
+exports.lookbackCreateBody = lookbackCreateBody;
+exports.lookbackInput = lookbackInput;
+exports.lookbackPlanSummary = lookbackPlanSummary;
+exports.lookbackArmingLine = lookbackArmingLine;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+Object.defineProperty(exports, "lookbackPlansApi", { enumerable: true, get: function () { return data_provider_1.lookbackPlansApi; } });
+const followups_1 = require("./followups");
+exports.lookbackPlanIdArg = core_1.Args.string({
+    description: 'Lookback plan id', required: true, ignoreStdin: true,
+    parse: async (value) => {
+        if (!value.trim())
+            throw new Error('Plan id is empty; see `skrr followups plans list`');
+        return value.trim();
+    },
+});
+/** JSON can be the plan itself or the canonical create envelope. Never copy identity fields. */
+function lookbackCreateBody(input, explicitAgentId) {
+    const envelope = Object.prototype.hasOwnProperty.call(input, 'plan');
+    const allowed = envelope
+        ? ['agentId', 'plan', 'endpointId', 'endpointTarget', 'pinnedConversationId']
+        : ['title', 'objective', 'stopCondition', 'timezone', 'source', 'steps'];
+    const unknown = Object.keys(input).filter((key) => !allowed.includes(key));
+    if (unknown.length)
+        throw new Error(`Unknown lookback input fields: ${unknown.join(', ')}`);
+    if (envelope) {
+        for (const field of ['agentId', 'endpointId', 'endpointTarget', 'pinnedConversationId']) {
+            if (input[field] !== undefined && (typeof input[field] !== 'string' || !input[field].trim())) {
+                throw new Error(`${field} must be a non-empty string`);
+            }
+        }
+    }
+    const inputAgent = typeof input.agentId === 'string' ? input.agentId : undefined;
+    if (explicitAgentId && inputAgent && explicitAgentId !== inputAgent) {
+        throw new Error('--agent conflicts with agentId in the input');
+    }
+    const agent = (0, followups_1.resolveFollowUpAgent)(explicitAgentId || inputAgent);
+    return {
+        agentId: agent.id,
+        producer: agent.boundToSession ? 'agent_in_turn' : 'user_explicit',
+        plan: lookbackInput(envelope ? input.plan : input),
+        ...(envelope && input.endpointId !== undefined ? { endpointId: input.endpointId } : {}),
+        ...(envelope && input.endpointTarget !== undefined ? { endpointTarget: input.endpointTarget } : {}),
+        ...(envelope && input.pinnedConversationId !== undefined
+            ? { pinnedConversationId: input.pinnedConversationId } : {}),
+    };
+}
+/** Validate time forms locally; admission time and authorization remain server authoritative. */
+function lookbackInput(raw, allowPast = false) {
+    const parsed = (0, data_provider_1.normalizeLookbackPlanInput)(raw, { allowPast });
+    if (!parsed.ok)
+        throw new Error(`${parsed.code}: ${parsed.message}`);
+    // Send only authored fields. The server fixes normalized times, generated
+    // step IDs, lifecycle and ownership; CLI must not forge those projections.
+    return raw;
+}
+function lookbackPlanSummary(plan) {
+    const next = plan.steps.find((step) => step.state === 'pending');
+    return `${plan.id}  [${plan.state}] r${plan.revision}  ${plan.title || plan.objective}` +
+        `  ${plan.steps.length} lookbacks${next ? `  next:${next.runAt}` : ''}`;
+}
+function lookbackArmingLine(result) {
+    const status = result.armed ? 'armed' : 'saved; scheduling is pending';
+    return `Lookback plan ${result.plan.id} ${status}${result.reused ? ' (existing plan)' : ''}.`;
+}

package/dist/lib/machines.d.ts

@@ -1,3 +1,4 @@
+import type { DaemonContactState } from '@skrr-ai/data-provider';
 /**
  * machines.ts — request client for `/api/machines`.
  *
@@ -62,6 +63,17 @@ export interface MachineHarnessRow {
     stale?: boolean;
     /** How long that row has been silent, in ms. Present with `stale`. */
     staleForMs?: number;
+    /**
+     * Recorded `online`, and the server saw the daemon's connection CLOSE with no
+     * heartbeat since: it is waiting out the grace before recording the daemon
+     * offline (`MachineContact.reconnectGraceMs`). A laptop that wakes, a network
+     * that blips and an API replica that restarts all come back inside it; a daemon
+     * stopped on purpose does not, and goes `offline` when it runs out. Present only
+     * when true (OSK-16442).
+     */
+    reconnecting?: boolean;
+    /** How long ago the connection closed, in ms. Present with `reconnecting`. */
+    disconnectedForMs?: number;
 }
 /**
  * What a machine's heartbeats say, apart from what its rows are recorded as
@@ -70,18 +82,24 @@ export interface MachineHarnessRow {
  * `online` for a process that had not been heard from in a minute.
  *
  * - `live`: a row is online and heard from recently.
+ * - `reconnecting`: the server saw a daemon's connection close and is waiting for
+ *   it to come back. The machine's `status` is `degraded` meanwhile.
  * - `stale`: rows are recorded online, but none has been heard from for
  *   `staleAfterMs`. The machine's `status` is `degraded` meanwhile.
  * - `offline`: nothing is recorded online.
  *
  * The thresholds are the server's, sent so this CLI never restates them. Absent
- * on a server older than this field and on a lease-backed machine.
+ * on a server older than this field and on a lease-backed machine. The two
+ * `...ForMs` fields and `reconnectGraceMs` arrived after the first version of the
+ * object, so a server one release older omits them.
  */
 export interface MachineContact {
-    state: 'live' | 'stale' | 'offline';
+    state: DaemonContactState;
     staleForMs: number | null;
+    disconnectedForMs?: number | null;
     staleAfterMs: number;
     offlineAfterMs: number;
+    reconnectGraceMs?: number;
 }
 export interface Machine {
     id: string;
@@ -190,11 +208,12 @@ export interface MachineDaemonSummary {
     /** How it was launched (`cli`, `launchd`, …); null when the id does not say. */
     source: string | null;
     /**
-     * `online` when any registration is online and heard from recently, `stale`
-     * when some are recorded online but none has been heard from lately, `offline`
-     * otherwise.
+     * `online` when any registration is online and heard from recently,
+     * `reconnecting` when the server saw its connection close and is waiting,
+     * `stale` when some are recorded online but none has been heard from lately,
+     * `offline` otherwise.
      */
-    status: 'online' | 'stale' | 'offline';
+    status: 'online' | 'reconnecting' | 'stale' | 'offline';
     lastSeenAt: string | null;
     harnessCount: number;
     /** Of those, how many a newer registration of the same provider replaced. */
@@ -206,6 +225,8 @@ export declare function parseDaemonId(daemonId: string): {
     source: string;
     profile: string;
 } | null;
+/** The word the tables print for one harness row: the server's statement, not the bare status. */
+export declare function harnessStateLabel(row: MachineHarnessRow): string;
 export declare function summarizeDaemons(harnesses: readonly MachineHarnessRow[], activeProfile: string): MachineDaemonSummary[];
 /** Whether the machine's identity is THIS computer's (the default profile's, or a profile qualified from it). */
 export declare function isThisComputer(machine: Machine, hardwareMachineUuid: string): boolean;

package/dist/lib/machines.js

@@ -6,6 +6,7 @@ exports.isReachableMachine = isReachableMachine;
 exports.isOwnComputer = isOwnComputer;
 exports.isListedByDefault = isListedByDefault;
 exports.parseDaemonId = parseDaemonId;
+exports.harnessStateLabel = harnessStateLabel;
 exports.summarizeDaemons = summarizeDaemons;
 exports.isThisComputer = isThisComputer;
 exports.machineListView = machineListView;
@@ -15,6 +16,7 @@ exports.getMachine = getMachine;
 exports.updateMachine = updateMachine;
 exports.disconnectMachine = disconnectMachine;
 exports.resolveMachineRef = resolveMachineRef;
+const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("./api-fetch");
 /**
  * What a machine's state actually is, when `offline` is doing two jobs.
@@ -31,11 +33,15 @@ const api_fetch_1 = require("./api-fetch");
  * could come back says so, and a destroyed one cannot.
  */
 function machineStateLabel(machine) {
-    // `degraded` is the machine's status while a daemon is silent, and it reads the
-    // same as a sign-in problem or one provider being down. The server says which
-    // it is; the word a person reads is that one (OSK-16442).
-    if (machine.status === 'degraded' && machine.contact?.state === 'stale')
-        return 'stale';
+    // `degraded` is the machine's status while a daemon is silent or its connection
+    // has just closed, and it reads the same as a sign-in problem or one provider
+    // being down. The server says which it is; the word a person reads is that one
+    // (OSK-16442).
+    if (machine.status === 'degraded') {
+        const contact = machine.contact?.state;
+        if (contact === 'stale' || contact === 'reconnecting')
+            return data_provider_1.DAEMON_CONTACT_WORDS[contact];
+    }
     if (machine.status !== 'offline')
         return machine.status;
     // A computer somebody installed a daemon on has no lease to resume and nothing
@@ -132,6 +138,11 @@ function newerStamp(a, b) {
         return a;
     return new Date(b).getTime() > new Date(a).getTime() ? b : a;
 }
+const RANK = { online: 0, reconnecting: 1, stale: 2, offline: 3 };
+/** The word the tables print for one harness row: the server's statement, not the bare status. */
+function harnessStateLabel(row) {
+    return data_provider_1.DAEMON_CONTACT_WORDS[(0, data_provider_1.daemonContactOfRow)(row)];
+}
 function summarizeDaemons(harnesses, activeProfile) {
     const byDaemon = new Map();
     for (const row of harnesses) {
@@ -152,18 +163,18 @@ function summarizeDaemons(harnesses, activeProfile) {
         entry.harnessCount += 1;
         if (row.superseded === true)
             entry.supersededCount += 1;
-        if (row.status === 'online') {
-            if (row.stale !== true)
-                entry.status = 'online';
-            else if (entry.status === 'offline')
-                entry.status = 'stale';
-        }
+        // The server's statement for this row, read, not recomputed. A daemon is as
+        // heard-from as its best row.
+        const state = (0, data_provider_1.daemonContactOfRow)(row);
+        const rowStatus = state === 'live' ? 'online' : state;
+        if (RANK[rowStatus] < RANK[entry.status])
+            entry.status = rowStatus;
         entry.lastSeenAt = newerStamp(entry.lastSeenAt, row.lastSeenAt);
         byDaemon.set(row.daemonId, entry);
     }
-    // Connected first, then silent, then gone, each by most recently seen: the one a
-    // person is looking for is on top.
-    const rank = { online: 0, stale: 1, offline: 2 };
+    // Connected first, then waiting on a reconnect, then silent, then gone, each by
+    // most recently seen: the one a person is looking for is on top.
+    const rank = RANK;
     return [...byDaemon.values()].sort((a, b) => {
         if (a.status !== b.status)
             return rank[a.status] - rank[b.status];

package/dist/lib/member-output.d.ts

@@ -0,0 +1,20 @@
+/** Member discovery promises identity and access, not image transport credentials. */
+export declare const memberImageFlags: {
+    'include-images': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+/** Only the explicit image flag expands a member; --raw affects storage fields only. */
+export declare function memberAvatar(raw: {
+    avatar?: unknown;
+} | null | undefined, includeImages?: boolean): {
+    avatar?: string;
+};
+/** Allowlist scalar fields so future provider additions cannot inflate routine logs. */
+export declare function projectMemberPrincipal(raw: Record<string, unknown>, includeImages?: boolean): Record<string, unknown>;
+/** Do not spread provider metadata: it can carry another copy of a raw principal. */
+export declare function projectSpaceMembership(response: {
+    resourceType: string;
+    resourceId: string;
+    principals: Array<Record<string, unknown>>;
+    public: boolean;
+    publicAccessRoleId?: string;
+}, includeImages?: boolean): Record<string, unknown>;

package/dist/lib/member-output.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memberImageFlags = void 0;
+exports.memberAvatar = memberAvatar;
+exports.projectMemberPrincipal = projectMemberPrincipal;
+exports.projectSpaceMembership = projectSpaceMembership;
+const core_1 = require("@oclif/core");
+/** Member discovery promises identity and access, not image transport credentials. */
+exports.memberImageFlags = {
+    'include-images': core_1.Flags.boolean({
+        description: 'Include avatar URLs in JSON. These may be temporary signed URLs containing authorization query parameters; avoid recording or sharing them.',
+        default: false,
+    }),
+};
+/** Only the explicit image flag expands a member; --raw affects storage fields only. */
+function memberAvatar(raw, includeImages = false) {
+    return includeImages && typeof raw?.avatar === 'string'
+        ? { avatar: raw.avatar }
+        : {};
+}
+const PRINCIPAL_FIELDS = [
+    'type',
+    'id',
+    'idOnTheSource',
+    'name',
+    'email',
+    'source',
+    'accessRoleId',
+    'memberCount',
+    'harnessProvider',
+    'harnessName',
+    'harnessStatus',
+    'harnessLastSeenAt',
+];
+/** Allowlist scalar fields so future provider additions cannot inflate routine logs. */
+function projectMemberPrincipal(raw, includeImages = false) {
+    const member = {};
+    for (const field of PRINCIPAL_FIELDS) {
+        const value = raw[field];
+        if (typeof value === 'string' || typeof value === 'number' || value === null) {
+            member[field] = value;
+        }
+    }
+    return { ...member, ...memberAvatar(raw, includeImages) };
+}
+/** Do not spread provider metadata: it can carry another copy of a raw principal. */
+function projectSpaceMembership(response, includeImages = false) {
+    return {
+        resourceType: response.resourceType,
+        resourceId: response.resourceId,
+        principals: response.principals.map((member) => projectMemberPrincipal(member, includeImages)),
+        public: response.public,
+        ...(response.publicAccessRoleId === undefined
+            ? {}
+            : { publicAccessRoleId: response.publicAccessRoleId }),
+    };
+}

package/dist/lib/preflight-copy.d.ts

@@ -16,6 +16,13 @@ type GateLike = {
 export declare function sourceRefusalWords(code: string): string;
 /** Extra lines under a gate, or none. The gate's own note is printed by the caller. */
 export declare function gateExplanationLines(gate: GateLike): string[];
+/**
+ * One line per execution target under "Is there somewhere else it can run?" (OSK-17003): the
+ * product, consent, contract and reachability the resolver would apply. The gate used to report a
+ * bare `fallbackCandidates` count, which read the same for a fallback that could take the run and
+ * one that never could. Nothing is printed for a single primary — the gate's note says that.
+ */
+export declare function placementTargetLines(gate: GateLike): string[];
 /**
  * The status word for a capability. A credential whose expiry has passed is `expired`, not the
  * storage word `stale`, which gave no sign that time had run out.