@skrr-ai/cli 0.1.92 → 0.1.94

package/dist/commands/agents/create.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FROM_SPEC_COMPATIBLE_FLAGS = void 0;
 exports.agentCreateMissingFieldsMessage = agentCreateMissingFieldsMessage;
 exports.agentCreateMissingFields = agentCreateMissingFields;
 exports.unappliedPayloadKeys = unappliedPayloadKeys;
@@ -15,6 +16,7 @@ const execution_target_1 = require("../../lib/execution-target");
 const prompt_1 = require("../../lib/prompt");
 const agent_config_1 = require("../../lib/agent-config");
 const web_url_1 = require("../../lib/web-url");
+const agent_spec_1 = require("../../lib/agent-spec");
 /**
  * OSK-4831 — build the missing-fields sentence from the real missing set.
  *
@@ -138,6 +140,23 @@ function backgroundLoopLines(agentId, relationshipLoopsSkipped) {
         '  skrr agents create --no-relationship-loops                  # a single-purpose agent next time',
     ];
 }
+/**
+ * The flags `--from-spec` may be combined with: placement and identity for the
+ * NEW row, which a spec document deliberately cannot carry (where an agent runs
+ * is not portable). Every configuration flag is refused alongside it, because
+ * the file is the source — a flag that quietly overrode a line of it would
+ * leave git and the agent disagreeing from the first push.
+ */
+exports.FROM_SPEC_COMPATIBLE_FLAGS = Object.freeze([
+    'from-spec',
+    'json',
+    'name',
+    'target',
+    'next-target',
+    'working-directory',
+    'default-permission-mode',
+    'no-relationship-loops',
+]);
 class AgentsCreate extends base_command_1.BaseCommand {
     static description = 'Create a new agent in the selected workspace, or in your default workspace when --workspace is omitted (`skrr workspaces list` names it)';
     static examples = [
@@ -147,11 +166,19 @@ class AgentsCreate extends base_command_1.BaseCommand {
         '<%= config.bin %> agents create --from-json agent.json',
         'cat agent.json | <%= config.bin %> agents create --from-json -',
         '<%= config.bin %> agents create --from-json template.json --name "Override name"',
+        '<%= config.bin %> agents create --from-spec agents/reviewer.agent.json',
+        '<%= config.bin %> agents create --from-spec agents/reviewer.agent.json --name "Reviewer (staging)" --target hosted-machine',
     ];
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the created agent as JSON' }),
         'from-json': core_1.Flags.string({
             description: 'Path to a JSON file (or "-" for stdin) to use as the request body',
+            exclusive: ['from-spec'],
+        }),
+        'from-spec': core_1.Flags.string({
+            description: 'Create the agent from an agent-as-code spec document (`skrr agents pull` writes one; "-" for stdin). ' +
+                'Checked with the same rules as `agents push`; a refused document leaves no agent behind',
+            exclusive: ['from-json'],
         }),
         // `--title` is an alias, not a rename (OSK-4850). tasks, spaces, projects,
         // goals and `chats create` all name the thing with `--title`, so muscle
@@ -295,6 +322,10 @@ class AgentsCreate extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(AgentsCreate);
+        if (flags['from-spec']) {
+            await this.createFromSpec(flags);
+            return;
+        }
         // Default to {} so TS flow-analysis is satisfied — the catch calls this.error(), which throws.
         let body = {};
         try {
@@ -447,5 +478,186 @@ class AgentsCreate extends base_command_1.BaseCommand {
         }
         this.log(`URL: ${(0, web_url_1.withAgentUrl)(this.cliConfig.baseURL, a).url ?? '-'}`);
     }
+    /**
+     * `agents create --from-spec <file>`: bootstrap a NEW agent from an
+     * agent-as-code document, so a repository can hold an agent before one
+     * exists (`agents push` needs an existing id).
+     *
+     * Two writes, one writer per concern. The create carries only what makes a
+     * row — its name, provider, model and placement — and every other field
+     * reaches the agent through the push endpoint, so the document is held to
+     * exactly the rules `agents push` and `agents validate` apply (portable
+     * fields only, no credentials, no withheld references, nothing push may not
+     * set). Validation runs first with no network. If the server then refuses
+     * the document, the agent just created is deleted again: a refused spec must
+     * not leave behind a half-configured agent that looks like it worked.
+     */
+    async createFromSpec(flags) {
+        const source = String(flags['from-spec']);
+        const incompatible = Object.keys(flags)
+            // This command's own flags only: the global ones (--profile, --workspace,
+            // --token, --bare) choose WHO creates, not what is created.
+            .filter((flag) => Object.prototype.hasOwnProperty.call(AgentsCreate.flags, flag))
+            .filter((flag) => flags[flag] !== undefined && flags[flag] !== false)
+            .filter((flag) => !exports.FROM_SPEC_COMPATIBLE_FLAGS.includes(flag));
+        if (incompatible.length > 0) {
+            this.failWithCliError({
+                message: `--from-spec takes the agent's configuration from ${source}; ` +
+                    `${incompatible.map((flag) => `--${flag}`).join(', ')} cannot be combined with it. ` +
+                    'Edit the file instead (placement flags --target, --next-target, --working-directory, ' +
+                    '--default-permission-mode, and --name, are accepted).',
+                code: 'AGENT_SPEC_FLAG_CONFLICT',
+                exit: 1,
+                retryable: false,
+                details: { incompatible },
+            });
+        }
+        let raw;
+        try {
+            raw = await (0, agent_spec_1.readSpecSource)(source);
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: `Could not read ${source}: ${err.message}`,
+                code: 'AGENT_SPEC_READ_FAILED',
+                exit: 1,
+                retryable: true,
+                details: { path: source },
+            });
+        }
+        const parsed = (0, agent_spec_1.parseAndValidateAgentSpec)(raw, source);
+        if (!parsed.ok) {
+            this.failWithCliError({
+                message: parsed.message,
+                code: 'AGENT_SPEC_NOT_JSON',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (!parsed.validation.ok) {
+            this.failWithCliError({
+                message: (0, agent_spec_1.issueBlock)(`Refused before sending: ${source} carries fields that may not travel. No agent was created.`, parsed.validation.issues),
+                code: 'AGENT_SPEC_INVALID',
+                exit: 1,
+                retryable: false,
+                details: { issues: parsed.validation.issues },
+            });
+        }
+        const document = parsed.validation.document;
+        const spec = { ...document.spec };
+        // `--name` renames the copy (a staging twin of a committed agent). It is
+        // written into the document too, or the push would rename it straight back.
+        if (typeof flags.name === 'string' && flags.name.trim())
+            spec.name = flags.name.trim();
+        const name = typeof spec.name === 'string' ? spec.name.trim() : '';
+        if (!name) {
+            this.failWithCliError({
+                message: `${source} has no "name" under "spec". Add one, or pass --name.`,
+                code: 'AGENT_CREATE_MISSING_FIELDS',
+                exit: 1,
+                retryable: false,
+                details: { missing: ['--name'] },
+            });
+        }
+        // Placement is never in a spec (it is not portable), so it defaults here
+        // exactly as a named create does, and the defaults are said out loud.
+        const appliedDefaults = [];
+        const provider = typeof spec.provider === 'string' && spec.provider ? spec.provider : 'agentic';
+        if (provider !== spec.provider)
+            appliedDefaults.push('provider=agentic');
+        const model = typeof spec.model === 'string' && spec.model ? spec.model : 'default';
+        if (model !== spec.model)
+            appliedDefaults.push('model=default');
+        let target = typeof flags.target === 'string' ? flags.target : undefined;
+        const nextTargets = flags['next-target'] ?? [];
+        if (!target) {
+            if (nextTargets.length > 0) {
+                this.error('--next-target requires --target.', { exit: 1 });
+            }
+            target = 'agent-worker';
+            appliedDefaults.push('target=agent-worker');
+        }
+        let executionPolicy;
+        try {
+            executionPolicy = (0, execution_target_1.buildExecutionOrderPatch)({
+                selectors: [target, ...nextTargets],
+            }).executionPolicy;
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        const payload = (0, prompt_1.mergeDefined)({}, {
+            name,
+            provider,
+            model,
+            executionPolicy,
+            workingDirectory: flags['working-directory'],
+            defaultPermissionMode: flags['default-permission-mode'],
+            relationshipLoops: flags['no-relationship-loops'] ? false : undefined,
+        });
+        let created;
+        try {
+            created = (await data_provider_1.dataService.createAgent(payload));
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const agentId = String(created.id ?? created._id ?? '');
+        let pushed;
+        try {
+            pushed = await data_provider_1.dataService.pushAgentSpec(agentId, { ...document, spec });
+        }
+        catch (err) {
+            // Undo the create first, then report — whichever way the undo went.
+            let rollback;
+            try {
+                await data_provider_1.dataService.deleteAgent({ agent_id: agentId });
+                rollback = `The agent created for it (${agentId}) was deleted again.`;
+            }
+            catch (deleteErr) {
+                rollback =
+                    `The agent created for it (${agentId}) could NOT be deleted ` +
+                        `(${deleteErr.message}); remove it with \`skrr agents delete ${agentId}\`.`;
+            }
+            const refusal = (0, agent_spec_1.refusalIssues)(err);
+            this.failWithCliError({
+                message: refusal
+                    ? (0, agent_spec_1.issueBlock)(`The server refused ${source}. ${rollback}`, refusal.issues)
+                    : `Could not apply ${source} (${err.message}). ${rollback}`,
+                code: refusal?.code ?? 'AGENT_SPEC_REFUSED',
+                status: err.status,
+                exit: 1,
+                retryable: !refusal,
+                details: { agentId, rolledBack: !rollback.includes('NOT'), issues: refusal?.issues },
+            });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({
+                agent: (0, web_url_1.withAgentUrl)(this.cliConfig.baseURL, created),
+                spec: {
+                    source,
+                    applied: pushed.applied,
+                    unchanged: pushed.unchanged,
+                    derived: pushed.derived ?? [],
+                    untouched: pushed.untouched,
+                },
+                defaultsApplied: appliedDefaults,
+            }, null, 2));
+            return;
+        }
+        const fields = [...pushed.applied, ...pushed.unchanged];
+        this.log(`Created agent ${agentId} — ${name}, from ${source} (${fields.length} field(s)).`);
+        if (appliedDefaults.length > 0)
+            this.log(`Defaults applied: ${appliedDefaults.join(', ')}`);
+        const derived = pushed.derived ?? [];
+        if (derived.length > 0) {
+            this.log(`Not taken from the file, because the server derives it from other fields: ${derived.join(', ')}.`);
+        }
+        this.log(`Keep the file in step: \`skrr agents push ${agentId} --file ${source === '-' ? '<file>' : source}\`.`);
+        for (const line of backgroundLoopLines(agentId, flags['no-relationship-loops'] === true)) {
+            this.log(line);
+        }
+        this.log(`URL: ${(0, web_url_1.withAgentUrl)(this.cliConfig.baseURL, created).url ?? '-'}`);
+    }
 }
 exports.default = AgentsCreate;

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

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr agents embed <agent>` — the snippet that puts a listing CARD for a
+ * public agent on another site (agent-distribution-2026-10-08.md, "Embed").
+ *
+ * Mints (idempotently) your share code on the `embed` channel, so installs
+ * that start from the card are attributed to you and show up under that
+ * channel in the listing's funnel. The card is a listing, not a chat.
+ */
+export default class AgentsEmbed extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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/agents/embed.js

@@ -0,0 +1,61 @@
+"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 web_url_1 = require("../../lib/web-url");
+/**
+ * `skrr agents embed <agent>` — the snippet that puts a listing CARD for a
+ * public agent on another site (agent-distribution-2026-10-08.md, "Embed").
+ *
+ * Mints (idempotently) your share code on the `embed` channel, so installs
+ * that start from the card are attributed to you and show up under that
+ * channel in the listing's funnel. The card is a listing, not a chat.
+ */
+class AgentsEmbed extends base_command_1.BaseCommand {
+    static description = "Print the HTML snippet that embeds a public agent's listing card on another site, with your embed share code";
+    static examples = [
+        '<%= config.bin %> agents embed <agent-id>',
+        '<%= config.bin %> agents embed <agent-id> --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Agent ID of a public Store listing',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON ({ code, snippet, cardUrl })' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsEmbed);
+        let code;
+        try {
+            ({ code } = await data_provider_1.dataService.mintDistributionCode({
+                entity: { kind: 'agent', id: args.id },
+                channel: 'embed',
+            }));
+        }
+        catch (error) {
+            // A private or missing agent answers ENTITY_NOT_FOUND: only a public
+            // listing can be embedded.
+            this.handleApiError(error, { subject: 'public agent listing' });
+            return;
+        }
+        const origin = (0, web_url_1.webOrigin)(this.cliConfig.baseURL);
+        const snippet = (0, data_provider_1.buildAgentEmbedSnippet)({ origin, agentId: args.id, code });
+        const cardUrl = `${origin}${(0, data_provider_1.embedListingPath)(args.id, { code })}`;
+        if (flags.json) {
+            this.log(JSON.stringify({ code, snippet, cardUrl }, null, 2));
+            return;
+        }
+        this.log('Paste this where the card should appear:');
+        this.log('');
+        this.log(snippet);
+        this.log('');
+        this.log(`Preview: ${cardUrl}`);
+    }
+}
+exports.default = AgentsEmbed;

package/dist/commands/agents/operating-plan.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base-command';
+export default class AgentOperatingPlan extends BaseCommand {
+    static description: string;
+    static args: {
+        id: 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/agents/operating-plan.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const roles_1 = require("../../lib/roles");
+class AgentOperatingPlan extends base_command_1.BaseCommand {
+    static description = 'Read responsibilities, evidence, inquiries, work, delayed evaluation and existing planning loops without scheduling work';
+    static args = {
+        id: core_1.Args.string({ required: true, description: 'Agent ID', ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output full joined state and source coverage as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentOperatingPlan);
+        try {
+            const plan = await roles_1.roleApi.plan(args.id);
+            if (flags.json) {
+                this.log(JSON.stringify(plan, null, 2));
+                return;
+            }
+            this.log(`Operating plan — ${args.id} (${plan.generatedAt})`);
+            for (const r of plan.responsibilities) {
+                this.log(`\n${r.title} · ${r.status} · ${r.kind} v${r.version}`);
+                this.log(`  Responsibility: ${r.purpose}`);
+                this.log(`  Evidence: ${r.evidence.status}${r.evidence.issues?.length ? ` (${r.evidence.issues.join(', ')})` : ''}`);
+                this.log("  Execution authority: tools, sandbox and approvals use the Agent's runtime permissions.");
+                for (const q of r.inquiries)
+                    this.log(`  Inquiry: ${q.question} [${q.status}] — ${q.decisionImpact}`);
+                for (const w of r.work)
+                    this.log(`  Work: ${w.title} [${w.status}]`);
+                for (const w of r.waiting)
+                    this.log(`  Evaluation: ${w.status} — ${w.reason}${w.nextAt ? `; next ${w.nextAt}` : ''}`);
+                this.log(`  Next intervention: ${r.lifecycle !== 'active' ? 'inactive; requires activation' : r.nextIntervention?.nextAt || r.nextIntervention?.status || 'not recorded'}`);
+                if (r.blocker)
+                    this.log(`  Blocker: ${r.blocker.code} — ${r.blocker.remediation || ''}`);
+            }
+            this.log(`\n${plan.planning.loops.length} existing planning/reflection loops; ${plan.planning.todos.length} scheduled work blocks.`);
+            if (plan.learning?.skillValidation)
+                this.log(`Skill validation: ${plan.learning.skillValidation.enabled ? 'enabled' : 'disabled'} (${plan.learning.skillValidation.scope}); external effects validated: ${plan.learning.skillValidation.externalEffectsValidated}.`);
+            if (!plan.coverage.complete) {
+                this.log(`Incomplete coverage${plan.coverage.truncated ? '; view limits reached' : ''}.`);
+                for (const s of plan.coverage.sources.filter((s) => s.status !== 'available'))
+                    this.log(`  ${s.name}: ${s.status} (${s.code || 'unknown'})`);
+            }
+            this.log('Task or Run completion does not establish a verified outcome.');
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = AgentOperatingPlan;

package/dist/commands/agents/roles/example.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class RolesExample extends BaseCommand {
+    static description: string;
+    static args: {
+        role: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/roles/example.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const node_fs_1 = require("node:fs");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+class RolesExample extends base_command_1.BaseCommand {
+    static description = 'Start a portable DevOps, Financial Tech or Research Operations role using one generic schema';
+    static args = {
+        role: core_1.Args.string({
+            required: true,
+            options: ['devops', 'financial', 'research'],
+            description: 'Example role',
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        output: core_1.Flags.string({ description: 'Save the example JSON to a file; otherwise print JSON' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RolesExample);
+        const example = data_provider_1.ROLE_OPERATING_SPEC_EXAMPLES[args.role];
+        const json = `${JSON.stringify(example, null, 2)}\n`;
+        if (flags.output)
+            (0, node_fs_1.writeFileSync)(flags.output, json, { mode: 0o600 });
+        else
+            this.log(json.trimEnd());
+    }
+}
+exports.default = RolesExample;

package/dist/commands/{commitments/mode.d.ts → agents/roles/export.d.ts}

@@ -1,15 +1,15 @@
-import { BaseCommand } from '../../base-command';
-export default class CommitmentsMode extends BaseCommand {
+import { BaseCommand } from '../../../base-command';
+export default class RolesExport extends BaseCommand {
     static description: string;
     static examples: string[];
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-        mode: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        key: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        summary: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/agents/roles/export.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const roles_1 = require("../../../lib/roles");
+const artifact_export_1 = require("../../../lib/artifact-export");
+/** Shape version of the portable role spec this command writes. */
+const ROLE_EXPORT_VERSION = 1;
+class RolesExport extends base_command_1.BaseCommand {
+    static description = 'Export portable role authoring intent; credentials, installation IDs and runtime state are excluded';
+    static examples = [
+        '<%= config.bin %> agents roles export <agent> <key> --summary',
+        '<%= config.bin %> agents roles export <agent> <key> --output role.json',
+        '<%= config.bin %> agents roles export <agent> <key> --output - | jq .',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, description: 'Agent ID', ignoreStdin: true }),
+        key: core_1.Args.string({ required: true, description: 'Role key', ignoreStdin: true }),
+    };
+    static flags = {
+        ...(0, artifact_export_1.standardExportFlags)(),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(RolesExport);
+        let selection;
+        try {
+            selection = (0, artifact_export_1.resolveExportSelection)(flags);
+        }
+        catch (err) {
+            if (err instanceof artifact_export_1.ExportContractError) {
+                this.failWithCliError({ message: err.message, code: err.code, exit: 2, retryable: false });
+            }
+            throw err;
+        }
+        let spec;
+        try {
+            spec = await roles_1.roleApi.export(args.id, args.key);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (selection.summary) {
+            const summary = (0, artifact_export_1.contentFreeSummary)({
+                command: 'agents roles export',
+                artifactSchemaVersion: ROLE_EXPORT_VERSION,
+                itemCount: 1,
+                counts: {},
+            });
+            this.log(selection.json ? JSON.stringify(summary, null, 2) : (0, artifact_export_1.humanExportSummary)(summary));
+            return;
+        }
+        const serialized = (0, artifact_export_1.serializedArtifact)(spec);
+        if (selection.output === '-') {
+            this.log(serialized.trimEnd());
+            return;
+        }
+        let receipt;
+        try {
+            receipt = await (0, artifact_export_1.writeExportArtifact)({
+                command: 'agents roles export',
+                artifactSchemaVersion: ROLE_EXPORT_VERSION,
+                format: 'json',
+                output: selection.output,
+                content: serialized,
+                itemCount: 1,
+            });
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: `Could not write ${selection.output}: ${err.message}`,
+                code: 'ROLE_EXPORT_WRITE_FAILED',
+                exit: 1,
+                retryable: false,
+                details: { path: selection.output },
+            });
+        }
+        this.log(selection.json ? JSON.stringify(receipt, null, 2) : (0, artifact_export_1.humanExportReceipt)(receipt));
+    }
+}
+exports.default = RolesExport;

package/dist/commands/agents/roles/install.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class RolesInstall extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        preview: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/roles/install.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const roles_1 = require("../../../lib/roles");
+class RolesInstall extends base_command_1.BaseCommand {
+    static description = 'Install or reconcile a reviewed role preview as inactive existing objects; never attach credentials or activate work';
+    static args = {
+        id: core_1.Args.string({ required: true, description: 'Agent ID', ignoreStdin: true }),
+    };
+    static flags = {
+        preview: core_1.Flags.string({
+            required: true,
+            description: 'Server-generated preview JSON saved by agents roles preview',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the installation receipt as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(RolesInstall);
+        try {
+            const preview = (0, roles_1.readRoleJson)(flags.preview);
+            (0, roles_1.assertRolePreview)(preview);
+            const receipt = await roles_1.roleApi.install(args.id, preview);
+            if (flags.json)
+                this.log(JSON.stringify(receipt, null, 2));
+            else {
+                this.log(receipt.complete ? 'Role installed inactive.' : 'Role installation partially saved.');
+                for (const item of receipt.results)
+                    this.log(`  ${item.key || item.id || 'receipt'}: ${item.status}${item.code ? ` (${item.code})` : ''}`);
+                this.log('Review and activate the Compass, attach required skills and evidence sources, then activate responsibilities through commitments resume.');
+                this.log(`Inspect the joined state: agents operating-plan ${args.id}`);
+            }
+            if (!receipt.complete)
+                this.failWithCliError({
+                    code: 'ROLE_INSTALL_INCOMPLETE',
+                    message: 'Some role objects were saved but installation is incomplete. Refresh the preview and reconcile the same revision.',
+                    retryable: true,
+                    exit: 1,
+                    details: receipt,
+                });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = RolesInstall;

package/dist/commands/agents/roles/list.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class RolesList extends BaseCommand {
+    static description: string;
+    static args: {
+        id: 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/agents/roles/list.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const roles_1 = require("../../../lib/roles");
+class RolesList extends base_command_1.BaseCommand {
+    static description = 'List installed role specifications and their Compass lifecycle';
+    static args = {
+        id: core_1.Args.string({ required: true, description: 'Agent ID', ignoreStdin: true }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(RolesList);
+        try {
+            const result = await roles_1.roleApi.list(args.id);
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            for (const role of result.roles)
+                this.log(`${role.spec.key}: ${role.spec.title} · revision ${role.spec.revision} · ${role.status} · Compass ${role.compassStatus} v${role.compassVersion}`);
+            if (!result.roles.length)
+                this.log('No roles installed. Use agents roles example to start a portable configuration.');
+            if (result.skillInventory) {
+                this.log(`Attached Skill inventory: ${result.skillInventory.status}`);
+                for (const skill of result.skillInventory.skills)
+                    this.log(`  ${skill.name}: ${skill.id} · ${skill.versions.join(', ')}`);
+            }
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = RolesList;