@skrr-ai/cli 0.1.48 → 0.1.50

package/README.md

@@ -1247,11 +1247,12 @@ Create a new goal. `--title` is required unless supplied via `--from-json`.
 ```bash
 sky goals create --title "Ship Q2 roadmap"
 sky goals create --title "Milestone 1" --level milestone --parent <parent-id>
+sky goals create --title "Launch" --label <existing-label-id>
 sky goals create --from-json goal.json
 ```
 
 Flags: `--title`, `--description`, `--level`, `--parent`, `--owner-agent`,
-`--dri-agent`, `--dri-user`, `--from-json <file|->`, `--json`.
+`--dri-agent`, `--dri-user`, `--label` (repeatable), `--from-json <file|->`, `--json`.
 
 ### `sky goals update <id>`
 
@@ -1351,7 +1352,7 @@ sky tasks create --title "QA pass" \
   --assignee-agent <agent-id> \
   --assignee-agent <other-agent-id> \
   --tag release --tag urgent \
-  --label-id <existing-label-id>
+  --label <existing-label-id>
 sky tasks create --title "Follow up" --source-conversation <conversation-id>
 sky tasks create --title "Spec task" --external-key ws0/spec --dry-run --json
 sky tasks create --from-json task.json
@@ -1379,14 +1380,14 @@ are globally resolvable.
 
 Tags are lightweight free-form keywords. Labels are shared workspace taxonomy
 and are attached by opaque ID; discover existing IDs with
-`sky tasks labels list --json`. Both are optional and repeatable at creation.
+`sky labels list --applicable-to task`. Both are optional and repeatable at creation.
 
 Flags: `--title`, `--description`, `--description-format`, `--external-key`,
 `--default-agent`,
 `--priority`, `--parent`, `--space`, `--goal`,
 `--source-conversation`, `--source-message`, `--assignee-agent`
 (repeatable), `--assignee-user` (repeatable), `--due-date`, `--tag`
-(repeatable), `--label-id` (repeatable), `--from-json <file|->`, `--dry-run`,
+(repeatable), `--label` (repeatable; `--label-id` is a compatibility alias), `--from-json <file|->`, `--dry-run`,
 `--json`.
 
 ### `sky tasks upsert`

package/dist/base-command.js

@@ -298,10 +298,22 @@ class BaseCommand extends core_1.Command {
                     const accessToken = autoResult.outcome.accessToken;
                     this.resolvedCredential = {
                         token: accessToken,
-                        // The backend the broker actually wrote to. Hard-coding
-                        // 'keychain' labelled a Linux credential (always the file)
-                        // "macOS Keychain" in the same process that minted it.
-                        source: autoResult.outcome.storedIn === 'keychain' ? 'keychain' : 'file',
+                        // A `brokered` outcome is a daemon-owned access token held for
+                        // THIS process only — nothing was persisted, so no stored-backend
+                        // label applies. 'env-token' is the honest slot the shared
+                        // CredentialSource union has for "a token this process holds in
+                        // memory": `ensureFreshCliCredential` skips non-stored sources,
+                        // which is correct — renewal happens by re-redeeming the
+                        // descriptor (see api-fetch's 401 path), not by rotating a
+                        // family that was never ours.
+                        source: autoResult.outcome.brokered
+                            ? 'env-token'
+                            : // The backend the broker actually wrote to. Hard-coding
+                                // 'keychain' labelled a Linux credential (always the file)
+                                // "macOS Keychain" in the same process that minted it.
+                                autoResult.outcome.storedIn === 'keychain'
+                                    ? 'keychain'
+                                    : 'file',
                         kind: (0, auth_core_1.classifyTokenKind)(accessToken),
                     };
                 }

