@skrr-ai/cli 0.1.130 → 0.1.132

package/dist/commands/agent/message/send.d.ts

@@ -118,6 +118,8 @@ export default class AgentMessageSend extends BaseCommand {
     private submitAsSession;
     private submitAsHuman;
 }
+/** Keep stdout machine-readable while making a slow delivery visible. */
+export declare function withSendWaitNotice<T>(send: () => Promise<T>): Promise<T>;
 export type NormalizedIntentPayload = {
     destination: CanonicalMessageDestination;
     content: {

package/dist/commands/agent/message/send.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXIT_DELIVERY_FAILED = exports.EXIT_DELIVERY_RETRYABLE = exports.OWNER_DM_SEGMENTATION_SOFT_LIMIT = void 0;
+exports.withSendWaitNotice = withSendWaitNotice;
 exports.messageSegmentationAdvisory = messageSegmentationAdvisory;
 exports.buildSequencedRequests = buildSequencedRequests;
 exports.deliveryExitCode = deliveryExitCode;
@@ -308,30 +309,33 @@ class AgentMessageSend extends base_command_1.BaseCommand {
                 'session claim, not the request. To change it, run the task from a space in ' +
                 'the intended workspace.');
         }
-        const envelopes = [];
-        let halt;
-        for (const [index, requestPart] of requests.entries()) {
-            const envelope = sessionContext
-                ? await this.submitAsSession({
-                    sessionContext,
-                    request: requestPart,
-                    agentIdentity: agentIdentity,
-                    principalSource,
-                })
-                : await this.submitAsHuman({
-                    request: requestPart,
-                    agentIdentity: agentIdentity,
-                    principalSource,
-                });
-            envelopes.push(envelope);
-            // A part that did not reach the user must stop the sequence. Continuing
-            // would deliver thought 3 while thought 2 sits held for approval, and the
-            // user would read the update out of order — worse than not receiving the
-            // tail at all.
-            halt = sequenceHalt({ envelope, sentCount: index + 1, totalParts: requests.length });
-            if (halt)
-                break;
-        }
+        const { envelopes, halt } = await withSendWaitNotice(async () => {
+            const envelopes = [];
+            let halt;
+            for (const [index, requestPart] of requests.entries()) {
+                const envelope = sessionContext
+                    ? await this.submitAsSession({
+                        sessionContext,
+                        request: requestPart,
+                        agentIdentity: agentIdentity,
+                        principalSource,
+                    })
+                    : await this.submitAsHuman({
+                        request: requestPart,
+                        agentIdentity: agentIdentity,
+                        principalSource,
+                    });
+                envelopes.push(envelope);
+                // A part that did not reach the user must stop the sequence. Continuing
+                // would deliver thought 3 while thought 2 sits held for approval, and the
+                // user would read the update out of order — worse than not receiving the
+                // tail at all.
+                halt = sequenceHalt({ envelope, sentCount: index + 1, totalParts: requests.length });
+                if (halt)
+                    break;
+            }
+            return { envelopes, halt };
+        });
         if (flags.json) {
             // Branch on the REQUESTED part count, not the sent count: a sequence that
             // halted on its first part still has to report the parts it skipped.
@@ -524,6 +528,18 @@ class AgentMessageSend extends base_command_1.BaseCommand {
     }
 }
 exports.default = AgentMessageSend;
+/** Keep stdout machine-readable while making a slow delivery visible. */
+async function withSendWaitNotice(send) {
+    const timer = setTimeout(() => {
+        process.stderr.write('Waiting for the message outcome; the request is still in progress.\n');
+    }, 3000);
+    try {
+        return await send();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 // Re-export the module-scope `request.post` under a local name so the transport
 // helper stays testable without pulling the whole data-provider surface into
 // scope inside every helper file.
@@ -747,6 +763,14 @@ function normalizeIntentPayload({ agentId, jsonBody, merged, }) {
     const overlayChannel = optionalString(merged.channelId);
     const overlayThreadTs = optionalString(merged.threadTs);
     const destinationKind = pickDestinationKind({ bodyDestination, overlayKind });
+    if (destinationKind !== 'slack_channel' && (overlayThreadTs || bodyDestination?.threadTs)) {
+        throw invalidIntent('--thread-ts / destination.threadTs only applies to slack_channel.');
+    }
+    if (destinationKind !== 'agent_email' &&
+        (merged.recipients !== undefined || merged.subject !== undefined ||
+            bodyDestination?.recipients !== undefined || bodyDestination?.subject !== undefined)) {
+        throw invalidIntent('--to / destination.recipients and --subject / destination.subject only apply to agent_email.');
+    }
     const destination = buildDestination({
         kind: destinationKind,
         bodyDestination,

package/dist/commands/agents/plan-day.d.ts

@@ -28,6 +28,7 @@ export default class AgentsPlanDay extends BaseCommand {
         'hours-start': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'hours-end': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'approve-next-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'save-hours': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
@@ -44,10 +45,9 @@ export default class AgentsPlanDay extends BaseCommand {
     private fetchPending;
     private workingHoursOverride;
     /**
-     * Statuses that mean "the request ran out of time", not "the request was
-     * refused". Only these are recoverable by reading the durable draft: a 4xx
-     * means no generation started, and a 500 means the route itself failed, so
-     * polling would just report an absence as if it were a timeout.
+     * Gateway failures can interrupt a response after the planner started.
+     * Check the durable draft before suggesting another billable request; a
+     * 502 can also mean the planner never started, so do not assert that it did.
      */
     private static readonly TIMEOUT_STATUSES;
     /** Bounded, honest recovery poll. A daemon-run plan lands in ~2-4 minutes. */

package/dist/commands/agents/plan-day.js

@@ -45,6 +45,10 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         'hours-start': core_1.Flags.string({ description: 'Working-hours start (HH:MM) for the proposal' }),
         'hours-end': core_1.Flags.string({ description: 'Working-hours end (HH:MM) for the proposal' }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for the working-hours window' }),
+        'approve-next-run': core_1.Flags.boolean({
+            description: 'With --approve, schedule the suggested next planning run',
+            dependsOn: ['approve'],
+        }),
         'save-hours': core_1.Flags.boolean({
             description: 'On --approve, persist the working-hours window as the agent default',
         }),
@@ -53,6 +57,14 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(AgentsPlanDay);
         const agentId = args.id;
+        if (!flags.dismiss && !flags.approve && flags.timezone) {
+            try {
+                new Intl.DateTimeFormat('en', { timeZone: flags.timezone });
+            }
+            catch {
+                this.error(`Invalid IANA timezone: ${flags.timezone}`, { exit: 1 });
+            }
+        }
         try {
             if (flags.dismiss) {
                 await this.runDismiss(agentId, flags.json);
@@ -120,12 +132,11 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         };
     }
     /**
-     * Statuses that mean "the request ran out of time", not "the request was
-     * refused". Only these are recoverable by reading the durable draft: a 4xx
-     * means no generation started, and a 500 means the route itself failed, so
-     * polling would just report an absence as if it were a timeout.
+     * Gateway failures can interrupt a response after the planner started.
+     * Check the durable draft before suggesting another billable request; a
+     * 502 can also mean the planner never started, so do not assert that it did.
      */
-    static TIMEOUT_STATUSES = new Set([408, 504, 524]);
+    static TIMEOUT_STATUSES = new Set([408, 502, 504, 524]);
     /** Bounded, honest recovery poll. A daemon-run plan lands in ~2-4 minutes. */
     static RECOVERY_ATTEMPTS = 12;
     static RECOVERY_INTERVAL_MS = 15_000;
@@ -141,9 +152,8 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
             return null;
         }
         // stderr, so `--json` stdout stays a single parseable document.
-        this.warn(`Plan generation for ${agentId} outlived the request (HTTP ${status}). ` +
-            'The run is still finishing on the agent runtime and the draft is persisted when it ' +
-            'completes — waiting for it rather than starting a second run.');
+        this.warn(`The plan request for ${agentId} was interrupted (HTTP ${status}). ` +
+            'The run may still be finishing; checking for its saved draft before starting another.');
         for (let attempt = 1; attempt <= AgentsPlanDay.RECOVERY_ATTEMPTS; attempt += 1) {
             await new Promise((resolve) => setTimeout(resolve, AgentsPlanDay.RECOVERY_INTERVAL_MS));
             let pending = null;
@@ -181,6 +191,7 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
             try {
                 generated = await schedule_1.scheduleApi.proposeSmartSchedule({
                     agentId,
+                    ...(flags.timezone ? { timezone: flags.timezone } : {}),
                     ...(this.workingHoursOverride(flags)
                         ? { workingHoursOverride: this.workingHoursOverride(flags) }
                         : {}),
@@ -216,6 +227,9 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         this.log('');
         this.log('This is a draft — nothing is scheduled yet.');
         this.log(`  Approve:  ${this.config.bin} agents plan-day ${agentId} --approve`);
+        if (proposal.nextRunSuggestion) {
+            this.log(`  Include next run: ${this.config.bin} agents plan-day ${agentId} --approve --approve-next-run`);
+        }
         this.log(`  Discard:  ${this.config.bin} agents plan-day ${agentId} --dismiss`);
     }
     async runApprove(agentId, flags) {
@@ -224,13 +238,20 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
             this.error(`No pending plan for agent ${agentId}. Run \`${this.config.bin} agents plan-day ${agentId}\` first.`, { exit: 4 });
         }
         const todos = (0, schedule_1.proposalToApproveTodos)(proposal);
-        if (todos.length === 0) {
-            this.error('The pending proposal has no schedulable to-dos to approve.', { exit: 1 });
+        if (flags['approve-next-run'] && !proposal.nextRunSuggestion) {
+            this.error('The pending proposal has no suggested next run to approve.', { exit: 1 });
+        }
+        if (todos.length === 0 && !flags['approve-next-run']) {
+            const next = proposal.nextRunSuggestion
+                ? ` Use --approve --approve-next-run to schedule its suggested next run, or --dismiss to discard it.`
+                : ' Use --dismiss to discard it.';
+            this.error(`The pending proposal has no schedulable to-dos.${next}`, { exit: 1 });
         }
         const result = await schedule_1.scheduleApi.approveSmartSchedule({
             agentId,
             proposalId: proposal.proposalId,
             todos,
+            ...(flags['approve-next-run'] ? { approveNextRunSuggestion: true } : {}),
             ...(flags['save-hours']
                 ? { saveHoursAsDefault: true, workingHours: proposal.workingHours }
                 : {}),
@@ -254,6 +275,11 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         }
         this.log(`Approved plan ${proposal.proposalId}: created ${result.created.length} to-do(s).`);
         (0, schedule_1.renderCapacityWarning)(result.capacity, (line) => this.log(line));
+        if (flags['approve-next-run']) {
+            this.log(result.scheduledNextRun?.created
+                ? `Next planning run scheduled${result.scheduledNextRun.triggerId ? ` (${result.scheduledNextRun.triggerId})` : ''}.`
+                : `Next planning run was not created${result.scheduledNextRun?.message || result.scheduledNextRun?.skippedReason ? `: ${result.scheduledNextRun.message || result.scheduledNextRun.skippedReason}` : '.'}`);
+        }
         if (result.failed.length > 0) {
             this.log(`${result.failed.length} failed:`);
             for (const f of result.failed) {

package/dist/commands/agents/schedule-overview.d.ts

@@ -42,3 +42,17 @@ export declare function reflectionLine(reflection: TriggerDefinition): string;
  * else null. "active · next <time>" only says the loop is armed.
  */
 export declare function reflectionNoteLine(reflection: TriggerDefinition, bin: string): string | null;
+/** A trigger the Always-On control fence withholds, as `/api/upcoming` reports it. */
+export interface WithheldTrigger {
+    label?: string;
+    reason?: string;
+    reasonText?: string;
+    indeterminate?: boolean;
+}
+/**
+ * One withheld trigger as the text view prints it. The sentence the server wrote
+ * (`reasonText`: "Always-On is off for this agent") is printed rather than the code,
+ * because `disabled` alone reads as a property of the trigger when the cause is the
+ * agent's Always-On switch. A server that predates `reasonText` still prints the code.
+ */
+export declare function withheldLine(trigger: WithheldTrigger): string;

package/dist/commands/agents/schedule-overview.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reflectionSummary = reflectionSummary;
 exports.reflectionLine = reflectionLine;
 exports.reflectionNoteLine = reflectionNoteLine;
+exports.withheldLine = withheldLine;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
@@ -126,7 +127,7 @@ class AgentsScheduleOverview extends base_command_1.BaseCommand {
             this.log('');
             this.log(`  ${blockedUpcoming.length} trigger(s) withheld — they will not fire as configured:`);
             for (const b of blockedUpcoming.slice(0, 8)) {
-                this.log(`    ${b.label ?? '(unlabeled)'} — ${b.reason ?? 'blocked'}`);
+                this.log(withheldLine(b));
             }
             if (blockedUpcoming.length > 8) {
                 this.log(`    … and ${blockedUpcoming.length - 8} more`);
@@ -214,6 +215,15 @@ function reflectionNoteLine(reflection, bin) {
     const note = (0, reflection_1.reflectionAutonomyNote)(reflection, bin);
     return note ? `  Note: ${note}` : null;
 }
+/**
+ * One withheld trigger as the text view prints it. The sentence the server wrote
+ * (`reasonText`: "Always-On is off for this agent") is printed rather than the code,
+ * because `disabled` alone reads as a property of the trigger when the cause is the
+ * agent's Always-On switch. A server that predates `reasonText` still prints the code.
+ */
+function withheldLine(trigger) {
+    return `    ${trigger.label ?? '(unlabeled)'} — ${trigger.reasonText ?? trigger.reason ?? 'blocked'}`;
+}
 function settledValue(result) {
     return result.status === 'fulfilled' ? result.value : undefined;
 }

package/dist/commands/agents/schedule-trace.js

@@ -25,7 +25,7 @@ class AgentsScheduleTrace extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        date: core_1.Flags.string({ description: 'Plan date (YYYY-MM-DD). Defaults to today.' }),
+        date: core_1.Flags.string({ description: 'Plan date (YYYY-MM-DD). Defaults to today in the plan timezone.' }),
         todo: core_1.Flags.string({ description: 'Scope the trace to one to-do' }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for the plan day' }),
         limit: core_1.Flags.integer({ description: 'Events to return (1-200)' }),
@@ -34,16 +34,25 @@ class AgentsScheduleTrace extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(AgentsScheduleTrace);
-        // The server requires a plan date. Defaulting to today locally keeps the
-        // common call a single argument rather than a date the caller must know.
-        const date = flags.date ?? new Date().toISOString().slice(0, 10);
+        // Use the same zone for choosing the day and querying its events. UTC can
+        // already be tomorrow while it is still evening for the reader.
+        const timezone = flags.timezone ?? (flags.date ? undefined : Intl.DateTimeFormat().resolvedOptions().timeZone);
+        let date = flags.date;
+        if (!date) {
+            try {
+                date = (0, schedule_1.scheduleTraceToday)(new Date(), timezone);
+            }
+            catch {
+                this.error(`Invalid IANA timezone: ${timezone}`, { exit: 1 });
+            }
+        }
         let trace;
         try {
             trace = await schedule_1.scheduleApi.scheduleTrace({
                 agentId: args.agent,
                 date,
                 todoId: flags.todo,
-                timezone: flags.timezone,
+                timezone,
                 limit: flags.limit,
                 cursor: flags.cursor,
             });

package/dist/commands/agents/todos/list.d.ts

@@ -13,6 +13,7 @@ export default class AgentsTodosList extends BaseCommand {
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         date: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/agents/todos/list.js

@@ -21,14 +21,15 @@ class AgentsTodosList extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        date: core_1.Flags.string({ description: 'Day to list (YYYY-MM-DD, UTC). Defaults to today.' }),
+        date: core_1.Flags.string({ description: 'Day to list (YYYY-MM-DD). Defaults to today in the selected timezone.' }),
+        timezone: core_1.Flags.string({ description: 'IANA timezone for the day (defaults to UTC)' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(AgentsTodosList);
         let response;
         try {
-            response = await schedule_1.scheduleApi.listTodos(args.id, flags.date);
+            response = await schedule_1.scheduleApi.listTodos(args.id, flags.date, flags.timezone);
         }
         catch (err) {
             this.handleApiError(err);
@@ -37,6 +38,7 @@ class AgentsTodosList extends base_command_1.BaseCommand {
             this.printJsonResult((0, list_output_1.listResult)(response, 'todos'));
             return;
         }
+        this.log(`Day timezone: ${flags.timezone || 'UTC'}`);
         (0, schedule_1.renderTodoList)(response.todos ?? [], (line) => this.log(line));
     }
 }

package/dist/commands/commitments/create.js

@@ -107,6 +107,19 @@ function assertEventDrivenWatchedSource(payload) {
         hasEventCapableWatchedSource(payload)) {
         return;
     }
+    const sources = Array.isArray(payload.watchedSources) ? payload.watchedSources : [];
+    const hasInvalidEvents = sources.some((value) => {
+        const source = record(value);
+        const config = record(source?.config);
+        return source?.enabled !== false && Array.isArray(config?.events) &&
+            !hasStructurallyValidExplicitEvent(config);
+    });
+    if (hasInvalidEvents) {
+        throw new Error('Event-driven cadence requires at least one event-capable watched source. ' +
+            'An explicit config.events list must contain event objects with non-empty entityType and eventType, ' +
+            'for example {"entityType":"github","eventType":"check_run_failed"}. ' +
+            'Supply valid bindings, or remove config.events to use the source defaults (which may include more events).');
+    }
     throw new Error('Event-driven cadence (--event-driven or --cadence-mode event_plus_interval) requires at least one event-capable watched source. ' +
         'Add --watch github (or another event-capable source), or choose an interval-only cadence.');
 }

package/dist/commands/daemon/install.js

@@ -56,6 +56,15 @@ class DaemonInstall extends core_1.Command {
         // own comment records `skrr code run -m <model>` dying the same way. Same
         // mistake, one directory over.
         const argv = this.argv;
+        // A forwarded help request is read-only. Do not run installation preflight,
+        // bind a profile, or download software just to show the runtime's options.
+        if (argv.some((arg) => arg === '--help' || arg === '-h')) {
+            if (!(0, exec_runtime_binary_1.isCurrentRuntimeBinary)((0, exec_runtime_binary_1.findRuntimeBinary)())) {
+                this.log('The background service is not installed, so its detailed install options are unavailable. Run `skrr daemon install` to install it.');
+                return;
+            }
+            this.exit(await (0, exec_runtime_binary_1.execRuntimeBinary)(['install', '--help']));
+        }
         // Before fetching anything: a machine still carrying the previous product
         // identity's state is refused by the runtime's own install, so downloading a
         // release first only delays the same refusal (OSK-6895).

package/dist/commands/harnesses/prune.d.ts

@@ -18,6 +18,7 @@ export default class HarnessesPrune extends BaseCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'older-than': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'include-gone-leases': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/harnesses/prune.js

@@ -30,12 +30,20 @@ class HarnessesPrune extends base_command_1.BaseCommand {
         'pinned row is KEPT, with the agents named. Move the pin (`agents attach-harness`) and run this again.\n\n' +
         'At most --limit rows are removed per run, oldest first; the rest are counted and the next run takes ' +
         'them. Running it again when nothing qualifies removes nothing. A daemon that is still running ' +
-        're-registers on its next connection, so removing a row never stops a machine.';
+        're-registers on its next connection, so removing a row never stops a machine.\n\n' +
+        'A hosted, dedicated or cloud machine belongs to its lease, so by default it is never touched. ' +
+        '--include-gone-leases also considers the rows of such a machine whose lease is GONE (archived, ' +
+        'terminating, terminated, failed or lost): no compute runs on it again, so the row can never come ' +
+        'back online. A row with no lease, a lease that can come back (stopped, ready, active) and a row ' +
+        'with usage recorded against it are kept, and so is everything the rules above keep. Use --older-than ' +
+        'to leave recent ones, for example 30d.';
     static examples = [
         '<%= config.bin %> harnesses prune',
         '<%= config.bin %> harnesses prune --yes',
         '<%= config.bin %> harnesses prune --yes --limit 20',
         '<%= config.bin %> harnesses prune --older-than 7d --json',
+        '<%= config.bin %> harnesses prune --include-gone-leases --older-than 30d',
+        '<%= config.bin %> harnesses prune --include-gone-leases --older-than 30d --yes --limit 200',
     ];
     static flags = {
         yes: core_1.Flags.boolean({
@@ -50,6 +58,10 @@ class HarnessesPrune extends base_command_1.BaseCommand {
         'older-than': core_1.Flags.string({
             description: 'Only rows unseen for at least this long: 90m, 36h or 7d (default 24h). The server never goes below its offline window.',
         }),
+        'include-gone-leases': core_1.Flags.boolean({
+            description: 'Also consider the rows of hosted, dedicated or cloud machines whose lease is gone. Off by default.',
+            default: false,
+        }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
     async run() {
@@ -71,6 +83,7 @@ class HarnessesPrune extends base_command_1.BaseCommand {
                 dryRun: !flags.yes,
                 ...(flags.limit !== undefined ? { limit: flags.limit } : {}),
                 ...(minUnseenMs !== undefined ? { minUnseenMs } : {}),
+                ...(flags['include-gone-leases'] ? { includeGoneLeases: true } : {}),
             });
         }
         catch (err) {
@@ -86,7 +99,9 @@ class HarnessesPrune extends base_command_1.BaseCommand {
     render(result) {
         const { dryRun } = result;
         const removing = dryRun ? result.remove.length : result.removedCount;
-        const noun = (n) => `${n} superseded harness row${n === 1 ? '' : 's'}`;
+        // "superseded" is only true of the personal-machine rows; a gone-lease row was not replaced by anything.
+        const kind = result.remove.some((row) => row.goneLease) ? '' : 'superseded ';
+        const noun = (n) => `${n} ${kind}harness row${n === 1 ? '' : 's'}`;
         if (dryRun) {
             this.log('Dry run - nothing was removed.');
         }
@@ -141,6 +156,9 @@ class HarnessesPrune extends base_command_1.BaseCommand {
         if (count('not_personal_machine') > 0) {
             passedOver.push(`${count('not_personal_machine')} hosted, dedicated, cloud or of unknown origin`);
         }
+        if (count('lease_not_gone') > 0) {
+            passedOver.push(`${count('lease_not_gone')} of a machine whose lease is not gone`);
+        }
         if (count('no_machine_identity') > 0) {
             passedOver.push(`${count('no_machine_identity')} that name no machine`);
         }
@@ -159,13 +177,15 @@ class HarnessesPrune extends base_command_1.BaseCommand {
             provider: (0, format_1.formatCell)(row.provider),
             daemon: (0, format_1.formatCell)(row.daemonId),
             seen: (0, format_1.localStamp)(row.lastSeenAt),
-            replacedBy: (0, format_1.formatCell)(row.supersededBy?.daemonId),
+            replacedBy: row.goneLease
+                ? `lease gone (${row.goneLease})`
+                : (0, format_1.formatCell)(row.supersededBy?.daemonId),
         })), [
             { key: 'id', header: 'HARNESS ID' },
             { key: 'provider', header: 'PROVIDER' },
             { key: 'daemon', header: 'DAEMON ID', verbatim: true },
             { key: 'seen', header: `LAST SEEN (${(0, format_1.localZone)()})` },
-            { key: 'replacedBy', header: 'REPLACED BY (ONLINE)', verbatim: true },
+            { key: 'replacedBy', header: 'REPLACED BY (ONLINE) / LEASE', verbatim: true },
         ], (line) => this.log(line));
     }
 }