@skrr-ai/cli 0.1.13 → 0.1.15

package/dist/commands/tasks/waive.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks waive <task> <expectation-id> --reason "<why>"`
+ *
+ * Drop a requirement, on the record. The expectation is KEPT and marked, never
+ * deleted: deleting it expresses the same decision while destroying the only
+ * evidence that it was ever owed, which is what someone asking "why wasn't this
+ * done?" needs to read.
+ *
+ * The reason is required for the same purpose — a waiver without one is
+ * indistinguishable from having forgotten.
+ */
+export default class TasksWaive extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        expectation: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/waive.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+/**
+ * `skrr tasks waive <task> <expectation-id> --reason "<why>"`
+ *
+ * Drop a requirement, on the record. The expectation is KEPT and marked, never
+ * deleted: deleting it expresses the same decision while destroying the only
+ * evidence that it was ever owed, which is what someone asking "why wasn't this
+ * done?" needs to read.
+ *
+ * The reason is required for the same purpose — a waiver without one is
+ * indistinguishable from having forgotten.
+ */
+class TasksWaive extends base_command_1.BaseCommand {
+    static description = 'Waive an expectation, with a stated reason';
+    static examples = [
+        '<%= config.bin %> tasks waive <task-id> c1 --reason "superseded by OSK-7000"',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        expectation: core_1.Args.string({
+            description: 'Expectation id (see `tasks show`)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        reason: core_1.Flags.string({
+            description: 'Why this is no longer required. Required — it is the record.',
+            required: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksWaive);
+        let result;
+        try {
+            result = await data_provider_1.dataService.waiveTaskExpectation(args.task, {
+                expectationId: args.expectation,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Waived ${args.expectation}: ${flags.reason}`);
+    }
+}
+exports.default = TasksWaive;

package/dist/commands/wiki/cat.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const web_url_1 = require("../../lib/web-url");
 class WikiCat extends base_command_1.BaseCommand {
     static description = 'Print a wiki page (Markdown by default)';
     static examples = [
@@ -41,7 +42,7 @@ class WikiCat extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify(page, null, 2));
+            this.log(JSON.stringify((0, web_url_1.withWikiPageUrl)(this.cliConfig.baseURL, page), null, 2));
             return;
         }
         // Body only — so `skrr wiki cat ... > page.md` produces a clean file and

package/dist/commands/wiki/mv.js

@@ -6,6 +6,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const http_error_1 = require("../../lib/http-error");
+const web_url_1 = require("../../lib/web-url");
 const wiki_1 = require("../../lib/wiki");
 const write_1 = require("./write");
 /**
@@ -231,7 +232,10 @@ class WikiMv extends base_command_1.BaseCommand {
                 });
             }
             if (flags.json) {
-                this.log(JSON.stringify({ kind: 'page', ...moved }, null, 2));
+                this.log(JSON.stringify({
+                    kind: 'page',
+                    ...(0, web_url_1.withWikiPageUrl)(this.cliConfig.baseURL, moved),
+                }, null, 2));
                 return;
             }
             this.log(`Moved page ${source} → ${moved.path ?? args.destination}.`);

package/dist/commands/wiki/write.js

@@ -8,6 +8,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const http_error_1 = require("../../lib/http-error");
+const web_url_1 = require("../../lib/web-url");
 const wiki_1 = require("../../lib/wiki");
 /**
  * The page lookup below goes through `dataService`, whose adapter throws a
@@ -248,8 +249,9 @@ class WikiWrite extends base_command_1.BaseCommand {
                 `it creates. Retitle it with \`${this.config.bin} wiki update ${args.space} ${page.path ?? args.path} ` +
                 `--title ${JSON.stringify(flags.title)}\` (the slug is kept, so stored paths stay valid).`);
         }
+        const withUrl = (0, web_url_1.withWikiPageUrl)(this.cliConfig.baseURL, page);
         if (flags.json) {
-            this.log(JSON.stringify(page, null, 2));
+            this.log(JSON.stringify(withUrl, null, 2));
             return;
         }
         // Report what actually happened, not what we set out to do — a write that
@@ -260,6 +262,8 @@ class WikiWrite extends base_command_1.BaseCommand {
             verb = flags.append ? 'Appended to' : 'Updated';
         }
         this.log(`${verb} ${page.path ?? args.path} (${page.pageId}).`);
+        if (withUrl.url)
+            this.log(`URL: ${withUrl.url}`);
     }
 }
 exports.default = WikiWrite;

package/dist/lib/agent-config.js

@@ -48,5 +48,10 @@ function mergeAgentConfigFlags(body, flags) {
     }
     if (flags['recursion-limit'] !== undefined)
         parsed.recursion_limit = flags['recursion-limit'];
+    // Cross-Space Task execution ceiling. `0` means unlimited, matching the
+    // Space limits' convention so a user learns one spelling of "no cap".
+    if (flags['max-concurrent-task-executions'] !== undefined) {
+        parsed.maxConcurrentTaskExecutions = flags['max-concurrent-task-executions'];
+    }
     return (0, prompt_1.mergeDefined)(body, parsed);
 }

package/dist/lib/agent-instructions.d.ts

@@ -0,0 +1,15 @@
+import { dataService, type AgentPromptComposition } from '@skrr-ai/data-provider';
+/** Positional and --agent forms agree with the existing `agents tone` UX. */
+export declare function resolveInstructionAgentId(argument?: string, flag?: string): Promise<string>;
+/** Fetch the edit-gated Agent projection used by the web composer. */
+export declare function loadAgentInstructions(agentId: string): Promise<{
+    agent: Awaited<ReturnType<typeof dataService.getExpandedAgentById>>;
+    composition: AgentPromptComposition;
+}>;
+/**
+ * The Agent controller is intentionally the only persistence boundary.  It
+ * resolves library versions, verifies bindings and materializes legacy
+ * `instructions` atomically, so a CLI never tries to compile a prompt itself.
+ */
+export declare function saveAgentInstructions(agentId: string, composition: AgentPromptComposition): Promise<import("@skrr-ai/data-provider").Agent>;
+export declare function renderCompositionLines(composition: AgentPromptComposition): string[];

