@skaile/workspaces 0.8.5

package/dist/core/src/logging/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../core/src/logging/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,SAAS,CAiB1E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAwBhF"}

package/dist/core/src/logging/sinks/no-op-sink.d.ts

@@ -0,0 +1,9 @@
+import type { LogEntry, LogQuery, LogQueryResult } from "@skaile/workspaces/types";
+import { type LogSink } from "./types.js";
+export declare class NoOpSink implements LogSink {
+    write(_entry: LogEntry): void;
+    writeBatch(_entries: LogEntry[]): void;
+    query(_q: LogQuery): LogQueryResult;
+    close(): void;
+}
+//# sourceMappingURL=no-op-sink.d.ts.map

package/dist/core/src/logging/sinks/no-op-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-op-sink.d.ts","sourceRoot":"","sources":["../../../../../core/src/logging/sinks/no-op-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjE,qBAAa,QAAS,YAAW,OAAO;IACtC,KAAK,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI;IAC7B,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,IAAI;IACtC,KAAK,CAAC,EAAE,EAAE,QAAQ,GAAG,cAAc;IAGnC,KAAK,IAAI,IAAI;CACd"}

package/dist/core/src/logging/sinks/on-log-bridge-sink.d.ts

@@ -0,0 +1,16 @@
+import type { LogEntry, LogSink } from "@skaile/workspaces/types";
+/**
+ * OnLogBridgeSink — forwards every entry as a single formatted text line to
+ * a legacy `onLog(line)` callback. Used as a back-compat bridge for callers
+ * that historically received plain text lines from the runner.
+ *
+ * Format: `[level] [kind:subkind[:instance]] message [data-json] [— error.message]`
+ */
+export declare class OnLogBridgeSink implements LogSink {
+    private readonly onLog;
+    constructor(onLog: (line: string) => void);
+    write(entry: LogEntry): void;
+    writeBatch(entries: LogEntry[]): void;
+    close(): void;
+}
+//# sourceMappingURL=on-log-bridge-sink.d.ts.map

package/dist/core/src/logging/sinks/on-log-bridge-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-log-bridge-sink.d.ts","sourceRoot":"","sources":["../../../../../core/src/logging/sinks/on-log-bridge-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAElE;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,OAAO;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;IAE1D,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAc5B,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI;IAIrC,KAAK,IAAI,IAAI;CAGd"}

package/dist/core/src/logging/sinks/sqlite-sink.d.ts

@@ -0,0 +1,18 @@
+import type { LogEntry, LogQuery, LogQueryResult } from "@skaile/workspaces/types";
+import type { LogSink } from "./types.js";
+export interface SqliteSinkOptions {
+    path: string;
+}
+export declare class SqliteSink implements LogSink {
+    private db;
+    private insertStmt;
+    private insertMany;
+    private closed;
+    constructor(opts: SqliteSinkOptions);
+    write(entry: LogEntry): void;
+    writeBatch(entries: LogEntry[]): void;
+    close(): void;
+    query(q: LogQuery): LogQueryResult;
+    private toRow;
+}
+//# sourceMappingURL=sqlite-sink.d.ts.map

package/dist/core/src/logging/sinks/sqlite-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-sink.d.ts","sourceRoot":"","sources":["../../../../../core/src/logging/sinks/sqlite-sink.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAoBD,qBAAa,UAAW,YAAW,OAAO;IACxC,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,MAAM,CAAS;gBAEX,IAAI,EAAE,iBAAiB;IAenC,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAK5B,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI;IAKrC,KAAK,IAAI,IAAI;IAMb,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,cAAc;IA0FlC,OAAO,CAAC,KAAK;CAcd"}

package/dist/core/src/logging/sinks/stdout-sink.d.ts

