@skaile/workspaces 6.14.0 → 6.16.0

package/dist/asset-manager/src/index.d.ts

@@ -9,807 +9,27 @@
  *   const am = new AssetManager({ projectDir: "/path/to/project" })
  *   await am.install()
  */
-import type { AssetRef, CatalogEntry, HarnessName, LockFile, StoreFetcher } from "@skaile/workspaces/core";
-import type { IAssetKindRegistry } from "@skaile/workspaces/plugins";
 import { FACTORY_SOURCE_URL } from "@skaile/workspaces/core";
-import type { PresetExpansion } from "@skaile/workspaces/core";
-import type { AssetDefinition, AssetFetcher, Library } from "@skaile/workspaces/library";
-import type { HistoryEntry } from "./history.js";
-import { type InstalledAgentInstance } from "./install-instances.js";
-import type { ScaffoldOptions } from "./installer.js";
-import { type DeployableEntry } from "./installer.js";
-/**
- * Normalize a git remote URL to a comparable identity so the same repo declared
- * in different syntaxes (`https://…`, `git@host:…`, trailing `/`, `.git` suffix,
- * case) compares equal. Used to dedupe the implicit factory source against an
- * explicit user declaration.
- */
-export declare function normalizeRepoUrl(url: string): string;
-/**
- * The checks one library asset must pass before `add` deploys it, as the lines `skaile validate`
- * prints for it (`<file> [<tag>] - <text>`). The asset manager does not know the per-kind checks
- * (they live with `validate`), so the host registers them once at startup; none registered means
- * `add` runs no such check (library use without the CLI). An asset the check refuses is never
- * deployed, as one the manifest does not list is not (p1550).
- */
-export type LibraryAssetCheck = (asset: {
-    kind: string;
-    name: string;
-    source: string;
-}, libraryPath: string) => string[];
-/** Register (or with `undefined`, remove) the {@link LibraryAssetCheck} `add` runs per library asset. */
-export declare function setLibraryAssetCheck(check: LibraryAssetCheck | undefined): void;
-/**
- * A first-party manifest entry of a library whose asset file now names another asset (`name:`, a
- * flow's `id:`), before `library index` renamed the entry: `publisher` is the entry's own or the
- * manifest's, `file` the asset file relative to the library and `now` the name it carries.
- */
-export interface RenamedLibraryEntry {
-    kind: string;
-    name: string;
-    publisher?: string;
-    file: string;
-    now: string;
-    /**
-     * The sentence that fixes the entry when `library index` cannot rename it (a flow whose `id:`
-     * no longer matches its file name: index drops the entry instead), `undefined` when index renames it.
-     */
-    fileFix?: string;
-}
-/** The {@link RenamedLibraryEntry}s of the library at `libraryPath`. Registered by the host, as {@link LibraryAssetCheck}. */
-export type RenamedEntryLookup = (libraryPath: string) => RenamedLibraryEntry[];
-/** Register (or with `undefined`, remove) the {@link RenamedEntryLookup} `add` asks when a ref resolves to nothing (p1603). */
-export declare function setRenamedEntryLookup(lookup: RenamedEntryLookup | undefined): void;
-/** One row of {@link AssetManager.libraryHolders}: a library holding a ref at one version. */
-export interface LibraryHolder {
-    library: string;
-    version: string;
-    description: string;
-    /** `true` for the holder `add <ref>` deploys. */
-    picked: boolean;
-}
-/**
- * One origin that holds a ref, see {@link AssetManager.refOrigins}: the bundled factory
- * source, a project source clone, or a registered library.
- */
-export interface RefOrigin {
-    kind: "factory" | "source" | "library";
-    /** `factory`, the source's short name, or the library name. */
-    label: string;
-    version: string;
-    description: string;
-}
-/**
- * Parse a canonical lock key (`<kind>:@<publisher>/<name>#<version>`) into its
- * parts. The lock key is a canonical asset ref, so this delegates to the one ref
- * parser; `AssetRef.pin` is exposed as `version` so the callers' destructuring is
- * unchanged. Stays total — callers rely on `{}`-then-`continue`, but `parseAssetRef`
- * throws, so a genuinely malformed key is caught and returned as `{}`.
- *
- * A **content-sha pseudo-version** key (`#0.0.0-sha.<hash>`, the version every
- * manifest-less source gets) fails `parseAssetRef`'s canonical-pin check. Dropping
- * it to `{}` would strip the identity, so the install reconcile / state machine
- * could never act on such an asset (it silently survives a remove-from-yaml). Fall
- * back to parsing the bare identity, keeping the raw pin as `version`.
- *
- * @internal Exported for unit tests; not part of the stable public surface.
- */
-export declare function parseCanonicalLockKey(key: string): {
-    publisher?: string;
-    kind?: string;
-    name?: string;
-    version?: string;
-};
-/**
- * Replace the `diff -u` timestamps of the `---` / `+++` header lines with a label of the side
- * (`--- <file> (deployed)`, `+++ <file> (library)`). A file that is missing on one side shows
- * the epoch there (`1970-01-01`), which says nothing a reader wants (p1693).
- */
-export declare function labelDiffHeaders(diff: string, from: string, to: string): string;
-/**
- * Bare asset name of a soft-dep target ref (`@pub/name@ver` → `name`); splits the
- * version off the *last* `@` since the leading one is the scope sigil. The
- * present-check matches on this bare name only (under-reports — the safe direction).
- */
-export declare function softDepName(ref: string): string;
-/**
- * Parse a ref for lookup, tolerating a **missing publisher** (`kind:name`, the
- * shape `listDeployed` emits and the strict `parseAssetRef` rejects). Returns
- * `null` when neither kind nor name is recoverable. Unlike {@link parseAssetRefLoose}
- * (publisher-required, only strips a `#pin`), this keeps the publisher optional.
- *
- * @internal Exported for unit tests; not part of the stable public surface.
- */
-export declare function parseRefTolerant(ref: string): AssetRef | null;
-/**
- * A library asset that `add`, `install` and the status commands cannot use as it is (a version
- * that is not semver, a flow file the engine does not load). The CLI prints its message as one
- * `✗` line, never a stack trace (p874, p1082).
- */
-export declare class LibraryEntryError extends Error {
-}
-/** A locked asset that now resolves from another library than its lock entry named. */
-export interface LibraryMove {
-    /** `kind:@publisher/name` (no version). */
-    ref: string;
-    /** Library name the lock entry recorded. */
-    from: string;
-    /** Library name the asset resolved from now. */
-    to: string;
-}
-/** One asset a `skaile add --dry-run` would deploy. */
-export interface AddPlanItem {
-    /** `kind:@publisher/name`. */
-    ref: string;
-    version: string;
-    /** `library <name>`, `source <name>`, `factory` or `store`. */
-    origin: string;
-    /** True for the asset that was asked for; false for a dependency it pulls. */
-    requested: boolean;
-    /** Deploy folders per harness target (project-relative, or `~`-relative for a global add). Empty for an agent. */
-    folders: string[];
-    /** Files of the asset, relative to its folder, when the resolver knows them. Empty for an agent. */
-    files: string[];
-    /** The native agent files each harness target gets, for an agent: it is rendered, not copied (p1621). */
-    renders: string[];
-}
-/** A source whose origin `outdated` could not fetch, so its behind count was not checked (p1820). */
-export interface UnreachableSource {
-    /** Short name of the source (`<owner>/<repo>` of its URL). */
-    name: string;
-    url: string;
-    /** One line why: the fetch error, or why the clone was not compared with its origin at all. */
-    reason: string;
-    /** Set when no fetch was tried: the clone's origin is another repository, or it holds no git checkout. */
-    notCompared?: true;
-}
-/** A locked library asset whose library holds the locked version with other bytes (an edit with no bump). */
-export interface ContentHeld {
-    /** The lock key, `kind:@publisher/name#version`. */
-    ref: string;
-    /** The library that holds the changed files. */
-    library: string;
-    version: string;
-}
-/**
- * Reconciliation state of a declared dependency relative to the lock + disk.
- * `invalid` flags a `dependencies:` entry that isn't a parseable canonical ref —
- * surfaced (not silently dropped) so a `skaile.yaml` typo is visible.
- */
-export type DeclaredState = "declared" | "installed" | "drift" | "invalid" | "skipped";
-/**
- * A top-level dependency declared in `skaile.yaml`, annotated with its
- * reconciliation {@link DeclaredState}. Transitive (lock-only) deps are never
- * included — {@link AssetManager.listDeclared} walks the declared set only.
- */
-export interface DeclaredAsset {
-    /** The canonical declared ref exactly as written in `skaile.yaml`. */
-    ref: string;
-    kind: string;
-    name: string;
-    state: DeclaredState;
-    /** Set with `skipped`: why skaile does not write the `mcp-server` to the coding agent's MCP config. */
-    reason?: string;
-}
-/** A note about an `mcp-server` that fails nothing. See {@link AssetManager.mcpNotices}. */
-export interface McpNotice {
-    /** The declaration id (`sql`, `@admin/sql`). */
-    id: string;
-    kind: "skipped" | "unset-field";
-    /** With `skipped`: why the server is not written to the MCP config. */
-    reason?: string;
-    /** The `!` line `check` and `doctor` print. */
-    text: string;
-}
-/** A deployed library asset that lacks files of its library entry. See {@link AssetManager.incompleteDeploys}. */
-export interface IncompleteDeploy {
-    /** Canonical ref of the asset. */
-    ref: string;
-    /** Files the deploy writes that are absent from the deployed directory, relative to it. */
-    missing: string[];
-}
-/**
- * A tracked asset whose copy still sits in the project dirs of a harness the
- * project no longer deploys to. See {@link AssetManager.listStaleHarnessCopies}.
- */
-export interface StaleHarnessCopy {
-    /** The harness whose dir holds the stale copy. */
-    harness: HarnessName;
-    kind: string;
-    name: string;
-    /** Absolute path of the stale copy. */
-    path: string;
-    /**
-     * `true` when skaile wrote this copy, so `harness set --clean` may delete it: its bytes equal
-     * the copy the active harness holds now, or (an agent, whose shape differs per harness) the
-     * lock records the asset. `false` for a folder the user made: it is named and kept (p1671).
-     */
-    skaileWrote: boolean;
-}
-/**
- * @deprecated Use {@link StaleHarnessCopy}, which also names the harness of the stale copy.
- */
-export interface LegacyDeployedAsset {
-    kind: string;
-    name: string;
-    /** Absolute path of the stale copy. */
-    path: string;
-}
-/**
- * A global declared dependency from `~/.skaile/skaile.yaml`, reconciled against
- * **one** harness's global deploy dir. The same ref yields one entry per global
- * harness (see {@link AssetManager.globalState}) so an asset can read `installed`
- * for `claude-code` and `drift`/`declared` for `codex` simultaneously.
- */
-export interface HarnessDeclaredAsset extends DeclaredAsset {
-    /** The global harness this state was reconciled against. */
-    harness: HarnessName;
-}
-/** @deprecated Use {@link HarnessDeclaredAsset}; the `backend` field is now `harness`. Removed in the next major. */
-export type BackendDeclaredAsset = HarnessDeclaredAsset;
-/**
- * A body-link soft-dependency edge: asset `from` references target `to` in its
- * body (not its typed `requires`). `toRef` is the parseable `skaile add` ref when
- * the target is in the index, omitted otherwise. Surfaced read-only — never
- * auto-installed (see {@link AssetManager.softDepsOf} / {@link AssetManager.reportSoftDeps}).
- */
-export interface SoftDepEdge {
-    from: string;
-    to: string;
-    toRef?: string;
-}
-/**
- * A soft-dependency target that would be left orphaned by removing some assets:
- * it is still present in the project, came in as `from`'s soft dependency, and
- * nothing else still needs it (neither a soft-dep nor a typed `requires`).
- * Report-only — {@link AssetManager.orphanedSoftDepsAfterRemoving} never removes
- * it; the caller prompts (default No). `targetRef` is the parseable `skaile
- * remove` ref when the target is in the index.
- */
-export interface OrphanedSoftDep {
-    from: string;
-    target: string;
-    targetRef?: string;
-}
-/**
- * Thrown by {@link AssetManager.listDeclared} when the project has no
- * `skaile.yaml`. The CLI maps this to a `skaile init` hint.
- */
-export declare class MissingManifestError extends Error {
-    readonly projectDir: string;
-    constructor(projectDir: string);
-}
-export type { HistoryEntry } from "./history.js";
-export { appendHistory, clearHistory, getRecentHistory, loadHistory, } from "./history.js";
-export type { DeployOptions, ScaffoldOptions } from "./installer.js";
-export type { DeployableEntry } from "./installer.js";
-export { createScaffold, deployAll, installTargetOf, removeAsset, SCAFFOLD_KINDS, } from "./installer.js";
-export type { RenderMcpConfigOptions, RenderMcpConfigResult, SkippedMcpServer, } from "./mcp-config.js";
-export { mcpNotRunnableReason, renderMcpServerConfig } from "./mcp-config.js";
-export type { Log } from "./renderers.js";
-export { renderAgentToFramework } from "./renderers.js";
-/**
- * Metadata about a repository declared in `skaile.yaml`.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface RepoInfo {
-    /** Repository name as declared in `skaile.yaml`. */
-    name: string;
-    /** How the repo is sourced: cloned from a URL, mounted from a local path, or symlinked via `skaile repo link`. */
-    kind: "local" | "remote" | "linked";
-    /** Remote URL (present when `kind === "remote"`). */
-    url?: string;
-    /** Filesystem path (present when `kind === "local"` or `kind === "linked"`). */
-    path?: string;
-    /** Git branch configured for this repository. */
-    branch: string;
-    /** Whether the repository has been cloned/resolved locally. */
-    cloned: boolean;
-}
-/**
- * Live sync status for a repository.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface RepoStatusInfo {
-    /** Repository name as declared in `skaile.yaml`. */
-    name: string;
-    /** How the repo is sourced. */
-    kind: "local" | "remote" | "linked";
-    /** Number of commits the local clone is behind the remote. */
-    behind: number;
-    /** `true` when the local clone matches the remote HEAD. */
-    upToDate: boolean;
-    /** Error message when status check failed. */
-    error?: string;
-}
-/** The rendered native files of one locked agent that a deploy wrote with other content. */
-export interface RewrittenAgent {
-    /** Lock key of the agent asset. */
-    ref: string;
-    /** Project-relative POSIX paths of the files whose bytes changed. */
-    files: string[];
-}
-/** One deployed copy `install` made equal to its locked bytes again. */
-export interface RestoredAsset {
-    /** Canonical ref of the asset. */
-    ref: string;
-    /** Deployed files whose hand edit was overwritten (project-relative POSIX paths). */
-    restored: string[];
-    /** Files the asset does not ship that were deleted from its deployed directory. */
-    removed: string[];
-}
-/** One asset `install` moved from one locked version to another. */
-export interface ReplacedAsset {
-    /** `kind:@publisher/name`, no version. */
-    ref: string;
-    from: string;
-    to: string;
-}
-/**
- * Result of a full `skaile install` or `skaile add` run.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-/** A locked store asset `install` did not re-check against the store; see {@link InstallResult.storeNotChecked}. */
-export interface StoreNotChecked {
-    /** The declared ref as `install` reports it (`kind:@publisher/name#version`). */
-    ref: string;
-    reason: "air-gapped" | "unreachable" | "skipped";
-    /** Why the store was not asked, or what it answered (the store URL and the cause). */
-    detail: string;
-}
-export interface InstallResult {
-    /** Canonical refs (`kind:@publisher/name#version`) successfully deployed in this run. */
-    deployed: string[];
-    /**
-     * Deployed library assets whose body is still the untouched `library create` scaffold: they
-     * fail `validate` and the publish plan, so `install` names them (p926). Absent when none is.
-     */
-    placeholderBodies?: string[];
-    /**
-     * Deployed library assets whose `description:` is still the `library create` placeholder
-     * (`TODO: …`): `validate` and the publish plan fail it as well. Absent when none is.
-     */
-    placeholderDescriptions?: string[];
-    /** Asset refs (`kind:name`) removed because they are no longer in the resolved set. */
-    removed: string[];
-    /**
-     * Asset refs that could not be resolved in any configured repository. On the
-     * non-locked path every entry is a bare ref; the reason a miss happened lives in
-     * {@link InstallResult.missingHints}. The `--locked` path still appends its prose
-     * (`ref (not found in library "x")`) to the entry, and also lists every
-     * {@link AssetManager.projectState} gap (a declared dependency or a locked asset's
-     * `requires` with no lock entry, a lock that contradicts a `skaile.yaml` pin, a library
-     * that cannot supply a locked asset) as its one-line message.
-     */
-    missing: string[];
-    /**
-     * Why a ref in {@link InstallResult.missing} may have missed, keyed by that ref:
-     * the asset's publisher changed (`library set publisher=`), so the lock still holds
-     * it under the old one and/or a library now holds it under another. Parenthesised
-     * parts such as `did you mean skill:@acme/x?` and
-     * `locked as skill:@plain/x; run skaile install to re-resolve`. Only refs with a
-     * hint appear; absent when none has.
-     */
-    missingHints?: Record<string, string>;
-    /**
-     * Locked store assets `install` could not check against the store (p792, p799): the deployed
-     * copy and the lock entry stay as they are and the asset is not in {@link InstallResult.missing}.
-     * `air-gapped` (`catalog.cache_ttl: 0`, nothing cached) and `skipped` (`update --no-catalog`)
-     * are a chosen mode, `unreachable` a store that did not answer. Absent when every locked store
-     * asset was checked.
-     */
-    storeNotChecked?: StoreNotChecked[];
-    /**
-     * Lock keys whose entry `install` rewrote for an asset that was already locked: the
-     * library or source holds another version of it, or the same version with other
-     * content. A re-lock can happen with nothing to deploy. Absent when none changed.
-     */
-    relocked?: string[];
-    /**
-     * Locked library assets whose library holds the locked version with other bytes (an edit with
-     * no version bump). `install` keeps their lock and deployed copy: only `skaile update` takes
-     * the edit (OQ13, p1911). Absent when none.
-     */
-    contentHeld?: ContentHeld[];
-    /**
-     * Global entries a 5.12.0 record left without a harness subset, now limited to the one harness
-     * that holds their copy (`ref` is `kind:@publisher/name`). Absent when nothing was inferred.
-     */
-    inferredHarnesses?: Array<{
-        ref: string;
-        harnesses: HarnessName[];
-    }>;
-    /**
-     * Library-origin assets whose lock entry now names another library than before. `install`
-     * keeps a locked asset on its library; only `update`, a pin, or a locked library that no
-     * longer holds the asset moves it. Absent when none moved.
-     */
-    moved?: LibraryMove[];
-    /**
-     * Assets whose locked version `install` replaced with another version of the same asset
-     * (`ref` is `kind:@publisher/name`). Not part of {@link InstallResult.removed}: nothing
-     * left the project. Absent when none changed.
-     */
-    replaced?: ReplacedAsset[];
-    /**
-     * Deployed copies `install` made equal to their locked bytes again: a file edited by hand
-     * (`restored`) or an extra file in the asset directory (`removed`), both as project-relative
-     * POSIX paths. Absent when every deployed copy already matched.
-     */
-    restored?: RestoredAsset[];
-    /**
-     * One line per locked library that is not registered here but whose assets `install --locked`
-     * restored from a store that serves the locked hash (every file SHA-verified): the notice that
-     * the library is not registered, where the bytes came from, and how to register it. Not a failure: `missing` stays empty (OQ8, p1655).
-     */
-    libraryNotices?: string[];
-    /**
-     * Rendered agent files that a lock without `rendered:` entries (written by a CLI before
-     * 5.12.0) did not cover and that this run wrote with other content, because the render of
-     * the agent changed. Absent when none.
-     */
-    rewritten?: RewrittenAgent[];
-    /** Whether `skaile.lock.yaml` was written or updated. */
-    lockWritten: boolean;
-    /**
-     * npm packages installed as a side effect of resolving runtime asset peer
-     * deps (connectors / mounts declared in skaile.yaml). Empty when nothing
-     * needed installing or when the runtime-deps step was skipped.
-     */
-    npmInstalled?: string[];
-    /**
-     * npm packages that the runtime-deps step tried but failed to install.
-     * Non-fatal — listed for telemetry and CLI reporting.
-     */
-    npmFailed?: string[];
-    /**
-     * One entry per `preset:` dependency expanded into this install (nested presets
-     * included): how many asset items joined the install set and how many instance
-     * items (`library://`, placeholders) were skipped.
-     */
-    presets?: PresetExpansion[];
-    /**
-     * One entry per `skaile.yaml` agent instance (`agent:` as `default`, plus
-     * `agents:`) rendered into the target harness's native agent files, with the
-     * workspace-relative paths written. Absent for `--global` installs and
-     * harnesses without a native agent format.
-     */
-    agentInstances?: InstalledAgentInstance[];
-    /**
-     * Ids of the `agentInstances` whose native agent files changed in this run (a new file,
-     * other bytes). An instance that rendered the same bytes again is not listed: `install`
-     * re-renders every instance each run (p1673).
-     */
-    agentInstancesChanged?: string[];
-    /**
-     * Workspace-relative native agent files removed because their instance left
-     * `skaile.yaml` (only files an earlier `skaile install` rendered are ever removed).
-     */
-    agentFilesRemoved?: string[];
-    /**
-     * Agent instances of `skaile.yaml` whose `ref` resolves to no agent (never added, or gone):
-     * one message each. Their earlier rendering is kept. `skaile install` fails on a non-empty list.
-     */
-    agentInstanceErrors?: string[];
-    /**
-     * The resolver's own text (with the directories it searched) for each entry of
-     * {@link agentInstanceErrors} whose message was shortened to one line of advice; for `--verbose`.
-     */
-    agentInstanceDetails?: string[];
-}
-/**
- * An installed asset whose source repository is behind the remote.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface OutdatedEntry {
-    /** Asset kind (`skill`, `agent`, `prompt`, `flow`, `contract`). */
-    kind: string;
-    /** Asset name as registered in the catalog. */
-    name: string;
-    /** Repository that provides this asset. */
-    publisher: string;
-    /** Version string recorded in the lock file at install time. */
-    currentVersion: string;
-    /** Number of commits the local repository is behind the remote (always 0 for a library asset). */
-    behind: number;
-    /** Library-origin asset only: the version the library index now offers (newer than `currentVersion`). */
-    latestVersion?: string;
-    /** Library-origin asset only: name of the library the asset was locked from. */
-    library?: string;
-    /**
-     * Set when the locked asset cannot be checked or is not in place: its library is
-     * not registered (renamed or removed), its deployed copy is gone, or the lock does not
-     * cover it ({@link AssetManager.projectState}). Such a row has no `latestVersion`.
-     */
-    problem?: string;
-    /**
-     * Library-origin asset only: the library's files on disk differ from the content
-     * hash recorded in the lock at the same version (edited in place, no version bump).
-     * `skaile update` re-locks and re-deploys them; `install` keeps the lock (OQ13).
-     */
-    contentChanged?: boolean;
-    /**
-     * Library-origin asset only: the library now holds this OLDER version than the lock. `install`
-     * keeps the lock and the deployed copy; only `update` moves it back (`replaced X → Y`).
-     */
-    libraryOlder?: string;
-    /**
-     * Library-origin asset only: the library `update` would re-lock the asset from, when it is
-     * not the one the lock names (`library`), e.g. after `skaile library default <other>`.
-     */
-    movesTo?: string;
-    /**
-     * Source asset only: the version the next `install` or `update` locks it under, when that
-     * is not the locked key. A `0.0.0-sha.<commit>` key whose file now declares a version is
-     * re-keyed (`0.0.0-sha.7de3555 → 0.2.0`, p914).
-     */
-    rekeyTo?: string;
-    /**
-     * Set when the row only reports a newer version than the `#version` pin of the asset's ref
-     * in `skaile.yaml` (`latestVersion`). The pin is deliberate: `update` leaves it and `outdated`
-     * does not fail on it.
-     */
-    pinned?: boolean;
-    /**
-     * Set on a `problem` row whose cause `skaile install` cannot fix: the asset's library is
-     * gone or its publisher changed, so the ref resolves nowhere. `problem` names what to
-     * change instead (`skaile library init …`, the ref under its new publisher).
-     */
-    manualFix?: true;
-}
-/**
- * Outcome of `AssetManager.diff()` — distinguishes an unknown ref from a real
- * "no differences" so callers never conflate the two.
- *
- * - `not-found` — the ref resolves to no asset (source, store or library).
- * - `not-deployed` — the asset resolves, but there is no deployed copy to compare.
- * - `identical` — the deployed copy matches the source.
- * - `differs` — the deployed copy differs; `diff` carries the unified diff. `fileSetDiffers` is
- *   set when a file is missing from the deployed copy or one is not part of the asset (an
- *   `mcp-server` payload): that is a state problem as for a skill, so `diff` lists it and exits 1.
- * - `no-files` — the asset kind has no files of its own (a preset: its items are the assets to
- *   compare) and the lock records it.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export type DiffResult = {
-    status: "not-found";
-} | {
-    status: "not-deployed";
-} | {
-    status: "identical";
-} | {
-    status: "no-files";
-} | {
-    status: "differs";
-    diff: string;
-    fileSetDiffers?: true;
-};
-/**
- * A node in the resolved dependency tree (returned by `AssetManager.tree()`).
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface DependencyNode {
-    /** Lock key (`kind:@publisher/name#version`), or `"project"` for the root node. */
-    ref: string;
-    /** Assets this node requires, nested under it. */
-    children: DependencyNode[];
-}
-/** Outcome of {@link AssetManager.removeWithDependencies}. */
-export interface RemoveResult {
-    /** Whether anything changed (as {@link AssetManager.remove}). */
-    changed: boolean;
-    /** Canonical refs (`kind:@publisher/name`) of the orphaned dependencies dropped as well. */
-    pruned: string[];
-    /**
-     * Set when the removal was refused because other assets still require it; nothing was
-     * removed. `ref` is the asset (`kind:@publisher/name`), `requiredBy` the refs requiring it.
-     */
-    blocked?: {
-        ref: string;
-        requiredBy: string[];
-    };
-    /**
-     * Deployed folders or files of the asset that no lock entry holds (the user's own work):
-     * kept, not deleted. Empty when `force` was given.
-     */
-    kept?: string[];
-    /**
-     * Deployed folders or files of the asset that another publisher's lock entry holds: kept, not
-     * deleted (only that entry's own `remove` may delete them, or `force`). `refs` are the owning
-     * lock entries, `paths` the kept folders.
-     */
-    ownedBy?: {
-        refs: string[];
-        paths: string[];
-    }[];
-    /**
-     * `mcp_servers` entries of `skaile.yaml` that were dropped with a removed `mcp-server` because
-     * they only set values for it (an `env` override with no `command` or `url` of its own), as
-     * `mcp_servers entry "<id>"`. An entry that can run alone stays.
-     */
-    droppedSettings?: string[];
-}
-/**
- * A missing dependency detected by `AssetManager.doctor()`.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface DepIssue {
-    /** Kind of the asset that has the unsatisfied requirement. */
-    assetKind: string;
-    /** Name of the asset that has the unsatisfied requirement. */
-    assetName: string;
-    /** Kind of the missing dependency. */
-    depKind: string;
-    /** Name of the missing dependency (`@<publisher>/<name>` when it names a publisher). */
-    depName: string;
-    /** `true` when the missing dependency exists in a configured repository but has not been installed. */
-    inRepos: boolean;
-    /**
-     * `true` when the asset itself is lock-managed but no source or library holds it
-     * any more, so its `requires` cannot be checked. `depKind`/`depName` repeat the asset.
-     */
-    unresolved?: boolean;
-    /**
-     * Set with `unresolved` when the lock ties the asset to a library: what to change
-     * (`register library "x" again with …`, `did you mean <ref>?`). `skaile install`
-     * cannot restore it. Absent when the lock names no library for it.
-     */
-    fix?: string;
-}
-/**
- * One way the project differs from what it declares and locks; see {@link AssetManager.projectState}.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface LockGap {
-    type: "declared" | "invalid" | "drift" | "pin" | "requires" | "unresolved" | "library" | "incomplete" | "content" | "modified" | "agent" | "flow" | "render" | "source";
-    /** The ref to act on: the declared ref, the unmet dependency `kind:name`, or the asset itself. */
-    ref: string;
-    /** Set on a `requires` gap: the requiring asset, `kind:@publisher/name` (`kind:name` when the lock knows no publisher). */
-    asset?: string;
-    /** What is wrong, as a phrase that follows `ref` (e.g. `is declared but not locked — run …`). */
-    reason: string;
-    /** One line naming the gap, without a leading status mark: `${ref} ${reason}`, except a `requires` gap, which leads with the requiring asset. */
-    message: string;
-    /** Set when `skaile install` cannot fix the gap; `reason` then names what to change instead. */
-    manualFix?: true;
-    /** Set on the gap of a `sources:` entry whose clone the walk could not read. `install --locked` restores from the lock alone, so it does not count that as missing. */
-    unreadableSource?: true;
-}
-/**
- * The project's state as {@link AssetManager.projectState} computes it: the one verdict
- * `check`, `doctor`, `outdated`, `diff` and `install --locked` share.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface ProjectState {
-    /** Every problem, one {@link LockGap} each; empty when the project is as declared and locked. */
-    gaps: LockGap[];
-    /** What {@link AssetManager.doctor} found: the unmet requirements (a `doctor` table row each) and the locked assets nothing provides. */
-    requirements: DepIssue[];
-}
-/**
- * A single deployed asset shown in the workspace overview.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface OverviewEntry {
-    /** Asset kind (`skill`, `agent`, `prompt`, `flow`, `contract`). */
-    kind: string;
-    /** Asset name. */
-    name: string;
-    /** Publisher that provides this asset (from the lock file; `"unknown"` when unresolvable). */
-    publisher: string;
-    /** Version string from the lock file. */
-    version: string;
-    /**
-     * Sync status relative to the source repository.
-     * - `"synced"` — local clone matches remote HEAD
-     * - `"outdated"` — local clone is behind the remote
-     * - `"local"` — sourced from a local path, no remote to compare
-     * - `"error"` — status check failed
-     * - `"unknown"` — repository not found or lock entry missing
-     */
-    syncStatus: string;
-}
-/**
- * Aggregated workspace overview returned by `AssetManager.overview()`.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface OverviewResult {
-    /** Entries grouped by publisher, sorted alphabetically. Each group is sorted by kind then name. */
-    byPublisher: Map<string, OverviewEntry[]>;
-    /** Total number of deployed assets. */
-    total: number;
-    /** Sync status for each configured repository. */
-    repos: RepoStatusInfo[];
-}
-/**
- * Options for constructing an {@link AssetManager}.
- *
- * @docLink packages/asset-manager/concepts#asset-manager
- */
-export interface AssetManagerOptions {
-    /** Absolute or relative path to the workspace root (must contain `skaile.yaml`). */
-    projectDir: string;
-    /**
-     * The process's asset-kind registry — the only authority on which kinds exist.
-     * Typed frontmatter whose `type:` is not registered is reported, not catalogued.
-     */
-    registry: IAssetKindRegistry;
-    /**
-     * Agent framework to target for asset deployment.
-     * Determines which framework directories (``.claude/``, ``.omp/``, etc.) are used.
-     * Defaults to the harness the project is configured for (`skaile.yaml`
-     * `agent-config.default.harness`, `.skaile/settings.json`), else `"claude-code"`.
-     */
-    harness?: HarnessName;
-    /**
-     * When `true`, the manager operates in **global cross-harness** mode: config
-     * SSOT, lock, cache, and history root at `~/.skaile` (not the project), the
-     * `dependencies:` manifest edits target `~/.skaile/skaile.yaml`, and deploy
-     * fans out to every harness in {@link harnesses}. When `false` (default),
-     * everything is project-scoped against the single {@link harness}.
-     */
-    global?: boolean;
-    /**
-     * Global-mode harness set the deploy fans out to. When omitted in global mode,
-     * resolved from `~/.skaile/skaile.yaml` `global_harnesses:` else auto-detection
-     * (`resolveGlobalHarnesses`). Ignored in project mode. A `--harness` filter
-     * narrows this to a subset.
-     */
-    harnesses?: HarnessName[];
-    /** @deprecated Use `harnesses`. Honoured only when `harnesses` is absent; removed in the next major. */
-    backends?: HarnessName[];
-    /**
-     * Catalog read-protocol fetcher used to resolve store-published assets. When
-     * omitted, one is built per call from the configured stores
-     * (`RemoteCatalogSource`). Injected mainly by tests to stay network-free.
-     */
-    storeFetcher?: StoreFetcher;
-    /**
-     * Byte fetcher used to fetch a store asset's files at its pinned commit before
-     * deploy. When omitted, the production GitHub fetcher is used. Injected by
-     * tests to stay network-free.
-     */
-    assetFetcher?: AssetFetcher;
-    /**
-     * Overrides the global `catalog.url` used as a store fallback when the project
-     * declares no `stores:`. `"local"` disables the fallback; project `stores:` are
-     * still asked. `""` (`update --no-catalog`) asks no store at all, project `stores:`
-     * included. When omitted, the URL is read from `~/.skaile/config.yaml` (`resolveConfig`).
-     */
-    catalogUrl?: string;
-    /**
-     * Overrides the index SQLite path read by {@link AssetManager.reportSoftDeps}
-     * (default `~/.skaile/index.db` via `resolveIndexPath`). Injected by tests to
-     * read a seeded index without touching the user's real one.
-     */
-    indexPath?: string;
-    /**
-     * Receives the warning printed when {@link AssetManager.add} picks one ref out of several
-     * local libraries (which library was chosen and why); no other method warns. Defaults to
-     * `console.warn`
-     * with a `skaile:` prefix. A CLI with a live spinner passes a collector and
-     * prints the lines after the spinner stops, so frames can't overwrite them.
-     */
-    onLibraryCollision?: (message: string, keys?: readonly string[]) => void;
-    /**
-     * An `add` that meets several colliding assets prints one summary line by default; `true`
-     * prints each asset's full message (`skaile add --verbose`). A single collision always
-     * prints in full.
-     */
-    verboseCollisions?: boolean;
-}
-export { FACTORY_SOURCE_URL };
+import { AmAdd } from "./add-remove/add.js";
+export { setRenamedEntryLookup } from "./add-remove/add.js";
+export type { RenamedLibraryEntry, RenamedEntryLookup, AddPlanItem } from "./add-remove/add.js";
+export { softDepName } from "./add-remove/remove.js";
+export type { SoftDepEdge, OrphanedSoftDep, RemoveResult } from "./add-remove/remove.js";
+export type { UnreachableSource, AssetManagerOptions } from "./config/core.js";
+export type { McpNotice } from "./mcp-render.js";
+export { labelDiffHeaders } from "./read/diff.js";
+export type { DiffResult } from "./read/diff.js";
+export type { ProjectState } from "./read/doctor.js";
+export type { DependencyNode } from "./read/graph.js";
+export type { OutdatedEntry } from "./read/outdated.js";
+export { MissingManifestError } from "./read/state.js";
+export type { StaleHarnessCopy, LegacyDeployedAsset, HarnessDeclaredAsset, RepoStatusInfo, OverviewEntry, OverviewResult, } from "./read/state.js";
+export { LibraryEntryError } from "./resolve/scan.js";
+export type { LibraryHolder, RefOrigin } from "./resolve/scan.js";
+export { setLibraryAssetCheck } from "./shared/library-hooks.js";
+export type { LibraryAssetCheck } from "./shared/library-hooks.js";
+export { parseCanonicalLockKey, parseRefTolerant } from "./shared/refs.js";
+export type { LibraryMove, ContentHeld, DeclaredState, DeclaredAsset, IncompleteDeploy, BackendDeclaredAsset, RepoInfo, RewrittenAgent, RestoredAsset, ReplacedAsset, StoreNotChecked, InstallResult, DepIssue, LockGap, } from "./shared/types.js";
 /**
  * Programmatic API for managing AI assets in a Skaile workspace.
  *
@@ -837,2168 +57,18 @@ export { FACTORY_SOURCE_URL };
  *
  * @docLink packages/asset-manager/concepts#asset-manager
  */
