@skrr-ai/cli 0.1.49 → 0.1.51

package/dist/commands/balance/show.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderRuntimeSpend = renderRuntimeSpend;
+exports.renderSessionBillingAccount = renderSessionBillingAccount;
 exports.renderPlanCeilings = renderPlanCeilings;
 const core_1 = require("@oclif/core");
 const auth_core_1 = require("@skrr-ai/auth-core");
@@ -37,6 +38,45 @@ function renderRuntimeSpend(spend, log) {
         }
     }
 }
+/**
+ * The account the NEXT session bills against, as lines — printed FIRST (OSK-12122).
+ *
+ * `skrr balance` opened on the personal account, so a user whose sessions bill
+ * the default workspace read `Credits: 999,503,672,326 ($999,503.67)` while every
+ * session was refused against that workspace's $0. The screen that exists to
+ * answer "why was I refused for credit" answered for the one account the
+ * refusal was not about, and nothing on it said which account that was.
+ *
+ * `balance` absent means the read failed: say so, never print a figure.
+ * Pure so the wording is pinned directly, like `renderRuntimeSpend`.
+ */
+function renderSessionBillingAccount(target, balance, log, bin = 'skrr') {
+    const label = target.name ? `"${target.name}" (${target.workspaceId})` : target.workspaceId;
+    const why = target.source === 'selected'
+        ? 'the workspace selected for this CLI'
+        : 'no workspace is selected, so sessions resolve to your default workspace';
+    log(`Next session bills: workspace ${label}`);
+    log(`  (${why})`);
+    if (!balance) {
+        log(`  Balance:        unavailable (\`${bin} balance show --workspace ${target.workspaceId}\` to retry)`);
+        return;
+    }
+    if (!balance.exists) {
+        log('  No billing account yet — nothing has ever been funded or spent here.');
+        log('  WARNING: a managed session carrying this workspace cannot be funded; it will be refused.');
+    }
+    else {
+        for (const line of (0, balance_1.workspaceBalanceLines)(balance))
+            log(line);
+        if (balance.availableMicros <= 0) {
+            log('  WARNING: nothing available — managed sessions billed here are refused for credit, ' +
+                'whatever your personal balance below says.');
+        }
+    }
+    if (balance.availableMicros <= 0) {
+        log(`  Add credit to this workspace, or bill another one with \`${bin} workspaces use <workspace>\`.`);
+    }
+}
 /**
  * Your plan's ceilings, as lines.
  *
@@ -135,17 +175,42 @@ class BalanceShow extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
+        // OSK-12122 — the account the next session bills, resolved the way the
+        // session resolves it, read before anything is printed so it can go first.
+        const sessionTarget = await this.resolveSessionBillingTarget();
+        let sessionBalance = null;
+        if (sessionTarget) {
+            try {
+                sessionBalance = await (0, balance_1.getWorkspaceBalance)(sessionTarget.workspaceId);
+            }
+            catch {
+                sessionBalance = null;
+            }
+        }
         if (flags.json) {
-            this.log(JSON.stringify(balance, null, 2));
+            // Additive: the personal balance keeps its shape, and the account a
+            // session bills rides beside it (`null` when no workspace resolves).
+            this.log(JSON.stringify({
+                ...(balance ?? {}),
+                sessionBilling: sessionTarget
+                    ? { ...sessionTarget, balance: sessionBalance, balanceReadable: !!sessionBalance }
+                    : null,
+            }, null, 2));
             return;
         }
         if (!balance) {
             this.error('No balance record for this account.', { exit: 1 });
         }
+        if (sessionTarget) {
+            renderSessionBillingAccount(sessionTarget, sessionBalance, (line) => this.log(line), this.config.bin);
+            this.log('');
+        }
         // Name the account. "Hosted usage balance" alone reads as "the balance
         // that matters here", which is exactly the wrong reading for someone sent
         // by a workspace refusal.
-        this.log('Hosted usage balance — your personal account');
+        this.log(sessionTarget
+            ? 'Hosted usage balance — your personal account (not what the session above bills)'
+            : 'Hosted usage balance — your personal account');
         // Credits AND dollars, because a credit is a micro-dollar and nothing on
         // this surface said so. Four spend screens reported four units with no
         // stated relationship between them (OSK-4664).
@@ -235,6 +300,31 @@ class BalanceShow extends base_command_1.BaseCommand {
         this.log('`skrr balance show --workspace <id>`. `skrr payments wallet` is the');
         this.log('separate x402 crypto wallet, in USDC — not this balance.');
     }
+    /**
+     * Which workspace the next session carries: the selected one, else the
+     * caller's default. Fail-open — an unreadable listing with nothing selected
+     * returns null and the screen falls back to the personal view it always had,
+     * rather than guessing an account.
+     */
+    async resolveSessionBillingTarget() {
+        const selected = process.env.OVERSKY_WORKSPACE_ID?.trim();
+        let listing = null;
+        try {
+            listing = await (0, workspaces_1.listWorkspaceListing)();
+        }
+        catch {
+            listing = null;
+        }
+        const workspaceId = selected || listing?.defaultWorkspaceId || null;
+        if (!workspaceId)
+            return null;
+        const name = listing?.rows.find((row) => row.id === workspaceId)?.name;
+        return {
+            workspaceId,
+            ...(name ? { name } : {}),
+            source: selected ? 'selected' : 'default',
+        };
+    }
     /**
      * Your plan's ceilings, beside the balance they are spent before.
      *

package/dist/commands/code/index.d.ts

@@ -39,4 +39,5 @@ export default class Code extends Command {
  */
 export declare function forwardToEngine(cmd: Command, subcommand: string | null, passthrough: string[], options?: {
     managed?: boolean;
+    projectPolicy?: 'tui' | 'headless';
 }): Promise<void>;

