@skaile/workspaces 6.15.0 → 6.16.0

package/dist/asset-manager/src/add-remove/add.d.ts

@@ -0,0 +1,134 @@
+import { type AssetRef, type HarnessName, type PresetExpansion, type ProvenanceCandidate, type SourceDeclaration, type SourceEntry, type StoreEntry } from "@skaile/workspaces/core";
+import { type DeployableEntry } from "../installer.js";
+import type { LibraryMove } from "../shared/types.js";
+import { AmRemove } from "./remove.js";
+/**
+ * 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 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[];
+}
+/** Add() and ref planning. One layer of the `AssetManager` class chain (see `asset-manager/CLAUDE.md`). */
+export declare abstract class AmAdd extends AmRemove {
+    /**
+     * 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.
+     */
+    protected otherKindRefs(parsed: AssetRef): Promise<string[]>;
+    /**
+     * 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.
+     */
+    protected planAddItems(resolved: readonly ProvenanceCandidate[], lib: {
+        entries: DeployableEntry[];
+        libraryOf: ReadonlyMap<DeployableEntry, string>;
+    }, stores: readonly StoreEntry[], parsed: AssetRef): AddPlanItem[];
+    /**
+     * 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>`.
+     */
+    protected parseAddRef(ref: string, repositories: Record<string, SourceDeclaration>, sources: SourceEntry[]): Promise<AssetRef>;
+    /**
+     * 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.
+     */
+    protected resolvableMatches(ref: string, repositories: Record<string, SourceDeclaration>, sources: SourceEntry[]): Promise<string[]>;
+    /**
+     * 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[]>;
+}
+//# sourceMappingURL=add.d.ts.map

package/dist/asset-manager/src/add-remove/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/add-remove/add.ts"],"names":[],"mappings":"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"}

package/dist/asset-manager/src/add-remove/remove.d.ts

@@ -0,0 +1,329 @@
+import { type HarnessName } from "@skaile/workspaces/core";
+import type { AssetDefinition } from "@skaile/workspaces/library";
+import { AmReadDoctor } from "../read/doctor.js";
+/**
+ * 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;
+/**
+ * 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;
+}
+/** 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[];
+}
+/** Identity {@link AssetManager.remove} acts on; `publisher` is absent for an unqualified short ref. */
+interface RemoveTarget {
+    kind: string;
+    name: string;
+    publisher?: string;
+}
+/** Soft deps, remove(), pruneOrphans. One layer of the `AssetManager` class chain (see `asset-manager/CLAUDE.md`). */
+export declare abstract class AmRemove extends AmReadDoctor {
+    /**
+     * 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.
+     */
+    protected withIndexDefs<T>(fn: (defs: AssetDefinition[]) => T, fallback: T): Promise<T>;
+    /**
+     * 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.
+     */
+    protected collectSoftDeps(allDefs: AssetDefinition[], refs: string[], onlyAbsent: boolean): SoftDepEdge[];
+    /**
+     * 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.
+     */
+    protected presentRefNames(): Set<string>;
+    /**
+     * 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.
+     */
+    protected presentRefs(): string[];
+    /**
+     * 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.
+     */
+    protected resolveRemoveTarget(ref: string): RemoveTarget | null;
+    /**
+     * 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.
+     */
+    protected requiredByOthers(target: RemoveTarget): Promise<{
+        ref: string;
+        requiredBy: string[];
+    } | null>;
+    /**
+     * 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.
+     */
+    protected trackedPublishers(kind: string, name: string): Set<string | undefined>;
+    /**
+     * The lock entries of `kind:name` under another publisher than `wantPub` whose recorded bytes
+     * are the deployed copy, while the entries of `wantPub` do not record them. Empty when no
+     * entry provably owns the folder (nothing recorded, or the copy was edited), so the remove
+     * keeps its old meaning there.
+     */
+    protected otherLockOwners(kind: string, name: string, wantPub: string): {
+        publisher?: string;
+        ref: string;
+    }[];
+    /**
+     * 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.
+     */
+    protected lockHolders(kind: string, name: string): {
+        publisher?: string;
+        ref: string;
+    }[];
+    /** The folders or files of `kind:name` on disk in `target`, shown relative to the project. */
+    protected heldDeployPaths(kind: string, name: string, target: HarnessName): string[];
+    /**
+     * 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`.
+     */
+    protected removeResolved(parsed: RemoveTarget, opts?: {
+        force?: boolean;
+        kept?: string[];
+        ownedBy?: {
+            refs: string[];
+            paths: string[];
+        }[];
+    }): boolean;
+    /**
+     * 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).
+     */
+    protected harnessesStillHolding(target: RemoveTarget): HarnessName[] | undefined;
+    /** Limit the declared global entry of `target` to `harnesses` (`~/.skaile/skaile.yaml`). */
+    protected limitDeclaredEntry(target: RemoveTarget, harnesses: HarnessName[]): void;
+    /**
+     * 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.
+     */
+    protected pruneOrphans(requiredRefs: string[]): Promise<string[]>;
+    /**
+     * 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.
+     */
+    protected pruneLockEntry(parsed: {
+        kind: string;
+        name: string;
+        publisher?: string;
+    }): boolean;
+}
+export {};
+//# sourceMappingURL=remove.d.ts.map

package/dist/asset-manager/src/add-remove/remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../../asset-manager/src/add-remove/remove.ts"],"names":[],"mappings":"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"}

package/dist/asset-manager/src/agent-render.d.ts

@@ -0,0 +1,116 @@
+import { type LockFileEntry } from "@skaile/workspaces/core";
+import { type StaleAgentFile } from "./install-instances.js";
+import type { DeployOptions } from "./installer.js";
+import { AmReadState } from "./read/state.js";
+import type { InstallResult } from "./shared/types.js";
+/** A file named after an agent asset that an instance's file stands for now; see `leftoverAgentFiles`. */
+interface LeftoverAgentFile {
+    agent: string;
+    /** Project-relative. */
+    path: string;
+    /** The instances that bind the agent (none for a `binding: run` role). */
+    ids: string[];
+    /** The lock records other bytes for it than the file holds. */
+    edited: boolean;
+}
+/** Agent instance render and leftover agent files. One layer of the `AssetManager` class chain (see `asset-manager/CLAUDE.md`). */
+export declare abstract class AmAgentRender extends AmReadState {
+    protected abstract renderedAgentFiles(name: string): LockFileEntry[];
+    protected abstract unboundAgentAdvice(ref: string): Promise<{
+        lead: string;
+        advice: string;
+    }>;
+    /**
+     * 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.
+     */
+    protected instanceClaims(): (rel: string) => boolean;
+    /**
+     * 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.
+     */
+    protected supersededRendering(): (name: string, rel: string) => boolean;
+    /**
+     * 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.
+     */
+    protected leftoverAgentFiles(): LeftoverAgentFile[];
+    /**
+     * 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.
+     */
+    protected pruneAssetNamedAgentFiles(): string[];
+    /**
+     * 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. The line
+     * of an agent whose `extends` parent is not there is not printed here: `add` prints it once
+     * (`missingParentNotices`), `check` and `doctor` print it after.
+     *
+     * @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`.
+     */
+    protected renderAgentInstances(opts?: Pick<DeployOptions, "lockAssets"> & {
+        prune?: boolean;
+    }): Promise<Pick<InstallResult, "agentInstances" | "agentInstancesChanged" | "agentFilesRemoved" | "agentInstanceErrors" | "agentInstanceDetails">>;
+    /**
+     * The agent assets rendered under their own name (no instance binds them, no `binding: run`
+     * role) whose source the cache holds: the agents whose files `staleAgentFiles` looks at besides
+     * the instances'.
+     */
+    private assetNamedAgents;
+    /**
+     * One line per baked block of a native agent file whose inputs changed since `install` wrote it
+     * (`<file>: <block label> is out of date - run skaile install`): what `check` and `doctor` print
+     * as drift. It covers the files of the agent instances, the delegate sub-agents beside them and
+     * the files named after an agent asset. Project scope only; a harness without a native agent
+     * file has none.
+     */
+    staleAgentFileLines(): Promise<string[]>;
+    /**
+     * Render every stale native agent file again, through the renders `install` uses (so the bytes
+     * are an `install`'s), and record the new bytes in the lock entries that list the files, so
+     * `check` finds no edit. `skaile run`, `repl` and `serve` call it before the session starts:
+     * the files are rendered artefacts, and an edit of `DUTIES.md`, a local ruleset or a prompt
+     * extension applies to the next run, whichever agent of the project the session reaches
+     * (another instance through `agent.run`, a delegate sub-agent the harness spawns). A render
+     * whose files include one that is not the bytes the lock recorded was edited by hand: it is
+     * left as it is (`check` names it) and not returned.
+     *
+     * @returns The files that were stale and are rendered again; empty when nothing was.
+     * @throws When a file is still stale after the render.
+     */
+    rerenderStaleAgentFiles(): Promise<StaleAgentFile[]>;
+    /** Render the agent a stale file belongs to again; the workspace-relative files it wrote. */
+    private renderOwner;
+    /**
+     * Put the sha256 of the files just written into the lock entries that list them. The lock is
+     * read again here, not taken from before the render: another process may have written it in
+     * between (an `add`, an `update`), and only the `rendered` hashes of these files change.
+     */
+    private recordRenderedHashes;
+}
+export {};
+//# sourceMappingURL=agent-render.d.ts.map

package/dist/asset-manager/src/agent-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-render.d.ts","sourceRoot":"","sources":["../../../asset-manager/src/agent-render.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,aAAa,EAGnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EASL,KAAK,cAAc,EAGpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,0GAA0G;AAC1G,UAAU,iBAAiB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,+DAA+D;IAC/D,MAAM,EAAE,OAAO,CAAC;CACjB;AAgCD,mIAAmI;AACnI,8BAAsB,aAAc,SAAQ,WAAW;IAErD,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE;IACpE,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAE7F;;;;OAIG;IACH,SAAS,CAAC,cAAc,IAAI,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO;IAOpD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO;IA6BvE;;;;;;;;OAQG;IACH,SAAS,CAAC,kBAAkB,IAAI,iBAAiB,EAAE;IAgDnD;;;;;;;OAOG;IACH,SAAS,CAAC,yBAAyB,IAAI,MAAM,EAAE;IAsB/C;;;;OAIG;IACH,wBAAwB,IAAI,MAAM,EAAE;IASpC;;;;;;;;;;;;OAYG;cACa,oBAAoB,CAClC,IAAI,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,GAAG;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7D,OAAO,CACR,IAAI,CACF,aAAa,EACX,gBAAgB,GAChB,uBAAuB,GACvB,mBAAmB,GACnB,qBAAqB,GACrB,sBAAsB,CACzB,CACF;IAuCD;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAiBxB;;;;;;OAMG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAY9C;;;;;;;;;;;;OAYG;IACG,uBAAuB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAuC1D,6FAA6F;YAC/E,WAAW;IAuCzB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;CAkB7B"}

package/dist/asset-manager/src/composed-blocks.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The prompt blocks an agent bakes into its native agent file besides the convention files: the
+ * inline items of `composes:` (rulesets, prompts, personas, contracts, knowledge) and the seeds of
+ * memory blocks that nothing stores (`memory.scope: none`).
+ *
+ * The bytes come from the runner's own content source (`createCompositionContentSource`, the one
+ * function `skaile run` resolves a `composes:` ref with: a local path, a lock pin, a registered
+ * library, the catalog), so the file holds what a run sends, in `composes:` order. A ref that
+ * source cannot resolve throws its `CompositionError`; install reports it and the agent is not
+ * rendered. A host-backed memory block is never baked: the host owns its content, only the
+ * runner has it.
+ */
+import type { AgentInstanceConfig, AgentPromptMemoryBlock, AgentPromptPart, LockEntry } from "@skaile/workspaces/core";
+import type { AgentManifest } from "@skaile/workspaces/types/manifests";
+/** What {@link loadPromptBlocks} found. */
+export interface PromptBlocks {
+    /** The inline `composes:` items, in `composes:` order. */
+    composed: AgentPromptPart[];
+    /** The memory blocks whose seed is baked (`memory.scope: none`). */
+    memory: AgentPromptMemoryBlock[];
+}
+/**
+ * Read the composed inline blocks and the baked memory seeds of an agent for its native file.
+ *
+ * @param manifest - The agent manifest (`composes`, `memory`).
+ * @param srcDir - The agent's source directory: base of local refs and of `memory.blocks[].source`.
+ * @param projectDir - The project root (`skaile.lock.yaml`, `.skaile/cache/store`).
+ * @param instance - The `skaile.yaml` instance being rendered; `memory.scope: none` bakes the seeds.
+ * @param lockAssets - The lock entries the command is about to write. A pin the same command moves
+ *   (`skaile update`) resolves against them, not against the older lock on disk.
+ * @throws `CompositionError` (`@skaile/workspaces/runner/composition-content`) when the runner's
+ *   content source cannot resolve an inline item; its message names the ref.
+ */
+export declare function loadPromptBlocks(manifest: AgentManifest, srcDir: string, projectDir: string, instance?: AgentInstanceConfig, lockAssets?: Record<string, LockEntry>): Promise<PromptBlocks>;
+/**
+ * The loaded prompt extensions as parts that carry their config path, the identity a native file
+ * and a run find them by. A missing or empty file is left out, as the runner leaves it out.
+ */
+export declare function loadPromptExtensionParts(paths: readonly string[] | undefined, projectDir: string): AgentPromptPart[];
+//# sourceMappingURL=composed-blocks.d.ts.map

package/dist/asset-manager/src/composed-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composed-blocks.d.ts","sourceRoot":"","sources":["../../../asset-manager/src/composed-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EACV,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,SAAS,EACV,MAAM,yBAAyB,CAAC;AAQjC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAgCxE,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,oEAAoE;IACpE,MAAM,EAAE,sBAAsB,EAAE,CAAC;CAClC;AAKD;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,mBAAmB,EAC9B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GACrC,OAAO,CAAC,YAAY,CAAC,CAgDvB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACpC,UAAU,EAAE,MAAM,GACjB,eAAe,EAAE,CAOnB"}