@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/preset-cloudflare/index.d.ts

@@ -1,58 +1,3 @@
-import { KeyProvisioner, KeyCrypto, WorkspaceKeyManager, WorkspaceKeyStore } from '../billing/index.js';
-import { KnowledgeStateAccessor } from '../knowledge/index.js';
-import { d as AppToolHandlers } from '../types-B25Mib1r.js';
-import { K as KvLike } from '../rate-limit-BOVmJRXZ.js';
-import '@tangle-network/agent-eval';
-
-/**
- * The structural part of a Cloudflare Workflow instance used to prove that a
- * failed create call actually left an addressable durable instance behind.
- */
-interface CloudflareWorkflowInstanceLike<TStatus = unknown> {
-    status(): Promise<TStatus>;
-}
-/** The structural binding implemented by Cloudflare's `Workflow<TParams>`. */
-interface CloudflareWorkflowBindingLike<TParams, TStatus = unknown, TInstance extends CloudflareWorkflowInstanceLike<TStatus> = CloudflareWorkflowInstanceLike<TStatus>> {
-    create(input: {
-        id: string;
-        params: TParams;
-    }): Promise<TInstance>;
-    get(id: string): Promise<TInstance>;
-}
-interface EnsureCloudflareWorkflowInstanceResult<TStatus, TInstance extends CloudflareWorkflowInstanceLike<TStatus>> {
-    instance: TInstance;
-    /** False only when create failed but the same id was proven readable. */
-    created: boolean;
-    /** Present on reuse because reading status is the proof the instance exists. */
-    status?: TStatus;
-}
-/**
- * Create one durable Workflow instance, or prove an instance with the same id
- * already exists before accepting a create error as an idempotent retry.
- *
- * Cloudflare does not expose a stable duplicate-error class. Matching error
- * text can therefore swallow unrelated failures. This helper uses the durable
- * resource itself as proof: `get(id).status()` must succeed, otherwise the
- * original create error is rethrown.
- */
-declare function ensureCloudflareWorkflowInstance<TParams, TStatus, TInstance extends CloudflareWorkflowInstanceLike<TStatus>>(binding: CloudflareWorkflowBindingLike<TParams, TStatus, TInstance>, input: {
-    id: string;
-    params: TParams;
-}): Promise<EnsureCloudflareWorkflowInstanceResult<TStatus, TInstance>>;
-
-/** One path rule in Cloudflare's static-asset `_headers` file. */
-interface CloudflareHeadersRule {
-    pattern: string;
-    headers: Readonly<Record<string, string>>;
-}
-/**
- * Render native Cloudflare static-asset header rules.
- *
- * Values are validated before serialization so a product setting cannot add a
- * second path rule or response header through a newline.
- */
-declare function renderCloudflareHeadersFile(rules: readonly CloudflareHeadersRule[]): string;
-
 /**
  * `@tangle-network/agent-app/preset-cloudflare` — the batteries-included default
  * stack.
@@ -80,9 +25,14 @@ declare function renderCloudflareHeadersFile(rules: readonly CloudflareHeadersRu
  *  - Crypto/billing reuse `../crypto` + `../billing` exactly — this only wires
  *    them to the D1 key table.
  */
-
+import { type KeyCrypto, type KeyProvisioner, type WorkspaceKeyManager, type WorkspaceKeyStore } from '../billing/index';
+import type { KnowledgeStateAccessor } from '../knowledge/index';
+import type { AppToolHandlers } from '../tools/index';
+import type { KvLike } from '../web/index';
+export { ensureCloudflareWorkflowInstance, type CloudflareWorkflowBindingLike, type CloudflareWorkflowInstanceLike, type EnsureCloudflareWorkflowInstanceResult, } from './workflow-instance';
+export { renderCloudflareHeadersFile, type CloudflareHeadersRule, } from './headers';
 /** A prepared, bound D1 statement. */
