@skaile/workspaces 5.5.0 → 5.6.0

package/dist/runner/src/composition/resolve-instance.d.ts

@@ -0,0 +1,140 @@
+/**
+ * composition/resolve-instance.ts
+ *
+ * Resolves one agent *instance* — an agent asset bound into a workspace under
+ * an id (see `skaile.yaml` `agents:`) — into everything a host needs to run it:
+ * inline blocks, discoverable entries, sub-agents split into delegate vs run,
+ * memory blocks, effective triggers, io, connector slot bindings, warnings and
+ * a stable {@link ResolvedAgentInstance.revisionHash}.
+ *
+ * The composition is the asset's convention files (SOUL.md, RULES.md,
+ * DUTIES.md, knowledge/) as implicit items followed by its declared
+ * `composes:`. Bytes come from the content source and the compile manifest as
+ * in {@link resolveComposition}; a standalone `persona` / `ruleset` item
+ * composes exactly like the convention file of the same role (persona →
+ * inline-snapshot like SOUL.md, ruleset → inline-live like RULES.md).
+ *
+ * Failures are {@link CompositionError}s that end session start: a required
+ * capability nobody provides is `composition_asset_missing`.
+ */
+import { type AgentInstanceConfig, type SkWorkspaceConfig } from "@skaile/workspaces/core";
+import type { IAssetKindRegistry } from "@skaile/workspaces/plugins";
+import type { Logger } from "@skaile/workspaces/types";
+import { type AgentIo, type AgentLifecycle, type AgentManifest, type AgentTrigger, type MemoryScope } from "@skaile/workspaces/types/manifests";
+import { type CompositionContentSource } from "./content-source.js";
+import { type ResolvedComposition } from "./types.js";
+/** The agent asset an instance binds: its parsed manifest and its directory. */
+export interface AgentInstanceAsset {
+    manifest: AgentManifest;
+    /** Directory holding `agent.yaml` and the convention files. */
+    dir: string;
+}
+/** What the host running the instance can do. Every field is optional. */
+export interface AgentInstanceHost {
+    /**
+     * Whether the driver spawns native sub-agents (rendered agent files). Drives
+     * the default of a `kind: agent` item without an explicit binding:
+     * `delegate` when true, `run` otherwise. An explicit `delegate` on a driver
+     * without native sub-agents is demoted to `run` with a warning.
+     */
+    nativeSubagents?: boolean;
+    /** Names of the capabilities the host provides (what `capabilities[]` requirements are checked against). */
+    capabilities?: readonly string[];
+    /** Current memory block content by block name (host-owned state); falls back to the block's seed. */
+    memory?: Readonly<Record<string, string>>;
+}
+/** Options of {@link resolveAgentInstance}. */
+export interface ResolveAgentInstanceOpts {
+    /** Id of the instance in `skaile.yaml` `agents:` (`default` for the primary `agent:`). Never part of the revision hash. */
+    instanceId: string;
+    instance: AgentInstanceConfig;
+    asset: AgentInstanceAsset;
+    /** Project root — holds `skaile.lock.yaml`, `.skaile/cache/store` and run snapshots. */
+    projectDir: string;
+    /** Content source; defaults to the project's (local files, lock pins, local catalog). */
+    source?: CompositionContentSource;
+    host?: AgentInstanceHost;
+    /** Id of the run this resolution starts; its bytes are kept in a run snapshot (unless one exists). */
+    sessionId?: string;
+    /** Id of an earlier run this one continues; its run snapshot outranks the live sources. */
+    resumeSessionId?: string;
+    /**
+     * Resolve without writing a run snapshot (`skaile run --dry-run`). A dry run
+     * has no host, so a missing required capability is a warning, not an error.
+     */
+    dryRun?: boolean;
+    log?: Logger;
+    /** Kind registry for recognising a kind's manifest file; defaults to the built-in providers. */
+    registry?: IAssetKindRegistry;
+}
+/** A `kind: agent` composition item, loaded and bound. */
+export interface ResolvedSubagent {
+    /** `composes[].ref` as written. */
+    ref: string;
+    /** Alias the sub-agent is exposed under: `as`, else the asset's `name`, else the ref's basename. */
+    as: string;
+    /** Effective binding. */
+    binding: "delegate" | "run";
+    description?: string;
+    resolvedRef: string;
+    version: string | null;
+    /** SHA256 of the sub-agent's `agent.yaml` bytes. */
+    hash: string;
+}
+/** One memory block of the instance. */
+export interface ResolvedMemoryBlock {
+    name: string;
+    /** Declared scope, or the instance's `memory.scope` when it overrides. */
+    scope: MemoryScope;
+    maxChars: number;
+    /** Convention file the block is seeded from. */
+    source?: string;
+    /** The seed bytes (from `source`), when it has one. */
+    seed?: string;
+    /** What `<MEMORY>` renders: host content, else the seed, else empty. */
+    content: string;
+    /** False when the instance has `memory.scope: none` — only the seed is shown, nothing is stored. */
+    persisted: boolean;
+}
+/** An effective trigger: the asset's, with the instance's overrides applied, or one the instance added. */
+export type ResolvedTrigger = AgentTrigger & {
+    origin: "asset" | "instance";
+};
+/** The result of {@link resolveAgentInstance}. */
+export interface ResolvedAgentInstance extends ResolvedComposition {
+    instanceId: string;
+    /** Normalized manifest: the asset's with lifecycle/model overrides, effective `composes`, merged triggers and effective memory blocks. */
+    manifest: AgentManifest;
+    lifecycle: AgentLifecycle;
+    subagents: {
+        delegate: ResolvedSubagent[];
+        run: ResolvedSubagent[];
+    };
+    memoryBlocks: ResolvedMemoryBlock[];
+    triggers: ResolvedTrigger[];
+    io?: AgentIo;
+    /** Compose slot id → `skaile.yaml` `connectors[].id`. Not part of the revision hash. */
+    slots: Record<string, string>;
+    /** SHA-256 of {normalized manifest, files, compile entries}; see `revision-hash.ts`. */
+    revisionHash: string;
+}
+/**
+ * The instance a session runs: the entry of `skaile.yaml` `agents:` (or the
+ * primary `agent:` for `default`), else a bare instance of the session's own
+ * agent directory.
+ */
+export declare function instanceForSession(config: Pick<SkWorkspaceConfig, "agent">, instanceId: string | undefined, agentDir: string): {
+    instanceId: string;
+    instance: AgentInstanceConfig;
+};
+/**
+ * Resolve an agent instance. Convention files compose first (implicit items),
+ * then the asset's `composes:`.
+ *
+ * @throws {CompositionError} `composition_rebuild_required` (declared `inline-snapshot` item never
+ *   compiled), `composition_asset_missing` (item bytes or a required capability missing),
+ *   `composition_conflict` (ambiguous or cyclic).
+ * @docLink packages/runner/capabilities#resolve-agent-instance
+ */
+export declare function resolveAgentInstance(opts: ResolveAgentInstanceOpts): Promise<ResolvedAgentInstance>;
+//# sourceMappingURL=resolve-instance.d.ts.map

