@skrr-ai/cli 0.1.46 → 0.1.47

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

@@ -25,8 +25,8 @@ import { BaseCommand } from '../../base-command';
  *
  * The transcript CAN travel once the engine implements the session-export
  * contract (docs/architecture/sky-code-session-export-contract-2026-08-21.md):
- * `sky-code session export <id> --format json` writes a versioned envelope to
- * stdout. This flag runs exactly that contract and folds the export into the
+ * `session export <id> --format json` on the engine writes a versioned envelope
+ * to stdout. This flag runs exactly that contract and folds the export into the
  * prompt — the endpoint's only carrier. An engine that predates the contract
  * is a clean refusal, never a silent fallback to brief-only.
  *

package/dist/commands/code/handover.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const data_provider_1 = require("@skrr-ai/data-provider");
+const auth_core_1 = require("@skrr-ai/auth-core");
 const base_command_1 = require("../../base-command");
 const code_handover_1 = require("../../lib/code-handover");
 const first_party_harness_1 = require("../../lib/first-party-harness");
@@ -33,8 +34,8 @@ const first_party_harness_1 = require("../../lib/first-party-harness");
  *
  * The transcript CAN travel once the engine implements the session-export
  * contract (docs/architecture/sky-code-session-export-contract-2026-08-21.md):
- * `sky-code session export <id> --format json` writes a versioned envelope to
- * stdout. This flag runs exactly that contract and folds the export into the
+ * `session export <id> --format json` on the engine writes a versioned envelope
+ * to stdout. This flag runs exactly that contract and folds the export into the
  * prompt — the endpoint's only carrier. An engine that predates the contract
  * is a clean refusal, never a silent fallback to brief-only.
  *
@@ -77,15 +78,15 @@ class CodeHandover extends base_command_1.BaseCommand {
             description: 'Give the receiving agent a browser. Refused where the deployment has no browser runtime, never run without one.',
         }),
         'carry-session': core_1.Flags.boolean({
-            description: 'Export the engine session transcript (`sky-code session export`) and carry it into the ' +
-                'handover. Opt-in because carrying a whole session is a cost the user should choose. ' +
-                'Refused outright when the engine predates the export contract — there is no silent ' +
-                'fallback to brief-only.',
+            description: `Export the engine session transcript (\`${auth_core_1.FIRST_PARTY_HARNESS.provider} session export\`) ` +
+                'and carry it into the handover. Opt-in because carrying a whole session is a cost the ' +
+                'user should choose. Refused outright when the engine predates the export contract — ' +
+                'there is no silent fallback to brief-only.',
             default: false,
         }),
         session: core_1.Flags.string({
             description: 'Engine session id to export with --carry-session (default: the session id the engine ' +
-                'exports to its environment — SKRR_CODE_SESSION_ID or SKY_CODE_SESSION_ID)',
+                `exports to its environment — ${(0, auth_core_1.firstPartyHarnessEngineEnvNames)('sessionId').join(' or ')})`,
         }),
         json: core_1.Flags.boolean({ description: 'Output the created task as JSON' }),
     };
@@ -142,12 +143,10 @@ class CodeHandover extends base_command_1.BaseCommand {
                 this.error((0, first_party_harness_1.notInstalledMessage)());
             // `--session` wins; otherwise the variable the engine stamps into
             // processes it spawns (current namespace, then the legacy spelling).
-            const sessionId = flags.session ||
-                process.env.SKRR_CODE_SESSION_ID?.trim() ||
-                process.env.SKY_CODE_SESSION_ID?.trim();
+            const sessionId = flags.session || (0, auth_core_1.readFirstPartyHarnessEngineEnv)(process.env, 'sessionId').value;
             if (!sessionId) {
                 this.error('--carry-session needs the engine session to carry. Pass --session <engine-session-id>, ' +
-                    'or run inside a session that exports SKRR_CODE_SESSION_ID.');
+                    `or run inside a session that exports ${(0, auth_core_1.firstPartyHarnessEngineEnvNames)('sessionId')[0]}.`);
             }
             carriedSessionId = sessionId;
             let stdout;
@@ -165,8 +164,8 @@ class CodeHandover extends base_command_1.BaseCommand {
                     this.error(`No engine session "${sessionId}" — the engine found nothing to carry.\n` +
                         `  ${failure.detail}`);
                 }