@@ -0,0 +1,24 @@
+import type { LogEntry } from "@skaile/workspaces/types";
+import type { LogSink } from "./types.js";
+export type StdoutFormat = "pretty" | "json";
+/** Which standard stream the sink writes to. */
+export type StdoutStream = "stdout" | "stderr";
+export interface StdoutSinkOptions {
+    format?: StdoutFormat;
+    /**
+     * Standard stream to write to. Default: `"stdout"`. Set to `"stderr"` for
+     * processes whose stdout is a reserved channel — e.g. a stdio MCP server,
+     * where stdout carries JSON-RPC and any log line would corrupt the protocol.
+     */
+    stream?: StdoutStream;
+}
+export declare class StdoutSink implements LogSink {
+    private format;
+    private stream;
+    constructor(opts?: StdoutSinkOptions);
+    write(entry: LogEntry): void;
+    writeBatch(entries: LogEntry[]): void;
+    close(): void;
+    private render;
+}
+//# sourceMappingURL=stdout-sink.d.ts.map

package/dist/core/src/logging/sinks/stdout-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdout-sink.d.ts","sourceRoot":"","sources":["../../../../../core/src/logging/sinks/stdout-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7C,gDAAgD;AAChD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAoBD,qBAAa,UAAW,YAAW,OAAO;IACxC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,MAAM,CAAqB;gBAEvB,IAAI,GAAE,iBAAsB;IAKxC,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI5B,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI;IAIrC,KAAK,IAAI,IAAI;IAEb,OAAO,CAAC,MAAM;CAUf"}

package/dist/core/src/logging/sinks/types.d.ts

