@skrr-ai/cli 0.1.13 → 0.1.15

package/dist/base-command.d.ts

@@ -369,44 +369,20 @@ export declare function withSubject(subject: string | undefined, message: string
 export declare function describeHarnessUnavailable(body: Record<string, unknown> | null, bin?: string): string;
 export declare function describeResourceNotFound(serverMessage: string | undefined, bin?: string, baseURL?: string): string | null;
 export declare function describeAssigneeNotInSpace(serverMessage: string | undefined, bin?: string): string;
+export declare function describeForbidden(bodyMessage?: string | null, method?: string | null): string;
 /**
- * Whether an automated retry of the IDENTICAL request could plausibly succeed.
+ * True when a credential is unmistakably machine/daemon authority rather
+ * than a human CLI session. This is a diagnostic guard only, never an
+ * authorization decision: the server remains authoritative for every token.
  *
- * Precedence:
- *   1. An explicit `retryable` boolean in the error body — the server knows
- *      more about its own failure than any status heuristic does.
- *   2. A known terminal refusal code → never retryable.
- *   3. Status heuristic, restricted to genuinely TRANSIENT conditions: request
- *      timeout, too-early, rate limit, server error. 409 Conflict is
- *      deliberately absent — by definition it means the request conflicts with
- *      the resource's current state, which an identical retry cannot change.
- *
- * Exported for tests.
- */
-/**
- * What a 403 means, given whether the server said anything.
- *
- * Exported and pure so the wording is testable without an oclif runtime — the
- * convention `isRetryableFailure` follows below.
- *
- * A 403 WITH a body is the API deciding, and it says why; we relay it. A 403
- * with NO body did not come from the API — every application 403 in this
- * codebase carries a message — so it is the edge refusing the request before it
- * arrived, and the two must not share a sentence.
- *
- * This used to assert "your account does not have access to this resource" for
- * both. For an edge refusal that names a cause this process never observed, and
- * it is the expensive kind of wrong: it sends the user to audit their
- * membership, their role and their token, which is the one place the problem is
- * not. Dogfooded as OSK-263 — `skrr tasks create` refused a task description
- * containing a dotted AWS-credentials path, in a project the same session had
- * created a minute earlier, as an ADMIN who owned the space, and finding the
- * real cause took a line-by-line bisect of the description body.
- *
- * The 404 branch has always done the honest thing (`bodyMessage || 'Not
- * found.'`, which claims nothing); this brings 403 into line and adds the one
- * lead worth having.
+ * Opaque daemon access tokens have a stable public prefix. Legacy daemon JWTs
+ * expose `scope: "daemon"`; decoding the unsigned payload lets the CLI give a
+ * repair instruction instead of calling a predictable 403 a transient edge
+ * failure. Malformed and unknown token shapes intentionally return false so a
+ * generic authentication failure remains honest.
  */
-export declare function describeForbidden(bodyMessage?: string | null): string;
+export declare function isDaemonScopedCredential(token?: string | null): boolean;
+/** The one repair for a daemon token passed to a human CLI command. */
+export declare function describeDaemonScopedCredential(bin: string): string;
 export declare function isRetryableFailure(status: number | undefined, body: Record<string, unknown> | null): boolean;
 export { Flags };

package/dist/base-command.js

@@ -8,6 +8,8 @@ exports.describeHarnessUnavailable = describeHarnessUnavailable;
 exports.describeResourceNotFound = describeResourceNotFound;
 exports.describeAssigneeNotInSpace = describeAssigneeNotInSpace;
 exports.describeForbidden = describeForbidden;
+exports.isDaemonScopedCredential = isDaemonScopedCredential;
+exports.describeDaemonScopedCredential = describeDaemonScopedCredential;
 exports.isRetryableFailure = isRetryableFailure;
 const core_1 = require("@oclif/core");
 Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return core_1.Flags; } });
@@ -576,6 +578,14 @@ class BaseCommand extends core_1.Command {
                 retryable: false,
             });
         }