-                this.error('This engine does not support session export — --carry-session requires a sky-code ' +
-                    'engine implementing the session-export contract ' +
+                this.error(`This engine does not support session export — --carry-session requires a ` +
+                    `${auth_core_1.FIRST_PARTY_HARNESS_ENGINE.appName} engine implementing the session-export contract ` +
                     '(docs/architecture/sky-code-session-export-contract-2026-08-21.md).\n' +
                     `  ${failure.detail}\n` +
                     '  Re-run without --carry-session to hand over the situation only, or upgrade the engine.');

package/dist/commands/code/install.js

@@ -57,6 +57,37 @@ class CodeInstall extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
+        // The daemon distinguishes three refusals, and only one of them attaches a
+        // job worth following:
+        //
+        // - `alreadyInstalled` carries the LAST job the provider ran — context, not
+        //   this request's work. Following it replays a stale outcome as though it
+        //   had just happened: `code install` on an engine one release behind
+        //   reprinted the previous update's log tail verbatim and reported that job
+        //   as its result (OSK-10650). The right answer is the daemon's own
+        //   installDisabledReason plus where the update actually comes from.
+        // - `alreadyRunning` carries the LIVE job — following it attaches the user
+        //   to work that is really in flight, which is what they asked for.
+        // - `started` carries the job this request began.
+        if (started.alreadyInstalled) {
+            if (flags.json) {
+                this.log(JSON.stringify({ daemonId, ...started }, null, 2));
+                return;
+            }
+            const state = started.provider;
+            const reason = state?.installDisabledReason?.trim();
+            const version = state?.version?.trim();
+            this.log(`Nothing to do on ${daemonId} — ${reason || 'Already installed.'}${version ? ` (${version})` : ''}`);
+            if (state?.updatable === true) {
+                this.log(`To update it: ${this.config.bin} code update`);
+            }
+            else {
+                const why = state?.updateDisabledReason?.trim();
+                if (why)
+                    this.log(`Updating: ${why}`);
+            }
+            return;
+        }
         const jobId = started.job?.id;
         // A 202 carrying NO job is not a queued install. It is the daemon
         // acknowledging the call and returning nothing, and the route builds its

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

@@ -0,0 +1,46 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr code update` — pull the engine's signed release down through the daemon.
+ *
+ * ── Why this command exists ────────────────────────────────────────────────
+ *
+ * The update verb has been API-exposed and daemon-implemented since OSK-10096 —
+ * `POST /api/daemons/:id/cli-installers/:provider/update` re-fetches the signed
+ * manifest and installs whatever the channel points at. But the only CLI that
+ * reached it was `skrr harnesses install <provider> --update`: a flag on a
+ * command a `code` user has no reason to read. On stable that left no
+ * discoverable path at all — `code install` answered "Already installed." with
+ * no next step, and the channel moving past the installed build was invisible
+ * from the surface that owns the engine (OSK-10650).
+ *
+ * So this adds a SURFACE and no mechanism. Same route `harnesses install
+ * --update` posts, same inventory pre-check, same 504 recovery — one update
+ * path, spelled where the engine's users look.
+ */
+export default class CodeUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        daemon: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /** Which daemon the update targets, by the rule every daemon-picking command shares. */
+    private resolveTarget;
+    /**
+     * The daemon id to update through, or the refusal — identical rules to
+     * `code install`: a Dedicated Runtime's own machine is image-managed, several
+     * connected daemons get named rather than guessed.
+     */
+    private updateTarget;
+    /**
+     * Start the update, and survive a gateway that cut the request off — the same
+     * 504 recovery `harnesses install --update` uses: the relay can drop the
+     * answer while the daemon runs the job it started, so on a server-side
+     * failure we ask the daemon and follow the job it reports.
+     */
+    private start;
+    /** Follow a job to its end, or report why it could not be followed (and return nothing). */
+    private follow;
+}

package/dist/commands/code/update.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const auth_core_1 = require("@skrr-ai/auth-core");
+const base_command_1 = require("../../base-command");
+const cli_installers_1 = require("../../lib/cli-installers");
+const daemon_target_1 = require("../../lib/daemon-target");
+const first_party_harness_1 = require("../../lib/first-party-harness");
+/**
+ * `skrr code update` — pull the engine's signed release down through the daemon.
+ *
+ * ── Why this command exists ────────────────────────────────────────────────
+ *
+ * The update verb has been API-exposed and daemon-implemented since OSK-10096 —
+ * `POST /api/daemons/:id/cli-installers/:provider/update` re-fetches the signed
+ * manifest and installs whatever the channel points at. But the only CLI that
+ * reached it was `skrr harnesses install <provider> --update`: a flag on a
+ * command a `code` user has no reason to read. On stable that left no
+ * discoverable path at all — `code install` answered "Already installed." with
+ * no next step, and the channel moving past the installed build was invisible
+ * from the surface that owns the engine (OSK-10650).
+ *
+ * So this adds a SURFACE and no mechanism. Same route `harnesses install
+ * --update` posts, same inventory pre-check, same 504 recovery — one update
+ * path, spelled where the engine's users look.
+ */
+class CodeUpdate extends base_command_1.BaseCommand {
+    static description = `Update the ${auth_core_1.FIRST_PARTY_HARNESS.displayName} engine on this machine, through the daemon`;
+    static examples = [
+        '<%= config.bin %> code update',
+        '<%= config.bin %> code update --daemon <daemon-id>',
+        '<%= config.bin %> code update --json',
+    ];
+    static flags = {
+        daemon: core_1.Flags.string({
+            description: 'Which daemon runs the update. Defaults to this machine on a Dedicated Runtime, otherwise to the only active one; required when you have several.',
+        }),
+        wait: core_1.Flags.boolean({
+            default: true,
+            allowNo: true,
+            description: 'Follow the update job until it finishes. --no-wait returns the job id.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Emit the result as JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(CodeUpdate);
+        const daemonId = this.updateTarget(await this.resolveTarget(flags.daemon));
+        // Ask the inventory before posting: a daemon older than managed updates has
+        // no handler for the request and would leave it to time out, and an engine
+        // that updates some other way has a reason the daemon already words.
+        let inventory;
+        try {
+            inventory = await (0, cli_installers_1.listCliInstallers)(daemonId, this.resolvedCredential);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const row = (inventory.providers ?? []).find((p) => (0, auth_core_1.isFirstPartyHarnessProvider)(p.provider));
+        if (!row) {
+            this.failWithCliError({
+                message: `${auth_core_1.FIRST_PARTY_HARNESS.displayName} is not installed on ${daemonId}. ` +
+                    `Install it with \`${this.config.bin} code install\`.`,
+                code: 'NOT_INSTALLED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (row.updatable === undefined) {
+            this.failWithCliError({
+                message: `The daemon ${daemonId} (${inventory.daemonVersion ?? 'version not reported'}) cannot update ${auth_core_1.FIRST_PARTY_HARNESS.displayName}: it predates managed updates. ` +
+                    `Update the daemon, then run this again.`,
+                code: 'DAEMON_UPDATE_UNSUPPORTED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (!row.updatable) {
+            this.failWithCliError({
+                message: row.updateDisabledReason?.trim() ||
+                    `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: the daemon cannot update it here.`,
+                code: 'CLI_NOT_UPDATABLE',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const start = await this.start(daemonId, flags.json === true);
+        if (!start)
+            return;
+        const jobId = start.job?.id;
+        if (!start.started || !jobId) {
+            if (flags.json) {
+                this.log(JSON.stringify({ daemonId, ...start }, null, 2));
+                return;
+            }
+            this.log(start.alreadyRunning
+                ? `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: an install or update is already running (job ${start.job?.id ?? 'unknown'}).`
+                : `${auth_core_1.FIRST_PARTY_HARNESS.displayName}: ${start.provider?.updateDisabledReason?.trim() || 'the daemon started no update job.'}`);
+            return;
+        }
+        if (!flags.wait) {
+            if (flags.json) {
+                this.log(JSON.stringify({ daemonId, ...start }, null, 2));
+                return;
+            }
+            this.log(`Update started on ${daemonId} — job ${jobId}.`);
+            return;
+        }
+        if (!flags.json) {
+            this.logToStderr(`Updating ${auth_core_1.FIRST_PARTY_HARNESS.displayName} ${row.version ? `${row.version} ` : ''}on ${daemonId}…`);
+        }
+        const job = await this.follow(daemonId, jobId, flags.json === true);
+        if (!job)
+            return;
+        if (flags.json) {
+            this.log(JSON.stringify({ daemonId, job }, null, 2));
+            if (job.status !== 'succeeded')
+                process.exitCode = 1;
+            return;
+        }
+        if (job.status === 'failed') {
+            this.failWithCliError({
+                message: job.error || 'The update failed and the daemon gave no reason.',
+                code: 'UPDATE_FAILED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        this.log((0, cli_installers_1.updateOutcomeLine)(job) ??
+            `${auth_core_1.FIRST_PARTY_HARNESS.displayName} updated${job.installedVersion ? ` to ${job.installedVersion}` : ''}.`);
+    }
+    /** Which daemon the update targets, by the rule every daemon-picking command shares. */
+    async resolveTarget(explicit) {
+        try {
+            return await (0, daemon_target_1.resolveDaemonTarget)({
+                explicit,
+                local: (0, daemon_target_1.localMachine)({ baseURL: this.cliConfig?.baseURL }),
+                listActiveDaemons: () => (0, daemon_target_1.listConnectedDaemons)(this.resolvedCredential),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+    }
+    /**
+     * The daemon id to update through, or the refusal — identical rules to
+     * `code install`: a Dedicated Runtime's own machine is image-managed, several
+     * connected daemons get named rather than guessed.
+     */
+    updateTarget(target) {
+        if (target.kind === 'daemon')
+            return target.daemonId;
+        if (target.kind === 'this-machine') {
+            this.failWithCliError({
+                message: target.explicit
+                    ? first_party_harness_1.DEDICATED_RUNTIME_ENGINE_MESSAGE
+                    : `${first_party_harness_1.DEDICATED_RUNTIME_ENGINE_MESSAGE} This command updates the machine it runs on; ` +
+                        'to update another of your machines, name it with --daemon.',
+                code: 'DEDICATED_RUNTIME_ENGINE_SHIPS_WITH_IMAGE',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        if (target.kind === 'none') {
+            this.failWithCliError({
+                message: 'No daemon is connected for this account, so nothing can perform the update. ' +
+                    `Start the background service on this computer with \`${this.config.bin} daemon start\`, then run this again.`,
+                code: 'NO_DAEMON',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const { daemons } = target;
+        const choices = daemons
+            .slice(0, 10)
+            .map((d) => `  ${d.id}  ${d.name || '—'}`)
+            .join('\n');
+        this.failWithCliError({
+            message: `${daemons.length} connected daemons — say which machine should update the engine:\n${choices}\n` +
+                `Pass one with --daemon, or see each daemon id in the DAEMON ID column of \`${this.config.bin} harnesses list\`.`,
+            code: 'AMBIGUOUS_DAEMON',
+            exit: 1,
+            retryable: false,
+        });
+    }
+    /**
+     * Start the update, and survive a gateway that cut the request off — the same
+     * 504 recovery `harnesses install --update` uses: the relay can drop the
+     * answer while the daemon runs the job it started, so on a server-side
+     * failure we ask the daemon and follow the job it reports.
+     */
+    async start(daemonId, json) {
+        try {
+            return await (0, cli_installers_1.startManagedCliUpdate)(daemonId, PROVIDER, this.resolvedCredential);
+        }
+        catch (err) {
+            const status = err.status ?? 0;
+            if (status >= 500 || status === 408) {
+                const job = await (0, cli_installers_1.jobStartedDespiteTimeout)(daemonId, PROVIDER, this.resolvedCredential);
+                if (job?.id) {
+                    if (!json) {
+                        this.logToStderr(`The request to ${daemonId} did not come back (HTTP ${status}), but the daemon started job ${job.id}. Following it.`);
+                    }
+                    return { started: true, job };
+                }
+            }
+            this.handleApiError(err);
+            return undefined;
+        }
+    }
+    /** Follow a job to its end, or report why it could not be followed (and return nothing). */
+    async follow(daemonId, jobId, json) {
+        const outcome = await (0, cli_installers_1.followManagedCliInstallJob)({
+            daemonId,
+            jobId,
+            credential: this.resolvedCredential,
+            onLogLine: json ? undefined : (line) => this.logToStderr(`  ${line}`),
+        });
+        if (outcome.kind === 'missing') {
+            this.failWithCliError({
+                message: `The daemon no longer has update job ${jobId}.`,
+                code: 'JOB_MISSING',
+                exit: 1,
+                retryable: false,
+            });
+            return undefined;
+        }
+        if (outcome.kind === 'timeout') {
+            this.failWithCliError({
+                message: `Still updating after ${Math.round(cli_installers_1.INSTALL_MAX_WAIT_MS / 60000)} minutes — the daemon is ` +
+                    `still working on job ${jobId}. Check \`${this.config.bin} code doctor\` in a while.`,
+                code: 'UPDATE_PENDING',
+                exit: 1,
+                retryable: true,
+            });
+            return undefined;
+        }
+        return outcome.job;
+    }
+}
+exports.default = CodeUpdate;
+/** Same canonical provider id `code install` posts — read from the identity module. */
+const PROVIDER = auth_core_1.FIRST_PARTY_HARNESS.provider;

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/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>;