package/dist/runner/src/composition/resolve-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-instance.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/resolve-instance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EACL,KAAK,mBAAmB,EAIxB,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAEL,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,aAAa,EAElB,KAAK,YAAY,EAGjB,KAAK,WAAW,EACjB,MAAM,oCAAoC,CAAC;AAI5C,OAAO,EAAE,KAAK,wBAAwB,EAAkC,MAAM,qBAAqB,CAAC;AASpG,OAAO,EAAE,KAAK,mBAAmB,EAAgD,MAAM,YAAY,CAAC;AAMpG,gFAAgF;AAChF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,aAAa,CAAC;IACxB,+DAA+D;IAC/D,GAAG,EAAE,MAAM,CAAC;CACb;AAED,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,4GAA4G;IAC5G,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,qGAAqG;IACrG,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC3C;AAED,+CAA+C;AAC/C,MAAM,WAAW,wBAAwB;IACvC,2HAA2H;IAC3H,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,wFAAwF;IACxF,UAAU,EAAE,MAAM,CAAC;IACnB,yFAAyF;IACzF,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,sGAAsG;IACtG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2FAA2F;IAC3F,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gGAAgG;IAChG,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED,0DAA0D;AAC1D,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,oGAAoG;IACpG,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,OAAO,EAAE,UAAU,GAAG,KAAK,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wCAAwC;AACxC,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,2GAA2G;AAC3G,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG;IAAE,MAAM,EAAE,OAAO,GAAG,UAAU,CAAA;CAAE,CAAC;AAE9E,kDAAkD;AAClD,MAAM,WAAW,qBAAsB,SAAQ,mBAAmB;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,0IAA0I;IAC1I,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,EAAE;QAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;QAAC,GAAG,EAAE,gBAAgB,EAAE,CAAA;KAAE,CAAC;IACrE,YAAY,EAAE,mBAAmB,EAAE,CAAC;IACpC,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,wFAAwF;IACxF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,wFAAwF;IACxF,YAAY,EAAE,MAAM,CAAC;CACtB;AAMD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,EACxC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,GACf;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,mBAAmB,CAAA;CAAE,CAGvD;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CA0IhC"}

