@skrr-ai/cli 0.1.14 → 0.1.15

package/dist/base-command.d.ts

@@ -370,5 +370,19 @@ export declare function describeHarnessUnavailable(body: Record<string, unknown>
 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;
+/**
+ * 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.
+ */
+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
@@ -1391,6 +1416,40 @@ function describeForbidden(bodyMessage, method) {
     }
     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;
     if (typeof declared === 'boolean')

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>;
+}

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

@@ -0,0 +1,61 @@
+"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 AgentsInstructionsMove extends base_command_1.BaseCommand {
+    static description = 'Reorder one instruction block; later enabled blocks can supplement or narrow earlier ones';
+    static examples = [
+        '<%= config.bin %> agents instructions move library_… --agent <agent-id> --before inline_…',
+        '<%= config.bin %> agents instructions move inline_… --agent <agent-id> --after library_…',
+    ];
+    static args = {
+        instance: core_1.Args.string({
+            description: 'Block instance to move',
+            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)' }),
+        before: core_1.Flags.string({ description: 'Move immediately before this instance ID' }),
+        after: core_1.Flags.string({ description: 'Move immediately after this instance ID' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsInstructionsMove);
+        if (Boolean(flags.before) === Boolean(flags.after)) {
+            this.error('Choose exactly one placement: --before <instance> or --after <instance>.', {
+                exit: 2,
+            });
+        }
+        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);
+            updated = await (0, agent_instructions_1.saveAgentInstructions)(agentId, (0, instruction_blocks_1.moveEntry)(composition, args.instance, (flags.before ?? flags.after), flags.before ? 'before' : 'after'));
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(updated, null, 2));
+        this.log(`Moved ${args.instance} ${flags.before ? 'before' : 'after'} ${flags.before ?? flags.after}.`);
+    }
+}
+exports.default = AgentsInstructionsMove;

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsInstructionsPreview 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>;
+    };
+    run(): Promise<void>;
+}