@skrr-ai/cli 0.1.115 → 0.1.116

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/firstPartyHarness.js

@@ -1,571 +1,388 @@
 "use strict";
-/**
- * The first-party harness identity — the ONLY place its product name is written.
- *
- * "First-party harness" is the harness provider this platform builds, signs,
- * distributes and installs itself: today a fork of OpenCode sold as Skrr Code.
- * It is a different axis from trust Tier 1 in `harnessTrust.ts`, whose
- * "first-party" means an audited VENDOR harness such as Claude Code.
- *
- * ── Why a module, not a find/replace ──────────────────────────────────────
- *
- * The product was renamed twice ("OverSky" engine → "Sky Code" → "skrr Code"),
- * and because its name was used as an IDENTIFIER — in file names, function
- * names, env vars, workflow inputs, Mongo values, wire events — the second
- * rename left 2,826 occurrences in 361 files spelled eleven ways. Every one was
- * a place the next rename would have to find again.
- *
- * So the rule is: the product name is a VALUE held here, and every NAME in the
- * codebase is brand-neutral and reads it. Renaming the product again is:
- *
- *   1. set `displayName` and `provider`;
- *   2. move the old `provider` to the front of `aliases`;
- *   3. set `wireProvider` to the old spelling as a literal — installed daemons
- *      still speak it — and derive it from `provider` again only in the wire
- *      phase, once every peer accepts the new one;
- *   4. regenerate `first-party-harness.json`
- *      (`node --import tsx scripts/emit-first-party-harness-json.mjs`);
- *   5. ship the data migration, which is generic over `aliases` and
- *      `formerSpellings`;
- *   6. at that rename's contract, move the spelling from `aliases` to the front
- *      of `formerSpellings`.
- *
- * No identifier, file, env var name or workflow input moves.
- *
- * ── Four fields, kept apart on purpose ────────────────────────────────────
- *
- * `provider`        CANONICAL. What the platform stores, returns and renders.
- * `aliases`         ACCEPTED on every ingress during a rename's window, and
- *                   normalised to canonical at the edge. Nothing new is ever
- *                   written with one. Empty between renames.
- * `formerSpellings` RETIRED. Accepted on NO ingress: no HTTP body, enum, Mongo
- *                   filter, capability, wire event, CLI flag or trust table
- *                   admits one. Recognised only where an ARTIFACT that predates
- *                   the rename is read — a binary already installed, a checkout
- *                   directory already on disk, a release already published
- *                   under its prefix, a row or config key already written.
- *                   Those exist whatever the platform accepts, and dropping a
- *                   spelling from this list does not make them go away. Read it
- *                   through `firstPartyHarnessArtifactSpellings`, never as an
- *                   ingress check.
- * `wireProvider`    What the server and a daemon say to EACH OTHER — the
- *                   capability a daemon advertises,
- *                   `daemon:<p>:request|response`, the `provider` of a session
- *                   RPC. It moves after the flip and BEFORE contract, because a
- *                   daemon on a user's machine may be any version and the
- *                   server cannot tell which one sent a request: only a
- *                   released daemon that already advertises the canonical
- *                   capability lets the old one age out of the fleet.
- *
- * The old code treated these as one string, which is why no single change could
- * rename it safely. See
- * `docs/architecture/skrr-code-identifier-rename-2026-09-13.md`.
- *
- * ── Constraints on this file ──────────────────────────────────────────────
- *
- * Pure: no `node:` imports, no `process` at module load. It is published as the
- * `@skrr-ai/auth-core/first-party-harness` subpath so the browser client and
- * the React Native app can read it, and a Node-only import here would break
- * both bundles at a distance.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIRST_PARTY_HARNESS_ENGINE = exports.FIRST_PARTY_HARNESS_ENV = exports.FIRST_PARTY_HARNESS_FEED_ORIGIN = exports.FIRST_PARTY_HARNESS_PROVIDER = exports.FIRST_PARTY_HARNESS = void 0;
-exports.firstPartyHarnessSpellings = firstPartyHarnessSpellings;
-exports.firstPartyHarnessArtifactSpellings = firstPartyHarnessArtifactSpellings;
-exports.isFirstPartyHarnessProvider = isFirstPartyHarnessProvider;
-exports.canonicalHarnessProvider = canonicalHarnessProvider;
-exports.canonicalArtifactHarnessProvider = canonicalArtifactHarnessProvider;
-exports.harnessProviderSpellings = harnessProviderSpellings;
-exports.wireHarnessProvider = wireHarnessProvider;
-exports.isSameHarnessProvider = isSameHarnessProvider;
-exports.firstPartyHarnessCapability = firstPartyHarnessCapability;
-exports.firstPartyHarnessCapabilities = firstPartyHarnessCapabilities;
-exports.firstPartyHarnessWireCapability = firstPartyHarnessWireCapability;
-exports.isFirstPartyHarnessCapability = isFirstPartyHarnessCapability;
-exports.canonicalSessionCapability = canonicalSessionCapability;
-exports.advertisesSessionCapability = advertisesSessionCapability;
-exports.firstPartyHarnessEnvironment = firstPartyHarnessEnvironment;
-exports.firstPartyHarnessEnvironments = firstPartyHarnessEnvironments;
-exports.isFirstPartyHarnessEnvironment = isFirstPartyHarnessEnvironment;
-exports.canonicalExecutionEnvironment = canonicalExecutionEnvironment;
-exports.firstPartyHarnessBinaryName = firstPartyHarnessBinaryName;
-exports.firstPartyHarnessBinaryNames = firstPartyHarnessBinaryNames;
-exports.firstPartyHarnessHomeDirname = firstPartyHarnessHomeDirname;
-exports.firstPartyHarnessManifestFile = firstPartyHarnessManifestFile;
-exports.firstPartyHarnessFeedPrefix = firstPartyHarnessFeedPrefix;
-exports.firstPartyHarnessFeedPrefixes = firstPartyHarnessFeedPrefixes;
-exports.firstPartyHarnessStagingPrefix = firstPartyHarnessStagingPrefix;
-exports.firstPartyHarnessDefaultFeedBase = firstPartyHarnessDefaultFeedBase;
-exports.readFirstPartyHarnessEnv = readFirstPartyHarnessEnv;
-exports.firstPartyHarnessEngineEnvNames = firstPartyHarnessEngineEnvNames;
-exports.readFirstPartyHarnessEngineEnv = readFirstPartyHarnessEngineEnv;
-exports.firstPartyHarnessEngineEnvEntries = firstPartyHarnessEngineEnvEntries;
-exports.firstPartyHarnessEngineProjectDirectories = firstPartyHarnessEngineProjectDirectories;
-exports.firstPartyHarnessEngineHomeDirnames = firstPartyHarnessEngineHomeDirnames;
-/** A slug usable as a directory name, a capability prefix and an event segment. */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var firstPartyHarness_exports = {};
+__export(firstPartyHarness_exports, {
+  FIRST_PARTY_HARNESS: () => FIRST_PARTY_HARNESS,
+  FIRST_PARTY_HARNESS_ENGINE: () => FIRST_PARTY_HARNESS_ENGINE,
+  FIRST_PARTY_HARNESS_ENV: () => FIRST_PARTY_HARNESS_ENV,
+  FIRST_PARTY_HARNESS_FEED_ORIGIN: () => FIRST_PARTY_HARNESS_FEED_ORIGIN,
+  FIRST_PARTY_HARNESS_PROVIDER: () => FIRST_PARTY_HARNESS_PROVIDER,
+  advertisesSessionCapability: () => advertisesSessionCapability,
+  canonicalArtifactHarnessProvider: () => canonicalArtifactHarnessProvider,
+  canonicalExecutionEnvironment: () => canonicalExecutionEnvironment,
+  canonicalHarnessProvider: () => canonicalHarnessProvider,
+  canonicalSessionCapability: () => canonicalSessionCapability,
+  firstPartyHarnessArtifactSpellings: () => firstPartyHarnessArtifactSpellings,
+  firstPartyHarnessBinaryName: () => firstPartyHarnessBinaryName,
+  firstPartyHarnessBinaryNames: () => firstPartyHarnessBinaryNames,
+  firstPartyHarnessCapabilities: () => firstPartyHarnessCapabilities,
+  firstPartyHarnessCapability: () => firstPartyHarnessCapability,
+  firstPartyHarnessDefaultFeedBase: () => firstPartyHarnessDefaultFeedBase,
+  firstPartyHarnessEngineEnvEntries: () => firstPartyHarnessEngineEnvEntries,
+  firstPartyHarnessEngineEnvNames: () => firstPartyHarnessEngineEnvNames,
+  firstPartyHarnessEngineHomeDirnames: () => firstPartyHarnessEngineHomeDirnames,
+  firstPartyHarnessEngineProjectDirectories: () => firstPartyHarnessEngineProjectDirectories,
+  firstPartyHarnessEnvironment: () => firstPartyHarnessEnvironment,
+  firstPartyHarnessEnvironments: () => firstPartyHarnessEnvironments,
+  firstPartyHarnessFeedPrefix: () => firstPartyHarnessFeedPrefix,
+  firstPartyHarnessFeedPrefixes: () => firstPartyHarnessFeedPrefixes,
+  firstPartyHarnessHomeDirname: () => firstPartyHarnessHomeDirname,
+  firstPartyHarnessManifestFile: () => firstPartyHarnessManifestFile,
+  firstPartyHarnessSpellings: () => firstPartyHarnessSpellings,
+  firstPartyHarnessStagingPrefix: () => firstPartyHarnessStagingPrefix,
+  firstPartyHarnessWireCapability: () => firstPartyHarnessWireCapability,
+  harnessProviderSpellings: () => harnessProviderSpellings,
+  isFirstPartyHarnessCapability: () => isFirstPartyHarnessCapability,
+  isFirstPartyHarnessEnvironment: () => isFirstPartyHarnessEnvironment,
+  isFirstPartyHarnessProvider: () => isFirstPartyHarnessProvider,
+  isSameHarnessProvider: () => isSameHarnessProvider,
+  readFirstPartyHarnessEngineEnv: () => readFirstPartyHarnessEngineEnv,
+  readFirstPartyHarnessEnv: () => readFirstPartyHarnessEnv,
+  wireHarnessProvider: () => wireHarnessProvider
+});
+module.exports = __toCommonJS(firstPartyHarness_exports);
 const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function defineIdentity(identity) {
-    const spellings = [identity.provider, ...identity.aliases];
-    const every = [...spellings, ...identity.formerSpellings];
-    for (const spelling of every) {
-        if (!SLUG.test(spelling)) {
-            throw new Error(`first-party harness spelling ${JSON.stringify(spelling)} is not a slug; it becomes a ` +
-                `directory name, a capability prefix and a wire event segment`);
-        }
-    }
-    if (new Set(every).size !== every.length) {
-        throw new Error('first-party harness provider, aliases and formerSpellings must be distinct — a spelling ' +
-            'is accepted or retired, never both');
-    }
-    if (!spellings.includes(identity.wireProvider)) {
-        throw new Error(`first-party harness wireProvider ${JSON.stringify(identity.wireProvider)} must be the ` +
-            'provider or one of its aliases — a peer can only accept a spelling it knows');
+  const spellings = [identity.provider, ...identity.aliases];
+  const every = [...spellings, ...identity.formerSpellings];
+  for (const spelling of every) {
+    if (!SLUG.test(spelling)) {
+      throw new Error(`first-party harness spelling ${JSON.stringify(spelling)} is not a slug; it becomes a directory name, a capability prefix and a wire event segment`);
     }
-    return Object.freeze({
-        ...identity,
-        aliases: Object.freeze([...identity.aliases]),
-        formerSpellings: Object.freeze([...identity.formerSpellings]),
-    });
-}
-/** The canonical slug. Written once, and read by every field that names the current spelling. */
-const PROVIDER = 'skrr-code';
-/**
- * THE identity — the only literal product name in the codebase.
- *
- * Phase: CONTRACTED (OSK-8663). `skrr-code` is the only spelling any ingress
- * accepts and the only one on the wire. `sky-code` is retired: nothing admits
- * it, and it is still recognised where a binary, a checkout, a published
- * release or a stored value written before the rename is looked for.
- */
+  }
+  if (new Set(every).size !== every.length) {
+    throw new Error("first-party harness provider, aliases and formerSpellings must be distinct \u2014 a spelling is accepted or retired, never both");
+  }
+  if (!spellings.includes(identity.wireProvider)) {
+    throw new Error(`first-party harness wireProvider ${JSON.stringify(identity.wireProvider)} must be the provider or one of its aliases \u2014 a peer can only accept a spelling it knows`);
+  }
+  return Object.freeze({
+    ...identity,
+    aliases: Object.freeze([...identity.aliases]),
+    formerSpellings: Object.freeze([...identity.formerSpellings])
+  });
+}
+const PROVIDER = "skrr-code";
 const IDENTITY = {
-    displayName: 'Skrr Code',
-    command: 'skrr code',
-    provider: PROVIDER,
-    aliases: [],
-    formerSpellings: ['sky-code'],
-    wireProvider: PROVIDER,
+  displayName: "Skrr Code",
+  command: "skrr code",
+  provider: PROVIDER,
+  aliases: [],
+  formerSpellings: ["sky-code"],
+  wireProvider: PROVIDER
 };
