@skrr-ai/cli 0.1.56 → 0.1.58

package/dist/base-command.d.ts

@@ -109,6 +109,17 @@ export declare abstract class BaseCommand extends Command {
      * silently matched nothing reaches the search.
      */
     protected resolveSpaceReference(value: string): Promise<string>;
+    /**
+     * A 24-hex value: almost always the internal `_id` copied from `--json`,
+     * which prints it first (OSK-12205). No space route accepts it, so passing it
+     * through produced a not-found or a raw 404 that never said to use `id`.
+     *
+     * One listing tells the cases apart: a space whose `id` really is this value
+     * passes through unchanged; one whose `_id` is this value fails naming the
+     * exact `id` to use. A listing that fails, or finds neither, is not proof of
+     * anything, so it keeps the old pass-through and lets the route answer.
+     */
+    private resolveObjectIdShapedSpace;
     /**
      * Turn a project reference into `{ projectRef, spaceId }`, or fail the
      * command.

package/dist/base-command.js

@@ -20,6 +20,7 @@ const core_1 = require("@oclif/core");
 Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return core_1.Flags; } });
 const option_hint_1 = require("./lib/option-hint");
 const failed_lookup_1 = require("./lib/failed-lookup");
+const internal_id_1 = require("./lib/internal-id");
 const http_error_1 = require("./lib/http-error");
 // Re-exported from its home in `lib/keychain`, beside the other profile
 // functions. It lived here while `init()` was its only caller; a lib module
@@ -260,6 +261,27 @@ class BaseCommand extends core_1.Command {
         // can't wedge the CLI; on timeout we fall through to legacy
         // plaintext and the resolver still finds the token.
         await (0, auth_core_init_1.prefetchCliAuth)();
+        // On a brokered Dedicated guest a stored cli-auth.json predates broker
+        // mode, and the broker's success path retires it (revoke + delete). That
+        // could never run when the file carried an access token: the resolver
+        // below adopted it first, and the auto-broker only asks when the resolver
+        // found nothing — so a live pre-broker family was used and kept forever
+        // (OSK-12194). Broker FIRST in exactly that case. The file is retired only
+        // after a redeem succeeds; if the broker cannot answer, the resolver still
+        // falls back to the file, so a working login is never lost to an outage.
+        // `maybeAutoBroker` applies the same skip rules as below (bare, env token,
+        // login/logout/pair), and a laptop never has the guest descriptor.
+        let earlyAutoBroker = null;
+        if (!this.bareMode && !parsed.token && (0, daemonBroker_1.shouldBrokerBeforeStoredCredential)()) {
+            earlyAutoBroker = await (0, daemonBroker_1.maybeAutoBroker)({
+                cliConfig: this.cliConfig,
+                bareMode: this.bareMode,
+                commandId: this.id,
+            });
+            if (!earlyAutoBroker.triggered)
+                earlyAutoBroker = null;
+        }
+        const brokeredFirst = earlyAutoBroker?.outcome?.ok === true;
         // Resolve credential via the Phase H.1 precedence chain. The
         // adapter then cherry-picks the token for the Authorization
         // header; we hand it a pre-resolved override so it doesn't
@@ -296,12 +318,14 @@ class BaseCommand extends core_1.Command {
         // repair that reason implies — "Not signed in. Run `skrr login`" was true
         // and pointed at the wrong fix (OSK-12149). Rate limiting and a mismatched
         // baseURL keep their own one-line hints below.
-        if (!this.resolvedCredential.token) {
-            const autoResult = await (0, daemonBroker_1.maybeAutoBroker)({
-                cliConfig: this.cliConfig,
-                bareMode: this.bareMode,
-                commandId: this.id,
-            });
+        if (!this.resolvedCredential.token || brokeredFirst) {
+            // The guest's early broker above already asked; its answer stands.
+            const autoResult = earlyAutoBroker ??
+                (await (0, daemonBroker_1.maybeAutoBroker)({
+                    cliConfig: this.cliConfig,
+                    bareMode: this.bareMode,
+                    commandId: this.id,
+                }));
             if (autoResult.triggered && autoResult.outcome) {
                 if (autoResult.outcome.ok) {
                     // Persist the cliId now so a sibling skrr process spawned
@@ -449,6 +473,8 @@ class BaseCommand extends core_1.Command {
         // Only canonical ids short-circuit. Human-readable refs are accepted by
         // some read endpoints, but space-scoped mutation endpoints require the
         // UUID, so refs go through the same exact-match resolution as titles.
+        if ((0, internal_id_1.looksLikeInternalObjectId)(query))
+            return this.resolveObjectIdShapedSpace(query);
         if (!query || (0, space_resolver_1.looksLikeCanonicalSpaceId)(query))
             return query;
         if ((0, failed_lookup_1.isFailedLookupValue)(query)) {
@@ -493,6 +519,43 @@ class BaseCommand extends core_1.Command {
             },
         });
     }
+    /**
+     * A 24-hex value: almost always the internal `_id` copied from `--json`,
+     * which prints it first (OSK-12205). No space route accepts it, so passing it
+     * through produced a not-found or a raw 404 that never said to use `id`.
+     *
+     * One listing tells the cases apart: a space whose `id` really is this value
+     * passes through unchanged; one whose `_id` is this value fails naming the
+     * exact `id` to use. A listing that fails, or finds neither, is not proof of
+     * anything, so it keeps the old pass-through and lets the route answer.
+     */
+    async resolveObjectIdShapedSpace(query) {
+        let rows = [];
+        try {
+            const response = (await data_provider_1.dataService.listSpaces({ limit: 200, includeArchived: true }));
+            rows = response?.data ?? [];
+        }
+        catch {
+            return query;
+        }
+        if (rows.some((row) => row.id === query))
+            return query;
+        const byInternalId = rows.find((row) => String(row._id ?? '') === query);
+        if (!byInternalId)
+            return query;
+        this.failWithCliError({
+            message: (0, internal_id_1.describeInternalIdMisuse)({
+                value: query,
+                noun: 'space',
+                canonicalId: typeof byInternalId.id === 'string' ? byInternalId.id : null,
+                bin: this.config.bin,
+            }),
+            code: 'SPACE_INTERNAL_ID',
+            exit: 2,
+            retryable: false,
+            details: { context: { query, id: byInternalId.id } },
+        });
+    }
     async resolveProjectReference(value, spaceFlag, opts = {}) {
         const spaceRequired = opts.spaceRequired !== false;
         const { projectRef, spaceRef } = (0, projects_1.splitQualifiedProjectRef)(value, spaceFlag);
@@ -557,6 +620,17 @@ class BaseCommand extends core_1.Command {
         const query = value.trim();
         if (!query)
             return query;
+        // A task's `id` is a UUID, so a 24-hex value is the internal `_id` that
+        // `--json` prints first. The title search it used to reach can only say
+        // "no task matching", which never names the field to use (OSK-12205).
+        if ((0, internal_id_1.looksLikeInternalObjectId)(query)) {
+            this.failWithCliError({
+                message: (0, internal_id_1.describeInternalIdMisuse)({ value: query, noun: 'task', bin: this.config.bin }),
+                code: 'TASK_INTERNAL_ID',
+                exit: 2,
+                retryable: false,
+            });
+        }
         // Before the search, not after it: `null` from a failed `jq -r` must never
         // reach the title tiers, and it should not cost a request to say so.
         if ((0, failed_lookup_1.isFailedLookupValue)(query)) {

package/dist/commands/agents/chat.js

@@ -287,9 +287,11 @@ class AgentsChat extends base_command_1.BaseCommand {
             description: 'Permission mode for THIS turn only, on a local-harness agent. It beats the agent’s and ' +
                 'the harness’s stored defaults for this turn and changes nothing else — pass it again ' +
                 'on each turn that needs it (`agents update --default-permission-mode` changes every ' +
-                'conversation of the agent). A mode the harness cannot honour runs as the one it can, ' +
-                'and run.started says which. --approve-tools is separate: it answers the approval ' +
-                'prompts a mode asks for.',
+                'conversation of the agent). A mode the harness cannot honour runs as the closest ' +
+                'STRICTER mode it can, and run.started says which; when the only mode it can run would ' +
+                'let more run without asking, the turn is refused before it starts (run.failed, ' +
+                'PERMISSION_MODE_UNSUPPORTED_BY_HARNESS). --approve-tools is separate: it answers the ' +
+                'approval prompts a mode asks for.',
             options: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
         }),
         'local-skill': core_1.Flags.string({

package/dist/commands/agents/create.js

@@ -9,6 +9,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const agent_visual_refs_1 = require("../../lib/agent-visual-refs");
 const runtime_tool_support_1 = require("../../lib/runtime-tool-support");
+const agent_model_check_1 = require("../../lib/agent-model-check");
 const base_command_1 = require("../../base-command");
 const execution_target_1 = require("../../lib/execution-target");
 const prompt_1 = require("../../lib/prompt");
@@ -407,6 +408,12 @@ class AgentsCreate extends base_command_1.BaseCommand {
             this.warn(unappliedPayloadKeysWarning(unapplied));
         }
         await (0, runtime_tool_support_1.warnPluginsNotLoaded)(payload.tools, (message) => this.warn(message));
+        await (0, agent_model_check_1.warnIfModelNotListed)({
+            model: payload.model,
+            agent: created,
+            bin: this.config.bin,
+            warn: (message) => this.warn(message),
+        });
         if (flags.json) {
             this.log(JSON.stringify((0, web_url_1.withAgentUrl)(this.cliConfig.baseURL, created), null, 2));
             return;

package/dist/commands/agents/show.js

@@ -54,8 +54,19 @@ function agentPermissionLines(agent, harness) {
         return [`Permission:  ${stored} — enforced by the ${harness} harness`];
     }
     const lines = [];
-    if (typeof effective.mode === 'string' && effective.mode) {
-        const from = PERMISSION_SOURCE_LABELS[effective.source] ?? effective.source;
+    const from = PERMISSION_SOURCE_LABELS[effective.source] ?? effective.source;
+    if (typeof effective.refusedMode === 'string' && effective.refusedMode) {
+        // OSK-12316: a mode the harness could only honour by WIDENING it is refused
+        // at dispatch (OSK-12154); it does not "run as" anything.
+        const required = typeof effective.requiredMode === 'string' && effective.requiredMode
+            ? effective.requiredMode
+            : null;
+        lines.push(`Permission:  ${effective.refusedMode} (from ${from}) — turns are REFUSED: the ${harness} harness cannot run it without allowing more`);
+        if (required) {
+            lines.push(`${pad}Set ${required} to run (skrr agents update <agent> --default-permission-mode ${required}), or pass --permission-mode for a turn.`);
+        }
+    }
+    else if (typeof effective.mode === 'string' && effective.mode) {
         lines.push(`Permission:  ${effective.mode} (from ${from}) — enforced by the ${harness} harness`);
     }
     else {

package/dist/commands/agents/update.js

@@ -10,6 +10,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const agent_visual_refs_1 = require("../../lib/agent-visual-refs");
 const create_1 = require("./create");
 const runtime_tool_support_1 = require("../../lib/runtime-tool-support");
+const agent_model_check_1 = require("../../lib/agent-model-check");
 const base_command_1 = require("../../base-command");
 const execution_target_1 = require("../../lib/execution-target");
 const prompt_1 = require("../../lib/prompt");
@@ -221,6 +222,12 @@ class AgentsUpdate extends base_command_1.BaseCommand {
         for (const warning of agentUpdateWarnings(payload, updated))
             this.warn(warning);
         await (0, runtime_tool_support_1.warnPluginsNotLoaded)(payload.tools, (message) => this.warn(message));
+        await (0, agent_model_check_1.warnIfModelNotListed)({
+            model: payload.model,
+            agent: updated,
+            bin: this.config.bin,
+            warn: (message) => this.warn(message),
+        });
         if (flags.json) {
             this.log(JSON.stringify((0, web_url_1.withAgentUrl)(this.cliConfig.baseURL, updated), null, 2));
             return;

package/dist/commands/harnesses/ping.d.ts

@@ -8,6 +8,8 @@ import { BaseCommand } from '../../base-command';
  * sends, and testing for them alone is what made the success branch dead code.
  */
 export declare function isPingSuccess(status: string | undefined): boolean;
+/** The server declared a completed probe failure, not a still-pending poll. */
+export declare function describePingFailure(status: string, error?: string | null): string;
 export default class HarnessesPing extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/harnesses/ping.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPingSuccess = isPingSuccess;
+exports.describePingFailure = describePingFailure;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const harnesses_1 = require("../../lib/harnesses");
@@ -31,6 +32,14 @@ const POLL_INTERVAL_MS = 300;
 function isPingSuccess(status) {
     return status === 'completed' || status === 'ok' || status === 'success';
 }
+/** The server declared a completed probe failure, not a still-pending poll. */
+function describePingFailure(status, error) {
+    const detail = typeof error === 'string' && error.trim() ? `: ${error.trim()}` : '.';
+    if (status === 'timeout') {
+        return `Ping timed out${detail} The daemon is registered but may be offline or not responding.`;
+    }
+    return `Ping ${status}${detail} The daemon is registered but may be offline or not responding.`;
+}
 class HarnessesPing extends base_command_1.BaseCommand {
     static description = 'Ping a harness and wait for its daemon to answer (local only)';
     static examples = [
@@ -90,7 +99,7 @@ class HarnessesPing extends base_command_1.BaseCommand {
                     await this.logReadiness(args.harness);
                 }
                 else {
-                    this.log(`Ping ${result.status}${result.error ? `: ${result.error}` : ''}.`);
+                    this.error(describePingFailure(result.status, result.error), { exit: 1 });
                 }
                 return;
             }

package/dist/commands/login.js

@@ -234,6 +234,25 @@ class Login extends base_command_1.BaseCommand {
                 if (handoff.status === 'delivered') {
                     this.log(`The local daemon was signed in too — ${handoff.detail}.`);
                 }
+                else if (handoff.reason === 'platform-managed') {
+                    // A Dedicated guest: its daemon is the platform's, so there is
+                    // nothing to install and nothing to hand over (OSK-12296).
+                    this.log("This machine's daemon is managed by the platform; there is nothing to set up here.");
+                }
+                else if (handoff.reason === 'foreign-root') {
+                    // Not a failure and not a hint to re-login anything: the daemon is
+                    // the default root's, and this is a second root (OSK-12189).
+                    this.log(`The local daemon was left as it was — ${handoff.detail}.`);
+                }
+                else if (handoff.reason === 'mint-refused') {
+                    // The server refused before the daemon was touched, so its own
+                    // credential is exactly what it was. Saying "not signed in" here sent
+                    // people to re-login a healthy daemon (OSK-12189).
+                    this.log(`This login was not handed to the local daemon (${handoff.detail}). ` +
+                        `The daemon keeps whatever sign-in it already had — check it with ` +
+                        `\`${this.config.bin} daemon status\`, and run \`${this.config.bin} daemon login\` ` +
+                        `only if that says it is signed out.`);
+                }
                 else if (handoff.status === 'failed') {
                     this.log(`The local daemon was not signed in (${handoff.detail}). ` +
                         `Run \`${this.config.bin} daemon login\` to finish.`);
@@ -377,7 +396,7 @@ class Login extends base_command_1.BaseCommand {
             refreshExpiresAt: result.refreshExpiresAt
                 ? new Date(result.refreshExpiresAt).getTime()
                 : undefined,
-        }, { serverOrigin: this.cliConfig.baseURL, clearReauth: true });
+        }, { serverOrigin: this.cliConfig.baseURL, clearReauth: true, provenance: 'user_login' });
         this.log('');
         this.log(`Signed in as ${result.user.email} via recovery code on ` +
             `${(0, config_1.describeDeployment)(this.cliConfig.baseURL)}.`);

package/dist/commands/logout.js

@@ -257,6 +257,14 @@ class Logout extends base_command_1.BaseCommand {
                 : 'Signed out from all devices.'
             : 'Signed out.';
         this.log(finalMessage);
+        // On a brokered Dedicated guest the sign-in just removed was the person's
+        // OWN (an explicit `skrr login`); the machine's platform-managed access is
+        // untouched and skrr keeps working through it. Say both, so "Signed out."
+        // is not read as "this machine can no longer reach skrr" (OSK-12043).
+        if ((0, daemonBroker_1.findBrokeredHandoffDescriptor)()) {
+            this.log('Removed your own sign-in from this machine. ' +
+                "skrr keeps working here through the platform's managed hand-off.");
+        }
         if (sweptLegacy.length > 0) {
             this.log(`Also removed ${sweptLegacy.length} credential${sweptLegacy.length === 1 ? '' : 's'} left by the previous product identity:`);
             for (const service of sweptLegacy)

package/dist/commands/pair.js

@@ -273,7 +273,7 @@ function persistPairCredentials(plaintext, serverOrigin) {
     (0, auth_storage_1.writeToBackend)({
         token: plaintext.token,
         ...(plaintext.refreshToken ? { refreshToken: plaintext.refreshToken } : {}),
-    }, { serverOrigin, clearReauth: true });
+    }, { serverOrigin, clearReauth: true, provenance: 'user_login' });
     if (plaintext.dataEncryptionKey) {
         // The unified `writeToBackend` API only carries token+refresh
         // today. For now, persist the DEK as a sibling field on the next

package/dist/commands/tasks/move.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("../../lib/api-fetch");
+const http_error_1 = require("../../lib/http-error");
+const workflow_state_hint_1 = require("../../lib/workflow-state-hint");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const base_command_1 = require("../../base-command");
 const task_closure_1 = require("../../lib/task-closure");
@@ -129,6 +131,15 @@ class TasksMove extends base_command_1.BaseCommand {
             }
         }
         catch (err) {
+            const unknownState = (0, workflow_state_hint_1.describeUnknownWorkflowState)((0, http_error_1.httpBodyOf)(err), this.config.bin);
+            if (unknownState) {
+                this.failWithCliError({
+                    message: unknownState,
+                    code: 'WORKFLOW_STATE_UNKNOWN',
+                    exit: 2,
+                    retryable: false,
+                });
+            }
             this.handleApiError(err);
         }
         if (flags.json) {

package/dist/lib/agent-model-check.d.ts

@@ -0,0 +1,19 @@
+interface ModelsReport {
+    provider?: string | null;
+    source?: string;
+    sourceReason?: string;
+    models?: Array<{
+        value?: string;
+    }>;
+}
+/** The harness the saved agent runs on first, as the write response names it. */
+export declare function primaryHarnessId(agent: unknown): string | null;
+export declare function describeUnlistedModel(model: string | undefined, report: ModelsReport | undefined, harnessId: string, bin: string): string | null;
+/** Best effort: a check that cannot run says nothing rather than failing the save. */
+export declare function warnIfModelNotListed(opts: {
+    model: string | undefined;
+    agent: unknown;
+    bin: string;
+    warn: (message: string) => void;
+}): Promise<void>;
+export {};

package/dist/lib/agent-model-check.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primaryHarnessId = primaryHarnessId;
+exports.describeUnlistedModel = describeUnlistedModel;
+exports.warnIfModelNotListed = warnIfModelNotListed;
+const harnesses_1 = require("./harnesses");
+/**
+ * A model id the agent's harness does not list, said at save time (OSK-12205).
+ *
+ * `agents create/update --model <id>` stored any well-formed id without a
+ * word; the first anyone heard of a typo was a failed turn, whose remedy then
+ * sent a local agent to "publish the agent". The server only validates the
+ * id's SHAPE on write — asking the daemon for its live list on every PATCH
+ * would put a machine round-trip on the write path — so the check lives here,
+ * after the write, and never fails the command.
+ *
+ * Only a list that speaks for the harness can say "not there": `live` (the
+ * installed harness enumerated it) or `managed` (the admission policy). A
+ * `curated` list is our suggestion, so a miss against it is reported as
+ * unverified, with the reason the live list was unavailable.
+ */
+/** Not model names: "no selection", which runs the harness default. */
+const SENTINELS = new Set(['', 'default', 'auto']);
+/** The harness the saved agent runs on first, as the write response names it. */
+function primaryHarnessId(agent) {
+    const record = (agent ?? {});
+    if (typeof record.harnessId === 'string' && record.harnessId)
+        return record.harnessId;
+    const policy = record.executionPolicy;
+    const target = (policy?.targets ?? []).find((t) => t?.kind === 'harness' && t.enabled !== false && typeof t.harnessId === 'string');
+    return target?.harnessId ?? null;
+}
+function describeUnlistedModel(model, report, harnessId, bin) {
+    const id = typeof model === 'string' ? model.trim() : '';
+    if (SENTINELS.has(id.toLowerCase()))
+        return null;
+    const listed = (report?.models ?? []).some((entry) => entry?.value === id);
+    if (listed)
+        return null;
+    const provider = report?.provider || 'this';
+    const remedy = `\`${bin} harnesses models ${harnessId}\` lists what it can run.`;
+    if (report?.source === 'live' || report?.source === 'managed') {
+        return (`Model '${id}' is not in the ${provider} harness's ${report.source} model list ` +
+            `(${harnessId}). It was saved, but a turn fails when the harness refuses it. ${remedy}`);
+    }
+    const why = report?.sourceReason ? ` (${report.sourceReason})` : '';
+    return (`Model '${id}' is not in the suggested list for the ${provider} harness, and the ` +
+        `harness's live list was unavailable${why}, so it could not be checked. It was saved. ` +
+        remedy);
+}
+/** Best effort: a check that cannot run says nothing rather than failing the save. */
+async function warnIfModelNotListed(opts) {
+    const id = typeof opts.model === 'string' ? opts.model.trim() : '';
+    if (SENTINELS.has(id.toLowerCase()))
+        return;
+    const harnessId = primaryHarnessId(opts.agent);
+    if (!harnessId)
+        return;
+    try {
+        const report = (await (0, harnesses_1.getHarnessModels)(harnessId));
+        const message = describeUnlistedModel(id, report, harnessId, opts.bin);
+        if (message)
+            opts.warn(message);
+    }
+    catch {
+        /* the save stands; the harness list is a hint */
+    }
+}

package/dist/lib/agentic-stream.d.ts

@@ -365,6 +365,18 @@ export declare class AgenticStreamClient {
     private readonly toolNamesByCall;
     /** `permission-ask` requestId → tool name, to name its resolution (OSK-12113). */
     private readonly toolNamesByPermission;
+    /**
+     * Permission prompts on the terminal still waiting for an answer, by
+     * toolUseId, so a server `permission:cancel` can close the one it names
+     * (OSK-12197) instead of leaving `[y/N]` open after the run stopped asking.
+     */
+    private readonly openPermissionPrompts;
+    /**
+     * Question prompts on the terminal still waiting for an answer, by
+     * questionId, so a server `question:cancel` can close the one it names
+     * (OSK-12208) the same way `permission:cancel` closes a permission prompt.
+     */
+    private readonly openQuestionPrompts;
     /** Text already written to the terminal, for suffix-only rendering. */
     private renderedText;
     private idleTimer;
@@ -443,6 +455,18 @@ export declare class AgenticStreamClient {
     private installHandlers;
     private handlePermission;
     private handleQuestion;
+    /**
+     * The server closed a permission request (OSK-12197): it expired unanswered,
+     * the pre-execution step gave up, or another surface answered it. Say so,
+     * and close the terminal prompt if this client is still showing it.
+     */
+    private handlePermissionCancel;
+    /**
+     * The server closed a question (OSK-12208): nobody answered it in time, or
+     * the turn ended first. Say so, and close the terminal prompt if this
+     * client is still showing it — the question twin of handlePermissionCancel.
+     */
+    private handleQuestionCancel;
     private ask;
     /**
      * True the first time this (kind, identity) pair is seen; false afterwards.