package/dist/commands/agent-worker.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class AgentWorker extends Command {
+    static summary: string;
+    static description: string;
+    static flags: {
+        socket: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'heartbeat-ms': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /** `revoked`/`invalid_handle` — the binding is gone, not the transport. */
+    private bindingRefused;
+}

package/dist/commands/agent-worker.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const guest_service_1 = require("../lib/guest-service");
+/**
+ * `skrr agent-worker` — the long-lived guest agent worker (§10.2).
+ *
+ * The blessed `agent` service template runs this command inside a Dedicated
+ * Runtime guest. The control plane mints the binding at service-create admit
+ * and injects it into the spec's env:
+ *
+ *   SKRR_AGENT_ID      the agent this worker holds presence for
+ *   SKRR_AGENT_HANDLE  the presence capability — `awh_<id>.aws_<secret>`
+ *
+ * On start the worker registers with the daemon's broker socket, then
+ * heartbeats until it is stopped (SIGTERM → bye) or the binding is revoked —
+ * `service remove` deletes the spec, the broker's next answer is `revoked`,
+ * and the worker exits. The service lifecycle IS the handle lifecycle.
+ *
+ * The handle is never logged and never echoed — the daemon's reply names the
+ * agent and service it validated, which is everything worth printing.
+ */
+const DEFAULT_SOCKET = '/run/skrr-dedicated-runtime/agent-worker/agent-worker.sock';
+const DEFAULT_HEARTBEAT_MS = 30_000;
+/** Register retries cover a service started while the daemon is restarting. */
+const REGISTER_RETRY_MS = 3_000;
+const REGISTER_BUDGET_MS = 120_000;
+/** Consecutive transport failures before the worker gives up and lets the reconciler see the crash. */
+const HEARTBEAT_FAILURE_LIMIT = 10;
+const BYE_TIMEOUT_MS = 5_000;
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+class AgentWorker extends core_1.Command {
+    static summary = 'Run the agent-worker presence loop for this machine (launched by the agent service template)';
+    static description = 'Reads the server-issued binding from SKRR_AGENT_ID / SKRR_AGENT_HANDLE, registers with ' +
+        'the machine’s daemon over the agent-worker socket, and holds presence with heartbeats ' +
+        'until the service is stopped or the binding is revoked. Not meant to be run by hand — ' +
+        'declare it with `skrr machines dedicated service create --template agent --param agent=<agent-id>` ' +
+        'or the service API.';
+    static flags = {
+        socket: core_1.Flags.string({
+            description: 'Agent-worker socket path (defaults to the machine’s broker socket)',
+            env: 'SKRR_AGENT_WORKER_SOCKET',
+        }),
+        'heartbeat-ms': core_1.Flags.integer({
+            description: 'Heartbeat interval override in milliseconds (the broker’s answer wins)',
+            min: 1000,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AgentWorker);
+        const agentId = (process.env.SKRR_AGENT_ID ?? '').trim();
+        const handle = (process.env.SKRR_AGENT_HANDLE ?? '').trim();
+        if (!agentId || !handle) {
+            this.error('SKRR_AGENT_ID and SKRR_AGENT_HANDLE must both be set — the control plane injects them ' +
+                'when a service is created with an agent binding. This process is not meant to be run ' +
+                'by hand; create the service with `--template agent --param agent=<agent-id>` instead.', { exit: 2 });
+        }
+        const socketPath = flags.socket ?? DEFAULT_SOCKET;
+        const heartbeatOverride = flags['heartbeat-ms'];
+        const call = (verb, timeoutMs) => (0, guest_service_1.callGuestServiceSocket)({ verb, handle }, { socketPath, ...(timeoutMs ? { timeoutMs } : {}) });
+        // ---- register --------------------------------------------------------
+        // The service can start while the daemon is restarting; transport errors
+        // retry inside a budget, a refused binding never does.
+        const deadline = Date.now() + REGISTER_BUDGET_MS;
+        let heartbeatMs = heartbeatOverride ?? DEFAULT_HEARTBEAT_MS;
+        for (;;) {
+            try {
+                const reply = await call('register');
+                if (typeof reply.agentId === 'string' && reply.agentId !== agentId) {
+                    this.error(`The daemon validated this handle for ${reply.agentId}, not ${agentId} — ` +
+                        'the service spec is inconsistent. Remove and recreate the service.', { exit: 2 });
+                }
+                if (typeof reply.heartbeatMs === 'number' && reply.heartbeatMs >= 1000) {
+                    heartbeatMs = reply.heartbeatMs;
+                }
+                this.log(`agent-worker registered: agent=${reply.agentId ?? agentId} ` +
+                    `service=${reply.serviceName ?? '?'} heartbeat=${heartbeatMs}ms`);
+                break;
+            }
+            catch (error) {
+                if (this.bindingRefused(error)) {
+                    this.error(`The daemon refused this worker's binding: ${error.message}. ` +
+                        'The service spec predates the handle — remove and recreate the service.', { exit: 1 });
+                }
+                if (Date.now() >= deadline) {
+                    this.error(`The agent-worker socket never answered within ${REGISTER_BUDGET_MS / 1000}s ` +
+                        `(${error.message}) — the machine's daemon is not offering the ` +
+                        'agent-worker lane.', { exit: 1 });
+                }
+                await sleep(REGISTER_RETRY_MS);
+            }
+        }
+        // ---- heartbeat -------------------------------------------------------
+        let failures = 0;
+        let stopping = false;
+        const stop = () => {
+            stopping = true;
+        };
+        process.on('SIGTERM', stop);
+        process.on('SIGINT', stop);
+        while (!stopping) {
+            await sleep(heartbeatMs);
+            if (stopping)
+                break;
+            try {
+                await call('heartbeat');
+                failures = 0;
+            }
+            catch (error) {
+                if (this.bindingRefused(error)) {
+                    // The binding is dead — almost always `service remove` having
+                    // deleted the spec. Exit cleanly: there is nothing to retry, and
+                    // under an on-failure restart policy a clean exit keeps the
+                    // reconciler from flapping a corpse.
+                    this.log('The agent binding was revoked — exiting.');
+                    process.exit(0);
+                }
+                failures += 1;
+                if (failures >= HEARTBEAT_FAILURE_LIMIT) {
+                    this.error(`Lost the agent-worker socket ${failures} times in a row ` +
+                        `(${error.message}) — exiting so the service state is honest.`, { exit: 1 });
+                }
+                this.warn(`agent-worker heartbeat missed (${failures}/${HEARTBEAT_FAILURE_LIMIT})`);
+            }
+        }
+        // ---- bye ---------------------------------------------------------------
+        try {
+            await call('bye', BYE_TIMEOUT_MS);
+        }
+        catch {
+            /* a dead socket cannot hear goodbye — the missed heartbeats say it */
+        }
+    }
+    /** `revoked`/`invalid_handle` — the binding is gone, not the transport. */
+    bindingRefused(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return /revoked|invalid_handle|forbidden/i.test(message);
+    }
+}
+exports.default = AgentWorker;

package/dist/commands/agents/create.js

@@ -163,10 +163,11 @@ class AgentsCreate extends base_command_1.BaseCommand {
         }),
         description: core_1.Flags.string({ description: 'Agent description' }),
         provider: core_1.Flags.string({
-            description: 'Model provider (required unless set via --from-json)',
+            description: 'Model provider (default: agentic when --name is given)',
         }),
         model: core_1.Flags.string({
-            description: 'Model identifier (required unless set via --from-json)',
+            description: 'Model identifier (default: `default`, auto-routing). On a local harness, any id the harness ' +
+                'accepts — `skrr harnesses models <harness>` lists the known ones.',
         }),
         instructions: core_1.Flags.string({
             description: 'Initial raw custom instructions (creates one inline block; use `agents instructions` to compose reusable blocks later)',
@@ -199,7 +200,9 @@ class AgentsCreate extends base_command_1.BaseCommand {
             description: 'Single-purpose agent: skip the system-managed relationship portfolio (conversation continuity, relationship pulse, commitment incubator, open-loop closer). Self-reflection is still seeded.',
         }),
         'default-permission-mode': core_1.Flags.string({
-            description: 'Default Claude permission mode for sessions',
+            description: "Permission mode for this agent's local-harness sessions (every harness, not only Claude Code). " +
+                'One-shot harnesses (gemini, opencode, cursor, copilot, goose, pi, openclaw) can only run as ' +
+                'bypassPermissions; any other mode is refused for them.',
             options: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
         }),
         tools: core_1.Flags.string({
@@ -242,19 +245,23 @@ class AgentsCreate extends base_command_1.BaseCommand {
             description: 'When this agent schedules its own work: HH:MM-HH:MM[@<IANA timezone>], e.g. ' +
                 '09:00-18:00@America/Los_Angeles',
         }),
+        // Retired (OSK-11975): a Commitment turn works under the Agent's own
+        // permissions, so these three are stored but no longer read at runtime.
         'reasoning-tool-escape': core_1.Flags.string({
-            description: 'Tool a reasoning-only turn may still use (repeatable; replaces the list). ' +
-                'These are ESCAPES, not a fenced tool surface.',
+            description: "Deprecated — no longer has any effect. Commitment runs use the agent's own permissions.",
             options: [...agent_config_1.REASONING_TOOL_ESCAPES],
             multiple: true,
+            deprecated: { message: agent_config_1.COMMITMENT_PERMISSION_FLAG_RETIRED },
         }),
         'commitment-responsibility': core_1.Flags.string({
-            description: "Default work authority for this agent's commitments",
+            description: "Deprecated — no longer has any effect. Commitment runs use the agent's own permissions.",
             options: [...agent_config_1.COMMITMENT_RESPONSIBILITY_LEVELS],
+            deprecated: { message: agent_config_1.COMMITMENT_PERMISSION_FLAG_RETIRED },
         }),
         'commitment-responsibility-ceiling': core_1.Flags.string({
-            description: 'Ceiling a commitment may not exceed, whatever it asks for',
+            description: "Deprecated — no longer has any effect. Commitment runs use the agent's own permissions.",
             options: [...agent_config_1.COMMITMENT_RESPONSIBILITY_LEVELS],
+            deprecated: { message: agent_config_1.COMMITMENT_PERMISSION_FLAG_RETIRED },
         }),
         'max-turns': core_1.Flags.integer({ description: 'Maximum turns in one agent run (1-500)' }),
         'tool-resources': core_1.Flags.string({

package/dist/commands/agents/update.js

@@ -49,7 +49,9 @@ class AgentsUpdate extends base_command_1.BaseCommand {
             description: 'Default working directory for local Harness sessions',
         }),
         'default-permission-mode': core_1.Flags.string({
-            description: 'Default Claude permission mode for sessions',
+            description: "Permission mode for this agent's local-harness sessions (every harness, not only Claude Code). " +
+                'One-shot harnesses (gemini, opencode, cursor, copilot, goose, pi, openclaw) can only run as ' +
+                'bypassPermissions; any other mode is refused for them.',
             options: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
         }),
         tools: core_1.Flags.string({
@@ -93,19 +95,23 @@ class AgentsUpdate extends base_command_1.BaseCommand {
             description: 'When this agent schedules its own work: HH:MM-HH:MM[@<IANA timezone>], e.g. ' +
                 '09:00-18:00@America/Los_Angeles',
         }),
+        // Retired (OSK-11975): a Commitment turn works under the Agent's own
+        // permissions, so these three are stored but no longer read at runtime.
         'reasoning-tool-escape': core_1.Flags.string({
-            description: 'Tool a reasoning-only turn may still use (repeatable; replaces the list). ' +
-                'These are ESCAPES, not a fenced tool surface.',
+            description: "Deprecated — no longer has any effect. Commitment runs use the agent's own permissions.",
             options: [...agent_config_1.REASONING_TOOL_ESCAPES],
             multiple: true,
+            deprecated: { message: agent_config_1.COMMITMENT_PERMISSION_FLAG_RETIRED },
         }),
         'commitment-responsibility': core_1.Flags.string({
-            description: "Default work authority for this agent's commitments",
+            description: "Deprecated — no longer has any effect. Commitment runs use the agent's own permissions.",
             options: [...agent_config_1.COMMITMENT_RESPONSIBILITY_LEVELS],
+            deprecated: { message: agent_config_1.COMMITMENT_PERMISSION_FLAG_RETIRED },
         }),
         'commitment-responsibility-ceiling': core_1.Flags.string({
-            description: 'Ceiling a commitment may not exceed, whatever it asks for',
+            description: "Deprecated — no longer has any effect. Commitment runs use the agent's own permissions.",
             options: [...agent_config_1.COMMITMENT_RESPONSIBILITY_LEVELS],
+            deprecated: { message: agent_config_1.COMMITMENT_PERMISSION_FLAG_RETIRED },
         }),
         'max-turns': core_1.Flags.integer({ description: 'Maximum turns in one agent run (1-500)' }),
         'tool-resources': core_1.Flags.string({

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/effective-policy.js

@@ -5,6 +5,12 @@ 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 || {};
@@ -28,17 +34,36 @@ 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) {
+        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/goals/create.d.ts

@@ -10,6 +10,7 @@ export default class GoalsCreate extends BaseCommand {
         level: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'target-date': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        label: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         project: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         parent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'owner-agent': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;