package/dist/commands/code/index.js

@@ -6,6 +6,7 @@ const auth_core_1 = require("@skrr-ai/auth-core");
 const first_party_harness_1 = require("../../lib/first-party-harness");
 const first_party_harness_broker_1 = require("../../lib/first-party-harness-broker");
 const first_party_harness_managed_1 = require("../../lib/first-party-harness-managed");
+const first_party_harness_project_trust_1 = require("../../lib/first-party-harness-project-trust");
 /**
  * `skrr code` — launch the first-party harness's interactive coding TUI in the
  * current directory.
@@ -29,7 +30,12 @@ class Code extends core_1.Command {
     static description = 'Everything after ' +
         `\`code\` is forwarded to the engine unchanged, so engine flags are not listed here — ` +
         `run \`${auth_core_1.FIRST_PARTY_HARNESS.command} run --help\` for this wrapper, or the engine's own help for its ` +
-        `flags. ${first_party_harness_managed_1.SKRR_AGENT_FLAG} is the one flag this wrapper consumes itself.`;
+        `flags. This wrapper consumes three flags itself: ${first_party_harness_managed_1.SKRR_AGENT_FLAG}, ` +
+        `${first_party_harness_project_trust_1.TRUST_PROJECT_FLAG} (load this project's own configuration — plugins, tools, MCP ` +
+        `servers, permissions — which is otherwise NOT loaded until you trust the project; ` +
+        `the TUI asks once when a project ships any), and ${first_party_harness_project_trust_1.ENGINE_PERMISSIONS_FLAG} (let your ` +
+        `engine config decide permissions instead of the TUI default: reads run, edits, ` +
+        `commands and web access ask).`;
     static strict = false;
     static examples = [
         '<%= config.bin %> code',
@@ -37,6 +43,8 @@ class Code extends core_1.Command {
         `<%= config.bin %> code ${first_party_harness_managed_1.SKRR_AGENT_FLAG} Engineer`,
         '<%= config.bin %> code run "fix the failing test"',
         '<%= config.bin %> code doctor',
+        `<%= config.bin %> code ${first_party_harness_project_trust_1.TRUST_PROJECT_FLAG}`,
+        `<%= config.bin %> code ${first_party_harness_project_trust_1.ENGINE_PERMISSIONS_FLAG}`,
     ];
     async run() {
         // `this.argv`, NOT `this.parse()`. oclif's `strict = false` relaxes POSITIONAL
@@ -52,7 +60,7 @@ class Code extends core_1.Command {
         //
         // The unit tests did not catch it because they cover `buildEngineArgs`, which
         // always forwarded verbatim. The args never reached it.
-        await forwardToEngine(this, null, this.argv, { managed: true });
+        await forwardToEngine(this, null, this.argv, { managed: true, projectPolicy: 'tui' });
     }
 }
 exports.default = Code;
@@ -79,7 +87,8 @@ exports.default = Code;
 async function forwardToEngine(cmd, subcommand, passthrough, options = {}) {
     // Unconditional: the engine must never see a flag it does not declare, whether
     // or not this run brokers. `skrr code --agent x` remains the ENGINE's flag.
-    const { agentRef, engineArgv } = (0, first_party_harness_managed_1.takeOverskyAgentFlag)(passthrough);
+    const policyFlags = (0, first_party_harness_project_trust_1.takeProjectPolicyFlags)(passthrough);
+    const { agentRef, engineArgv } = (0, first_party_harness_managed_1.takeOverskyAgentFlag)(policyFlags.engineArgv);
     // `logToStderr`, never `log`: `skrr code run --json` writes machine-readable
     // output on stdout, and one friendly sentence in the middle of it is a parse
     // error at the other end.
@@ -88,6 +97,29 @@ async function forwardToEngine(cmd, subcommand, passthrough, options = {}) {
         say(`${first_party_harness_managed_1.SKRR_AGENT_FLAG} has no effect here — this command does not host a managed ` +
             'session. It was removed from the arguments passed to the engine.');
     }
+    // OSK-11958 — the project's own configuration can run code on this machine
+    // and loosen permissions, so it is not loaded until the person trusts the
+    // project. Decided BEFORE any lease is acquired: a refusal to answer must not
+    // cost a broker. Only the TUI and `run` — an engine subcommand such as
+    // `trust` must see the project config it exists to approve, and `acp` is
+    // the daemon's, which sets its own.
+    const projectDir = options.projectPolicy === 'tui'
+        ? (0, first_party_harness_project_trust_1.tuiProjectDir)(engineArgv, process.cwd())
+        : options.projectPolicy === 'headless'
+            ? process.cwd()
+            : null;
+    const policy = options.projectPolicy && projectDir
+        ? await (0, first_party_harness_project_trust_1.resolveProjectPolicy)({
+            cwd: projectDir,
+            env: process.env,
+            mode: options.projectPolicy,
+            trustProject: policyFlags.trustProject,
+            enginePermissions: policyFlags.enginePermissions,
+            ask: options.projectPolicy === 'tui' ? (0, first_party_harness_project_trust_1.ttyTrustAsker)() : undefined,
+        })
+        : null;
+    for (const notice of policy?.notices ?? [])
+        say(notice);
     const managed = options.managed
         ? (0, first_party_harness_broker_1.createManagedEngineHooks)({
             subcommand,
@@ -106,10 +138,22 @@ async function forwardToEngine(cmd, subcommand, passthrough, options = {}) {
                 // skipped or failed attempt is a genuine BYOK run whose credential is
                 // the ambient one. Only the hooks know which happened.
                 credentialMode: managed.credentialMode,
+                policyEnv: policy?.env,
+            }
+            : { policyEnv: policy?.env });
+        if (code !== 0) {
+            // The engine ran with no managed session and no credential to inherit —
+            // its failure (typically a bare "Unexpected server error") names nothing
+            // the user can act on. The prepare-time warning already diagnosed this;
+            // say it again where the failure lands, because a warning scrolled past
+            // is not a diagnosis at the point of failure (OSK-11949).
+            if (managed?.unprovisionedByok()) {
+                say('No managed session and no provider credential reached the engine — if ' +
+                    'the failure above is an authentication or server error, sign in with ' +
+                    '`skrr login` or set OPENROUTER_API_KEY and retry.');
             }
-            : {});
-        if (code !== 0)
             cmd.exit(code);
+        }
     }
     catch (err) {
         if (err instanceof first_party_harness_1.EngineStartRefusedError) {

package/dist/commands/code/run.js

@@ -16,6 +16,7 @@ class CodeRun extends core_1.Command {
         '<%= config.bin %> code run "add a regression test for the parser"',
         '<%= config.bin %> code run --json "summarize the diff"',
         '<%= config.bin %> code run --oversky-agent Engineer "fix the failing test"',
+        '<%= config.bin %> code run --trust-project "run the project\'s own lint plugin"',
     ];
     async run() {
         // `this.argv`, NOT `this.parse()`. oclif's `strict = false` relaxes POSITIONAL
@@ -31,7 +32,10 @@ class CodeRun extends core_1.Command {
         //
         // The unit tests did not catch it because they cover `buildEngineArgs`, which
         // always forwarded verbatim. The args never reached it.
-        await (0, index_1.forwardToEngine)(this, 'run', this.argv, { managed: true });
+        // `headless`: project configuration is gated exactly as for the TUI, but
+        // nobody is asked and the engine keeps its own permission config — an `ask`
+        // default would be auto-rejected by a headless run (OSK-11958).
+        await (0, index_1.forwardToEngine)(this, 'run', this.argv, { managed: true, projectPolicy: 'headless' });
     }
 }
 exports.default = CodeRun;

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

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * The Cycle is the unit a person reads: one row per check (and per wake that
+ * never became one), each with one outcome and, when it stopped, the one
+ * reason and what to do about it.
+ */
+export default class CommitmentsCycles extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        commitmentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/cycles.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 commitments_1 = require("../../lib/commitments");
+/**
+ * The Cycle is the unit a person reads: one row per check (and per wake that
+ * never became one), each with one outcome and, when it stopped, the one
+ * reason and what to do about it.
+ */
+class CommitmentsCycles extends base_command_1.BaseCommand {
+    static description = "List a commitment's cycles, newest first: what woke it, how each ended, and why it stopped";
+    static examples = [
+        '<%= config.bin %> commitments cycles obj_abc123',
+        '<%= config.bin %> commitments cycles obj_abc123 --limit 50 --json',
+        '<%= config.bin %> commitments cycles obj_abc123 --cursor <next_cursor>',
+    ];
+    static args = {
+        commitmentId: core_1.Args.string({ ignoreStdin: true, description: 'Commitment ID', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        limit: core_1.Flags.integer({ description: 'Max checks per page (1-50)', min: 1, max: 50 }),
+        cursor: core_1.Flags.string({ description: 'Opaque cursor returned by the preceding page' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsCycles);
+        try {
+            const page = await commitments_1.commitmentApi.cycles(args.commitmentId, {
+                ...(typeof flags.limit === 'number' ? { limit: flags.limit } : {}),
+                ...(flags.cursor ? { cursor: flags.cursor } : {}),
+            });
+            if (flags.json) {
+                this.log(JSON.stringify(page, null, 2));
+                return;
+            }
+            for (const line of (0, commitments_1.formatCommitmentCycles)(page))
+                this.log(line);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = CommitmentsCycles;

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

@@ -6,6 +6,7 @@ export declare function doctorVerdict(input: {
 }): {
     verdict: string;
     next: string;
+    why?: string;
 };
 export default class CommitmentsDoctor extends BaseCommand {
     static description: string;

package/dist/commands/commitments/doctor.js

@@ -15,8 +15,12 @@ function doctorVerdict(input) {
     if (operatingState.status === 'waiting_approval') {
         return { verdict: 'waiting_approval', next: 'Open the pending prepared action for review' };
     }
-    if (operatingState.coverage && operatingState.coverage.complete === false) {
-        return { verdict: 'degraded', next: 'Retry doctor; one or more operating-state projections are unavailable' };
+    if (operatingState.coverage &&
+        operatingState.coverage.complete === false) {
+        return {
+            verdict: 'degraded',
+            next: 'Retry doctor; one or more operating-state projections are unavailable',
+        };
     }
     const autonomy = operatingState.autonomy;
     const budget = autonomy?.budget;
@@ -30,9 +34,18 @@ function doctorVerdict(input) {
     }
     if (operatingState.status && commitment.status === 'active') {
         const status = String(operatingState.status);
+        const healthy = ['on_track', 'healthy'].includes(status);
+        // Where the latest cycle stopped, as the server words it. "Read the raw
+        // trace" was the only next step an unhealthy Commitment was ever given,
+        // even when the stop already named the fix (OSK-12120).
+        const latestCheck = operatingState.latestCheck;
+        const stop = latestCheck?.stop;
+        const fix = typeof stop?.fix === 'string' && stop.fix ? stop.fix : undefined;
+        const why = typeof stop?.detail === 'string' && stop.detail ? stop.detail : undefined;
         return {
-            verdict: ['on_track', 'healthy'].includes(status) ? 'active_healthy' : status,
-            next: 'skrr commitments trace <id> --limit 50',
+            verdict: healthy ? 'active_healthy' : status,
+            next: !healthy && fix ? fix : 'skrr commitments trace <id> --limit 50',
+            ...(!healthy && why ? { why } : {}),
         };
     }
     if (commitment.status !== 'active')
@@ -81,6 +94,8 @@ class CommitmentsDoctor extends base_command_1.BaseCommand {
             this.log(JSON.stringify(report, null, 2));
         else {
             this.log(`Verdict: ${diagnosis.verdict}`);
+            if (diagnosis.why)
+                this.log(`Why:     ${diagnosis.why}`);
             this.log(`Next:    ${diagnosis.next.replace('<id>', args.id)}`);
             const autonomy = operatingState.autonomy;
             if (autonomy) {

package/dist/commands/commitments/effective-policy.js

@@ -5,10 +5,19 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
 const commitment_product_1 = require("../../lib/commitment-product");
+/** Which limit binds the daily action runs — the fix lives on that object. */
+const RUN_LIMIT_BINDING_LABELS = {
+    northstar_allocation: 'Northstar allocation',
+    workspace_admin: 'workspace limit',
+    owner: 'owner limit',
+};
 function effectivePolicyLines(policy) {
     const governance = policy.governance || {};
     const owner = policy.owner || {};
     const lines = [`Mode in force: ${(0, commitment_product_1.productModeLabel)(governance.effectiveAutonomyMode)}`];
+    // Whose permissions a run uses (OSK-11975), directly under the mode it can
+    // contradict — an Execute Commitment on a plan-mode Agent (OSK-12065).
+    lines.push(...(0, commitments_1.permissionLines)(policy.permissions));
     if (governance.blocked) {
         lines.push(`Workspace status: blocked${governance.blockedReason ? ` — ${governance.blockedReason}` : ''}`);
     }
@@ -28,17 +37,47 @@ function effectivePolicyLines(policy) {
     if (Array.isArray(governance.allowedCommitmentDeliveryModes)) {
         lines.push(`Workspace delivery allowlist: ${governance.allowedCommitmentDeliveryModes.length ? governance.allowedCommitmentDeliveryModes.map(commitment_product_1.deliveryLabel).join(', ') : 'none'}`);
     }
-    if (Array.isArray(governance.requireAttestedAccessForDeliveryModes) && governance.requireAttestedAccessForDeliveryModes.length) {
+    if (Array.isArray(governance.requireAttestedAccessForDeliveryModes) &&
+        governance.requireAttestedAccessForDeliveryModes.length) {
         lines.push(`Runtime attestation required for: ${governance.requireAttestedAccessForDeliveryModes.map(commitment_product_1.deliveryLabel).join(', ')}`);
     }
     const runLimit = owner.actionRunsPerDay;
     if (runLimit) {
         lines.push(`Owner action-run limit: ${runLimit.mode === 'unbounded' ? 'Unlimited' : `${runLimit.value}/day`}`);
     }
+    const effectiveRuns = policy.effective?.actionRunsPerDay;
+    if (effectiveRuns) {
+        const bindingLabel = RUN_LIMIT_BINDING_LABELS[effectiveRuns.binding];
+        const binding = bindingLabel ? ` (binding: ${bindingLabel})` : '';
+        lines.push(`Effective action-run limit: ${effectiveRuns.mode === 'unbounded' ? 'Unlimited' : `${effectiveRuns.value}/day`}${binding}`);
+    }
     const cost = policy.billing;
     if (cost?.effectiveCostLimitUsd != null) {
         lines.push(`Effective daily cost limit: $${Number(cost.effectiveCostLimitUsd).toFixed(2)}`);
     }
+    // What a sensing turn's fence holds (OSK-11978). The shell line carries the
+    // part that is NOT enforced, because that is the one an operator granting
+    // it has to see.
+    const observation = policy.observation;
+    if (observation?.sensing && observation.retired) {
+        // OSK-11975 retired the sensing fence: printing "granted — read-only" for
+        // a grant that no longer fences anything is the claim this must not make.
+        const recorded = [
+            observation.shell?.granted ? 'shell' : null,
+            observation.browser?.granted ? 'browser' : null,
+        ].filter(Boolean);
+        lines.push(`Sensing runs: the Agent's own permissions${recorded.length
+            ? ` (recorded ${recorded.join(' and ')} grant is retired and has no effect)`
+            : ''}`);
+    }
+    else if (observation?.sensing) {
+        lines.push(`Sensing shell: ${observation.shell?.granted
+            ? 'granted — read-only filesystem on the Hosted Machine; network NOT fenced (a command can still change remote state); withheld on your own machine'
+            : 'not granted'}`);
+        lines.push(`Sensing browser: ${observation.browser?.granted
+            ? 'granted — read-only, enforced by your machine'
+            : 'not granted'}`);
+    }
     return lines;
 }
 /** Show the policy actually governing a Commitment without changing it. */

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

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Walk the latest cycle as six questions — did anything wake it, was there new
+ * evidence, was it its turn, did the agent think, did it act, did it tell you —
+ * and name the first "no" with its fix.
+ */
+export default class CommitmentsExplain extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        commitmentId: 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/explain.js

@@ -0,0 +1,40 @@
+"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");
+/**
+ * Walk the latest cycle as six questions — did anything wake it, was there new
+ * evidence, was it its turn, did the agent think, did it act, did it tell you —
+ * and name the first "no" with its fix.
+ */
+class CommitmentsExplain extends base_command_1.BaseCommand {
+    static description = 'Explain where the latest cycle of a commitment stopped, as six yes/no questions';
+    static examples = [
+        '<%= config.bin %> commitments explain obj_abc123',
+        '<%= config.bin %> commitments explain obj_abc123 --json',
+    ];
+    static args = {
+        commitmentId: core_1.Args.string({ ignoreStdin: true, description: 'Commitment ID', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsExplain);
+        try {
+            const explanation = await commitments_1.commitmentApi.explain(args.commitmentId);
+            if (flags.json) {
+                this.log(JSON.stringify(explanation, null, 2));
+                return;
+            }
+            for (const line of (0, commitments_1.formatCommitmentExplanation)(explanation))
+                this.log(line);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = CommitmentsExplain;

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

@@ -75,7 +75,9 @@ function formatNextTick(projection) {
         `Posture:    ${decision.posture ?? '-'}`,
         `Health:     ${decision.health ?? '-'}`,
         `Risk:       ${decision.riskLevel ?? '-'}`,
-        `Confidence: ${decision.confidence ?? '-'}`,
+        // Two decimals: the arbiter's arithmetic yields values like
+        // 0.6000000000000001, which reads as a precision the number does not have.
+        `Confidence: ${typeof decision.confidence === 'number' ? decision.confidence.toFixed(2) : '-'}`,
     ];
     if (decision.whyNow)
         lines.push(`Why now:    ${decision.whyNow}`);

package/dist/commands/commitments/preflight.js

@@ -110,6 +110,16 @@ class CommitmentsPreflight extends base_command_1.BaseCommand {
             return;
         }
         this.log(`${args.id ? 'Preflight' : 'Pre-create preview (nothing persisted)'}: ${report.verdict === 'ready' ? 'Ready to run' : report.verdict === 'blocked' ? 'Run is blocked' : 'A capability or configuration check is still needed'}`);
+        // Whose permissions the run will use (OSK-11975), before the gates, so an
+        // Execute Commitment on a plan-mode Agent is the first thing read
+        // (OSK-12065).
+        for (const line of (0, commitments_1.permissionLines)(report.permissions))
+            this.log(line);
+        if (flags.verbose) {
+            const retired = (0, commitments_1.retiredFieldsLine)(report.execution?.retired, report.execution?.retiredReason);
+            if (retired)
+                this.log(retired);
+        }
         this.log('\nGates:');
         for (const gate of report.gates || []) {
             for (const line of preflightGateLines(gate, flags.verbose))

package/dist/commands/commitments/show.js

@@ -50,6 +50,11 @@ class CommitmentsShow extends base_command_1.BaseCommand {
             return;
         }
         (0, commitments_1.renderCommitmentSummary)(response.commitment, (line) => this.log(line), response.latestCheck);
+        // Whose permissions a run uses (OSK-11975) — read from the operating state,
+        // which carries the same projection preflight reports (OSK-12065).
+        const autonomy = response.operatingState?.autonomy;
+        for (const line of (0, commitments_1.permissionLines)(autonomy?.permissions))
+            this.log(line);
         // `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).
@@ -101,8 +106,13 @@ class CommitmentsShow extends base_command_1.BaseCommand {
             this.log('');
             this.log(`Full history:  ${this.config.bin} commitments checks ${args.id}`);
         }
-        if (flags.verbose)
+        if (flags.verbose) {
             this.log(`Compatibility policy: ${JSON.stringify(response.commitment.policy)}`);
+            const runtime = autonomy?.runtime;
+            const retired = (0, commitments_1.retiredFieldsLine)(runtime?.retired, runtime?.retiredReason);
+            if (retired)
+                this.log(retired);
+        }
         const url = (0, web_url_1.commitmentUrlFrom)(this.cliConfig.baseURL, response.commitment);
         if (url)
             this.log(`URL: ${url}`);

package/dist/commands/daemon/config.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+/**
+ * `skrr daemon config` — set this machine's daemon configuration, including
+ * each tool category's permission mode (OSK-12099). Before this the only way
+ * to set a category was to guess the separate `skrrd` binary exists; every
+ * other daemon verb was forwarded and this one was not.
+ */
+export default class DaemonConfig extends Command {
+    static aliases: string[];
+    static summary: string;
+    static description: string;
+    static strict: boolean;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/daemon/config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const exec_runtime_binary_1 = require("../../lib/exec-runtime-binary");
+/**
+ * `skrr daemon config` — set this machine's daemon configuration, including
+ * each tool category's permission mode (OSK-12099). Before this the only way
+ * to set a category was to guess the separate `skrrd` binary exists; every
+ * other daemon verb was forwarded and this one was not.
+ */
+class DaemonConfig extends core_1.Command {
+    static aliases = ['daemons:config'];
+    static summary = "Set the local daemon's configuration, e.g. a tool category's permission mode";
+    static description = (0, exec_runtime_binary_1.forwardedFlagsNote)('config');
+    static strict = false; // forward all args verbatim — see run()
+    static examples = [
+        '<%= config.bin %> daemon config --mode bash=manual',
+        '<%= config.bin %> daemon config --mode bash=auto --mode browser=auto',
+        '<%= config.bin %> daemon config --require-approvals',
+    ];
+    async run() {
+        // `this.argv`, NOT `this.parse()`: oclif would reject every `skrrd config`
+        // flag this wrapper has not redeclared (OSK-296).
+        const argv = this.argv;
+        try {
+            const code = await (0, exec_runtime_binary_1.execRuntimeBinary)(['config', ...argv]);
+            this.exit(code);
+        }
+        catch (err) {
+            if (err.message === 'runtime-binary-not-installed') {
+                this.log((0, exec_runtime_binary_1.notInstalledMessage)());
+                this.exit(127);
+            }
+            throw err;
+        }
+    }
+}
+exports.default = DaemonConfig;

package/dist/commands/daemon/index.js

@@ -47,6 +47,7 @@ class Daemon extends core_1.Command {
         this.log('  skrr daemon stop       — stop the daemon');
         this.log('  skrr daemon update     — update the daemon binary to the latest signed release');
         this.log('  skrr daemon status     — show running state and config');
+        this.log('  skrr daemon config     — set config, e.g. a tool category: --mode bash=manual');
         this.log('  skrr daemon logs       — tail recent daemon logs');
         this.log('  skrr daemon recover-offline-queue — restore recoverable offline WALs');
         this.log('  skrr daemon usage      — show local Claude Code and Codex usage limits');