@skrr-ai/cli 0.1.45 → 0.1.47

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

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr commitments handover` — rebind a commitment's executor to a different
+ * agent.
+ *
+ * `commitment.agentId` is single-valued by design, so this is NOT a patch: the
+ * server records the move on the commitment's audit trail (`executorHandovers`)
+ * with who initiated it and why (impl contract B4, design doc P4). The
+ * canonical case is a commitment whose agent's execution targets are all
+ * quota-blocked — this is the "reassign" half of "executor cannot run until
+ * <date> — reassign or add a fallback target".
+ *
+ * Only the WHO moves: the contract, cadence, watched sources and audit trail
+ * are unchanged, and the new executor's own execution policy decides WHERE the
+ * next check runs.
+ */
+export default class CommitmentsHandover 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>;
+        to: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/commitments/handover.js

@@ -0,0 +1,99 @@
+"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 commitments_1 = require("../../lib/commitments");
+const web_url_1 = require("../../lib/web-url");
+const code_handover_1 = require("../../lib/code-handover");
+/**
+ * `skrr commitments handover` — rebind a commitment's executor to a different
+ * agent.
+ *
+ * `commitment.agentId` is single-valued by design, so this is NOT a patch: the
+ * server records the move on the commitment's audit trail (`executorHandovers`)
+ * with who initiated it and why (impl contract B4, design doc P4). The
+ * canonical case is a commitment whose agent's execution targets are all
+ * quota-blocked — this is the "reassign" half of "executor cannot run until
+ * <date> — reassign or add a fallback target".
+ *
+ * Only the WHO moves: the contract, cadence, watched sources and audit trail
+ * are unchanged, and the new executor's own execution policy decides WHERE the
+ * next check runs.
+ */
+class CommitmentsHandover extends base_command_1.BaseCommand {
+    static description = 'Reassign a commitment to a different executor agent';
+    static examples = [
+        '<%= config.bin %> commitments handover <commitment-id> --to "Backup Agent"',
+        '<%= config.bin %> commitments handover <id> --to agent_abc --reason "claude quota exhausted until Sep 19"',
+        '<%= config.bin %> commitments handover <id> --to agent_abc --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Commitment ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        to: core_1.Flags.string({
+            description: 'Agent that takes over the commitment — id or name',
+            required: true,
+        }),
+        reason: core_1.Flags.string({
+            description: 'Why the executor is changing — recorded on the audit trail',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(CommitmentsHandover);
+        // ── Target agent: id or name, resolved like `code handover --to`. ──────
+        let agents = [];
+        try {
+            const resp = await data_provider_1.dataService.listAgents({ requiredPermission: data_provider_1.PermissionBits.VIEW });
+            agents = (resp?.data ?? []).filter(Boolean);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const matched = (0, code_handover_1.matchAgent)(flags.to, agents);
+        if (matched.kind === 'none') {
+            this.error(`No agent matches "${flags.to}". Run \`${this.config.bin} agents list\` to see the agents you can use.`);
+        }
+        if (matched.kind === 'ambiguous') {
+            this.error(`"${flags.to}" matches ${matched.candidates.length} agents. Pass the agent id instead:\n` +
+                matched.candidates.map((a) => `  ${a.id}  ${a.name ?? ''}`).join('\n'));
+        }
+        const target = matched.agent;
+        let result;
+        try {
+            result = await commitments_1.commitmentApi.setExecutor(args.id, {
+                agentId: target.id,
+                ...(flags.reason ? { reason: flags.reason } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `Commitment ${args.id}` });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const agentLabel = target.name ? `${target.name} (${target.id})` : target.id;
+        this.log(`Handed commitment ${args.id} over to ${agentLabel}`);
+        // The audit entry the server appended — echo it so "from whom" is answered
+        // without a second call. Absent on a server that predates the trail.
+        const commitment = result?.commitment ??
+            result;
+        const handovers = commitment?.executorHandovers;
+        if (Array.isArray(handovers) && handovers.length > 0) {
+            const last = handovers[handovers.length - 1];
+            if (typeof last?.fromAgentId === 'string' && typeof last?.toAgentId === 'string') {
+                this.log(`  executor ${last.fromAgentId} → ${last.toAgentId}`);
+            }
+        }
+        if (commitment) {
+            const withUrl = (0, web_url_1.withCommitmentUrl)(this.cliConfig.baseURL, commitment);
+            if (withUrl.url)
+                this.log(`  ${withUrl.url}`);
+        }
+    }
+}
+exports.default = CommitmentsHandover;