-interface D1PreparedLike {
+export interface D1PreparedLike {
     bind(...values: unknown[]): D1PreparedLike;
     first<T = Record<string, unknown>>(colName?: string): Promise<T | null>;
     run(): Promise<unknown>;
@@ -91,13 +41,13 @@ interface D1PreparedLike {
     }>;
 }
 /** The D1 surface the preset needs. Cloudflare `D1Database` satisfies it. */
-interface D1Like {
+export interface D1Like {
     prepare(query: string): D1PreparedLike;
 }
 /** The preset table + column names — the contract the DDL, Drizzle schema,
  *  handlers, and accessor share. Exposed so a consumer can reference a column
  *  without a string literal. */
-declare const PRESET_TABLES: {
+export declare const PRESET_TABLES: {
     readonly proposals: {
         readonly name: "proposals";
         readonly columns: {
@@ -157,11 +107,11 @@ declare const PRESET_TABLES: {
  * or paste into a `.sql` migration). One statement per table so D1's
  * single-statement `prepare` accepts each. Matches {@link PRESET_TABLES} exactly.
  */
-declare const PRESET_MIGRATION_SQL: readonly string[];
+export declare const PRESET_MIGRATION_SQL: readonly string[];
 /** A chainable column builder — every modifier returns the builder so calls
  *  like `.notNull().default('pending')` typecheck. The concrete drizzle builders
  *  satisfy this structurally. */
-interface DrizzleColumnLike {
+export interface DrizzleColumnLike {
     primaryKey: () => DrizzleColumnLike;
     notNull: () => DrizzleColumnLike;
     default: (v: unknown) => DrizzleColumnLike;
@@ -169,7 +119,7 @@ interface DrizzleColumnLike {
 /** The shape of a `drizzle-orm/sqlite-core` module — the few builders the
  *  preset schema uses. The consumer passes the real module; agent-app never
  *  imports it (it stays a peer). */
-interface DrizzleSqliteCoreLike {
+export interface DrizzleSqliteCoreLike {
     sqliteTable: (name: string, columns: Record<string, DrizzleColumnLike>) => unknown;
     text: (name?: string) => DrizzleColumnLike;
     integer: (name?: string, config?: unknown) => DrizzleColumnLike;
@@ -187,7 +137,7 @@ interface DrizzleSqliteCoreLike {
  * const schema = createPresetDrizzleSchema(d)
  * ```
  */
-declare function createPresetDrizzleSchema(d: DrizzleSqliteCoreLike): {
+export declare function createPresetDrizzleSchema(d: DrizzleSqliteCoreLike): {
     proposals: unknown;
     knowledge: unknown;
     deadlines: unknown;
@@ -195,9 +145,9 @@ declare function createPresetDrizzleSchema(d: DrizzleSqliteCoreLike): {
 };
 /** The KV-backed vault. `KvLike` (from `../web`) is the structural KV contract;
  *  Cloudflare `KVNamespace` satisfies it. Artifacts are stored under their path. */
-type VaultKv = KvLike;
+export type VaultKv = KvLike;
 /** Define configuration options for handling preset tools including database, vault, and optional utilities */
-interface PresetToolHandlerOptions {
+export interface PresetToolHandlerOptions {
     /** The D1 database (Cloudflare `D1Database` satisfies {@link D1Like}). */
     db: D1Like;
     /** The KV namespace used as the artifact vault. */
@@ -225,9 +175,9 @@ interface PresetToolHandlerOptions {
  * a completion oracle sees real bytes. Pure seam wiring: a consumer that runs
  * D1 + KV gets all four tools with no handler code.
  */
-declare function createPresetToolHandlers(opts: PresetToolHandlerOptions): AppToolHandlers;
+export declare function createPresetToolHandlers(opts: PresetToolHandlerOptions): AppToolHandlers;
 /** Define options for accessing preset knowledge scoped to a specific workspace and configuration */
-interface PresetKnowledgeAccessorOptions {
+export interface PresetKnowledgeAccessorOptions {
     db: D1Like;
     /** The active workspace — every `count` is scoped to it. */
     workspaceId: string;
@@ -250,19 +200,19 @@ interface PresetKnowledgeAccessorOptions {
  * interpolation — they originate from the product's own config, never model
  * input, but we fail loud rather than build a malformed/injectable query.
  */
-declare function createD1KnowledgeStateAccessor(opts: PresetKnowledgeAccessorOptions): KnowledgeStateAccessor;
+export declare function createD1KnowledgeStateAccessor(opts: PresetKnowledgeAccessorOptions): KnowledgeStateAccessor;
 /** Build the {@link KeyCrypto} the billing key store uses — AES-256-GCM field
  *  crypto bound to the product's 64-char-hex `ENCRYPTION_KEY` (or a resolver).
  *  This is the concrete impl behind the `../billing` `KeyCrypto` seam. */
-declare function createPresetFieldCrypto(key: string | (() => string)): KeyCrypto;
+export declare function createPresetFieldCrypto(key: string | (() => string)): KeyCrypto;
 /**
  * The {@link WorkspaceKeyStore} over the preset `workspace_keys` table — the
  * persistence seam the per-workspace key manager needs. "Active" = a row with a
  * null `revoked_at`. Pure D1 wiring; no key minting (that's the provisioner).
  */
-declare function createPresetWorkspaceKeyStore(db: D1Like): WorkspaceKeyStore;
+export declare function createPresetWorkspaceKeyStore(db: D1Like): WorkspaceKeyStore;
 /** Define preset billing options including database, provisioner, encryption key, budget, and optional settings */
-interface PresetBillingOptions {
+export interface PresetBillingOptions {
     db: D1Like;
     /** The key provisioner (`@tangle-network/tcloud`'s client satisfies it structurally). */
     provisioner: KeyProvisioner;
@@ -281,6 +231,4 @@ interface PresetBillingOptions {
  * the consumer's tcloud provisioner. The mint/rotate/rollover/usage LOGIC lives
  * in `../billing`; this only binds it to the preset table + crypto.
  */
-declare function createPresetWorkspaceKeyManager(opts: PresetBillingOptions): WorkspaceKeyManager;
-
-export { type CloudflareHeadersRule, type CloudflareWorkflowBindingLike, type CloudflareWorkflowInstanceLike, type D1Like, type D1PreparedLike, type DrizzleColumnLike, type DrizzleSqliteCoreLike, type EnsureCloudflareWorkflowInstanceResult, PRESET_MIGRATION_SQL, PRESET_TABLES, type PresetBillingOptions, type PresetKnowledgeAccessorOptions, type PresetToolHandlerOptions, type VaultKv, createD1KnowledgeStateAccessor, createPresetDrizzleSchema, createPresetFieldCrypto, createPresetToolHandlers, createPresetWorkspaceKeyManager, createPresetWorkspaceKeyStore, ensureCloudflareWorkflowInstance, renderCloudflareHeadersFile };
+export declare function createPresetWorkspaceKeyManager(opts: PresetBillingOptions): WorkspaceKeyManager;

package/dist/preset-cloudflare/workflow-instance.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The structural part of a Cloudflare Workflow instance used to prove that a
+ * failed create call actually left an addressable durable instance behind.
+ */
+export interface CloudflareWorkflowInstanceLike<TStatus = unknown> {
+    status(): Promise<TStatus>;
+}
+/** The structural binding implemented by Cloudflare's `Workflow<TParams>`. */
+export interface CloudflareWorkflowBindingLike<TParams, TStatus = unknown, TInstance extends CloudflareWorkflowInstanceLike<TStatus> = CloudflareWorkflowInstanceLike<TStatus>> {
+    create(input: {
+        id: string;
+        params: TParams;
+    }): Promise<TInstance>;
+    get(id: string): Promise<TInstance>;
+}
+export interface EnsureCloudflareWorkflowInstanceResult<TStatus, TInstance extends CloudflareWorkflowInstanceLike<TStatus>> {
+    instance: TInstance;
+    /** False only when create failed but the same id was proven readable. */
+    created: boolean;
+    /** Present on reuse because reading status is the proof the instance exists. */
+    status?: TStatus;
+}
+/**
+ * Create one durable Workflow instance, or prove an instance with the same id
+ * already exists before accepting a create error as an idempotent retry.
+ *
+ * Cloudflare does not expose a stable duplicate-error class. Matching error
+ * text can therefore swallow unrelated failures. This helper uses the durable
+ * resource itself as proof: `get(id).status()` must succeed, otherwise the
+ * original create error is rethrown.
+ */
+export declare function ensureCloudflareWorkflowInstance<TParams, TStatus, TInstance extends CloudflareWorkflowInstanceLike<TStatus>>(binding: CloudflareWorkflowBindingLike<TParams, TStatus, TInstance>, input: {
+    id: string;
+    params: TParams;
+}): Promise<EnsureCloudflareWorkflowInstanceResult<TStatus, TInstance>>;

package/dist/profile/budget.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The composed-system-prompt byte budget, split out of `./index` so it imports
+ * NOTHING.
+ *
+ * `./index` pulls `@tangle-network/agent-eval` (the evolvable-section seam), so
+ * `/sandbox` — which has no agent-eval import and must not gain one — could not
+ * enforce the budget from there. The gate is the same function either way; only
+ * its module home moved. `./index` re-exports every symbol below, so the
+ * published `/profile` surface is byte-identical.
+ *
+ * Why the gate belongs at more than one call site: `composeAgentProfile` is
+ * OPT-IN. A product may hand-build its `AgentProfile`, and one does —
+ * creative-agent's create-time profile is deliberately minimal and its full
+ * system prompt rides the PER-TURN backend (`buildPromptBackend`), which never
+ * touches the composer. `/sandbox` therefore runs this gate at the three points
+ * where the profile that actually executes exists.
+ */
+/** Byte budget on the FINAL composed `prompt.systemPrompt`. Past this the
+ *  model degrades sharply (a 122,659-byte prompt shipped once and the model
+ *  returned empty answers), so the default gate throws well before that. */
+export declare const DEFAULT_MAX_SYSTEM_PROMPT_BYTES = 40000;
+/** Budget config for the composed system prompt. */
+export interface ComposeProfileBudget {
+    /** Byte cap on the composed `prompt.systemPrompt`.
+     *  Default {@link DEFAULT_MAX_SYSTEM_PROMPT_BYTES}. */
+    maxSystemPromptBytes?: number;
+    /** Downgrade the over-budget throw to a `console.warn` — the escape hatch
+     *  for a product with a known-big prompt that must still ship (it yells on
+     *  every compose instead of blocking). */
+    warnOnly?: boolean;
+    /** Required to raise {@link maxSystemPromptBytes} above
+     *  {@link DEFAULT_MAX_SYSTEM_PROMPT_BYTES} or to set {@link warnOnly}: a
+     *  written reason naming what stays inline and why it cannot be mounted.
+     *  Weakening the cap is a product decision that outlives the person making
+     *  it, and the usual cause is reference material concatenated into the prompt
+     *  that belongs in `resources.files`; demanding the sentence here keeps that
+     *  from happening by accident. */
+    overBudgetReason?: string;
+}
+/** Largest markdown-heading-delimited sections of a prompt, by UTF-8 bytes.
+ *  Cheap heuristic: split on `#`-heading lines; the preamble before the first
+ *  heading reports as "(preamble)". */
+export declare function largestPromptSections(prompt: string, top?: number): Array<{
+    title: string;
+    bytes: number;
+}>;
+/** Enforce {@link ComposeProfileBudget} on a composed system prompt: over
+ *  budget throws (or warns with `warnOnly`) with the actual size and the
+ *  top-3 largest sections. Exported so a product assembling its prompt
+ *  outside `composeAgentProfile` (e.g. via the `/prompt` assembler) can
+ *  run the same gate at its own final-composition point. */
+export declare function assertSystemPromptWithinBudget(systemPrompt: string, budget?: ComposeProfileBudget, 
+/** Prefixed to the message so a throw from a turn/provision choke point says
+ *  WHERE it fired — "composed systemPrompt" alone reads like a compose-time
+ *  error even when it fired on `driveSandboxTurn`. */
+origin?: string): void;
+/** Run {@link assertSystemPromptWithinBudget} over a profile-shaped object's
+ *  `prompt.systemPrompt`. Structural on purpose: `/sandbox` calls this on the
+ *  SDK's `AgentProfile` and on the product-supplied seam result without either
+ *  module importing the other's types. A profile with no string systemPrompt
+ *  is a no-op — there is nothing to measure.
+ *
+ *  The `hint` exists because this gate can fire on a product that ALREADY made
+ *  a deliberate budget decision somewhere else. gtm-agent composes with
+ *  `{ maxSystemPromptBytes: 50_000 }`; without the hint, the shell's 40 KB
+ *  default reads as the gate contradicting a choice the product already made
+ *  rather than as "declare the same number here too". */
+export declare function assertProfilePromptWithinBudget(profile: {
+    prompt?: {
+        systemPrompt?: unknown;
+    };
+} | undefined, budget?: ComposeProfileBudget, origin?: string, hint?: string): void;

package/dist/profile/fingerprint.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Profile fingerprinting — prove WHICH profile a turn actually executed.
+ *
+ * The backtest invariant this exists to enforce: an eval's score is only worth
+ * publishing if the benchmarked profile IS the shipped profile. The failure
+ * mode is structural, not hypothetical — a product's eval composed the
+ * production profile in one module, executed a hand-rolled stub in another,
+ * and stamped the composed profile's identity onto the stub's scorecard.
+ * Nothing compared the two, so nothing could notice.
+ *
+ * A `ProfileFingerprint` is a channelled identity of the profile handed to the
+ * sandbox SDK: the system-prompt digest plus the names of every capability
+ * surface (MCP servers, subagents, file mounts, hub connections) and the
+ * model/harness the turn dispatched at. It is deliberately NOT a byte-exhaustive
+ * serialization — channels are what drift in practice, and a channelled diff
+ * names the surface that moved instead of reporting "bytes differ".
+ *
+ * The write half of the seam is `StreamSandboxPromptOptions.onProfileResolved`
+ * (`/sandbox`): the one place the final profile exists is inside
+ * `streamSandboxPrompt` after the system-prompt override, the MCP merge, and
+ * reasoning-effort attachment, so that is where the fingerprint is taken. A
+ * caller re-deriving a profile to fingerprint it would reintroduce the exact
+ * gap this closes.
+ */
+import type { AgentProfile } from '@tangle-network/agent-interface';
+/** The dispatch context a profile cannot see but a turn's identity includes. */
+export interface ProfileFingerprintContext {
+    model?: string;
+    harness?: string;
+}
+/** Channelled identity of one executed (or composed) profile. */
+export interface ProfileFingerprint {
+    /** sha256 over every channel below — one value to log/compare. */
+    hash: string;
+    /** sha256 of `prompt.systemPrompt` ('' when absent). */
+    promptSha: string;
+    /** UTF-8 byte length of `prompt.systemPrompt`. */
+    promptBytes: number;
+    /** Sorted MCP server keys. */
+    mcpKeys: string[];
+    /** Sorted subagent names. */
+    subagentNames: string[];
+    /** Sorted `resources.files[].path` mounts. */
+    fileMountPaths: string[];
+    /** Sorted hub connection ids (alias-qualified when present). */
+    connectionIds: string[];
+    model?: string;
+    harness?: string;
+}
+/** Fingerprint a profile as the SDK would receive it. */
+export declare function fingerprintAgentProfile(profile: AgentProfile, context?: ProfileFingerprintContext): Promise<ProfileFingerprint>;
+/** One drifted channel between two fingerprints, rendered as comparable strings. */
+export interface ProfileDriftEntry {
+    channel: 'promptSha' | 'promptBytes' | 'mcpKeys' | 'subagentNames' | 'fileMountPaths' | 'connectionIds' | 'model' | 'harness';
+    a: string;
+    b: string;
+}
+export interface ProfileDrift {
+    equal: boolean;
+    drift: ProfileDriftEntry[];
+}
+/** Channel-by-channel comparison of two fingerprints. */
+export declare function diffProfileFingerprints(a: ProfileFingerprint, b: ProfileFingerprint): ProfileDrift;
+/** Human-readable drift report; exactly 'profiles identical' when equal. */
+export declare function formatProfileDrift(drift: ProfileDrift): string;

package/dist/profile/index.d.ts

@@ -1,11 +1,3 @@
-import { AgentProfileFileMount, AgentProfileResourceRef, AgentProfileMcpServer, AgentProfile } from '@tangle-network/agent-interface';
-import { profile } from '@tangle-network/agent-eval';
-export { profile } from '@tangle-network/agent-eval';
-import { SkillEntry } from '../skills/index.js';
-export { ComposeShellResourcesInput, ComposedSkills, CorpusEntry, CorpusLoadResult, GlobModules, LoadCorpusOptions, ParsedSkill, SkillDeliveryMode, SkillFrontmatter, assertSkillDeliveryDisjoint, composeShellResources, composeSkills, corpusSkills, loadMarkdownCorpus, mergeComposedSkills, parseCorpusSkills, parseSkillFrontmatter, registrySkills, renderInlineSkills, renderSkillIndex, skillEntryFromMarkdown, skillMountPath, skillRefs } from '../skills/index.js';
-import { C as ComposeProfileBudget } from '../budget-BOucfcb_.js';
-export { D as DEFAULT_MAX_SYSTEM_PROMPT_BYTES, P as ProfileDrift, a as ProfileDriftEntry, b as ProfileFingerprint, c as ProfileFingerprintContext, d as assertProfilePromptWithinBudget, e as assertSystemPromptWithinBudget, f as diffProfileFingerprints, g as fingerprintAgentProfile, h as formatProfileDrift, l as largestPromptSections } from '../budget-BOucfcb_.js';
-
 /**
  * Profile composer + evolvable-section seam for agent products.
  *
@@ -41,12 +33,26 @@ export { D as DEFAULT_MAX_SYSTEM_PROMPT_BYTES, P as ProfileDrift, a as ProfileDr
  * defaults the baseline, so a product can't render an empty learned-guidance
  * section. `stripComments` is the shared "is this addendum really empty?" test.
  */
-
+import type { AgentProfile, AgentProfileFileMount, AgentProfileMcpServer, AgentProfileResourceRef } from '@tangle-network/agent-interface';
+import { profile } from '@tangle-network/agent-eval';
+import { type SkillEntry } from '../skills/index';
+import { type ComposeProfileBudget } from './budget';
+/** The prompt byte budget lives in `./budget` (import-free) so `/sandbox` can
+ *  run the same gate without pulling agent-eval through this module. Re-exported
+ *  here so the published `/profile` surface is unchanged. */
+export { assertProfilePromptWithinBudget, assertSystemPromptWithinBudget, DEFAULT_MAX_SYSTEM_PROMPT_BYTES, largestPromptSections, type ComposeProfileBudget, } from './budget';
+/** Re-expose the agent-eval section/render substrate so a product wires the
+ *  evolvable surface through ONE subpath: `makeEvolvableSection` builds the
+ *  section, `profile.renderProfile` renders it, `profile.applyDomainPatch` lets
+ *  the loop patch it by id. The rendering/patching engine stays in agent-eval;
+ *  reach it through this namespace (re-exporting the bare fns would leak
+ *  agent-eval's un-nameable AgentProfile type into our generated d.ts). */
+export { profile };
 /** The file-mount channels layered onto `resources.files`. The first three
  *  mirror {@link ComposeShellResourcesInput}; `userSkills` is the per-user /
  *  per-workspace channel — skills the END USER added to their own instance,
  *  mounted at the harness skill-discovery path like the registry's free tier. */
-interface ProfileChannels {
+export interface ProfileChannels {
     /** Always-mounted skill corpus (pass `corpusSkills(...)`). */
     skills?: AgentProfileFileMount[];
     /** Always-mounted knowledge corpus (pass `corpusSkills(...)` for the pack). */
@@ -78,13 +84,13 @@ interface ProfileChannels {
 /** A per-user / per-workspace skill: an id and an inline `SKILL.md` body. The
  *  user-facing analogue of a registry {@link SkillEntry} with no tier gate —
  *  every user skill is mounted (the user opted in by adding it). */
-interface UserSkill {
+export interface UserSkill {
     id: string;
     /** Inline `SKILL.md` body mounted at {@link skillMountPath}. */
     skillMd: string;
 }
 /** Overlay overrides applied on top of the channel mounts. */
-interface ProfileOverlay {
+export interface ProfileOverlay {
     /** Extra MCP servers merged into the profile `mcp` map (last-wins per key over
      *  the base servers). The product builds this from its delegation MCP entry
      *  and any per-turn app-tool side-channel servers. An absent/`undefined` entry
@@ -105,7 +111,7 @@ interface ProfileOverlay {
 /** Project per-user skills onto SDK file mounts at the harness skill-discovery
  *  path. No tier gate — a user skill is mounted because the user added it.
  *  Sorted by path for determinism (matches {@link registrySkills}). */
-declare function userSkillMounts(userSkills: UserSkill[]): AgentProfileFileMount[];
+export declare function userSkillMounts(userSkills: UserSkill[]): AgentProfileFileMount[];
 /**
  * Compose a deployable `AgentProfile` from a canonical base plus the four
  * file-mount channels and the overlay overrides.
@@ -127,12 +133,12 @@ declare function userSkillMounts(userSkills: UserSkill[]): AgentProfileFileMount
  * where the FINAL prompt exists ({@link assertSystemPromptWithinBudget};
  * default {@link DEFAULT_MAX_SYSTEM_PROMPT_BYTES}, `warnOnly` escape hatch).
  */
-declare function composeAgentProfile(base: AgentProfile, channels?: ProfileChannels, overlay?: ProfileOverlay, budget?: ComposeProfileBudget): AgentProfile;
+export declare function composeAgentProfile(base: AgentProfile, channels?: ProfileChannels, overlay?: ProfileOverlay, budget?: ComposeProfileBudget): AgentProfile;
 /** True body of an addendum file with HTML comments stripped — an all-comment
  *  placeholder counts as empty, so the loader falls back to the baseline. */
-declare function stripComments(raw: string): string;
+export declare function stripComments(raw: string): string;
 /** Inputs to {@link makeEvolvableSection}. */
-interface EvolvableSectionInput {
+export interface EvolvableSectionInput {
     /** Section id the self-improvement loop targets with `applyDomainPatch`. */
     id: string;
     /** Section title rendered as `### <title>`. */
@@ -161,6 +167,8 @@ interface EvolvableSectionInput {
  * sections. The loader is the only seam; the empty-vs-populated rule and the
  * baseline fallback are the lifted algebra.
  */
-declare function makeEvolvableSection(input: EvolvableSectionInput): profile.AgentProfileSection;
-
-export { ComposeProfileBudget, type EvolvableSectionInput, type ProfileChannels, type ProfileOverlay, SkillEntry, type UserSkill, composeAgentProfile, makeEvolvableSection, stripComments, userSkillMounts };
+export declare function makeEvolvableSection(input: EvolvableSectionInput): profile.AgentProfileSection;
+export { assertSkillDeliveryDisjoint, composeShellResources, composeSkills, corpusSkills, loadMarkdownCorpus, mergeComposedSkills, parseCorpusSkills, parseSkillFrontmatter, registrySkills, renderInlineSkills, renderSkillIndex, skillEntryFromMarkdown, skillMountPath, skillRefs, } from '../skills/index';
+export type { ComposedSkills, ComposeShellResourcesInput, CorpusEntry, CorpusLoadResult, GlobModules, LoadCorpusOptions, ParsedSkill, SkillDeliveryMode, SkillEntry, SkillFrontmatter, } from '../skills/index';
+export { diffProfileFingerprints, fingerprintAgentProfile, formatProfileDrift, } from './fingerprint';
+export type { ProfileDrift, ProfileDriftEntry, ProfileFingerprint, ProfileFingerprintContext, } from './fingerprint';

package/dist/prompt/index.d.ts

@@ -36,7 +36,7 @@
  * `renderInlineSkills`/`renderSkillIndex` are the source of that section text.
  */
 /** Inputs to {@link assembleSystemPrompt}. */
-interface AssembleSystemPromptInput {
+export interface AssembleSystemPromptInput {
     /** The product's already-composed base block: persona/system prompt + tools
      *  block + (optionally) the rendered skills section. The product is
      *  responsible for resolving its profile system prompt and failing loud if it
@@ -57,7 +57,7 @@ interface AssembleSystemPromptInput {
 /** Typed outcome of {@link assembleSystemPrompt}. `succeeded: false` is returned
  *  for a programmer error (an empty base) rather than emitting a roleless
  *  prompt — callers MUST inspect `succeeded` before using `prompt`. */
-type AssembleResult = {
+export type AssembleResult = {
     succeeded: true;
     prompt: string;
 } | {
@@ -73,6 +73,4 @@ type AssembleResult = {
  * prompt with no role. The product resolves and validates its profile prompt
  * upstream; this is the last-line guard at the seam.
  */
-declare function assembleSystemPrompt(input: AssembleSystemPromptInput): AssembleResult;
-
-export { type AssembleResult, type AssembleSystemPromptInput, assembleSystemPrompt };
+export declare function assembleSystemPrompt(input: AssembleSystemPromptInput): AssembleResult;