+        if (isDaemonScopedCredential(this.resolvedCredential.token)) {
+            this.failWithCliError({
+                message: describeDaemonScopedCredential(this.config.bin),
+                code: 'DAEMON_SCOPE_CREDENTIAL',
+                exit: 2,
+                retryable: false,
+            });
+        }
     }
     /**
      * Resolve the authenticated user's id via `GET /api/user`.
@@ -802,7 +812,22 @@ class BaseCommand extends core_1.Command {
             const body = parseErrorBody(e.body);
             const bodyCode = stringProp(body, 'code') || stringProp(body, 'errorType');
             const bodyMessage = stringProp(body, 'message') || stringProp(body, 'error');
-            if (bodyCode === 'AGENT_RUNTIME_UNAVAILABLE') {
+            // `requireAuth()` catches this before requests for normal commands, but
+            // keep the API-error check too: a handful of commands make a direct
+            // request and a supplied `--token` can bypass their normal preflight.
+            // A daemon credential reaching a human endpoint is deterministic, not
+            // an edge outage; retrying only repeats the same 401/403.
+            if ((e.status === 401 || e.status === 403) &&
+                isDaemonScopedCredential(this.resolvedCredential?.token)) {
+                this.failWithCliError({
+                    message: say(describeDaemonScopedCredential(this.config.bin)),
+                    code: 'DAEMON_SCOPE_CREDENTIAL',
+                    status: e.status,
+                    exit: 2,
+                    retryable: false,
+                });
+            }
+            else if (bodyCode === 'AGENT_RUNTIME_UNAVAILABLE') {
                 // A specific agent's runtime is offline — not a platform outage, even
                 // though the server returns 503. Intercept before the 503→outage
                 // heuristic so we neither claim a service outage nor promise a
@@ -870,12 +895,17 @@ class BaseCommand extends core_1.Command {
                 // named a cause and the cause was fiction. The 404 branch below has
                 // always done the honest thing — `bodyMessage || 'Not found.'`, which
                 // claims nothing.
+                // An API-authored 403 (has a body) is a terminal refusal — retrying
+                // the same request will fail the same way. An edge-authored 403 (no
+                // body) is commonly transient (OSK-6765), so the JSON envelope's
+                // `retryable` should match what the human line already says: retry.
+                const edgeRefusal = !bodyMessage;
                 this.failWithCliError({
-                    message: say(describeForbidden(bodyMessage)),
+                    message: say(describeForbidden(bodyMessage, e.method)),
                     code: bodyCode || 'FORBIDDEN',
                     status: e.status,
                     exit: 3,
-                    retryable: false,
+                    retryable: edgeRefusal,
                 });
             }
             else if (e.status === 404) {
@@ -1353,17 +1383,72 @@ const TERMINAL_ERROR_CODES = new Set(['task_output_required', 'task_output_not_a
  * created a minute earlier, as an ADMIN who owned the space, and finding the
  * real cause took a line-by-line bisect of the description body.
  *
- * The 404 branch has always done the honest thing (`bodyMessage || 'Not
- * found.'`, which claims nothing); this brings 403 into line and adds the one
- * lead worth having.
+ * OSK-6765 refined this again. The original replacement led with the body
+ * explanation ("try again with less of the request body") as a diagnosis, and
+ * it was wrong two ways for `skrr agents show <id>`: (1) that command is a GET
+ * and has no body to trim, so the advice was impossible to follow; (2) the
+ * failure was TRANSIENT — the same command succeeded 5/5 on retry with nothing
+ * changed — and the one action that actually fixed it (retry) was the one thing
+ * the message did not mention. A user hunting for the trigger burned six probe
+ * agents isolating candidate strings in their own data before noticing the
+ * request had no body at all.
+ *
+ * So: LEAD with retry (edge rejections are commonly transient). Then, ONLY on
+ * a method that actually carries a body, offer the body-content explanation as
+ * a possibility, not as the diagnosis. The 404 branch has always done the
+ * honest thing (`bodyMessage || 'Not found.'`, which claims nothing).
  */