package/dist/runner/src/composition/resolve.d.ts

@@ -1,20 +1,27 @@
 /**
  * composition/resolve.ts
  *
- * Resolves an agent's `composes:` items against the Library into a
- * ResolvedComposition — prompt blocks for inline items and discoverable
- * entries for tool-list items.
+ * Resolves an agent's `composes:` items into a ResolvedComposition — prompt
+ * blocks for inline items and discoverable entries for tool-list items.
  *
- * Three resolution paths per binding:
- *   - `inline-snapshot`: reads frozen content from compile_manifest.json
- *   - `inline-live`: reads current content from Library (per invocation)
- *   - `discoverable`: registers as a capability (name + description + content)
+ * Where each binding's bytes come from:
+ *   - `inline-snapshot`: the compile manifest only. An item that was never
+ *     compiled is a `composition_rebuild_required` error — there is no live
+ *     fallback.
+ *   - `inline-live`: the content source (lock pin, else catalog/local file),
+ *     read once when a run starts. The caller keeps the bytes in the run's
+ *     snapshot; a resumed run passes that snapshot back and gets them again.
+ *   - `discoverable`: registered by name + description; the content the tool
+ *     hands out is the compiled capture (or, for an item added after the last
+ *     rebuild, what the content source serves at run start).
  *
- * This module is pure logic — no IO beyond the IAssetIndex calls.
+ * A run snapshot, when given, outranks every other origin so a resumed run is
+ * byte-identical to the run it continues.
  */
 import type { IAssetIndex } from "@skaile/workspaces/library";
 import type { AgentComposeItem } from "@skaile/workspaces/types/manifests";
-import { type CompileManifest, type ResolvedComposition } from "./types.js";
+import type { CompositionContentSource } from "./content-source.js";
+import { type CompileManifest, type CompositionRunSnapshot, type ResolvedComposition, type ResolvedCompositionItem } from "./types.js";
 /**
  * Options for {@link resolveComposition}.
  *
@@ -23,31 +30,42 @@ import { type CompileManifest, type ResolvedComposition } from "./types.js";
 export interface ResolveCompositionOpts {
     /** The agent's composes: items */
     items: AgentComposeItem[];
-    /** Library for asset resolution */
+    /** Library for asset descriptions (optional enrichment) */
     library: IAssetIndex;
-    /**
-     * Pre-loaded compile manifest for inline-snapshot items.
-     * If absent, inline-snapshot items fall back to live resolution with a warning.
-     */
+    /** Where live bytes come from */
+    source: CompositionContentSource;
+    /** Pre-loaded compile manifest (absent when the agent was never compiled). */
     compileManifest?: CompileManifest;
+    /** The bytes a run already captured; set when resuming it. */
+    runSnapshot?: CompositionRunSnapshot;
     /**
-     * Content loader — given an asset ref, returns the asset's prompt-injectable content.
-     * For skill: the SKILL.md body. For persona/ruleset: the manifest body text.
-     * Returns null if the content cannot be loaded.
+     * Marks the implicit convention items (SOUL.md, RULES.md, DUTIES.md,
+     * knowledge/). They are the agent's own files, which harnesses also carry
+     * natively, so they are held to a softer rule than declared items: an
+     * `inline-snapshot` item that was never compiled is read from the source
+     * (with a warning) instead of ending session start, and one the source
+     * cannot serve is skipped with a warning. Declared items stay strict.
      */
