@skrr-ai/cli 0.1.46 → 0.1.48

package/dist/commands/commitments/hypotheses.js

@@ -35,6 +35,9 @@ class CommitmentsHypotheses extends base_command_1.BaseCommand {
         'investigation-key': core_1.Flags.string({
             description: 'Narrow to one investigation (an open loop subject key)',
         }),
+        cursor: core_1.Flags.string({
+            description: 'Continue from the next_cursor emitted by a previous page',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -45,6 +48,7 @@ class CommitmentsHypotheses extends base_command_1.BaseCommand {
                 limit: flags.limit,
                 status: flags.status,
                 investigationKey: flags['investigation-key'],
+                cursor: flags.cursor,
             });
         }
         catch (err) {
@@ -52,9 +56,20 @@ class CommitmentsHypotheses extends base_command_1.BaseCommand {
         }
         if (flags.json) {
             this.log(JSON.stringify(response, null, 2));
-            return;
         }
-        (0, commitments_1.renderCommitmentHypotheses)(response, (line) => this.log(line));
+        else {
+            // A filtered-out list is not an empty ledger — say which filter did it
+            // (OSK-10953).
+            const filters = [
+                flags.status ? `--status ${flags.status}` : null,
+                flags['investigation-key'] ? `--investigation-key ${flags['investigation-key']}` : null,
+            ].filter(Boolean);
+            const emptyMessage = filters.length
+                ? `No hypotheses match ${filters.join(' ')}.`
+                : 'No hypotheses recorded.';
+            (0, commitments_1.renderCommitmentHypotheses)(response, (line) => this.log(line), { emptyMessage });
+        }
+        (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsHypotheses;

package/dist/commands/commitments/links/list.js

@@ -34,7 +34,10 @@ class CommitmentsLinksList extends base_command_1.BaseCommand {
             return;
         }
         for (const link of links) {
-            this.log(`${link.id}  ${link.targetType}:${link.target?.title || link.targetId}  [${link.roles.join(', ')}]  ${link.status}`);
+            // `origin: 'goal_lineage'` rows are derived from `goal.commitmentId`, not
+            // a work-link row — `links detach` cannot remove them (OSK-10960).
+            const provenance = link.origin === 'goal_lineage' ? '  (via goals link — remove with goals unlink)' : '';
+            this.log(`${link.id}  ${link.targetType}:${link.target?.title || link.targetId}  [${link.roles.join(', ')}]  ${link.status}${provenance}`);
         }
     }
 }

package/dist/commands/commitments/liveness.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr commitments liveness` — is the liveness witness itself alive?
+ *
+ * Per-commitment health is on `show`; this is the SWEEP's health — the marker
+ * the reconciler writes each pass. A stale sweep means every per-commitment
+ * verdict is also stale, which no single-commitment surface can tell you
+ * (OSK-10958). `healthy: false` or a null `lastSweepAt` means the witness is
+ * not running, not that commitments are fine.
+ */
+export default class CommitmentsLiveness extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/commitments/liveness.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const commitments_1 = require("../../lib/commitments");
+/**
+ * `skrr commitments liveness` — is the liveness witness itself alive?
+ *
+ * Per-commitment health is on `show`; this is the SWEEP's health — the marker
+ * the reconciler writes each pass. A stale sweep means every per-commitment
+ * verdict is also stale, which no single-commitment surface can tell you
+ * (OSK-10958). `healthy: false` or a null `lastSweepAt` means the witness is
+ * not running, not that commitments are fine.
+ */
+class CommitmentsLiveness extends base_command_1.BaseCommand {
+    static description = 'Show liveness sweep health — when the witness last ran and what it saw';
+    static examples = [
+        '<%= config.bin %> commitments liveness',
+        '<%= config.bin %> commitments liveness --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(CommitmentsLiveness);
+        let health;
+        try {
+            health = (await commitments_1.commitmentApi.livenessSweep());
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(health, null, 2));
+            return;
+        }
+        for (const line of formatSweepHealth(health))
+            this.log(line);
+    }
+}
+exports.default = CommitmentsLiveness;
+function formatSweepHealth(health) {
+    const lines = [];
+    if (!health.lastSweepAt) {
+        lines.push('Liveness sweep: NO SWEEP RECORDED');
+        lines.push('  The reconciler has never completed a sweep on this deployment —');
+        lines.push('  every per-commitment health verdict is unverified.');
+        return lines;
+    }
+    const age = health.sweepAgeSeconds ?? 0;
+    const status = health.healthy ? 'healthy' : 'STALE';
+    lines.push(`Liveness sweep: ${status} (${formatAge(age)} old)`);
+    lines.push(`  last sweep:    ${health.lastSweepAt}`);
+    const tick = health.lastTick;
+    if (tick) {
+        lines.push(`  last tick:     scanned ${tick.scanned ?? 0}` +
+            ` | on_track ${tick.onTrack ?? 0}` +
+            ` | stalled ${tick.stalled ?? 0}` +
+            ` | unknown ${tick.unknown ?? 0}` +
+            ` | unjudged ${tick.unjudged ?? 0}` +
+            ` | alerted ${tick.alerted ?? 0}` +
+            ` | errors ${tick.errors ?? 0}`);
+    }
+    if (health.cursor?.id) {
+        lines.push(`  cursor:        ${health.cursor.id}${health.cursor.at ? ` @ ${health.cursor.at}` : ''}`);
+    }
+    return lines;
+}
+function formatAge(seconds) {
+    if (seconds < 90)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 90)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ${minutes % 60}m`;
+    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+}