-exports.FIRST_PARTY_HARNESS = defineIdentity(IDENTITY);
-/** The canonical slug with its literal type, for `as const` tuples and keyed tables. */
-exports.FIRST_PARTY_HARNESS_PROVIDER = IDENTITY.provider;
+const FIRST_PARTY_HARNESS = defineIdentity(IDENTITY);
+const FIRST_PARTY_HARNESS_PROVIDER = IDENTITY.provider;
 const SPELLINGS = Object.freeze([
-    exports.FIRST_PARTY_HARNESS.provider,
-    ...exports.FIRST_PARTY_HARNESS.aliases,
+  FIRST_PARTY_HARNESS.provider,
+  ...FIRST_PARTY_HARNESS.aliases
 ]);
 const SPELLING_SET = new Set(SPELLINGS);
 const ARTIFACT_SPELLINGS = Object.freeze([
-    ...SPELLINGS,
-    ...exports.FIRST_PARTY_HARNESS.formerSpellings,
+  ...SPELLINGS,
+  ...FIRST_PARTY_HARNESS.formerSpellings
 ]);
 const ARTIFACT_SPELLING_SET = new Set(ARTIFACT_SPELLINGS);
-const SESSION_SUFFIX = '_session';
-const ENVIRONMENT_PREFIX = 'local-';
+const SESSION_SUFFIX = "_session";
+const ENVIRONMENT_PREFIX = "local-";
 function asSlug(value) {
-    if (typeof value !== 'string')
-        return null;
-    const slug = value.trim().toLowerCase();
-    return slug ? slug : null;
-}
-/**
- * Every ACCEPTED spelling, canonical first — what an ingress admits. The order
- * is the resolution order.
- */
+  if (typeof value !== "string")
+    return null;
+  const slug = value.trim().toLowerCase();
+  return slug ? slug : null;
+}
 function firstPartyHarnessSpellings() {
-    return SPELLINGS;
-}
-/**
- * Every spelling an ARTIFACT that already exists may carry, canonical first:
- * the accepted spellings, then every former one.
- *
- * For code that LOOKS FOR what an earlier release left behind — an installed
- * binary, a checkout directory, an immutable published release, a stored value
- * or config key — and for the tooling that must keep recognising those
- * (ignore lists, the identity ratchet). A machine that never ran a post-rename
- * client still has its engine under the old name, and it must still be found.
- *
- * Never an ingress check: a former spelling is not accepted anywhere, and a
- * reader that admitted one here would silently reopen what contract closed. Use
- * `firstPartyHarnessSpellings` / `isFirstPartyHarnessProvider` for that.
- */
+  return SPELLINGS;
+}
 function firstPartyHarnessArtifactSpellings() {
-    return ARTIFACT_SPELLINGS;
+  return ARTIFACT_SPELLINGS;
 }