-    loadContent: (ref: string, kind: string) => Promise<string | null>;
+    implicit?: (item: AgentComposeItem) => boolean;
 }
 /**
  * Resolve all composition items for an agent.
  *
- * Returns:
- *   - inlineBlocks: content to inject into the system prompt
- *   - discoverableEntries: items to register as LLM-visible capabilities
- *   - warnings: non-fatal issues encountered during resolution
- *
- * @param opts - Resolution options with items, library, optional compile manifest and content loader.
- * @returns A {@link ResolvedComposition} with inline blocks, discoverable entries, and warnings.
+ * @param opts - Resolution options with items, library, content source, compile manifest and run snapshot.
+ * @returns A {@link ResolvedComposition} with inline blocks, discoverable entries, the resolved items and warnings.
+ * @throws {CompositionError} `composition_rebuild_required` for an uncompiled `inline-snapshot` item;
+ *   `composition_asset_missing` / `composition_conflict` for an item the content source cannot serve.
  * @docLink packages/runner/capabilities#resolve-composition
  */
 export declare function resolveComposition(opts: ResolveCompositionOpts): Promise<ResolvedComposition>;
+/**
+ * Load the asset a `kind: agent` item names (its `agent.yaml` text). Sub-agents
+ * are pinned like discoverable items: a run snapshot, then the compiled
+ * capture, then the content source. The compiled entry is found whichever
+ * delegate/run binding it was compiled under — the effective binding depends
+ * on the driver, the pinned bytes do not.
+ *
+ * @throws {CompositionError} `composition_asset_missing` / `composition_conflict` from the content source.
+ */
+export declare function resolveSubagentItem(item: AgentComposeItem, binding: "delegate" | "run", source: CompositionContentSource, compileManifest: CompileManifest | undefined, runSnapshot: CompositionRunSnapshot | undefined): Promise<ResolvedCompositionItem>;
 //# sourceMappingURL=resolve.d.ts.map

package/dist/runner/src/composition/resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,mBAAmB,EAAkB,MAAM,YAAY,CAAC;AAM5F;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,kCAAkC;IAClC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,mCAAmC;IACnC,OAAO,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC;;;;OAIG;IACH,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACpE;AAMD;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CA+B9B"}
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAGpE,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAE7B,MAAM,YAAY,CAAC;AAMpB;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,kCAAkC;IAClC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,2DAA2D;IAC3D,OAAO,EAAE,WAAW,CAAC;IACrB,iCAAiC;IACjC,MAAM,EAAE,wBAAwB,CAAC;IACjC,8EAA8E;IAC9E,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,8DAA8D;IAC9D,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,OAAO,CAAC;CAChD;AAMD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAsE9B;AAuFD;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,UAAU,GAAG,KAAK,EAC3B,MAAM,EAAE,wBAAwB,EAChC,eAAe,EAAE,eAAe,GAAG,SAAS,EAC5C,WAAW,EAAE,sBAAsB,GAAG,SAAS,GAC9C,OAAO,CAAC,uBAAuB,CAAC,CAMlC"}

package/dist/runner/src/composition/revision-hash.d.ts

