@skaile/workspaces 0.8.5

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

@@ -0,0 +1,14 @@
+/**
+ * composition/index.ts — barrel for the agent composition module (Task 1.7).
+ *
+ * Resolves an agent's `composes:` field into:
+ *   - Inline prompt blocks (inline-live, inline-snapshot)
+ *   - Discoverable tool entries (registered via capability registry)
+ *
+ * And supports `skaile rebuild <agent>` via the compile module.
+ */
+export { resolveBinding, type Binding, type AgentComposeItem, type CompileManifest, type CompileManifestEntry, type InlineBlock, type DiscoverableEntry, type ResolvedComposition, } from "./types.js";
+export { resolveComposition, type ResolveCompositionOpts } from "./resolve.js";
+export { compileComposition, loadCompileManifest, loadCompileManifestFromDir, COMPILE_MANIFEST_FILENAME, type CompileOpts, type CompileResult, } from "./compile.js";
+export { resolveAgentComposition, registerCompositionCapabilities, type ResolveAgentCompositionOpts, } from "./bootstrap.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EACL,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAG/E,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,yBAAyB,EACzB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,KAAK,2BAA2B,GACjC,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ *
+ * 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)
+ *
+ * This module is pure logic — no IO beyond the ILibrary calls.
+ */
+import type { ILibrary } from "@skaile/workspaces/library";
+import type { AgentComposeItem } from "@skaile/workspaces/types/manifests";
+import { type CompileManifest, type ResolvedComposition } from "./types.js";
+/**
+ * Options for {@link resolveComposition}.
+ *
+ * @docLink packages/runner/capabilities#resolve-composition
+ */
+export interface ResolveCompositionOpts {
+    /** The agent's composes: items */
+    items: AgentComposeItem[];
+    /** Library for asset resolution */
+    library: ILibrary;
+    /**
+     * Pre-loaded compile manifest for inline-snapshot items.
+     * If absent, inline-snapshot items fall back to live resolution with a warning.
+     */
+    compileManifest?: CompileManifest;
+    /**
+     * 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.
+     */
+    loadContent: (ref: string, kind: string) => Promise<string | null>;
+}
+/**
+ * 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.
+ * @docLink packages/runner/capabilities#resolve-composition
+ */
+export declare function resolveComposition(opts: ResolveCompositionOpts): Promise<ResolvedComposition>;
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAkB,KAAK,eAAe,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAM5F;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,kCAAkC;IAClC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,mCAAmC;IACnC,OAAO,EAAE,QAAQ,CAAC;IAClB;;;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"}

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