package/dist/lib/agent-instructions.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInstructionAgentId = resolveInstructionAgentId;
+exports.loadAgentInstructions = loadAgentInstructions;
+exports.saveAgentInstructions = saveAgentInstructions;
+exports.renderCompositionLines = renderCompositionLines;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const agent_resolver_1 = require("./agent-resolver");
+const instruction_blocks_1 = require("./instruction-blocks");
+/** Positional and --agent forms agree with the existing `agents tone` UX. */
+async function resolveInstructionAgentId(argument, flag) {
+    return (0, agent_resolver_1.resolveAgentId)((0, agent_resolver_1.mergeExplicitAgentInputs)([
+        { label: 'argument', value: argument },
+        { label: '--agent', value: flag },
+    ]));
+}
+/** Fetch the edit-gated Agent projection used by the web composer. */
+async function loadAgentInstructions(agentId) {
+    const agent = await data_provider_1.dataService.getExpandedAgentById({ agent_id: agentId });
+    return { agent, composition: (0, instruction_blocks_1.compositionForAgent)(agent) };
+}
+/**
+ * The Agent controller is intentionally the only persistence boundary.  It
+ * resolves library versions, verifies bindings and materializes legacy
+ * `instructions` atomically, so a CLI never tries to compile a prompt itself.
+ */
+async function saveAgentInstructions(agentId, composition) {
+    return data_provider_1.dataService.updateAgent({
+        agent_id: agentId,
+        data: { promptComposition: composition },
+    });
+}
+function renderCompositionLines(composition) {
+    if (!composition.entries.length)
+        return ['(No custom instruction blocks.)'];
+    return composition.entries.flatMap((entry, index) => {
+        const state = entry.enabled ? 'on' : 'off';
+        if (entry.source.kind === 'inline') {
+            const preview = entry.source.body.trim().replace(/\s+/g, ' ').slice(0, 140);
+            return [
+                `${index + 1}. ${state.padEnd(3)} inline  ${entry.source.title}  (${entry.instanceId})`,
+                `     ${preview || '(empty)'}`,
+            ];
+        }
+        const label = entry.resolved?.name || entry.source.blockId;
+        const bindings = entry.bindings && Object.keys(entry.bindings).length
+            ? ` · bindings: ${Object.entries(entry.bindings)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(', ')}`
+            : '';
+        return [
+            `${index + 1}. ${state.padEnd(3)} library ${label} · v${entry.source.version}  (${entry.instanceId})${bindings}`,
+        ];
+    });
+}

package/dist/lib/api-fetch.d.ts