@@ -0,0 +1,58 @@
+/**
+ * composition/revision-hash.ts
+ *
+ * The one place a resolved agent instance is reduced to a content hash.
+ * `skaile run --dry-run` and every host that records instance revisions call
+ * {@link computeRevisionHash}, so the same inputs always give the same hash.
+ *
+ * The hash covers what defines the agent's behaviour: the normalized manifest,
+ * the agent directory's files (path + sha256) and the composition entries
+ * (ref, binding, hash of the bytes composed). It excludes everything that
+ * varies between runs of the same definition: timestamps, host/workspace ids,
+ * the instance id and connector slot bindings.
+ */
+/** One file of the agent directory. */
+export interface RevisionFileEntry {
+    /** Path relative to the agent directory, `/`-separated. */
+    path: string;
+    sha256: string;
+}
+/** One composition item as it enters the hash. */
+export interface RevisionCompileEntry {
+    kind: string;
+    ref: string;
+    /** Slot id, when the item has one (part of the definition, unlike its connector binding). */
+    id?: string;
+    /** Effective binding. */
+    binding: string;
+    /** SHA256 of the composed bytes. */
+    hash: string;
+}
+/** Input of {@link computeRevisionHash}. */
+export interface RevisionHashInput {
+    /** The normalized (effective) manifest: asset manifest with instance overrides applied. */
+    manifest: unknown;
+    /** Files of the agent directory; order does not matter. */
+    files: readonly RevisionFileEntry[];
+    /** Composition entries in effective order (order shapes the prompt, so it is kept). */
+    entries: readonly RevisionCompileEntry[];
+}
+/**
+ * Deterministic JSON: object keys sorted, `undefined` dropped, no whitespace.
+ * Two values that differ only in key order or `undefined` members serialise equally.
+ */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * SHA-256 (hex) over the canonical JSON of `{ manifest, files, entries }`,
+ * with `files` sorted by path.
+ *
+ * @docLink packages/runner/capabilities#compute-revision-hash
+ */
+export declare function computeRevisionHash(input: RevisionHashInput): string;
+/**
+ * List and hash the files of an agent directory (recursive, sorted by path).
+ * Dot-entries, `node_modules` and the compile manifest are not part of the
+ * definition and are skipped. A missing directory yields no entries.
+ */
+export declare function hashAgentFiles(agentDir: string): Promise<RevisionFileEntry[]>;
+//# sourceMappingURL=revision-hash.d.ts.map

package/dist/runner/src/composition/revision-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-hash.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/revision-hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,uCAAuC;AACvC,MAAM,WAAW,iBAAiB;IAChC,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,kDAAkD;AAClD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,6FAA6F;IAC7F,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,4CAA4C;AAC5C,MAAM,WAAW,iBAAiB;IAChC,2FAA2F;IAC3F,QAAQ,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACpC,uFAAuF;IACvF,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAeD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAcpE;AAID;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAuBnF"}

package/dist/runner/src/composition/run-snapshot.d.ts

@@ -0,0 +1,37 @@
+/**
+ * composition/run-snapshot.ts
+ *
+ * Per-run capture of composition bytes. `inline-live` is read once when a run
+ * starts; the bytes are written beside the session's persisted state so a
+ * resumed run is byte-identical to the run it continues. File:
+ * `<project>/.skaile/composition-runs/<sessionId>.json`.
+ */
+import type { CompositionRunSnapshot, ResolvedCompositionItem } from "./types.js";
+/**
+ * Absolute path of the snapshot file for a session.
+ *
+ * @docLink packages/runner/capabilities#composition-run-snapshot
+ */
+export declare function compositionRunSnapshotPath(projectDir: string, sessionId: string): string;
+/**
+ * Load a session's run snapshot.
+ *
+ * @returns The snapshot, or `undefined` when the session captured none.
+ * @throws {CompositionError} `composition_conflict` when the file is malformed or an item's
+ *   bytes no longer match its hash.
+ * @docLink packages/runner/capabilities#composition-run-snapshot
+ */
+export declare function loadCompositionRunSnapshot(projectDir: string, sessionId: string): Promise<CompositionRunSnapshot | undefined>;
+/**
+ * Build a run snapshot from what a resolution just served.
+ *
+ * @docLink packages/runner/capabilities#composition-run-snapshot
+ */
+export declare function buildCompositionRunSnapshot(sessionId: string, items: readonly ResolvedCompositionItem[], promptVersion: number | null): CompositionRunSnapshot;
+/**
+ * Persist a run snapshot (atomic write).
+ *
+ * @docLink packages/runner/capabilities#composition-run-snapshot
+ */
+export declare function saveCompositionRunSnapshot(projectDir: string, snapshot: CompositionRunSnapshot): Promise<void>;
+//# sourceMappingURL=run-snapshot.d.ts.map

package/dist/runner/src/composition/run-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-snapshot.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/run-snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH,OAAO,KAAK,EAEV,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAgBpB;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAExF;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAqC7C;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,uBAAuB,EAAE,EACzC,aAAa,EAAE,MAAM,GAAG,IAAI,GAC3B,sBAAsB,CAmBxB;AAED;;;;GAIG;AACH,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,sBAAsB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/runner/src/composition/types.d.ts