-/** True for the canonical provider or any alias (case- and whitespace-insensitive). */
 function isFirstPartyHarnessProvider(value) {
-    const slug = asSlug(value);
-    return slug !== null && SPELLING_SET.has(slug);
-}
-/**
- * The canonical provider for any spelling of the first-party harness; every
- * other value is returned UNCHANGED (this is not a general normaliser — the
- * caller's own normalisation still owns case and shape for other providers).
- */
+  const slug = asSlug(value);
+  return slug !== null && SPELLING_SET.has(slug);
+}
 function canonicalHarnessProvider(value) {
-    return isFirstPartyHarnessProvider(value) ? exports.FIRST_PARTY_HARNESS.provider : value;
-}
-/**
- * The canonical provider for a value read back from an ARTIFACT that may predate
- * a rename — any artifact spelling (canonical, alias or FORMER) becomes the
- * provider; every other value is returned unchanged.
- *
- * For values nobody migrates and nobody can refuse: a harness row's stored
- * display NAME (the operator migration rewrites `provider`, never `name`), a
- * daemon's config file, a harness session binding on a user's machine. Read raw
- * after contract, each would name an unknown provider — a label that renders the
- * retired name again, a local session silently running another backend, a live
- * resume context reset as new — with no error anywhere.
- *
- * NEVER for anything a peer, a client or an operator SENDS, and never for a
- * trust, dispatch or admission decision: a former spelling is accepted on no
- * ingress, and canonicalising one here would reopen what contract closed. Use
- * `canonicalHarnessProvider` for those.
- */
+  return isFirstPartyHarnessProvider(value) ? FIRST_PARTY_HARNESS.provider : value;
+}
 function canonicalArtifactHarnessProvider(value) {
-    const slug = asSlug(value);
-    return slug !== null && ARTIFACT_SPELLING_SET.has(slug) ? exports.FIRST_PARTY_HARNESS.provider : value;
-}
-/**
- * Every spelling a stored row for this provider may carry, canonical first —
- * for a Mongo `$in` filter while rows written before a flip still exist. Any
- * other provider is returned as a one-element list.
- */
+  const slug = asSlug(value);
+  return slug !== null && ARTIFACT_SPELLING_SET.has(slug) ? FIRST_PARTY_HARNESS.provider : value;
+}
 function harnessProviderSpellings(value) {
-    return isFirstPartyHarnessProvider(value) ? [...SPELLINGS] : [value];
+  return isFirstPartyHarnessProvider(value) ? [...SPELLINGS] : [value];
 }
