@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/{run-D80hoLKh.d.ts → signoff/run.d.ts}

@@ -1,5 +1,4 @@
-import { S as SignoffSource, a as SignoffEvent, b as SignoffReport } from './types-Bd6uW9vQ.js';
-
+import type { SignoffEvent, SignoffReport, SignoffSource } from './types';
 /**
  * The sign-off run: reproduce a clean CI environment, then go further.
  *
@@ -17,7 +16,7 @@ import { S as SignoffSource, a as SignoffEvent, b as SignoffReport } from './typ
  * Nothing about a failure is inferred. Every step reports its command, exit
  * code, duration, seed and captured output.
  */
-interface RunSignoffOptions {
+export interface RunSignoffOptions {
     /** Any directory inside the repo. Defaults to the process cwd. */
     readonly repoDir?: string;
     readonly configPath?: string;
@@ -35,6 +34,4 @@ interface RunSignoffOptions {
     readonly keepWorkspace?: boolean;
     readonly onEvent?: (event: SignoffEvent) => void;
 }
-declare function runSignoff(options?: RunSignoffOptions): Promise<SignoffReport>;
-
-export { type RunSignoffOptions as R, runSignoff as r };
+export declare function runSignoff(options?: RunSignoffOptions): Promise<SignoffReport>;

package/dist/signoff/schedule.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The dependency graph, and running it as wide as the graph allows.
+ *
+ * CI runs these steps in a line because a YAML `steps:` list is a line. Nothing
+ * about the work requires that: typecheck, the suite, the build and knip all
+ * read source and none reads another's output. On a 32-core host, running them
+ * concurrently is free wall-clock, and it is the only reason a strictly larger
+ * verification can still finish faster than the CI it replaces.
+ *
+ * The graph is declared per step (`needs`), validated here, and the schedule is
+ * derived from it — so an omitted edge is a correctness bug the repo owns, and
+ * a cycle is named rather than deadlocking.
+ */
+export interface GraphNode {
+    readonly name: string;
+    readonly needs?: readonly string[];
+}
+/** Throws on a duplicate name, a dangling `needs`, or a cycle. */
+export declare function validateGraph(nodes: readonly GraphNode[]): void;
+type TaskStatus = 'passed' | 'failed' | 'skipped' | 'cancelled' | 'blocked';
+export interface TaskOutcome<T> {
+    readonly name: string;
+    readonly status: TaskStatus;
+    /** Present for anything that actually ran, including a cancelled task. */
+    readonly value: T | null;
+    readonly startedAtMs: number | null;
+    readonly finishedAtMs: number | null;
+}
+export interface RunGraphOptions<TNode extends GraphNode, TValue> {
+    readonly nodes: readonly TNode[];
+    readonly maxParallel: number;
+    /** `false` stops scheduling after the first failure and kills what is running. */
+    readonly keepGoing: boolean;
+    /** Runs one node. Resolves `{ ok }` for pass/fail; must not throw for a
+     *  failing command — a non-zero exit is data. */
+    readonly run: (node: TNode, signal: AbortSignal) => Promise<{
+        readonly ok: boolean;
+        readonly value: TValue;
+    }>;
+    /** Wall-clock origin, so outcomes are comparable across the whole run. */
+    readonly now?: () => number;
+}
+/**
+ * Run the graph, honouring dependencies and the parallelism cap.
+ *
+ * Failure semantics, stated because they are the difference between a gate you
+ * trust and one you argue with:
+ *  - fail-fast (default): nothing new is scheduled, everything in flight is
+ *    aborted and reported as `cancelled`, everything unstarted as `skipped`.
+ *  - `keepGoing`: independent work continues, but a step whose dependency
+ *    failed is reported `blocked`. It is never reported as passed, and never
+ *    silently omitted.
+ */
+export declare function runGraph<TNode extends GraphNode, TValue>(options: RunGraphOptions<TNode, TValue>): Promise<TaskOutcome<TValue>[]>;
+export {};

package/dist/signoff/seeds.d.ts

@@ -0,0 +1,50 @@
+import type { SignoffStepSpec } from './types';
+export declare const DEFAULT_SHUFFLE_RUNS = 2;
+/** A fresh base seed. Random, then recorded — never a fixed constant, or the
+ *  "randomized" order is one more fixed order. */
+export declare function newSeedBase(): number;
+/**
+ * Derive a step's Nth seed from the base.
+ *
+ * A hash rather than `base + n`: adjacent seeds produce correlated orders in
+ * some runners, and the point is independent samples of the order space.
+ */
+export declare function deriveSeed(base: number, stepName: string, index: number): number;
+/**
+ * Refuse a shuffled step whose command cannot receive the appended flags.
+ *
+ * pnpm only forwards extra arguments to a script through `run`, `exec` or
+ * `dlx`. The shorthand form puts pnpm's own option parser in front of them, and
+ * what happens next is a version lottery. Measured on this host, appending
+ * `--sequence.shuffle.files=true --sequence.seed=7` to a script that prints its
+ * `process.argv`:
+ *
+ * | command | pnpm 9.15.9 | pnpm 10.22.0 |
+ * |---|---|---|
+ * | `pnpm run t <flags>` | forwarded, exit 0 | forwarded, exit 0 |
+ * | `pnpm exec node probe.mjs <flags>` | forwarded, exit 0 | forwarded, exit 0 |
+ * | `pnpm t <flags>` | `Unknown options`, exit 1 | exit 254, script never ran |
+ * | `pnpm --filter web t <flags>` | `Unknown options`, exit 1 | **exit 0, script never ran** |
+ *
+ * That last cell is the reason this is a refusal and not a note. tax-agent's CI
+ * runs `pnpm --filter web test`, and a config that copied the line verbatim
+ * would, on pnpm 10, report a green "unit tests" step that executed zero tests.
+ * A gate reporting safety it did not provide is the exact failure this module
+ * exists to prevent, and the shorthand makes it silent.
+ *
+ * This is a static approximation — it checks the invocation SHAPE, not what the
+ * runner received — so it is deliberately narrow: it fires only on commands
+ * that invoke pnpm, and only on steps that get arguments appended.
+ */
+export declare function assertShuffleArgsReachTheRunner(steps: readonly SignoffStepSpec[]): void;
+export interface StepAttemptPlan {
+    readonly command: string;
+    readonly seed: number | null;
+}
+/**
+ * Expand one step into the commands that will actually run.
+ *
+ * An unshuffled step is one attempt with no seed. A shuffled step is one
+ * attempt per seed, each with the seed substituted into the appended arguments.
+ */
+export declare function planAttempts(step: SignoffStepSpec, seedBase: number, overrideRuns?: number): StepAttemptPlan[];

package/dist/signoff/store.d.ts

@@ -0,0 +1,22 @@
+export interface StoreResolution {
+    readonly storeDir: string;
+    readonly cacheKey: string;
+    /** True when a store for this key already had content. */
+    readonly hit: boolean;
+    /** Repo-relative manifest paths, sorted — the inputs to `cacheKey`. */
+    readonly keyedOn: readonly string[];
+    /** Store directories removed by the generation cap. */
+    readonly pruned: readonly string[];
+}
+export interface ResolveStoreOptions {
+    /** The clean tree whose manifests are hashed. */
+    readonly treePath: string;
+    readonly cacheDir: string;
+    /** Generations to keep. Default 4. */
+    readonly generations?: number;
+}
+/** Every manifest in the tree, repo-relative and sorted. */
+export declare function manifestFiles(treePath: string): string[];
+/** sha256 over each manifest's path and content — order-independent by sorting. */
+export declare function manifestCacheKey(treePath: string, files: readonly string[]): string;
+export declare function resolveStore(options: ResolveStoreOptions): StoreResolution;

package/dist/{types-Bd6uW9vQ.d.ts → signoff/types.d.ts}

@@ -11,7 +11,7 @@
  * gates.
  */
 /** Which bytes get verified. */
-type SignoffSource = 
+export type SignoffSource = 
 /** Exactly the commit that would merge. Uncommitted work is NOT included. */
 'head'
 /** HEAD plus the working tree: tracked modifications applied as a patch and
@@ -26,7 +26,7 @@ type SignoffSource =
  * it in either direction. Every seed used is recorded in the report, which is
  * what makes a shuffled failure reproducible rather than folklore.
  */
-interface SignoffShuffleSpec {
+export interface SignoffShuffleSpec {
     /** How many times to run the step, each with its own seed. Default 2. */
     readonly runs?: number;
     /** Exact seeds to use. Wins over `runs`; use it to replay a known failure. */
@@ -36,7 +36,7 @@ interface SignoffShuffleSpec {
     readonly args?: readonly string[];
 }
 /** One verification step — a CI step, declared by the repo. */
-interface SignoffStepSpec {
+export interface SignoffStepSpec {
     /** Unique within the config. Names the failure in the report. */
     readonly name: string;
     /** Shell command, run from `cwd` inside the clean tree. */
@@ -56,7 +56,7 @@ interface SignoffStepSpec {
     readonly shuffle?: boolean | SignoffShuffleSpec;
 }
 /** The hermetic install that precedes every step. */
-interface SignoffInstallSpec {
+export interface SignoffInstallSpec {
     /** Default `pnpm install --frozen-lockfile`. tax-agent needs
      *  `--filter web...` because `server/` depends on a sibling repo by `file:`. */
     readonly run?: string;
@@ -73,7 +73,7 @@ interface SignoffInstallSpec {
     readonly env?: Readonly<Record<string, string>>;
 }
 /** What a repo declares in `signoff.config.mjs` or a package.json `signoff` key. */
-interface SignoffConfig {
+export interface SignoffConfig {
     readonly install?: SignoffInstallSpec;
     readonly steps: readonly SignoffStepSpec[];
     /** Cap on concurrently running steps. Defaults to the host's parallelism. */
@@ -98,7 +98,7 @@ interface SignoffConfig {
 }
 /** Where a config came from. Printed in the proof — a run against a derived
  *  default is a weaker claim than one against a declared step list. */
-type SignoffConfigOrigin = {
+export type SignoffConfigOrigin = {
     readonly kind: 'file';
     readonly path: string;
 } | {
@@ -109,12 +109,12 @@ type SignoffConfigOrigin = {
     readonly path: string;
     readonly scripts: readonly string[];
 };
-interface LoadedSignoffConfig {
+export interface LoadedSignoffConfig {
     readonly config: SignoffConfig;
     readonly origin: SignoffConfigOrigin;
 }
 /** One execution of a step's command. A shuffled step has several. */
-interface SignoffAttempt {
+export interface SignoffAttempt {
     readonly command: string;
     /** The suite-order seed, or `null` for an unshuffled step. */
     readonly seed: number | null;
@@ -127,14 +127,14 @@ interface SignoffAttempt {
     readonly output: string;
     readonly outputTruncated: boolean;
 }
-type SignoffStepStatus = 'passed' | 'failed'
+export type SignoffStepStatus = 'passed' | 'failed'
 /** Never started — an earlier failure stopped the schedule. */
  | 'skipped'
 /** Started, then killed when another step failed under fail-fast. */
  | 'cancelled'
 /** A dependency failed, so this step could not be judged. */
  | 'blocked';
-interface SignoffStepResult {
+export interface SignoffStepResult {
     readonly name: string;
     readonly status: SignoffStepStatus;
     readonly attempts: readonly SignoffAttempt[];
@@ -144,7 +144,7 @@ interface SignoffStepResult {
     readonly startedAtMs: number | null;
     readonly finishedAtMs: number | null;
 }
-interface SignoffInstallResult {
+export interface SignoffInstallResult {
     readonly command: string;
     readonly storeDir: string;
     readonly cacheKey: string;
@@ -157,7 +157,7 @@ interface SignoffInstallResult {
     readonly output: string;
     readonly outputTruncated: boolean;
 }
-interface SignoffRepoFacts {
+export interface SignoffRepoFacts {
     readonly root: string;
     readonly head: string;
     readonly branch: string;
@@ -169,7 +169,7 @@ interface SignoffRepoFacts {
     readonly untrackedFiles: readonly string[];
     readonly carriedFiles: readonly string[];
 }
-interface SignoffHostFacts {
+export interface SignoffHostFacts {
     readonly node: string;
     /** The pin the repo declares, and where it came from. `null` when the repo
      *  pins nothing — stated in the proof, because an unpinned runtime is a
@@ -181,7 +181,7 @@ interface SignoffHostFacts {
     readonly arch: string;
     readonly cpus: number;
 }
-interface SignoffReport {
+export interface SignoffReport {
     readonly ok: boolean;
     readonly startedAt: string;
     readonly repo: SignoffRepoFacts;
@@ -201,7 +201,7 @@ interface SignoffReport {
     readonly reproduce: string;
 }
 /** Progress, for a CLI that prints as it goes rather than at the end. */
-type SignoffEvent = {
+export type SignoffEvent = {
     readonly kind: 'tree';
     readonly path: string;
     readonly head: string;
@@ -229,5 +229,3 @@ type SignoffEvent = {
     readonly status: SignoffStepStatus;
     readonly durationMs: number;
 };
-
-export type { LoadedSignoffConfig as L, SignoffSource as S, SignoffEvent as a, SignoffReport as b, SignoffAttempt as c, SignoffConfig as d, SignoffConfigOrigin as e, SignoffHostFacts as f, SignoffInstallResult as g, SignoffInstallSpec as h, SignoffRepoFacts as i, SignoffShuffleSpec as j, SignoffStepResult as k, SignoffStepSpec as l, SignoffStepStatus as m };

package/dist/signoff/workflow-pin.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Read the Node pin out of the workflows that gate a merge.
+ *
+ * This exists because of a measured false PASS. legal-agent `4c0d688` was red
+ * in CI on two test files — `Cannot bundle Node.js built-in "node:sqlite"` —
+ * and the sign-off gate signed it off. Same bytes, same lockfile, same
+ * hermetic tree: on Node 22 both files fail, on Node 24 both pass, 100% of the
+ * time. The runtime was the whole difference, and the gate never saw it because
+ * it looked for a pin in exactly two places the fleet does not keep one.
+ *
+ * None of tax-agent, legal-agent or agent-app has a `.nvmrc`. All three pin
+ * `node-version: 22` in the workflow that IS the merge gate. So the pin the
+ * gate is replacing was sitting in the file it is replacing, unread.
+ *
+ * Scope is deliberate: only workflows that trigger on `pull_request`. Those are
+ * the merge gate. agent-app's `publish.yml` runs Node 24.18.0 for its release
+ * jobs and triggers on push, and reading it would put the gate in permanent
+ * conflict with `ci.yml`'s Node 22.
+ *
+ * Nothing here guesses. An expression (`${{ matrix.node }}`) is not a version,
+ * a `node-version-file` that does not exist is not a pin, and two merge-gate
+ * workflows on different majors is a question this module cannot answer — each
+ * one refuses and names the config key that settles it.
+ */
+export interface WorkflowNodePin {
+    /** Repo-relative workflow path, for the proof. */
+    readonly file: string;
+    /** The version as written: `22`, `24.18.0`, `v20`. */
+    readonly value: string;
+    /** `node-version`, or the `node-version-file` path it was read through. */
+    readonly via: string;
+}
+/**
+ * Does this workflow run on `pull_request`?
+ *
+ * Both spellings the fleet uses are handled: the block form every workflow here
+ * writes, and the inline form (`on: [push, pull_request]`). `on` is quoted in
+ * some repos because YAML 1.1 reads a bare `on` as the boolean true, so the
+ * quoted keys are matched too.
+ */
+export declare function triggersOnPullRequest(source: string): boolean;
+/** Node pins declared by every workflow that gates a merge, in filename order. */
+export declare function scanMergeGateNodePins(repoRoot: string): WorkflowNodePin[];
+export interface ResolvedWorkflowPin {
+    readonly major: number;
+    readonly declared: string;
+    readonly source: string;
+}
+/**
+ * One Node major for the whole merge gate, or a refusal that names why not.
+ *
+ * `majorOf` is injected rather than imported to keep the direction of the
+ * dependency one-way: `node-version.ts` owns what a version string means, this
+ * module owns where the string lives.
+ */
+export declare function resolveWorkflowNodePin(repoRoot: string, majorOf: (raw: string) => number | null): ResolvedWorkflowPin | null;

package/dist/signoff/workspace.d.ts

@@ -0,0 +1,40 @@
+import type { SignoffRepoFacts, SignoffSource } from './types';
+/**
+ * Materialize the pristine checkout every step runs against.
+ *
+ * **The decision, and the measurement behind it: a `git worktree` of HEAD, not
+ * a filtered copy.** Both were timed on two real repos on this host:
+ *
+ * | repo | `git worktree add --detach` | `rsync -a --exclude node_modules --exclude .git` |
+ * |---|---|---|
+ * | agent-app (931 tracked files) | **0.04 s / 11 MB** | 0.12 s / 25 MB |
+ * | legal-agent (753 tracked files) | **0.06 s / 24 MB** | **3.97 s / 2.7 GB** |
+ *
+ * The 2.7 GB is the argument. The copy carried `build/`, `.react-router/` and
+ * `.wrangler/` — generated output and framework caches — because an exclude
+ * list is a hand-maintained enumeration of things to leave behind, and it is
+ * never complete. A warm Vite cache is precisely what made the `node:sqlite`
+ * bundling failure invisible locally while CI saw it, so a materializer that
+ * can leak one has defeated its own purpose. `git` already knows what is source
+ * and what is generated, and `.gitignore` is that list, maintained by the repo.
+ *
+ * The overlay on top is what keeps the gate usable before you commit:
+ * `source: 'working-tree'` applies `git diff HEAD` (staged and unstaged) as a
+ * patch and copies untracked, non-ignored files in. `source: 'head'` verifies
+ * exactly the commit that would merge.
+ */
+export interface MaterializeOptions {
+    readonly repoDir: string;
+    readonly dest: string;
+    readonly source: SignoffSource;
+    /** Gitignored files the run genuinely needs. Missing ones abort. */
+    readonly carryFiles?: readonly string[];
+}
+export interface CleanTree extends SignoffRepoFacts {
+    /** Absolute path of the materialized checkout. */
+    readonly path: string;
+}
+export declare function repoRootOf(dir: string): string;
+export declare function materializeCleanTree(options: MaterializeOptions): CleanTree;
+/** Unregister and delete a materialized tree. */
+export declare function removeCleanTree(tree: CleanTree): void;

package/dist/skills/index.d.ts

@@ -1,5 +1,3 @@
-import { AgentProfileFileMount, AgentProfileResourceRef } from '@tangle-network/agent-interface';
-
 /**
  * Unified skill + corpus mounter for agent products.
  *
@@ -43,15 +41,15 @@ import { AgentProfileFileMount, AgentProfileResourceRef } from '@tangle-network/
  * are resolved lazily via `process.getBuiltinModule` so a static `node:*`
  * import never reaches the Vite SSR bundle.
  */
-
+import type { AgentProfileFileMount, AgentProfileResourceRef } from '@tangle-network/agent-interface';
 /** A Vite eager `?raw` glob result: glob key -> raw file body. The consumer
  *  produces this by calling `import.meta.glob('<lit>', { eager: true, query:
  *  '?raw', import: 'default' })` at its own call site — the literal must stay
  *  literal so Vite can static-analyze it; passing the result here keeps that
  *  constraint at the edge and the loader substrate-free. */
-type GlobModules = Record<string, string>;
+export type GlobModules = Record<string, string>;
 /** One markdown document discovered from the corpus. */
-interface CorpusEntry {
+export interface CorpusEntry {
     /** Slug derived from the glob key (folder slug for `SKILL.md` layouts, or the
      *  normalized relative path for flat `*.md` layouts). */
     id: string;
@@ -65,7 +63,7 @@ interface CorpusEntry {
  *  registry entry (gtm/insurance `SkillEntry`); the runtime's certified `skill`
  *  artifact kind is unrelated. `skillMd` is the inline body — file provenance
  *  does not apply to the registry. */
-interface SkillEntry {
+export interface SkillEntry {
     id: string;
     name: string;
     description: string;
@@ -93,9 +91,9 @@ interface SkillEntry {
  *  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;
+export declare function skillMountPath(id: string): string;
 /** Options for {@link loadMarkdownCorpus}. */
-interface LoadCorpusOptions {
+export interface LoadCorpusOptions {
     /** The anchor folder name that appears in both glob keys and fs paths
      *  (`skills`, `doctrine`, `knowledge`). Used to normalize keys + derive ids. */
     anchor: string;
@@ -116,7 +114,7 @@ interface LoadCorpusOptions {
 /** Outcome of {@link loadMarkdownCorpus}: the entries plus which path produced
  *  them, so a caller can fail loud when both are empty rather than silently
  *  mounting nothing. */
-interface CorpusLoadResult {
+export interface CorpusLoadResult {
     source: 'vite' | 'fs' | 'empty';
     entries: CorpusEntry[];
 }
@@ -127,18 +125,18 @@ interface CorpusLoadResult {
  * determinism. The `import.meta.glob` literal stays at the CONSUMER call site
  * (passed in as `globModules`); this loader never constructs a glob.
  */
-declare function loadMarkdownCorpus(options: LoadCorpusOptions, importMetaUrl?: string): CorpusLoadResult;
+export declare function loadMarkdownCorpus(options: LoadCorpusOptions, importMetaUrl?: string): CorpusLoadResult;
 /** Project corpus entries onto SDK file mounts at a relative path under
  *  `<anchor>/`. Always-mounted: the corpus is the agent's baseline knowledge. */
-declare function corpusSkills(corpus: CorpusEntry[], anchor: string): AgentProfileFileMount[];
+export declare function corpusSkills(corpus: CorpusEntry[], anchor: string): AgentProfileFileMount[];
 /** Project the registry's free-tier (or `tier`-matched) entries onto SDK file
  *  mounts at the harness skill-discovery path. Tier-gating is the registry's
  *  only selection rule — paid skills are installed on demand, not at boot. */
-declare function registrySkills(registry: SkillEntry[], tier?: string): AgentProfileFileMount[];
+export declare function registrySkills(registry: SkillEntry[], tier?: string): AgentProfileFileMount[];
 /** Inputs to {@link composeShellResources}. Each channel is optional so a
  *  product mounts only the systems it has — corpus-only, registry-only, or
  *  both — without conflating them. */
-interface ComposeShellResourcesInput {
+export interface ComposeShellResourcesInput {
     /** Corpus mounts (always-mounted baseline). Pass the result of
      *  {@link corpusSkills}, or a hand-built mount list. */
     skills?: AgentProfileFileMount[];
@@ -159,11 +157,11 @@ interface ComposeShellResourcesInput {
  * is exactly `AgentProfileFileMount[]` — assign it straight into
  * `profile.resources.files` with no cast.
  */
-declare function composeShellResources(input: ComposeShellResourcesInput): AgentProfileFileMount[];
+export 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 {
+export interface SkillFrontmatter {
     id?: string;
     name?: string;
     description?: string;
@@ -178,7 +176,7 @@ interface SkillFrontmatter {
 }
 /** The result of {@link parseSkillFrontmatter}: the parsed fields, the body
  *  with the frontmatter block stripped, and the original untouched text. */
-interface ParsedSkill {
+export interface ParsedSkill {
     frontmatter: SkillFrontmatter;
     body: string;
     raw: string;
@@ -197,7 +195,7 @@ interface ParsedSkill {
  * 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;
+export 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`,
@@ -205,21 +203,21 @@ declare function parseSkillFrontmatter(raw: string): ParsedSkill;
  *  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;
+export 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[];
+export 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?: {
+export declare function skillRefs(skills: SkillEntry[], opts?: {
     tier?: string;
 }): AgentProfileResourceRef[];
 /** Inputs to {@link renderInlineSkills}. */
-interface RenderInlineSkillsInput {
+export interface RenderInlineSkillsInput {
     skills: SkillEntry[];
     /** Section heading. Default `'## Skills'`. */
     heading?: string;
@@ -236,9 +234,9 @@ interface RenderInlineSkillsInput {
  * `\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;
+export declare function renderInlineSkills(input: RenderInlineSkillsInput): string;
 /** Inputs to {@link renderSkillIndex}. */
-interface RenderSkillIndexInput {
+export 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
@@ -255,25 +253,25 @@ interface RenderSkillIndexInput {
  * {@link skillRefs} putting the actual files on `resources.skills`. Same
  * empty/section shape as {@link renderInlineSkills}.
  */
-declare function renderSkillIndex(input: RenderSkillIndexInput): string;
+export 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';
+export 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 {
+export interface ComposedSkills {
     refs: AgentProfileResourceRef[];
     promptSection: string;
     inlineIds: string[];
     mountedIds: string[];
 }
 /** Inputs to {@link composeSkills}. */
-interface ComposeSkillsInput {
+export interface ComposeSkillsInput {
     skills: SkillEntry[];
     mode: SkillDeliveryMode;
     tier?: string;
@@ -293,12 +291,12 @@ interface ComposeSkillsInput {
  * whose own default is to throw rather than choose `inline` for you — inline
  * is a narrow, explicitly opted-into fallback, not a co-equal mode).
  */
-declare function composeSkills(input: ComposeSkillsInput): ComposedSkills;
+export 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;
+export 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
@@ -308,6 +306,4 @@ declare function assertSkillDeliveryDisjoint(inlineIds: Iterable<string>, mounte
  * reaching the agent twice. Merge through this rather than spreading batch
  * fields by hand.
  */
-declare function mergeComposedSkills(batches: ComposedSkills[]): ComposedSkills;
-
-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 };
+export declare function mergeComposedSkills(batches: ComposedSkills[]): ComposedSkills;

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

@@ -1,7 +1,3 @@
-import { Harness } from '../harness/index.js';
-import { SkillEntry, ComposedSkills } from '../skills/index.js';
-import '@tangle-network/agent-interface';
-
 /**
  * Harness-native skill directory resolution — the one place agent-app binds
  * to the platform's authoritative per-harness skill-dir map.
@@ -21,19 +17,20 @@ import '@tangle-network/agent-interface';
  * other agent-app skills surface (`../skills`, `ProfileChannels.skillRefs`)
  * works without it, falling back to `inline` delivery.
  */
-
+import { type Harness } from '../harness/index';
+import { type ComposedSkills, type SkillEntry } from '../skills/index';
 /** 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;
+export 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[];
+export declare function unsupportedSkillHarnesses(harnesses: Iterable<Harness>): Harness[];
 /** Inputs to {@link composeSkillsForHarness}. */
-interface ComposeSkillsForHarnessInput {
+export interface ComposeSkillsForHarnessInput {
     skills: SkillEntry[];
     harness: Harness;
     tier?: string;
@@ -76,6 +73,5 @@ interface ComposeSkillsForHarnessInput {
  * 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 };
+export declare function composeSkillsForHarness(input: ComposeSkillsForHarnessInput): ComposedSkills;
+export type { ComposedSkills, SkillEntry } from '../skills/index';