@tangle-network/agent-app 0.43.48 → 0.43.49

package/dist/skills/index.d.ts

@@ -1,4 +1,4 @@
-import { AgentProfileFileMount } from '@tangle-network/sandbox';
+import { AgentProfileFileMount, AgentProfileResourceRef } from '@tangle-network/sandbox';
 
 /**
  * Unified skill + corpus mounter for agent products.
@@ -17,13 +17,30 @@ import { AgentProfileFileMount } from '@tangle-network/sandbox';
  * fs fallback), a registry adapter that tier-gates, and a single
  * `composeShellResources` that projects either onto the SDK file-mount shape.
  *
+ * A THIRD surface lives alongside those two: adoptable `SkillEntry`s sourced
+ * from `SKILL.md` frontmatter rather than hand-authored fields.
+ * `parseSkillFrontmatter` is the ONE frontmatter parser (hand-rolled, no YAML
+ * dependency — fail loud on a malformed block rather than silently mis-reading
+ * a field); `skillEntryFromMarkdown`/`parseCorpusSkills` turn raw markdown into
+ * `SkillEntry`s. From there a skill reaches the agent by one of two DELIVERY
+ * MODES: `inline` renders the skill body straight into the system prompt (every
+ * harness can read it, at prompt-byte cost), or `mounted` projects it onto the
+ * typed `resources.skills` channel (`AgentProfileResourceRef[]`) plus an index
+ * section that just names the file, and lets the platform materializer place it
+ * at the harness-native skill dir. `composeSkills` builds either shape;
+ * `mergeComposedSkills` combines batches and throws (via
+ * `assertSkillDeliveryDisjoint`) on a skill accidentally delivered both
+ * ways. Picking WHICH harnesses can take `mounted` delivery is platform-bound
+ * (see `@tangle-network/agent-app/skills-placement`) and deliberately kept out
+ * of this substrate-free module.
+ *
  * Substrate-free over storage, exact over the SDK boundary: the only inbound
  * seam is the glob-result map the consumer passes in (its call site keeps the
  * literal `import.meta.glob` Vite must static-analyze); the only outbound seam
- * is `@tangle-network/sandbox`'s `AgentProfileFileMount[]`, the exact shape the
- * agent profile's `resources.files` consumes. Node builtins are resolved lazily
- * via `process.getBuiltinModule` so a static `node:*` import never reaches the
- * Vite SSR bundle.
+ * is `@tangle-network/sandbox`'s `AgentProfileFileMount[]`/`AgentProfileResourceRef[]`,
+ * the exact shapes `resources.files`/`resources.skills` consume. Node builtins
+ * are resolved lazily via `process.getBuiltinModule` so a static `node:*`
+ * import never reaches the Vite SSR bundle.
  */
 
 /** A Vite eager `?raw` glob result: glob key -> raw file body. The consumer
@@ -63,8 +80,18 @@ interface SkillEntry {
     tier: string;
     skillMd: string;
 }
-/** Harness skill-discovery path the Claude Code / OpenCode backend reads
- *  natively. The registry mounts here; the corpus mounts at its relative path. */
+/** Harness skill-discovery path the Claude Code backend reads natively. The
+ *  registry mounts here; the corpus mounts at its relative path.
+ *
+ *  @deprecated Hardcodes the claude-code path (`~/.claude/skills/<id>/SKILL.md`).
+ *  It is NOT a path other harnesses read — OpenCode discovers `.opencode/skills`,
+ *  not `~/.claude/skills` (the doc comment here previously claimed otherwise);
+ *  codex, kimi-code, and the rest each have their own dir or none at all. Use
+ *  {@link skillRefs} to put a skill on the typed `resources.skills` channel and
+ *  let the platform materializer place it correctly, or resolve the
+ *  harness-native dir directly via `@tangle-network/agent-app/skills-placement`.
+ *  Kept only for the pre-existing `registrySkills`/`userSkillMounts` callers;
+ *  do not add new call sites. */
 declare function skillMountPath(id: string): string;
 /** Options for {@link loadMarkdownCorpus}. */
 interface LoadCorpusOptions {
@@ -132,5 +159,153 @@ interface ComposeShellResourcesInput {
  * `profile.resources.files` with no cast.
  */
 declare function composeShellResources(input: ComposeShellResourcesInput): AgentProfileFileMount[];
+/** Fields a `SKILL.md` frontmatter block may declare. All optional — absent
+ *  frontmatter (or an absent field within it) is legal; callers fill defaults
+ *  (see {@link skillEntryFromMarkdown}). */
+interface SkillFrontmatter {
+    id?: string;
+    name?: string;
+    description?: string;
+    author?: {
+        name: string;
+        url?: string;
+    };
+    source?: string;
+    category?: string;
+    tags?: string[];
+    tier?: string;
+}
+/** The result of {@link parseSkillFrontmatter}: the parsed fields, the body
+ *  with the frontmatter block stripped, and the original untouched text. */
+interface ParsedSkill {
+    frontmatter: SkillFrontmatter;
+    body: string;
+    raw: string;
+}
+/** THE one `SKILL.md` frontmatter parser — hand-rolled, no YAML dependency.
+ *
+ * Absent frontmatter (text does not open with a `---` delimiter line) is
+ * legal: returns `{frontmatter: {}, body: raw, raw}`. An OPENED block with no
+ * closing `---` is truncated input and throws. Inside the block: scalar
+ * `key: value` lines (value optionally double-quoted, decoded via
+ * `JSON.parse`); a nested `author:` block whose indented `name:`/`url:` lines
+ * are the only children it accepts; `tags:` as an inline `[a, b]` list or as
+ * an indented `- item` block. Unknown scalar keys are ignored (forward-compat)
+ * — but a line that matches NONE of these shapes (no colon, an orphaned
+ * indented line, a bad dash) throws naming the offending line. Silently
+ * mis-parsed metadata is the bug class this parser exists to kill; an
+ * unrecognized shape is never guessed at.
+ */
+declare function parseSkillFrontmatter(raw: string): ParsedSkill;
+/** Build a {@link SkillEntry} from a raw `SKILL.md` body. `id` comes from
+ *  frontmatter, falling back to `fallbackId` (typically the corpus entry's
+ *  slug/filename); neither present throws. `name` defaults to `id`,
+ *  `description` to `''`, `tier` to `'free'`. `skillMd` is always the
+ *  untouched `raw` input — the full file, frontmatter included, is what a
+ *  `mounted` delivery writes to disk and what `renderInlineSkills` strips per
+ *  render. */
+declare function skillEntryFromMarkdown(raw: string, fallbackId?: string): SkillEntry;
+/** Map a loaded corpus (see {@link loadMarkdownCorpus}) onto `SkillEntry`s,
+ *  using each entry's `id` as the fallback when its `SKILL.md` carries no
+ *  frontmatter `id` of its own. */
+declare function parseCorpusSkills(corpus: CorpusEntry[]): SkillEntry[];
+/** Project skills onto the typed `resources.skills` channel
+ *  (`AgentProfileResourceRef[]`), tier-filtered (same `s.tier === tier`
+ *  semantics as {@link registrySkills}) when `opts.tier` is given, sorted by
+ *  id for determinism. `ref.name` MUST be the skill id: the platform
+ *  materializer writes each ref to `${skillDir}/${name}/SKILL.md`. */
+declare function skillRefs(skills: SkillEntry[], opts?: {
+    tier?: string;
+}): AgentProfileResourceRef[];
+/** Inputs to {@link renderInlineSkills}. */
+interface RenderInlineSkillsInput {
+    skills: SkillEntry[];
+    /** Section heading. Default `'## Skills'`. */
+    heading?: string;
+    /** Tier filter — same semantics as {@link skillRefs}. */
+    tier?: string;
+    /** Per-skill body renderer. Default strips frontmatter and emits
+     *  `### <name>\n\n<body>`. */
+    body?: (skill: SkillEntry) => string;
+}
+/**
+ * Render every (tier-filtered) skill's full body inline into the prompt — the
+ * `inline` delivery mode. Returns `''` when no skill survives the filter, else
+ * a section starting `\n\n<heading>\n\n` with each skill's body joined by
+ * `\n\n` — the same "already carries its own leading `\n\n`" shape
+ * `assembleSystemPrompt` expects from every section it concatenates.
+ */
+declare function renderInlineSkills(input: RenderInlineSkillsInput): string;
+/** Inputs to {@link renderSkillIndex}. */
+interface RenderSkillIndexInput {
+    skills: SkillEntry[];
+    /** cwd-relative directory the skills are mounted under (e.g.
+     *  `.opencode/skills`) — named in each index line so the agent knows where
+     *  to read the full `SKILL.md`. */
+    skillDir: string;
+    /** Section heading. Default `'## Skills'`. */
+    heading?: string;
+    /** Tier filter — same semantics as {@link skillRefs}. */
+    tier?: string;
+}
+/**
+ * Render a one-line-per-skill INDEX (name, description, and the path to read
+ * the full body) — the `mounted` delivery mode's prompt section, paired with
+ * {@link skillRefs} putting the actual files on `resources.skills`. Same
+ * empty/section shape as {@link renderInlineSkills}.
+ */
+declare function renderSkillIndex(input: RenderSkillIndexInput): string;
+/** How a skill reaches the agent: `inline` renders its full body into the
+ *  system prompt; `mounted` puts it on the typed `resources.skills` channel
+ *  and renders only an index line. */
+type SkillDeliveryMode = 'inline' | 'mounted';
+/** The output of {@link composeSkills}: the refs to attach to
+ *  `resources.skills` (empty for `inline`) and the prompt section to fold into
+ *  the system prompt (already carries its own leading `\n\n`, or `''`).
+ *  `inlineIds`/`mountedIds` record which (tier-filtered) skills were delivered
+ *  in each mode so {@link mergeComposedSkills} can enforce the modes stay
+ *  disjoint when batches are combined. */
+interface ComposedSkills {
+    refs: AgentProfileResourceRef[];
+    promptSection: string;
+    inlineIds: string[];
+    mountedIds: string[];
+}
+/** Inputs to {@link composeSkills}. */
+interface ComposeSkillsInput {
+    skills: SkillEntry[];
+    mode: SkillDeliveryMode;
+    tier?: string;
+    heading?: string;
+    /** REQUIRED (non-null) for `mode: 'mounted'` — the cwd-relative skill dir
+     *  the harness reads. Resolve it with `@tangle-network/agent-app/skills-placement`
+     *  rather than hardcoding it; omitted or `null` throws. */
+    skillDir?: string | null;
+}
+/**
+ * Build the {@link ComposedSkills} for one delivery mode. `inline` never
+ * touches `resources.skills` — `refs` is always `[]`. `mounted` requires a
+ * non-null `skillDir` (the harness must have a native skill-discovery
+ * directory); a null/absent one throws rather than silently falling back, so
+ * the caller resolves the fallback deliberately (see
+ * `@tangle-network/agent-app/skills-placement`'s `composeSkillsForHarness`,
+ * which does exactly that).
+ */
+declare function composeSkills(input: ComposeSkillsInput): ComposedSkills;
+/** Throw when the same skill id is delivered both `inline` and `mounted` —
+ *  the agent would see it twice (once in the prompt body, once as a mounted
+ *  file it's told to go read), doubling prompt bytes and inviting drift
+ *  between the two copies. Lists every offending id in the message. */
+declare function assertSkillDeliveryDisjoint(inlineIds: Iterable<string>, mountedIds: Iterable<string>): void;
+/**
+ * Combine multiple {@link ComposedSkills} batches (e.g. a built-in corpus and
+ * an installed catalog) into one, concatenating refs and prompt sections in
+ * batch order. This is the seam where inline and mounted deliveries can first
+ * collide, so it applies {@link assertSkillDeliveryDisjoint} — a skill id
+ * delivered inline by one batch and mounted by another throws instead of
+ * reaching the agent twice. Merge through this rather than spreading batch
+ * fields by hand.
+ */
+declare function mergeComposedSkills(batches: ComposedSkills[]): ComposedSkills;
 
-export { type ComposeShellResourcesInput, type CorpusEntry, type CorpusLoadResult, type GlobModules, type LoadCorpusOptions, type SkillEntry, composeShellResources, corpusSkills, loadMarkdownCorpus, registrySkills, skillMountPath };
+export { type ComposeShellResourcesInput, type ComposeSkillsInput, type ComposedSkills, type CorpusEntry, type CorpusLoadResult, type GlobModules, type LoadCorpusOptions, type ParsedSkill, type RenderInlineSkillsInput, type RenderSkillIndexInput, type SkillDeliveryMode, type SkillEntry, type SkillFrontmatter, assertSkillDeliveryDisjoint, composeShellResources, composeSkills, corpusSkills, loadMarkdownCorpus, mergeComposedSkills, parseCorpusSkills, parseSkillFrontmatter, registrySkills, renderInlineSkills, renderSkillIndex, skillEntryFromMarkdown, skillMountPath, skillRefs };

package/dist/skills/index.js

@@ -1,15 +1,33 @@
 import {
+  assertSkillDeliveryDisjoint,
   composeShellResources,
+  composeSkills,
   corpusSkills,
   loadMarkdownCorpus,
+  mergeComposedSkills,
+  parseCorpusSkills,
+  parseSkillFrontmatter,
   registrySkills,
-  skillMountPath
-} from "../chunk-KOG473C4.js";
+  renderInlineSkills,
+  renderSkillIndex,
+  skillEntryFromMarkdown,
+  skillMountPath,
+  skillRefs
+} from "../chunk-NBSBRZ6F.js";
 export {
+  assertSkillDeliveryDisjoint,
   composeShellResources,
+  composeSkills,
   corpusSkills,
   loadMarkdownCorpus,
+  mergeComposedSkills,
+  parseCorpusSkills,
+  parseSkillFrontmatter,
   registrySkills,
-  skillMountPath
+  renderInlineSkills,
+  renderSkillIndex,
+  skillEntryFromMarkdown,
+  skillMountPath,
+  skillRefs
 };
 //# sourceMappingURL=index.js.map

package/dist/skills-placement/index.d.ts

@@ -0,0 +1,52 @@
+import { Harness } from '../harness/index.js';
+import { SkillEntry, ComposedSkills } from '../skills/index.js';
+import '@tangle-network/agent-interface';
+import '@tangle-network/sandbox';
+
+/**
+ * Harness-native skill directory resolution — the one place agent-app binds
+ * to the platform's authoritative per-harness skill-dir map.
+ *
+ * `../skills` renders skill CONTENT (parse, tier-filter, `inline`/`mounted`
+ * delivery) but deliberately stops short of naming WHICH cwd path a `mounted`
+ * skill lands at on a given harness — that mapping is owned by the platform
+ * materializer (`@tangle-network/agent-profile-materialize`'s
+ * `skillDirForHarness`), not by app-shell. This subpath exists so no product
+ * — and no other agent-app module — ever writes a skill path literal
+ * (`~/.claude/skills/...`, `.opencode/skills`, ...) of its own; it bridges
+ * agent-app's `Harness` taxonomy onto the platform's `HarnessId` and asks the
+ * platform for the answer.
+ *
+ * Requires the OPTIONAL peer `@tangle-network/agent-profile-materialize`.
+ * Products that don't install it simply don't import this subpath — every
+ * other agent-app skills surface (`../skills`, `ProfileChannels.skillRefs`)
+ * works without it, falling back to `inline` delivery.
+ */
+
+/** Resolve the cwd-relative skill dir `resources.skills` refs materialize
+ *  into on `harness` — via the platform's `skillDirForHarness`. `null` when
+ *  `harness` isn't bridged (see {@link HARNESS_BRIDGE}) or when the platform
+ *  itself has no cwd skill primitive for it (e.g. `hermes`, user-dir-only). */
+declare function resolveSkillDir(harness: Harness): string | null;
+/** Filter `harnesses` down to those with no mounted skill dir (deduped,
+ *  first-seen order preserved) — the set that must fall back to `inline`
+ *  delivery, or that a caller should warn about before offering "mounted"
+ *  install UX. */
+declare function unsupportedSkillHarnesses(harnesses: Iterable<Harness>): Harness[];
+/** Inputs to {@link composeSkillsForHarness}. */
+interface ComposeSkillsForHarnessInput {
+    skills: SkillEntry[];
+    harness: Harness;
+    tier?: string;
+    heading?: string;
+}
+/**
+ * Compose {@link ComposedSkills} for `harness`: `mounted` delivery when the
+ * platform names a cwd skill dir for it, `inline` delivery (the automatic
+ * fallback that keeps every skill available on every harness) otherwise. The
+ * one function a product calls instead of hand-checking `resolveSkillDir`
+ * and branching between {@link composeSkills}'s two modes itself.
+ */
+declare function composeSkillsForHarness(input: ComposeSkillsForHarnessInput): ComposedSkills;
+
+export { type ComposeSkillsForHarnessInput, ComposedSkills, SkillEntry, composeSkillsForHarness, resolveSkillDir, unsupportedSkillHarnesses };

package/dist/skills-placement/index.js

@@ -0,0 +1,44 @@
+import {
+  composeSkills
+} from "../chunk-NBSBRZ6F.js";
+
+// src/skills-placement/index.ts
+import { skillDirForHarness } from "@tangle-network/agent-profile-materialize";
+var HARNESS_BRIDGE = {
+  opencode: "opencode",
+  "claude-code": "claude-code",
+  nanoclaw: "nanoclaw",
+  "kimi-code": "kimi-code",
+  codex: "codex",
+  pi: "pi",
+  hermes: "hermes",
+  openclaw: "openclaw"
+};
+function resolveSkillDir(harness) {
+  const bridged = HARNESS_BRIDGE[harness];
+  if (!bridged) return null;
+  return skillDirForHarness(bridged);
+}
+function unsupportedSkillHarnesses(harnesses) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const harness of harnesses) {
+    if (resolveSkillDir(harness) !== null) continue;
+    if (seen.has(harness)) continue;
+    seen.add(harness);
+    out.push(harness);
+  }
+  return out;
+}
+function composeSkillsForHarness(input) {
+  const { skills, harness, tier, heading } = input;
+  const skillDir = resolveSkillDir(harness);
+  if (skillDir) return composeSkills({ skills, mode: "mounted", skillDir, tier, heading });
+  return composeSkills({ skills, mode: "inline", tier, heading });
+}
+export {
+  composeSkillsForHarness,
+  resolveSkillDir,
+  unsupportedSkillHarnesses
+};
+//# sourceMappingURL=index.js.map