-/** The spelling to put ON THE WIRE to a daemon; other providers pass through. */
 function wireHarnessProvider(value) {
-    return isFirstPartyHarnessProvider(value) ? exports.FIRST_PARTY_HARNESS.wireProvider : value;
+  return isFirstPartyHarnessProvider(value) ? FIRST_PARTY_HARNESS.wireProvider : value;
 }
-/** True when two provider values name the same harness, whatever spelling each uses. */
 function isSameHarnessProvider(a, b) {
-    if (typeof a !== 'string' || typeof b !== 'string')
-        return false;
-    return (canonicalHarnessProvider(a.trim().toLowerCase()) ===
-        canonicalHarnessProvider(b.trim().toLowerCase()));
+  if (typeof a !== "string" || typeof b !== "string")
+    return false;
+  return canonicalHarnessProvider(a.trim().toLowerCase()) === canonicalHarnessProvider(b.trim().toLowerCase());
 }
-/* ── Derived: session capability ─────────────────────────────────────────── */
-function firstPartyHarnessCapability(provider = exports.FIRST_PARTY_HARNESS.provider) {
-    return `${provider}${SESSION_SUFFIX}`;
+function firstPartyHarnessCapability(provider = FIRST_PARTY_HARNESS.provider) {
+  return `${provider}${SESSION_SUFFIX}`;
 }
-/** Every capability spelling, canonical first. */
 function firstPartyHarnessCapabilities() {
-    return SPELLINGS.map((spelling) => firstPartyHarnessCapability(spelling));
+  return SPELLINGS.map((spelling) => firstPartyHarnessCapability(spelling));
 }
-/** The capability a daemon advertises. */
 function firstPartyHarnessWireCapability() {
-    return firstPartyHarnessCapability(exports.FIRST_PARTY_HARNESS.wireProvider);
+  return firstPartyHarnessCapability(FIRST_PARTY_HARNESS.wireProvider);
 }
 function isFirstPartyHarnessCapability(value) {
-    const slug = asSlug(value);
-    if (slug === null || !slug.endsWith(SESSION_SUFFIX))
-        return false;
-    return SPELLING_SET.has(slug.slice(0, -SESSION_SUFFIX.length));
+  const slug = asSlug(value);
+  if (slug === null || !slug.endsWith(SESSION_SUFFIX))
+    return false;
+  return SPELLING_SET.has(slug.slice(0, -SESSION_SUFFIX.length));
 }
-/** `<alias>_session` → `<provider>_session`; every other value unchanged. */
 function canonicalSessionCapability(value) {
-    return isFirstPartyHarnessCapability(value) ? firstPartyHarnessCapability() : value;
-}
-/**
- * Whether a capability list contains `capability` under ANY accepted spelling.
- *
- * A daemon advertises the capability it was built with, and a daemon on a user's
- * machine may be any version, so around a rename the same harness arrives as
- * more than one `<provider>_session`. An exact `includes` against the canonical
- * spelling reads the older one as "not installed" — a card that never lights up,
- * a dispatch refused — with no error. Every other capability compares exactly.
- */
+  return isFirstPartyHarnessCapability(value) ? firstPartyHarnessCapability() : value;
+}
 function advertisesSessionCapability(capabilities, capability) {
-    if (!Array.isArray(capabilities) || capabilities.length === 0)
-        return false;
-    const wanted = canonicalSessionCapability(capability);
-    return capabilities.some((advertised) => canonicalSessionCapability(advertised) === wanted);
+  if (!Array.isArray(capabilities) || capabilities.length === 0)
+    return false;
+  const wanted = canonicalSessionCapability(capability);
+  return capabilities.some((advertised) => canonicalSessionCapability(advertised) === wanted);
 }