@@ -29,7 +29,8 @@ export declare class ApiFetchError extends Error {
     readonly status: number;
     readonly body?: string;
     readonly code?: string;
-    constructor(message: string, status: number, body?: string, code?: string);
+    readonly method?: string;
+    constructor(message: string, status: number, body?: string, code?: string, method?: string);
 }
 /**
  * Call a skrr API endpoint with the current credential. Throws

package/dist/lib/api-fetch.js

@@ -46,12 +46,19 @@ class ApiFetchError extends Error {
     status;
     body;
     code;
-    constructor(message, status, body, code) {
+    // The HTTP method of the failing request. The 403 branch of
+    // `handleApiError` needs to know whether the request even HAD a body before
+    // it can advise the user to "try again with less of the request body"
+    // (OSK-6765): `agents show` is a GET and had no body, and the advice was
+    // impossible to follow.
+    method;
+    constructor(message, status, body, code, method) {
         super(message);
         this.name = 'ApiFetchError';
         this.status = status;
         this.body = body;
         this.code = code;
+        this.method = method;
     }
 }
 exports.ApiFetchError = ApiFetchError;
@@ -189,7 +196,7 @@ async function apiFetch(pathOrUrl, opts = {}) {
         catch {
             /* ignore body read failures */
         }
-        throw new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code);
+        throw new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code, method);
     }
     // 204/205 carry no body by definition; an empty body has no content-type
     // worth judging. Neither is an error.

package/dist/lib/command-hygiene.d.ts

@@ -30,5 +30,10 @@ export type CommandHygieneReport = {
 };
 export declare function auditCommands({ rootDir, manifest, }: {
     rootDir: string;
-    manifest: CommandManifest;
+    /**
+     * The generated oclif catalogue is not present in a source checkout.  Such
+     * callers can still run source-level checks, but cannot make claims about
+     * what a generated manifest contains.
+     */
+    manifest?: CommandManifest;
 }): CommandHygieneReport;

package/dist/lib/command-hygiene.js