@@ -8,6 +8,17 @@
  */
 import type { AgentComposeItem, Binding } from "@skaile/workspaces/types/manifests";
 export type { AgentComposeItem, Binding };
+/**
+ * Thrown by {@link resolveBinding} when a composition item has no explicit
+ * `binding` and its `kind` has no default. `skaile validate` reports the same
+ * condition earlier as `unknown_asset_kind`.
+ */
+export declare class UnknownCompositionKindError extends Error {
+    readonly kind: string;
+    readonly ref: string;
+    readonly code = "unknown_asset_kind";
+    constructor(kind: string, ref: string);
+}
 /**
  * Resolve the effective binding for a composition item.
  * Uses explicit `binding` if set, otherwise falls back to kind default.
@@ -15,39 +26,46 @@ export type { AgentComposeItem, Binding };
  * @param item - A single entry from an agent manifest's `composes:` list.
  * @returns The effective {@link Binding} — explicit value when set, otherwise
  *   the kind-specific default (e.g. `soul` → `inline-snapshot`, `skill` → `discoverable`).
+ * @throws {UnknownCompositionKindError} when no `binding` is set and the kind has no default.
  * @docLink packages/runner/capabilities#resolve-binding
  */
 export declare function resolveBinding(item: AgentComposeItem): Binding;
 /**
  * Single entry in the agent's `compile_manifest.json`. Records the resolved
- * version, content hash, and effective binding for one composition item at
- * the time of the last `skaile rebuild` run.
+ * ref, version, content hash, effective binding and the captured bytes of one
+ * composition item at the time of the last `skaile rebuild` run.
  *
  * @docLink packages/runner/capabilities#compile-manifest-entry
  */
 export interface CompileManifestEntry {
-    /** Asset ref (e.g. '@skaile/sales-soul@1.2') */
+    /** The `composes[].ref` exactly as written in agent.yaml. */
     asset_ref: string;
-    /** Resolved version (e.g. '1.2.3') */
+    /** The item's asset kind. */
+    kind: string;
+    /** Where the bytes actually came from (`kind:@publisher/name#version` or `local:<path>`). */
+    resolved_ref: string;
+    /** Resolved version; `null` for a local file. */
     version: string | null;
-    /** SHA256 of the resolved content */
+    /** SHA256 of `content` (recomputed on every read). */
     hash: string;
-    /** Effective binding */
+    /** Effective binding. */
     binding: Binding;
-    /** ISO timestamp when this entry was resolved */
+    /** ISO timestamp when this entry was resolved. */
     resolved_at: string;
+    /** The captured bytes: what `inline-snapshot` serves and `discoverable` hands out on invocation. */
+    content: string;
 }
 /**
  * Root structure of `compile_manifest.json` written by `skaile rebuild`.
  * Tracks the prompt version counter and all resolved composition entries.
- * The runner reads this at session start to verify inline-snapshot content
- * against its stored hash.
+ * The runner serves `inline-snapshot` and `discoverable` content from these
+ * entries and never from the live sources.
  *
  * @docLink packages/runner/capabilities#compile-manifest
  */
 export interface CompileManifest {
-    /** Compile manifest schema version */
-    schema_version: 1;
+    /** Compile manifest schema version (1 was the hash-only format; it must be rebuilt). */
+    schema_version: 2;
     /** Prompt version — bumped on every rebuild */
     prompt_version: number;
     /** Entries for each composition item */
@@ -55,6 +73,24 @@ export interface CompileManifest {
     /** ISO timestamp of the last rebuild */
     compiled_at: string;
 }
+/**
+ * The bytes one run of an agent uses for every non-snapshot composition item,
+ * captured when the run starts and reused when the run resumes. Stored beside
+ * the session's persisted state (`<project>/.skaile/composition-runs/<id>.json`).
+ *
+ * @docLink packages/runner/capabilities#composition-run-snapshot
+ */
+export interface CompositionRunSnapshot {
+    schema_version: 1;
+    /** Session id (or run id) the snapshot belongs to. */
+    session_id: string;
+    /** ISO timestamp of capture. */
+    captured_at: string;
+    /** Compile `prompt_version` the run started under (`null` when never compiled). */
+    prompt_version: number | null;
+    /** One entry per resolved item (content items and sub-agent items). */
+    items: CompileManifestEntry[];
+}
 /**
  * A resolved inline content block for system prompt injection.
  *
@@ -69,6 +105,12 @@ export interface InlineBlock {
     content: string;
     /** Binding mode that produced this block */
     binding: "inline-live" | "inline-snapshot";
+    /**
+     * True for the agent's own convention files (SOUL.md, RULES.md, DUTIES.md).
+     * Harnesses carry those natively (rendered at install), so the runner does
+     * not repeat them in the live system prompt.
+     */
+    implicit?: boolean;
 }
 /**
  * A resolved discoverable item (becomes a tool-list entry).
@@ -87,6 +129,29 @@ export interface DiscoverableEntry {
     /** Full content (loaded on demand when the tool is invoked) */
     content: string;
 }
