@tangle-network/agent-app 0.43.47 → 0.43.49

package/dist/chunk-E7QYOOON.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/harness/index.ts"],"sourcesContent":["/**\n * Coding-agent harness selection — taxonomy, coercion, and the session-lock invariant.\n *\n * A \"harness\" is the coding-agent CLI a sandbox drives (opencode / codex /\n * claude-code / …). The shell governs WHICH harness a chat session uses and\n * enforces that a session is LOCKED to the harness it started with — the model\n * may change mid-session, the harness may not (swapping it mid-session would\n * orphan the session's running agent state). Every product otherwise hand-rolls\n * this and hard-codes a single harness; this is the one place the rule lives.\n *\n * Substrate-free: the harness list mirrors the sandbox SDK's `BackendType` as a\n * plain string union (no sandbox dependency). The consumer owns storage — which\n * harness a workspace defaults to, which one a session locked — and maps the\n * resolved value onto the SDK's `backend.type`.\n *\n * Harness↔model COMPATIBILITY (which models a harness can run, snapping) is NOT defined here — it\n * comes from `@tangle-network/agent-interface`, the single source of truth shared with the\n * sandbox-ui pickers and the cli-bridge backends. This module owns the harness TAXONOMY + the\n * session lock.\n */\n\nimport {\n  harnessSupportsModel,\n  modelProvider,\n  preferredHarnessForModel,\n  snapHarnessToModel as aiSnapHarnessToModel,\n  snapModelToHarness as aiSnapModelToHarness,\n  type HarnessType,\n} from '@tangle-network/agent-interface'\n\n/** The known coding-agent backends. Mirrors `@tangle-network/sandbox`'s\n *  `BackendType`; kept structural so this module needs no sandbox dependency. */\nexport const KNOWN_HARNESSES = [\n  'opencode',\n  'claude-code',\n  'kimi-code',\n  'codex',\n  'amp',\n  'factory-droids',\n  'pi',\n  'hermes',\n  'forge',\n  'openclaw',\n  'acp',\n  'cursor',\n  'cli-base',\n] as const\n\nexport type Harness = (typeof KNOWN_HARNESSES)[number]\n\nexport const DEFAULT_HARNESS: Harness = 'opencode'\n\nconst HARNESS_SET: ReadonlySet<string> = new Set(KNOWN_HARNESSES)\n\nexport function isHarness(value: unknown): value is Harness {\n  return typeof value === 'string' && HARNESS_SET.has(value)\n}\n\n/** Coerce an arbitrary value to a known harness, falling back (default `opencode`). */\nexport function coerceHarness(value: unknown, fallback: Harness = DEFAULT_HARNESS): Harness {\n  return isHarness(value) ? value : fallback\n}\n\nexport interface ResolveSessionHarnessInput {\n  /** The harness already locked to this session (recorded at its first turn). */\n  sessionHarness?: unknown\n  /** The harness requested now — a new session's choice, or a turn's attempt to switch. */\n  requested?: unknown\n  /** The workspace's default harness, used only when starting a fresh session. */\n  workspaceDefault?: unknown\n  /** Final fallback when nothing else resolves (default `opencode`). */\n  fallback?: Harness\n}\n\nexport interface ResolvedSessionHarness {\n  /** The harness to actually run — the locked one when the session already has it. */\n  harness: Harness\n  /** True when the session already had a locked harness (this turn did not pick it). */\n  locked: boolean\n  /** True when `requested` differs from the locked harness — a forbidden mid-session\n   *  swap the caller should reject or warn on. The lock always wins regardless. */\n  swapAttempted: boolean\n}\n\n/**\n * Resolve the harness for a turn, enforcing the session lock.\n *\n * - **Session already started** (`sessionHarness` is a known harness): that harness\n *   wins (`locked: true`); a differing `requested` sets `swapAttempted` so the caller\n *   can reject the swap. The model is a separate per-turn concern and is unaffected.\n * - **Fresh session**: pick `requested → workspaceDefault → fallback`. The caller\n *   persists the result as the session's lock for every subsequent turn.\n */\nexport function resolveSessionHarness(input: ResolveSessionHarnessInput = {}): ResolvedSessionHarness {\n  const fallback = input.fallback ?? DEFAULT_HARNESS\n  if (isHarness(input.sessionHarness)) {\n    const locked = input.sessionHarness\n    const swapAttempted = isHarness(input.requested) && input.requested !== locked\n    return { harness: locked, locked: true, swapAttempted }\n  }\n  const harness = coerceHarness(input.requested, coerceHarness(input.workspaceDefault, fallback))\n  return { harness, locked: false, swapAttempted: false }\n}\n\n/**\n * Harness ↔ model compatibility + snapping — delegated to `@tangle-network/agent-interface`.\n *\n * agent-app's `Harness` taxonomy is a superset of agent-interface's `HarnessType` (it carries\n * `forge`/`cursor`, which agent-interface doesn't list). Those extra runners have no provider lock\n * there, so they resolve as router-backed (any model) — the correct behavior — which makes the\n * `as HarnessType` casts safe. The snap helpers only ever return a vendor-locked harness or\n * `opencode`, all of which are valid `Harness` values.\n */\n\nexport { modelProvider }\n\n/** Provider-less ids (sentinels like \"default\", or a session's own config) are\n *  compatible everywhere — every harness honors its own configuration. */\nexport function isModelCompatibleWithHarness(harness: Harness, modelId: string): boolean {\n  return harnessSupportsModel(harness as HarnessType, modelId)\n}\n\n/** Keep `modelId` when the harness can run it; else the harness's best compatible\n *  catalog id (preferred patterns in order, highest version). When nothing in the\n *  catalog fits, return the original so the caller sees the incompatibility. */\nexport function snapModelToHarness(harness: Harness, modelId: string, canonicalIds: readonly string[]): string {\n  return aiSnapModelToHarness(harness as HarnessType, modelId, canonicalIds)\n}\n\n/** Keep the harness when it can run `modelId`; else the model's native harness\n *  (anthropic → claude-code, openai → codex, moonshot → kimi-code), falling back to opencode. */\nexport function snapHarnessToModel(harness: Harness, modelId: string): Harness {\n  return aiSnapHarnessToModel(harness as HarnessType, modelId) as Harness\n}\n\n/** Fail-loud server guard: throw when a harness is asked to run a model it can't.\n *  Call before dispatching a sandbox turn so a bypassed UI can't reach the sidecar\n *  with an incompatible pair. */\nexport function assertHarnessModelCompatible(harness: Harness, modelId: string): void {\n  if (!isModelCompatibleWithHarness(harness, modelId)) {\n    const provider = modelProvider(modelId)\n    const native = preferredHarnessForModel(modelId)\n    throw new Error(\n      `Harness \"${harness}\" cannot run model \"${modelId}\" (provider \"${provider}\"). ` +\n        `Use ${native ?? 'a router-backed harness (opencode)'} or an allowed model.`,\n    )\n  }\n}\n"],"mappings":";AAqBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA,sBAAsB;AAAA,EACtB,sBAAsB;AAAA,OAEjB;AAIA,IAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIO,IAAM,kBAA2B;AAExC,IAAM,cAAmC,IAAI,IAAI,eAAe;AAEzD,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU,YAAY,YAAY,IAAI,KAAK;AAC3D;AAGO,SAAS,cAAc,OAAgB,WAAoB,iBAA0B;AAC1F,SAAO,UAAU,KAAK,IAAI,QAAQ;AACpC;AAgCO,SAAS,sBAAsB,QAAoC,CAAC,GAA2B;AACpG,QAAM,WAAW,MAAM,YAAY;AACnC,MAAI,UAAU,MAAM,cAAc,GAAG;AACnC,UAAM,SAAS,MAAM;AACrB,UAAM,gBAAgB,UAAU,MAAM,SAAS,KAAK,MAAM,cAAc;AACxE,WAAO,EAAE,SAAS,QAAQ,QAAQ,MAAM,cAAc;AAAA,EACxD;AACA,QAAM,UAAU,cAAc,MAAM,WAAW,cAAc,MAAM,kBAAkB,QAAQ,CAAC;AAC9F,SAAO,EAAE,SAAS,QAAQ,OAAO,eAAe,MAAM;AACxD;AAgBO,SAAS,6BAA6B,SAAkB,SAA0B;AACvF,SAAO,qBAAqB,SAAwB,OAAO;AAC7D;AAKO,SAAS,mBAAmB,SAAkB,SAAiB,cAAyC;AAC7G,SAAO,qBAAqB,SAAwB,SAAS,YAAY;AAC3E;AAIO,SAAS,mBAAmB,SAAkB,SAA0B;AAC7E,SAAO,qBAAqB,SAAwB,OAAO;AAC7D;AAKO,SAAS,6BAA6B,SAAkB,SAAuB;AACpF,MAAI,CAAC,6BAA6B,SAAS,OAAO,GAAG;AACnD,UAAM,WAAW,cAAc,OAAO;AACtC,UAAM,SAAS,yBAAyB,OAAO;AAC/C,UAAM,IAAI;AAAA,MACR,YAAY,OAAO,uBAAuB,OAAO,gBAAgB,QAAQ,WAChE,UAAU,oCAAoC;AAAA,IACzD;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-KOG473C4.js