-function describeForbidden(bodyMessage) {
+function methodCarriesRequestBody(method) {
+    if (!method)
+        return false;
+    const m = method.toUpperCase();
+    return m === 'POST' || m === 'PUT' || m === 'PATCH';
+}
+function describeForbidden(bodyMessage, method) {
     if (bodyMessage)
         return bodyMessage;
-    return ('Forbidden: the server refused this request and gave no reason. That usually means an ' +
-        'edge rule rejected it before it reached the API rather than a permission you lack — if ' +
-        'you can read this resource elsewhere, try again with less of the request body (a path ' +
-        'or token-shaped string in your text is enough to trigger one).');
+    const lead = 'Forbidden: the server refused this request and gave no reason. This is often a ' +
+        'transient edge rule rather than a permission you lack — retry once. If it keeps ' +
+        'failing, check that you can read this resource elsewhere';
+    if (methodCarriesRequestBody(method)) {
+        return (`${lead}, and consider that a path or token-shaped string in the request body can ` +
+            'be enough to trigger an edge rule; try again with less.');
+    }
+    return `${lead}.`;
+}
+/**
+ * True when a credential is unmistakably machine/daemon authority rather
+ * than a human CLI session. This is a diagnostic guard only, never an
+ * authorization decision: the server remains authoritative for every token.
+ *
+ * Opaque daemon access tokens have a stable public prefix. Legacy daemon JWTs
+ * expose `scope: "daemon"`; decoding the unsigned payload lets the CLI give a
+ * repair instruction instead of calling a predictable 403 a transient edge
+ * failure. Malformed and unknown token shapes intentionally return false so a
+ * generic authentication failure remains honest.
+ */
+function isDaemonScopedCredential(token) {
+    if (typeof token !== 'string' || token.length === 0)
+        return false;
+    if (token.startsWith('osk_dmn_'))
+        return true;
+    const payload = token.split('.')[1];
+    if (!payload)
+        return false;
+    try {
+        const decoded = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+        return (typeof decoded === 'object' &&
+            decoded !== null &&
+            decoded.scope === 'daemon');
+    }
+    catch {
+        return false;
+    }
+}
+/** The one repair for a daemon token passed to a human CLI command. */
+function describeDaemonScopedCredential(bin) {
+    return ('This command received a daemon-scoped credential, which cannot access user API commands. ' +
+        `Run \`${bin} login\` to create a CLI credential. For the local runtime itself, use \`${bin} daemon login\`.`);
 }
 function isRetryableFailure(status, body) {
     const declared = body?.retryable;

package/dist/commands/agents/create.d.ts

@@ -55,6 +55,7 @@ export default class AgentsCreate extends BaseCommand {
         'tone-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'tone-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'tone-notes': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-concurrent-task-executions': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         skills: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'agent-actions': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'tool-policy': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/agents/create.js

@@ -86,7 +86,9 @@ class AgentsCreate extends base_command_1.BaseCommand {
         model: core_1.Flags.string({
             description: 'Model identifier (required unless set via --from-json)',
         }),
-        instructions: core_1.Flags.string({ description: 'System instructions / prompt' }),
+        instructions: core_1.Flags.string({
+            description: 'Initial raw custom instructions (creates one inline block; use `agents instructions` to compose reusable blocks later)',
+        }),
         category: core_1.Flags.string({ description: 'Agent category' }),
         target: core_1.Flags.string({
             description: 'Required execution target. Use a Harness id, Hosted Machine session, or Agent Worker. Use hosted-machine, sbs_..., agent-worker, or a connected Harness id.',
@@ -116,6 +118,9 @@ class AgentsCreate extends base_command_1.BaseCommand {
         'tone-mode': core_1.Flags.string({ description: 'Tone mode' }),
         'tone-id': core_1.Flags.string({ description: 'Tone ID' }),
         'tone-notes': core_1.Flags.string({ description: 'Per-agent tone notes' }),
+        'max-concurrent-task-executions': core_1.Flags.integer({
+            description: 'Max Task executions this agent may run at once ACROSS every space (0 = unlimited)',
+        }),
         skills: core_1.Flags.string({ description: 'Skills JSON array' }),
         'agent-actions': core_1.Flags.string({ description: 'Embedded actions JSON array' }),
         'tool-policy': core_1.Flags.string({ description: 'Tool policy JSON object' }),

package/dist/commands/agents/instructions/add.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsInstructionsAdd extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        inline: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        block: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        binding: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        body: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        disabled: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/instructions/add.js

@@ -0,0 +1,115 @@
+"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");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+const agent_instructions_1 = require("../../../lib/agent-instructions");
+const instruction_blocks_1 = require("../../../lib/instruction-blocks");
+const instruction_input_1 = require("../../../lib/instruction-input");
+class AgentsInstructionsAdd extends base_command_1.BaseCommand {
+    static description = 'Add an inline instruction or a version-pinned library block to an Agent';
+    static examples = [
+        '<%= config.bin %> agents instructions add <agent-id> --inline --title "Working preferences" --body "Lead with the answer."',
+        '<%= config.bin %> agents instructions add <agent-id> --block block_official_github_pr_review --binding repository=acme/api',
+        '<%= config.bin %> agents instructions add <agent-id> --block block_… --version 2 --disabled',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Agent ID. Omit to use OVERSKY_SESSION_AGENT_ID.',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the updated Agent as JSON' }),
+        agent: core_1.Flags.string({ description: 'Agent ID (alias for the positional argument)' }),
+        inline: core_1.Flags.boolean({ description: 'Add a new inline block owned by this Agent' }),
+        block: core_1.Flags.string({ description: 'Library or official block ID to attach' }),
+        version: core_1.Flags.integer({
+            description: 'Version to pin (defaults to the block’s current version)',
+        }),
+        binding: core_1.Flags.string({
+            description: 'Parameter binding as key=value (repeatable)',
+            multiple: true,
+        }),
+        title: core_1.Flags.string({ description: 'Inline block title (required with --inline)' }),
+        body: core_1.Flags.string({ description: 'Inline instruction text' }),
+        file: core_1.Flags.string({ description: 'Read inline instruction text from a file, or - for stdin' }),
+        disabled: core_1.Flags.boolean({ description: 'Attach the block disabled' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsInstructionsAdd);
+        if (Boolean(flags.inline) === Boolean(flags.block)) {
+            this.error('Choose exactly one source: --inline or --block <block-id>.', { exit: 2 });
+        }
+        if (flags.inline && (flags.version !== undefined || flags.binding?.length)) {
+            this.error('--version and --binding only apply to --block.', { exit: 2 });
+        }
+        let agentId;
+        try {
+            agentId = await (0, agent_instructions_1.resolveInstructionAgentId)(args.id, flags.agent);
+        }
+        catch (error) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(error);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let entry;
+        try {
+            if (flags.inline) {
+                const body = (await (0, instruction_input_1.readInstructionBody)({
+                    body: flags.body,
+                    file: flags.file,
+                    required: true,
+                }));
+                if (!flags.title?.trim())
+                    throw new Error('--title is required with --inline.');
+                entry = {
+                    instanceId: (0, instruction_blocks_1.nextInstanceId)('inline'),
+                    enabled: !flags.disabled,
+                    source: { kind: 'inline', title: flags.title, body },
+                };
+            }
+            else {
+                const block = await data_provider_1.dataService.getInstructionBlock(flags.block);
+                const version = flags.version ?? block.currentVersion;
+                const bindings = (0, instruction_blocks_1.parseBindings)(flags.binding);
+                if (!block.versions.some((candidate) => candidate.version === version)) {
+                    throw new Error(`${block.id} has no v${version}. Run \`skrr instruction-blocks show ${block.id}\`.`);
+                }
+                entry = {
+                    instanceId: (0, instruction_blocks_1.nextInstanceId)('library'),
+                    enabled: !flags.disabled,
+                    source: { kind: 'library', blockId: block.id, version },
+                    ...(bindings ? { bindings } : {}),
+                };
+            }
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+        }
+        let loaded;
+        let updated;
+        try {
+            loaded = await (0, agent_instructions_1.loadAgentInstructions)(agentId);
+            updated = await (0, agent_instructions_1.saveAgentInstructions)(agentId, {
+                schemaVersion: 1,
+                entries: [...loaded.composition.entries, entry],
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(updated, null, 2));
+        this.log(`Added ${entry.source.kind === 'inline' ? entry.source.title : entry.source.blockId} to ${agentId}.`);
+        this.log(`Instance: ${entry.instanceId}`);
+    }
+}
+exports.default = AgentsInstructionsAdd;

package/dist/commands/agents/instructions/disable.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsInstructionsDisable extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        instance: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/instructions/disable.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+const agent_instructions_1 = require("../../../lib/agent-instructions");
+const instruction_blocks_1 = require("../../../lib/instruction-blocks");
+class AgentsInstructionsDisable extends base_command_1.BaseCommand {
+    static description = 'Disable one instruction block without removing its configuration';
+    static examples = [
+        '<%= config.bin %> agents instructions disable library_… --agent <agent-id>',
+    ];
+    static args = {
+        instance: core_1.Args.string({ description: 'Block instance ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the updated Agent as JSON' }),
+        agent: core_1.Flags.string({ description: 'Agent ID (alias for the positional argument)' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsInstructionsDisable);
+        let agentId;
+        try {
+            agentId = await (0, agent_instructions_1.resolveInstructionAgentId)(undefined, flags.agent);
+        }
+        catch (error) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(error);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let updated;
+        try {
+            const { composition } = await (0, agent_instructions_1.loadAgentInstructions)(agentId);
+            const entry = (0, instruction_blocks_1.entryByInstance)(composition, args.instance);
+            updated = await (0, agent_instructions_1.saveAgentInstructions)(agentId, (0, instruction_blocks_1.replaceEntry)(composition, args.instance, { ...entry, enabled: false }));
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(updated, null, 2));
+        this.log(`Disabled ${args.instance} on ${agentId}; its configuration is retained.`);
+    }
+}
+exports.default = AgentsInstructionsDisable;

package/dist/commands/agents/instructions/edit.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsInstructionsEdit extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        instance: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        body: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/instructions/edit.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+const agent_instructions_1 = require("../../../lib/agent-instructions");
+const instruction_blocks_1 = require("../../../lib/instruction-blocks");
+const instruction_input_1 = require("../../../lib/instruction-input");
+class AgentsInstructionsEdit extends base_command_1.BaseCommand {
+    static description = 'Edit an inline block owned by an Agent (library blocks are immutable; fork or upgrade them instead)';
+    static examples = [
+        '<%= config.bin %> agents instructions edit inline_… --agent <agent-id> --body "Name uncertainty."',
+        '<%= config.bin %> agents instructions edit inline_… --agent <agent-id> --title "Reporting format" --file ./format.md',
+    ];
+    static args = {
+        instance: core_1.Args.string({
+            description: 'Inline block instance ID',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the updated Agent as JSON' }),
+        agent: core_1.Flags.string({ description: 'Agent ID (alias for the positional argument)' }),
+        title: core_1.Flags.string({ description: 'New inline block title' }),
+        body: core_1.Flags.string({ description: 'New inline block text' }),
+        file: core_1.Flags.string({ description: 'Read new inline block text from a file, or - for stdin' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsInstructionsEdit);
+        let agentId;
+        try {
+            agentId = await (0, agent_instructions_1.resolveInstructionAgentId)(undefined, flags.agent);
+        }
+        catch (error) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(error);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let body;
+        try {
+            body = await (0, instruction_input_1.readInstructionBody)({ body: flags.body, file: flags.file });
+            if (flags.title === undefined && body === undefined) {
+                throw new Error('Nothing to edit. Pass --title, --body, or --file.');
+            }
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+        }
+        let updated;
+        try {
+            const { composition } = await (0, agent_instructions_1.loadAgentInstructions)(agentId);
+            const current = (0, instruction_blocks_1.entryByInstance)(composition, args.instance);
+            if (current.source.kind !== 'inline') {
+                throw new Error(`Instance ${args.instance} is a version-pinned library block. Edit its source with \`skrr instruction-blocks update\`, then use \`agents instructions upgrade\` when ready.`);
+            }
+            updated = await (0, agent_instructions_1.saveAgentInstructions)(agentId, (0, instruction_blocks_1.replaceEntry)(composition, args.instance, {
+                ...current,
+                source: {
+                    kind: 'inline',
+                    title: flags.title ?? current.source.title,
+                    body: body ?? current.source.body,
+                },
+            }));
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(updated, null, 2));
+        this.log(`Edited inline block ${args.instance} on ${agentId}.`);
+    }
+}
+exports.default = AgentsInstructionsEdit;

package/dist/commands/agents/instructions/enable.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsInstructionsEnable extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        instance: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/instructions/enable.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const agent_resolver_1 = require("../../../lib/agent-resolver");
+const agent_instructions_1 = require("../../../lib/agent-instructions");
+const instruction_blocks_1 = require("../../../lib/instruction-blocks");
+class AgentsInstructionsEnable extends base_command_1.BaseCommand {
+    static description = 'Enable one instruction block on an Agent';
+    static examples = [
+        '<%= config.bin %> agents instructions enable library_… --agent <agent-id>',
+    ];
+    static args = {
+        instance: core_1.Args.string({ description: 'Block instance ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the updated Agent as JSON' }),
+        agent: core_1.Flags.string({ description: 'Agent ID (alias for the positional argument)' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsInstructionsEnable);
+        let agentId;
+        try {
+            agentId = await (0, agent_instructions_1.resolveInstructionAgentId)(undefined, flags.agent);
+        }
+        catch (error) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(error);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let updated;
+        try {
+            const { composition } = await (0, agent_instructions_1.loadAgentInstructions)(agentId);
+            const entry = (0, instruction_blocks_1.entryByInstance)(composition, args.instance);
+            updated = await (0, agent_instructions_1.saveAgentInstructions)(agentId, (0, instruction_blocks_1.replaceEntry)(composition, args.instance, { ...entry, enabled: true }));
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(updated, null, 2));
+        this.log(`Enabled ${args.instance} on ${agentId}.`);
+    }
+}
+exports.default = AgentsInstructionsEnable;

package/dist/commands/agents/instructions/move.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsInstructionsMove extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        instance: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        before: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        after: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}