@skrr-ai/cli 0.1.118 → 0.1.120

package/dist/lib/command-hygiene.js

@@ -38,6 +38,414 @@ exports.auditCommands = auditCommands;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const usage_discovery_1 = require("./usage-discovery");
+const provided = (note) => ({ status: 'provided', note });
+const missing = (note) => ({ status: 'missing', note });
+const notApplicable = (note) => ({
+    status: 'not_applicable',
+    note,
+});
+const NO_MACHINE_STATE = notApplicable('This flow does not control a machine lifecycle.');
+/**
+ * This is intentionally an explicit first tranche rather than a guess based
+ * on descriptions. Each row names the owning surface and is safe to audit
+ * before changing any command behaviour.
+ */
+const HIGH_SIDE_EFFECT_COMMANDS = [
+    {
+        command: 'machines:hosted:start',
+        effect: 'machine_lifecycle',
+        owner: 'Hosted Machine transport',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: provided('The request-id flag identifies the logical machine start.'),
+            receipt: missing('Return the accepted start receipt alongside the created session.'),
+            recovery: provided('Timeout and setup-failure paths name status, pause, or destroy for the created machine.'),
+            machineState: provided('The JSON result returns the session state and wait observes readiness.'),
+            idempotency: provided('The start request supplies a client request id.'),
+        },
+    },
+    {
+        command: 'machines:hosted:destroy',
+        effect: 'machine_lifecycle',
+        owner: 'Hosted Machine transport',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: provided('The target session id is the durable destroy subject.'),
+            receipt: missing('Return a destroy receipt that distinguishes accepted from terminal termination.'),
+            recovery: missing('Name a read-only state check for a lost destroy response.'),
+            machineState: provided('The result returns the hosted session state.'),
+            idempotency: missing('Add a stable destroy identity for ambiguous transport retries.'),
+        },
+    },
+    {
+        command: 'machines:hosted:exec',
+        effect: 'remote_execution',
+        owner: 'Hosted Machine transport',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: missing('Return a durable execution id, not only the enclosing session id.'),
+            receipt: missing('Persist and return an invocation receipt for a completed or unknown command.'),
+            recovery: missing('Add inspect-before-retry guidance keyed by the returned execution id.'),
+            machineState: provided('The curated JSON result includes session.id and session.status.'),
+            idempotency: missing('Accept a caller-supplied execution identity and deduplicate that logical command.'),
+        },
+    },
+    {
+        command: 'machines:dedicated:exec',
+        effect: 'remote_execution',
+        owner: 'Dedicated Runtime execution',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: provided('The request-id flag identifies the logical command.'),
+            receipt: provided('The dedicated exec result is returned after start/observation under that request id.'),
+            recovery: provided('Contact-loss and unconfirmed-start errors direct the caller to reuse the request id.'),
+            machineState: provided('Wake/refusal states are carried through the dedicated-runtime response.'),
+            idempotency: provided('Repeating request-id returns the run already started.'),
+        },
+    },
+    ...['start', 'stop', 'restart', 'update-image'].map((action) => ({
+        command: 'machines:dedicated:' + action,
+        effect: 'machine_lifecycle',
+        owner: 'Dedicated Runtime lifecycle',
+        priority: action === 'update-image' ? 'P0' : 'P1',
+        requirements: {
+            operationIdentifier: provided('The returned lease identifies the in-flight lifecycle operation.'),
+            receipt: provided('reportLeaseAction preserves the server action response for JSON callers.'),
+            recovery: provided('The wait contract distinguishes an unfinished operation and names show.'),
+            machineState: provided('The lease state is returned immediately and can be observed to the requested goal.'),
+            idempotency: provided('Lifecycle actions converge on desired lease state rather than replaying a second effect.'),
+        },
+    })),
+    {
+        command: 'machines:dedicated:destroy',
+        effect: 'machine_lifecycle',
+        owner: 'Dedicated Runtime lifecycle',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: provided('The returned lease is the durable subject of the destroy operation.'),
+            receipt: provided('reportLeaseAction returns the destroy response to JSON callers.'),
+            recovery: provided('Retention notes and restore describe the bounded recovery path.'),
+            machineState: provided('The returned lease exposes the transition and storage-retention outcome.'),
+            idempotency: provided('Destroy is a lease-state transition; repeated requests converge on that lease.'),
+        },
+    },
+    {
+        command: 'machines:dedicated:restore',
+        effect: 'machine_lifecycle',
+        owner: 'Dedicated Runtime lifecycle',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: provided('The request-id flag identifies a logical restore.'),
+            receipt: provided('The restore response carries the replacement lease.'),
+            recovery: provided('The command documents the retained recovery-point window.'),
+            machineState: provided('reportLeaseAction returns and optionally waits on the replacement lease state.'),
+            idempotency: provided('The documented request-id is safe to reuse for the same restore.'),
+        },
+    },
+    {
+        command: 'machines:dedicated:service:apply',
+        effect: 'machine_lifecycle',
+        owner: 'Dedicated Runtime services',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The lease id and service name identify the desired-state change.'),
+            receipt: provided('The created or updated service specification is returned as JSON.'),
+            recovery: provided('The command reads the stored revision and reports CAS conflicts instead of silently merging.'),
+            machineState: provided('The returned service declaration is the persisted desired state.'),
+            idempotency: provided('Apply is explicitly create-or-update and safe to re-run against its revision.'),
+        },
+    },
+    {
+        command: 'machines:dedicated:service:exec',
+        effect: 'remote_execution',
+        owner: 'Dedicated Runtime services',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The daemon persists a service-execution operationId before it spawns the child.'),
+            receipt: provided('The additive execution receipt distinguishes accepted, started, completed and unknown evidence.'),
+            recovery: provided('A lost relay response names service exec --request-id <id> --inspect before any retry.'),
+            machineState: provided('The additive execution envelope carries the observed service state and lease subject.'),
+            idempotency: provided('Reusing --request-id converges on the same durable service-execution receipt.'),
+        },
+    },
+    ...['start', 'stop', 'restart'].map((action) => ({
+        command: 'machines:dedicated:service:' + action,
+        effect: 'machine_lifecycle',
+        owner: 'Dedicated Runtime services',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The lease id and service name identify the desired-state operation.'),
+            receipt: provided('The service action returns its updated declaration.'),
+            recovery: provided('Persisted desired state survives restarts and can be re-read with status.'),
+            machineState: provided('The returned declaration reports the desired service state.'),
+            idempotency: provided('Repeated desired-state actions converge on the same service state.'),
+        },
+    })),
+    {
+        command: 'tasks:start',
+        effect: 'durable_execution',
+        owner: 'Task execution',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: provided('The request-id flag is generated or supplied for each logical start.'),
+            receipt: provided('JSON exposes the start receipt and task/run identifiers.'),
+            recovery: provided('tasks start-receipt is named for a lost or machine-waiting start.'),
+            machineState: provided('A machine-waiting response is structured rather than reported as a failed start.'),
+            idempotency: provided('The request id is the task-start idempotency key.'),
+        },
+    },
+    {
+        command: 'tasks:retry',
+        effect: 'durable_execution',
+        owner: 'Task execution',
+        priority: 'P0',
+        requirements: {
+            operationIdentifier: missing('Add one retry-attempt id spanning the committed move and the subsequent start.'),
+            receipt: missing('Return a compound retry receipt that records both the status transition and dispatch result.'),
+            recovery: provided('A start failure names tasks show before another start is attempted.'),
+            machineState: provided('Machine waiting is a structured JSON outcome, not a false dispatch success.'),
+            idempotency: missing('Do not replay the move/start pair without a stable retry identity.'),
+        },
+    },
+    {
+        command: 'spaces:workflows:start',
+        effect: 'durable_execution',
+        owner: 'Workflow runtime',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The result promotes runId and status to top-level JSON fields.'),
+            receipt: provided('The created workflow run is the durable start receipt.'),
+            recovery: provided('The returned run id is inspectable with spaces workflows run.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('The start-identity flag names the logical start.'),
+        },
+    },
+    {
+        command: 'spaces:workflows:retry',
+        effect: 'durable_execution',
+        owner: 'Workflow runtime',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The retry result identifies the resulting workflow run.'),
+            receipt: provided('The result records whether the run was reused or started.'),
+            recovery: missing('Print an inspect-before-retry command for an ambiguous retry response.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: missing('Accept a retry identity instead of relying on a repeated network request.'),
+        },
+    },
+    {
+        command: 'spaces:workflows:cancel',
+        effect: 'automation_control',
+        owner: 'Workflow runtime',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The workflow run id is the cancellation subject.'),
+            receipt: provided('cancelReceipt distinguishes a new cancellation from an already-settled run.'),
+            recovery: provided('Converging and failed cleanup paths name re-read or reconcile commands.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('Cancellation is a convergent state transition and reports the receipt outcome.'),
+        },
+    },
+    {
+        command: 'spaces:workflows:proposals:apply',
+        effect: 'automation_control',
+        owner: 'Workflow runtime',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The proposal id and workflow id identify the reviewed draft mutation.'),
+            receipt: missing('Return a revision-fenced proposal-apply receipt rather than an unqualified workflow result.'),
+            recovery: missing('Name the draft read or proposal status command before a caller retries an ambiguous apply.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: missing('Bind repeated proposal application to a stable reviewed revision and identity.'),
+        },
+    },
+    {
+        command: 'spaces:workflows:triggers:fire',
+        effect: 'durable_execution',
+        owner: 'Workflow runtime',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The returned run identifies the trigger delivery.'),
+            receipt: provided('The trigger result records whether the run was reused or fired.'),
+            recovery: missing('Add an explicit run-inspection instruction to the human output and JSON hint.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('The start-identity flag is the trigger delivery identity.'),
+        },
+    },
+    {
+        command: 'commitments:control:apply',
+        effect: 'automation_control',
+        owner: 'Commitment controls',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('A required idempotency key identifies the exact reviewed control request.'),
+            receipt: provided('The command returns the actual control receipt.'),
+            recovery: provided('The input is a saved reviewed preview, so a retry is bound to the same scope and version.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('The required key is checked against the reviewed control payload.'),
+        },
+    },
+    {
+        command: 'commitments:action-proposals:execute',
+        effect: 'automation_control',
+        owner: 'Commitment controls',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The frozen Action Bundle revision and digest form the stable operation id.'),
+            receipt: provided('The additive execution envelope classifies the durable proposal receipt.'),
+            recovery: provided('The result names the read-only proposal receipt required before any retry.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('The action key and frozen bundle coordinates fence repeated execution nudges.'),
+        },
+    },
+    {
+        command: 'commitments:execute-remediation',
+        effect: 'automation_control',
+        owner: 'Commitment controls',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The immutable remediation action key and proposal revision form the operation id.'),
+            receipt: provided('The additive execution envelope classifies the durable remediation receipt.'),
+            recovery: provided('A stale-lease retry remains explicit and the receipt requires inspection before another retry.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('The frozen remediation action key is surfaced as the retry identity.'),
+        },
+    },
+    {
+        command: 'store:artifacts:release',
+        effect: 'release_publication',
+        owner: 'Store release governance',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The immutable release id is surfaced as the publication operation id.'),
+            receipt: provided('The release result preserves its historical field and adds a versioned receipt envelope.'),
+            recovery: provided('The result names a read-only immutable-release receipt; incident response stays a separately authorized curator action.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('A caller can reuse the immutable release id only for the exact reviewed publication.'),
+        },
+    },
+    {
+        command: 'store:governance:publish-release',
+        effect: 'release_publication',
+        owner: 'Store release governance',
+        priority: 'P1',
+        requirements: {
+            operationIdentifier: provided('The stable immutable release id is returned at the top level and in the receipt.'),
+            receipt: provided('The historical release field is retained with a versioned receipt envelope.'),
+            recovery: provided('The result names a read-only governed receipt; rollback stays a human-authorized incident procedure.'),
+            machineState: NO_MACHINE_STATE,
+            idempotency: provided('The reviewed release id is the publication identity; a source-revision fence rejects stale evidence.'),
+        },
+    },
+];
+const HUMAN_ONLY_EXEMPTIONS = [
+    {
+        command: 'create-token',
+        effect: 'credential_issuance',
+        reason: 'A CI token is secret material printed once for daemon bootstrap; durable receipts must not echo or retain it.',
+        reviewedEvidence: 'docs/cli/SKRR_AUTH.md#credential-types-and-allowed-surfaces',
+    },
+    {
+        command: 'generate-recovery-code',
+        effect: 'credential_issuance',
+        reason: 'This route requires a signed-in user session and fresh step-up proof; the secret is deliberately shown once.',
+        reviewedEvidence: 'docs/cli/SKRR_AUTH.md#recovery-codes',
+    },
+];
+const EXECUTION_CONTRACT_BY_COMMAND = new Map(HIGH_SIDE_EFFECT_COMMANDS.map((contract) => [contract.command, contract]));
+const HUMAN_ONLY_EXEMPTION_BY_COMMAND = new Map(HUMAN_ONLY_EXEMPTIONS.map((exemption) => [exemption.command, exemption]));
+/**
+ * Adding one of these verbs in a controlled execution namespace must add a
+ * reviewed row above. The narrow vocabulary avoids pretending that ordinary
+ * metadata changes need a remote-execution recovery contract.
+ */
+const CONTROLLED_EXECUTION_VERB = /(^|:)(?:exec|destroy|restore|restart|start|stop|update-image|apply|fire|cancel|retry|publish-release|drain)$/;
+function isExecutionContractCandidate(command) {
+    if (EXECUTION_CONTRACT_BY_COMMAND.has(command) ||
+        HUMAN_ONLY_EXEMPTION_BY_COMMAND.has(command)) {
+        return true;
+    }
+    return ((command.startsWith('machines:dedicated:') ||
+        command.startsWith('machines:hosted:') ||
+        command.startsWith('spaces:workflows:')) &&
+        CONTROLLED_EXECUTION_VERB.test(command));
+}
+const EXECUTION_REQUIREMENT_ISSUES = {
+    operationIdentifier: {
+        code: 'EXECUTION_OPERATION_IDENTIFIER_MISSING',
+        label: 'operation identifier',
+    },
+    receipt: { code: 'EXECUTION_RECEIPT_MISSING', label: 'receipt' },
+    recovery: { code: 'EXECUTION_RECOVERY_GUIDANCE_MISSING', label: 'recovery guidance' },
+    machineState: {
+        code: 'EXECUTION_MACHINE_STATE_OUTPUT_MISSING',
+        label: 'machine-state output',
+    },
+    idempotency: {
+        code: 'EXECUTION_IDEMPOTENCY_BEHAVIOR_MISSING',
+        label: 'idempotency behaviour',
+    },
+};
+function auditExecutionContracts(commandIds) {
+    const candidates = [...new Set([...commandIds].filter(isExecutionContractCandidate))].sort();
+    const contracts = candidates
+        .map((command) => EXECUTION_CONTRACT_BY_COMMAND.get(command))
+        .filter((contract) => Boolean(contract));
+    const exemptions = candidates
+        .map((command) => HUMAN_ONLY_EXEMPTION_BY_COMMAND.get(command))
+        .filter((exemption) => Boolean(exemption));
+    const unclassified = candidates.filter((command) => !EXECUTION_CONTRACT_BY_COMMAND.has(command) && !HUMAN_ONLY_EXEMPTION_BY_COMMAND.has(command));
+    const issues = unclassified.map((command) => ({
+        code: 'HIGH_SIDE_EFFECT_COMMAND_UNCLASSIFIED',
+        severity: 'error',
+        command,
+        message: 'High-side-effect command is not in the execution-contract inventory. Add a reviewed contract row or a documented human-only exemption.',
+    }));
+    const missingByRequirement = {
+        operationIdentifier: 0,
+        receipt: 0,
+        recovery: 0,
+        machineState: 0,
+        idempotency: 0,
+    };
+    for (const contract of contracts) {
+        for (const requirement of Object.keys(contract.requirements)) {
+            const assessment = contract.requirements[requirement];
+            if (assessment.status !== 'missing')
+                continue;
+            missingByRequirement[requirement] += 1;
+            const issue = EXECUTION_REQUIREMENT_ISSUES[requirement];
+            issues.push({
+                code: issue.code,
+                severity: 'warning',
+                command: contract.command,
+                message: 'High-side-effect command lacks ' + issue.label + ': ' + assessment.note,
+            });
+        }
+    }
+    return {
+        report: {
+            candidates: candidates.length,
+            classified: contracts.length,
+            humanOnlyExemptions: exemptions.length,
+            missingOperationIdentifiers: missingByRequirement.operationIdentifier,
+            missingReceipts: missingByRequirement.receipt,
+            missingRecoveryGuidance: missingByRequirement.recovery,
+            missingMachineStateOutputs: missingByRequirement.machineState,
+            missingIdempotencyBehavior: missingByRequirement.idempotency,
+            contracts: contracts.map(({ command, effect, owner, priority, requirements }) => ({
+                command,
+                effect,
+                owner,
+                priority,
+                requirements,
+            })),
+            exemptions,
+            unclassified,
+        },
+        issues,
+    };
+}
 const AGENT_CRITICAL_COMMANDS = [
     'context',
     'doctor',
@@ -96,6 +504,7 @@ function auditCommands({ rootDir, manifest, }) {
     const jsonCommands = commandIds.filter((id) => hasJsonFlag(commands[id]?.flags)).length;
     let fromJsonCommands = 0;
     let argsStringBlocks = 0;
+    const sourceCommandIds = new Set();
     const sourceRoot = path.join(rootDir, 'src', 'commands');
     if (fs.existsSync(sourceRoot)) {
         sourceAvailable = true;
@@ -105,6 +514,7 @@ function auditCommands({ rootDir, manifest, }) {
             const rel = path.relative(sourceRoot, file);
             const source = fs.readFileSync(file, 'utf8');
             const command = commandIdFromRelativePath(rel);
+            sourceCommandIds.add(command);
             const hasFromJson = /['"]from-json['"]/.test(source);
             const hasJson = /json:\s*Flags\.boolean/.test(source);
             if (hasFromJson)
@@ -206,6 +616,8 @@ function auditCommands({ rootDir, manifest, }) {
             }
         }
     }
+    const executionAudit = auditExecutionContracts(sourceAvailable ? sourceCommandIds : commandIds);
+    issues.push(...executionAudit.issues);
     const errors = issues.filter((issue) => issue.severity === 'error').length;
     const warnings = issues.filter((issue) => issue.severity === 'warning').length;
     return {
@@ -229,6 +641,7 @@ function auditCommands({ rootDir, manifest, }) {
             budgetErrors: usageBudgetIssues.length,
         },
         namingGrammar: exports.NAMING_GRAMMAR,
+        execution: executionAudit.report,
         issues,
     };
 }

package/dist/lib/commitments.d.ts

@@ -173,6 +173,12 @@ export type CommitmentPackPlanResponse = {
     };
     planDigest: string;
     draft?: Record<string, unknown>;
+    /** A Pack planned into a Space: where it would go and who would hold it. */
+    spacePlacement?: {
+        spaceId: string;
+        agentId: string;
+        holder?: 'space_lead' | 'explicit';
+    };
     [key: string]: unknown;
 };
 export type CommitmentPackBindResponse = {
@@ -181,11 +187,47 @@ export type CommitmentPackBindResponse = {
         title?: string;
         status?: string;
     };
-    pack: {
+    /** The API answers with the plan it bound; `plan.pack` names the Pack. */
+    pack?: {
         id: string;
         version: string;
     };
+    plan?: {
+        pack?: {
+            id: string;
+            version: string;
+        };
+        planDigest?: string;
+    };
     reused?: boolean;
+    /**
+     * Present when the Pack was bound into a Space: the Commitment is that
+     * Space's loop, held by `agentId` (`holder: 'space_lead'` when it defaulted
+     * to the Space's lead). `knowledgeScope.default` is what the link service
+     * did with the Space knowledge opt-in; absent when an existing loop was
+     * reused unchanged.
+     */
+    spaceLoop?: {
+        spaceId: string;
+        agentId: string;
+        holder?: 'space_lead' | 'explicit';
+        linkId?: string;
+        roles?: string[];
+        knowledgeScope?: {
+            default?: string;
+            enabled?: boolean;
+        };
+    };
+    /**
+     * The plan's other links, written with the Space link when a new loop was
+     * bound: a `goal_advance` loop's `advance` + `watch` link to its Goal.
+     */
+    workLinks?: Array<{
+        linkId: string;
+        targetType: string;
+        targetId: string;
+        roles: string[];
+    }>;
     [key: string]: unknown;
 };
 export type CommitmentPackLifecycleResponse = {
@@ -311,6 +353,7 @@ export declare const commitmentApi: {
         object: "commitment_action_proposal_list";
         data: CommitmentActionProposal[];
     }>;
+    actionProposal: (id: string, proposalId: string) => Promise<Record<string, unknown>>;
     /**
      * Propose a prepared action for a check.
      *
@@ -327,7 +370,7 @@ export declare const commitmentApi: {
         reason?: string;
         reasonCode?: import("@skrr-ai/data-provider").ProposalDiscardReasonCode;
     }) => Promise<Record<string, unknown>>;
-    executeActionProposal: (id: string, proposalId: string) => Promise<Record<string, unknown>>;
+    executeActionProposal: (id: string, proposalId: string, body?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     preflight: (id: string, nextRunCount?: number) => Promise<CommitmentPreflightReport>;
     effectivePolicy: (id: string) => Promise<Record<string, unknown>>;
     /**
@@ -374,7 +417,11 @@ export declare const commitmentApi: {
     remediationProposal: (id: string, proposalId: string) => Promise<Record<string, unknown>>;
     proposeRemediation: (id: string, caseId: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
     decideRemediationProposal: (id: string, proposalId: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
-    executeRemediationProposal: (id: string, proposalId: string, retryExecuting?: boolean) => Promise<Record<string, unknown>>;
+    executeRemediationProposal: (id: string, proposalId: string, body?: {
+        retryExecuting?: boolean;
+        expectedRevision?: number;
+        expectedUpdatedAt?: string | null;
+    }) => Promise<Record<string, unknown>>;
     triggerStatus: (id: string, limit?: number) => Promise<Record<string, unknown>>;
     workLineage: (id: string, limit?: number) => Promise<Record<string, unknown>>;
     /** One ordered explanation surface across the immutable commitment ledgers. */
@@ -802,6 +849,20 @@ export declare function extractStandstillFromCheck(check?: {
     fix?: string;
     alsoConstrained?: Array<Record<string, unknown>>;
 } | null;
+/**
+ * The fix to print beside a standstill, as `stopForRead` resolves a stop's on
+ * the server. The check's own stored sentence is the answer for a reason that
+ * still occurs. A reason only a pre-2026-10-09 Check carries stored a fix that
+ * names a retired Commitment mode (OSK-18146), so its current copy is printed
+ * instead, with `<commitment>` bound to this Commitment when its id is a plain
+ * token.
+ *
+ * Exported for tests.
+ */
+export declare function standstillFixForRead(standstill: {
+    reason: string;
+    fix?: string;
+}, commitmentId?: string): string | undefined;
 /**
  * The `Autonomy:` line — the stated mode, annotated when the latest check
  * actually ran at a STRICTER one (OSK-4881). Without the caveat, a commitment

package/dist/lib/commitments.js

@@ -20,6 +20,7 @@ exports.pendingCadenceRequestLines = pendingCadenceRequestLines;
 exports.cadenceLabel = cadenceLabel;
 exports.renderCommitmentList = renderCommitmentList;
 exports.extractStandstillFromCheck = extractStandstillFromCheck;
+exports.standstillFixForRead = standstillFixForRead;
 exports.describeExecutorBlocked = describeExecutorBlocked;
 exports.describeOperation = describeOperation;
 exports.describeOperationFix = describeOperationFix;
@@ -195,6 +196,7 @@ exports.commitmentApi = {
     checks: (id, query = {}) => data_provider_2.request.get((0, triggers_1.withQuery)(`${base(id)}/checks`, query)),
     actionHistory: (id, query = {}) => data_provider_2.request.get((0, triggers_1.withQuery)(`${base(id)}/action-history`, query)),
     actionProposals: (id, query = {}) => data_provider_2.request.get((0, triggers_1.withQuery)(`${base(id)}/action-proposals`, query)),
+    actionProposal: (id, proposalId) => data_provider_2.request.get(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}`),
     /**
      * Propose a prepared action for a check.
      *
@@ -213,7 +215,7 @@ exports.commitmentApi = {
         ...(snapshot?.reasonCode ? { reasonCode: snapshot.reasonCode } : {}),
         via: 'cli',
     }),
-    executeActionProposal: (id, proposalId) => data_provider_2.request.post(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}/execute`, {}),
+    executeActionProposal: (id, proposalId, body = {}) => data_provider_2.request.post(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}/execute`, body),
     preflight: (id, nextRunCount) => data_provider_2.request.post(`${base(id)}/preflight`, {
         ...(typeof nextRunCount === 'number' ? { nextRunCount } : {}),
     }),
@@ -247,8 +249,8 @@ exports.commitmentApi = {
     remediationProposal: (id, proposalId) => data_provider_2.request.get(`${base(id)}/remediation-proposals/${encodeURIComponent(proposalId)}`),
     proposeRemediation: (id, caseId, body) => data_provider_2.request.post(`${base(id)}/cases/${encodeURIComponent(caseId)}/remediation-proposals`, body),
     decideRemediationProposal: (id, proposalId, body) => data_provider_2.request.post(`${base(id)}/remediation-proposals/${encodeURIComponent(proposalId)}/decision`, body),
-    executeRemediationProposal: (id, proposalId, retryExecuting = false) => data_provider_2.request.post(`${base(id)}/remediation-proposals/${encodeURIComponent(proposalId)}/execute`, {
-        retryExecuting,
+    executeRemediationProposal: (id, proposalId, body = {}) => data_provider_2.request.post(`${base(id)}/remediation-proposals/${encodeURIComponent(proposalId)}/execute`, {
+        ...body,
     }),
     /* ------------------------------------------------------------------------ *
      * Observability and lineage
@@ -826,7 +828,7 @@ function pendingCadenceRequestLines(commitment) {
         }),
     ];
 }
-function cadenceLabel(commitment) {
+function baseCadenceLabel(commitment) {
     const cadence = commitment.cadence;
     if (!cadence || !cadence.mode || cadence.mode === 'manual')
         return 'manual';
@@ -842,6 +844,13 @@ function cadenceLabel(commitment) {
     }
     return `${cadence.mode === 'event_plus_interval' ? 'event+' : ''}${describeIntervalMs(cadence.intervalMs)}`;
 }
+function cadenceLabel(commitment) {
+    const base = baseCadenceLabel(commitment);
+    const window = (0, data_provider_1.describeCommitmentCadenceWindow)(commitment.cadence);
+    return window
+        ? `${base} ${window}${commitment.cadence?.mode !== 'daily' ? ` (${commitment.cadence?.timezone || 'UTC'})` : ''}`
+        : base;
+}
 function renderCommitmentList(commitments, log) {
     if (commitments.length === 0) {
         log('No commitments.');
@@ -905,6 +914,24 @@ function extractStandstillFromCheck(check) {
     }
     return null;
 }
+/**
+ * The fix to print beside a standstill, as `stopForRead` resolves a stop's on
+ * the server. The check's own stored sentence is the answer for a reason that
+ * still occurs. A reason only a pre-2026-10-09 Check carries stored a fix that
+ * names a retired Commitment mode (OSK-18146), so its current copy is printed
+ * instead, with `<commitment>` bound to this Commitment when its id is a plain
+ * token.
+ *
+ * Exported for tests.
+ */
+function standstillFixForRead(standstill, commitmentId) {
+    if (!(0, data_provider_2.isLegacyStandstillReason)(standstill.reason))
+        return standstill.fix;
+    const fix = (0, data_provider_2.describeStandstill)(standstill.reason).fix ?? undefined;
+    if (!fix || !commitmentId || !/^[A-Za-z0-9_-]{1,80}$/.test(commitmentId))
+        return fix;
+    return fix.split('<commitment>').join(commitmentId);
+}
 /**
  * The `Autonomy:` line — the stated mode, annotated when the latest check
  * actually ran at a STRICTER one (OSK-4881). Without the caveat, a commitment
@@ -1184,8 +1211,9 @@ scheduleIssues) {
         const streak = commitment.state?.consecutiveUnresolvedChecks;
         const streakClause = typeof streak === 'number' && streak >= 2 ? `${streak} checks in a row: ` : '';
         log(`Standstill:${` ${streakClause}${(0, data_provider_2.describeStandstill)(standstill.reason).title}`}`);
-        if (standstill.fix)
-            log(`           Fix: ${standstill.fix}`);
+        const fix = standstillFixForRead(standstill, commitment.id);
+        if (fix)
+            log(`           Fix: ${fix}`);
         if (standstill.alsoConstrained?.length) {
             const also = standstill.alsoConstrained
                 .map((entry) => {