@@ -0,0 +1,5 @@
+export type { LogSink } from "@skaile/workspaces/types";
+export declare class LogStoreDisabledError extends Error {
+    constructor();
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/src/logging/sinks/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../core/src/logging/sinks/types.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD,qBAAa,qBAAsB,SAAQ,KAAK;;CAK/C"}

package/dist/core/src/logging/sinks/ws-log-sink.d.ts

@@ -0,0 +1,24 @@
+import type { LogEntry, LogEntryEvent } from "@skaile/workspaces/types";
+import type { LogSink } from "./types.js";
+export interface WsLogSinkOptions {
+    /**
+     * Transport send callback. Typically wired to `transport.send` on the
+     * runner's `WebSocketServerTransport`. The transport already drops sends
+     * when no client is connected — this sink does not buffer.
+     */
+    send: (event: LogEntryEvent) => void;
+}
+/**
+ * Forwards every LogEntry recorded by LogStore as a `log_entry` AgentEvent
+ * over the configured transport. Used by the runner to make container-side
+ * structured logs visible to the platform gateway in real time. Historical
+ * reads still go through SQLite — this sink is for live tail only.
+ */
+export declare class WsLogSink implements LogSink {
+    private readonly send;
+    constructor(opts: WsLogSinkOptions);
+    write(entry: LogEntry): void;
+    writeBatch(entries: LogEntry[]): void;
+    close(): void;
+}
+//# sourceMappingURL=ws-log-sink.d.ts.map

package/dist/core/src/logging/sinks/ws-log-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-log-sink.d.ts","sourceRoot":"","sources":["../../../../../core/src/logging/sinks/ws-log-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CACtC;AAED;;;;;GAKG;AACH,qBAAa,SAAU,YAAW,OAAO;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAiC;gBAE1C,IAAI,EAAE,gBAAgB;IAIlC,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAQ5B,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI;IAIrC,KAAK,IAAI,IAAI;CAGd"}

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

@@ -0,0 +1,228 @@
+/**
+ * Manifest parsing — reads SKILL.md, AGENT.md, agent.yaml, CONTRACT.md,
+ * CONNECTOR.md, MOUNT.md, *.prompt.md, *.flow.yaml, *.bundle.yaml files and
+ * produces CatalogEntry objects.
+ * Used by @skaile/asset-manager for on-demand repo scanning.
+ */
+import type { CatalogEntry, Dependency } from "./models.js";
+/**
+ * Result of parsing YAML frontmatter from a markdown file.
+ * @docLink packages/core/concepts#frontmatter-result
+ */
+export interface FrontmatterResult {
+    /** Parsed YAML data. Empty object if no frontmatter block is present. */
+    data: Record<string, unknown>;
+    /** Markdown body below the frontmatter block (trimmed). */
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from a markdown file (`---` delimited).
+ * Returns `{ data: {}, body: text }` when no frontmatter block is present.
+ *
+ * @param text - Raw file contents
+ * @returns Parsed frontmatter data and the remaining body text
+ * @docLink packages/core/concepts#parse-frontmatter
+ */
+export declare function parseFrontmatter(text: string): FrontmatterResult;
+/**
+ * Parse the `requires:` field from manifest frontmatter into typed `Dependency` objects.
+ * Accepts a comma-separated string or an array of `"kind:name"` strings. Reads from either
+ * the root or `metadata.requires` (matching `extractVersion`'s dual-location behavior) so
+ * skill authors can follow the agentskills.io convention of placing skaile extensions under
+ * `metadata:` while remaining backward-compatible with root-level declarations.
+ *
+ * @param meta - Parsed frontmatter data object
+ * @returns Array of `Dependency` objects (empty when `requires` is absent)
+ * @docLink packages/core/concepts#parse-requires
+ */
+export declare function parseRequires(meta: Record<string, unknown>): Dependency[];
+/**
+ * Parse a `SKILL.md` file into a `CatalogEntry`.
+ * The `kind` field defaults to `"skill"` but can be overridden to `"agent"` or `"prompt"`
+ * via the `type:` frontmatter key. Falls back to the parent directory name when `name:` is absent.
+ *
+ * @param filePath - Absolute path to the `SKILL.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind, name, description, version, and requires
+ * @docLink packages/core/concepts#from-skill-md
+ */
+export declare function fromSkillMd(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse an `AGENT.md` file into a `CatalogEntry` with `kind: "agent"`.
+ * Falls back to the parent directory name when `name:` is absent.
+ *
+ * @param filePath - Absolute path to the `AGENT.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"agent"`
+ * @docLink packages/core/concepts#from-agent-md
+ */
+export declare function fromAgentMd(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse an `agent.yaml` file into a `CatalogEntry` with `kind: "agent"`.
+ * Collects sub-agent dependencies from `requires[]` (new format) and `dependencies[]`
+ * (legacy format), skill abilities from `abilities[]`, and contracts from `contracts[]`.
+ *
+ * @param filePath - Absolute path to the `agent.yaml` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"agent"` and full dependency graph
+ * @docLink packages/core/concepts#from-agent-yaml
+ */
+export declare function fromAgentYaml(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `*.prompt.md` file into a `CatalogEntry` with `kind: "prompt"`.
+ * The name defaults to the filename stem (without the `.prompt.md` suffix)
+ * when no `name:` frontmatter key is present.
+ *
+ * @param filePath - Absolute path to the `.prompt.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"prompt"`
+ * @docLink packages/core/concepts#from-prompt-md
+ */
+export declare function fromPromptMd(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `*.flow.yaml` or `*.flow.json` file into a `CatalogEntry` with `kind: "flow"`.
+ * The name resolves from `name:` or `id:` frontmatter, falling back to the filename stem.
+ *
+ * @param filePath - Absolute path to the flow definition file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"flow"`
+ * @docLink packages/core/concepts#from-flow-yaml
+ */
+export declare function fromFlowYaml(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `*.bundle.yaml` file into a `CatalogEntry` with `kind: "bundle"`.
+ * Bundles declare a flat list of string `dependencies` (asset refs) rather than
+ * typed `Dependency` objects; both `requires` and `dependencies` are populated.
+ *
+ * @param filePath - Absolute path to the bundle YAML file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"bundle"`
+ * @docLink packages/core/concepts#from-bundle-yaml
+ */
+export declare function fromBundleYaml(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `CONTRACT.md` file into a `CatalogEntry` with `kind: "contract"`.
+ * Falls back to the parent directory name when `name:` is absent.
+ *
+ * @param filePath - Absolute path to the `CONTRACT.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"contract"`
+ * @docLink packages/core/concepts#from-contract-md
+ */
+export declare function fromContractMd(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse an `MCP.md` file into a `CatalogEntry` with `kind: "mcp-server"`.
+ * Falls back to the parent directory name when `name:` is absent.
+ *
+ * Frontmatter fields (catalog identity):
+ *   - `name`        — server name (default: parent dir name)
+ *   - `description` — short description
+ *   - `version`     — semver
+ *   - `keywords`    — array of discovery tags
+ *
+ * Frontmatter fields (runtime defaults, stored in `metadata`):
+ *   - `transport`   — "stdio" | "sse" | "http" (default: "stdio")
+ *   - `command`     — command to execute (stdio)
+ *   - `args`        — command arguments (stdio)
+ *   - `env`         — environment variables (stdio)
+ *   - `url`         — server URL (sse/http)
+ *   - `headers`     — HTTP headers (sse/http)
+ *
+ * When `mcp:name` appears in `skaile.yaml` `dependencies`, the runner reads
+ * these defaults from `metadata` to build a `McpServerDeclaration` without
+ * requiring verbose inline config.
+ *
+ * @param filePath - Absolute path to the `MCP.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"mcp-server"`
+ * @docLink packages/core/concepts#from-mcp-server-md
+ */
+export declare function fromMcpServerMd(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `knowledge.yaml` file into a `CatalogEntry` with `kind: "knowledge"`.
+ * Falls back to the parent directory name when `name:` is absent.
+ *
+ * @param filePath - Absolute path to the `knowledge.yaml` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"knowledge"`
+ * @docLink packages/core/concepts#from-knowledge-yaml
+ */
+export declare function fromKnowledgeYaml(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `CONNECTOR.md` file into a `CatalogEntry` with `kind: "connector"`.
+ * Falls back to the parent directory name when `name:` is absent.
+ *
+ * Frontmatter fields (catalog identity):
+ *   - `name`        — connector name (default: parent dir name)
+ *   - `description` — short description
+ *   - `version`     — semver
+ *
+ * Frontmatter fields (runtime defaults, stored in `metadata`):
+ *   - `entry`        — adapter entry point (default: "./adapter.ts")
+ *   - `npm_deps`     — npm dependencies required by the adapter
+ *   - `fields`       — configuration fields the adapter expects
+ *   - `health_check` — whether to run a health check on connect
+ *
+ * The markdown body (below the frontmatter) is stored in `metadata.body`
+ * so the runner can inject the connector's skill description into the
+ * system prompt when `expose_as_skill` is enabled.
+ *
+ * @param filePath - Absolute path to the `CONNECTOR.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"connector"`
+ * @docLink packages/core/concepts#from-connector-md
+ */
+export declare function fromConnectorMd(filePath: string, repoName: string): CatalogEntry;
+/**
+ * Parse a `MOUNT.md` file into a `CatalogEntry` with `kind: "mount"`.
+ * Falls back to the parent directory name when `name:` is absent.
+ *
+ * Frontmatter fields (catalog identity):
+ *   - `name`        — mount driver name (default: parent dir name)
+ *   - `description` — short description
+ *   - `version`     — semver
+ *
+ * Frontmatter fields (runtime defaults, stored in `metadata`):
+ *   - `entry`  — driver entry point (default: "./driver.ts")
+ *   - `fields` — configuration fields the driver expects
+ *
+ * The markdown body (below the frontmatter) is stored in `metadata.body`.
+ *
+ * @param filePath - Absolute path to the `MOUNT.md` file
+ * @param repoName - Repository name used as the `repository` field of the entry
+ * @returns Populated `CatalogEntry` with kind `"mount"`
+ * @docLink packages/core/concepts#from-mount-md
+ */
+export declare function fromMountMd(filePath: string, repoName: string): CatalogEntry;
+interface WalkEntry {
+    path: string;
+    name: string;
+}
+/**
+ * Recursively yield every file entry under `dir`, sorted alphabetically at each level.
+ * Skips `.git` and `node_modules` directories and follows symlinks (resolving to
+ * the stat target). `node_modules` is excluded because Bun's `node_modules/.bun/...`
+ * layout contains symlink farms that form cycles when packages reference each other
+ * transitively — entering them causes unbounded recursion in this walker.
+ *
+ * @param dir - Absolute path to the directory to walk
+ * @docLink packages/core/concepts#walk-dir
+ */
+export declare function walkDir(dir: string): Generator<WalkEntry>;
+/**
+ * Walk `root` recursively and return a `CatalogEntry` for every recognized asset manifest found.
+ *
+ * Recognized filenames: `SKILL.md`, `AGENT.md`, `agent.yaml`, `CONTRACT.md`, `MCP.md`,
+ * `CONNECTOR.md`, `MOUNT.md`, `*.prompt.md`, `*.bundle.yaml`, `*.flow.yaml`, `*.flow.json`.
+ *
+ * When two entries share the same `kind:name` key, the one with the alphabetically
+ * later source path wins (consistent with catalog precedence rules).
+ *
+ * @param root - Absolute path to the directory tree to scan
+ * @param repoName - Repository name attached to every produced entry
+ * @returns Array of deduplicated `CatalogEntry` objects, one per manifest file
+ * @docLink packages/core/concepts#scan-directory
+ */
+export declare function scanDirectory(root: string, repoName: string): CatalogEntry[];
+export {};
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../core/src/manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAa,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKvE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAUhE;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,EAAE,CAUzE;AAID;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAe5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAY5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CA0F9E;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAa7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAmB7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAqB/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAY/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CA8BhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAelF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAqBhF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAmB5E;AAID,UAAU,SAAS;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAiB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,CAoB1D;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE,CAkC5E"}

package/dist/core/src/models.d.ts

@@ -0,0 +1,304 @@
+/**
+ * Pure data models — no I/O, no side effects.
+ */
+/**
+ * Discriminator for catalog entries and asset references.
+ * Used in asset ref strings (e.g. `'skill:my-skill'`, `'agent:my-agent'`).
+ * @docLink packages/core/concepts#asset-kind
+ */
+export type AssetKind = "skill" | "agent" | "prompt" | "bundle" | "flow" | "contract" | "mcp-server" | "persona" | "ruleset" | "knowledge" | "connector" | "mount";
+/**
+ * All valid AssetKind values as a readonly array.
+ * @docLink packages/core/concepts#asset-kinds
+ */
+export declare const ASSET_KINDS: readonly AssetKind[];
+/**
+ * Asset kinds that represent individually installable assets (excludes "bundle").
+ * Note: persona, ruleset, and knowledge are valid AssetKind values but are not
+ * individually installable — they are resolved at session creation time via the
+ * mixin-resolver, not through the install/deploy pipeline.
+ * @docLink packages/core/concepts#individual-kinds
+ */
+export declare const INDIVIDUAL_KINDS: ["skill", "agent", "prompt", "flow", "contract", "mcp-server"];
+/**
+ * Declared dependency on another catalog asset.
+ * @docLink packages/core/concepts#dependency
+ */
+export interface Dependency {
+    /** Asset kind (e.g. "skill", "agent", "contract"). */
+    kind: string;
+    /** Asset name within that kind. */
+    name: string;
+}
+/**
+ * Parse a `"kind:name"` dependency string, or a bare `"name"` (defaults kind to `"skill"`).
+ *
+ * @param s - Dependency string, e.g. `"skill:use-exa"` or `"use-exa"`
+ * @returns Parsed `{ kind, name }` dependency object
+ * @docLink packages/core/concepts#parse-dep
+ */
+export declare function parseDep(s: string): Dependency;
+/**
+ * Serialize a Dependency back to its `"kind:name"` string form.
+ *
+ * @param d - Dependency to serialize
+ * @returns String in `"kind:name"` format
+ * @docLink packages/core/concepts#dep-to-str
+ */
+export declare function depToStr(d: Dependency): string;
+/**
+ * A resolved catalog entry describing an installable asset.
+ * Produced by manifest parsers and stored in the catalog YAML.
+ * @docLink packages/core/concepts#catalog-entry
+ */
+export interface CatalogEntry {
+    /** Unique asset name within its kind. */
+    name: string;
+    /** Asset kind discriminator. */
+    kind: AssetKind;
+    /** Short description of what this asset does. */
+    description: string;
+    /** Absolute path to manifest file */
+    source: string;
+    /** Originating repository name */
+    repository?: string;
+    /** Domain this asset belongs to (top-level directory in the repo root). */
+    domain?: string;
+    /** Semantic version string (may be empty if not declared in the manifest). */
+    version: string;
+    /** Skills, agents, or other assets this entry depends on. */
+    requires: Dependency[];
+    /** Bundle dependencies — asset refs to install (bundles only). */
+    dependencies: string[];
+    /**
+     * Kind-specific metadata extracted from the manifest frontmatter.
+     * Used by MCP servers to carry default config (transport, command, args, env, url, headers)
+     * so that `mcp:name` dependency refs resolve to a runnable declaration without
+     * requiring verbose inline config in `skaile.yaml`.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Construct a CatalogEntry from a raw deserialized record (e.g. from catalog.yaml).
+ *
+ * @param d - Raw object with loosely typed fields
+ * @returns Normalized CatalogEntry
+ * @docLink packages/core/concepts#entry-from-raw
+ */
+export declare function entryFromRaw(d: Record<string, unknown>): CatalogEntry;
+/**
+ * Serialize a CatalogEntry to a plain record suitable for YAML/JSON persistence.
+ *
+ * @param e - CatalogEntry to serialize
+ * @returns Plain object with string-serialized requires and dependencies
+ * @docLink packages/core/concepts#entry-to-raw
+ */
+export declare function entryToRaw(e: CatalogEntry): Record<string, unknown>;
+/**
+ * A parsed asset reference: `kind:name[@repository][#pin]`.
+ * Produced by `parseAssetRef`; consumed by `resolveAsset` and `resolveAll`.
+ * @docLink packages/core/concepts#asset-ref
+ */
+export interface AssetRef {
+    kind: string;
+    name: string;
+    /** Optional repository qualifier (from skaile.yaml repositories section). */
+    repository?: string;
+    /** Optional pin: git tag, commit SHA, or branch name. */
+    pin?: string;
+}
+/**
+ * Parse an asset reference string into an `AssetRef` object.
+ *
+ * Formats:
+ *   "skill:overview"                    → { kind: "skill", name: "overview" }
+ *   "skill:overview@skaile-ai"          → { kind: "skill", name: "overview", repository: "skaile-ai" }
+ *   "skill:overview@skaile-ai#v2.1.0"   → { kind: "skill", name: "overview", repository: "skaile-ai", pin: "v2.1.0" }
+ *   "overview"                           → { kind: "skill", name: "overview" }
+ *
+ * The shorthand `mcp:` is normalized to `mcp-server:`.
+ *
+ * @param s - Asset reference string
+ * @returns Parsed `AssetRef`
+ * @docLink packages/core/concepts#parse-asset-ref
+ */
+export declare function parseAssetRef(s: string): AssetRef;
+/**
+ * Serialize an AssetRef back to its canonical string form.
+ *
+ * @param ref - AssetRef to serialize
+ * @returns String in `"kind:name[@repository][#pin]"` format
+ * @docLink packages/core/concepts#asset-ref-to-str
+ */
+export declare function assetRefToStr(ref: AssetRef): string;
+/**
+ * Convert an AssetRef to a simple Dependency, dropping the repository and pin qualifiers.
+ *
+ * @param ref - Full asset reference (may include repository and pin)
+ * @returns Dependency with only kind and name
+ * @docLink packages/core/concepts#asset-ref-to-dep
+ */
+export declare function assetRefToDep(ref: AssetRef): Dependency;
+/**
+ * Repository entry recorded in the lock file.
+ * Captures the source URL or path, branch, and resolved HEAD commit.
+ * @docLink packages/core/api-reference#lock-repository
+ */
+export interface LockRepository {
+    /** Remote git URL (for cloned repos). */
+    url?: string;
+    /** Local filesystem path (for path repos). */
+    path?: string;
+    /** Branch that was locked. */
+    branch: string;
+    /** HEAD commit SHA at lock time. */
+    commit?: string;
+}
+/**
+ * Per-asset entry in the lock file.
+ * Records the resolved version, repo source, content integrity hash, and resolution provenance.
+ * @docLink packages/core/api-reference#lock-entry
+ */
+export interface LockEntry {
+    /** Semver version at lock time. */
+    version: string;
+    /** Name of the repository this asset was resolved from. */
+    repository: string;
+    /** Path to manifest relative to repo root. */
+    source: string;
+    /** Domain this asset belongs to (top-level directory in the repo root). */
+    domain?: string;
+    /** SHA-256 hash of manifest content. */
+    integrity: string;
+    /** What caused this asset to be included: "direct" or "kind:name" of parent. */
+    resolved_by: string;
+}
+/**
+ * Full skaile.lock.yaml structure.
+ * Captures the complete resolved state of all asset dependencies at install time.
+ * @docLink packages/core/api-reference#lock-file
+ */
+export interface LockFile {
+    /** Lock file schema version. */
+    lockfile_version: number;
+    /** ISO timestamp of when the lock was generated. */
+    locked_at: string;
+    /** Repositories declared in skaile.yaml, with their locked commits. */
+    repositories: Record<string, LockRepository>;
+    /** All resolved assets keyed by "kind:name". */
+    assets: Record<string, LockEntry>;
+}
+/**
+ * Agent package manifest — parsed from `agent.yaml` in an agent directory.
+ * Defines the agent's identity, model preferences, capability requirements, and composition mixins.
+ * @docLink packages/core/concepts#agent-manifest
+ */
+export interface AgentManifest {
+    spec_version?: string;
+    name?: string;
+    version?: string;
+    description?: string;
+    model?: {
+        preferred?: string;
+        fallback?: string[];
+        constraints?: {
+            temperature?: number;
+            max_tokens?: number;
+        };
+    };
+    tools?: {
+        allowed?: string[];
+        denied?: string[];
+    };
+    delegation?: {
+        mode?: string;
+    };
+    requires?: Array<{
+        name: string;
+        source: string;
+        version?: string;
+        mount: string;
+    }>;
+    tags?: string[];
+    author?: string;
+    metadata?: Record<string, unknown>;
+    /**
+     * @deprecated Use `persona`, `rules`, and `knowledge` mixin arrays instead.
+     * This field is declared but was never resolved at runtime.
+     */
+    extends?: string;
+    abilities?: string[];
+    /**
+     * Identity fragments to compose into the agent persona.
+     * Each entry is a catalog ref (`persona:name@repo#pin`), a bare name
+     * (defaults to kind "persona"), or a local path (`./my.persona.md`).
+     * Resolved in order — concatenated with \n\n---\n\n separator.
+     */
+    persona?: string[];
+    /**
+     * Behavioral rule sets to compose into the agent's constraints.
+     * Each entry is a catalog ref (`ruleset:name@repo#pin`), bare name,
+     * or local path. All rules apply (union).
+     */
+    rules?: string[];
+    /**
+     * Knowledge bundles to compose into the agent's domain knowledge.
+     * Each entry is a catalog ref (`knowledge:name@repo#pin`), bare name,
+     * or local path to a knowledge directory. Loaded in declaration order.
+     */
+    knowledge?: string[];
+    contracts?: string[];
+    /**
+     * v2 composition items. Each entry references an asset (skill, connector,
+     * soul, ruleset, etc.) with binding semantics (discoverable, inline-live,
+     * inline-snapshot). Resolved at session start via the composition module.
+     */
+    composes?: Array<{
+        kind: string;
+        ref: string;
+        instance?: string;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot";
+    }>;
+    runtime?: {
+        max_turns?: number;
+        timeout?: number;
+        [key: string]: unknown;
+    };
+}
+type RepositoryKind = "local" | "github";
+/**
+ * A registered asset repository (local path or cloned GitHub repo).
+ * Stored in the catalog; consumed by `repo-manager` for cloning and scanning.
+ * @docLink packages/core/concepts#repository
+ */
+export interface Repository {
+    /** Logical repository name. */
+    name: string;
+    /** Storage kind: "local" for paths, "github" for remote URLs. */
+    kind: RepositoryKind;
+    /** Absolute path (local) or remote URL (github). */
+    path: string;
+    /** Active branch. */
+    branch: string;
+    /** Upstream fork URL (for fork-based workflows). */
+    upstream?: string;
+}
+/**
+ * Construct a `Repository` from a raw deserialized record.
+ *
+ * @param d - Raw object from YAML/JSON
+ * @returns Normalized `Repository`
+ * @docLink packages/core/concepts#repository-from-raw
+ */
+export declare function repositoryFromRaw(d: Record<string, unknown>): Repository;
+/**
+ * Serialize a `Repository` to a plain record for YAML/JSON persistence.
+ * Omits the `branch` field when it equals `"main"` to keep serialized output clean.
+ *
+ * @param r - Repository to serialize
+ * @returns Plain object suitable for YAML/JSON
+ * @docLink packages/core/concepts#repository-to-raw
+ */
+export declare function repositoryToRaw(r: Repository): Record<string, unknown>;
+export {};
+//# sourceMappingURL=models.d.ts.map