package/dist/skills-placement/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/skills-placement/index.ts"],"sourcesContent":["/**\n * Harness-native skill directory resolution — the one place agent-app binds\n * to the platform's authoritative per-harness skill-dir map.\n *\n * `../skills` renders skill CONTENT (parse, tier-filter, `inline`/`mounted`\n * delivery) but deliberately stops short of naming WHICH cwd path a `mounted`\n * skill lands at on a given harness — that mapping is owned by the platform\n * materializer (`@tangle-network/agent-profile-materialize`'s\n * `skillDirForHarness`), not by app-shell. This subpath exists so no product\n * — and no other agent-app module — ever writes a skill path literal\n * (`~/.claude/skills/...`, `.opencode/skills`, ...) of its own; it bridges\n * agent-app's `Harness` taxonomy onto the platform's `HarnessId` and asks the\n * platform for the answer.\n *\n * Requires the OPTIONAL peer `@tangle-network/agent-profile-materialize`.\n * Products that don't install it simply don't import this subpath — every\n * other agent-app skills surface (`../skills`, `ProfileChannels.skillRefs`)\n * works without it, falling back to `inline` delivery.\n */\n\nimport type { Harness } from '../harness/index'\nimport { skillDirForHarness, type HarnessId } from '@tangle-network/agent-profile-materialize'\nimport { composeSkills, type ComposedSkills, type SkillEntry } from '../skills/index'\n\n/** agent-app `Harness` -> platform `HarnessId`, identity-mapped for exactly\n *  the harnesses the platform map covers. Harnesses absent here (`amp`,\n *  `factory-droids`, `forge`, `acp`, `cursor`, `cli-base`) resolve to `null` —\n *  callers fall back to `inline` delivery. `cursor`'s adapter supports\n *  `resources.skills` bespokely but isn't in the platform map yet; treating it\n *  as unbridged (inline fallback) is the safe posture until the map covers\n *  it, rather than guessing its cwd skill dir here. */\nconst HARNESS_BRIDGE: Partial<Record<Harness, HarnessId>> = {\n  opencode: 'opencode',\n  'claude-code': 'claude-code',\n  nanoclaw: 'nanoclaw',\n  'kimi-code': 'kimi-code',\n  codex: 'codex',\n  pi: 'pi',\n  hermes: 'hermes',\n  openclaw: 'openclaw',\n}\n\n/** Resolve the cwd-relative skill dir `resources.skills` refs materialize\n *  into on `harness` — via the platform's `skillDirForHarness`. `null` when\n *  `harness` isn't bridged (see {@link HARNESS_BRIDGE}) or when the platform\n *  itself has no cwd skill primitive for it (e.g. `hermes`, user-dir-only). */\nexport function resolveSkillDir(harness: Harness): string | null {\n  const bridged = HARNESS_BRIDGE[harness]\n  if (!bridged) return null\n  return skillDirForHarness(bridged)\n}\n\n/** Filter `harnesses` down to those with no mounted skill dir (deduped,\n *  first-seen order preserved) — the set that must fall back to `inline`\n *  delivery, or that a caller should warn about before offering \"mounted\"\n *  install UX. */\nexport function unsupportedSkillHarnesses(harnesses: Iterable<Harness>): Harness[] {\n  const seen = new Set<Harness>()\n  const out: Harness[] = []\n  for (const harness of harnesses) {\n    if (resolveSkillDir(harness) !== null) continue\n    if (seen.has(harness)) continue\n    seen.add(harness)\n    out.push(harness)\n  }\n  return out\n}\n\n/** Inputs to {@link composeSkillsForHarness}. */\nexport interface ComposeSkillsForHarnessInput {\n  skills: SkillEntry[]\n  harness: Harness\n  tier?: string\n  heading?: string\n}\n\n/**\n * Compose {@link ComposedSkills} for `harness`: `mounted` delivery when the\n * platform names a cwd skill dir for it, `inline` delivery (the automatic\n * fallback that keeps every skill available on every harness) otherwise. The\n * one function a product calls instead of hand-checking `resolveSkillDir`\n * and branching between {@link composeSkills}'s two modes itself.\n */\nexport function composeSkillsForHarness(input: ComposeSkillsForHarnessInput): ComposedSkills {\n  const { skills, harness, tier, heading } = input\n  const skillDir = resolveSkillDir(harness)\n  if (skillDir) return composeSkills({ skills, mode: 'mounted', skillDir, tier, heading })\n  return composeSkills({ skills, mode: 'inline', tier, heading })\n}\n\nexport type { ComposedSkills, SkillEntry } from '../skills/index'\n"],"mappings":";;;;;AAqBA,SAAS,0BAA0C;AAUnD,IAAM,iBAAsD;AAAA,EAC1D,UAAU;AAAA,EACV,eAAe;AAAA,EACf,UAAU;AAAA,EACV,aAAa;AAAA,EACb,OAAO;AAAA,EACP,IAAI;AAAA,EACJ,QAAQ;AAAA,EACR,UAAU;AACZ;AAMO,SAAS,gBAAgB,SAAiC;AAC/D,QAAM,UAAU,eAAe,OAAO;AACtC,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,mBAAmB,OAAO;AACnC;AAMO,SAAS,0BAA0B,WAAyC;AACjF,QAAM,OAAO,oBAAI,IAAa;AAC9B,QAAM,MAAiB,CAAC;AACxB,aAAW,WAAW,WAAW;AAC/B,QAAI,gBAAgB,OAAO,MAAM,KAAM;AACvC,QAAI,KAAK,IAAI,OAAO,EAAG;AACvB,SAAK,IAAI,OAAO;AAChB,QAAI,KAAK,OAAO;AAAA,EAClB;AACA,SAAO;AACT;AAiBO,SAAS,wBAAwB,OAAqD;AAC3F,QAAM,EAAE,QAAQ,SAAS,MAAM,QAAQ,IAAI;AAC3C,QAAM,WAAW,gBAAgB,OAAO;AACxC,MAAI,SAAU,QAAO,cAAc,EAAE,QAAQ,MAAM,WAAW,UAAU,MAAM,QAAQ,CAAC;AACvF,SAAO,cAAc,EAAE,QAAQ,MAAM,UAAU,MAAM,QAAQ,CAAC;AAChE;","names":[]}