-export declare class AssetManager {
-    /** Resolved absolute path to the workspace root. */
-    readonly projectDir: string;
-    /** Harness all deploy operations target (a `HarnessName`). */
-    readonly harness: HarnessName;
-    /** Whether this instance operates in global-install mode. */
-    readonly global: boolean;
-    /** Asset-kind registry shared with the host (one instance per process). */
-    readonly registry: IAssetKindRegistry;
-    private _knownKinds?;
-    /** Explicit global-harness override (global mode only); else auto-resolved. */
-    private readonly harnessesOverride?;
-    private readonly legacyCopiesRemoved;
-    private readonly legacyCopiesKept;
-    /** Injected catalog fetcher (tests / custom); falls back to a built one. */
-    private readonly injectedStoreFetcher?;
-    /** Injected byte fetcher for store staging; falls back to GitHub. */
-    private readonly injectedAssetFetcher?;
-    /** Injected global catalog URL override for the no-project-store fallback. */
-    private readonly catalogUrlOverride?;
-    /** Injected index SQLite path override (tests); else the default index.db. */
-    private readonly indexPathOverride?;
-    /** Sink for cross-library collision warnings; else `console.warn`. */
-    private readonly onLibraryCollision?;
-    /** Print every colliding asset's full message instead of one summary ({@link AssetManagerOptions.verboseCollisions}). */
-    private readonly verboseCollisions;
-    /** Store URLs whose failed version lookup was already reported (one warning per URL). */
-    private readonly warnedStoreVersionLookups;
-    /** Whether each store answers: one process asks a dead store once (`processStoreProbe`). */
-    private readonly storeProbe;
-    /** Stores a lookup could not reach (store URL -> one line why); `add` reports them instead of "not found". */
-    private readonly storeFailures;
-    /** The agent `add` is about to bind to an instance: its deploy writes no file named after the asset. */
-    private pendingAgentBinding;
-    /** Source origins `outdated` could not fetch; read once through {@link takeUnreachableSources}. */
-    private readonly unreachableSources;
-    /** Store-origin refs `outdated` could not check; read once through {@link takeStoreNotChecked}. */
-    private readonly storeUnchecked;
-    /** How many store lookups failed so far; a lookup that moved it failed. */
-    private storeFailureCount;
-    /** Set while a lookup reports its own failure: the generic one-line warning stays off. */
-    private quietStoreLookups;
-    /** Store URLs a lookup failed on because the client is air-gapped (`cache_ttl: 0`), not because the store is down. */
-    private readonly airGappedStores;
-    /** Sources a provenance walk had to skip (source URL → why); one warning per source. */
-    private readonly skippedSources;
-    /** `onSourceError` of every provenance walk: name the source once, leave it out, go on. */
-    private readonly reportSourceError;
-    constructor(opts: AssetManagerOptions);
-    /** Registered kind names — the `knownKinds` argument of the manifest scanners. */
-    private get knownKinds();
-    /**
-     * The harness component dir a kind installs into (its provider's
-     * `installTarget`), or `undefined` for composition-only kinds, which are only
-     * cached in the store cache and composed at session start.
-     */
-    private installTarget;
-    /**
-     * Root for this manager's **state** — config SSOT, lock, cache, history.
-     * `~/.skaile` in global mode (the cross-harness SSOT), else the project dir.
-     * Deploy dirs are unaffected; they come from `HARNESS_TARGETS[target]`.
-     */
-    private get stateRoot();
-    /**
-     * The harnesses a global deploy fans out to: the explicit `harnesses` override (a `--harness`
-     * filter), else the explicit `global_harnesses:` of `~/.skaile/skaile.yaml`, else every harness
-     * whose root dir exists under `~` plus the harness the project is configured for (a project on
-     * a harness whose dir does not exist yet still gets its user-scope assets). In project mode
-     * this is exactly `[harness]`, so the shared fan-out loop degenerates to the
-     * single-target path.
-     */
-    private targetHarnesses;
-    /** The global harness set without a `--harness` filter (see {@link AssetManager.targetHarnesses}). */
-    private defaultGlobalHarnesses;
-    /**
-     * `global_asset_harnesses:` of `~/.skaile/skaile.yaml`: the harnesses `add --global --harness`
-     * limited an entry to, keyed by the declared ref without its pin. An entry with no row goes to
-     * every global harness. Global mode only.
-     */
-    private readEntryHarnesses;
-    /** The harnesses recorded for `kind:name` (`publisher` must agree when both sides have one). */
-    private entryHarnessRecord;
-    /** Keep the entries a recorded `--harness` limit sends to `target` (all of them in project mode). */
-    private entriesForHarness;
-    /**
-     * The harness a 5.12.0 `add --global --harness omp` left as the asset's only copy: the copy sits
-     * under the 5.12.0 omp folder (`~/.omp/skills`) and no other default harness holds one. That
-     * folder is the only real 5.12.0 evidence: a current `add --global` writes no row either, so a
-     * lone copy elsewhere may be a copy the user deleted or a harness added later (p1442).
-     */
-    private legacySingleCopyHarness;
-    /**
-     * Whether `~/.skaile/skaile.yaml` is a 5.12.0 record: it exists and has no
-     * `global_asset_harnesses:` key yet, so {@link inferLegacyHarnessSubsets} has not run.
-     */
-    private isLegacyHarnessRecord;
-    /**
-     * A 5.12.0 global record has no `global_asset_harnesses:` key, yet `add --global --harness omp`
-     * wrote one copy only, under `~/.omp/skills`. On the first global `install`, an entry whose only
-     * copy sits there (see {@link legacySingleCopyHarness}) is omp's subset (OQ6): record it, so the
-     * install does not fan the asset out to harnesses the user never asked for (p1442). Nothing is
-     * inferred without that evidence, once the key exists (an entry without a row then means "every
-     * harness"), or with one default harness. Global mode only; returns the rows written.
-     */
-    private inferLegacyHarnessSubsets;
-    /**
-     * Set (or, with `harnesses` undefined, clear) the harness row of `ref` in the parsed
-     * `~/.skaile/skaile.yaml` `raw`. Returns whether `raw` changed.
-     */
-    private setEntryHarnessRow;
-    /** The harness row of `kind:name` (publisher must agree when both sides have one) in the parsed `raw`. */
-    private harnessRowIn;
-    /**
-     * The harness row `add --global --harness <requested>` leaves for `ref`: the recorded set plus
-     * `requested`. An asset declared with no row goes to every global harness, so its set is that
-     * default; `undefined` (no row) when `requested` is already part of it. A new asset gets
-     * `requested` alone.
-     */
-    private widenedHarnessRow;
-    /**
-     * After `add --global --harness X`: widen the row of every other entry of the add that has one
-     * (a requirement declared on its own with `--harness`), so the copy now deployed into X stays
-     * managed. Entries with no row already go to every harness.
-     */
-    private widenDependencyRows;
-    /**
-     * `add --global --harness X --only`: name each harness that leaves the asset's set but still
-     * holds a copy. The copy stays on disk; `remove --global --harness <h>` deletes it.
-     */
-    private reportDroppedCopies;
-    /**
-     * Delete the copies a 5.12.0 global install left in `~/.omp/skills`, `~/.omp/agents`,
-     * `~/.omp/prompts` and `~/.omp/contracts` (omp reads `~/.omp/agent/<dir>`) for the assets just
-     * deployed into omp's new folder, and remember them for {@link takeLegacyCopiesRemoved} (p744).
-     */
-    private sweepLegacyOmpCopies;
-    /** The old omp copies the deploys since the last call kept, as skaile did not write them. */
-    takeLegacyCopiesKept(): string[];
-    /**
-     * The old `~/.omp/<dir>/<name>` copies of the globally locked assets that are still on disk
-     * (a 5.12.0 install wrote them; omp reads `~/.omp/agent/<dir>`). Global mode only. `check`,
-     * `doctor` and `clean` with `--global` report or remove them (p911).
-     */
-    staleLegacyOmpCopies(): {
-        ref: string;
-        path: string;
-    }[];
-    /** The old omp copies the deploys since the last call removed (see {@link sweepLegacyOmpCopies}). */
-    takeLegacyCopiesRemoved(): string[];
-    /**
-     * The source origins the last {@link outdated} call could not fetch (name, URL, why). Their
-     * behind count was not checked, so the CLI must not call the project up to date (p1820).
-     */
-    takeUnreachableSources(): UnreachableSource[];
-    /**
-     * The refs the last {@link outdated} call could not check because their store did not answer
-     * (`unreachable`) or the client is air-gapped (`air-gapped`): `outdated`, `check` and `doctor`
-     * name them and fail on `unreachable` instead of calling the project up to date.
-     */
-    takeStoreNotChecked(): StoreNotChecked[];
-    /**
-     * The harnesses `add` / `install` deploy into: `[harness]` for a project, the global
-     * harness set (see {@link AssetManager.targetHarnesses}) for a global manager.
-     */
-    deployTargets(): HarnessName[];
-    private get storeCacheDir();
-    private get reposDir();
-    /**
-     * Project-scoped cache dirs rooted at `.skaile/cache/` (`store`, `sources`)
-     * relative to `projectDir`. Reading is a side effect: it triggers lazy
-     * migration of the legacy `.skaile/{store-cache,repos}` dirs.
-     */
-    get projectCacheDirs(): {
-        store: string;
-        sources: string;
-    };
-    private get lockPath();
-    private get patchDir();
-    /** Deploy options for one harness. In global mode, `harness` is the
-     * fan-out target (not the constructor's `harness`, which is project-only). */
-    private deployOptsFor;
-    /** Agent name → the `../` compose folder files its lock entry records (`LockEntry.composed`). */
-    private composedRecords;
-    /** `install`'s `Missing:` line for a `../` compose folder the library moved past the lock. */
-    private composedDriftLine;
-    /**
-     * Names of the `mcp-server` assets the lock holds (the declaration ids, unscoped); a missing
-     * `.mcp.json` entry of one counts as drift even before skaile owned it.
-     */
-    private lockedMcpNames;
-    /**
-     * The payloads and managed `.mcp.json` entries of the project's **locked** `mcp-server`
-     * assets that differ from what the declarations render (see {@link mcpServerDrift}), one row
-     * per server, named by the lock identity `mcp-server:@publisher/name`; `key` is the lock key.
-     * An `mcp_servers:` entry of `skaile.yaml` is configuration, not a locked asset: it has no
-     * row. Empty for a global manager and for a project that locks no `mcp-server`.
-     */
-    private mcpDriftRows;
-    /**
-     * What the render wrote for the `mcp-server` asset `name` into the coding agent's MCP
-     * config: the config file and, for a server with a payload, the payload directory
-     * (project-relative). `written` is false when the render left the server out (see
-     * {@link AssetManager.mcpNotices}). `undefined` when the harness has no MCP config skaile
-     * writes (`codex`, `omp`) or for a global manager: the asset is composed at run time only.
-     */
-    mcpRenderFootprint(name: string): Promise<{
-        file: string;
-        payloadDir?: string;
-        written: boolean;
-    } | undefined>;
-    /**
-     * The declared MCP servers whose `.mcp.json` entry skaile wrote and nothing edited, but that
-     * `skaile.yaml` (or a newer asset) now renders differently: the config waits for
-     * `skaile install`. Covers a locked `mcp-server` and an `mcp_servers:` entry alike; the
-     * server is named by its lock identity when it has one, else `mcp-server:<id>`. Empty for a
-     * global manager.
-     */
-    private mcpPendingRender;
-    /**
-     * Render the project's declared MCP servers into the harness target's own
-     * native MCP config (`<project>/.mcp.json` for `claude-code`), so the coding
-     * agent sees the same servers skaile's agent loop wires up.
-     *
-     * Project scope only: a `--global` install has no project-scope config to
-     * write, and the coding agent's user scope is a large user-state file this
-     * must not touch. Never fails an install — a render error is warned and
-     * swallowed.
-     *
-     * @returns The payload files and config entries the render wrote back (and the files it
-     *   removed) because they had drifted from the declaration: `install` names them, as it does
-     *   a restored skill file.
-     */
-    private renderHarnessMcpConfig;
-    /**
-     * Whether a project-relative path is a file an agent instance renders (the ledger's files). An
-     * instance claims files and folders (omp renders a folder): a file under a claimed folder is
-     * claimed too.
-     */
-    private instanceClaims;
-    /**
-     * Whether the path `rel` that the lock lists under `rendered:` for the agent `name` is a file
-     * named after the asset that an instance's file (or the `binding: run` role) stands for now.
-     * Such a path is no part of the rendering the lock expects any more: a lock of 5.13.0 and older
-     * still lists it, `install` drops it at the next lock write, and until then it is neither a
-     * missing nor an edited copy. Always `false` in global mode.
-     */
-    private supersededRendering;
-    /**
-     * The files named after an agent asset that an earlier CLI rendered and this one does not: the
-     * agent is bound by an instance (its rendering is the instance's file), or it only runs as a
-     * `binding: run` role. A file counts when no instance of the ledger claims it and either the
-     * lock lists it for the agent (`edited` when its bytes differ from the recorded ones), or the
-     * lock records no rendering for the agent at all (5.11.0 and older) and the file is the
-     * instance's render under the asset's name. A file of the second kind that differs from that
-     * render may be the user's own and is not listed. Project mode only.
-     */
-    private leftoverAgentFiles;
-    /**
-     * Remove the leftover files {@link leftoverAgentFiles} lists. A file edited since the lock
-     * stays (it is the user's now) and is named. The old lock entry is rewritten by the same
-     * install, so the lock never keeps a path that is gone; `install --locked` leaves the lock,
-     * which `check` does not read for a file that is gone.
-     *
-     * @returns The project-relative paths removed.
-     */
-    private pruneAssetNamedAgentFiles;
-    /**
-     * The `check`, `doctor` and `outdated` lines for the files {@link leftoverAgentFiles} lists: an
-     * untouched one is removed by the next `install` (and by `install --locked`), an edited one
-     * stays. Empty in global mode and when nothing is left over.
-     */
-    leftoverAgentFileNotices(): string[];
-    /**
-     * Render every agent instance of `skaile.yaml` into the harness target's native
-     * agent files (`.claude/agents/<id>.md`, …) and prune the renderings of
-     * instances that left the config. Runs after the skills deploy, so composed
-     * skills resolve. Project scope only. An instance whose `ref` resolves to no agent is
-     * reported in `agentInstanceErrors`; any other render error is warned and swallowed.
-     *
-     * @param opts.prune - Also remove the files named after the agent assets that an earlier CLI
-     *   rendered and an instance renders now ({@link pruneAssetNamedAgentFiles}). Set by the
-     *   commands that deploy or re-lock; the lock is left as it is by `install --locked`.
-     */
-    private renderAgentInstances;
-    private loadConfig;
-    /** Build provenance-index clones from the resolved source declarations; a clone folder with no git checkout goes to `onSourceError`. */
-    private buildClones;
-    /**
-     * Bridge a resolved {@link ProvenanceCandidate} to a {@link CatalogEntry} for
-     * the deploy pipeline. `source` is the absolute path to the asset's primary
-     * manifest (or its directory) inside the clone; `publisher` is set to the
-     * clone slug so `deployAll`'s repositories lookup resolves local-vs-remote.
-     */
-    private candidateToCatalogEntry;
-    /**
-     * The {@link ProvenanceCandidate} a source- or store-origin lock entry stands for: what a
-     * deploy needs to restore the asset from the commit the lock names (`files[]` is the asset's
-     * whole file set). `null` for a library-origin entry or a key that is not a canonical ref.
-     * The source URL is the declared source's own spelling (the bundled factory tree and a
-     * `sources:` entry match their declaration by it).
-     */
-    private lockedCandidate;
-    /**
-     * Resolve refs the source/store pass could not against the user's registered
-     * **libraries** (local authoring places). Each library dir is scanned on disk
-     * under its declared publisher (its root `skaile.manifest.yaml`, falling back
-     * to the kebab-cased library name); a matching asset becomes a deployable
-     * {@link CatalogEntry} whose `source` points at the on-disk manifest. This is
-     * the consume side of `library create` — a freshly authored asset is
-     * deployable with `skaile add <kind>:@<publisher>/<name>` without publishing.
-     *
-     * Local read (no network) and mirrors how `findSkills` discovers library
-     * content. The returned `libraryOf` map names the library each entry came from
-     * so callers can lock it as library-origin (see {@link libraryLockEntries}).
-     *
-     * @param opts.quiet - Skip the cross-library collision warning (a lookup that only
-     *   builds an error hint must not warn).
-     * @param opts.library - Resolve only from this library (the one a lock entry names), not
-     *   from every registered one. Never warns: no choice is made between libraries.
-     * @param opts.lockedLibraries - `kind:publisher/name` → the library its lock entry names
-     *   ({@link AssetManager.lockedLibraryNames}). A ref listed here resolves from that library
-     *   when it holds a match, whatever the default library is.
-     * @returns the matched deploy entries, the set of `missing` refs covered, and
-     *   each entry's originating library name.
-     */
-    private resolveLibraryEntries;
-    /**
-     * Scan every candidate library (the set {@link resolveLibraryEntries} resolves from)
-     * into `kind:@publisher/name` → every holder, across all libraries and versions.
-     *
-     * @param minRoots - Return `null` without scanning when fewer candidate libraries
-     *   exist (a cross-library question needs at least two).
-     * @returns `null` when there is no candidate library or none holds an asset.
-     */
-    private scanLibraries;
-    /**
-     * Every ref that more than one registered library holds, with one row per holder
-     * (all libraries, all versions) in the order `add` prefers them: the first row is
-     * the one `add <ref>` deploys. `search` reads this to group the index rows of a ref
-     * (one per library) and mark the copy `add` deploys; the versions come from the files
-     * themselves, which the index follows only after the next `skaile library index`.
-     *
-     * @returns `kind:@publisher/name` → holders; refs held by one library are absent.
-     */
-    libraryHolders(): Promise<Map<string, LibraryHolder[]>>;
-    /**
-     * Every asset a registered library holds, read from the library directories themselves
-     * (not the local index, which lags behind them until the next `skaile library index`).
-     * One row per holder, all versions.
-     *
-     * @returns `[]` when no library holds an asset. Never warns.
-     */
-    libraryAssets(): Promise<Array<{
-        entry: CatalogEntry;
-        library: string;
-    }>>;
-    /**
-     * The version `add` deploys for each asset of a source clone registered as a `reader`
-     * library, when its file declares none: the repo commit pseudo-version (p855). `search`
-     * reads this where no project is in scope, so it lists what `add` locks, not the index
-     * default.
-     *
-     * @returns `<library>\0<kind>:@<publisher>/<name>` -> version; only assets that declare none.
-     */
-    sourceAssetVersions(): Promise<Map<string, string>>;
-    /**
-     * Every origin that holds `ref` (`kind:@publisher/name`) with the version it holds, in
-     * the order `add <ref>` prefers them, so the first row is the one `add` deploys: the
-     * project's source clones and the bundled factory source (highest version first), then
-     * the registered libraries. `add`, `info` and `search` all read this, so the three name
-     * one origin for one ref. Stores are not asked (no network).
-     *
-     * @returns one row per origin and version; `[]` for a ref without a publisher or one
-     *   nothing holds. Never warns.
-     */
-    refOrigins(ref: string): Promise<RefOrigin[]>;
-    /**
-     * Every ref (`kind:@publisher/name`) that several origins hold at different versions,
-     * with its origins in {@link refOrigins} order. A ref the origins hold at one version
-     * has nothing to choose between and is left out.
-     */
-    competingOrigins(): Promise<Map<string, RefOrigin[]>>;
-    /**
-     * The origins of {@link refOrigins} for every ref, keyed by `kind:@publisher/name`: the
-     * version in each row is the one `add` locks (a source asset whose file declares none is
-     * `0.0.0-sha.<commit>`), which `search` lists too (p855).
-     */
-    allOrigins(): Promise<Map<string, RefOrigin[]>>;
-    /**
-     * The origins of {@link refOrigins} for every ref, or for the one `only` names
-     * (`kind:@publisher/name`), keyed by `kind:@publisher/name`.
-     */
-    private collectOrigins;
-    /**
-     * Where each missed publisher-qualified ref went when its publisher changed, for every
-     * ref at once (one library scan, one lock read):
-     * - `moved` when a registered library holds the same kind + name under another publisher.
-     *   When the lock ties the missed ref to a library, only that library is looked at (an
-     *   asset of the same name in another library is a different asset). Without a lock
-     *   entry, a library asset the project already declares or locks under its own ref is
-     *   not offered, and two candidate publishers are ambiguous: no hint;
-     * - `lockedAs` when the lock holds the same kind + name under another publisher, records
-     *   the library it came from, and that library now holds the asset under yet another
-     *   publisher than the locked one. An unrelated asset that merely shares kind + name does
-     *   not qualify.
-     *
-     * @param refs - Missed refs; a trailing `(reason)` after the first space is ignored.
-     * @returns one finding per ref that has one. Never warns.
-     */
-    private publisherChangeFindings;
-    /**
-     * Explain misses caused by a publisher change, as parenthesized hint text per ref:
-     * `did you mean <ref>?` when a registered library holds the same kind + name under
-     * another publisher, and `locked as <lockRef>; run skaile install to re-resolve` when
-     * the lock holds it under the library's previous publisher (see
-     * {@link AssetManager.publisherChangeFindings}).
-     *
-     * @param refs - Missed refs; a trailing `(reason)` after the first space is ignored.
-     * @returns hint text per ref, only for refs that have one. Never warns.
-     */
-    private publisherChangeHints;
-    /**
-     * What the user has to change for each ref that is locked from a library but resolves
-     * nowhere any more, where `skaile install` cannot help: the library is not registered
-     * (renamed away or removed), the library now publishes the asset under another
-     * publisher, or the library no longer holds it. A ref the lock does not tie to a
-     * library has no entry.
-     *
-     * @param refs - Declared or locked refs, `kind:@publisher/name` (a trailing `(reason)`
-     *   after the first space is ignored).
-     * @returns a phrase per ref that follows the ref name, without parentheses.
-     */
-    private unresolvedFixes;
-    /**
-     * A ref pinned to a version its library never held (`#9.9.9`): the thing to change is the pin
-     * in `skaile.yaml`, not the library (p1096). Sets the fix and returns `true` when it applies.
-     */
-    private pinNeverHeld;
-    /**
-     * The ref a library now holds a flow under when a project still locks it by the slug of the
-     * flow's `name:` (5.12.0 named a flow by `name:`; later releases name it by `id:`), or
-     * `undefined` when `kind` is no flow, the library is not at hand or no flow of it matches.
-     */
-    private renamedFlowRef;
-    /** Collision messages already printed by this instance (one warning per ref + library set). */
-    private readonly warnedLibraryCollisions;
-    /**
-     * Collisions of one `add`, held back until {@link flushLibraryCollisions} so a dependency
-     * tree that touches several colliding assets prints one summary, not one line per asset
-     * (p1097). `null` outside an `add`: a collision then warns at once.
-     */
-    private collisionBatch;
-    /**
-     * Warn once when `key` is held by more than one library: names every library
-     * with its version and the one chosen, so a silent pick can't surprise.
-     */
-    private warnLibraryCollision;
-    /** Print each distinct collision message once; the sink also gets the keys it names. */
-    private emitLibraryCollision;
-    /**
-     * End the batch of {@link collisionBatch}: one collision prints its full message; several
-     * print one summary (how many libraries and assets, the library each asset came from, the
-     * assets whose bytes differ). `verboseCollisions` prints every asset's full message instead.
-     */
-    private flushLibraryCollisions;
-    /** Kind, name and bare publisher of a deploy entry; the publisher comes from its canonical ref. */
-    private entryIdentity;
-    /**
-     * Refuse to lock a source commit another machine cannot check out. A commit made in the clone
-     * itself (or one `source sync` could not fast-forward past) is in no remote branch: the lock
-     * would name bytes nobody else has, and `install --locked` there could not restore them.
-     * Linked (dev-override) and user-owned local sources are never checked: their lock is
-     * machine-local by choice.
-     *
-     * @param resolved - Candidates about to be locked.
-     * @param repositories - Source declarations of the project.
-     * @throws With `<url> clone has unpublished commit <sha>` and the way out.
-     */
-    private assertSourceCommitsPublished;
-    /**
-     * Refuse assets of one kind and name from different publishers: they deploy into the
-     * same folder, so the later one would silently overwrite the earlier. Throws one line
-     * naming the folder and the asset that holds it.
-     *
-     * @param incoming - Assets about to be deployed. Two of them clashing is refused.
-     * @param held - Assets the project already declares or has locked; one of them
-     *   clashing with an incoming asset is refused when its folder is on disk.
-     */
-    private assertNoFolderCollision;
-    /**
-     * Refuse to deploy over a folder (or agent file) the project did not put there: it is on disk,
-     * but no lock entry of the same kind and name owns it, so it is the user's own work and the
-     * deploy would replace it and `remove` would delete it. Throws one line naming the folder.
-     *
-     * A folder the deploy would rewrite with the same content is adopted silently (the way back
-     * from `asset import`: the project's own copy is what the library now holds): every file in
-     * it is shipped by the asset with the same bytes, or the same body and an asset frontmatter
-     * that only adds to the folder's (import normalizes it). Nothing is lost then.
-     *
-     * @param incoming - Assets about to be deployed, with the entry whose bytes would be written
-     *   when there is one.
-     * @param owned - Assets the lock holds; one of the same kind and name, from any publisher,
-     *   owns the folder (a publisher clash is {@link assertNoFolderCollision}'s refusal).
-     */
-    private assertNoUnownedFolder;
-    /**
-     * Whether deploying `entry` over the folder already in `target` loses nothing: the folder
-     * holds no file the asset does not ship, and each of its files equals the asset's, or is a
-     * markdown file with the same body whose frontmatter the asset's only extends.
-     */
-    private deployWouldOnlyRewriteSame;
-    /**
-     * Open the local index and snapshot its libraries + asset definitions, scoped to this
-     * project's `sources:` ({@link scopeLibraryIndex}).
-     * Best-effort: no index file (never indexed), or any open/guard failure,
-     * yields `null` — a lock/outdated read must never create `index.db` or throw.
-     */
-    private loadLibraryIndex;
-    /**
-     * The `sources:` this project declares by clone key, or `undefined` outside a project (no
-     * `skaile.yaml` in `projectDir` or a parent) or when the file does not parse. Outside a
-     * project nothing declares sources, so the machine-wide search reads every clone.
-     */
-    private declaredSourceEntries;
-    /** The clone-cache key a source-clone reader row stands for, or `undefined` for any other library. */
-    private sourceCloneKey;
-    /**
-     * Ids of the registered libraries that are the clone of a source this project does not
-     * declare. `source add` registers the clone as a machine-wide reader library so `search`
-     * and the indexer can read it, but a `sources:` clone belongs to the projects that declare
-     * it (OQ4, p321): another project neither resolves it, nor ties with it by name, nor has
-     * `update` re-pin its locked assets to it. A reader library the user registered by hand
-     * (`library init --reader --git`) lives outside the sources cache and is never hidden.
-     */
-    undeclaredSourceClones(libraries: readonly Library[]): Set<string>;
-    /**
-     * The registered libraries as `library list` shows them in this project. A source clone is
-     * cache: its row is read from the clone, so it is dropped when the clone is gone and
-     * when this project does not declare the source. `sources` holds the ids of the clone rows
-     * that stay, so the list can mark them `(source)`.
-     */
-    scopeLibraryList(libraries: readonly Library[]): {
-        libraries: Library[];
-        sources: Set<string>;
-    };
-    /**
-     * The index as this project sees it: the source clones of other projects are dropped
-     * ({@link undeclaredSourceClones}) and the assets of a declared source carry the publisher
-     * this project's `sources:` entry names. The clone and its index rows are shared by every
-     * project that declares the source, so a project that declares another `--publisher` is
-     * re-labelled here, at read time, and never changes what the others see (p1822).
-     */
-    scopeLibraryIndex(libraries: Library[], defs: AssetDefinition[]): {
-        libraries: Library[];
-        defs: AssetDefinition[];
-    };
-    /**
-     * Library-origin lock entries for the assets {@link resolveLibraryEntries}
-     * matched. The locked version is the one actually deployed: the on-disk
-     * entry's version, falling back to the library index only when the disk entry
-     * carries none — the index lags until the next `skaile library index`, so
-     * preferring it would lock a stale version after an in-place bump. The hash is
-     * computed from the files on disk, so it matches what `install --locked`
-     * re-hashes.
-     *
-     * A git-backed library also records its remote URL. When the previous lock names the
-     * library under another name that {@link lockedLibrary} matched to this one by URL (a
-     * teammate registered the same remote under a different name), the entry keeps the locked
-     * name and URL: the lock does not change because it was installed on another machine. A
-     * library renamed on this machine with `library rename` is locked under its new name.
-     */
-    private libraryLockEntries;
-    /**
-     * The entries a deploy would write into some target harness: those without a current deployed
-     * copy. An intact copy stays as it is, so a library change that does not reach it (a symlink
-     * added next to the files) stops no `install` or `update` (p1857).
-     */
-    private needingDeploy;
-    /**
-     * The files of a library asset that git has not committed (edited, new or staged only), as
-     * paths relative to the library root. The asset's own folder, or its one manifest file when it
-     * shares the folder with other assets. Empty when the asset is not in a git work tree.
-     */
-    private uncommittedAssetFiles;
-    /**
-     * Warn when a library with a git remote has uncommitted changes in the folders of the assets
-     * `add` or `install` lock: the lock records the bytes on this disk, which no clone of the
-     * remote holds, so a teammate (or CI) cannot restore them. One line per library naming the
-     * files; the command goes on (OQ5, p1859).
-     */
-    private warnUncommittedLibraryAssets;
-    /**
-     * Whether every declared ref is locked and no declared pin differs from the locked version:
-     * `skaile.yaml` asks for nothing the lock does not hold. A declared preset counts when the
-     * lock records it.
-     */
-    private declaredMatchesLock;
-    /**
-     * Lock keys that `skaile.yaml` still wants: the entries a declared ref names, plus every
-     * entry such an asset requires, transitively. All keys when a `preset:` is declared.
-     */
-    private declaredLockKeys;
-    /**
-     * The `Missing:` lines of every library-origin lock entry whose library cannot supply
-     * assets on this machine (not registered, or registered with its directory gone). Plain
-     * `install` stops on a non-empty list, the same lines `install --locked` prints: it must
-     * not re-resolve a locked asset from another origin. The ONE function that decides "the
-     * locked library is not here", so a store-restore fallback extends it in one place.
-     *
-     * An entry `install --locked` already restored from a store (its library is not registered
-     * here and the store cache holds the locked version, see {@link restoredFromStoreCache}) is no
-     * line: it is returned in `restored`, and plain `install` then restores the lock as
-     * `install --locked` does instead of re-resolving it from another origin (OQ8, p1655).
-     *
-     * Only entries `skaile.yaml` still declares, or that a declared asset requires
-     * (transitively, read from the deployed copy), count. A stale entry nothing declares is
-     * pruned by `install` as usual, so a removed dependency whose library is gone can be
-     * cleaned up. With a declared `preset:` every entry counts: the lock records no edge
-     * from a preset to its items, and the preset's own library may be the one that is gone.
-     *
-     * @param declared - The `dependencies:` refs as written in `skaile.yaml`.
-     */
-    private unavailableLockedLibraries;
-    /**
-     * Re-resolve every library-origin lock entry from its named library, for
-     * `install --locked`. An entry is restored only when its library is still
-     * registered/on disk, still holds the asset, and still offers the locked
-     * version; anything else is reported in `missing` with the reason.
-     *
-     * @param opts.storeFallback - `install --locked` only: an entry whose library is not registered
-     *   here is restored from a store that serves the locked sha256 (OQ8, OQ15, p1490, p1655). The
-     *   lock records the library's remote and hash but no commit and no file list, so the library
-     *   remote itself cannot be fetched at a locked commit; the store pointer names the upstream
-     *   repository and commit that hold exactly the hashed bytes. Reads such as the drift check
-     *   never ask a store.
-     */
-    private restoreLibraryLockEntries;
-    /**
-     * Whether a library-origin lock entry was restored from a store: its library is not
-     * registered here, and the project's store cache holds the locked version (`install --locked`
-     * fetched it there and SHA-verified every file against the sha256 the lock recorded). Such an
-     * entry is as restorable as a source- or store-origin one: `check`, `doctor` and plain
-     * `install` read its requirements from the deployed copy and do not ask for the library (OQ8,
-     * p1655). An unregistered library that never restored anything here stays a gap.
-     *
-     * This only checks that the cache directory of the locked version is not empty: the bytes were
-     * verified when they were fetched, and a later edit of the deployed copy is the `modified`
-     * drift check's job, not this one's.
-     */
-    private restoredFromStoreCache;
-    /**
-     * The store's copy of a library-origin lock entry whose library is not registered here: a
-     * store (project `stores:` or the global catalog) that serves `kind:@publisher/name#version`
-     * under the very sha256 the lock recorded holds the same bytes. The entry is fetched and
-     * verified like any store asset; the lock stays as it is. `null` when the lock has no hash,
-     * no store answers, or the hash differs (OQ15, p1490). `from` names the store and the
-     * upstream repository and commit its pointer gives, for the notice.
-     */
-    private storeEntryForLockedLibraryAsset;
-    /**
-     * Whether a deployed copy exists for the lock entries `install` kept for the unresolved
-     * `ref`. A kind with no install target has none, except an `mcp-server`: its copy is the
-     * `.mcp.json` entry skaile wrote and the payload that entry points into (p792).
-     */
-    private keptCopyDeployed;
-    /** Whether the deployed copy of a library asset is on disk; a kind with no install target has none to check. */
-    private lockedCopyDeployed;
-    /**
-     * The library-origin lock entries `install` keeps when the library holds a newer version:
-     * only `update` moves a locked asset, so `install` restores the locked one (p1095).
-     * Keyed by `<publisher>/<kind>:<name>`. `requires` is what the locked version needs: the
-     * lock's own list, or for a lock that predates the field the deployed copy's requirements,
-     * never the newer library entry's.
-     */
-    private keepLockedLibraryEntries;
-    /**
-     * How the library `origin` names stands on this machine. THE one lookup of a locked library
-     * ("is it registered here?"): `check`, `outdated`, `install` and `install --locked` all ask it.
-     *
-     * - registered in the index under its name: `ok` at its registered path, or `dir-missing` when
-     *   that directory is gone;
-     * - not registered: a directory `<libraries dir>/<name>` nobody unregistered still counts as a
-     *   hand-made library (`ok`). One `library remove` unregistered without `--purge` does not
-     *   (it stays on disk but no longer resolves), and neither does the reserved `installed` folder.
-     * - otherwise, when the lock recorded the library's remote URL: another registered library
-     *   whose git remote is the same repository (`.git` suffix, trailing `/` and the
-     *   `git@host:o/r` / `https://host/o/r` forms do not matter) and whose directory exists is
-     *   `ok`, with `name` set to the name it is registered under here. The library name is
-     *   machine-local; the remote is what a clone shares.
-     */
-    private lockedLibrary;
-    /**
-     * Why `install --locked` cannot restore a locked library asset from its library: the library
-     * holds another version than the lock (`library "x" is at 0.1.1, locked 0.1.0`) or the locked
-     * version with other bytes (`library "x" content changed since lock`). Only `update` moves
-     * the lock to it. `undefined` when the library is not here, no longer holds the asset, or
-     * still holds the locked files (the other gaps say what is wrong then).
-     */
-    private libraryAheadOfLock;
-    /** The registered library whose files for `asset` hash to `sha256` (the locked bytes), if any. */
-    private libraryHoldingLockedBytes;
-    /** On-disk root of the library `origin` names; `null` unless {@link lockedLibrary} says `ok`. */
-    private libraryPath;
-    /**
-     * Rename the library every library-origin lock entry names: `library rename <interim> <old>`
-     * puts a library back under its old name, and an entry locked in between would keep the
-     * interim name, so a later "register library again" advice would name a library nobody knows
-     * any more (p893). Nothing is written when no entry names `from`.
-     *
-     * @returns the number of lock entries renamed.
-     */
-    renameLockedLibrary(from: string, to: string): number;
-    /**
-     * The `kind:@publisher/name` identities the lock holds for one `kind` and `name`, whatever
-     * their publisher. `diff` uses it to accept a ref without a publisher only when it names
-     * exactly one locked asset.
-     */
-    lockedRefsNamed(kind: string, name: string): string[];
-    /**
-     * The library a library-origin lock entry of `kind` and `name` (and `publisher`, when given)
-     * resolves to on this machine, or `undefined` when the lock holds no such entry, it is not
-     * from a library, or its library is not here. `info` prints it next to `source:`.
-     */
-    lockedLibraryOf(kind: string, name: string, publisher?: string): Promise<string | undefined>;
-    /**
-     * Where each library-origin lock entry of this project resolves on this machine: identity
-     * `kind:publisher/name` (no scope sigil, no version) → the name the locked library is
-     * registered under here. The name differs from the locked one when the lock's remote URL
-     * matched another registered library ({@link lockedLibrary}). A deployed entry whose library
-     * resolves nowhere (not registered, directory gone) maps to `null`.
-     *
-     * Direct `asset install` entries (`library.installed`) are included and resolved the same
-     * way, but they map to the locked library name when that lookup fails: such a copy sits in
-     * the project and does not depend on the library still being registered. A missing or
-     * unreadable lock yields an empty map. `skaile manage` uses it to tick the right library row.
-     */
-    lockedLibraryNames(): Promise<Map<string, string | null>>;
-    /**
-     * What `update` prefers when libraries tie: the library each lock entry resolves to here
-     * ({@link lockedLibraryNames}, a `library rename` followed) and the sha256 it locked.
-     */
-    private lockedPreference;
-    /**
-     * Canonical refs of the locked source assets that share a source URL with `resolved` but
-     * are locked at another commit than the one `resolved` carries for it. Assets in `resolved`
-     * and library-origin entries are skipped.
-     */
-    private staleSourceSiblingRefs;
-    /**
-     * The lock entries that came from a source or the store (a `source:`, no `library:`), by
-     * identity `<publisher>/<kind>:<name>` -> locked version. The lock's origin
-     * wins: a library registered later that holds the same ref does not take such an asset
-     * (`update`, `install`, `add`; OQ15, p1490).
-     */
-    private lockedOriginVersions;
-    /**
-     * The locked assets whose entry says `origin: store`, by identity -> the store URL. A store
-     * origin is a pin: no source that holds the same ref takes the asset until `skaile remove`
-     * and `skaile add` move it (`update`, `install`, `add`). A declared ref whose `#pin` the
-     * locked version does not satisfy is the user asking for another version: it is not pinned.
-     *
-     * @param declared - The `dependencies:` refs of `skaile.yaml`.
-     * @param asked - Refs being resolved now.
-     */
-    private storePinnedIdentities;
-    /**
-     * Say which registered library holds a ref the lock keeps on its source or the store: the
-     * candidate that lost, with the way to switch (p1490). Printed once per `add`.
-     */
-    private noteLosingLibraries;
-    /** A candidate's stable identity key (`<publisher>/<kind>:<name>@<version>`). */
-    private candidateKey;
-    /**
-     * Resolve `deps`, falling back to the global `catalog.url` store when the
-     * project declares no store and the first pass leaves something missing.
-     *
-     * The first pass uses the project stores only, so locally-resolvable refs
-     * never trigger a network probe. The fallback retry is best-effort: any error
-     * (offline, store down) keeps the first pass's result rather than regressing.
-     */
-    private resolveWithStores;
-    /**
-     * Resolve `deps` library-first, then walk the dependencies of every library
-     * asset it picks.
-     *
-     * A publisher-qualified ref that no project source declares is looked up in the
-     * registered **libraries** before any store is asked, so a locally authored
-     * asset resolves (and deploys) with the store unreachable and without a
-     * version-discovery round trip. Only refs the libraries did not satisfy go to
-     * {@link resolveWithStores}; its misses get one more library try (a ref a source
-     * knows only under another version). A `#version` pin still selects through
-     * `matchPin` inside {@link resolveLibraryEntries}.
-     *
-     * Library assets declare `dependencies` / `requires`. Those are fed back through
-     * the same resolution with a `seen` identity set (mirrors `resolveAll`), so deps
-     * deploy, get lock entries, and a dependency cycle terminates.
-     *
-     * @returns source/store candidates, still-unresolved refs, applied overrides,
-     *   expanded presets, and the library leg (entries + originating library per entry).
-     */
-    private resolveLibraryFirst;
-    /**
-     * A source asset without a declared version is keyed `0.0.0-sha.<repo commit>`, so every
-     * commit of its repo would re-key (and re-lock, and report as updated) every asset of
-     * that repo, changed or not. Keep the locked key and version of an asset whose files hash
-     * to what the lock holds: `update` then re-locks only what changed, as `outdated` lists.
-     * The commit stays the clone's, so the lock's `sources:` row still names the bytes' commit.
-     * A ref the user pinned (`#<version>`) keeps the version it names.
-     */
-    private keepUnchangedSourceVersions;
-    /**
-     * The catalog fetcher to use: an injected one, else built from `stores`. `catalogUrl: ""`
-     * (`update --no-catalog`) asks no store at all, project `stores:` included.
-     */
-    private storeFetcherFor;
-    /**
-     * The global `catalog.url` as a single-store fallback, or `[]` when no
-     * project store should be synthesized — `local` sentinel, already-declared,
-     * or no URL. Honours an explicit `catalogUrl` injection (`""` and `"local"` disable it).
-     */
-    private globalStoreFallback;
-    /**
-     * Build deployable catalog entries from resolved candidates. Store-resolved
-     * candidates (no local clone bytes) are fetched + SHA-verified into the
-     * project store-cache first, then their entry points at the staged bytes so
-     * the existing copy-deploy path works. Source-backed candidates keep the
-     * clone-relative entry.
-     */
-    private buildCatalogEntries;
-    /**
-     * The tail of a `hash mismatch for <file>: expected <lock>, got <fetched>` failure of a locked
-     * restore when the deployed copy already holds the fetched bytes: the lock records another
-     * hash for the file, and `install` (not `install --locked`) writes the right one. Empty for
-     * any other failure, and when the copy is missing or differs from the fetched bytes.
-     */
-    private wrongLockHashHint;
-    /**
-     * Fetch + SHA-verify the bytes of every store-resolved candidate that needs
-     * bytes on disk into `.skaile/cache/store/`, reusing the same verified-fetch
-     * path the pointer-only `library.install` uses (`installFromManifest` flat
-     * mode). Every kind with bytes, composition-only kinds included.
-     *
-     * @returns Map of candidate key → staged primary-manifest path.
-     */
-    private stageStoreAssets;
-    /**
-     * The requirements a store candidate's own manifest declares (`metadata.requires`, a manifest
-     * `dependencies:`) that its catalog row did not list, read from the staged bytes. The catalog
-     * row is the store's own summary and may hold only same-kind ones; the deployed copy is what
-     * `check` reads, so a requirement only the manifest names would be missing right after `add`
-     * (p1221). Each one is added to the candidate's `deps` and `storeRequires` (the lock records
-     * them) and returned so the caller resolves, deploys and locks it like any other dependency.
-     * A candidate whose bytes come from a source clone, or that has none, adds nothing.
-     */
-    private readStoreCandidateRequires;
-    /** Repo-relative path of a candidate's primary manifest (un-stripped). */
-    private primaryManifestRel;
-    /**
-     * The primary-manifest path relative to a staged asset dir. Takes the kind's
-     * manifest (e.g. `SKILL.md`), then strips the same common-dir prefix
-     * `installFromManifest` flat mode removed on write.
-     */
-    private stagedManifestRel;
-    /**
-     * `true` when a candidate's primary manifest is present on a local source
-     * clone — its `sourceUrl` matches a registered source AND the manifest file
-     * exists on disk at the expected path. A URL match alone is not enough: a
-     * store can pin a different commit (or a subtree not bundled) of a repo that
-     * is also a registered source, in which case the bytes must be fetched from
-     * the store rather than read from the clone. (Only the primary manifest is
-     * probed — a partially-cloned source is deployed as-is, matching the existing
-     * clone-deploy path.)
-     */
-    private candidateHasLocalBytes;
-    /** Build a copy-deploy catalog entry pointing at staged store bytes. */
-    private stagedCandidateToEntry;
-    /**
-     * Install all dependencies declared in `skaile.yaml`.
-     *
-     * Steps: clone/pull repositories → resolve transitive dependencies → reconcile
-     * (remove stale assets) → deploy new assets → write `skaile.lock.yaml` → record history.
-     *
-     * @param opts - Optional installation options.
-     * @param opts.locked - When `true`, restore the exact versions recorded in the existing
-     *   lock file instead of resolving from source. Throws if no lock file is found, unless the
-     *   project declares no dependencies (nothing to restore).
-     * @param opts.link - When `true`, symlink local-path assets instead of copying them
-     *   (the author dev-loop). Machine-local / not for committing; a no-op for
-     *   store/factory sources. Defaults to copy.
-     * @param opts.moveLibraries - When `true` (`skaile update`), a locked library asset is
-     *   re-resolved from every library and may move to another one; {@link InstallResult.moved}
-     *   lists the moves. Without it a locked asset stays on the library its lock entry names.
-     * @returns {@link InstallResult} summarising what was deployed, what was missing, and any collisions.
-     */
-    install(opts?: {
-        locked?: boolean;
-        link?: boolean;
-        moveLibraries?: boolean;
-        /** Deploy over a folder no lock entry owns (a hand-made skill of the same name) instead of refusing. */
-        force?: boolean;
-    }): Promise<InstallResult>;
-    /**
-     * Why `install` asks no store, or `undefined` when it does: `--no-catalog`, or `catalog.url:
-     * local` with no `stores:` entry in `skaile.yaml`. A locked store asset is then kept as it is,
-     * as for an air-gapped client.
-     */
-    private whyNoStoreAsked;
-    /**
-     * The kept refs whose locked copy came from a store that `install` did not (or could not)
-     * ask, and whose deployed copy is still there: nothing says the copy is wrong, so it stays
-     * and the run does not fail on it. A ref whose store answered "no such asset", one with no
-     * deployed copy, and one a source or library used to supply stay missing.
-     *
-     * @param declaredSourceUrls - The `sources:` URLs of `skaile.yaml`; a lock entry from one of
-     *   them is that source's, not the store's.
-     */
-    private storeNotCheckedRefs;
-    /**
-     * Extend `kept` (see {@link keptLockEntries}) with every previous lock entry a kept asset
-     * requires, transitively, that the new lock (`freshKeys`) does not already carry. The lock
-     * records no edges, so they are read from the kept asset's deployed copy, where the
-     * requirement is publisher-qualified the same way a library scan does it. A copy that
-     * cannot be read has no known requirements.
-     */
-    private keepRequiredByKept;
-    /**
-     * Publisher-qualified refs the deployed copy of `id` requires, read from its own
-     * manifest file (`metadata.requires`, a manifest `dependencies:` entry): the one place
-     * the requirements stay knowable when no source or library holds the asset any more.
-     * A copy that is not deployed or cannot be read has no known requirements.
-     */
-    private deployedRequirementsOf;
-    /**
-     * The `requires:` the lock recorded for the store-resolved asset `id` (see
-     * {@link LockEntry.requires}): what its deployed copy cannot say, a store agent's skills.
-     * Empty for an asset the lock does not hold or records none for.
-     */
-    private lockedRequirementsOf;
-    /**
-     * Ensure all source clones are present/up to date. Returns an early
-     * {@link InstallResult} describing the failed source on the first error, or
-     * `null` when every clone succeeds.
-     */
-    private ensureSourceClones;
-    /**
-     * Best-effort twin of {@link ensureSourceClones} for the read-mostly entry
-     * points (`add` / `lock`): same declarations and the same pins — a pinned
-     * source must never be pulled off its pin — but a clone failure is swallowed
-     * so resolution still runs against whatever is on disk.
-     */
-    private ensureSourceClonesQuiet;
-    /** Lock entries `skaile asset install` wrote (copied/linked straight into the project). */
-    private directInstallLockEntries;
-    /**
-     * Refuse to prune a stale lock entry (in the old lock, not in the new resolved set, with no
-     * other version taking its place) whose deployed folder holds hand edits: the files that differ
-     * from the lock are named, nothing is removed, and `--force` prunes anyway (OQ6).
-     */
-    private assertNoHandEditsPruned;
-    /**
-     * Report (and, without `force`, guard) the files a re-lock deletes from a deployed copy
-     * (OQ5, p1441): the asset is locked already and its library or source now holds other content
-     * (`next` re-locks it), and the deployed folder holds files the new content does not ship. The
-     * deploy clears them. Two cases:
-     *  - the deployed copy still equals what `prevLock` recorded (per-file sha256 for a source
-     *    or store asset, the library hash for a library asset): the new version dropped those
-     *    files, nobody edited them, so they are deleted and come back as `removed` rows (an
-     *    `install`/`update` prints `Removed <file> (not part of <ref>)`), without a refusal;
-     *  - the copy diverged (a file the previous content did not ship, an edited file, or no hash
-     *    to compare): without `force` this throws one error naming the files and changes nothing.
-     *    A source or store asset names only the files the previous content did not ship (or that
-     *    were edited); a library asset records no file list, so it names every file to delete.
-     *
-     * @param entries - The catalog entries about to be deployed.
-     * @param next - The lock the run is about to write (or merge).
-     * @param libraryOf - The library each library-origin entry came from.
-     */
-    private relockDeletions;
-    /**
-     * Stop `install` from overwriting a hand-edited rendered agent file that no lock entry
-     * records (OQ5, p1440): the lock is gone (or never held the agent), so nothing tells an edit
-     * from a stale render, and the deploy would replace the file without a word. Checks the file
-     * named after each agent about to be deployed and the file of each agent instance whose bound
-     * agent has no lock entry. Throws one error naming each file that exists and differs from its
-     * render and changes nothing; `--force` (the caller skips this check) overwrites. A file that
-     * equals its render is not an edit. Project mode only.
-     */
-    private assertNoUnrecordedAgentOverwrite;
-    /**
-     * Stop a re-lock from replacing a hand edit of a deployed copy (OQ6, p1641): the asset is locked
-     * already, its library or source now holds other content (`next` re-locks it), and a deployed
-     * file differs from what the lock covers and from the new content. The deploy would replace
-     * the file without a word. Throws one error naming each file and changes nothing; `--force`
-     * (the caller skips this check) replaces them. An agent's rendered files are compared with the
-     * hashes the lock records. A file the new content brings back byte for byte loses nothing.
-     * Project mode only.
-     */
-    private assertNoHandEditsOverwritten;
-    /**
-     * Remove stale assets — those recorded in the old lock but absent from the
-     * newly resolved set (`resolved` source candidates plus `keep`, the canonical
-     * refs of library-origin assets locked in this run). Returns the list of
-     * removed refs.
-     */
-    private reconcileRemovedAssets;
-    /** Append `add`/`remove` history entries for a completed install reconcile. */
-    private recordInstallHistory;
-    /**
-     * Read the lock, returning null on a legacy v1 lock instead of throwing. A lock that is not
-     * valid YAML throws {@link LockParseError}: it is not an empty lock (p1892).
-     */
-    private tryReadLock;
-    /**
-     * A catalog client for `storeUrl` that honours `catalog.cache_ttl` (`0` = air-gapped: no
-     * network, so every lookup that is not cached throws `OfflineError`).
-     */
-    private remoteStore;
-    /**
-     * Remember why a store could not be asked (store URL → one line without a JS error class
-     * name), so `add` can say `store unreachable` instead of a bare `Asset not found`.
-     */
-    private noteStoreFailure;
-    /** Build a store fetcher from the configured stores, or undefined when none. */
-    private buildStoreFetcher;
-    /**
-     * Resolve runtime assets and install any missing npm peer deps.
-     *
-     * - Required deps: installed via `bun add --optional`. Failure is recorded
-     *   in `npmFailed` but does not throw — install() proceeds so users get a
-     *   useful error message rather than a hung command.
-     * - Optional deps: not installed automatically (would force every consumer
-     *   to pull every connector's deps). Future: add a flag to opt in.
-     */
-    private installRuntimeAssetDeps;
-    /**
-     * Give every ref `install` could not resolve, and that has no hint yet, the fix the shared
-     * {@link AssetManager.projectState} names for it (a declared ref no library or source holds,
-     * a requirement nothing holds). Runs after the deploy, so a requirer is known by then.
-     * Mutates `hints`: ` <reason>` follows the ref in the `Missing:` line.
-     */
-    private adviseMissing;
-    private installLocked;
-    /**
-     * One notice line per locked library that is not registered here and whose assets
-     * `install --locked` restored from a store: names the library, how many assets came from
-     * which store (and the upstream repository and commit its pointer names), and how to register
-     * the library to move the lock later (OQ8, p1655). Every file was SHA-verified against the
-     * hash the lock recorded.
-     */
-    private storeRestoreNotices;
-    /**
-     * The versions of `parsed`'s name that a source, a library or a store holds, newest first,
-     * for the `Asset not found` of a pinned ref. Empty for an unpinned ref (nothing was ruled
-     * out by a version) and when the name is unknown everywhere. A store that cannot be asked
-     * adds nothing here: its failure is reported by the caller.
-     */
-    private availableVersions;
-    /**
-     * The refs of the other kinds that a source or a library holds under the same publisher and
-     * name as `parsed` (`agent:@pub/captain` for a `@pub/captain` that is no skill), for the
-     * `Did you mean` of an `add` that missed.
-     */
-    private otherKindRefs;
-    /**
-     * The sentence that ends the not-found line of a ref that names no asset but whose name exists
-     * under another kind: refs of other kinds under the same name that a source, a library, the
-     * lock or `skaile.yaml` holds. For a ref written without a kind (`@pub/name`, which means
-     * `skill`) it is `Did you mean agent:@pub/name?`; for a kind-qualified ref of the wrong
-     * kind (`skill:@pub/captain`) it is `It is an agent: agent:@pub/captain.`. `undefined`
-     * when nothing of another kind answers to it. `add`, `diff`, `update`, `info`, `remove` and
-     * `why` end their not-found line with it.
-     */
-    otherKindHint(ref: string): Promise<string | undefined>;
-    /**
-     * What `add` would deploy for the resolved candidates and library entries, without touching
-     * the project: one item per asset with its origin, version, deploy folders and files.
-     */
-    private planAddItems;
-    /**
-     * Parse the ref `add` was given. A ref the grammar rejects fails with the parser's message
-     * minus its manifest-migration advice (it points at a skill that is not for `add`), and:
-     * - a publisher-less ref (`report-html`, `skill:report-html`) names the assets of that
-     *   kind and name that `add` can resolve (a source, the bundled factory source or a
-     *   library holds them), so `Did you mean` never names an asset that does not resolve;
-     * - a `@version` suffix (`skill:@acme/x@1.0.0`) says the pin is written `#<version>`.
-     */
-    private parseAddRef;
-    /**
-     * The publisher-qualified refs of the assets named like the publisher-less `ref` that
-     * `add` resolves: held by a source clone, the bundled factory source or a registered
-     * library. A ref without a kind means a skill, as the grammar says.
-     */
-    private resolvableMatches;
-    /**
-     * Add a single asset (and its transitive dependencies) to the workspace.
-     *
-     * Resolves `ref`, deploys the asset and all requirements, then records the ref
-     * in `skaile.yaml` `dependencies` so subsequent `skaile install` runs re-deploy it.
-     *
-     * @param ref - Asset ref in `kind:name` or `repo/kind:name` form (e.g. `skill:my-skill`).
-     * @param opts - Optional deploy options.
-     * @param opts.link - When `true`, symlink local-path assets instead of copying them
-     *   (the author dev-loop). Machine-local / not for committing; a no-op for
-     *   store/factory sources. Defaults to copy.
-     * @param opts.onLibraryOrigin - Called once per deployed library-origin asset with its
-     *   canonical ref and the name of the library it was resolved from.
-     * @param opts.onLibraryMoved - Called once per asset whose lock entry named another library
-     *   than the one this add resolved it from.
-     * @param opts.onPresets - Called once with the presets expanded into this add (the
-     *   added preset and any it nests); a library-held preset names its library.
-     * @returns Array of asset refs that were deployed in this call.
-     * @throws When the asset cannot be found in any configured repository, or when a
-     *   preset's items do not all resolve (nothing is deployed or recorded then).
-     */
-    add(ref: string, opts?: {
-        link?: boolean;
-        onLibraryOrigin?: (deployedRef: string, library: string) => void;
-        /** Called per deployed library asset whose body is still the untouched `library create` scaffold. */
-        onPlaceholderBody?: (deployedRef: string) => void;
-        /** Called per deployed library asset whose `description:` is still the `library create` placeholder. */
-        onPlaceholderDescription?: (deployedRef: string) => void;
-        /** Called per already-locked asset this add moved to another library than its lock entry named. */
-        onLibraryMoved?: (move: LibraryMove) => void;
-        /** Called with the instance id and ref when this add bound an agent as `agents.<id>` of `skaile.yaml`. */
-        onAgentBound?: (id: string, ref: string) => void;
-        /** Called when the id this add would bind is taken by another agent: `agents.<id>` keeps `keptRef`. */
-        onAgentBindingKept?: (id: string, keptRef: string) => void;
-        /** `update <name>`: an equal-version tie between libraries goes to the default library, then the locked one (see {@link install}'s `moveLibraries`). */
-        preferLockedLibrary?: boolean;
-        onPresets?: (presets: PresetExpansion[]) => void;
-        /** Deploy over a folder no lock entry owns (a hand-made skill of the same name) instead of refusing. */
-        force?: boolean;
-        /** Called per `.env` file in an asset's directory that a copy deploy leaves out. */
-        onSecretFile?: (ref: string, path: string) => void;
-        /** Resolve and check everything, write nothing, and hand the plan to `onPlan`. */
-        dryRun?: boolean;
-        /** Global `--harness`: replace the recorded harness set instead of adding to it (`--only`). */
-        only?: boolean;
-        /** With `only`: called per harness that drops out of the set but still holds a copy. */
-        onDroppedCopy?: (ref: string, harness: HarnessName, path: string) => void;
-        /** Called once with the plan of a `dryRun` add. */
-        onPlan?: (plan: AddPlanItem[]) => void;
-    }): Promise<string[]>;
-    /**
-     * Report the body-link **soft dependencies** of the given assets that are not
-     * already present in the project.
-     *
-     * Looks up each ref's persisted `softDeps` in the local index
-     * (`~/.skaile/index.db`, populated by `skaile source sync`) and returns the
-     * edges whose target is neither a declared dependency nor deployed on disk. It
-     * does **not** install anything and never touches the resolver / lock /
-     * reconcile path: callers surface the result as a hint, the user opts in with
-     * a follow-up `skaile add`. Inspects exactly the passed `refs` — soft deps of
-     * their transitively-deployed dependencies are not surfaced here.
-     *
-     * Opening the index runs its idempotent migrations, so this is not a pure
-     * read — but it is **best-effort**: any failure (legacy/corrupt index, a
-     * removed-backend guard) yields `[]`, so it can never fail a primary `add`
-     * that already succeeded.
-     *
-     * @param refs - Asset refs to inspect (canonical, `kind:@pub/name`, or `kind:name`).
-     * @returns One edge per absent soft-dep target (deduped by target). `toRef` is
-     *   the parseable `skaile add` ref, omitted when the target isn't in the index.
-     */
-    reportSoftDeps(refs: string[]): Promise<Array<{
-        from: string;
-        to: string;
-        toRef?: string;
-    }>>;
-    /**
-     * Presets in the configured sources (and the bundled factory source) that list
-     * `ref` as an asset item, for the `skaile add` discoverability hint. Membership is
-     * not a dependency: nothing here installs the preset or its siblings.
-     *
-     * Matches on kind + name, and on publisher only when both sides carry one, so
-     * a bare `skill:x` item still matches `skill:@pub/x`. Presets already
-     * declared in `skaile.yaml` are left out. Best-effort: any failure yields `[]`,
-     * so it can never fail an `add` that succeeded.
-     *
-     * @param ref - The added asset ref (`kind:name`, `kind:@pub/name`, optionally pinned).
-     * @returns One `{ name, ref }` per containing preset, deduped by `ref`; `ref` is
-     *   the `skaile add` form (`preset:@pub/name`, or `preset:name` without a publisher).
-     */
-    presetsContaining(ref: string): Promise<Array<{
-        name: string;
-        ref: string;
-    }>>;
-    /**
-     * All body-link soft dependencies of the given assets — present or not.
-     *
-     * Unlike {@link reportSoftDeps} (which filters to *absent* targets so it can
-     * nudge a follow-up `skaile add`), this returns the asset's full inferred
-     * soft-dep set for display surfaces (`skaile info` / `tree` / `why`). Read-only
-     * and best-effort: any index failure yields `[]`. Targets are deduped.
-     *
-     * @param refs - Asset refs to inspect (canonical, `kind:@pub/name`, or `kind:name`).
-     * @returns One {@link SoftDepEdge} per soft-dep target. `toRef` is the parseable
-     *   ref, omitted when the target isn't in the index.
-     */
-    softDepsOf(refs: string[]): Promise<SoftDepEdge[]>;
-    /**
-     * Reverse lookup: refs (canonical ids) of cached assets whose persisted
-     * `softDeps` include `targetRef`. Scans the whole index, not just present
-     * assets. Read-only and best-effort (`[]` on any index failure).
-     *
-     * @param targetRef - Canonical soft-dep target ref (`<publisher>/<name>@<version>`).
-     * @returns Def ids that declare `targetRef` as a soft dependency.
-     */
-    softDepDependents(targetRef: string): Promise<string[]>;
-    /**
-     * Compute which soft-dependency targets would be left **orphaned** by removing
-     * `refs`: targets still present in the project that came in as one of `refs`'
-     * soft dependencies and that **nothing else still needs** — neither another
-     * present asset's soft-dep ({@link softDepDependents}) nor a typed `requires`.
-     *
-     * Pure read — never removes anything. The CLI / manage surfaces each result as
-     * a prompt (default No) so the user opts in to an extra `skaile remove`. Safe to
-     * call before or after the primary remove: assets being removed are excluded
-     * from the "needed by others" scan, so a soft target referenced only by the
-     * removed asset is still reported as an orphan.
-     *
-     * @param refs - Asset refs being removed (canonical, `kind:@pub/name`, or `kind:name`).
-     * @returns One {@link OrphanedSoftDep} per orphaned target (deduped).
-     */
-    orphanedSoftDepsAfterRemoving(refs: string[]): Promise<OrphanedSoftDep[]>;
-    /**
-     * Open the local index, run `fn` against its cached asset defs, and close it.
-     * Best-effort: no index (user never ran `source sync`), a missing file, or any
-     * open/guard failure yields `fallback` — so a read surface can never throw or
-     * create an empty `index.db` as a side effect.
-     */
-    private withIndexDefs;
-    /**
-     * Build soft-dep edges for `refs` from cached defs. With `onlyAbsent`, targets
-     * already present in the project are skipped (the `reportSoftDeps` nudge); else
-     * the full inferred set is returned (the `softDepsOf` display). Deduped by target.
-     */
-    private collectSoftDeps;
-    /**
-     * Names of assets already in the project — declared deps + deployed on disk.
-     * Bare name only (see {@link softDepName}): a same-named asset of a different
-     * publisher/kind counts as present, so the report under-reports rather than
-     * nags about something already installed.
-     */
-    private presentRefNames;
-    /**
-     * Present asset refs — declared `skaile.yaml` deps (canonical refs as written)
-     * plus deployed assets as `kind:name`. Used by the soft-dep present-check and
-     * the orphan "needed by others" scan.
-     */
-    private presentRefs;
-    /**
-     * Remove a deployed asset and unregister it from `skaile.yaml` and the lock.
-     *
-     * A declared asset is always unregistered, even when nothing is deployed any
-     * more (e.g. its library file was deleted): the declaration and lock entry
-     * would otherwise be stuck behind a "not deployed" refusal.
-     *
-     * Removes only `ref` itself; use {@link removeWithDependencies} to also drop the
-     * dependencies it leaves orphaned.
-     *
-     * Deliberately does NOT re-render the harness target's MCP config: the render
-     * step is async (the declaration resolver is), and making this synchronous
-     * method async would break every external caller. {@link removeWithDependencies}
-     * (what `skaile remove` runs) does re-render it; a caller of this method gets the
-     * dropped entry at the next {@link AssetManager.install} — see
-     * {@link renderMcpServerConfig}.
-     *
-     * @param ref - Asset ref: `kind:@publisher/name`, or the short `kind:name` /
-     *   `name` form when exactly one declared, locked or deployed asset matches it.
-     * @returns `true` if anything changed (files undeployed, declaration or lock
-     *   entry removed), `false` if the asset was neither deployed nor declared.
-     *   A `preset:` ref has no deployed files: only its declaration goes — its
-     *   expanded items leave with the next `skaile install`.
-     * @throws When `ref` is malformed, or a short ref matches several assets (the
-     *   message lists them).
-     */
-    remove(ref: string, opts?: {
-        force?: boolean;
-    }): boolean;
-    /**
-     * {@link remove} `ref`, then drop the dependencies that removal left orphaned:
-     * locked assets `ref` required (directly or through one another) that
-     * `skaile.yaml` no longer declares and no remaining locked asset requires. A
-     * preset's items count as its requirements. They are undeployed and unlocked;
-     * a dependency still declared or required elsewhere stays.
-     *
-     * An asset another locked asset (or a declared preset) requires is kept and reported in
-     * `blocked`, nothing changes, unless `opts.force` (see {@link requiredByOthers}).
-     *
-     * @returns `changed` as {@link remove}; `pruned` the canonical refs
-     *   (`kind:@publisher/name`) of the dependencies dropped as well; `blocked` when the
-     *   removal was refused.
-     */
-    removeWithDependencies(ref: string, opts?: {
-        force?: boolean;
-    }): Promise<RemoveResult>;
-    /**
-     * Resolve the identity {@link remove} acts on. A publisher-qualified ref is taken
-     * as written; a short ref (`kind:name`, or just `name`) is matched on kind + name
-     * against the declared dependencies, the lock and the deployed assets, like
-     * `why` / `diff` do.
-     *
-     * @returns the identity, or `null` when a name-only ref matches nothing.
-     * @throws On a malformed ref, or when a short ref matches more than one asset.
-     */
-    private resolveRemoveTarget;
-    /**
-     * The refs among `refs` (`skill:@publisher/name`, `skill:name`, with or without `#version`)
-     * that are not deployed for this manager's harnesses and scope, judged as `check` judges a
-     * requirement. A ref that does not parse or names a kind this build does not install is
-     * never reported. `run <flow> --dry-run` names the node skills a flow still lacks (p1757).
-     */
-    undeployedSkills(refs: readonly string[]): string[];
-    /**
-     * The reverse guard of {@link removeWithDependencies}: which other locked assets (and
-     * declared presets) require `target`. Their requirements are read the way {@link lockedGraph}
-     * reads them for pruning. Never touches the project.
-     *
-     * @returns `ref` and `requiredBy` (both `kind:@publisher/name`, version-agnostic), or `null`
-     *   when `target` is not locked or nothing else requires it.
-     */
-    private requiredByOthers;
-    /**
-     * Publishers under which the lock or `skaile.yaml` track `kind:name`. A deployed dir carries
-     * no publisher, so this is what says whose copy it is. `undefined` stands for a
-     * publisher-less declaration.
-     */
-    private trackedPublishers;
-    /**
-     * The lock entries that hold `kind:name`, each with its publisher (no leading `@`) and its
-     * canonical ref. A deployed folder carries no publisher; these are who it belongs to.
-     */
-    private lockHolders;
-    /** The folders or files of `kind:name` on disk in `target`, shown relative to the project. */
-    private heldDeployPaths;
-    /**
-     * Undeploy `parsed` from every target harness and drop its declaration and lock entry.
-     *
-     * A folder no lock entry holds is the user's own work (a hand-made skill of the same name):
-     * it is kept and named in `opts.kept` unless `opts.force`.
-     */
-    private removeResolved;
-    /**
-     * After an `mcp-server` asset left the project: drop what would keep it rendered. Its staged
-     * store bytes under `.skaile/cache/store/<publisher>/mcp-server/<name>/` go (an `mcp_servers:`
-     * entry of the same id would otherwise keep loading them), and so does an `mcp_servers:` entry
-     * that only sets values for it: `env` and the like, with no `command`, `url` or recipe of its
-     * own. An entry that can run alone is the user's own server and stays.
-     *
-     * @returns The dropped `mcp_servers` entries, as `mcp_servers entry "<id>"`.
-     */
-    private dropRemovedMcpServerSettings;
-    /**
-     * After `remove --global --harness X`: the harnesses outside `X` that still hold a copy of the
-     * asset, or `undefined` when none does (or this is not a harness-limited global remove).
-     */
-    private harnessesStillHolding;
-    /** Limit the declared global entry of `target` to `harnesses` (`~/.skaile/skaile.yaml`). */
-    private limitDeclaredEntry;
-    /**
-     * Drop the locked assets among `requiredRefs` (and what they require in turn) that
-     * nothing needs any more: not declared in `skaile.yaml`, not required by a locked
-     * asset outside that set. Call after the requiring asset is gone.
-     *
-     * @returns the canonical refs of the assets dropped.
-     */
-    private pruneOrphans;
-    /**
-     * Drop every lock entry matching a removed asset's identity, version-agnostic so
-     * a content-sha pseudo-version key is pruned too. Symmetric with {@link add}'s
-     * lock-merge — stops a stale entry reporting a phantom "removed" on next install.
-     *
-     * @returns `true` when at least one lock entry was dropped.
-     */
-    private pruneLockEntry;
-    /**
-     * Search the catalog across all configured repositories.
-     *
-     * @param query - Substring to match against entry names and descriptions (case-insensitive).
-     *   Omit to return all entries.
-     * @param kind - Filter by asset kind (`"skill"`, `"agent"`, `"prompt"`, `"flow"`, `"contract"`).
-     *   Omit to return all kinds.
-     * @returns Array of matching {@link CatalogEntry} objects from all accessible repositories.
-     */
-    search(query?: string, kind?: string): Promise<CatalogEntry[]>;
-    /**
-     * On-disk root + config slug for every declared (and the implicit factory)
-     * source that has a local clone. Companion to {@link search}: callers that
-     * need to relate a scanned entry back to its source root (e.g. to stamp
-     * plugin grouping) can't recover the root from the flat
-     * {@link CatalogEntry} list `search` returns.
-     */
-    searchRepoRoots(): {
-        repoName: string;
-        root: string;
-    }[];
-    /**
-     * Look up a single asset's full catalog entry.
-     *
-     * Accepts a bare `kind:name` ref (no publisher) in addition to the fully-qualified
-     * `kind:@publisher/name` form — {@link listDeployed} emits publisher-less refs and
-     * {@link doctor} passes them straight to this method.
-     *
-     * @param ref - Asset ref in `kind:name`, `kind:@publisher/name`, or `repo/kind:name` form.
-     * @returns The matching {@link CatalogEntry}, or `null` when not found.
-     */
-    info(ref: string): Promise<DeployableEntry | null>;
-    /**
-     * List all assets currently deployed in the workspace (or global cache).
-     *
-     * Scans the framework deploy directories rather than the lock file, so it
-     * also returns assets that were installed manually or outside of `skaile install`.
-     *
-     * @param kind - Filter by asset kind. Omit to return all kinds.
-     * @returns Shallow {@link CatalogEntry} objects (description and version will be empty).
-     */
-    listDeployed(kind?: string): CatalogEntry[];
-    /**
-     * Absolute path → sha256 of every native agent file the lock records under `rendered:`. A
-     * `harness set` rewrites the lock for the new harness, so a caller that cleans up afterwards
-     * reads this first and hands it to {@link AssetManager.listStaleHarnessCopies}.
-     */
-    lockedRenderedHashes(): Map<string, string>;
-    /**
-     * Tracked assets (`skaile.lock.yaml` or declared in `skaile.yaml`) whose copy
-     * still sits in the project dirs of another harness (`.claude/…`, `.omp/…`,
-     * `.codex/…`) although this manager deploys to {@link AssetManager.harness}.
-     * A project that moved with `skaile harness set` holds orphans there that
-     * `remove` / `clean` / `list` no longer look at.
-     *
-     * Read-only: nothing is deleted. Empty for global mode and for kinds whose
-     * dir is shared with the active target (flows).
-     *
-     * @param opts.renderedBefore - {@link AssetManager.lockedRenderedHashes} of the lock as it was
-     *   before the move to this harness. An agent copy counts as skaile's only when it matches a
-     *   hash the lock (now or then) recorded for its path.
-     * @returns One {@link StaleHarnessCopy} per stale copy, sorted by harness, kind, then name.
-     */
-    listStaleHarnessCopies(opts?: {
-        renderedBefore?: ReadonlyMap<string, string>;
-    }): StaleHarnessCopy[];
-    /**
-     * @deprecated Use {@link AssetManager.listStaleHarnessCopies}, which covers every
-     * other harness folder. This returns only its `.claude/` rows (the old default
-     * deploy dir), in the old shape.
-     */
-    listLegacyClaudeDeployed(): LegacyDeployedAsset[];
-    /**
-     * List the **declared** top-level dependencies from `skaile.yaml`, each tagged
-     * with a reconciliation {@link DeclaredState}:
-     *
-     * - `declared` — in `skaile.yaml`, not yet resolved into the lock.
-     * - `installed` — declared + locked, and (for kinds with an `installTarget`)
-     *   materialized on disk. An `mcp-server` is instead checked against the
-     *   declarations the runner would actually wire (store-staged or materialized
-     *   `MCP.md`); the remaining composition-only kinds (no `installTarget`) count as
-     *   installed once locked — they are resolved at session start with no harness
-     *   footprint here.
-     * - `drift` — declared + locked but the deployed files are missing on disk.
-     * - `invalid` — the `dependencies:` entry isn't a parseable canonical ref. Only
-     *   surfaced in the unfiltered listing (a `kind` filter can't classify it).
-     *
-     * Transitive (lock-only) deps are excluded by construction — only the declared
-     * set is walked, so a lock entry with no matching `dependencies:` ref never shows.
-     *
-     * @param kind - Filter by asset kind. Omit to return all kinds.
-     * @returns One {@link DeclaredAsset} per declared dep (after the optional kind filter), plus
-     *   one per locked agent that only an agent instance of `skaile.yaml` binds.
-     * @throws {MissingManifestError} when the project has no `skaile.yaml`.
-     * @throws {Error} with a `migrate-skaile-manifest` hint on legacy `repositories:` / `ai_resources:` keys.
-     */
-    listDeclared(kind?: string): Promise<DeclaredAsset[]>;
-    /**
-     * One note per locked library asset whose library went back to an older version than the lock
-     * (`library is at 0.1.0, locked 0.3.0`). Not drift: `install` keeps the lock and only `update`
-     * moves it, so `check` and `doctor` print the note as a `!` line and still exit 0 (p1257).
-     * Empty for a global manager or when the libraries cannot be read.
-     */
-    libraryOlderNotices(): Promise<string[]>;
-    /**
-     * Notes about the project's `mcp-server`s that are not drift and fail nothing: a declared
-     * server skaile does not write to the coding agent's MCP config (`reason` from the last
-     * render), and a required `MCP.md` field nothing sets. `check` and `doctor` print them as
-     * `!` lines; `list` shows the first kind as `skipped`.
-     *
-     * @returns One {@link McpNotice} per note; empty for a global manager.
-     */
-    mcpNotices(): Promise<McpNotice[]>;
-    /**
-     * Locked assets whose deployed directory lacks files the deploy writes — a deleted
-     * `build.py` / `scripts/` helper next to an intact `SKILL.md`. The expected set is the file
-     * set the lock covers: a library entry's files (every file under its manifest `root:`), a
-     * source or store entry's `files[]` (the asset's whole file set at the locked commit). Only
-     * presence is checked, so a local edit never counts. An asset with no deployed directory is
-     * not listed (`listDeclared` reports it as drift); an agent is rendered, not copied, so it
-     * has no file mirror to compare. `skaile install` restores what is listed.
-     *
-     * @returns One {@link IncompleteDeploy} per affected asset; empty when healthy
-     *   or when the project has no lock.
-     */
-    incompleteDeploys(): Promise<IncompleteDeploy[]>;
-    /**
-     * Per-harness reconciliation of the **global** declared deps
-     * (`~/.skaile/skaile.yaml`) against each global harness's deploy dir. The
-     * global twin of {@link listDeclared}: the same `declared` / `installed` /
-     * `drift` / `invalid` vocabulary, but one row **per (ref, harness)** so an
-     * asset can be `installed` for `claude-code` and `drift`/`declared` for
-     * `codex` at once.
-     *
-     * Reads the SSOT + the global lock (`~/.skaile/skaile.lock.yaml`) — construct
-     * the manager with `global: true`. Unlike `listDeclared`, a missing SSOT is
-     * **not** an error: it yields an empty list (a fresh machine has no globals).
-     *
-     * @param opts.harness - Reconcile against this one harness only (the
-     *   `--harness` filter); omit for every harness in {@link targetHarnesses}.
-     * @param opts.kind - Filter by asset kind.
-     * @returns One {@link HarnessDeclaredAsset} per declared dep × harness.
-     * @throws {Error} on legacy keys in `~/.skaile/skaile.yaml` (migration hint).
-     */
-    globalState(opts?: {
-        harness?: HarnessName;
-        /** @deprecated Use `harness`. Honoured only when `harness` is absent; removed in the next major. */
-        backend?: HarnessName;
-        kind?: string;
-    }): HarnessDeclaredAsset[];
-    /**
-     * Build an aggregated workspace overview with publisher grouping and sync status.
-     *
-     * Combines deployed assets, lock file metadata, and live repository status
-     * into a single structured result. Used by `skaile status`.
-     *
-     * @returns {@link OverviewResult} with entries grouped by publisher and per-repo sync status.
-     */
-    overview(): OverviewResult;
-    /** Collect live sync status for every configured repository, keyed by name. */
-    private buildRepoStatuses;
-    /**
-     * Requirement graph of the locked assets, for {@link tree} / {@link why} / removal pruning.
-     *
-     * The lock records no edges, so they are rebuilt from each locked asset's own
-     * declaration (`requires`, manifest `dependencies`, a preset's items) — the same
-     * source the install walk reads, via {@link info}. An asset that no source or
-     * library can be found for has no known requirements. Nodes are lock keys, plus
-     * each declared `preset:` that the lock does not carry (a preset is expanded at
-     * install, never locked), keyed by its declared ref.
-     *
-     * @returns `requires` (node → the lock keys it requires), `roots` (nodes
-     *   `skaile.yaml` declares) and `findKey` (a ref → its lock key, version-agnostic).
-     */
-    private lockedGraph;
-    /**
-     * Build the resolved dependency tree from the lock file.
-     *
-     * Required assets nest under the asset that requires them (see {@link lockedGraph});
-     * an asset required by several parents appears under each, and a dependency cycle
-     * is cut where it would repeat.
-     *
-     * @returns Root {@link DependencyNode} with `ref === "project"` whose children
-     *   are the directly-declared assets, followed by locked assets nothing requires,
-     *   each with the assets it requires as children.
-     *   Returns a single node with `ref === "(no lock file)"` when no lock exists.
-     */
-    tree(): Promise<DependencyNode>;
-    /**
-     * Explain why an asset is installed by tracing its dependency chain.
-     *
-     * The chain is read from the requirement graph ({@link lockedGraph}): the asset,
-     * then the asset that requires it, and so on up to a dependency `skaile.yaml`
-     * declares (the shortest such path; cycles are not followed twice).
-     *
-     * @param ref - Asset ref in `kind:name` form.
-     * @returns Chain of refs from the asset back to `"direct (skaile.yaml)"`; an asset
-     *   no declared dependency reaches ends in `"not required by a declared dependency"`
-     *   instead. `[]` when the asset is not in the lock file.
-     */
-    why(ref: string): Promise<string[]>;
-    /**
-     * The {@link AssetManager.why} chain of a preset. A preset is never a lock asset: its record
-     * is the lock's `presets` slice. Declared in `skaile.yaml` it is `direct`; one only a declared
-     * preset nests is traced through the presets that list it.
-     *
-     * @returns `[]` when the lock does not record the preset.
-     */
-    private whyPreset;
-    /**
-     * List installed assets that have a newer upstream available.
-     *
-     * Two kinds of staleness are reported:
-     * - **Source assets** — only remote repositories (not local paths) are checked;
-     *   `behind` counts the commits the clone is missing from the remote plus the
-     *   commits the clone moved past the locked commit (`source sync` after `add`).
-     * - **Library assets** — a library-origin lock entry whose library files on disk
-     *   (not the index, which lags until `skaile library index`) hold a newer version
-     *   than the locked one (`latestVersion`, `library` set), or the same version with
-     *   different bytes (`contentChanged`). `behind` is 0.
-     * - **Project state** — every {@link AssetManager.projectState} gap (an unregistered or
-     *   renamed library, a missing deployed copy, a declared dependency or a deployed asset's
-     *   `requires` with no lock entry, a lock that contradicts a `skaile.yaml` pin) as a
-     *   `problem` row, so `outdated` lists what `check`, `doctor` and `install --locked` fail
-     *   on. An asset that also has a version row is listed once, with that row.
-     *
-     * @returns Array of {@link OutdatedEntry} objects.
-     */
-    outdated(): Promise<OutdatedEntry[]>;
-    /**
-     * The `#pin` of every publisher-qualified `skaile.yaml` dependency, keyed `kind:publisher/name`
-     * (no scope sigil). `update` honours it, so `outdated` must not list a move it keeps.
-     */
-    private declaredPinsByIdentity;
-    /**
-     * List a locked asset whose `skaile.yaml` ref carries a `#version` pin while a source, a
-     * library or a store holds a newer one: `locked 0.7.0 -> 0.9.0 (pinned)`. The pin is the
-     * user's choice, so the row only informs (`pinned`): `update` leaves it, `outdated` does not
-     * fail on it (OQ13, p1291). An asset already listed keeps its own row.
-     */
-    private addPinnedRows;
-    /**
-     * Ask the stores about every locked asset whose lock entry says `origin: store`, and record
-     * those no store could be asked about (the URL did not answer, or the client is air-gapped)
-     * for {@link takeStoreNotChecked}. `outdated` runs it, and so do `check` and `doctor`, which
-     * otherwise never ask a store: without it a dead store reads as "everything is fine".
-     * A store that answers, and a client that skips the store on purpose
-     * (`catalogUrl: ''`, `--no-catalog`), record nothing. A ref already recorded is not asked again.
-     */
-    probeStoreOrigins(): Promise<void>;
-    /**
-     * List a source asset locked under a `0.0.0-sha.<commit>` key whose file now declares a
-     * version: the next `install` or `update` re-keys it (`replaced 0.0.0-sha.7de3555 → 0.2.0`),
-     * so `outdated` lists it as `re-key (…)` instead of saying everything is up to date (p914).
-     * An asset already listed (behind its remote) gets the target on that row.
-     */
-    private addRekeyRows;
-    /**
-     * List a locked library asset that `update` would move to another library (a default-library
-     * switch, a library that now holds a newer version) as `library → movesTo`, so `outdated`
-     * does not say "up to date" and `update` then re-locks it announced only after the fact.
-     * The resolution is the one `update` runs ({@link lockedPreference}); an asset already listed
-     * with a version row gets the target library on that row.
-     */
-    private addLibraryMoves;
-    /**
-     * Add one `problem` row per {@link AssetManager.projectState} gap whose asset is not
-     * listed yet, so `outdated` lists the same assets `check`, `doctor` and `install --locked`
-     * fail on. An asset that is behind its source and also broken is listed once, with its
-     * version row.
-     */
-    private addLockGapRows;
-    /**
-     * The deploy entry of a library-origin asset from the library its lock entry records,
-     * at the locked version when that library still holds it (else its newest). Other
-     * libraries holding the same ref are not consulted: the lock already chose.
-     *
-     * @param want - Kind, name and optional publisher of the asset.
-     * @returns `null` when the lock has no library-origin entry for it, or the recorded
-     *   library is gone or no longer holds it (callers fall back to a general lookup).
-     */
-    private lockedLibraryEntry;
-    /**
-     * The deploy entry of a source- or store-origin asset, carrying the file set its lock entry
-     * lists (so a missing or edited helper shows in `diff`, not only the manifest). A source asset
-     * reads from its clone; a store asset from the bytes `add`/`install` staged in the project
-     * store cache. `null` when the lock has no such entry or its bytes are not on disk.
-     *
-     * @param want - Kind, name and optional publisher of the asset.
-     */
-    private lockedSourceEntry;
-    /** Whether the lock holds `want` as a store asset (`origin: store`, no library). */
-    private isStorePinnedRef;
-    /**
-     * {@link AssetManager.diff} for a locked source or store asset whose bytes are not on disk:
-     * the deployed copy against the per-file hashes the lock records. No text to show without the
-     * locked bytes, so an edited file is named and the way to fetch them is. `null` when the lock
-     * has no such entry or the kind is rendered (an agent), not copied.
-     */
-    private diffAgainstLock;
-    /**
-     * Produce a unified diff from the deployed asset to its catalog source: `-` lines
-     * are in the deployed copy only (local edits `update` would overwrite), `+` lines
-     * are in the source only (what `update` would add).
-     *
-     * Useful for detecting manual edits to deployed files or seeing what an upstream
-     * change would bring in; also for verifying that a patch
-     * was applied correctly.
-     *
-     * @param ref - Asset ref in `kind:name` form.
-     * @returns A {@link DiffResult}: `not-found` (unknown ref), `not-deployed`,
-     *   `identical`, or `differs` with the unified diff.
-     * @throws When `diff(1)` itself fails (exit status other than 0/1).
-     */
-    diff(ref: string): Promise<DiffResult>;
-    /**
-     * The agent instances of `skaile.yaml` whose `ref` names `want` (an `agent:` ref, matched on
-     * name and, when both name one, publisher) and bind to an agent definition directory.
-     */
-    private instancesBoundTo;
-    /**
-     * Resolve all declared dependencies and write (or overwrite) `skaile.lock.yaml`.
-     *
-     * Performs repository sync and full dependency resolution without deploying assets.
-     * Use this to regenerate the lock file after manually editing `skaile.yaml`.
-     *
-     * @returns The written {@link LockFile} data.
-     */
-    lock(): Promise<LockFile>;
-    /**
-     * Extract a deployed asset into a patch working directory for editing.
-     *
-     * Copies the deployed asset to `.skaile/patches/<kind>-<name>/` so changes
-     * can be made there and then committed as a patch file via `patchCommit`.
-     *
-     * @param ref - Asset ref in `kind:name` form.
-     * @returns Absolute path to the patch working directory.
-     * @throws When the asset cannot be found in the catalog.
-     */
-    patch(ref: string): Promise<string>;
-    /**
-     * Generate a `.patch` file from changes made in the patch working directory.
-     *
-     * Diffs the patch working directory against the original catalog source and
-     * writes the result to `.skaile/patches/<kind>-<name>.patch`.
-     *
-     * @param ref - Asset ref in `kind:name` form.
-     * @returns Absolute path to the generated `.patch` file.
-     * @throws When the patch working directory does not exist or no differences are found.
-     */
-    patchCommit(ref: string): Promise<string>;
-    /**
-     * Apply the committed patch file to the repository clone and open a contribution branch.
-     *
-     * Applies `.skaile/patches/<kind>-<name>.patch` to the repository clone, creates a
-     * `patch/<kind>-<name>` branch, and stages a commit — ready to push via `contribPush`.
-     *
-     * @param ref - Asset ref in `kind:name` form.
-     * @throws When the asset is not found, has no repository, or the patch file is missing.
-     */
-    patchSubmit(ref: string): Promise<void>;
-    /**
-     * Delete the patch working directory and patch file for an asset.
-     *
-     * @param ref - Asset ref in `kind:name` form.
-     */
-    patchRemove(ref: string): void;
-    /**
-     * Scan deployed assets for unsatisfied transitive dependencies.
-     *
-     * For each deployed asset, checks that all entries in its `requires` list are
-     * also deployed. Returns a list of issues with a flag indicating whether the
-     * missing dependency can be resolved from a configured repository or library.
-     *
-     * A deployed asset is looked up by its publisher-qualified identity taken from
-     * the lock key (`kind:@pub/name`), so library and source assets resolve alike.
-     * A lock-managed asset that no source or library can be found for is reported
-     * as an issue with `unresolved: true` (its `requires` cannot be verified);
-     * unmanaged deployed files carry no declared origin and are skipped.
-     *
-     * @returns Array of {@link DepIssue} objects. An empty array means the workspace is healthy.
-     */
-    doctor(): Promise<DepIssue[]>;
-    /**
-     * The project's state as one verdict: every way the project differs from what it
-     * declares and locks. `skaile check`, `skaile doctor`, `skaile outdated`, `skaile diff`
-     * and `skaile install --locked` all take their verdict and exit code from this one list,
-     * so one situation reads the same in all five.
-     *
-     * - `declared` — a `skaile.yaml` dependency with no lock entry (library or source gone,
-     *   unresolvable ref, never installed);
-     * - `invalid` — a `dependencies:` entry that is not a parseable ref;
-     * - `drift` — a locked asset whose deployed files are missing;
-     * - `pin` — a declared `#pin` that no lock entry for that asset satisfies;
-     * - `requires` — a deployed asset's `requires` (or a declared preset's item) that is not
-     *   deployed (so not locked either);
-     * - `unresolved` — a lock-managed deployed asset that no source or library holds any more;
-     * - `library` — a locked library asset whose library is not registered (renamed or
-     *   removed) or no longer holds it, while another library holds it now;
-     * - `incomplete` — a deployed library asset that lacks files of its library entry;
-     * - `content` — a locked library asset whose files in the library changed since the lock
-     *   (or whose lock hash predates the one shared asset hash); `skaile install` re-locks it;
-     * - `agent` — an `agents.<id>.ref` (or `agent.definition`) that binds to no agent.
-     *
-     * An asset appears once for what the lock says about it (`unresolved`, else `library`,
-     * else `drift`). A declared ref no registered library or source holds names
-     * `skaile library init` / `skaile remove`, never `skaile install`: `install` has nothing
-     * to resolve it from.
-     *
-     * Project mode only: a global manager (`global: true`) has no gaps. A project without
-     * `skaile.yaml` has no declared set, so only the lock and deployed-asset gaps can appear.
-     *
-     * @returns The {@link ProjectState}; `gaps` is empty when the project is as declared and locked.
-     */
-    projectState(): Promise<ProjectState>;
-    /**
-     * The first `../` compose folder of the locked library agent `kind:name` whose library copy
-     * changed since the lock, or `undefined` (project scope only). `install --locked` cannot
-     * restore such an agent; `update` moves the lock to the library's copy.
-     */
-    private lockedComposeDrift;
-    /**
-     * The agent instances whose `ref` binds to no agent and that the install about to run does not
-     * deploy (`entries`), worded as `renderAgentInstances` words them (`errors`, and the resolver's
-     * own text in `details` for `--verbose`). The install cannot fix them, and its instance render
-     * after the deploy would end the run `Failed` having rewritten files. A ref the `entries` hold
-     * binds once they are deployed, so it is no cause.
-     */
-    private unboundInstanceErrors;
-    /**
-     * Why the `agent:` ref of agent instance `id` binds to nothing, as the phrase that follows
-     * the ref in a {@link LockGap}; see {@link AssetManager.unboundAgentAdvice}.
-     */
-    private unboundAgentReason;
-    /**
-     * What is wrong with an `agent:` ref bound by an agent instance and what to do (`lead`, then
-     * `advice`). `skaile add` is named only when a registered library or source holds the agent
-     * and `add` takes the ref (it needs a publisher); otherwise the user registers the library
-     * that holds it, writes the publisher, or drops the binding.
-     */
-    private unboundAgentAdvice;
-    /**
-     * Whether the library a locked agent names is here and holds the agent, or the agent comes
-     * from a source or store: `install --locked` restores it, so its missing cache is no fault of
-     * the library.
-     */
-    private lockedAgentLibraryHolds;
-    /** @deprecated Use `(await projectState()).gaps`; removed in the next major. */
-    lockGaps(): Promise<LockGap[]>;
-    /**
-     * The {@link ProjectState} gaps that name `ref`: as the gap's own ref, or as the asset
-     * whose requirement is unmet. A ref without a publisher matches any publisher.
-     *
-     * @param ref - Asset ref in `kind:name` or `kind:@publisher/name` form.
-     */
-    gapsOf(ref: string): Promise<LockGap[]>;
-    /**
-     * The {@link ProjectState} gaps of everything `ref` requires, transitively: what `check`
-     * says about the requirements of `ref`, so a command that answers for one asset (`diff`)
-     * does not call it fine while a requirement of it is broken. The requirements are read from
-     * the deployed copies (the lock records no edges), the way `remove` and `install` read them
-     * when no library holds the asset any more. The gaps of `ref` itself are not included
-     * ({@link gapsOf}).
-     *
-     * @param ref - Asset ref in `kind:name` or `kind:@publisher/name` form.
-     */
-    requirementGapsOf(ref: string): Promise<LockGap[]>;
-    /**
-     * Locked library assets whose library cannot supply them: the library is not registered
-     * (renamed or removed) or no longer holds the asset. Another library holding it makes the
-     * gap fixable by `skaile install` (it re-locks); otherwise the user registers the library
-     * again or drops the dependency.
-     *
-     * @param named - `kind:name` identities already reported; they are skipped.
-     */
-    private libraryOriginGaps;
-    /**
-     * The locked source assets whose source is no longer in `skaile.yaml` `sources:` (`source
-     * remove`, a hand edit), keyed by lock key. ONE sentence for it: `check`, `doctor`, `outdated`,
-     * `install`, `install --locked` and `update` all say it (p1062), and none re-clones the source.
-     * A GitHub lock entry that no source declares counts as store-supplied only when a store
-     * lists the ref (OQ3): a configured store alone proves nothing, as it may never have held
-     * the asset. `check`, `doctor` and `outdated` read the store's cached catalog and never touch
-     * the network; `install` and `update` (`online`) ask the store itself.
-     *
-     * @param inScope - Only these lock keys count (`install` prunes an undeclared entry as usual).
-     * @param online - Ask the stores when the cached catalog does not list the ref.
-     */
-    private orphanedSourceGaps;
-    /**
-     * `true` when one of `stores` lists `ref` (a canonical lock key): its cached catalog holds it
-     * or, with `online`, the store answers for it. An injected store fetcher is the store client
-     * itself, so it is asked either way. A store an online install cannot ask (unreachable,
-     * air-gapped, `--no-catalog`) may hold the ref; `check` never asks, so a store lists only what
-     * its cached catalog holds.
-     */
-    private storeListsRef;
-    /**
-     * Locked source assets whose source cannot supply them any more: the source is no longer in
-     * `skaile.yaml` `sources:` (`source remove`, a hand edit), or it is there but now publishes
-     * the asset under another publisher (`source add <url> --publisher`). `skaile install` has
-     * nothing to restore them from, so the fix is manual. A source of a store-resolved lock entry
-     * is not told apart from one, so no source is called missing while a `stores:` entry exists.
-     *
-     * @param named - `kind:name` identities already reported; they are skipped.
-     * @param index - What the registered sources publish today.
-     */
-    private sourceOriginGaps;
-    /**
-     * The locked assets that come from the source `url` (a `sources:` entry): canonical refs,
-     * `kind:@publisher/name`. `skaile source remove` refuses while this list is not empty.
-     */
-    lockedFromSource(url: string): string[];
-    /**
-     * Record, on every library-origin entry of `lock` that is copied into a harness folder, the
-     * files of the deployed copy and their sha256 (`LockEntry.copied`), so a hand edit is named
-     * even after the library moved past the lock (p1641). Call it after the deploy. An entry that
-     * is unchanged since `prev` keeps its record, or stays without one: the deployed bytes may
-     * carry an edit the deploy did not touch. Project mode only; a `--link` deploy and a patched
-     * asset are not recorded.
-     */
-    private withCopiedFiles;
-    /**
-     * Record, on every agent entry of `lock` that has none, the files the agent's harness
-     * rendering occupies and their sha256. Call it after the deploy, so the bytes hashed are the
-     * ones `install` just wrote; {@link lockedCopyDrift} compares later edits with them.
-     * Entries that carry a record (kept from an earlier lock) are left as they are.
-     *
-     * @param keepComposedOf - The lock an `install` read: an agent whose `../` compose folder is
-     *   not in the cache keeps that lock's `composed:` record. Omitted by `update` and `add`,
-     *   which copy the library's current bytes.
-     */
-    private withRenderedAgents;
-    /**
-     * Make the `rendered:` list of every agent entry say exactly which files belong to it: the
-     * asset-named files of its own rendering (hashes kept as recorded) plus the files of the agent
-     * instances whose `ref` names it (`.claude/agents/default.md`, …) with their current sha256,
-     * so a hand edit of an instance file is drift like one of the asset-named file. A path that is
-     * neither is dropped: an instance that left `skaile.yaml`, or was bound to another agent, no
-     * longer lists its file under the old entry. A file that is another entry's own rendering
-     * stays with that entry; an instance whose `ref` names no locked agent (a path ref) has no
-     * entry to hold its files. Call it after `renderAgentInstances`, which rewrites every
-     * instance file, so the bytes hashed are the ones just written.
-     */
-    private withInstanceRenderings;
-    /** Append the regular files under `path` (a file or a directory) to `out`, project-relative with sha256. Symlinks are skipped. */
-    private hashTree;
-    /** The files of one agent's rendering for the active harness, project-relative, with sha256. */
-    private renderedAgentFiles;
-    /**
-     * The lock key of the agent entry an agent instance's `ref` names, or `undefined` when no locked
-     * agent matches (a path ref has no entry).
-     */
-    private agentKeyOfRef;
-    /**
-     * The rendered native files of every locked agent that the lock does not list under
-     * `rendered:` (a lock an older CLI wrote), as path → sha256 per lock key, taken before a
-     * deploy. `check` cannot tell such a file from a stale one, so {@link changedRenderings}
-     * compares it afterwards. `agent` holds the asset-named files of an entry with no `rendered:`
-     * at all (5.11.0 and older); `instance` the files of agent instances the entry's `rendered:`
-     * does not list yet (5.13.0 and older), which the instance render rewrites. Project mode only.
-     */
-    private unrecordedRenderings;
-    /**
-     * The notice `check` and `outdated` print for a lock written before it listed the rendered
-     * agent files and the files of agent instances: the next `install`, `add` or `update`
-     * adds the list and rewrites those files from the render, so a hand edit of one is lost.
-     * Empty for a current lock, and in global mode.
-     */
-    legacyLockNotices(): string[];
-    /**
-     * What a deploy changed among the files {@link unrecordedRenderings} saw before it. `rewritten`
-     * is one row per locked agent whose asset-named files differ now: a render the CLI changed (the
-     * 5.12.0 abilities block) otherwise reaches the user as a silent rewrite. `restored` is one row
-     * per agent whose instance files differ now: the render replaced them, a hand edit included.
-     */
-    private changedRenderings;
-    /**
-     * The {@link RestoredAsset} rows for the drifted copies (see {@link lockedCopyDrift}) a
-     * deploy just wrote again: those whose ref is among the `deployed` canonical refs.
-     */
-    private restoredCopies;
-    /**
-     * Hand edits in the deployed copy of a library asset whose library moved past the lock (a
-     * version bump, or an in-place edit of the same version): {@link restoreLibraryLockEntries}
-     * drops such an entry, so {@link lockedCopyDrift} would not see the edit and `update` would
-     * replace the file without a word (p1641). `covered` holds the `kind:@publisher/name` of the
-     * entries that were compared already. The lock's per-file record (`copied:`) names the edited
-     * files; a lock without one (written before it existed) compares the deployed folder with the
-     * one library hash and names the files that also differ from the library's new content.
-     */
-    private changedLibraryCopyEdits;
-    /**
-     * Locked assets whose deployed copy differs from the bytes the lock covers: a file edited by
-     * hand, or a file the asset does not ship. One row per asset, `ref` being `kind:@publisher/name`
-     * and `key` its lock key. The one comparison behind the `modified` gap and the `Restored` lines
-     * of `install`.
-     *
-     * - A library-origin asset is compared with its library's files, but only while those equal the
-     *   locked hash (changed library content is the `content` gap's business), both modified and
-     *   extra files.
-     * - A source asset is compared with the per-file hashes the lock records (modified files only:
-     *   the lock lists what the source covers, not what the deploy copies).
-     *
-     * A `--link` deploy, an asset with a configured patch, and a copy that is missing are not
-     * compared: other gaps cover them. An agent (rendered, not copied) is compared with the
-     * hashes of its rendered files the lock records (`LockEntry.rendered`); its `modified` paths
-     * are project-relative. Project mode only.
-     */
-    private lockedCopyDrift;
-    /**
-     * Locked assets (declared or required by one) whose deployed copy is gone: `skaile install`
-     * restores them. Same deployability rule as {@link AssetManager.listDeclared}'s `drift`.
-     *
-     * @param named - `kind:name` identities already reported; they are skipped.
-     */
-    private undeployedLockGaps;
-    /**
-     * {@link declaredNoHolderReason} plus, when the name exists under another kind, the same
-     * `It is a skill: skill:@pub/name.` tail `add` and `update` end their not-found line with.
-     */
-    private declaredNoHolderLine;
-    /**
-     * The `skaile.yaml` side of {@link AssetManager.projectState}: declared refs that do not
-     * parse, never resolved into the lock, are not materialized, or contradict a `#pin`.
-     * A project with no (or an unreadable) `skaile.yaml` has no declared set to reconcile.
-     *
-     * @param requirements - What {@link AssetManager.doctor} found; a declared preset whose
-     *   items it already named needs no second line.
-     * @param named - `kind:name` identities already reported; a declared asset among them
-     *   needs no `drift` line.
-     */
-    private declaredGaps;
-    /** Whether the lock's `presets` slice records `want` (kind, name and, when both carry one, publisher). */
-    private presetRecorded;
-    /**
-     * The first requirement, direct or transitive, of the declared `ref` that no local source or
-     * library holds and that nothing in the project already provides — the case `install` ends
-     * with `Missing: … nothing was installed`. `undefined` when every requirement is held, when a
-     * store is declared (it may hold the requirement and a check never goes to the network), or
-     * when `ref` itself resolves to nothing.
-     */
-    private unmetRequirementOf;
-    /**
-     * Whether `skaile install` can resolve a declared ref: a source or library holds it, or the
-     * project declares a store that may. The global catalog is not asked: a check never goes
-     * to the network.
-     */
-    private declaredRefResolvable;
-    /**
-     * Items of each declared `preset:` dependency that the lock does not cover.
-     *
-     * A preset is never locked itself; the lock lists only its expanded items, so an
-     * item missing from the lock never resolved (or was declared after the last
-     * install). Presets are read from the local sources and libraries (nested presets
-     * followed); one only a store holds cannot be read without the network and
-     * reports no gaps. Without a lock nothing is reported: `list` and `check` already
-     * show a never-installed declaration as `declared`.
-     *
-     * @param declared - The `dependencies:` refs as written in `skaile.yaml`.
-     * @param lock - The current lock, or `null` when none exists.
-     * @returns Declared preset ref → its uncovered items; `resolvable` is `true` when a
-     *   local source or library offers the item (so `skaile install` can fix it).
-     *   Presets without gaps are absent.
-     */
-    private declaredPresetGaps;
-    /**
-     * Create a minimal asset scaffold directory (delegates to {@link createScaffold}).
-     *
-     * @param name - Asset name (also used as the directory name).
-     * @param kind - Asset kind: `skill` | `agent` | `preset` | `flow` | `prompt` | `contract`.
-     * @param destDir - Parent directory to create the asset in.
-     * @param opts - Optional scaffold content (`description`).
-     * @returns `{ ok: true, path }` on success, `{ ok: false, path: errorMessage }` if the
-     *   directory already exists or `kind` has no scaffold template.
-     */
-    create(name: string, kind: string, destDir: string, opts?: ScaffoldOptions): {
-        ok: boolean;
-        path: string;
-    };
-    /**
-     * Return recent asset action history entries, newest first.
-     *
-     * @param limit - Maximum number of entries to return. Defaults to `20`.
-     * @returns Array of {@link HistoryEntry} objects in reverse-chronological order.
-     */
-    history(limit?: number): HistoryEntry[];
-    /**
-     * Erase all asset action history for this workspace.
-     */
-    clearHistory(): void;
-    /**
-     * Remove deployed assets tracked by the lock file and report unmanaged ones.
-     *
-     * With `opts.all`, also deletes `.skaile/history.yaml`, `.skaile/patches/`,
-     * `.skaile/cache/sources/`, and `skaile.lock.yaml` — effectively resetting the
-     * workspace to a pre-install state.
-     *
-     * @param opts - Optional cleanup options.
-     * @param opts.all - When `true`, remove all Skaile-managed state in addition to deployed assets.
-     * @returns Object with `removed` (successfully cleaned refs), `skipped` (with reasons),
-     *   and `unmanaged` (deployed assets not in the lock file).
-     */
-    clean(opts?: {
-        all?: boolean;
-    }): {
-        removed: string[];
-        skipped: Array<{
-            ref: string;
-            reason: string;
-        }>;
-        unmanaged: string[];
-    };
-    /**
-     * `clean --global`: remove the copy of every asset the global lock tracks from each global
-     * harness (and the old `~/.omp/<dir>` copy), keeping `~/.skaile/skaile.yaml`. With `all`, the
-     * global lock goes too.
-     */
-    private cleanGlobal;
-    /**
-     * Remove the deployed dir of every asset tracked by the lock; missing dirs
-     * still count as removed. Returns the list of cleaned refs.
-     */
-    private cleanLockedDeployedAssets;
-    /**
-     * Report deployed assets not tracked by the lock file. Deployed assets are
-     * keyed by <kind>:<name>; lock canonical refs are mapped to that shape.
-     */
-    private collectUnmanagedAssets;
-    /** Delete all Skaile-managed state: history file, patches/, cache/sources/, lock. */
-    private removeAllManagedState;
-    /**
-     * Add a dependency ref to the manifest `dependencies:` if not already present.
-     * Project mode edits `<projectDir>/skaile.yaml`; global mode edits the
-     * user-scope SSOT `~/.skaile/skaile.yaml`, **bootstrapping** the file (and its
-     * parent dir) when absent so `skaile add --global` works on a fresh machine.
-     */
-    private addDependencyToConfig;
-    /**
-     * Whether the declared `dep` names the same asset (kind, publisher, name) as
-     * `ref`, ignoring the version pin. A publisher must agree on both sides —
-     * unlike {@link removeDependencyFromConfig}, a bare `kind:name` never replaces a
-     * publisher-qualified line. Unparseable entries only match on string equality.
-     */
-    private sameDeclaredAsset;
-    /**
-     * Remove a dependency ref from the manifest `dependencies:`. Targets the same
-     * file as {@link addDependencyToConfig} (`~/.skaile/skaile.yaml` in global mode).
-     *
-     * @returns `true` when a declaration was removed.
-     */
-    private removeDependencyFromConfig;
-    /**
-     * Whether `target` is an agent that an agent instance of `skaile.yaml` binds and no
-     * `dependencies:` line names. Project mode only.
-     */
-    private boundOnlyByInstance;
-    /**
-     * The locked agents an agent instance binds (`agents.<id>.ref`, `agent.definition`) that
-     * `declared` does not name, as version-less `agent:@publisher/name`. An agent no lock entry
-     * holds is left out: `install` does not add what the user never added (`skaile add` does).
-     */
-    private lockedAgentBindings;
-    /**
-     * Bind the agent `skaile add agent:<ref>` just added as an instance `agents.<name>:
-     * {ref: agent:@publisher/name}` of `skaile.yaml`, so `run --instance <name>` and the repl
-     * banner hint work at once. An agent that an instance or `agent:` already binds, or an id
-     * `agents:` already holds, is left as it is. Project mode only.
-     *
-     * @returns the instance id and ref bound; the id with `keptRef` (what that id binds instead)
-     * when the id is taken by another agent; `undefined` when nothing was bound and nothing needs saying.
-     */
-    private bindAgentInstance;
-    /** The refs `skaile.yaml` binds agent instances to: every `agents.<id>.ref` and `agent.definition`. Project mode only. */
-    private declaredAgentInstanceRefs;
-    /**
-     * Drop the agent instances of `skaile.yaml` (`agents.<id>`, or the `agent.definition`
-     * default) whose `ref` binds to `target`, and the native agent files an install rendered for
-     * them. Only an `agent` target has bindings; project mode only. A `ref` without a publisher
-     * matches any publisher, and a pin is ignored.
-     *
-     * @returns `true` when a binding was removed.
-     */
-    private removeAgentBindings;
-    private resolveRepoDir;
+export declare class AssetManager extends AmAdd {
 }
+export type { HistoryEntry } from "./history.js";
+export { appendHistory, clearHistory, getRecentHistory, loadHistory, } from "./history.js";
+export type { DeployOptions, ScaffoldOptions } from "./installer.js";
+export type { DeployableEntry } from "./installer.js";
+export { createScaffold, deployAll, installTargetOf, removeAsset, SCAFFOLD_KINDS, } from "./installer.js";
+export type { RenderMcpConfigOptions, RenderMcpConfigResult, SkippedMcpServer, } from "./mcp-config.js";
+export { mcpNotRunnableReason, renderMcpServerConfig } from "./mcp-config.js";
+export type { Log } from "./renderers.js";
+export { renderAgentToFramework } from "./renderers.js";
+export { FACTORY_SOURCE_URL };
 export { installAgent } from "./install-agent.js";
 export { type HarnessSwitchState, harnessSwitchKeptKey, harnessSwitchStateFile, readHarnessSwitchState, writeHarnessSwitchState, } from "./harness-switch-state.js";
 export type { InstalledAgentInstance, InstallAgentInstancesOptions, InstallAgentInstancesResult, } from "./install-instances.js";