@@ -1,132 +0,0 @@
-// src/skills/index.ts
-function inlineResource(name, content) {
-  return { kind: "inline", name, content };
-}
-function skillMountPath(id) {
-  return `~/.claude/skills/${id}/SKILL.md`;
-}
-function normalizeKey(key, anchor) {
-  const marker = `${anchor}/`;
-  const at = key.lastIndexOf(marker);
-  if (at >= 0) return key.slice(at);
-  return key.startsWith("./") ? key.slice(2) : key;
-}
-function toCorpusId(normalizedKey, anchor) {
-  const nested = normalizedKey.match(new RegExp(`${anchor}/([^/]+)/SKILL\\.md$`));
-  if (nested) return nested[1];
-  const flat = normalizedKey.match(new RegExp(`${anchor}/(.+)\\.md$`));
-  if (flat) return flat[1];
-  return normalizedKey;
-}
-function nodeBuiltins() {
-  const getBuiltin = globalThis.process?.getBuiltinModule;
-  if (typeof getBuiltin !== "function") return void 0;
-  return {
-    fs: getBuiltin("node:fs"),
-    path: getBuiltin("node:path"),
-    url: getBuiltin("node:url")
-  };
-}
-function fsWalkFlat(builtins, root) {
-  const { fs, path } = builtins;
-  const out = {};
-  if (!fs.existsSync(root)) return out;
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && entry.name.endsWith(".md")) out[full] = fs.readFileSync(full, "utf8");
-    }
-  };
-  walk(root);
-  return out;
-}
-function fsWalkNested(builtins, root) {
-  const { fs, path } = builtins;
-  const out = {};
-  if (!fs.existsSync(root)) return out;
-  let entries;
-  try {
-    entries = fs.readdirSync(root, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = path.join(root, entry.name, "SKILL.md");
-    if (!fs.existsSync(skillFile)) continue;
-    out[skillFile] = fs.readFileSync(skillFile, "utf8");
-  }
-  return out;
-}
-function resolveFsBase(builtins, fsBaseDir, importMetaUrl) {
-  const { path, url } = builtins;
-  if (path.isAbsolute(fsBaseDir)) return fsBaseDir;
-  const here = importMetaUrl ? path.dirname(url.fileURLToPath(importMetaUrl)) : process.cwd();
-  return path.join(here, fsBaseDir);
-}
-function loadMarkdownCorpus(options, importMetaUrl) {
-  const { anchor, globModules, fsBaseDir, fsLayout = "flat", skip } = options;
-  let modules;
-  let source;
-  if (globModules && Object.keys(globModules).length > 0) {
-    modules = globModules;
-    source = "vite";
-  } else {
-    const builtins = nodeBuiltins();
-    if (builtins && fsBaseDir) {
-      const root = resolveFsBase(builtins, fsBaseDir, importMetaUrl);
-      modules = fsLayout === "nested" ? fsWalkNested(builtins, root) : fsWalkFlat(builtins, root);
-      source = Object.keys(modules).length > 0 ? "fs" : "empty";
-    } else {
-      modules = {};
-      source = "empty";
-    }
-  }
-  const entries = [];
-  for (const [rawKey, content] of Object.entries(modules)) {
-    if (typeof content !== "string") continue;
-    const key = normalizeKey(rawKey, anchor);
-    if (skip && skip(key)) continue;
-    entries.push({ id: toCorpusId(key, anchor), key, content });
-  }
-  entries.sort((a, b) => a.id.localeCompare(b.id));
-  return { source, entries };
-}
-function corpusSkills(corpus, anchor) {
-  return corpus.map(
-    (entry) => ({
-      path: `${anchor}/${entry.id}.md`,
-      resource: inlineResource(`${anchor}-${entry.id}`, entry.content)
-    })
-  ).sort((a, b) => a.path.localeCompare(b.path));
-}
-function registrySkills(registry, tier = "free") {
-  return registry.filter((s) => s.tier === tier).map(
-    (s) => ({
-      path: skillMountPath(s.id),
-      resource: inlineResource(s.id, s.skillMd)
-    })
-  ).sort((a, b) => a.path.localeCompare(b.path));
-}
-function composeShellResources(input) {
-  const { skills = [], knowledge = [], evolvable = [], registry = [], predicate } = input;
-  const composed = [...skills, ...knowledge, ...evolvable, ...registry];
-  return predicate ? composed.filter(predicate) : composed;
-}
-
-export {
-  skillMountPath,
-  loadMarkdownCorpus,
-  corpusSkills,
-  registrySkills,
-  composeShellResources
-};
-//# sourceMappingURL=chunk-KOG473C4.js.map

package/dist/chunk-KOG473C4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/skills/index.ts"],"sourcesContent":["/**\n * Unified skill + corpus mounter for agent products.\n *\n * Every agent product hand-rolls the same two file-mount systems and then\n * drifts on the seams between them. (1) An ALWAYS-MOUNTED markdown corpus —\n * (`skills/<slug>/SKILL.md`, `doctrine` and `knowledge` markdown trees) — discovered\n * by a Vite `?raw` glob in the Worker bundle and by Node `fs` under the eval\n * CLI, then projected into `resources.files`. (2) A TIER-GATED installable\n * registry — a hand-authored array of `SkillEntry` whose free tier mounts at\n * the harness skill-discovery path and whose paid tier is installed on demand.\n * Both ride the same `resources.files` channel but use different provenance\n * (file-backed vs inline), different mount paths (relative corpus path vs\n * `~/.claude/skills/<id>/SKILL.md`), and different selection rules. This module\n * makes both DATA: a corpus loader that accepts a Vite glob-result map (or an\n * fs fallback), a registry adapter that tier-gates, and a single\n * `composeShellResources` that projects either onto the SDK file-mount shape.\n *\n * Substrate-free over storage, exact over the SDK boundary: the only inbound\n * seam is the glob-result map the consumer passes in (its call site keeps the\n * literal `import.meta.glob` Vite must static-analyze); the only outbound seam\n * is `@tangle-network/sandbox`'s `AgentProfileFileMount[]`, the exact shape the\n * agent profile's `resources.files` consumes. Node builtins are resolved lazily\n * via `process.getBuiltinModule` so a static `node:*` import never reaches the\n * Vite SSR bundle.\n */\n\nimport type { AgentProfileFileMount, AgentProfileResourceRef } from '@tangle-network/sandbox'\n\n/** Construct the inline arm of the SDK's `AgentProfileResourceRef`. Inlined here\n *  so this leaf subpath stays type-only over `@tangle-network/sandbox` — it\n *  carries no runtime dependency on the SDK, just its file-mount type contract. */\nfunction inlineResource(name: string, content: string): AgentProfileResourceRef {\n  return { kind: 'inline', name, content }\n}\n\n/** A Vite eager `?raw` glob result: glob key -> raw file body. The consumer\n *  produces this by calling `import.meta.glob('<lit>', { eager: true, query:\n *  '?raw', import: 'default' })` at its own call site — the literal must stay\n *  literal so Vite can static-analyze it; passing the result here keeps that\n *  constraint at the edge and the loader substrate-free. */\nexport type GlobModules = Record<string, string>\n\n/** One markdown document discovered from the corpus. */\nexport interface CorpusEntry {\n  /** Slug derived from the glob key (folder slug for `SKILL.md` layouts, or the\n   *  normalized relative path for flat `*.md` layouts). */\n  id: string\n  /** Glob/fs key the entry was loaded from, normalized to a stable relative\n   *  form (leading `./` and absolute prefixes stripped). */\n  key: string\n  /** Raw markdown body (including any frontmatter). */\n  content: string\n}\n\n/** A hand-authored, tier-gated installable skill. Mirrors the per-product\n *  registry entry (gtm/insurance `SkillEntry`); the runtime's certified `skill`\n *  artifact kind is unrelated. `skillMd` is the inline body — file provenance\n *  does not apply to the registry. */\nexport interface SkillEntry {\n  id: string\n  name: string\n  description: string\n  author?: { name: string; url?: string }\n  source?: string\n  category?: string\n  tags?: string[]\n  /** Gate keyword. `composeShellResources`/`registrySkills` treat `free` as\n   *  always-mounted; everything else is install-on-demand. */\n  tier: string\n  skillMd: string\n}\n\n/** Harness skill-discovery path the Claude Code / OpenCode backend reads\n *  natively. The registry mounts here; the corpus mounts at its relative path. */\nexport function skillMountPath(id: string): string {\n  return `~/.claude/skills/${id}/SKILL.md`\n}\n\n/** Strip a glob/fs key down to a stable relative form: drop a leading `./`,\n *  and for an absolute fs path keep only the tail from the last anchor segment\n *  the pattern implies. We normalize on the trailing `<dir>/.../*.md` so the\n *  Vite key (`./skills/x/SKILL.md`) and the fs key (`/abs/.../skills/x/SKILL.md`)\n *  collapse to the same value. */\nfunction normalizeKey(key: string, anchor: string): string {\n  const marker = `${anchor}/`\n  const at = key.lastIndexOf(marker)\n  if (at >= 0) return key.slice(at)\n  return key.startsWith('./') ? key.slice(2) : key\n}\n\n/** Folder-slug for a `<anchor>/<slug>/SKILL.md` layout; falls back to the\n *  normalized key (sans `<anchor>/` prefix, sans `.md`) for flat layouts. */\nfunction toCorpusId(normalizedKey: string, anchor: string): string {\n  const nested = normalizedKey.match(new RegExp(`${anchor}/([^/]+)/SKILL\\\\.md$`))\n  if (nested) return nested[1]!\n  const flat = normalizedKey.match(new RegExp(`${anchor}/(.+)\\\\.md$`))\n  if (flat) return flat[1]!\n  return normalizedKey\n}\n\n/** Resolve Node builtins lazily. `process.getBuiltinModule` (Node 22+) is\n *  absent in workerd, so this returns undefined there and the fs path is never\n *  taken — Workers always reach the loader through the Vite glob map. A static\n *  `import 'node:fs'` would break Vite SSR bundling in the consumer apps, so it\n *  is deliberately avoided. */\nfunction nodeBuiltins():\n  | { fs: typeof import('node:fs'); path: typeof import('node:path'); url: typeof import('node:url') }\n  | undefined {\n  const getBuiltin = (globalThis as { process?: { getBuiltinModule?: (id: string) => unknown } })\n    .process?.getBuiltinModule\n  if (typeof getBuiltin !== 'function') return undefined\n  return {\n    fs: getBuiltin('node:fs') as typeof import('node:fs'),\n    path: getBuiltin('node:path') as typeof import('node:path'),\n    url: getBuiltin('node:url') as typeof import('node:url'),\n  }\n}\n\n/** Options for {@link loadMarkdownCorpus}. */\nexport interface LoadCorpusOptions {\n  /** The anchor folder name that appears in both glob keys and fs paths\n   *  (`skills`, `doctrine`, `knowledge`). Used to normalize keys + derive ids. */\n  anchor: string\n  /** Vite glob-result map. When present and non-empty it is authoritative and\n   *  the fs path is skipped. Omit it (or pass an empty map) only outside Vite. */\n  globModules?: GlobModules\n  /** Absolute or `import.meta.url`-relative base dir the fs fallback walks when\n   *  `globModules` is empty. Required for the fs path to run; without it the fs\n   *  fallback returns no entries (Workers never need it). */\n  fsBaseDir?: string\n  /** Walk strategy for the fs fallback. `nested` finds `<dir>/<slug>/SKILL.md`\n   *  one level deep; `flat` recurses for every `*.md`. Default: `flat`. */\n  fsLayout?: 'nested' | 'flat'\n  /** Drop an entry by its normalized key after load. Covers the per-product\n   *  skip lists (corpus index/log files, scaffold templates, allow-lists). */\n  skip?: (normalizedKey: string) => boolean\n}\n\n/** Outcome of {@link loadMarkdownCorpus}: the entries plus which path produced\n *  them, so a caller can fail loud when both are empty rather than silently\n *  mounting nothing. */\nexport interface CorpusLoadResult {\n  source: 'vite' | 'fs' | 'empty'\n  entries: CorpusEntry[]\n}\n\nfunction fsWalkFlat(\n  builtins: NonNullable<ReturnType<typeof nodeBuiltins>>,\n  root: string,\n): GlobModules {\n  const { fs, path } = builtins\n  const out: GlobModules = {}\n  if (!fs.existsSync(root)) return out\n  const walk = (dir: string) => {\n    let entries: import('node:fs').Dirent[]\n    try {\n      entries = fs.readdirSync(dir, { withFileTypes: true })\n    } catch {\n      return\n    }\n    for (const entry of entries) {\n      if (entry.name.startsWith('.')) continue\n      const full = path.join(dir, entry.name)\n      if (entry.isDirectory()) walk(full)\n      else if (entry.isFile() && entry.name.endsWith('.md')) out[full] = fs.readFileSync(full, 'utf8')\n    }\n  }\n  walk(root)\n  return out\n}\n\nfunction fsWalkNested(\n  builtins: NonNullable<ReturnType<typeof nodeBuiltins>>,\n  root: string,\n): GlobModules {\n  const { fs, path } = builtins\n  const out: GlobModules = {}\n  if (!fs.existsSync(root)) return out\n  let entries: import('node:fs').Dirent[]\n  try {\n    entries = fs.readdirSync(root, { withFileTypes: true })\n  } catch {\n    return out\n  }\n  for (const entry of entries) {\n    if (!entry.isDirectory()) continue\n    const skillFile = path.join(root, entry.name, 'SKILL.md')\n    if (!fs.existsSync(skillFile)) continue\n    out[skillFile] = fs.readFileSync(skillFile, 'utf8')\n  }\n  return out\n}\n\n/** Resolve `fsBaseDir` against `import.meta.url` when relative-looking, so a\n *  consumer can pass a bare folder name (`'skills'`) and have it land beside\n *  the calling module. Absolute paths pass through. */\nfunction resolveFsBase(\n  builtins: NonNullable<ReturnType<typeof nodeBuiltins>>,\n  fsBaseDir: string,\n  importMetaUrl?: string,\n): string {\n  const { path, url } = builtins\n  if (path.isAbsolute(fsBaseDir)) return fsBaseDir\n  const here = importMetaUrl\n    ? path.dirname(url.fileURLToPath(importMetaUrl))\n    : process.cwd()\n  return path.join(here, fsBaseDir)\n}\n\n/**\n * Load a markdown corpus, preferring a Vite glob-result map and falling back to\n * a Node fs walk. Selection is by non-empty glob result — never an env flag.\n * Entries are normalized, optionally skip-filtered, and sorted by id for\n * determinism. The `import.meta.glob` literal stays at the CONSUMER call site\n * (passed in as `globModules`); this loader never constructs a glob.\n */\nexport function loadMarkdownCorpus(\n  options: LoadCorpusOptions,\n  importMetaUrl?: string,\n): CorpusLoadResult {\n  const { anchor, globModules, fsBaseDir, fsLayout = 'flat', skip } = options\n\n  let modules: GlobModules\n  let source: CorpusLoadResult['source']\n  if (globModules && Object.keys(globModules).length > 0) {\n    modules = globModules\n    source = 'vite'\n  } else {\n    const builtins = nodeBuiltins()\n    if (builtins && fsBaseDir) {\n      const root = resolveFsBase(builtins, fsBaseDir, importMetaUrl)\n      modules = fsLayout === 'nested' ? fsWalkNested(builtins, root) : fsWalkFlat(builtins, root)\n      source = Object.keys(modules).length > 0 ? 'fs' : 'empty'\n    } else {\n      modules = {}\n      source = 'empty'\n    }\n  }\n\n  const entries: CorpusEntry[] = []\n  for (const [rawKey, content] of Object.entries(modules)) {\n    if (typeof content !== 'string') continue\n    const key = normalizeKey(rawKey, anchor)\n    if (skip && skip(key)) continue\n    entries.push({ id: toCorpusId(key, anchor), key, content })\n  }\n  entries.sort((a, b) => a.id.localeCompare(b.id))\n  return { source, entries }\n}\n\n/** Project corpus entries onto SDK file mounts at a relative path under\n *  `<anchor>/`. Always-mounted: the corpus is the agent's baseline knowledge. */\nexport function corpusSkills(corpus: CorpusEntry[], anchor: string): AgentProfileFileMount[] {\n  return corpus\n    .map(\n      (entry) =>\n        ({\n          path: `${anchor}/${entry.id}.md`,\n          resource: inlineResource(`${anchor}-${entry.id}`, entry.content),\n        }) satisfies AgentProfileFileMount,\n    )\n    .sort((a, b) => a.path.localeCompare(b.path))\n}\n\n/** Project the registry's free-tier (or `tier`-matched) entries onto SDK file\n *  mounts at the harness skill-discovery path. Tier-gating is the registry's\n *  only selection rule — paid skills are installed on demand, not at boot. */\nexport function registrySkills(\n  registry: SkillEntry[],\n  tier: string = 'free',\n): AgentProfileFileMount[] {\n  return registry\n    .filter((s) => s.tier === tier)\n    .map(\n      (s) =>\n        ({\n          path: skillMountPath(s.id),\n          resource: inlineResource(s.id, s.skillMd),\n        }) satisfies AgentProfileFileMount,\n    )\n    .sort((a, b) => a.path.localeCompare(b.path))\n}\n\n/** Inputs to {@link composeShellResources}. Each channel is optional so a\n *  product mounts only the systems it has — corpus-only, registry-only, or\n *  both — without conflating them. */\nexport interface ComposeShellResourcesInput {\n  /** Corpus mounts (always-mounted baseline). Pass the result of\n   *  {@link corpusSkills}, or a hand-built mount list. */\n  skills?: AgentProfileFileMount[]\n  /** Knowledge-corpus mounts (a second always-mounted corpus, e.g. a domain\n   *  knowledge pack distinct from the skills corpus). */\n  knowledge?: AgentProfileFileMount[]\n  /** Evolvable / learned-guidance mounts (single-file corpora). */\n  evolvable?: AgentProfileFileMount[]\n  /** Registry mounts (tier-gated). Pass the result of {@link registrySkills}. */\n  registry?: AgentProfileFileMount[]\n  /** Final skip filter applied to the composed mount list by mount `path`. */\n  predicate?: (mount: AgentProfileFileMount) => boolean\n}\n\n/**\n * Compose every mount channel into one `resources.files`-ready array. Corpus\n * channels come first (baseline), the tier-gated registry last (so a registry\n * entry can override a corpus entry that mounts at the same path). The result\n * is exactly `AgentProfileFileMount[]` — assign it straight into\n * `profile.resources.files` with no cast.\n */\nexport function composeShellResources(input: ComposeShellResourcesInput): AgentProfileFileMount[] {\n  const { skills = [], knowledge = [], evolvable = [], registry = [], predicate } = input\n  const composed = [...skills, ...knowledge, ...evolvable, ...registry]\n  return predicate ? composed.filter(predicate) : composed\n}\n"],"mappings":"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","names":[]}