@skrr-ai/cli 0.1.8 → 0.1.10

package/dist/lib/sky-code-broker.js

@@ -239,7 +239,7 @@ async function acquireManagedSession(input = {}, deps = {}) {
         if (agent.createdNow) {
             input.log?.(`Created "${agent.name ?? agent.id}" as your default skrr Code agent — ` +
                 'this session, and future ones, are attributed to it. ' +
-                'Change it with `skrr code oversky-agent --set <id-or-name>`.');
+                'Change it with `skrr code skrr-agent --set <id-or-name>`.');
         }
         const minted = await mintSessionToken({ sessionId, processStartId, agentId: agent.id, actorId: newId() }, api, acquisition.signal);
         sessionToken = minted.token;
@@ -888,11 +888,27 @@ function describe(err) {
  *
  * The predicate is `hasProviderCredential`, the same one that decides what the
  * engine actually inherits (`sky-code.ts`), so the sentence and the spawn cannot
- * disagree.
+ * disagree. `strippedProviderCredentialNames` covers the third case that
+ * predicate cannot see: the machine HAS a provider credential and this run
+ * removes it, which reads as absence and is not.
  */
 function fallbackTail(env) {
     if ((0, sky_code_1.hasProviderCredential)(env))
         return 'Continuing with your own provider credentials.';
+    // Absence and removal are different problems, and the old sentence said the
+    // first when the second was true: on a machine whose only credential is an AWS
+    // profile the engine runs fine on its own and fails through `skrr code`,
+    // because `AWS_*` is stripped on the way in. Being told "no provider
+    // credential is set here" sends that user to buy a key they do not need.
+    const stripped = (0, sky_code_1.strippedProviderCredentialNames)(env);
+    if (stripped.length > 0) {
+        return (`${stripped.join(', ')} is set here, but this run does not pass it to the engine — ` +
+            'it is stripped so a model-driven process opening other people\u2019s repositories cannot ' +
+            'reuse a cloud credential. So the engine starts without one and its first request will ' +
+            'fail. Export a provider key the engine may inherit (any `*_API_KEY`, e.g. ' +
+            'OPENROUTER_API_KEY), resolve the reason above, or run the engine directly if you ' +
+            'intend to spend that credential (`skrr code doctor` shows where it is).');
+    }
     return ('No provider credential is set here either, so the engine will start without one and ' +
         'its first request will fail — set OPENROUTER_API_KEY, or resolve the reason above ' +
         '(`skrr code doctor`).');

package/dist/lib/sky-code-doctor.js

@@ -32,6 +32,7 @@ exports.formatReport = formatReport;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const sky_code_1 = require("./sky-code");
+const auth_core_1 = require("@skrr-ai/auth-core");
 const harness_tiers_1 = require("./harness-tiers");
 const config_1 = require("./config");
 const sky_code_managed_1 = require("./sky-code-managed");
@@ -39,10 +40,124 @@ const sky_code_managed_1 = require("./sky-code-managed");
 function projectStateDir(cwd) {
     return node_path_1.default.join(node_path_1.default.resolve(cwd), '.sky-code');
 }
+/**
+ * Which release channel this machine follows, and where its manifest lives.
+ *
+ * `notInstalledMessage()` has always ended by promising that this command names
+ * "which channel this machine follows and whether that channel has a published
+ * release", and nothing here knew what a channel was — the whole vocabulary sat
+ * in `daemon/src/sky-code/channels.ts`, whose only importer was the daemon's own
+ * installer. So the user with no engine, who is exactly the audience for that
+ * sentence, was sent to a command that could not answer (dogfood OSK-274).
+ *
+ * It reports the channel and the exact URL, and does NOT fetch it. The doctor is
+ * documented as safe to run in any context and reads only env, config and one
+ * `existsSync`; adding a network call to satisfy a sentence would trade a broken
+ * promise for a diagnostic that hangs on a captive portal. Printing the URL puts
+ * the answer one copy-paste away and keeps the property — and the promise is
+ * reworded to match what is delivered rather than the other way round.
+ *
+ * `warn` on an unrecognised channel, because `resolveSkyCodeChannel` falls back
+ * to the default rather than throwing: a typo must not brick updates, and a
+ * silent fallback must not look like agreement.
+ */
+function releaseChannelCheck(env) {
+    const { channel, invalid } = (0, auth_core_1.resolveSkyCodeChannel)(env);
+    const url = (0, auth_core_1.resolveChannelManifestUrl)({
+        base: (0, auth_core_1.skyCodeFeedBase)(env),
+        manifestFilename: auth_core_1.SKY_CODE_MANIFEST_FILE,
+        channel,
+    });
+    if (invalid) {
+        return {
+            name: 'release-channel',
+            status: 'warn',
+            detail: `${auth_core_1.SKY_CODE_CHANNEL_ENV}='${invalid}' is not a channel; following '${channel}' instead — ${url}`,
+            remedy: `Set ${auth_core_1.SKY_CODE_CHANNEL_ENV} to one of internal, canary, beta, stable, or unset it to follow the default.`,
+        };
+    }
+    return {
+        name: 'release-channel',
+        status: 'ok',
+        detail: `${channel} — ${url}`,
+        remedy: `Fetch that URL to see whether the channel has a published release, and which version.`,
+    };
+}
+/**
+ * What the pre-rename engine directory still holds, for a machine that has moved on.
+ *
+ * Round 1 gave both readers a fallback to `~/.oversky/sky-code/bin` so nothing
+ * BREAKS on a machine that installed before the rename. Nothing was given the job
+ * of finishing the move: no installer sweep, and — once the current root wins —
+ * no mention anywhere. This machine converged on two engine directories and
+ * reported one, the older holding 713 MB across six binaries (dogfood OSK-278).
+ *
+ * Flat, never recursive, and failures are swallowed: this is a footnote on a
+ * diagnostic, and a doctor that throws while counting bytes it was only going to
+ * mention has made things worse than the clutter it was reporting.
+ */
+function strandedLegacyEngine(env) {
+    const exeName = process.platform === 'win32' ? 'sky-code.exe' : 'sky-code';
+    const legacy = (0, sky_code_1.legacyManagedEnginePath)(exeName, env);
+    if (!legacy)
+        return null;
+    const dir = node_path_1.default.dirname(legacy);
+    try {
+        const entries = (0, node_fs_1.readdirSync)(dir);
+        let bytes = 0;
+        let files = 0;
+        for (const entry of entries) {
+            const stats = (0, node_fs_1.statSync)(node_path_1.default.join(dir, entry));
+            if (!stats.isFile())
+                continue;
+            files += 1;
+            bytes += stats.size;
+        }
+        return files > 0 ? { dir, files, bytes } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Bytes as the size a human would say out loud. */
+function humanBytes(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return mb >= 1024 ? `${(mb / 1024).toFixed(1)} GB` : `${Math.round(mb)} MB`;
+}
 function engineCheck(env) {
     const { path: bin, source } = (0, sky_code_1.resolveEngine)(env);
+    if (bin && source === 'legacy-managed') {
+        // `ok`, because it runs and this is the resolution the daemon has always
+        // made. The remedy is here because the resolution is SURPRISING: the path
+        // says `.oversky` on a CLI that says `skrr` everywhere else, and the next
+        // daemon-driven install will write to `~/.skrr` and leave two copies of a
+        // hundred-megabyte binary on disk with no hint which one is live.
+        return {
+            name: 'engine',
+            status: 'ok',
+            detail: `${bin} (resolved via ${source} — the pre-rename location)`,
+            remedy: 'It works, and nothing has to change today. Installing the engine again ' +
+                `through the daemon writes it to ${(0, sky_code_1.managedEnginePath)('sky-code', env)}; ` +
+                'the copy above can be deleted once it does.',
+        };
+    }
     if (bin) {
-        return { name: 'engine', status: 'ok', detail: `${bin} (resolved via ${source})` };
+        // The engine resolved from the current root — and the pre-rename directory
+        // may still be sitting there. Said here rather than in its own check because
+        // it is a footnote on a healthy answer, not a finding of its own.
+        const stranded = strandedLegacyEngine(env);
+        return {
+            name: 'engine',
+            status: 'ok',
+            detail: `${bin} (resolved via ${source})`,
+            ...(stranded
+                ? {
+                    remedy: `${stranded.dir} still holds ${stranded.files} file(s), ${humanBytes(stranded.bytes)}, ` +
+                        'from before the config root moved. Nothing reads it now that the engine above ' +
+                        'resolves, and nothing removes it either — delete it when you want the space back.',
+                }
+                : {}),
+        };
     }
     const override = env[sky_code_1.ENGINE_PATH_ENV];
     if (override && !node_path_1.default.isAbsolute(override)) {
@@ -461,7 +576,7 @@ function sessionAuthorityCheck(env) {
                 remedy: 'Intended for local use, and nothing to fix. Worth knowing because it is NOT the same ' +
                     'trust plane as a daemon-dispatched run — and neither plane is an OS-level sandbox ' +
                     '(no seccomp, container, or namespace). An untrusted autonomous workload needs a hosted ' +
-                    'or container profile; see the fork’s docs/sky-code/threat-model.md.',
+                    'or container profile; see sky-code/docs/sky-code/threat-model.md.',
             };
     }
 }
@@ -473,7 +588,7 @@ function sessionAuthorityCheck(env) {
  * a `/api/agents` read, and this module's whole contract is that it answers from
  * env, one config read and one `existsSync` — that is what lets `skrr code doctor`
  * run before the auth plane is configured, and on a machine with no network.
- * `skrr code oversky-agent` is the command that resolves for real.
+ * `skrr code skrr-agent` is the command that resolves for real.
  *
  * Never a `warn`. An unset value is the normal, supported state now that
  * resolution ends in a default agent rather than a refusal; flagging it would
@@ -507,12 +622,13 @@ function agentAttributionCheck() {
         name: 'agent',
         status: 'ok',
         detail: `no ${sky_code_managed_1.AGENT_CONFIG_KEY} set — sessions use your sole owned agent, else your default ${sky_code_managed_1.SKY_CODE_HARNESS} agent`,
-        remedy: 'Run `skrr code oversky-agent` to see which, or `skrr code oversky-agent --set <id>` to pin one.',
+        remedy: 'Run `skrr code skrr-agent` to see which, or `skrr code skrr-agent --set <id>` to pin one.',
     };
 }
 function runDoctor(cwd = process.cwd(), env = process.env) {
     const checks = [
         engineCheck(env),
+        releaseChannelCheck(env),
         stateDirCheck(cwd, env),
         compatCheck(cwd, env),
         opencodeCheck(cwd),

package/dist/lib/sky-code-managed.d.ts

@@ -46,7 +46,19 @@ export declare const MANAGED_ENV_FLAG = "OVERSKY_SKY_CODE_MANAGED";
  * `skrr code --agent reviewer` is the engine's flag and is pinned as such by
  * `sky-code-passthrough.spec.ts`. A bare `--agent` here would steal it.
  */
+export declare const SKRR_AGENT_FLAG = "--skrr-agent";
+/**
+ * The pre-rename spelling, still accepted.
+ *
+ * It is in muscle memory and in scripts, and `skrr code` forwards argv verbatim
+ * — so a flag this CLI stops recognising is not an error, it is silently handed
+ * to the engine, which rejects it with a message about a flag the user did not
+ * think they were passing. Accepting both is the only version of this rename
+ * that fails safely.
+ */
 export declare const OVERSKY_AGENT_FLAG = "--oversky-agent";
+/** Every spelling the argv scanner honours, primary first. */
+export declare const AGENT_FLAG_SPELLINGS: readonly ["--skrr-agent", "--oversky-agent"];
 /** The config key `skrr code` reads when the flag is absent. */
 export declare const AGENT_CONFIG_KEY = "skyCodeAgentId";
 /**

package/dist/lib/sky-code-managed.js

@@ -32,7 +32,7 @@
  * reason: the user is about to spend their own key and must know it.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BROKER_SOCKET_ENV = exports.MANAGED_SESSION_ENV = exports.SKY_CODE_HARNESS = exports.AGENT_CONFIG_KEY = exports.OVERSKY_AGENT_FLAG = exports.MANAGED_ENV_FLAG = void 0;
+exports.BROKER_SOCKET_ENV = exports.MANAGED_SESSION_ENV = exports.SKY_CODE_HARNESS = exports.AGENT_CONFIG_KEY = exports.AGENT_FLAG_SPELLINGS = exports.OVERSKY_AGENT_FLAG = exports.SKRR_AGENT_FLAG = exports.MANAGED_ENV_FLAG = void 0;
 exports.resolveTrustPlane = resolveTrustPlane;
 exports.skyCodeServerUrl = skyCodeServerUrl;
 exports.managedSkipReason = managedSkipReason;
@@ -59,7 +59,19 @@ exports.MANAGED_ENV_FLAG = 'OVERSKY_SKY_CODE_MANAGED';
  * `skrr code --agent reviewer` is the engine's flag and is pinned as such by
  * `sky-code-passthrough.spec.ts`. A bare `--agent` here would steal it.
  */
+exports.SKRR_AGENT_FLAG = '--skrr-agent';
+/**
+ * The pre-rename spelling, still accepted.
+ *
+ * It is in muscle memory and in scripts, and `skrr code` forwards argv verbatim
+ * — so a flag this CLI stops recognising is not an error, it is silently handed
+ * to the engine, which rejects it with a message about a flag the user did not
+ * think they were passing. Accepting both is the only version of this rename
+ * that fails safely.
+ */
 exports.OVERSKY_AGENT_FLAG = '--oversky-agent';
+/** Every spelling the argv scanner honours, primary first. */
+exports.AGENT_FLAG_SPELLINGS = [exports.SKRR_AGENT_FLAG, exports.OVERSKY_AGENT_FLAG];
 /** The config key `skrr code` reads when the flag is absent. */
 exports.AGENT_CONFIG_KEY = 'skyCodeAgentId';
 /**
@@ -238,19 +250,21 @@ function takeOverskyAgentFlag(passthrough) {
     let agentRef;
     for (let i = 0; i < passthrough.length; i += 1) {
         const token = passthrough[i];
-        if (token === exports.OVERSKY_AGENT_FLAG) {
-            // Last one wins, matching how every argv parser treats a repeated flag.
+        if (exports.AGENT_FLAG_SPELLINGS.includes(token)) {
+            // Last one wins, matching how every argv parser treats a repeated flag —
+            // and across spellings too, so `--oversky-agent a --skrr-agent b` is `b`.
             const value = passthrough[i + 1];
-            // A trailing `--oversky-agent` with no value must not swallow the next
-            // token (there is none) nor leave the flag in the argv.
+            // A trailing flag with no value must not swallow the next token (there is
+            // none) nor leave the flag in the argv.
             if (value !== undefined && !value.startsWith('-')) {
                 agentRef = value;
                 i += 1;
             }
             continue;
         }
-        if (token.startsWith(`${exports.OVERSKY_AGENT_FLAG}=`)) {
-            agentRef = token.slice(exports.OVERSKY_AGENT_FLAG.length + 1);
+        const inline = exports.AGENT_FLAG_SPELLINGS.find((f) => token.startsWith(`${f}=`));
+        if (inline) {
+            agentRef = token.slice(inline.length + 1);
             continue;
         }
         engineArgv.push(token);

package/dist/lib/sky-code.d.ts

@@ -31,9 +31,23 @@ export declare function skyCodeInstructionHome(env?: NodeJS.ProcessEnv): string;
  * `scripts/sky-code/build.mjs --install` all put the engine.
  */
 export declare function managedEnginePath(exeName: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * The same managed location under the PREVIOUS config root.
+ *
+ * The root moved `~/.oversky` → `~/.skrr` in the skrr rename, and an engine
+ * installed before that is still on disk under the old one. `daemon/src/
+ * binary-resolver.ts` was given this fallback and this module was not, so on
+ * the same machine the daemon found the engine and `skrr code` reported that no
+ * engine was installed — the same product, the same 106 MB binary, two answers.
+ *
+ * Returns null when an explicit `OVERSKY_CONFIG_DIR` is set, matching the
+ * daemon: that override names one root deliberately, and reaching past it to a
+ * hard-coded home would defeat the pinning {@link engineHome} relies on.
+ */
+export declare function legacyManagedEnginePath(exeName: string, env?: NodeJS.ProcessEnv): string | null;
 export interface EngineResolution {
     path: string | null;
-    source: 'env' | 'path' | 'managed' | 'fallback' | 'unresolved';
+    source: 'env' | 'path' | 'managed' | 'legacy-managed' | 'fallback' | 'unresolved';
 }
 /**
  * Resolve the engine binary, reporting WHERE it came from.
@@ -185,6 +199,7 @@ export interface EngineSpawnOptions {
 export declare function inheritedProviderCredentials(env: NodeJS.ProcessEnv): Record<string, string>;
 /** Whether an unmanaged run has anything to authenticate with. */
 export declare function hasProviderCredential(env?: NodeJS.ProcessEnv): boolean;
+export declare function strippedProviderCredentialNames(env?: NodeJS.ProcessEnv): string[];
 /**
  * The environment the engine actually receives.
  *

package/dist/lib/sky-code.js

@@ -21,11 +21,13 @@ exports.ENGINE_PATH_ENV = void 0;
 exports.engineHome = engineHome;
 exports.skyCodeInstructionHome = skyCodeInstructionHome;
 exports.managedEnginePath = managedEnginePath;
+exports.legacyManagedEnginePath = legacyManagedEnginePath;
 exports.resolveEngine = resolveEngine;
 exports.buildEngineArgs = buildEngineArgs;
 exports.notInstalledMessage = notInstalledMessage;
 exports.inheritedProviderCredentials = inheritedProviderCredentials;
 exports.hasProviderCredential = hasProviderCredential;
+exports.strippedProviderCredentialNames = strippedProviderCredentialNames;
 exports.engineSpawnEnv = engineSpawnEnv;
 exports.execEngine = execEngine;
 const node_child_process_1 = require("node:child_process");
@@ -33,6 +35,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const auth_core_1 = require("@skrr-ai/auth-core");
+const config_1 = require("./config");
 // Deliberately does NOT import the managed marker any more. This module used to
 // read it to decide whether a run was managed; that decision now arrives as a
 // declared `credentialMode`, and re-introducing the import here would be the first
@@ -49,14 +52,18 @@ exports.ENGINE_PATH_ENV = 'OVERSKY_SKY_CODE_PATH';
  * ordering below exists to prevent.
  */
 function engineHome(env = process.env) {
-    const root = env.OVERSKY_CONFIG_DIR?.trim();
-    return node_path_1.default.join(root || node_path_1.default.join((0, node_os_1.homedir)(), '.skrr'), 'sky-code');
+    // `configRoot` and not a second reading of the environment: deriving the root
+    // twice is what let this function and `getConfigPath()` disagree (OSK-300).
+    return node_path_1.default.join((0, config_1.configRoot)(env), 'sky-code');
 }
 /** The user-level instruction root owned by skrr Code. */
 function skyCodeInstructionHome(env = process.env) {
     const configured = env.SKY_CODE_HOME?.trim();
+    // Falls through to `engineHome()` rather than re-deriving `~/.skrr` — the two
+    // describe the same root, and re-deriving it is what made them disagree under
+    // `OVERSKY_CONFIG_DIR` (OSK-300).
     if (!configured)
-        return node_path_1.default.join((0, node_os_1.homedir)(), '.skrr', 'sky-code');
+        return engineHome(env);
     if (configured === '~')
         return (0, node_os_1.homedir)();
     if (configured.startsWith('~/'))
@@ -70,6 +77,24 @@ function skyCodeInstructionHome(env = process.env) {
 function managedEnginePath(exeName, env = process.env) {
     return node_path_1.default.join(engineHome(env), 'bin', exeName);
 }
+/**
+ * The same managed location under the PREVIOUS config root.
+ *
+ * The root moved `~/.oversky` → `~/.skrr` in the skrr rename, and an engine
+ * installed before that is still on disk under the old one. `daemon/src/
+ * binary-resolver.ts` was given this fallback and this module was not, so on
+ * the same machine the daemon found the engine and `skrr code` reported that no
+ * engine was installed — the same product, the same 106 MB binary, two answers.
+ *
+ * Returns null when an explicit `OVERSKY_CONFIG_DIR` is set, matching the
+ * daemon: that override names one root deliberately, and reaching past it to a
+ * hard-coded home would defeat the pinning {@link engineHome} relies on.
+ */
+function legacyManagedEnginePath(exeName, env = process.env) {
+    if (env.OVERSKY_CONFIG_DIR?.trim())
+        return null;
+    return node_path_1.default.join((0, node_os_1.homedir)(), '.oversky', 'sky-code', 'bin', exeName);
+}
 /**
  * Unmanaged well-known locations, checked after PATH.
  *
@@ -139,6 +164,15 @@ function resolveEngine(env = process.env) {
     const managed = managedEnginePath(exeName, env);
     if (isExecutable(managed))
         return { path: managed, source: 'managed' };
+    // The pre-rename managed location, SECOND. After the current one, so a fresh
+    // install always wins; before PATH, for the same WL-6.2 reason the current one
+    // beats PATH — a binary skrr installed outranks whatever happens to sit on the
+    // user's PATH, and which config root it was installed under does not change
+    // that. Reported as its own `source` so `skrr code doctor` can say where it
+    // came from rather than quietly resolving something surprising.
+    const legacy = legacyManagedEnginePath(exeName, env);
+    if (legacy && isExecutable(legacy))
+        return { path: legacy, source: 'legacy-managed' };
     const PATH = env.PATH ?? '';
     const sep = process.platform === 'win32' ? ';' : ':';
     const exeNames = process.platform === 'win32' ? ['sky-code.exe', 'sky-code.cmd'] : ['sky-code'];
@@ -198,15 +232,17 @@ function notInstalledMessage() {
         'The skrr Code engine (`sky-code`) is not installed on this machine.',
         '',
         'Install it through the daemon, which verifies the signed release:',
-        '  • In the web app: the runtime menu beside the chat input → skrr Code → Install',
-        '  • Make sure a daemon is running here first: `oversky status`',
+        '  • `skrr code install`  — from here, no browser needed',
+        '  • Or in the web app: the runtime menu beside the chat input → skrr Code → Install',
+        '  • Either way a daemon must be running here: `skrr daemon status`',
         '',
         `Or point the CLI at an existing build:  export ${exports.ENGINE_PATH_ENV}=/absolute/path/to/sky-code`,
         '  (an unsigned build runs, and since 2026-08-11 at the same trust tier as a',
         '   signed one — see `skrr code doctor` under trust-tier)',
         '',
-        'Run `skrr code doctor` for a full diagnosis, including which channel this',
-        'machine follows and whether that channel has a published release.',
+        'Run `skrr code doctor` for a full diagnosis. Its `release-channel` line',
+        'names the channel this machine follows and the exact manifest URL to check',
+        'for a published release.',
     ].join('\n');
 }
 /**
@@ -220,6 +256,37 @@ function notInstalledMessage() {
  */
 const BYOK_CREDENTIAL_SUFFIXES = ['_API_KEY', '_AUTH_TOKEN'];
 const BYOK_CREDENTIAL_NAMES = new Set(['HUGGINGFACE_HUB_TOKEN']);
+/**
+ * `AWS_*` names that are not credentials, and that Bedrock cannot run without.
+ *
+ * The `AWS_` prefix rule below exists for STS/IAM material — `AWS_ACCESS_KEY_ID`,
+ * `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_BEARER_TOKEN_BEDROCK` — and
+ * every one of those stays stripped. These three carry no secret: two are a
+ * region and one is the NAME of a profile whose credentials live in the AWS
+ * shared config, a file the engine can read anyway. Stripping them therefore
+ * protected nothing and cost an entire provider.
+ *
+ * Dogfooded as OSK-262, where `sky-code run "say hi"` answered on a Bedrock
+ * model and the identical run through `skrr code` died in the engine's generic
+ * error handler — because `AWS_PROFILE` did not survive the sanitizer.
+ * `env -u AWS_PROFILE` on the bare engine reproduced the failure exactly.
+ *
+ * An enumerated carve-out rather than a narrower prefix, so every future
+ * addition is a reviewable line that has to argue "this one is not a secret".
+ * The failure mode of the alternative is an exemption list that grows until the
+ * prefix rule means nothing.
+ *
+ * BYOK ONLY, and that is why it lives here rather than in `sanitizeSpawnEnv`.
+ * {@link engineSpawnEnv} re-admits nothing on a managed run, so a session
+ * spending a budgeted relay credential still cannot reach Bedrock directly and
+ * bill around its own budget. Putting the exemption in the shared sanitizer
+ * would hand it to the daemon's managed ACP path too, and lose that.
+ */
+const BYOK_AWS_NON_SECRETS = new Set([
+    'AWS_PROFILE',
+    'AWS_REGION',
+    'AWS_DEFAULT_REGION',
+]);
 /**
  * …and these are never inherited, whatever they look like.
  *
@@ -256,6 +323,11 @@ function inheritedProviderCredentials(env) {
             continue;
         if (ENGINE_NEVER_INHERITS.has(key))
             continue;
+        // Before the prefix rule, which would otherwise take these with the family.
+        if (BYOK_AWS_NON_SECRETS.has(key)) {
+            out[key] = value;
+            continue;
+        }
         if (ENGINE_NEVER_INHERITS_PREFIXES.some((prefix) => key.startsWith(prefix)))
             continue;
         if (BYOK_CREDENTIAL_NAMES.has(key) || BYOK_CREDENTIAL_SUFFIXES.some((s) => key.endsWith(s))) {
@@ -268,6 +340,37 @@ function inheritedProviderCredentials(env) {
 function hasProviderCredential(env = process.env) {
     return Object.keys(inheritedProviderCredentials(env)).length > 0;
 }
+/**
+ * Provider-capable credentials this environment HAS and the engine will not get.
+ *
+ * `hasProviderCredential` answers "will the engine have a key", which is the
+ * right question for what to spawn and the wrong one for what to SAY. On a
+ * machine whose only credential is an AWS profile the two answers differ: the
+ * engine defaults to a Bedrock model and runs fine when launched directly, and
+ * `skrr code` — which strips `AWS_*` — reported "no provider credential is set
+ * here", sent the user to buy an OpenRouter key, and then died in the engine's
+ * generic error handler. The user had a working credential; this run removed it.
+ *
+ * "You have none" and "you have one and this run does not pass it on" are
+ * different problems with different fixes, so they must not share a sentence.
+ *
+ * Only the deny-listed names a PROVIDER could actually authenticate with are
+ * reported. `GH_TOKEN` and `NPM_TOKEN` are stripped too and are not model
+ * credentials, so naming them here would turn a precise sentence into noise.
+ */
+const STRIPPED_PROVIDER_CREDENTIALS = [
+    // Bedrock's SECRET material only. `AWS_PROFILE` and the region variables are
+    // exempt ({@link BYOK_AWS_NON_SECRETS}) and now reach the engine, so naming
+    // them here would make this sentence contradict the spawn — which is the exact
+    // defect this reporter was added to end.
+    'AWS_ACCESS_KEY_ID',
+    'AWS_BEARER_TOKEN_BEDROCK',
+    // Anthropic OAuth, deny-listed by name in ENGINE_NEVER_INHERITS.
+    'CLAUDE_CODE_OAUTH_TOKEN',
+];
+function strippedProviderCredentialNames(env = process.env) {
+    return STRIPPED_PROVIDER_CREDENTIALS.filter((name) => (env[name] ?? '').trim() !== '');
+}
 /**
  * The environment the engine actually receives.
  *

package/dist/lib/task-execution.js

@@ -27,6 +27,7 @@ exports.sleep = sleep;
 exports.compactSnapshotSignature = compactSnapshotSignature;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const tasks_1 = require("./tasks");
+const html_text_1 = require("./html-text");
 /**
  * Statuses at which an execution is OVER — nothing further will move the task
  * without new input.
@@ -304,17 +305,9 @@ function compactSnapshotSignature(snapshot) {
         .sort()
         .join('|');
 }
-function stripHtml(value) {
-    return value
-        .replace(/<br\s*\/?>/gi, '\n')
-        .replace(/<\/p>/gi, '\n')
-        .replace(/<[^>]+>/g, ' ')
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&#39;/g, "'")
-        .replace(/&quot;/g, '"')
-        .replace(/&amp;/g, '&')
-        .replace(/[ \t]+/g, ' ');
-}
+// Was a private copy here; it is the same job `tasks show` needs, and two
+// slightly different HTML strippers is how the two surfaces drift.
+const stripHtml = html_text_1.htmlToDisplayText;
 function stringValue(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }

package/dist/lib/tasks.d.ts

@@ -1,3 +1,4 @@
+export declare const TASK_PRIORITIES: readonly ["low", "medium", "high", "critical"];
 /**
  * The kinds `tasks events append --kind` will accept.
  *

package/dist/lib/tasks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TASK_WORK_EVENT_KINDS = void 0;
+exports.TASK_WORK_EVENT_KINDS = exports.TASK_PRIORITIES = void 0;
 exports.releasePinRepairGuard = releasePinRepairGuard;
 exports.taskUpdateMutationGuard = taskUpdateMutationGuard;
 exports.executionIsolationFromWorktreeFlag = executionIsolationFromWorktreeFlag;
@@ -30,7 +30,7 @@ exports.normalizeBulkUpdateInput = normalizeBulkUpdateInput;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const prompt_1 = require("./prompt");
 const projects_1 = require("./projects");
-const TASK_PRIORITIES = ['low', 'medium', 'high', 'critical'];
+exports.TASK_PRIORITIES = ['low', 'medium', 'high', 'critical'];
 const DESCRIPTION_FORMATS = ['html', 'markdown', 'plain'];
 /**
  * The kinds `tasks events append --kind` will accept.
@@ -201,8 +201,8 @@ function validateTaskCreatePayload(payload) {
         errors.push(`descriptionFormat must be one of: ${DESCRIPTION_FORMATS.join(', ')}`);
     }
     if (payload.priority !== undefined &&
-        !TASK_PRIORITIES.includes(payload.priority)) {
-        errors.push(`priority must be one of: ${TASK_PRIORITIES.join(', ')}`);
+        !exports.TASK_PRIORITIES.includes(payload.priority)) {
+        errors.push(`priority must be one of: ${exports.TASK_PRIORITIES.join(', ')}`);
     }
     if (payload.externalKey !== undefined && !isBoundedString(payload.externalKey, 1, 300)) {
         errors.push('externalKey must be a non-empty string at most 300 characters');
@@ -566,9 +566,12 @@ function taskRef(task) {
     return '';
 }
 function formatTaskLabel(task) {
-    const id = taskId(task) || '?';
+    // Ref first, id as the fallback — matching every other entity's confirmation
+    // (see `lib/created-line.ts`). Printing both put a uuid in front of the ref a
+    // person would actually type, and the `View it at` line already carries the id.
     const ref = taskRef(task);
-    return `${id}${ref ? ` (${ref})` : ''} — ${String(task.title ?? '(no title)')}`;
+    const label = ref || taskId(task) || '?';
+    return `${label} — ${String(task.title ?? '(no title)')}`;
 }
 function hasTaskAssignee(task) {
     return (stringArray(task?.assigneeAgentIds).length > 0 || stringArray(task?.assigneeUserIds).length > 0);

package/dist/lib/update-check.js

@@ -138,7 +138,7 @@ function buildNudgeLine(currentVersion, latest, npmPackage) {
     if (!latest || !isOlderVersion(currentVersion, latest))
         return null;
     const pkg = npmPackage || '@skrr-ai/cli';
-    return (`[sky] Update available: ${currentVersion} → ${latest}. ` +
+    return (`[skrr] Update available: ${currentVersion} → ${latest}. ` +
         `Run \`npm update -g ${pkg}\` (or update the skrr app). ` +
         `Silence with OVERSKY_NO_UPDATE_NUDGE=1.\n`);
 }

package/dist/lib/usage-discovery.js

@@ -95,7 +95,7 @@ function buildUsageReference(manifest, domainInput, options = {}) {
 }
 function renderUsageOverview(overview) {
     const lines = [
-        `Sky command domains (${overview.domains.length}; manifest-derived).`,
+        `skrr command domains (${overview.domains.length}; manifest-derived).`,
         'Read one domain at a time: skrr usage <domain>.',
         ...overview.domains.map(({ domain }) => domain),
     ];

package/dist/lib/web-url.js

@@ -40,6 +40,7 @@ exports.withNorthstarUrl = withNorthstarUrl;
 exports.withAgentUrl = withAgentUrl;
 exports.withDataUrls = withDataUrls;
 exports.workflowUrlFrom = workflowUrlFrom;
+const publicEndpoints_generated_1 = require("./publicEndpoints.generated");
 /**
  * Site-relative canonical path for an entity, or `null` when the required id is
  * missing. When a task/goal knows its hosting space we emit the canonical
@@ -141,8 +142,18 @@ function webUrl(baseURL, ref) {
  * custom) passes through unchanged — only the known skrr api hosts are mapped.
  */
 const WEB_ORIGIN_FROM_API = {
+    // DERIVED from the one domain contract, not hand-listed. The hand-listed
+    // version knew only the pre-rename hosts, so `api.skrr.ai` — the CURRENT prod
+    // API origin — mapped to nothing and fell through unchanged, and every link
+    // the CLI printed from that baseURL would point at the API host instead of
+    // the SPA. Deriving it means the next environment cannot be silently omitted.
+    ...Object.fromEntries(Object.values(publicEndpoints_generated_1.OVERSKY_ENVIRONMENT_ENDPOINTS).map((e) => [
+        e.realtimeUrl.toLowerCase(),
+        e.appUrl,
+    ])),
+    // Prod's retained previous origin. `oversky.ai` still resolves and is
+    // deliberately kept (LEGACY_PROD_BASE_URL), so its api. host must map too.
     'https://api.oversky.ai': 'https://oversky.ai',
-    'https://api.oversky.dev': 'https://oversky.dev',
 };
 function toWebOrigin(baseURL) {
     const trimmed = trimTrailingSlash(baseURL);

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/credentialResolver.d.ts

@@ -215,7 +215,7 @@ export declare class AuthHelperUnavailableError extends Error {
 /**
  * L6.1 — typed error thrown when the workspace-trust gate blocks a
  * project- or local-scope helper. Surfaces the actionable next step
- * (`oversky trust accept`) to the user; the daemon catches and presents
+ * (`skrrd trust accept`) to the user; the daemon catches and presents
  * this without falling through to OAuth.
  */
 export declare class AuthHelperUntrustedError extends Error {