-/* ── Derived: pinned execution environment ───────────────────────────────── */
-function firstPartyHarnessEnvironment(provider = exports.FIRST_PARTY_HARNESS.provider) {
-    return `${ENVIRONMENT_PREFIX}${provider}`;
+function firstPartyHarnessEnvironment(provider = FIRST_PARTY_HARNESS.provider) {
+  return `${ENVIRONMENT_PREFIX}${provider}`;
 }
-/** Every environment spelling, canonical first. */
 function firstPartyHarnessEnvironments() {
-    return SPELLINGS.map((spelling) => firstPartyHarnessEnvironment(spelling));
+  return SPELLINGS.map((spelling) => firstPartyHarnessEnvironment(spelling));
 }
 function isFirstPartyHarnessEnvironment(value) {
-    const slug = asSlug(value);
-    if (slug === null || !slug.startsWith(ENVIRONMENT_PREFIX))
-        return false;
-    return SPELLING_SET.has(slug.slice(ENVIRONMENT_PREFIX.length));
+  const slug = asSlug(value);
+  if (slug === null || !slug.startsWith(ENVIRONMENT_PREFIX))
+    return false;
+  return SPELLING_SET.has(slug.slice(ENVIRONMENT_PREFIX.length));
 }
-/** `local-<alias>` → `local-<provider>`; every other value unchanged. */
 function canonicalExecutionEnvironment(value) {
-    return isFirstPartyHarnessEnvironment(value) ? firstPartyHarnessEnvironment() : value;
-}
-/* ── Derived: on-disk and distribution names ─────────────────────────────── */
-/** Binary file name. `platform` is a `process.platform` value; only `win32` differs. */
-function firstPartyHarnessBinaryName(provider = exports.FIRST_PARTY_HARNESS.provider, platform) {
-    return platform === 'win32' ? `${provider}.exe` : provider;
-}
-/**
- * Every binary file name an install may carry, canonical first — the lookup
- * order, and the names an install links to the canonical binary.
- *
- * Built from the ARTIFACT spellings, former ones included: binaries are
- * artifacts. An engine installed before a rename is still on disk under its old
- * name, and a platform CLI or daemon built before it still looks for that name,
- * so resolvers try it and installers leave a link at it. Neither makes the
- * spelling acceptable on any ingress.
- */
+  return isFirstPartyHarnessEnvironment(value) ? firstPartyHarnessEnvironment() : value;
+}
+function firstPartyHarnessBinaryName(provider = FIRST_PARTY_HARNESS.provider, platform) {
+  return platform === "win32" ? `${provider}.exe` : provider;
+}
 function firstPartyHarnessBinaryNames(platform) {
-    return ARTIFACT_SPELLINGS.map((spelling) => firstPartyHarnessBinaryName(spelling, platform));
-}
-/**
- * The engine home directory name under the skrr config root.
- *
- * It follows the ENGINE's namespace (`FIRST_PARTY_HARNESS_ENGINE.appName`), not
- * the provider slug, because it is one directory with two owners: the platform
- * installs the binary into `<home>/bin`, and the engine reads its own config and
- * the managed `AGENTS.md` from `<home>`. Deriving it from the provider would, on
- * a fresh install after a provider rename, create a second directory the engine
- * never reads — managed instructions would stop applying with no error. It moves
- * when the engine's namespace moves, and not before; it did in OSK-8674, and
- * `migrateFirstPartyHarnessHome` moves a home under a legacy name onto it.
- */
+  return ARTIFACT_SPELLINGS.map((spelling) => firstPartyHarnessBinaryName(spelling, platform));
+}
 function firstPartyHarnessHomeDirname() {
-    return exports.FIRST_PARTY_HARNESS_ENGINE.appName;
-}
-/** Signed release manifest file name. */
-function firstPartyHarnessManifestFile(provider = exports.FIRST_PARTY_HARNESS.provider) {
-    return `${provider}-version.json`;
-}
-/**
- * The update feed ORIGIN. Not a product name, and not moved by this identity:
- * a feed host sits inside signed manifests (naming map §2 "Update feed").
- */
-exports.FIRST_PARTY_HARNESS_FEED_ORIGIN = 'https://updates.skrr.ai';
-/** Object-key prefix for one spelling's feed, e.g. `skrr-code/`. */
-function firstPartyHarnessFeedPrefix(provider = exports.FIRST_PARTY_HARNESS.provider) {
-    return `${provider}/`;
-}
-/**
- * Every feed prefix a publish WRITES, canonical first: the accepted spellings.
- *
- * A former spelling's prefix still holds every release published under it, and
- * those stay served — their artifact URLs are inside signed manifests — but
- * nothing new is written there, so its channel pointers stop moving at contract.
- */
+  return FIRST_PARTY_HARNESS_ENGINE.appName;
+}
+function firstPartyHarnessManifestFile(provider = FIRST_PARTY_HARNESS.provider) {
+  return `${provider}-version.json`;
+}
+const FIRST_PARTY_HARNESS_FEED_ORIGIN = "https://updates.skrr.ai";
+function firstPartyHarnessFeedPrefix(provider = FIRST_PARTY_HARNESS.provider) {
+  return `${provider}/`;
+}
 function firstPartyHarnessFeedPrefixes() {
-    return SPELLINGS.map((spelling) => firstPartyHarnessFeedPrefix(spelling));
+  return SPELLINGS.map((spelling) => firstPartyHarnessFeedPrefix(spelling));
 }