package/dist/web-react/index.js

@@ -68,7 +68,7 @@ import {
   useSmoothText,
   useThinkingSeconds,
   waterfallLayout
-} from "../chunk-PHIXZC6Y.js";
+} from "../chunk-O6H2WD3I.js";
 import {
   tabTerminalConnectionId,
   useSandboxTerminalConnection
@@ -122,7 +122,7 @@ import {
   stampInteractionAnswers
 } from "../chunk-XAWFPMAR.js";
 import "../chunk-SIXYZ2FB.js";
-import "../chunk-E7QYOOON.js";
+import "../chunk-MCJSS6SM.js";
 export {
   AgentActivityPanel,
   AgentSessionControls,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.43.48",
+  "version": "0.43.49",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent→app tool side channel, integration-hub client, per-workspace billing, and crypto — composed over the Tangle agent substrate through typed seams.",
   "keywords": [
@@ -92,6 +92,11 @@
       "import": "./dist/skills/index.js",
       "default": "./dist/skills/index.js"
     },
+    "./skills-placement": {
+      "types": "./dist/skills-placement/index.d.ts",
+      "import": "./dist/skills-placement/index.js",
+      "default": "./dist/skills-placement/index.js"
+    },
     "./profile": {
       "types": "./dist/profile/index.d.ts",
       "import": "./dist/profile/index.js",
@@ -411,17 +416,18 @@
     "@tangle-network/agent-integrations": "^0.44.0",
     "@tangle-network/agent-interface": "^0.15.0",
     "@tangle-network/agent-knowledge": "^1.7.0",
+    "@tangle-network/agent-profile-materialize": "^0.6.0",
     "@tangle-network/agent-runtime": "^0.79.3",
     "@tangle-network/brand": "^1.0.0",
     "@tangle-network/sandbox": "^0.10.5",
     "@tangle-network/sandbox-ui": "^0.72.0",
     "@tangle-network/ui": "^11.0.0",
     "@testing-library/dom": "^10.4.1",
-    "@xyflow/react": "^12.0.0",
     "@testing-library/react": "^16.3.2",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.6.0",
     "@types/react": "^19.0.0",
+    "@xyflow/react": "^12.0.0",
     "better-auth": "^1.6.16",
     "better-sqlite3": "^12.10.0",
     "drizzle-orm": "^0.45.2",
@@ -446,6 +452,7 @@
     "@tangle-network/agent-integrations": ">=0.44.0",
     "@tangle-network/agent-interface": ">=0.15.0",
     "@tangle-network/agent-knowledge": ">=1.7.0",
+    "@tangle-network/agent-profile-materialize": ">=0.6.0",
     "@tangle-network/agent-runtime": ">=0.79.3",
     "@tangle-network/brand": ">=1.0.0",
     "@tangle-network/sandbox": ">=0.9.7",
@@ -470,6 +477,9 @@
     "@tangle-network/agent-knowledge": {
       "optional": true
     },
+    "@tangle-network/agent-profile-materialize": {
+      "optional": true
+    },
     "@tangle-network/agent-runtime": {
       "optional": true
     },

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":[]}