package/dist/commands/commitments/metrics.d.ts

@@ -15,6 +15,7 @@ export default class CommitmentsMetrics extends BaseCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/metrics.js

@@ -22,13 +22,19 @@ class CommitmentsMetrics extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         limit: core_1.Flags.integer({ description: 'Days to include', min: 1, max: 200 }),
+        cursor: core_1.Flags.string({
+            description: 'Continue from the next_cursor emitted by a previous page',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(CommitmentsMetrics);
         let response;
         try {
-            response = await commitments_1.commitmentApi.dailyMetrics(args.commitmentId, flags.limit);
+            response = await commitments_1.commitmentApi.dailyMetrics(args.commitmentId, {
+                limit: flags.limit,
+                cursor: flags.cursor,
+            });
         }
         catch (err) {
             this.handleApiError(err);
@@ -38,6 +44,7 @@ class CommitmentsMetrics extends base_command_1.BaseCommand {
             return;
         }
         (0, commitments_1.renderCommitmentMetrics)(response, (line) => this.log(line));
+        (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsMetrics;

package/dist/commands/commitments/next-tick.d.ts

@@ -0,0 +1,39 @@
+import { BaseCommand } from '../../base-command';
+import { type CommitmentNextTickProjection } from '../../lib/commitments';
+/**
+ * `skrr commitments next-tick <id>` — what the NEXT check would decide.
+ *
+ * Every other read on a commitment is retrospective: `checks` says what it
+ * decided, `receipt` says what one wake produced, `trigger-status` says when it
+ * will fire again. None of them answers the question an operator actually has
+ * when a commitment is about to nudge somebody — "what is it about to do, and
+ * on what grounds" — and the only way to find out used to be to run a real
+ * check, which changes the thing you were trying to observe.
+ *
+ * The server's projection stops at the DecisionEnvelope → Arbiter boundary: no
+ * Check row, no budget debit, no delivery gate, no contract write. That is what
+ * makes this safe to ask from a terminal, and it is why the envelope is only
+ * printed under `--json` — the decision and its policy trail are the answer;
+ * the envelope is the evidence behind it.
+ */
+export default class CommitmentsNextTick extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+/**
+ * Pure renderer for the next-tick projection.
+ *
+ * Kept separate from the command for the same reason `formatTriggerStatus` is:
+ * it can be unit-tested without a live API, and the command body stays a thin
+ * fetch + print. Defensive about every field — this is a projection of a
+ * versioned envelope, so a missing key is a shape change, not a reason to throw
+ * in front of somebody debugging a live commitment.
+ */
+export declare function formatNextTick(projection: CommitmentNextTickProjection): string[];

package/dist/commands/commitments/next-tick.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNextTick = formatNextTick;
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const commitments_1 = require("../../lib/commitments");
+/**
+ * `skrr commitments next-tick <id>` — what the NEXT check would decide.
+ *
+ * Every other read on a commitment is retrospective: `checks` says what it
+ * decided, `receipt` says what one wake produced, `trigger-status` says when it
+ * will fire again. None of them answers the question an operator actually has
+ * when a commitment is about to nudge somebody — "what is it about to do, and
+ * on what grounds" — and the only way to find out used to be to run a real
+ * check, which changes the thing you were trying to observe.
+ *
+ * The server's projection stops at the DecisionEnvelope → Arbiter boundary: no
+ * Check row, no budget debit, no delivery gate, no contract write. That is what
+ * makes this safe to ask from a terminal, and it is why the envelope is only
+ * printed under `--json` — the decision and its policy trail are the answer;
+ * the envelope is the evidence behind it.
+ */
+class CommitmentsNextTick extends base_command_1.BaseCommand {
+    static description = 'Preview what the next check would decide, without running one (no budget, no side effects)';
+    static examples = [
+        '<%= config.bin %> commitments next-tick obj_abc123',
+        '<%= config.bin %> commitments next-tick obj_abc123 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({
+            description: 'Output the full projection, including the DecisionEnvelope',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsNextTick);
+        let projection;
+        try {
+            projection = await commitments_1.commitmentApi.nextTick(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(projection, null, 2));
+            return;
+        }
+        for (const line of formatNextTick(projection))
+            this.log(line);
+    }
+}
+exports.default = CommitmentsNextTick;
+/**
+ * Pure renderer for the next-tick projection.
+ *
+ * Kept separate from the command for the same reason `formatTriggerStatus` is:
+ * it can be unit-tested without a live API, and the command body stays a thin
+ * fetch + print. Defensive about every field — this is a projection of a
+ * versioned envelope, so a missing key is a shape change, not a reason to throw
+ * in front of somebody debugging a live commitment.
+ */
+function formatNextTick(projection) {
+    const decision = projection.decision ?? {};
+    const lines = [
+        `Next tick for ${projection.commitmentId ?? '-'} (projected ${projection.projectedAt ?? '-'})`,
+        '',
+        // The header states what this did NOT do, because the value of the command
+        // is entirely in that: a reader who thinks a check just ran will misread
+        // every number on the commitment afterwards.
+        'Projection only — no check was recorded, no budget spent, no action routed.',
+        '',
+        `Posture:    ${decision.posture ?? '-'}`,
+        `Health:     ${decision.health ?? '-'}`,
+        `Risk:       ${decision.riskLevel ?? '-'}`,
+        `Confidence: ${decision.confidence ?? '-'}`,
+    ];
+    if (decision.whyNow)
+        lines.push(`Why now:    ${decision.whyNow}`);
+    // OSK-11433 — the projected envelope health is a delta read; the stored
+    // liveness verdict is the independent witness. Print the witness too so a
+    // dispatch-refusal loop can't hide behind an on_track projection.
+    if (projection.health || projection.liveness) {
+        const census = projection.liveness?.terminalDispositionCensus;
+        const detail = [
+            projection.liveness?.diagnosisKind,
+            census?.workFailures
+                ? `${census.workFailures} recent run failure${census.workFailures === 1 ? '' : 's'}`
+                : null,
+        ]
+            .filter(Boolean)
+            .join(', ');
+        lines.push(`Liveness:   ${projection.health ?? '-'}` + (detail ? ` (${detail})` : ''));
+    }
+    const actions = decision.actionPlan ?? [];
+    lines.push('');
+    if (actions.length === 0) {
+        lines.push('Action plan: none');
+    }
+    else {
+        lines.push(`Action plan (${actions.length}):`);
+        for (const action of actions) {
+            const label = action.summary || action.title || '';
+            lines.push(`  - ${action.kind || action.type || 'action'}${label ? `: ${label}` : ''}`);
+        }
+    }
+    const trace = decision.policyTrace ?? [];
+    lines.push('');
+    if (trace.length === 0) {
+        lines.push('Policy trace: none');
+    }
+    else {
+        lines.push(`Policy trace (${trace.length}):`);
+        for (const entry of trace) {
+            lines.push(`  ${entry.rule ?? '-'} → ${entry.decision ?? '-'}` +
+                (entry.reason ? ` — ${entry.reason}` : ''));
+        }
+    }
+    return lines;
+}

package/dist/commands/commitments/observations.d.ts

@@ -26,6 +26,7 @@ export default class CommitmentsObservations extends BaseCommand {
         'declared-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'changed-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         since: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/commitments/observations.js

@@ -38,6 +38,9 @@ class CommitmentsObservations extends base_command_1.BaseCommand {
             description: 'Only readings the server judged a material change',
         }),
         since: core_1.Flags.string({ description: 'ISO date — only observations made after it' }),
+        cursor: core_1.Flags.string({
+            description: 'Continue from the next_cursor emitted by a previous page',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -49,6 +52,7 @@ class CommitmentsObservations extends base_command_1.BaseCommand {
                 declaredOnly: flags['declared-only'] || undefined,
                 changedOnly: flags['changed-only'] || undefined,
                 since: flags.since,
+                cursor: flags.cursor,
             });
         }
         catch (err) {
@@ -56,9 +60,22 @@ class CommitmentsObservations extends base_command_1.BaseCommand {
         }
         if (flags.json) {
             this.log(JSON.stringify(response, null, 2));
-            return;
         }
-        (0, commitments_1.renderCommitmentObservations)(response, (line) => this.log(line));
+        else {
+            // "The commitment has none" and "your filter matched none" are different
+            // facts; a filter that empties the list must not claim the first
+            // (OSK-10953).
+            const filters = [
+                flags['declared-only'] ? '--declared-only' : null,
+                flags['changed-only'] ? '--changed-only' : null,
+                flags.since ? `--since ${flags.since}` : null,
+            ].filter(Boolean);
+            const emptyMessage = filters.length
+                ? `No observations match ${filters.join(' ')}.`
+                : 'No observations recorded.';
+            (0, commitments_1.renderCommitmentObservations)(response, (line) => this.log(line), { emptyMessage });
+        }
+        (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsObservations;

package/dist/commands/commitments/pause.js

@@ -30,6 +30,18 @@ class CommitmentsPause extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Paused commitment ${args.id}.`);
+        // The status write is the fence and it has landed. The teardown of the
+        // wake tree behind it is best-effort, and used to be silent — so a pause
+        // that left triggers live looked exactly like one that did not. Say which
+        // happened; a reconciler will converge the degraded case, but a person
+        // deciding whether they are really stopped should not have to assume it.
+        const teardown = commitment
+            .teardown;
+        if (teardown?.status === 'degraded') {
+            this.warn('The control loop is stopped, but some scheduled wakes may not have been retired yet. ' +
+                'They cannot run anything — every wake is refused while this Commitment is paused — ' +
+                `and the reconciler retries automatically. Check with: skrr commitments trigger-status ${args.id}`);
+        }
         (0, commitments_1.renderCommitmentSummary)(commitment, (line) => this.log(line));
     }
 }

package/dist/commands/commitments/receipt.d.ts

@@ -8,6 +8,8 @@ export default class CommitmentsReceipt extends BaseCommand {
     static flags: {
         latest: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        check: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        run: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/commitments/receipt.js

@@ -6,11 +6,21 @@ const commitments_1 = require("../../lib/commitments");
 const commitment_product_1 = require("../../lib/commitment-product");
 class CommitmentsReceipt extends base_command_1.BaseCommand {
     static description = 'Explain what happened from the event through work, delivery, and verification';
-    static examples = ['<%= config.bin %> commitments receipt <id> --latest'];
+    static examples = [
+        '<%= config.bin %> commitments receipt <id> --latest',
+        '<%= config.bin %> commitments receipt <id> --check objchk_abc',
+        '<%= config.bin %> commitments receipt <id> --run arun_abc',
+    ];
     static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
     static flags = {
         latest: core_1.Flags.boolean({ description: 'Show the latest wake (default)' }),
         limit: core_1.Flags.integer({ description: 'Number of receipts to show', min: 1, max: 100 }),
+        check: core_1.Flags.string({
+            description: 'Explain one specific check — its exact receipt, not the latest-N window',
+        }),
+        run: core_1.Flags.string({
+            description: 'Explain the run — resolves to the receipt of the check that minted it',
+        }),
         json: core_1.Flags.boolean({ description: 'Output projected receipts as JSON' }),
         verbose: core_1.Flags.boolean({ description: 'Include source IDs and diagnostic traces' }),
     };
@@ -18,7 +28,11 @@ class CommitmentsReceipt extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(CommitmentsReceipt);
         try {
-            const result = await commitments_1.commitmentApi.receipts(args.id, flags.latest ? 1 : flags.limit || 1);
+            const result = await commitments_1.commitmentApi.receipts(args.id, {
+                limit: flags.latest ? 1 : flags.limit || 1,
+                checkId: flags.check,
+                runId: flags.run,
+            });
             if (flags.json)
                 return this.log(JSON.stringify(result, null, 2));
             if (!result.receipts.length)

package/dist/commands/commitments/remediation-proposal.js

@@ -12,7 +12,7 @@ class CommitmentsRemediationProposal extends base_command_1.BaseCommand {
     static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
     async run() {
         this.requireAuth();
-        const { args } = await this.parse(CommitmentsRemediationProposal);
+        const { args, flags } = await this.parse(CommitmentsRemediationProposal);
         let result;
         try {
             result = await commitments_1.commitmentApi.remediationProposal(args.commitmentId, args.proposalId);
@@ -20,7 +20,11 @@ class CommitmentsRemediationProposal extends base_command_1.BaseCommand {
         catch (error) {
             this.handleApiError(error);
         }
-        this.log(JSON.stringify(result, null, 2));
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        (0, commitments_1.renderCommitmentRemediationProposal)(result, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsRemediationProposal;

package/dist/commands/commitments/remediation-proposals.js

@@ -28,7 +28,11 @@ class CommitmentsRemediationProposals extends base_command_1.BaseCommand {
         catch (error) {
             this.handleApiError(error);
         }
-        this.log(JSON.stringify(result, null, 2));
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        (0, commitments_1.renderCommitmentRemediationProposals)(result, (line) => this.log(line));
     }
 }
 exports.default = CommitmentsRemediationProposals;

package/dist/commands/commitments/restore.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr commitments restore <id>` — bring back a deleted commitment.
+ *
+ * Deleting is a soft tombstone, so the row and its whole history were always
+ * still there; until now there was simply no way for anyone to reach them
+ * again, which is the storage cost of a recoverable delete with none of the
+ * benefit.
+ *
+ * It comes back PAUSED, never active. Restoring the record and re-granting the
+ * authority to act are two decisions, and the second still has to pass the
+ * activation preflight — so a restore can never quietly put an agent back to
+ * work.
+ */
+export default class CommitmentsRestore extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/commitments/restore.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const web_url_1 = require("../../lib/web-url");
+const commitments_1 = require("../../lib/commitments");
+/**
+ * `skrr commitments restore <id>` — bring back a deleted commitment.
+ *
+ * Deleting is a soft tombstone, so the row and its whole history were always
+ * still there; until now there was simply no way for anyone to reach them
+ * again, which is the storage cost of a recoverable delete with none of the
+ * benefit.
+ *
+ * It comes back PAUSED, never active. Restoring the record and re-granting the
+ * authority to act are two decisions, and the second still has to pass the
+ * activation preflight — so a restore can never quietly put an agent back to
+ * work.
+ */
+class CommitmentsRestore extends base_command_1.BaseCommand {
+    static description = 'Restore a deleted commitment (it comes back paused — resume it separately)';
+    static examples = ['<%= config.bin %> commitments restore <commitment-id>'];
+    static args = {
+        id: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsRestore);
+        let commitment;
+        try {
+            commitment = await commitments_1.commitmentApi.restore(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify((0, web_url_1.withCommitmentUrl)(this.cliConfig.baseURL, commitment), null, 2));
+            return;
+        }
+        this.log(`Restored commitment ${args.id}. It is paused.`);
+        this.log(`  Start it again with: skrr commitments resume ${args.id}`);
+        (0, commitments_1.renderCommitmentSummary)(commitment, (line) => this.log(line));
+    }
+}
+exports.default = CommitmentsRestore;

package/dist/commands/commitments/show.js

@@ -50,6 +50,38 @@ class CommitmentsShow extends base_command_1.BaseCommand {
             return;
         }
         (0, commitments_1.renderCommitmentSummary)(response.commitment, (line) => this.log(line), response.latestCheck);
+        // `show` is the first surface a person reaches after linking something, and
+        // it used to render only watchedSources — a freshly linked goal or task was
+        // invisible until you knew to run `links list` (OSK-10963).
+        try {
+            const links = await commitments_1.commitmentApi.workLinks(args.id);
+            const active = (links.data || []).filter((link) => link.status === 'active');
+            if (active.length) {
+                this.log('Links:');
+                for (const link of active) {
+                    const roles = Array.isArray(link.roles) ? link.roles.join(', ') : '';
+                    this.log(`  - ${link.targetType}:${link.targetId}${roles ? ` (${roles})` : ''}${link.isDelivery ? ' · delivery' : ''}`);
+                }
+            }
+        }
+        catch {
+            // The header still stands on its own when the links read is unavailable.
+        }
+        // `goals link` writes goal.commitmentId — an edge that lives on the GOAL,
+        // so `links list` can never see it. The lineage projection aggregates both
+        // link models; without it, a goal the commitment visibly advances is
+        // unrenderable from its own headline view (OSK-10963).
+        try {
+            const lineage = await commitments_1.commitmentApi.workLineage(args.id, 50);
+            const hasAny = ['goals', 'tasks', 'runs'].some((key) => Array.isArray(lineage?.[key]) && lineage[key].length > 0);
+            if (hasAny) {
+                this.log('');
+                (0, commitments_1.renderCommitmentLineage)(lineage, (line) => this.log(line));
+            }
+        }
+        catch {
+            // Lineage is a hint on the headline view, not load-bearing.
+        }
         try {
             const receipts = await commitments_1.commitmentApi.receipts(args.id, 1);
             if (receipts.receipts[0]) {