-/** Object-key prefix the fork stages unsigned builds under, e.g. `skrr-code-staging/`. */
-function firstPartyHarnessStagingPrefix(provider = exports.FIRST_PARTY_HARNESS.provider) {
-    return `${provider}-staging/`;
+function firstPartyHarnessStagingPrefix(provider = FIRST_PARTY_HARNESS.provider) {
+  return `${provider}-staging/`;
 }
-/** Default feed base URL for one spelling. */
-function firstPartyHarnessDefaultFeedBase(provider = exports.FIRST_PARTY_HARNESS.provider) {
-    return `${exports.FIRST_PARTY_HARNESS_FEED_ORIGIN}/${provider}`;
+function firstPartyHarnessDefaultFeedBase(provider = FIRST_PARTY_HARNESS.provider) {
+  return `${FIRST_PARTY_HARNESS_FEED_ORIGIN}/${provider}`;
 }
 function envName(name) {
-    return Object.freeze({ name });
-}
-/**
- * Every environment variable the PLATFORM reads for the first-party harness, by
- * purpose, under one brand-neutral name each — so a product rename never renames
- * one.
- *
- * The product-named variables these replaced were read second until contract
- * (OSK-8663) and are not read at all now. The ENGINE's own variables are a
- * different namespace (`FIRST_PARTY_HARNESS_ENGINE.env`): the fork reads them,
- * so a platform reader that must agree with the engine consults the engine's
- * names explicitly (`readFirstPartyHarnessEngineEnv`) — the engine home is the
- * one case (`home` below).
- */
-exports.FIRST_PARTY_HARNESS_ENV = Object.freeze({
-    /** Absolute path to an engine binary, overriding resolution. */
-    path: envName('SKRR_FIRST_PARTY_HARNESS_PATH'),
-    /** Forces the CLI's managed-inference mode. */
-    managed: envName('SKRR_FIRST_PARTY_HARNESS_MANAGED'),
-    /** Update channel. */
-    channel: envName('SKRR_FIRST_PARTY_HARNESS_CHANNEL'),
-    /** Update-feed base URL override. */
-    updateFeedBase: envName('SKRR_FIRST_PARTY_HARNESS_UPDATE_FEED_BASE'),
-    /** Path to a file of development release keys. */
-    devKeys: envName('SKRR_FIRST_PARTY_HARNESS_DEV_KEYS'),
-    /** Engine version the desktop build bundles. */
-    bundleVersion: envName('SKRR_FIRST_PARTY_HARNESS_BUNDLE_VERSION'),
-    /**
-     * Engine home override. The engine reads only its own variable, under every
-     * name it has had (`readFirstPartyHarnessEngineEnv(env, 'home')`), so a reader
-     * that resolves the home the engine will use reads those second, and a
-     * launcher hands the engine the resolved path under every one of them
-     * (`firstPartyHarnessEngineEnvEntries`).
-     */
-    home: envName('SKRR_FIRST_PARTY_HARNESS_HOME'),
-    /** Engine version baked into the cloud-coding image. */
-    cloudCodingVersion: envName('CLOUD_CODING_FIRST_PARTY_HARNESS_VERSION'),
-    /** Engine version baked into the Dedicated Runtime AMI. */
-    dedicatedRuntimeVersion: envName('SKRR_DEDICATED_RUNTIME_FIRST_PARTY_HARNESS_VERSION'),
-    /** Engine version the desktop release workflow bundles. */
-    desktopBundledVersion: envName('DESKTOP_BUNDLED_FIRST_PARTY_HARNESS_VERSION'),
-    /** Update-feed bucket used by publish and promote. */
-    updatesBucket: envName('FIRST_PARTY_HARNESS_UPDATES_BUCKET'),
-    /** Release signing key (CI secret). */
-    signingKey: envName('FIRST_PARTY_HARNESS_SIGNING_KEY'),
-    /** Release signing key id (CI secret). */
-    signingKeyId: envName('FIRST_PARTY_HARNESS_SIGNING_KEY_ID'),
+  return Object.freeze({ name });
+}
+const FIRST_PARTY_HARNESS_ENV = Object.freeze({
+  /** Absolute path to an engine binary, overriding resolution. */
+  path: envName("SKRR_FIRST_PARTY_HARNESS_PATH"),
+  /** Forces the CLI's managed-inference mode. */
+  managed: envName("SKRR_FIRST_PARTY_HARNESS_MANAGED"),
+  /** Update channel. */
+  channel: envName("SKRR_FIRST_PARTY_HARNESS_CHANNEL"),
+  /** Update-feed base URL override. */
+  updateFeedBase: envName("SKRR_FIRST_PARTY_HARNESS_UPDATE_FEED_BASE"),
+  /** Path to a file of development release keys. */
+  devKeys: envName("SKRR_FIRST_PARTY_HARNESS_DEV_KEYS"),
+  /** Engine version the desktop build bundles. */
+  bundleVersion: envName("SKRR_FIRST_PARTY_HARNESS_BUNDLE_VERSION"),
+  /**
+   * Engine home override. The engine reads only its own variable, under every
+   * name it has had (`readFirstPartyHarnessEngineEnv(env, 'home')`), so a reader
+   * that resolves the home the engine will use reads those second, and a
+   * launcher hands the engine the resolved path under every one of them
+   * (`firstPartyHarnessEngineEnvEntries`).
+   */
+  home: envName("SKRR_FIRST_PARTY_HARNESS_HOME"),
+  /** Engine version baked into the cloud-coding image. */
+  cloudCodingVersion: envName("CLOUD_CODING_FIRST_PARTY_HARNESS_VERSION"),
+  /** Engine version baked into the Dedicated Runtime AMI. */
+  dedicatedRuntimeVersion: envName("SKRR_DEDICATED_RUNTIME_FIRST_PARTY_HARNESS_VERSION"),
+  /** Engine version the desktop release workflow bundles. */
+  desktopBundledVersion: envName("DESKTOP_BUNDLED_FIRST_PARTY_HARNESS_VERSION"),
+  /** Update-feed bucket used by publish and promote. */
+  updatesBucket: envName("FIRST_PARTY_HARNESS_UPDATES_BUCKET"),
+  /** Release signing key (CI secret). */
+  signingKey: envName("FIRST_PARTY_HARNESS_SIGNING_KEY"),
+  /** Release signing key id (CI secret). */
+  signingKeyId: envName("FIRST_PARTY_HARNESS_SIGNING_KEY_ID")
 });
-/** Read one purpose's variable. A blank value counts as unset. */
 function readFirstPartyHarnessEnv(env, key) {
-    const { name } = exports.FIRST_PARTY_HARNESS_ENV[key];
-    const raw = env[name];
-    if (typeof raw === 'string' && raw.trim() !== '') {
-        return { value: raw.trim(), name };
-    }
-    return { value: undefined, name: undefined };
-}
-/* ── The ENGINE's own namespace (defined inside the fork) ───────────────── */
-/**
- * The engine's state namespace today. Moved from `sky-code` by OSK-8674: XDG
- * dirs, project directory, config basename, the engine home under the skrr
- * root, and every variable the engine reads all derive from it.
- */
-const ENGINE_APP_NAME = 'skrr-code';
-/**
- * Earlier engine namespaces, newest first. Still READ on both sides of the
- * daemon↔engine boundary: an engine binary, a daemon, a CLI and a desktop app
- * each ship on their own schedule, and a machine holds state written under
- * every name it has run.
- */
-const ENGINE_LEGACY_APP_NAMES = ['sky-code'];
-/**
- * Every variable the engine reads, by purpose, as the suffix after the app
- * name's prefix (`skrr-code` → `SKRR_CODE_<suffix>`). The fork names all of its
- * own variables this way, so the names follow the namespace rather than being
- * written out once per spelling.
- */
+  const { name } = FIRST_PARTY_HARNESS_ENV[key];
+  const raw = env[name];
+  if (typeof raw === "string" && raw.trim() !== "") {
+    return { value: raw.trim(), name };
+  }
+  return { value: void 0, name: void 0 };
+}
+const ENGINE_APP_NAME = "skrr-code";
+const ENGINE_LEGACY_APP_NAMES = ["sky-code"];
 const ENGINE_ENV_SUFFIXES = Object.freeze({
-    serverPassword: 'SERVER_PASSWORD',
-    serverUsername: 'SERVER_USERNAME',
-    home: 'HOME',
-    config: 'CONFIG',
-    appName: 'APP_NAME',
-    scriptName: 'SCRIPT_NAME',
-    allowUpstreamEgress: 'ALLOW_UPSTREAM_EGRESS',
-    compatOpencode: 'COMPAT_OPENCODE',
-    noCompatPrompts: 'NO_COMPAT_PROMPTS',
-    /**
-     * Advisory input-token budget for a managed session, set by the daemon from
-     * the server-issued `requestEnvelope.maxInputTokens` so the engine's
-     * auto-compaction can trigger before the relay refuses the request. The
-     * engine must treat it as a hint: enforcement stays server-side.
-     */
-    maxInputTokens: 'MAX_INPUT_TOKENS',
-    /**
-     * The session id the engine stamps into processes it spawns — the one
-     * variable on this table the engine WRITES rather than reads, so a child
-     * process (e.g. `skrr code handover --carry-session`) can name the session it
-     * is running inside without being told. Read with
-     * `readFirstPartyHarnessEngineEnv`: current namespace first, then legacy.
-     */
-    sessionId: 'SESSION_ID',
+  serverPassword: "SERVER_PASSWORD",
+  serverUsername: "SERVER_USERNAME",
+  home: "HOME",
+  config: "CONFIG",
+  appName: "APP_NAME",
+  scriptName: "SCRIPT_NAME",
+  allowUpstreamEgress: "ALLOW_UPSTREAM_EGRESS",
+  compatOpencode: "COMPAT_OPENCODE",
+  noCompatPrompts: "NO_COMPAT_PROMPTS",
+  /**
+   * Advisory input-token budget for a managed session, set by the daemon from
+   * the server-issued `requestEnvelope.maxInputTokens` so the engine's
+   * auto-compaction can trigger before the relay refuses the request. The
+   * engine must treat it as a hint: enforcement stays server-side.
+   */
+  maxInputTokens: "MAX_INPUT_TOKENS",
+  /**
+   * The session id the engine stamps into processes it spawns — the one
+   * variable on this table the engine WRITES rather than reads, so a child
+   * process (e.g. `skrr code handover --carry-session`) can name the session it
+   * is running inside without being told. Read with
+   * `readFirstPartyHarnessEngineEnv`: current namespace first, then legacy.
+   */
+  sessionId: "SESSION_ID"
 });
 function engineEnvName(appName, key) {
-    return `${appName.toUpperCase().replace(/-/g, '_')}_${ENGINE_ENV_SUFFIXES[key]}`;
+  return `${appName.toUpperCase().replace(/-/g, "_")}_${ENGINE_ENV_SUFFIXES[key]}`;
 }
 function engineEnvTable(appName) {
-    return Object.freeze(Object.fromEntries(Object.keys(ENGINE_ENV_SUFFIXES).map((key) => [
-        key,
-        engineEnvName(appName, key),
-    ])));
+  return Object.freeze(Object.fromEntries(Object.keys(ENGINE_ENV_SUFFIXES).map((key) => [
+    key,
+    engineEnvName(appName, key)
+  ])));
 }
 function defineEngineNamespace(appName, legacyAppNames) {
-    const every = [appName, ...legacyAppNames];
-    for (const name of every) {
-        if (!SLUG.test(name)) {
-            throw new Error(`first-party harness engine app name ${JSON.stringify(name)} is not a slug; it becomes a ` +
-                'directory name and a variable prefix');
-        }
+  const every = [appName, ...legacyAppNames];
+  for (const name of every) {
+    if (!SLUG.test(name)) {
+      throw new Error(`first-party harness engine app name ${JSON.stringify(name)} is not a slug; it becomes a directory name and a variable prefix`);
     }
-    if (new Set(every).size !== every.length) {
-        throw new Error('first-party harness engine appName and legacyAppNames must be distinct');
-    }
-    return Object.freeze({
-        /**
-         * The engine's state namespace: XDG dirs, project marker, config basename, and
-         * the engine home under the skrr root (`firstPartyHarnessHomeDirname`).
-         */
-        appName,
-        /**
-         * Earlier `appName`s, newest first. `migrateFirstPartyHarnessHome` moves a home
-         * under one of them onto the current name and leaves a symlink; readers of
-         * engine state look under them after the current name.
-         */
-        legacyAppNames: Object.freeze([...legacyAppNames]),
-        /** Project-local configuration directory inside a user's repository. */
-        projectDirectory: `.${appName}`,
-        /**
-         * Earlier project directories, newest first. The engine still reads them and
-         * the platform never rewrites a user's repository to move one, so a reader
-         * looks here after `projectDirectory`, and a writer adopts an existing file
-         * here rather than creating a second one beside it.
-         */
-        legacyProjectDirectories: Object.freeze(legacyAppNames.map((name) => `.${name}`)),
-        /**
-         * Environment variables the engine reads, under the CURRENT namespace. The
-         * engine also reads each one under every legacy namespace, second — use
-         * `readFirstPartyHarnessEngineEnv` to read one the way the engine does and
-         * `firstPartyHarnessEngineEnvEntries` to set one every engine build honours.
-         */
-        env: engineEnvTable(appName),
-    });
-}
-/**
- * Names the ENGINE itself defines and reads. The platform sets or reads them
- * across the daemon↔engine boundary, so they are recorded here as values rather
- * than scattered as literals. They are the fork's names, and moving one is a
- * two-sided change: the engine reads the new name first and every legacy name
- * second, and while engine and platform releases can arrive in either order the
- * platform SETS every name and READS new-then-legacy (contract §6, OSK-8674).
- */
-exports.FIRST_PARTY_HARNESS_ENGINE = defineEngineNamespace(ENGINE_APP_NAME, ENGINE_LEGACY_APP_NAMES);
-/**
- * Every name the engine reads for one purpose, current namespace first — the
- * engine's own lookup order.
- */
+  }
+  if (new Set(every).size !== every.length) {
+    throw new Error("first-party harness engine appName and legacyAppNames must be distinct");
+  }
+  return Object.freeze({
+    /**
+     * The engine's state namespace: XDG dirs, project marker, config basename, and
+     * the engine home under the skrr root (`firstPartyHarnessHomeDirname`).
+     */
+    appName,
+    /**
+     * Earlier `appName`s, newest first. `migrateFirstPartyHarnessHome` moves a home
+     * under one of them onto the current name and leaves a symlink; readers of
+     * engine state look under them after the current name.
+     */
+    legacyAppNames: Object.freeze([...legacyAppNames]),
+    /** Project-local configuration directory inside a user's repository. */
+    projectDirectory: `.${appName}`,
+    /**
+     * Earlier project directories, newest first. The engine still reads them and
+     * the platform never rewrites a user's repository to move one, so a reader
+     * looks here after `projectDirectory`, and a writer adopts an existing file
+     * here rather than creating a second one beside it.
+     */
+    legacyProjectDirectories: Object.freeze(legacyAppNames.map((name) => `.${name}`)),
+    /**
+     * Environment variables the engine reads, under the CURRENT namespace. The
+     * engine also reads each one under every legacy namespace, second — use
+     * `readFirstPartyHarnessEngineEnv` to read one the way the engine does and
+     * `firstPartyHarnessEngineEnvEntries` to set one every engine build honours.
+     */
+    env: engineEnvTable(appName)
+  });
+}
+const FIRST_PARTY_HARNESS_ENGINE = defineEngineNamespace(ENGINE_APP_NAME, ENGINE_LEGACY_APP_NAMES);
 function firstPartyHarnessEngineEnvNames(key) {
-    return [exports.FIRST_PARTY_HARNESS_ENGINE.appName, ...exports.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames].map((appName) => engineEnvName(appName, key));
+  return [FIRST_PARTY_HARNESS_ENGINE.appName, ...FIRST_PARTY_HARNESS_ENGINE.legacyAppNames].map((appName) => engineEnvName(appName, key));
 }
-/**
- * Read one engine variable the way the engine reads it: the current name, then
- * every legacy name. A blank value counts as unset.
- */
 function readFirstPartyHarnessEngineEnv(env, key) {
-    for (const name of firstPartyHarnessEngineEnvNames(key)) {
-        const raw = env[name];
-        if (typeof raw === 'string' && raw.trim() !== '') {
-            return { value: raw.trim(), name };
-        }
+  for (const name of firstPartyHarnessEngineEnvNames(key)) {
+    const raw = env[name];
+    if (typeof raw === "string" && raw.trim() !== "") {
+      return { value: raw.trim(), name };
     }
-    return { value: undefined, name: undefined };
-}
-/**
- * One engine variable set under EVERY name the engine has read, for a process
- * that spawns the engine. An engine binary is installed on its own schedule, so
- * a launcher cannot know whether the one it starts reads the current name or a
- * legacy one; setting both means either build receives the value.
- */
+  }
+  return { value: void 0, name: void 0 };
+}
 function firstPartyHarnessEngineEnvEntries(key, value) {
-    return Object.fromEntries(firstPartyHarnessEngineEnvNames(key).map((name) => [name, value]));
+  return Object.fromEntries(firstPartyHarnessEngineEnvNames(key).map((name) => [name, value]));
 }
-/** Every engine project directory, current first — the engine's read order. */
 function firstPartyHarnessEngineProjectDirectories() {
-    return [
-        exports.FIRST_PARTY_HARNESS_ENGINE.projectDirectory,
-        ...exports.FIRST_PARTY_HARNESS_ENGINE.legacyProjectDirectories,
-    ];
-}
-/**
- * Every engine home directory name under a config root, current first: where an
- * engine home may exist on disk. `firstPartyHarnessHomeDirname` is the one the
- * platform writes.
- */
-function firstPartyHarnessEngineHomeDirnames() {
-    return [exports.FIRST_PARTY_HARNESS_ENGINE.appName, ...exports.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames];
+  return [
+    FIRST_PARTY_HARNESS_ENGINE.projectDirectory,
+    ...FIRST_PARTY_HARNESS_ENGINE.legacyProjectDirectories
+  ];
 }
+function firstPartyHarnessEngineHomeDirnames() {
+  return [FIRST_PARTY_HARNESS_ENGINE.appName, ...FIRST_PARTY_HARNESS_ENGINE.legacyAppNames];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FIRST_PARTY_HARNESS,
+  FIRST_PARTY_HARNESS_ENGINE,
+  FIRST_PARTY_HARNESS_ENV,
+  FIRST_PARTY_HARNESS_FEED_ORIGIN,
+  FIRST_PARTY_HARNESS_PROVIDER,
+  advertisesSessionCapability,
+  canonicalArtifactHarnessProvider,
+  canonicalExecutionEnvironment,
+  canonicalHarnessProvider,
+  canonicalSessionCapability,
+  firstPartyHarnessArtifactSpellings,
+  firstPartyHarnessBinaryName,
+  firstPartyHarnessBinaryNames,
+  firstPartyHarnessCapabilities,
+  firstPartyHarnessCapability,
+  firstPartyHarnessDefaultFeedBase,
+  firstPartyHarnessEngineEnvEntries,
+  firstPartyHarnessEngineEnvNames,
+  firstPartyHarnessEngineHomeDirnames,
+  firstPartyHarnessEngineProjectDirectories,
+  firstPartyHarnessEnvironment,
+  firstPartyHarnessEnvironments,
+  firstPartyHarnessFeedPrefix,
+  firstPartyHarnessFeedPrefixes,
+  firstPartyHarnessHomeDirname,
+  firstPartyHarnessManifestFile,
+  firstPartyHarnessSpellings,
+  firstPartyHarnessStagingPrefix,
+  firstPartyHarnessWireCapability,
+  harnessProviderSpellings,
+  isFirstPartyHarnessCapability,
+  isFirstPartyHarnessEnvironment,
+  isFirstPartyHarnessProvider,
+  isSameHarnessProvider,
+  readFirstPartyHarnessEngineEnv,
+  readFirstPartyHarnessEnv,
+  wireHarnessProvider
+});