@@ -0,0 +1,103 @@
+/**
+ * composition/types.ts
+ *
+ * Shared types for the agent composition module (Task 1.7).
+ *
+ * Defines the binding system, compile manifest schema, and the
+ * resolved composition result that the runner consumes at session start.
+ */
+import type { Binding, AgentComposeItem } from "@skaile/workspaces/types/manifests";
+export type { Binding, AgentComposeItem };
+/**
+ * Resolve the effective binding for a composition item.
+ * Uses explicit `binding` if set, otherwise falls back to kind default.
+ *
+ * @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`).
+ * @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.
+ *
+ * @docLink packages/runner/capabilities#compile-manifest-entry
+ */
+export interface CompileManifestEntry {
+    /** Asset ref (e.g. '@skaile/sales-soul@1.2') */
+    asset_ref: string;
+    /** Resolved version (e.g. '1.2.3') */
+    version: string | null;
+    /** SHA256 of the resolved content */
+    hash: string;
+    /** Effective binding */
+    binding: Binding;
+    /** ISO timestamp when this entry was resolved */
+    resolved_at: 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.
+ *
+ * @docLink packages/runner/capabilities#compile-manifest
+ */
+export interface CompileManifest {
+    /** Compile manifest schema version */
+    schema_version: 1;
+    /** Prompt version — bumped on every rebuild */
+    prompt_version: number;
+    /** Entries for each composition item */
+    entries: CompileManifestEntry[];
+    /** ISO timestamp of the last rebuild */
+    compiled_at: string;
+}
+/**
+ * A resolved inline content block for system prompt injection.
+ *
+ * @docLink packages/runner/capabilities#inline-block
+ */
+export interface InlineBlock {
+    /** Source ref for debugging */
+    ref: string;
+    /** Asset kind */
+    kind: string;
+    /** The text content to inject */
+    content: string;
+    /** Binding mode that produced this block */
+    binding: "inline-live" | "inline-snapshot";
+}
+/**
+ * A resolved discoverable item (becomes a tool-list entry).
+ *
+ * @docLink packages/runner/capabilities#discoverable-entry
+ */
+export interface DiscoverableEntry {
+    /** Source ref */
+    ref: string;
+    /** Asset kind */
+    kind: string;
+    /** Tool name for capability registry */
+    name: string;
+    /** One-line description */
+    description: string;
+    /** Full content (loaded on demand when the tool is invoked) */
+    content: string;
+}
+/**
+ * The full result of resolving an agent's composes: field.
+ *
+ * @docLink packages/runner/capabilities#resolved-composition
+ */
+export interface ResolvedComposition {
+    /** Blocks to inline into the system prompt (inline-live + inline-snapshot) */
+    inlineBlocks: InlineBlock[];
+    /** Items to register as discoverable capabilities */
+    discoverableEntries: DiscoverableEntry[];
+    /** Warnings (non-fatal — e.g. missing assets) */
+    warnings: string[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../runner/src/composition/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAMpF,YAAY,EAAE,OAAO,EAAE,gBAAgB,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"}

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

@@ -0,0 +1,11 @@
+/**
+ * Driver configuration — re-exported from @skaile/workspaces/core.
+ *
+ * This file is a backwards-compatibility shim. All types and functions
+ * originate in skaile-agent-core and are re-exported here so existing
+ * imports within skaile-agent-runner continue to work unchanged.
+ * @docLink packages/runner/dev-guide#config
+ */
+export type { DriverTarget, DriverPaths } from "@skaile/workspaces/core";
+export { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS, DRIVER_DEFAULTS, resolveDriverPaths, } from "@skaile/workspaces/core";
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../runner/src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,eAAe,EACf,kBAAkB,GACnB,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1,16 @@
+/**
+ * Build a markdown section describing the platform context in which the
+ * agent is running. Rendered into the system prompt alongside resource and environment sections.
+ */
+import type { AgentContextConfig } from "@skaile/workspaces/core";
+/**
+ * Build a markdown section describing the platform context in which the
+ * agent is running. Rendered into the system prompt alongside resource
+ * and environment sections.
+ *
+ * @param context - Platform context configuration (platform, multi_user, session_model)
+ * @returns Markdown section string, or undefined when no context is configured
+ * @docLink packages/runner/dev-guide#flow-execution-turn-based-model
+ */
+export declare function buildContextSection(context: AgentContextConfig | undefined): string | undefined;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../runner/src/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAOlE;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CA8C/F"}

package/dist/runner/src/define-capability.d.ts

@@ -0,0 +1,153 @@
+/**
+ * `defineCapability` — author-friendly factory that builds a {@link DefinedCapability}
+ * from a Zod-typed input/output schema.
+ *
+ * Authors declare a capability with Zod schemas; this factory derives the
+ * wire-format `inputSchema` / `outputSchema` (JSON Schema) and packages the
+ * handler so it can be invoked uniformly through {@link CapabilityRegistry}.
+ *
+ * The runtime per-handler logger (`ctx.log`) is wired by the registry at
+ * invocation time — handlers MUST NOT construct their own logger; all output
+ * goes through `ctx.log` so it lands under the
+ * `capability:<origin>:<name>` slice (see protocol-v2 carry-forward L2).
+ *
+ * @category Capabilities
+ * @since 2.0.0
+ */
+import type { z } from "zod";
+import type { Capability, CapabilityAudience, CapabilityOrigin, Logger, RenderSpec } from "@skaile/workspaces/types";
+/**
+ * Per-invocation context passed to a capability handler. The registry builds
+ * a fresh context for each call and fills in `log` from
+ * `createLogger({kind: 'capability', subkind: <origin.kind>, instance: <name>})`.
+ *
+ * Additional runtime hooks (cancellation signal, store accessors, etc.) can
+ * be threaded in by the bridge layer in later phases; the minimum contract is
+ * `sessionId` + `log`.
+ *
+ * @category Capabilities
+ * @since 2.0.0
+ * @docLink packages/runner/capabilities#handlercontext-log-convention-carry-forward-l2
+ */
+export type HandlerContext = {
+    /** Session this invocation belongs to. */
+    sessionId: string;
+    /**
+     * Per-capability logger pre-configured as
+     * `createLogger({kind: 'capability', subkind: <origin.kind>, instance: <name>})`.
+     * Handlers MUST emit through this logger so invocations land under the
+     * `capability:<origin>:<name>` slice and stay queryable from the debug
+     * panel and `skaile session logs`.
+     */
+    log: Logger;
+};
+/**
+ * Arguments to {@link defineCapability}. Mirrors the wire-format
+ * {@link Capability} fields plus the Zod schemas (input + optional output)
+ * and the handler.
+ *
+ * @category Capabilities
+ * @since 2.0.0
+ * @docLink packages/runner/capabilities#registry-surface
+ */
+export type DefineCapabilityArgs<T extends z.ZodTypeAny, R extends z.ZodTypeAny | undefined = undefined> = {
+    /** Stable, session-unique name. Convention: `<namespace>.<verb>`. */
+    name: string;
+    /**
+     * Human-readable label for user-facing surfaces (cmdK action palette,
+     * debug panels). Falls back to `name` when omitted.
+     */
+    displayName?: string;
+    /** Human/LLM-readable summary; shown to the LLM at tool registration. */
+    description: string;
+    /** Zod schema validating `args` at invocation time. Converted to JSON Schema. */
+    input: T;
+    /** Optional Zod schema for the return value. Converted to JSON Schema when present. */
+    output?: R;
+    /** Where the handler runs. */
+    side: "client" | "agent";
+    /** Discriminated tag identifying who registered the capability. */
+    origin: CapabilityOrigin;
+    /** Lifetime: `session` survives the whole session, `turn` is dropped at end-of-turn. */
+    scope?: "session" | "turn";
+    /** When true, the bridge auto-resolves with `{}` immediately and runs the handler in the background. */
+    fireAndForget?: boolean;
+    /** When true, the platform shows a confirm UI before dispatch. */
+    requiresApproval?: boolean;
+    /** Documentation hint: side-effect, render, or pure query. */
+    kind?: "effect" | "render" | "query";
+    /**
+     * Whether this capability should be exposed in user-facing surfaces
+     * (cmdK / capability menus). Defers to `isUserInvokable` inference rules
+     * when omitted. See `@skaile/workspaces/types#isUserInvokable`.
+     *
+     * @deprecated Set {@link audience} instead. Kept for v2.x compatibility
+     * with skill authors that haven't migrated.
+     */
+    userInvokable?: boolean;
+    /**
+     * Audience scoping for this capability. When omitted, consumers treat
+     * the capability as `['llm', 'user']` (v2.x default). Host RPCs and
+     * `runner.*` capabilities MUST set this to `['runtime']` so they never
+     * reach the LLM tool list or the user-facing command palette.
+     *
+     * @since 3.0.0
+     */
+    audience?: CapabilityAudience[];
+    /** Appended to the system prompt's `<CAPABILITIES>` section. */
+    promptFragment?: string;
+    /** Render contract for capabilities that produce a UI surface. */
+    render?: RenderSpec;
+    /**
+     * The handler. Receives validated input plus a {@link HandlerContext}.
+     * When `output` is declared, the return type is inferred from the schema;
+     * otherwise the handler may return any value (including `void` for pure
+     * effects).
+     */
+    handler: (args: z.infer<T>, ctx: HandlerContext) => Promise<R extends z.ZodTypeAny ? z.infer<R> : unknown>;
+};
+/**
+ * A registered capability. Carries the wire-format {@link Capability} fields
+ * plus the original Zod schemas and the type-erased handler. The registry
+ * stores `DefinedCapability`s; serialization to the wire (for replay or
+ * remote registration) drops the runtime fields.
+ *
+ * @category Capabilities
+ * @since 2.0.0
+ * @docLink packages/runner/capabilities#registry-surface
+ */
+export type DefinedCapability = Capability & {
+    /** Original Zod schema for runtime input validation. Not serialized to the wire. */
+    readonly inputZod: z.ZodTypeAny;
+    /** Original Zod schema for the optional output, if declared. Not serialized. */
+    readonly outputZod?: z.ZodTypeAny;
+    /** Type-erased handler invoked through {@link CapabilityRegistry.invoke}. */
+    handler: (args: unknown, ctx: HandlerContext) => Promise<unknown>;
+};
+/**
+ * Build a {@link DefinedCapability} from author-friendly Zod-typed args.
+ *
+ * The resulting `inputSchema` / `outputSchema` on the capability are JSON
+ * Schema records (per the wire contract); the original Zod schemas are kept
+ * on `inputZod` / `outputZod` for runtime validation in
+ * {@link CapabilityRegistry.invoke}.
+ *
+ * @example
+ * ```ts
+ * const reactCap = defineCapability({
+ *   name: 'platform.react',
+ *   description: 'Acknowledge a user message with a Unicode emoji.',
+ *   side: 'client',
+ *   origin: { kind: 'client' },
+ *   fireAndForget: true,
+ *   input: z.object({ emoji: z.string(), targetSeq: z.number().optional() }),
+ *   handler: async ({ emoji }, ctx) => { ctx.log.info('reacted', { emoji }) },
+ * });
+ * ```
+ *
+ * @category Capabilities
+ * @since 2.0.0
+ * @docLink packages/runner/capabilities#registry-surface
+ */
+export declare function defineCapability<T extends z.ZodTypeAny, R extends z.ZodTypeAny | undefined = undefined>(args: DefineCapabilityArgs<T, R>): DefinedCapability;
+//# sourceMappingURL=define-capability.d.ts.map

package/dist/runner/src/define-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-capability.d.ts","sourceRoot":"","sources":["../../../runner/src/define-capability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EACV,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,MAAM,EACN,UAAU,EACX,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,CAAC,CAAC,UAAU,EACtB,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,SAAS,GAAG,SAAS,IAC5C;IACF,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,KAAK,EAAE,CAAC,CAAC;IACT,uFAAuF;IACvF,MAAM,CAAC,EAAE,CAAC,CAAC;IACX,8BAA8B;IAC9B,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IACzB,mEAAmE;IACnE,MAAM,EAAE,gBAAgB,CAAC;IACzB,wFAAwF;IACxF,KAAK,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC3B,wGAAwG;IACxG,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kEAAkE;IAClE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,8DAA8D;IAC9D,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAChC,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;;OAKG;IACH,OAAO,EAAE,CACP,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAChB,GAAG,EAAE,cAAc,KAChB,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;CAC7D,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG;IAC3C,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC;IAChC,gFAAgF;IAChF,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC;IAClC,6EAA6E;IAC7E,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACnE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,SAAS,CAAC,CAAC,UAAU,EACtB,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,SAAS,GAAG,SAAS,EAC9C,IAAI,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,iBAAiB,CA6BrD"}

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

@@ -0,0 +1,21 @@
+/**
+ * Probe the runtime environment for available tools and runtimes, and build
+ * a markdown section describing them for the system prompt.
+ *
+ * Runs once at session start. All probes execute in parallel with a per-probe
+ * timeout so the total wall time is bounded by the slowest single probe.
+ */
+/**
+ * Probe the runtime environment for available tools and runtimes at
+ * session start, and build a markdown section describing them for the
+ * system prompt.
+ *
+ * All probes execute in parallel with a per-probe timeout so total wall
+ * time is bounded by the slowest single probe.
+ *
+ * @param projectDir - The project working directory
+ * @returns Markdown section string, or undefined when no tools are found
+ * @docLink packages/runner/dev-guide#environment-variables
+ */
+export declare function buildEnvironmentSection(projectDir: string): Promise<string | undefined>;
+//# sourceMappingURL=environment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../runner/src/environment.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmDH;;;;;;;;;;;GAWG;AACH,wBAAsB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoD7F"}

package/dist/runner/src/file-changed-rewriter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Rewrite file_changed event paths to mounts-relative form.
+ *
+ * The bridge normalizer forwards tool filePaths verbatim — for Claude SDK
+ * Write/Edit they are cwd-relative (e.g. "workspace/foo/bar.py" when cwd
+ * is /skaile and the file lives at /skaile/workspace/foo/bar.py). The
+ * frontend's file-change listener treats the path as relative to the
+ * currently-selected mount, which double-prefixes when the workspace
+ * mount sits under cwd.
+ *
+ * This helper resolves the path against cwd, locates the mount it falls
+ * inside, and re-expresses the path relative to that mount with the
+ * matching mountId attached.
+ *
+ * Events that already carry a mountId (watcher-originated) and events
+ * whose path resolves outside every mount are passed through unchanged.
+ */
+import type { AgentEvent } from "@skaile/workspaces/types";
+/**
+ * Describes a filesystem mount point for path rewriting.
+ *
+ * @docLink packages/runner/dev-guide#flow-execution-turn-based-model
+ */
+export interface MountPoint {
+    id: string;
+    /** Absolute mount path on the agent's filesystem. */
+    mountPath: string;
+}
+/**
+ * Rewrite a single file_changed event. Non-file_changed events and events
+ * already tagged with a mountId are returned unchanged.
+ * @docLink packages/runner/dev-guide#flow-execution-turn-based-model
+ */
+export declare function rewriteFileChangedPath(event: AgentEvent, cwd: string, mounts: readonly MountPoint[]): AgentEvent;
+//# sourceMappingURL=file-changed-rewriter.d.ts.map

package/dist/runner/src/file-changed-rewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-changed-rewriter.d.ts","sourceRoot":"","sources":["../../../runner/src/file-changed-rewriter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,UAAU,EAAE,GAC5B,UAAU,CAgBZ"}

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

@@ -0,0 +1,22 @@
+export { globalSettingsPath, loadSettings, mapLegacyFields, projectSettingsPath, resolveSettings, type SkaileSettings, saveSettings, } from "@skaile/workspaces/core";
+export * from "./agent.js";
+export * from "./config.js";
+export * from "./context.js";
+export * from "./environment.js";
+export * from "./resources.js";
+export * from "./manifest.js";
+export * from "./prompt-assembly.js";
+export * from "./mixin-resolver.js";
+export { MarkdownStreamer } from "./markdown-stream.js";
+export * from "./resource-handler.js";
+export * from "./logging-bootstrap.js";
+export * from "./serve.js";
+export * from "./session.js";
+export * from "./session-builder.js";
+export * from "./session-stimulus.js";
+export * from "./define-capability.js";
+export * from "./capability-registry.js";
+export * from "./builtin-capabilities.js";
+export * from "./capability-roundtrip.js";
+export * from "./composition/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC"}

package/dist/runner/src/logging-bootstrap.d.ts

@@ -0,0 +1,92 @@
+import { type LogStore } from "@skaile/workspaces/core/logging";
+import type { LogEntry, LogEntryEvent, LogSink, LogQuery, LogQueryResult } from "@skaile/workspaces/types";
+/**
+ * Pre-init log sink. Active before the LogStore boots — i.e. during the
+ * window between process start and `session_init` processing.
+ *
+ * Writes every entry to `process.stdout` (so early-boot operators / container
+ * log shippers still see it). Entries are also captured in a bounded
+ * in-memory ring (default cap 200 entries) so that, once the LogStore boots,
+ * subscribers can read them via {@link entries} for diagnostic purposes.
+ *
+ * NOTE: backfilling the buffered entries into the LogStore's SQLite trail is
+ * not done in v3.0 because `LogStore.record()` re-stamps id/timestamp/
+ * sessionId, which would corrupt the original entries. A follow-up
+ * (`AF-PV3 / F-LOG-BACKFILL`) will add a `replay()` API to LogStore so the
+ * boot logs land in the persistent trail alongside the live stream.
+ *
+ * Spec: `_devlog/specs/2026-05-10-deterministic-session-bootstrap.md` §
+ * Pre-init logging.
+ */
+export declare class PreInitRingSink implements LogSink {
+    private readonly ring;
+    private readonly cap;
+    constructor(cap?: number);
+    write(entry: LogEntry): void;
+    writeBatch(entries: LogEntry[]): void;
+    /** Optional query (no-op) — satisfies the LogSink contract. */
+    query(_q: LogQuery): LogQueryResult;
+    /** Close hook — clears the ring so subsequent writes are dropped. */
+    close(): void;
+    /** Number of entries currently buffered (capped at {@link cap}). */
+    size(): number;
+    /** Snapshot of the currently-buffered entries. Used for diagnostics. */
+    entries(): readonly LogEntry[];
+    /** Discard all buffered entries. Called by `bootstrapRunnerLogStore`. */
+    clear(): void;
+}
+/**
+ * Install (or return the existing) process-wide pre-init sink. Idempotent
+ * so the first import wins; later calls reuse the same ring.
+ *
+ * Called from the top of every runner entry point (CLI, serve.ts) before
+ * any other code emits structured logs.
+ */
+export declare function installPreInitRingSink(cap?: number): PreInitRingSink;
+/** Currently-installed pre-init sink, or `null` if none has been installed. */
+export declare function getPreInitRingSink(): PreInitRingSink | null;
+/** Drop the reference to the installed sink. Used in tests + on dispose. */
+export declare function clearPreInitRingSink(): void;
+/**
+ * Options for {@link bootstrapRunnerLogStore}.
+ *
+ * @docLink packages/runner/logging#bootstrap-options
+ */
+export interface BootstrapOptions {
+    sessionId: string;
+    projectDir: string;
+    /** `skaile.yaml`'s `logging:` block, if pre-loaded. */
+    yamlBlock?: unknown;
+    /** Back-compat callback — every entry mirrored as a formatted line. */
+    onLog?: (line: string) => void;
+    /**
+     * Transport send callback. When provided, a `WsLogSink` is installed so
+     * every recorded LogEntry flows to the connected client as a `log_entry`
+     * AgentEvent. Drops silently when the transport is disconnected — that
+     * gating happens inside the transport's `send()`.
+     */
+    transportSend?: (event: LogEntryEvent) => void;
+}
+/**
+ * Result from {@link bootstrapRunnerLogStore}.
+ *
+ * @docLink packages/runner/logging#bootstrap-result
+ */
+export interface BootstrapResult {
+    store: LogStore;
+    dispose: () => void;
+}
+/**
+ * Idempotent bootstrap. If the same sessionId is re-used, returns the existing
+ * registered store. If a different sessionId arrives, the previous store is
+ * closed and replaced.
+ * @docLink packages/runner/logging#bootstrap-runner-log-store
+ */
+export declare function bootstrapRunnerLogStore(opts: BootstrapOptions): BootstrapResult;
+/**
+ * Reset the runner's process-singleton LogStore.
+ *
+ * @docLink packages/runner/logging#reset-runner-log-store
+ */
+export declare function resetRunnerLogStore(): void;
+//# sourceMappingURL=logging-bootstrap.d.ts.map

package/dist/runner/src/logging-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-bootstrap.d.ts","sourceRoot":"","sources":["../../../runner/src/logging-bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAQd,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,OAAO,EACP,QAAQ,EACR,cAAc,EACf,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,eAAgB,YAAW,OAAO;IAC7C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,GAAG,SAAM;IAIrB,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAM5B,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI;IAIrC,+DAA+D;IAC/D,KAAK,CAAC,EAAE,EAAE,QAAQ,GAAG,cAAc;IAInC,qEAAqE;IACrE,KAAK,IAAI,IAAI;IAIb,oEAAoE;IACpE,IAAI,IAAI,MAAM;IAId,wEAAwE;IACxE,OAAO,IAAI,SAAS,QAAQ,EAAE;IAI9B,yEAAyE;IACzE,KAAK,IAAI,IAAI;CAGd;AAaD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,SAAM,GAAG,eAAe,CAIjE;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,IAAI,CAE3D;AAED,4EAA4E;AAC5E,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uEAAuE;IACvE,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAChD;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAID;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,GAAG,eAAe,CA0C/E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C"}

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

@@ -0,0 +1,33 @@
+/**
+ * manifest.ts
+ *
+ * Parses the agent definition manifest (agent.yaml) from a GitAgent directory.
+ * This is the sole responsibility of this module — system prompt assembly for
+ * SOUL/RULES/knowledge is handled by the renderers at install time and the
+ * backend drivers at runtime (native identity).
+ */
+import type { AgentManifest } from "@skaile/workspaces/core";
+/** True if the given directory contains a valid GitAgent definition (agent.yaml present). */
+/**
+ * Check whether an agent definition directory contains a valid agent.yaml.
+ *
+ * @param agentDir - Path to the agent definition directory
+ * @returns true when agent.yaml exists at the given path
+ * @docLink packages/runner/dev-guide#manifest-loading
+ */
+export declare function agentDefinitionExists(agentDir: string): Promise<boolean>;
+/**
+ * Load and parse the agent manifest from `agent.yaml` in the given directory.
+ *
+ * Returns `undefined` when:
+ * - The file does not exist
+ * - The file is empty or whitespace-only
+ * - The YAML is malformed
+ *
+ * This replaces the old `buildAgentImprint()` for the manifest-extraction use case.
+ * The system prompt assembly that `buildAgentImprint()` used to do is no longer
+ * a runtime concern — it is handled by the renderers at install time.
+ * @docLink packages/runner/dev-guide#manifest-loading
+ */
+export declare function loadAgentManifest(agentDir: string): Promise<AgentManifest | undefined>;
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../runner/src/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,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/markdown-stream.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Accumulates streamed markdown text and renders it to the terminal
+ * with ANSI formatting (bold, italic, code blocks, etc.).
+ *
+ * Strategy: accumulate full text, re-render on each write, output only
+ * the newly rendered portion. Completed blocks (separated by double
+ * newlines) are "committed" so re-rendering only processes the tail.
+ * @docLink packages/runner/dev-guide#agent-chat-single-shot
+ */
+export declare class MarkdownStreamer {
+    private buffer;
+    private committedSource;
+    private committedRender;
+    private output;
+    constructor(output?: NodeJS.WriteStream);
+    write(chunk: string): void;
+    /** Render any remaining content and reset state. */
+    end(): void;
+    private flush;
+    private render;
+}
+//# sourceMappingURL=markdown-stream.d.ts.map

package/dist/runner/src/markdown-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-stream.d.ts","sourceRoot":"","sources":["../../../runner/src/markdown-stream.ts"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,eAAe,CAAM;IAE7B,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,MAAM,CAAqB;gBAEvB,MAAM,GAAE,MAAM,CAAC,WAA4B;IAIvD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK1B,oDAAoD;IACpD,GAAG,IAAI,IAAI;IAaX,OAAO,CAAC,KAAK;IAeb,OAAO,CAAC,MAAM;CAYf"}