+/**
+ * One composition item as resolved for a run — what `skaile run --dry-run`
+ * prints and what the run snapshot is built from.
+ *
+ * @docLink packages/runner/capabilities#resolved-composition-item
+ */
+export interface ResolvedCompositionItem {
+    /** `composes[].ref` as written. */
+    ref: string;
+    kind: string;
+    binding: Binding;
+    /** Where the bytes came from (`kind:@publisher/name#version` or `local:<path>`). */
+    resolvedRef: string;
+    version: string | null;
+    /** SHA256 of `content`. */
+    hash: string;
+    content: string;
+    /**
+     * `compiled` — served from the compile manifest; `run-snapshot` — reused from
+     * the run's own capture (resume); `source` — read from the content source now.
+     */
+    origin: "compiled" | "run-snapshot" | "source";
+}
 /**
  * The full result of resolving an agent's composes: field.
  *
@@ -97,7 +162,9 @@ export interface ResolvedComposition {
     inlineBlocks: InlineBlock[];
     /** Items to register as discoverable capabilities */
     discoverableEntries: DiscoverableEntry[];
-    /** Warnings (non-fatal — e.g. missing assets) */
+    /** Every resolved content item, in `composes:` order (sub-agent items carry no content and are absent). */
+    items: ResolvedCompositionItem[];
+    /** Non-fatal notes */
     warnings: string[];
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/runner/src/composition/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAMpF,YAAY,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAC;AA0B1C;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAG9D;AAMD;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,iDAAiD;IACjD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,cAAc,EAAE,CAAC,CAAC;IAClB,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,wCAAwC;IACxC,WAAW,EAAE,MAAM,CAAC;CACrB;AAMD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,OAAO,EAAE,aAAa,GAAG,iBAAiB,CAAC;CAC5C;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,iBAAiB;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,2BAA2B;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,qDAAqD;IACrD,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IACzC,iDAAiD;IACjD,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/types.ts"],"names":[],"mappings":"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"}

package/dist/runner/src/index.d.ts

@@ -1,5 +1,7 @@
 export { globalSettingsPath, loadSettings, mapLegacyFields, projectSettingsPath, resolveSettings, type SkaileSettings, saveSettings, } from "@skaile/workspaces/core";
 export * from "./agent.js";
+export * from "./agents/memory-run-store.js";
+export * from "./agents/run-controller.js";
 export * from "./builtin-capabilities.js";
 export * from "./capability-registry.js";
 export * from "./capability-roundtrip.js";

package/dist/runner/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../runner/src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,KAAK,cAAc,EACnB,YAAY,GACb,MAAM,yBAAyB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,kBAAkB,CAAC;AAEjC,OAAO,EACL,0BAA0B,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,iBAAiB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../runner/src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,KAAK,cAAc,EACnB,YAAY,GACb,MAAM,yBAAyB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,kBAAkB,CAAC;AAEjC,OAAO,EACL,0BAA0B,EAC1B,KAAK,uBAAuB,GAC7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,iBAAiB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC"}

package/dist/runner/src/manifest.d.ts

@@ -6,7 +6,7 @@
  * SOUL/RULES/knowledge is handled by the renderers at install time and the
  * drivers at runtime (native identity).
  */
-import type { AgentManifest } from "@skaile/workspaces/core";
+import type { AgentManifest } from "@skaile/workspaces/types/manifests";
 /** True if the given directory contains a valid GitAgent definition (agent.yaml present). */
 /**
  * Check whether an agent definition directory contains a valid agent.yaml.

package/dist/runner/src/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../runner/src/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG7D,6FAA6F;AAC7F;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAc5F"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../runner/src/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAGxE,6FAA6F;AAC7F;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAc5F"}

package/dist/runner/src/mixin-resolver.d.ts

@@ -15,7 +15,7 @@
  * Knowledge bundles (kind="knowledge") resolve to a directory — all *.md files
  * inside are loaded in priority order (same priority-based loadKnowledge logic used by the asset-manager).
  */
-import type { AgentManifest, CatalogEntry } from "@skaile/workspaces/core";
+import type { CatalogEntry } from "@skaile/workspaces/core";
 /**
  * A resolved mixin with its content loaded from disk.
  *
@@ -35,16 +35,6 @@ export interface ResolvedMixin {
  * @docLink packages/runner/dev-guide#key-conventions
  */
 export type RepoMap = Record<string, CatalogEntry[]>;
-/**
- * Content of an agent mixin, loaded from `CONVENTIONS.md` or `RULES.md`.
- *
- * @docLink packages/runner/dev-guide#key-conventions
- */
-export interface AgentMixinContent {
-    personas: ResolvedMixin[];
-    rules: ResolvedMixin[];
-    knowledge: ResolvedMixin[];
-}
 /**
  * Resolve a single mixin ref to its text content.
  * Returns null if the ref cannot be resolved (missing file or unknown catalog name).
@@ -52,10 +42,19 @@ export interface AgentMixinContent {
  * @docLink packages/runner/dev-guide#key-conventions
  */
 export declare function resolveMixin(ref: string, defaultKind: string, agentDir: string, repos: RepoMap): Promise<ResolvedMixin | null>;
+/** Strip YAML frontmatter (--- delimited) from markdown content. */
+export declare function stripFrontmatter(text: string): string;
 /**
- * Resolve all mixin arrays from a manifest.
- * All three kinds resolve concurrently. Unresolvable refs are silently skipped.
- * @docLink packages/runner/dev-guide#key-conventions
+ * True when `text` is a knowledge `index.yaml` that declares `documents: []` —
+ * a valid, empty knowledge base. A missing, unparsable or `documents`-less
+ * index is not.
+ */
+export declare function isEmptyKnowledgeIndex(text: string): boolean;
+/**
+ * Load all *.md files from a knowledge directory, in priority order.
+ * Reads index.yaml (same priority-based loadKnowledge format used by the asset-manager) when present.
+ * Returns combined content joined with \n\n---\n\n; an empty-documents index yields the index
+ * bytes (see {@link isEmptyKnowledgeIndex}); null when the dir is missing or holds neither.
  */
-export declare function resolveAgentMixins(manifest: Pick<AgentManifest, "persona" | "rules" | "knowledge">, agentDir: string, repos: RepoMap): Promise<AgentMixinContent>;
+export declare function loadKnowledgeDir(dir: string): Promise<ResolvedMixin | null>;
 //# sourceMappingURL=mixin-resolver.d.ts.map

package/dist/runner/src/mixin-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mixin-resolver.d.ts","sourceRoot":"","sources":["../../../runner/src/mixin-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI3E;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,SAAS,EAAE,aAAa,EAAE,CAAC;CAC5B;AAID;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA0B/B;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,CAAC,EAChE,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,iBAAiB,CAAC,CAkB5B"}
+{"version":3,"file":"mixin-resolver.d.ts","sourceRoot":"","sources":["../../../runner/src/mixin-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAK5D;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;AAIrD;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA0B/B;AAaD,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErD;AAuDD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAW3D;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CA4CjF"}

package/dist/runner/src/serve.d.ts

@@ -338,6 +338,12 @@ export interface ServeOptions {
      * `AgentRefResolutionError` instead of starting as a different agent.
      */
     agentDir?: string;
+    /**
+     * Id of the `skaile.yaml` `agents:` instance this runner serves; default
+     * `default` (the primary `agent:`). Selects the instance's overrides and the
+     * memory blocks `memory.*` addresses.
+     */
+    instanceId?: string;
     /**
      * Exit the process with 141 when stdout's pipe dies. Defaults to `false`,
      * because `startAgentServer` is a library entry point and an embedder's