@@ -46,13 +46,14 @@ const AGENT_CRITICAL_COMMANDS = [
 ];
 function auditCommands({ rootDir, manifest, }) {
     const issues = [];
-    const commands = manifest.commands ?? {};
+    const commands = manifest?.commands ?? {};
     const commandIds = Object.keys(commands);
+    const manifestForCatalog = manifest ?? {};
     // The command manifest is the only catalogue. The progressive `skrr usage`
     // surfaces are useful precisely because they do not make an agent load that
     // whole catalogue at once, so audit every generated continuation page too.
-    const overview = (0, usage_discovery_1.buildUsageOverview)(manifest);
-    const usageBudgetIssues = (0, usage_discovery_1.auditUsageBudgets)(manifest);
+    const overview = (0, usage_discovery_1.buildUsageOverview)(manifestForCatalog);
+    const usageBudgetIssues = (0, usage_discovery_1.auditUsageBudgets)(manifestForCatalog);
     for (const issue of usageBudgetIssues) {
         issues.push({
             code: 'USAGE_DISCOVERY_TOKEN_BUDGET_EXCEEDED',
@@ -62,14 +63,31 @@ function auditCommands({ rootDir, manifest, }) {
                 `uses ${issue.estimatedTokens} estimated tokens; budget is ${issue.tokenBudget}.`,
         });
     }
-    for (const id of AGENT_CRITICAL_COMMANDS) {
-        if (!commands[id]) {
-            issues.push({
-                code: 'AGENT_CRITICAL_COMMAND_MISSING',
-                severity: 'error',
-                command: id,
-                message: `Agent-critical command is missing from the manifest: ${id}`,
-            });
+    if (!manifest) {
+        // Absence is a distinct answer from "missing", and it should be audible.
+        //
+        // Skipping silently means a source-only run reports a clean bill of health
+        // for a check it never performed. That is the shape that makes an audit
+        // untrustworthy — worse than a noisy one, because a green result stops
+        // meaning anything. A warning keeps the run green while saying which claim
+        // it is NOT making, and names the command that would let it.
+        issues.push({
+            code: 'AGENT_CRITICAL_COMMANDS_UNCHECKED',
+            severity: 'warning',
+            message: 'No command manifest was available, so the agent-critical command check did not run. ' +
+                'Build the CLI (`npx tsc -p tsconfig.build.json && npx oclif manifest` in cli/) to audit it.',
+        });
+    }
+    if (manifest) {
+        for (const id of AGENT_CRITICAL_COMMANDS) {
+            if (!commands[id]) {
+                issues.push({
+                    code: 'AGENT_CRITICAL_COMMAND_MISSING',
+                    severity: 'error',
+                    command: id,
+                    message: `Agent-critical command is missing from the manifest: ${id}`,
+                });
+            }
         }
     }
     let sourceAvailable = false;
@@ -129,23 +147,25 @@ function auditCommands({ rootDir, manifest, }) {
             message: 'Source command files are unavailable; source-level hygiene checks were skipped.',
         });
     }
-    for (const id of commandIds) {
-        const command = commands[id];
-        if (!command?.description?.trim()) {
-            issues.push({
-                code: 'COMMAND_DESCRIPTION_MISSING',
-                severity: 'warning',
-                command: id,
-                message: 'Command is missing a description in the manifest.',
-            });
-        }
-        if (!hasJsonFlag(command?.flags) && isMachineRelevantCommand(id)) {
-            issues.push({
-                code: 'JSON_SUCCESS_OUTPUT_MISSING',
-                severity: 'warning',
-                command: id,
-                message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
-            });
+    if (manifest) {
+        for (const id of commandIds) {
+            const command = commands[id];
+            if (!command?.description?.trim()) {
+                issues.push({
+                    code: 'COMMAND_DESCRIPTION_MISSING',
+                    severity: 'warning',
+                    command: id,
+                    message: 'Command is missing a description in the manifest.',
+                });
+            }
+            if (!hasJsonFlag(command?.flags) && isMachineRelevantCommand(id)) {
+                issues.push({
+                    code: 'JSON_SUCCESS_OUTPUT_MISSING',
+                    severity: 'warning',
+                    command: id,
+                    message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
+                });
+            }
         }
     }
     const errors = issues.filter((issue) => issue.severity === 'error').length;
@@ -167,7 +187,7 @@ function auditCommands({ rootDir, manifest, }) {
         usage: {
             overviewTokenBudget: overview.tokenBudget,
             overviewEstimatedTokens: overview.estimatedTokens,
-            domains: (0, usage_discovery_1.usageDomains)(manifest).length,
+            domains: (0, usage_discovery_1.usageDomains)(manifestForCatalog).length,
             budgetErrors: usageBudgetIssues.length,
         },
         issues,

package/dist/lib/commitments.d.ts

@@ -362,6 +362,29 @@ export declare const COMMITMENT_CREATE_KEYS: readonly ["agentId", "kind", "compa
  */
 export declare function normalizeCreateBody(input: Record<string, unknown>): Record<string, unknown>;
 export declare function parseIntervalToMs(input: string): number;
+/**
+ * Assemble the `watchedSources` array from CLI flags — one place, so `create`
+ * and `update` agree on which flags carry what.
+ *
+ * The `space` and `monitor` sources need a scope id (`config.spaceId` /
+ * `config.monitorId`) that the flat `--watch` enum cannot carry. The API
+ * rejects the whole write when one is missing (`SPACE_SOURCE_SCOPE_REQUIRED` /
+ * `INVALID_MONITOR_REFERENCE`) — the same shape that made this a finding: the
+ * CLI advertised the source but had no way to satisfy it.
+ *
+ * The companion flags (`--watch-space`, `--watch-monitor`) fill that gap and
+ * implicitly opt the source in, so the enum and its config cannot disagree.
+ * Space refs must be RESOLVED to canonical ids by the caller — this helper
+ * does not do the network round trip, so it is unit-testable on its own.
+ */
+export type WatchFlagInputs = {
+    watch?: string[];
+    metricKey?: string[];
+    /** Already resolved to canonical space ids by the caller. */
+    spaceIds?: string[];
+    monitorIds?: string[];
+};
+export declare function buildWatchedSources(inputs: WatchFlagInputs): Array<Record<string, unknown>> | undefined;
 /** The evidence-health shape carried on a check's `inputs`. */
 export type EvidenceHealthView = {
     state?: string | null;
@@ -429,6 +452,27 @@ export declare function effectiveAutonomyMode(check?: {
         policyTrace?: Array<Record<string, unknown>>;
     } | null;
 } | null): string | undefined;
+/**
+ * A `commitment_standstill` policyTrace entry, extracted from the latest
+ * check's decision. The arbiter appends it whenever a quiet posture is the
+ * ANSWER to "why nothing is happening" (`CommitmentControl/index.js` around
+ * the `record_only`/empty-action-plan branch). Every field except `reason` is
+ * optional, and old checks lack the entry entirely — so a missing entry means
+ * "the loop had nothing standstill-worthy to say", not "we don't know".
+ *
+ * Exported for tests.
+ */
+export declare function extractStandstillFromCheck(check?: {
+    decision?: {
+        policyTrace?: Array<Record<string, unknown>>;
+    } | null;
+} | null): {
+    reason: string;
+    layer?: string;
+    owner?: string;
+    fix?: string;
+    alsoConstrained?: Array<Record<string, unknown>>;
+} | null;
 /**
  * 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

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMMITMENT_CLI_EVALUATORS = exports.COMMITMENT_CREATE_KEYS = exports.COMMITMENT_REMEDIATION_ACTIONS = exports.COMMITMENT_FEEDBACK_KINDS = exports.commitmentApi = exports.commitmentPackApi = exports.MAX_COMMITMENT_INTERVAL_MS = exports.MIN_COMMITMENT_INTERVAL_MS = exports.COMMITMENT_AUTONOMY_MODES = exports.COMMITMENT_STATUSES = exports.COMMITMENT_CADENCE_MAX_TIMES = exports.COMMITMENT_CADENCE_TIME_PATTERN = exports.COMMITMENT_CADENCE_MODES = exports.COMMITMENT_TEMPLATE_IDS = exports.COMMITMENT_WATCHED_SOURCES = void 0;
 exports.normalizeCreateBody = normalizeCreateBody;
 exports.parseIntervalToMs = parseIntervalToMs;
+exports.buildWatchedSources = buildWatchedSources;
 exports.describeEvidenceHealth = describeEvidenceHealth;
 exports.describeIntervalMs = describeIntervalMs;
 exports.buildSuccessCriteria = buildSuccessCriteria;
 exports.cadenceLabel = cadenceLabel;
 exports.renderCommitmentList = renderCommitmentList;
 exports.effectiveAutonomyMode = effectiveAutonomyMode;
+exports.extractStandstillFromCheck = extractStandstillFromCheck;
 exports.describeAutonomyLine = describeAutonomyLine;
 exports.renderCommitmentSummary = renderCommitmentSummary;
 exports.describeWakeDecision = describeWakeDecision;
@@ -316,6 +318,66 @@ function parseIntervalToMs(input) {
     }
     return ms;
 }
+function buildWatchedSources(inputs) {
+    const watched = (inputs.watch ?? []).filter(Boolean);
+    const metricKeys = (inputs.metricKey ?? []).filter(Boolean);
+    const spaceIds = (inputs.spaceIds ?? []).filter(Boolean);
+    const monitorIds = (inputs.monitorIds ?? []).filter(Boolean);
+    const effective = new Set(watched);
+    if (spaceIds.length)
+        effective.add('space');
+    if (monitorIds.length)
+        effective.add('monitor');
+    if (effective.has('space') && spaceIds.length === 0) {
+        throw new Error('--watch space needs at least one --watch-space <space-id-or-ref>. ' +
+            'The `space` source requires a scope id, which the enum on its own cannot carry.');
+    }
+    if (effective.has('monitor') && monitorIds.length === 0) {
+        throw new Error('--watch monitor needs at least one --watch-monitor <monitor-id>. ' +
+            'The `monitor` source requires a scope id, which the enum on its own cannot carry.');
+    }
+    if (metricKeys.length && !effective.has('metrics')) {
+        throw new Error('--metric-key requires --watch metrics.');
+    }
+    if (effective.size === 0)
+        return undefined;
+    // Preserve caller order: --watch entries first (deduped), then any source
+    // that was only implied by a companion flag.
+    const orderedSources = [];
+    const seen = new Set();
+    for (const s of watched) {
+        if (!seen.has(s)) {
+            orderedSources.push(s);
+            seen.add(s);
+        }
+    }
+    for (const implied of ['space', 'monitor']) {
+        if (effective.has(implied) && !seen.has(implied)) {
+            orderedSources.push(implied);
+            seen.add(implied);
+        }
+    }
+    const rows = [];
+    for (const source of orderedSources) {
+        if (source === 'space') {
+            for (const spaceId of spaceIds) {
+                rows.push({ source, enabled: true, config: { spaceId } });
+            }
+        }
+        else if (source === 'monitor') {
+            for (const monitorId of monitorIds) {
+                rows.push({ source, enabled: true, config: { monitorId } });
+            }
+        }
+        else if (source === 'metrics' && metricKeys.length) {
+            rows.push({ source, enabled: true, config: { metricKeys } });
+        }
+        else {
+            rows.push({ source, enabled: true });
+        }
+    }
+    return rows;
+}
 /**
  * One line an author can act on, or nothing.
  *
@@ -480,6 +542,41 @@ function effectiveAutonomyMode(check) {
     }
     return undefined;
 }
+/**
+ * A `commitment_standstill` policyTrace entry, extracted from the latest
+ * check's decision. The arbiter appends it whenever a quiet posture is the
+ * ANSWER to "why nothing is happening" (`CommitmentControl/index.js` around
+ * the `record_only`/empty-action-plan branch). Every field except `reason` is
+ * optional, and old checks lack the entry entirely — so a missing entry means
+ * "the loop had nothing standstill-worthy to say", not "we don't know".
+ *
+ * Exported for tests.
+ */
+function extractStandstillFromCheck(check) {
+    const trace = check?.decision?.policyTrace;
+    if (!Array.isArray(trace))
+        return null;
+    for (const entry of trace) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        if (e.rule !== 'commitment_standstill')
+            continue;
+        const reason = typeof e.reason === 'string' ? e.reason : '';
+        if (!reason)
+            continue;
+        return {
+            reason,
+            layer: typeof e.layer === 'string' ? e.layer : undefined,
+            owner: typeof e.owner === 'string' ? e.owner : undefined,
+            fix: typeof e.fix === 'string' ? e.fix : undefined,
+            alsoConstrained: Array.isArray(e.alsoConstrained)
+                ? e.alsoConstrained
+                : undefined,
+        };
+    }
+    return null;
+}
 /**
  * The `Autonomy:` line — the stated mode, annotated when the latest check
  * actually ran at a STRICTER one (OSK-4881). Without the caveat, a commitment
@@ -538,6 +635,32 @@ latestCheck) {
     if (typeof commitment.state?.consecutiveUnresolvedChecks === 'number') {
         log(`Unresolved checks in a row:${` ${commitment.state.consecutiveUnresolvedChecks}`}`);
     }
+    // The load-bearing signal on a commitment that "reports active but never
+    // acts": the arbiter names WHY every recent check decided to do nothing, but
+    // that entry sat only in `policyTrace` on each check and was never rendered.
+    // Read at check time, unrolled here so a person reading the header sees the
+    // same conclusion the check already reached — and the `fix` string that was
+    // already written for them.
+    const standstill = extractStandstillFromCheck(latestCheck);
+    if (standstill) {
+        const streak = commitment.state?.consecutiveUnresolvedChecks;
+        const streakClause = typeof streak === 'number' && streak >= 2 ? `${streak} checks in a row: ` : '';
+        log(`Standstill:${` ${streakClause}${standstill.reason}`}`);
+        if (standstill.fix)
+            log(`           Fix: ${standstill.fix}`);
+        if (standstill.alsoConstrained?.length) {
+            const also = standstill.alsoConstrained
+                .map((entry) => {
+                if (!entry || typeof entry !== 'object')
+                    return null;
+                const reason = entry.reason;
+                return typeof reason === 'string' ? reason : null;
+            })
+                .filter((r) => Boolean(r));
+            if (also.length)
+                log(`           Also constrained: ${also.join(', ')}`);
+        }
+    }
     const sources = (commitment.watchedSources || [])
         .filter((s) => s.enabled !== false)
         .map((s) => s.source);

package/dist/lib/daemon-binding.d.ts

@@ -21,9 +21,8 @@
 /** Whether `argv` already carries `--name` or `--name=value` (or `-alias`). */
 export declare function hasFlag(argv: readonly string[], name: string, alias?: string): boolean;
 /**
- * Append `--server` / `--profile` describing the CLI's own session, for any
- * the caller did not pass. An explicit flag always wins — this only fills a
- * silence, so `skrr daemon install --env prod` still installs against prod
- * while the CLI sits on dev.
+ * Fill `--server` / `--profile` from the CLI's own session when the caller did
+ * not pass them. The runtime's profile is global, so normalize it before the
+ * subcommand even when the caller supplied it after one.
  */
 export declare function bindToCliSession(argv: readonly string[]): string[];