package/dist/commands/convos/handover.d.ts

@@ -24,6 +24,7 @@ export default class ConvosHandover extends BaseCommand {
         to: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         'up-to': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'allow-recall': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/convos/handover.js

@@ -44,6 +44,9 @@ class ConvosHandover extends base_command_1.BaseCommand {
         reason: core_1.Flags.string({
             description: 'Why the work is moving — recorded in provenance and the forward link',
         }),
+        'allow-recall': core_1.Flags.boolean({
+            description: 'Grant the receiving agent a time-boxed (7d) re-read of this thread after handover',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -74,6 +77,7 @@ class ConvosHandover extends base_command_1.BaseCommand {
                 targetAgentId: flags.to,
                 upTo: flags['up-to'],
                 reason: flags.reason,
+                allowRecall: flags['allow-recall'] === true ? true : undefined,
             });
         }
         catch (err) {

package/dist/commands/daemon/index.js

@@ -26,6 +26,7 @@ class Daemon extends core_1.Command {
         '<%= config.bin %> daemon status',
         '<%= config.bin %> daemon start',
         '<%= config.bin %> daemon stop',
+        '<%= config.bin %> daemon update',
         '<%= config.bin %> daemon logs',
         '<%= config.bin %> daemon recover-offline-queue --apply',
         '<%= config.bin %> daemon usage --refresh',
@@ -44,6 +45,7 @@ class Daemon extends core_1.Command {
         this.log('  skrr daemon uninstall  — remove that service (local state is left alone)');
         this.log('  skrr daemon start      — start the daemon');
         this.log('  skrr daemon stop       — stop the daemon');
+        this.log('  skrr daemon update     — update the daemon binary to the latest signed release');
         this.log('  skrr daemon status     — show running state and config');
         this.log('  skrr daemon logs       — tail recent daemon logs');
         this.log('  skrr daemon recover-offline-queue — restore recoverable offline WALs');

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

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+/**
+ * `skrr daemon update` — update the runtime binary on this computer.
+ *
+ * Proxied like every other lifecycle verb. The earlier exclusion reason — that
+ * a self-update "must not run from inside a wrapper it may replace" — did not
+ * hold: `skrr` is a separate Node process that spawns `skrrd update`; the
+ * verified swap targets the daemon BINARY on disk, never the running CLI. The
+ * running daemon process is likewise untouched — the self-upgrade monitor
+ * restarts it afterwards, exactly as it does for the background poller.
+ */
+export default class DaemonUpdate extends Command {
+    static aliases: string[];
+    static summary: string;
+    static description: string;
+    static strict: boolean;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/daemon/update.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const exec_runtime_binary_1 = require("../../lib/exec-runtime-binary");
+/**
+ * `skrr daemon update` — update the runtime binary on this computer.
+ *
+ * Proxied like every other lifecycle verb. The earlier exclusion reason — that
+ * a self-update "must not run from inside a wrapper it may replace" — did not
+ * hold: `skrr` is a separate Node process that spawns `skrrd update`; the
+ * verified swap targets the daemon BINARY on disk, never the running CLI. The
+ * running daemon process is likewise untouched — the self-upgrade monitor
+ * restarts it afterwards, exactly as it does for the background poller.
+ */
+class DaemonUpdate extends core_1.Command {
+    // `skrr daemons <sub>` — the plural is advertised as an alias for the
+    // whole topic, and without a per-command alias only the bare topic
+    // resolved: every subcommand under it failed.
+    static aliases = ['daemons:update'];
+    static summary = 'Update the skrr daemon binary on this computer to the latest signed release';
+    static description = (0, exec_runtime_binary_1.forwardedFlagsNote)('update');
+    static strict = false; // forward all args verbatim — see run()
+    static examples = [
+        '<%= config.bin %> daemon update',
+        '<%= config.bin %> daemon update --check',
+        '<%= config.bin %> daemon update --target-version 0.8.54',
+        '<%= config.bin %> daemon update --restart',
+    ];
+    async run() {
+        // `this.argv`, NOT `this.parse()`. `strict = false` relaxes POSITIONAL
+        // arity and oclif still rejects any flag this command has not declared —
+        // so every `skrrd` flag would be unreachable through the wrapper that
+        // exists to reach it (OSK-296).
+        const argv = this.argv;
+        try {
+            const code = await (0, exec_runtime_binary_1.execRuntimeBinary)(['update', ...argv]);
+            this.exit(code);
+        }
+        catch (err) {
+            if (err.message === 'runtime-binary-not-installed') {
+                this.log((0, exec_runtime_binary_1.notInstalledMessage)());
+                this.exit(127);
+            }
+            throw err;
+        }
+    }
+}
+exports.default = DaemonUpdate;

package/dist/commands/followups/watch.js

@@ -30,6 +30,7 @@ class FollowupsWatch extends base_command_1.BaseCommand {
         '<%= config.bin %> followups watch --subject task:OSK-42 --why "deploy still running" --url https://ci.example.com/api/build/9 --until \'{"path":"status","op":"equals","value":"done"}\' --deadline 6h',
         '<%= config.bin %> followups watch --subject task:OSK-42 --why "pr review" --check "gh pr view 42 --json state" --success "state == MERGED" --abort "state == CLOSED" --wait event --wait-entity github --wait-event pull_request_merged --wait-fallback 2h',
         '<%= config.bin %> followups watch --subject conversation:abc --why "vendor reply" --check "check inbox" --success "reply arrived" --abort "3 days" --wait clock --wait-at 2026-09-20T09:00:00Z',
+        '<%= config.bin %> followups watch --subject task:OSK-42 --why "deploy tail" --check "release-status says live" --success "live" --abort "6h" --wait clock --wait-at 45m',
     ];
     static flags = {
         subject: core_1.Flags.string({ description: 'Subject ref: type:externalKey', required: true }),
@@ -41,9 +42,15 @@ class FollowupsWatch extends base_command_1.BaseCommand {
             description: 'Predicate tree as JSON (predicate form — the server evaluates it; no agent turn per check): a leaf {"path","op","value"} or {"all"|"any": [...]}. op is equals, not_equals, contains, starts_with, in, gt, lt, exists, … — an unknown op is refused with the full list',
         }),
         grant: core_1.Flags.string({ description: 'Grant id supplying the watch credentials' }),
-        deadline: core_1.Flags.string({ description: 'When the watch must stop (predicate form, required)' }),
-        'check-every': core_1.Flags.string({ description: 'Observation interval (predicate form)' }),
-        'max-checks': core_1.Flags.integer({ description: 'Observation cap (predicate form)' }),
+        deadline: core_1.Flags.string({
+            description: 'When the watch must stop (predicate form, required — refused on a recipe watch, which ends through its --wait)',
+        }),
+        'check-every': core_1.Flags.string({
+            description: 'Observation interval (predicate form — refused on a recipe watch)',
+        }),
+        'max-checks': core_1.Flags.integer({
+            description: 'Observation cap (predicate form — refused on a recipe watch)',
+        }),
         'root-path': core_1.Flags.string({ description: 'JSON root path inside the response' }),
         'resume-prompt': core_1.Flags.string({ description: 'What to tell the settling turn' }),
         // recipe form
@@ -53,10 +60,15 @@ class FollowupsWatch extends base_command_1.BaseCommand {
         success: core_1.Flags.string({ description: 'What state means the wait resolved (recipe form)' }),
         abort: core_1.Flags.string({ description: 'When to stop and escalate (recipe form)' }),
         wait: core_1.Flags.string({
-            description: 'Wait kind (recipe form)',
+            description: 'Wait kind (recipe form, required)',
             options: [...followups_1.WATCH_WAIT_KINDS],
         }),
-        'wait-at': core_1.Flags.string({ description: 'Instant/duration for --wait clock' }),
+        'wait-at': core_1.Flags.string({
+            // Naming both shapes here and in the server's rejection, because the
+            // duration grammar is a shorthand and not ISO-8601: `PT45M` is refused
+            // (OSK-10392).
+            description: 'When --wait clock fires: an ISO-8601 instant, or a duration from now (45m, 2h, 3d, 1w)',
+        }),
         'wait-entity': core_1.Flags.string({ description: 'Entity type for --wait event' }),
         'wait-event': core_1.Flags.string({ description: 'Event type for --wait event' }),
         'wait-filter-field': core_1.Flags.string({ description: 'Payload field for an event filter' }),
@@ -161,6 +173,19 @@ class FollowupsWatch extends base_command_1.BaseCommand {
                     });
                 }
             }
+            const boundsRefusal = (0, followups_1.recipeWatchBoundsRefusal)(flags.wait, {
+                deadline: flags.deadline,
+                checkEvery: flags['check-every'],
+                maxChecks: flags['max-checks'],
+            });
+            if (boundsRefusal) {
+                this.failWithCliError({
+                    message: boundsRefusal,
+                    code: 'FOLLOWUP_INVALID_FIELD',
+                    exit: 2,
+                    retryable: false,
+                });
+            }
             const wait = { kind: flags.wait };
             if (flags.wait === 'clock') {
                 wait.at = flags['wait-at'];
@@ -188,6 +213,16 @@ class FollowupsWatch extends base_command_1.BaseCommand {
                 success: flags.success,
                 abort: flags.abort,
                 wait,
+                // Forwarded so the SERVER refuses them, rather than dropped here so
+                // nobody does (OSK-10407). These are predicate-only bounds; this branch
+                // used to assemble the five fields above and silently discard the rest,
+                // so `--deadline 7d` armed a watch and reported success having stored
+                // no deadline. The rule that answers now lives once, in
+                // `normalizeFollowUpInput`, so the CLI and the agent-facing paths
+                // cannot drift into disagreeing about which form owns a flag.
+                ...(flags.deadline !== undefined ? { deadline: flags.deadline } : {}),
+                ...(flags['check-every'] !== undefined ? { checkEvery: flags['check-every'] } : {}),
+                ...(flags['max-checks'] !== undefined ? { maxChecks: flags['max-checks'] } : {}),
             });
         }
         let response;

package/dist/commands/spaces/briefs/get.js

@@ -38,9 +38,17 @@ class SpacesBriefsGet extends base_command_1.BaseCommand {
             return;
         }
         const b = result;
+        const expertise = Array.isArray(b.expertise) ? b.expertise : [];
+        const dismissed = Array.isArray(b.dismissedExpertiseSuggestions)
+            ? b.dismissedExpertiseSuggestions
+            : [];
         this.log(`Principal Type: ${b.principalType ?? flags.principal}`);
         this.log(`Principal ID:   ${b.principalId ?? flags.id}`);
         this.log(`Updated:        ${b.updatedAt ? (0, format_1.localTime)(b.updatedAt) : '-'}`);
+        this.log(`Expertise:      ${expertise.length > 0 ? expertise.join(', ') : '-'}`);
+        if (dismissed.length > 0) {
+            this.log(`Dismissed:      ${dismissed.join(', ')}`);
+        }
         this.log('');
         this.log('Content:');
         const content = typeof b.content === 'string' ? b.content : '';

package/dist/commands/spaces/briefs/list.js

@@ -39,12 +39,14 @@ class SpacesBriefsList extends base_command_1.BaseCommand {
         const rows = items.map((b) => ({
             principalType: String(b.principalType ?? '-'),
             principalId: String(b.principalId ?? '-'),
+            expertise: Array.isArray(b.expertise) ? b.expertise.join(', ') : '-',
             length: String(typeof b.content === 'string' ? b.content.length : 0),
             updated: b.updatedAt ? (0, format_1.localTime)(b.updatedAt) : '-',
         }));
         (0, format_1.renderTable)(rows, [
             { key: 'principalType', header: 'PRINCIPAL TYPE' },
             { key: 'principalId', header: 'PRINCIPAL ID' },
+            { key: 'expertise', header: 'EXPERTISE', maxWidth: 40 },
             { key: 'length', header: 'LENGTH' },
             { key: 'updated', header: 'UPDATED' },
         ], (line) => this.log(line));

package/dist/commands/spaces/briefs/set.d.ts

@@ -11,6 +11,9 @@ export default class SpacesBriefsSet extends BaseCommand {
         id: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         content: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'content-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        expertise: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'add-expertise': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'dismiss-expertise': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/spaces/briefs/set.js

@@ -44,6 +44,9 @@ class SpacesBriefsSet extends base_command_1.BaseCommand {
     static examples = [
         '<%= config.bin %> spaces briefs set <space-id> --principal user --id <user-id> --content "You are..."',
         '<%= config.bin %> spaces briefs set <space-id> --principal agent --id <agent-id> --content-file brief.md',
+        '<%= config.bin %> spaces briefs set <space-id> --principal agent --id <agent-id> --expertise browser --expertise frontend',
+        '<%= config.bin %> spaces briefs set <space-id> --principal agent --id <agent-id> --add-expertise reliability',
+        '<%= config.bin %> spaces briefs set <space-id> --principal agent --id <agent-id> --dismiss-expertise browser',
         '<%= config.bin %> spaces briefs set <space-id> --principal user --id <user-id> --from-json brief.json',
     ];
     static args = {
@@ -59,15 +62,36 @@ class SpacesBriefsSet extends base_command_1.BaseCommand {
         id: core_1.Flags.string({ description: 'Principal ID', required: true }),
         content: core_1.Flags.string({ description: 'Brief content string' }),
         'content-file': core_1.Flags.string({ description: 'Path to a file whose content becomes the brief' }),
+        expertise: core_1.Flags.string({
+            description: 'Domain label this member is best suited for in the space (repeatable, ≤20 items, ≤40 chars each). Replaces the full expertise list.',
+            multiple: true,
+        }),
+        'add-expertise': core_1.Flags.string({
+            description: 'Add a domain label to the existing expertise list (repeatable, merged — does not replace)',
+            multiple: true,
+        }),
+        'dismiss-expertise': core_1.Flags.string({
+            description: 'Dismiss an expertise suggestion so it stops appearing (repeatable, merged into the dismissed list)',
+            multiple: true,
+        }),
         'from-json': core_1.Flags.string({
-            description: 'Path to a JSON file (or "-" for stdin) containing { content: string }',
+            description: 'Path to a JSON file (or "-" for stdin) containing { content?: string, expertise?: string[], dismissedExpertiseSuggestions?: string[] }',
         }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SpacesBriefsSet);
         let content;
+        let expertise;
+        let dismissed;
+        const addExpertise = flags['add-expertise'] ?? [];
+        const dismissExpertise = flags['dismiss-expertise'] ?? [];
         if (flags['from-json']) {
+            if (addExpertise.length > 0 || dismissExpertise.length > 0) {
+                this.error('--add-expertise / --dismiss-expertise cannot be combined with --from-json.', {
+                    exit: 1,
+                });
+            }
             let body = {};
             try {
                 body = await (0, prompt_1.readJsonBody)(flags['from-json']);
@@ -75,24 +99,56 @@ class SpacesBriefsSet extends base_command_1.BaseCommand {
             catch (err) {
                 this.error(err.message, { exit: 1 });
             }
-            if (typeof body.content !== 'string') {
-                this.error('JSON body must contain a "content" string field.', { exit: 1 });
+            if (body.content !== undefined && typeof body.content !== 'string') {
+                this.error('JSON body "content" must be a string when provided.', { exit: 1 });
+            }
+            for (const key of ['expertise', 'dismissedExpertiseSuggestions']) {
+                if (body[key] !== undefined && !Array.isArray(body[key])) {
+                    this.error(`JSON body "${key}" must be an array of strings when provided.`, { exit: 1 });
+                }
             }
             content = body.content;
+            expertise = body.expertise;
+            dismissed = body.dismissedExpertiseSuggestions;
         }
-        else if (flags['content-file']) {
-            try {
-                content = fs.readFileSync(flags['content-file'], 'utf8');
+        else {
+            if (flags['content-file']) {
+                try {
+                    content = fs.readFileSync(flags['content-file'], 'utf8');
+                }
+                catch (err) {
+                    this.error(`Could not read content file: ${err.message}`, { exit: 1 });
+                }
             }
-            catch (err) {
-                this.error(`Could not read content file: ${err.message}`, { exit: 1 });
+            else if (flags.content !== undefined) {
+                content = flags.content;
+            }
+            if (flags.expertise !== undefined) {
+                expertise = flags.expertise;
             }
         }
-        else if (flags.content !== undefined) {
-            content = flags.content;
+        const needsMerge = addExpertise.length > 0 || dismissExpertise.length > 0;
+        if (needsMerge) {
+            let existing = {};
+            try {
+                existing = (await data_provider_1.dataService.getSpaceBrief(args.id, flags.principal, flags.id));
+            }
+            catch {
+                existing = {};
+            }
+            if (addExpertise.length > 0) {
+                const base = expertise ?? (Array.isArray(existing.expertise) ? existing.expertise : []);
+                expertise = [...new Set([...base, ...addExpertise])];
+            }
+            if (dismissExpertise.length > 0) {
+                const current = Array.isArray(existing.dismissedExpertiseSuggestions)
+                    ? existing.dismissedExpertiseSuggestions
+                    : [];
+                dismissed = [...new Set([...current, ...dismissExpertise])];
+            }
         }
-        else {
-            this.error('Provide content via --content, --content-file, or --from-json.', { exit: 1 });
+        if (content === undefined && expertise === undefined && dismissed === undefined) {
+            this.error('Provide --content, --content-file, --expertise, --add-expertise, --dismiss-expertise, or --from-json.', { exit: 1 });
         }
         let result;
         try {
@@ -101,6 +157,8 @@ class SpacesBriefsSet extends base_command_1.BaseCommand {
                 principalType: flags.principal,
                 principalId: flags.id,
                 content,
+                expertise,
+                dismissedExpertiseSuggestions: dismissed,
             });
         }
         catch (err) {
@@ -110,7 +168,14 @@ class SpacesBriefsSet extends base_command_1.BaseCommand {
             this.log(JSON.stringify((0, space_output_1.withSpacePerspectiveUrl)(this.cliConfig.baseURL, args.id, 'members', result), null, 2));
             return;
         }
-        this.log(`Saved brief for ${flags.principal} ${flags.id} in space ${args.id} (${content.length} chars)`);
+        const changed = [
+            content !== undefined ? `content (${content.length} chars)` : null,
+            expertise !== undefined ? `expertise=[${expertise.join(', ')}]` : null,
+            dismissed !== undefined ? `dismissed=[${dismissed.join(', ')}]` : null,
+        ]
+            .filter(Boolean)
+            .join(', ');
+        this.log(`Saved brief for ${flags.principal} ${flags.id} in space ${args.id}: ${changed}`);
     }
 }
 exports.default = SpacesBriefsSet;

package/dist/commands/spaces/expertise-suggestions.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command';
+export default class SpacesExpertiseSuggestions 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/spaces/expertise-suggestions.js

@@ -0,0 +1,71 @@
+"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 format_1 = require("../../lib/format");
+const space_output_1 = require("../../lib/space-output");
+class SpacesExpertiseSuggestions extends base_command_1.BaseCommand {
+    static description = 'Advisory domain expertise inferred from settled-task history (computed on read, never persisted)';
+    static examples = [
+        '<%= config.bin %> spaces expertise-suggestions <space-id>',
+        '<%= config.bin %> spaces expertise-suggestions <space-id> --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpacesExpertiseSuggestions);
+        let response;
+        let members;
+        try {
+            response = await data_provider_1.dataService.getSpaceExpertiseSuggestions(args.id);
+            members = await data_provider_1.dataService.getSpaceMembers(args.id).catch(() => undefined);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify((0, space_output_1.withSpacePerspectiveUrl)(this.cliConfig.baseURL, args.id, 'members', response), null, 2));
+            return;
+        }
+        const suggestions = response.suggestions ?? [];
+        if (suggestions.length === 0) {
+            this.log('No expertise suggestions.');
+            return;
+        }
+        const nameByAgentId = new Map();
+        for (const agent of members?.agents ?? []) {
+            if (agent.id)
+                nameByAgentId.set(agent.id, agent.name || agent.id);
+            if (agent._id)
+                nameByAgentId.set(agent._id, agent.name || agent.id);
+        }
+        const rows = suggestions.map((s) => {
+            const evidence = (s.evidence ?? {});
+            const agentId = String(s.agentId ?? '-');
+            return {
+                agent: nameByAgentId.get(agentId) ?? agentId,
+                suggested: String(s.suggestedExpertise ?? '-'),
+                evidence: evidence.tasks !== undefined && evidence.succeeded !== undefined
+                    ? `${evidence.succeeded}/${evidence.tasks} succeeded`
+                    : '-',
+                samples: (evidence.sampleIdentifiers ?? []).join(', ') || '-',
+            };
+        });
+        (0, format_1.renderTable)(rows, [
+            { key: 'agent', header: 'AGENT', maxWidth: 28 },
+            { key: 'suggested', header: 'SUGGESTED EXPERTISE', maxWidth: 32 },
+            { key: 'evidence', header: 'EVIDENCE' },
+            { key: 'samples', header: 'SAMPLE TASKS', maxWidth: 40 },
+        ], (line) => this.log(line));
+        this.log('');
+        this.log('Accept: skrr spaces briefs set <space-id> --principal agent --id <agent-id> --expertise <value>');
+        this.log('Dismiss: skrr spaces briefs set <space-id> --principal agent --id <agent-id> --dismiss-expertise <value>');
+    }
+}
+exports.default = SpacesExpertiseSuggestions;

package/dist/commands/spaces/members/add.d.ts

@@ -12,6 +12,7 @@ export default class SpacesMembersAdd extends BaseCommand {
         role: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         brief: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'brief-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        expertise: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }