@skaile/workspaces 6.15.0 → 6.16.1

package/dist/chunk-4ZNKEDYH.js

@@ -0,0 +1,887 @@
+import { knowledgeKindProvider, scanLibraryRoot, LocalIndex } from './chunk-RPRMD7XV.js';
+import { createDefaultKindRegistry } from './chunk-QUPZKTF3.js';
+import { readLock, assembleAgent } from './chunk-U7P22GEB.js';
+import { matchPin, getGlobalCacheDir, sourceCacheKey, sameRepo, resolveSkWorkspaceConfig } from './chunk-BRAOB37W.js';
+import { harnessNameForHarnessId, HARNESS_TARGETS } from './chunk-VTETQCR6.js';
+import { BindingSchema } from './chunk-LCXQ4LVP.js';
+import fs3 from 'fs/promises';
+import path2, { join, dirname } from 'path';
+import { parse } from 'yaml';
+import { spawnSync } from 'child_process';
+import { createHash } from 'crypto';
+import { readdirSync, statSync, existsSync, mkdirSync, writeFileSync, readFileSync, realpathSync } from 'fs';
+import * as z from 'zod';
+
+// runner/src/composition/errors.ts
+var CompositionError = class extends Error {
+  constructor(code, reason, message, ref, moved) {
+    super(message);
+    this.code = code;
+    this.reason = reason;
+    this.ref = ref;
+    this.moved = moved;
+    this.name = "CompositionError";
+  }
+  code;
+  reason;
+  ref;
+  moved;
+};
+function isCompositionError(err, code) {
+  return err instanceof CompositionError && (code === void 0 || err.code === code);
+}
+async function resolveMixin(ref, defaultKind, agentDir, repos) {
+  if (ref.startsWith(".") || ref.startsWith("/")) {
+    const absPath = ref.startsWith("/") ? ref : path2.join(agentDir, ref);
+    if (defaultKind === "knowledge") {
+      return loadKnowledgeDir(absPath);
+    }
+    const content = await readFileSafe(absPath);
+    if (!content) return null;
+    return { content: stripFrontmatter(content).trim(), source: absPath };
+  }
+  const { kind, name, repoQualifier } = parseRef(ref, defaultKind);
+  const entry = findInRepos(repos, kind, name, repoQualifier);
+  if (!entry) return null;
+  if (entry.kind === "knowledge") {
+    return loadKnowledgeDir(path2.dirname(entry.source));
+  }
+  const raw = await readFileSafe(entry.source);
+  if (!raw) return null;
+  return { content: stripFrontmatter(raw).trim(), source: entry.source };
+}
+async function readFileSafe(filePath) {
+  try {
+    return await fs3.readFile(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function stripFrontmatter(text) {
+  return text.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "");
+}
+function parseRef(ref, defaultKind) {
+  let rest = ref.trim();
+  let kind = defaultKind;
+  const colonIdx = rest.indexOf(":");
+  if (colonIdx !== -1) {
+    kind = rest.slice(0, colonIdx).trim();
+    rest = rest.slice(colonIdx + 1).trim();
+  }
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) rest = rest.slice(0, hashIdx).trim();
+  let repoQualifier;
+  const atIdx = rest.indexOf("@");
+  if (atIdx !== -1) {
+    repoQualifier = rest.slice(atIdx + 1).trim() || void 0;
+    rest = rest.slice(0, atIdx).trim();
+  }
+  return { kind, name: rest, repoQualifier };
+}
+function findInRepos(repos, kind, name, repoQualifier) {
+  const searchRepos = repoQualifier ? repos[repoQualifier] ? [repos[repoQualifier]] : [] : Object.values(repos);
+  for (const entries of searchRepos) {
+    const found = entries.find((e) => e.kind === kind && e.name === name);
+    if (found) return found;
+  }
+  return void 0;
+}
+function isEmptyKnowledgeIndex(text) {
+  if (!text) return false;
+  let parsed;
+  try {
+    parsed = parse(text);
+  } catch {
+    return false;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+  const documents = parsed.documents;
+  return Array.isArray(documents) && documents.length === 0;
+}
+async function loadKnowledgeDir(dir) {
+  let entries;
+  try {
+    entries = (await fs3.readdir(dir)).filter((e) => e.endsWith(".md"));
+  } catch {
+    return null;
+  }
+  const priorityMap = {};
+  const indexContent = await readFileSafe(path2.join(dir, "index.yaml"));
+  if (indexContent) {
+    const pathMatches = [...indexContent.matchAll(/path:\s*(\S+)/g)];
+    const priorityMatches = [...indexContent.matchAll(/priority:\s*(\d+)/g)];
+    pathMatches.forEach((m, i) => {
+      const filename = m[1];
+      if (!filename) return;
+      const priority = priorityMatches[i] ? parseInt(priorityMatches[i][1] ?? "99", 10) : 99;
+      priorityMap[filename] = priority;
+    });
+  }
+  const docs = await Promise.all(
+    entries.map(async (filename) => ({
+      filename,
+      priority: priorityMap[filename] ?? 99,
+      content: (await readFileSafe(path2.join(dir, filename))).trim()
+    }))
+  );
+  const sorted = docs.filter((d) => d.content).sort((a, b) => a.priority - b.priority || a.filename.localeCompare(b.filename));
+  if (sorted.length === 0) {
+    return isEmptyKnowledgeIndex(indexContent) ? { content: indexContent, source: dir } : null;
+  }
+  return {
+    content: sorted.map((d) => d.content).join("\n\n---\n\n"),
+    source: dir
+  };
+}
+function parseCatalogRef(ref) {
+  let rest = ref.trim();
+  const kindPrefix = /^([a-z][a-z0-9-]*):(?!\/\/)/.exec(rest);
+  if (kindPrefix) rest = rest.slice(kindPrefix[0].length);
+  let pin;
+  const hash = rest.indexOf("#");
+  if (hash !== -1) {
+    pin = rest.slice(hash + 1).trim() || void 0;
+    rest = rest.slice(0, hash);
+  }
+  const scoped = /^@([^/@]+)\/([^@]+)(?:@(.+))?$/.exec(rest);
+  if (scoped) {
+    return { publisher: scoped[1], name: scoped[2], pin: pin ?? scoped[3]?.trim() };
+  }
+  const at = rest.indexOf("@");
+  if (at !== -1) {
+    return { publisher: rest.slice(at + 1) || void 0, name: rest.slice(0, at), pin };
+  }
+  return { name: rest, pin };
+}
+var LOCK_KEY_RE = /^([a-z][a-z0-9-]*):@([^/]+)\/([^#]+)#(.+)$/;
+var barePublisher = (p) => p.startsWith("@") ? p.slice(1) : p;
+var sha256Of = (text) => createHash("sha256").update(text).digest("hex");
+var CatalogScanner = class {
+  constructor(projectDir, registry, explicitRoots) {
+    this.projectDir = projectDir;
+    this.registry = registry;
+    this.roots = explicitRoots;
+  }
+  projectDir;
+  registry;
+  scans = /* @__PURE__ */ new Map();
+  roots;
+  /** Every discovered asset of `kind` named `name` under one root (any root, declared or not). */
+  findIn(root, kind, name) {
+    return this.scan(root).filter((hit) => hit.asset.kind === kind && hit.asset.name === name);
+  }
+  /** Every discovered asset of `kind` named `name`, across all roots. */
+  find(kind, name) {
+    const out = [];
+    for (const root of this.resolveRoots()) {
+      for (const hit of this.scan(root)) {
+        if (hit.asset.kind === kind && hit.asset.name === name) out.push(hit);
+      }
+    }
+    return out;
+  }
+  scan(root) {
+    let cached = this.scans.get(root);
+    if (!cached) {
+      try {
+        cached = scanLibraryRoot(root, this.registry).assets.map((asset) => ({ asset, root }));
+      } catch {
+        cached = [];
+      }
+      this.scans.set(root, cached);
+    }
+    return cached;
+  }
+  resolveRoots() {
+    if (!this.roots) this.roots = defaultCatalogRoots(this.projectDir);
+    return this.roots;
+  }
+};
+function defaultCatalogRoots(projectDir) {
+  const roots = /* @__PURE__ */ new Set();
+  const add = (dir2) => {
+    if (!dir2 || !existsSync(dir2)) return;
+    try {
+      if (statSync(dir2).isDirectory()) roots.add(realpathSync(dir2));
+    } catch {
+    }
+  };
+  let dir = path2.resolve(projectDir);
+  for (let i = 0; i < 8; i++) {
+    const candidate = path2.join(dir, "ai-assets");
+    if (existsSync(candidate)) {
+      add(candidate);
+      break;
+    }
+    const parent = path2.resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  try {
+    for (const source of resolveSkWorkspaceConfig(projectDir).sources ?? []) {
+      add(path2.join(getGlobalCacheDir(), sourceCacheKey(source.url)));
+    }
+  } catch {
+  }
+  const projectSources = path2.join(projectDir, ".skaile", "cache", "sources");
+  try {
+    for (const entry of readdirSync(projectSources)) add(path2.join(projectSources, entry));
+  } catch {
+  }
+  return [...roots];
+}
+async function registeredLibraryRoots(origin) {
+  let index;
+  try {
+    index = new LocalIndex();
+    const libraries = await index.listSources();
+    const byName = libraries.filter((l) => l.name === origin.name);
+    const byUrl = byName.length === 0 && origin.url ? libraries.filter((l) => {
+      const url = l.backendConfig.url;
+      return typeof url === "string" && sameRepo(url, origin.url ?? "");
+    }) : [];
+    return [...byName, ...byUrl].map((l) => l.path).filter((dir) => existsSync(dir));
+  } catch {
+    return [];
+  } finally {
+    index?.close();
+  }
+}
+function createCompositionContentSource(opts) {
+  const registry = opts.registry ?? createDefaultKindRegistry([knowledgeKindProvider]);
+  const scanner = new CatalogScanner(opts.projectDir, registry, opts.catalogRoots);
+  return new DefaultCompositionContentSource(
+    path2.resolve(opts.agentDir),
+    path2.resolve(opts.projectDir),
+    registry,
+    scanner,
+    opts.lockAssets
+  );
+}
+var DefaultCompositionContentSource = class _DefaultCompositionContentSource {
+  constructor(agentDir, projectDir, registry, scanner, givenLock) {
+    this.agentDir = agentDir;
+    this.projectDir = projectDir;
+    this.registry = registry;
+    this.scanner = scanner;
+    this.givenLock = givenLock;
+    this.lockLoaded = givenLock !== void 0;
+    this.lockAssets = givenLock ?? {};
+  }
+  agentDir;
+  projectDir;
+  registry;
+  scanner;
+  givenLock;
+  lockLoaded;
+  lockAssets;
+  scoped(agentDir) {
+    return new _DefaultCompositionContentSource(
+      path2.resolve(agentDir),
+      this.projectDir,
+      this.registry,
+      this.scanner,
+      this.givenLock
+    );
+  }
+  async load(ref, kind) {
+    if (ref.startsWith(".") || ref.startsWith("/")) return this.loadLocal(ref, kind);
+    const parsed = parseCatalogRef(ref);
+    if (!parsed.name) {
+      throw new CompositionError(
+        "composition_asset_missing",
+        "missing",
+        `"${ref}" (${kind}): not a resolvable ref`,
+        ref
+      );
+    }
+    const locked = this.lockCandidate(ref, kind, parsed);
+    if (locked) return this.loadLocked(ref, kind, locked);
+    return this.loadFromCatalog(ref, kind, parsed);
+  }
+  // ── local ────────────────────────────────────────────────────────────────
+  async loadLocal(ref, kind) {
+    const absPath = ref.startsWith("/") ? ref : path2.join(this.agentDir, ref);
+    let target = absPath;
+    let resolved = await resolveMixin(ref, kind, this.agentDir, {});
+    if (!resolved && kind !== "knowledge" && isDirectory(absPath)) {
+      const manifest = this.manifestInDir(kind, absPath);
+      if (manifest) {
+        target = manifest;
+        resolved = await resolveMixin(manifest, kind, this.agentDir, {});
+      }
+    }
+    if (!resolved) {
+      throw new CompositionError(
+        "composition_asset_missing",
+        "missing",
+        `"${ref}" (${kind}): no content at ${absPath}`,
+        ref
+      );
+    }
+    return {
+      canonicalRef: `local:${this.relativeToProject(target)}`,
+      kind,
+      version: null,
+      sha256: sha256Of(resolved.content),
+      content: resolved.content,
+      location: resolved.source
+    };
+  }
+  manifestInDir(kind, dir) {
+    const provider = this.registry.getProvider(kind);
+    for (const name of readdirSync(dir).sort()) {
+      const matches = provider ? provider.matchesPath(name) : name === `${kind.toUpperCase()}.md`;
+      if (matches && statSync(path2.join(dir, name)).isFile()) return path2.join(dir, name);
+    }
+    return void 0;
+  }
+  relativeToProject(abs) {
+    const rel = path2.relative(this.projectDir, abs).split(path2.sep).join("/");
+    return rel.startsWith("..") ? abs : rel;
+  }
+  // ── lock pin ─────────────────────────────────────────────────────────────
+  lockCandidate(ref, kind, parsed) {
+    if (!this.lockLoaded) {
+      this.lockLoaded = true;
+      try {
+        this.lockAssets = readLock(path2.join(this.projectDir, "skaile.lock.yaml"))?.assets ?? {};
+      } catch (err) {
+        throw new CompositionError(
+          "composition_conflict",
+          "stale_manifest",
+          `skaile.lock.yaml is unreadable: ${err instanceof Error ? err.message : String(err)}`,
+          ref
+        );
+      }
+    }
+    const matches = [];
+    for (const [key, entry] of Object.entries(this.lockAssets)) {
+      const m = LOCK_KEY_RE.exec(key);
+      if (!m || m[1] !== kind || m[3] !== parsed.name) continue;
+      if (parsed.publisher && barePublisher(parsed.publisher) !== m[2]) continue;
+      if (parsed.pin && !matchPin(parsed.pin, m[4])) continue;
+      matches.push({ key, publisher: m[2], name: m[3], version: m[4], entry });
+    }
+    if (matches.length > 1) {
+      throw new CompositionError(
+        "composition_conflict",
+        "ambiguous",
+        `"${ref}" (${kind}): skaile.lock.yaml pins ${matches.length} matching assets (${matches.map((x) => x.key).join(", ")}) \u2014 qualify the ref with a publisher and version`,
+        ref
+      );
+    }
+    return matches[0] ?? null;
+  }
+  async loadLocked(ref, kind, pin) {
+    const { entry } = pin;
+    const storeDir = path2.join(
+      this.projectDir,
+      ".skaile",
+      "cache",
+      "store",
+      pin.publisher,
+      kind,
+      pin.name,
+      pin.version
+    );
+    const prefix = commonDirPrefix(entry.files.map((f) => f.path));
+    const strip = (p) => prefix && p.startsWith(`${prefix}/`) ? p.slice(prefix.length + 1) : p;
+    if (isDirectory(storeDir) && entry.files.length > 0) {
+      await this.verifyFiles(ref, pin.key, entry, (p) => path2.join(storeDir, strip(p)));
+      const primary = this.primaryOf(
+        kind,
+        entry.files.map((f) => f.path)
+      );
+      return this.readAsset(
+        kind,
+        pin.key,
+        pin.version,
+        path2.join(storeDir, strip(primary)),
+        storeDir
+      );
+    }
+    const holdsPin = (h) => h.asset.version === pin.version && barePublisher(h.asset.publisher) === pin.publisher;
+    let hit = this.scanner.find(kind, pin.name).find(holdsPin);
+    if (!hit && entry.library) {
+      for (const root of await registeredLibraryRoots(entry.library)) {
+        hit = this.scanner.findIn(root, kind, pin.name).find(holdsPin);
+        if (hit) break;
+      }
+    }
+    if (!hit) {
+      const atCommit = await this.loadAtLockedCommit(ref, kind, pin, strip);
+      if (atCommit) return atCommit;
+      let moved;
+      if (entry.library) {
+        for (const root of await registeredLibraryRoots(entry.library)) {
+          const other = this.scanner.findIn(root, kind, pin.name).find((h) => barePublisher(h.asset.publisher) === pin.publisher);
+          if (other?.asset.version) {
+            moved = {
+              key: pin.key,
+              library: entry.library.name,
+              libraryVersion: other.asset.version,
+              lockedVersion: pin.version
+            };
+            break;
+          }
+        }
+      }
+      throw new CompositionError(
+        "composition_asset_missing",
+        "missing",
+        moved ? `"${ref}" (${kind}): skaile.lock.yaml pins ${pin.key} but library "${moved.library}" is at ${moved.libraryVersion} \u2014 run \`skaile update\` to move the lock to it` : `"${ref}" (${kind}): skaile.lock.yaml pins ${pin.key} but no bytes for it are on disk \u2014 run \`skaile install\``,
+        ref,
+        moved
+      );
+    }
+    const assetRoot = hit.asset.fileFilter.assetRoot;
+    if (entry.files.length > 0) {
+      try {
+        await this.verifyFiles(ref, pin.key, entry, (p) => path2.join(assetRoot, strip(p)));
+      } catch (err) {
+        const atCommit = await this.loadAtLockedCommit(ref, kind, pin, strip);
+        if (atCommit) return atCommit;
+        throw err;
+      }
+    } else if (entry.library?.sha256 && entry.library.sha256 !== hit.asset.sha256) {
+      throw new CompositionError(
+        "composition_conflict",
+        "hash_mismatch",
+        `"${ref}" (${kind}): ${pin.key} was locked from a library at ${entry.library.sha256.slice(0, 12)}\u2026 but the catalog now holds ${hit.asset.sha256.slice(0, 12)}\u2026`,
+        ref
+      );
+    }
+    return this.readAsset(kind, pin.key, pin.version, hit.asset.manifestPath, assetRoot);
+  }
+  /**
+   * A source-origin entry's bytes at ITS locked commit, read from the git objects of a source
+   * clone that holds the commit (the clone's checkout never moves) and staged under the
+   * project cache. `null` when the entry is not a source entry or no clone holds the commit; the
+   * staged bytes are verified against the lock like any other.
+   */
+  async loadAtLockedCommit(ref, kind, pin, strip) {
+    const { entry } = pin;
+    const source = entry.source;
+    if (!source || entry.library || entry.origin === "store" || entry.files.length === 0) {
+      return null;
+    }
+    if (!/^[0-9a-f]{40}$/.test(source.commit) || /^0+$/.test(source.commit)) return null;
+    const clones = [path2.join(getGlobalCacheDir(), sourceCacheKey(source.url))];
+    const projectSources = path2.join(this.projectDir, ".skaile", "cache", "sources");
+    try {
+      for (const e of readdirSync(projectSources)) clones.push(path2.join(projectSources, e));
+    } catch {
+    }
+    const git = (dir, args) => spawnSync("git", ["-C", dir, ...args], {
+      stdio: "pipe",
+      maxBuffer: 256 * 1024 * 1024,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+    const clone = clones.find(
+      (dir) => existsSync(dir) && git(dir, ["cat-file", "-e", `${source.commit}^{commit}`]).status === 0
+    );
+    if (!clone) return null;
+    const stageDir = path2.join(
+      this.projectDir,
+      ".skaile",
+      "cache",
+      "source-commits",
+      source.commit,
+      pin.publisher,
+      kind,
+      pin.name,
+      pin.version
+    );
+    for (const file of entry.files) {
+      const shown = git(clone, ["show", `${source.commit}:${file.path}`]);
+      if (shown.status !== 0) return null;
+      const dest = path2.join(stageDir, strip(file.path));
+      mkdirSync(path2.dirname(dest), { recursive: true });
+      writeFileSync(dest, shown.stdout);
+    }
+    await this.verifyFiles(ref, pin.key, entry, (p) => path2.join(stageDir, strip(p)));
+    const primary = this.primaryOf(
+      kind,
+      entry.files.map((f) => f.path)
+    );
+    return this.readAsset(
+      kind,
+      pin.key,
+      pin.version,
+      path2.join(stageDir, strip(primary)),
+      stageDir
+    );
+  }
+  async verifyFiles(ref, key, entry, locate) {
+    for (const file of entry.files) {
+      const abs = locate(file.path);
+      let bytes;
+      try {
+        bytes = await fs3.readFile(abs);
+      } catch {
+        throw new CompositionError(
+          "composition_asset_missing",
+          "missing",
+          `"${ref}": ${key} lists ${file.path} but ${abs} is missing \u2014 run \`skaile install\``,
+          ref
+        );
+      }
+      const actual = sha256Of(bytes);
+      if (actual !== file.sha256) {
+        throw new CompositionError(
+          "composition_conflict",
+          "hash_mismatch",
+          `"${ref}": ${file.path} of ${key} is ${actual.slice(0, 12)}\u2026 on disk but skaile.lock.yaml pins ${file.sha256.slice(0, 12)}\u2026 \u2014 run \`skaile install\` to restore it`,
+          ref
+        );
+      }
+    }
+  }
+  primaryOf(kind, paths) {
+    const provider = this.registry.getProvider(kind);
+    const hit = provider ? paths.find((p) => provider.matchesPath(p)) : void 0;
+    return hit ?? paths[0] ?? "";
+  }
+  // ── catalog ──────────────────────────────────────────────────────────────
+  async loadFromCatalog(ref, kind, parsed) {
+    const wantPublisher = parsed.publisher ? barePublisher(parsed.publisher) : void 0;
+    const candidates = this.scanner.find(kind, parsed.name).filter((h) => !wantPublisher || barePublisher(h.asset.publisher) === wantPublisher).filter((h) => matchPin(parsed.pin, h.asset.version));
+    const distinct = /* @__PURE__ */ new Map();
+    for (const c of candidates) {
+      distinct.set(`${c.asset.publisher}/${c.asset.name}#${c.asset.version}:${c.asset.sha256}`, c);
+    }
+    if (distinct.size === 0) {
+      throw new CompositionError(
+        "composition_asset_missing",
+        "missing",
+        `"${ref}" (${kind}): not in skaile.lock.yaml and not found in the local catalog`,
+        ref
+      );
+    }
+    if (distinct.size > 1) {
+      throw new CompositionError(
+        "composition_conflict",
+        "ambiguous",
+        `"${ref}" (${kind}): ${distinct.size} catalog assets match (${[...distinct.values()].map((c) => `@${barePublisher(c.asset.publisher)}/${c.asset.name}#${c.asset.version}`).join(", ")}) \u2014 qualify the ref with a publisher and version`,
+        ref
+      );
+    }
+    const { asset } = [...distinct.values()][0];
+    const canonical = `${kind}:@${barePublisher(asset.publisher)}/${asset.name}#${asset.version}`;
+    return this.readAsset(
+      kind,
+      canonical,
+      asset.version,
+      asset.manifestPath,
+      asset.fileFilter.assetRoot
+    );
+  }
+  // ── shared read ──────────────────────────────────────────────────────────
+  async readAsset(kind, canonicalRef, version, primaryPath, assetRoot) {
+    let content;
+    let location = primaryPath;
+    if (kind === "knowledge") {
+      const dir = path2.basename(primaryPath) === "knowledge.yaml" ? path2.dirname(primaryPath) : assetRoot;
+      const loaded = await loadKnowledgeDir(dir);
+      if (!loaded) {
+        throw new CompositionError(
+          "composition_asset_missing",
+          "missing",
+          `"${canonicalRef}": knowledge directory ${dir} holds no documents`,
+          canonicalRef
+        );
+      }
+      content = loaded.content;
+      location = dir;
+    } else {
+      let raw;
+      try {
+        raw = await fs3.readFile(primaryPath, "utf-8");
+      } catch {
+        throw new CompositionError(
+          "composition_asset_missing",
+          "missing",
+          `"${canonicalRef}": ${primaryPath} is not readable`,
+          canonicalRef
+        );
+      }
+      content = stripFrontmatter(raw).trim();
+    }
+    return { canonicalRef, kind, version, sha256: sha256Of(content), content, location };
+  }
+};
+function isDirectory(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function commonDirPrefix(paths) {
+  if (paths.length === 0) return "";
+  const split = paths.map((p) => p.split("/").slice(0, -1));
+  const first = split[0];
+  let n = first.length;
+  for (const parts of split) {
+    let i = 0;
+    while (i < n && i < parts.length && parts[i] === first[i]) i++;
+    n = i;
+  }
+  return first.slice(0, n).join("/");
+}
+function hashContent(content) {
+  return sha256Of(content);
+}
+
+// runner/src/composition/types.ts
+var KIND_BINDING_DEFAULTS = {
+  soul: "inline-snapshot",
+  persona: "inline-snapshot",
+  ruleset: "inline-live",
+  skill: "discoverable",
+  knowledge: "discoverable",
+  connector: "discoverable",
+  prompt: "inline-live",
+  flow: "discoverable",
+  "mcp-server": "discoverable",
+  contract: "inline-live",
+  agent: "delegate"
+};
+var UnknownCompositionKindError = class extends Error {
+  constructor(kind, ref) {
+    super(`composes item "${ref}" has unknown asset kind "${kind}" and no explicit binding`);
+    this.kind = kind;
+    this.ref = ref;
+    this.name = "UnknownCompositionKindError";
+  }
+  kind;
+  ref;
+  code = "unknown_asset_kind";
+};
+function resolveBinding(item) {
+  if (item.binding) return item.binding;
+  if (!Object.hasOwn(KIND_BINDING_DEFAULTS, item.kind)) {
+    throw new UnknownCompositionKindError(item.kind, item.ref);
+  }
+  return KIND_BINDING_DEFAULTS[item.kind];
+}
+var COMPILE_MANIFEST_FILENAME = "compile_manifest.json";
+var CompileManifestEntrySchema = z.object({
+  asset_ref: z.string().min(1),
+  kind: z.string().min(1),
+  resolved_ref: z.string().min(1),
+  version: z.string().nullable(),
+  hash: z.string().regex(/^[0-9a-f]{64}$/),
+  binding: BindingSchema,
+  resolved_at: z.string(),
+  content: z.string()
+});
+var CompileManifestSchema = z.object({
+  schema_version: z.literal(2),
+  prompt_version: z.number().int().nonnegative(),
+  compiled_at: z.string(),
+  entries: z.array(CompileManifestEntrySchema)
+});
+var StaleSchemaMarker = z.object({ schema_version: z.literal(1) });
+var NestedAgentComposes = z.object({ composes: z.array(z.unknown()) });
+var NestedAgentItem = z.object({ kind: z.literal("agent"), ref: z.string() });
+async function compileComposition(opts) {
+  const { agentDir, items, source } = opts;
+  const manifestPath = path2.join(agentDir, COMPILE_MANIFEST_FILENAME);
+  const nextVersion = await readPromptVersion(manifestPath) + 1;
+  const loaded = /* @__PURE__ */ new Map();
+  const entries = [];
+  const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const item of items) {
+    const binding = resolveBinding(item);
+    const cacheKey = `${item.kind}\0${item.ref}`;
+    let asset = loaded.get(cacheKey);
+    if (!asset) {
+      asset = await source.load(item.ref, item.kind);
+      loaded.set(cacheKey, asset);
+    }
+    entries.push({
+      asset_ref: item.ref,
+      kind: item.kind,
+      resolved_ref: asset.canonicalRef,
+      version: asset.version,
+      hash: asset.sha256,
+      binding,
+      resolved_at: resolvedAt,
+      content: asset.content
+    });
+  }
+  await assertAcyclicSubagents(agentDir, items, source);
+  const manifest = {
+    schema_version: 2,
+    prompt_version: nextVersion,
+    entries,
+    compiled_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmpPath = `${manifestPath}.tmp`;
+  await fs3.writeFile(tmpPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+  await fs3.rename(tmpPath, manifestPath);
+  return { manifest, manifestPath, resolvedCount: entries.length };
+}
+async function isCompilePinCurrent(opts) {
+  let pinned;
+  try {
+    pinned = await loadCompileManifestFromDir(opts.agentDir);
+  } catch {
+    return false;
+  }
+  if (!pinned || pinned.entries.length !== opts.items.length) return false;
+  for (const [i, item] of opts.items.entries()) {
+    const entry = pinned.entries[i];
+    if (entry.asset_ref !== item.ref || entry.kind !== item.kind) return false;
+    if (entry.binding !== resolveBinding(item)) return false;
+    const asset = await opts.source.load(item.ref, item.kind);
+    if (asset.sha256 !== entry.hash) return false;
+  }
+  return true;
+}
+async function loadCompileManifest(manifestPath) {
+  let raw;
+  try {
+    raw = await fs3.readFile(manifestPath, "utf-8");
+  } catch {
+    return void 0;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new CompositionError(
+      "composition_rebuild_required",
+      "stale_manifest",
+      `${manifestPath} is not valid JSON \u2014 run \`skaile rebuild\``
+    );
+  }
+  if (StaleSchemaMarker.safeParse(json).success) {
+    throw new CompositionError(
+      "composition_rebuild_required",
+      "stale_manifest",
+      `${manifestPath} is a schema-1 compile manifest (hashes only, no captured content) \u2014 run \`skaile rebuild\``
+    );
+  }
+  const parsed = CompileManifestSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new CompositionError(
+      "composition_rebuild_required",
+      "stale_manifest",
+      `${manifestPath} is malformed (${parsed.error.issues[0]?.path.join(".") || "root"}: ${parsed.error.issues[0]?.message}) \u2014 run \`skaile rebuild\``
+    );
+  }
+  for (const entry of parsed.data.entries) {
+    const actual = hashContent(entry.content);
+    if (actual !== entry.hash) {
+      throw new CompositionError(
+        "composition_conflict",
+        "hash_mismatch",
+        `${manifestPath}: captured content of "${entry.asset_ref}" (${entry.kind}) hashes to ${actual.slice(0, 12)}\u2026 but the manifest records ${entry.hash.slice(0, 12)}\u2026 \u2014 the file was edited; run \`skaile rebuild\``,
+        entry.asset_ref
+      );
+    }
+  }
+  return parsed.data;
+}
+async function loadCompileManifestFromDir(agentDir) {
+  return loadCompileManifest(path2.join(agentDir, COMPILE_MANIFEST_FILENAME));
+}
+async function readPromptVersion(manifestPath) {
+  try {
+    const parsed = JSON.parse(await fs3.readFile(manifestPath, "utf-8"));
+    return typeof parsed?.prompt_version === "number" ? parsed.prompt_version : 0;
+  } catch {
+    return 0;
+  }
+}
+var identityOf = (file) => {
+  try {
+    return realpathSync(file);
+  } catch {
+    return file;
+  }
+};
+async function assertAcyclicSubagents(agentDir, items, source) {
+  const manifestFile = path2.join(agentDir, "agent.yaml");
+  const root = existsSync(manifestFile) ? identityOf(manifestFile) : identityOf(agentDir);
+  const visit = async (children, src, chain) => {
+    for (const item of children) {
+      if (item.kind !== "agent") continue;
+      const asset = await src.load(item.ref, "agent");
+      const identity = asset.location ? identityOf(asset.location) : asset.canonicalRef;
+      if (chain.includes(identity)) {
+        throw new CompositionError(
+          "composition_conflict",
+          "cycle",
+          `"${item.ref}" (agent): sub-agent composition loops (${[...chain, identity].map((p) => path2.basename(path2.dirname(p)) || p).join(" \u2192 ")})`,
+          item.ref
+        );
+      }
+      const nested = NestedAgentComposes.safeParse(parseYamlSafe(asset.content));
+      if (!nested.success || !asset.location) continue;
+      const subagents = nested.data.composes.flatMap((c) => {
+        const parsedItem = NestedAgentItem.safeParse(c);
+        return parsedItem.success ? [parsedItem.data] : [];
+      });
+      if (subagents.length === 0) continue;
+      await visit(subagents, src.scoped(path2.dirname(asset.location)), [...chain, identity]);
+    }
+  };
+  await visit(items, source, [root]);
+}
+function parseYamlSafe(text) {
+  try {
+    return parse(text);
+  } catch {
+    return null;
+  }
+}
+function agentPromptInput(resolved, promptExtensions) {
+  const blocks = resolved?.inlineBlocks ?? [];
+  const joined = (kind) => blocks.filter((block) => block.implicit && block.kind === kind).map((block) => block.content.trim()).filter(Boolean).join("\n\n");
+  return {
+    soul: joined("soul"),
+    memory: resolved?.memoryBlocks ?? [],
+    duties: joined("prompt"),
+    composed: blocks.filter((block) => !block.implicit).map((block) => ({ text: block.content, source: block.ref })),
+    promptExtensions: promptExtensions.map((e) => ({ text: e.value, source: e.source }))
+  };
+}
+function assembleRunnerAgent(resolved, promptExtensions, options = {}) {
+  return assembleAgent(agentPromptInput(resolved, promptExtensions), options);
+}
+function buildRunnerAgentSections(resolved, promptExtensions, options = {}) {
+  return assembleRunnerAgent(resolved, promptExtensions, options).runnerSections;
+}
+function nativeAgentFilePath(cwd, harness, agentName) {
+  const target = harnessNameForHarnessId(harness);
+  if (target === "claude-code") {
+    return join(cwd, HARNESS_TARGETS["claude-code"].local.agent, `${agentName}.md`);
+  }
+  if (target === "codex") {
+    return join(
+      cwd,
+      dirname(HARNESS_TARGETS.codex.local.agent),
+      "skaile-agents",
+      `${agentName}.md`
+    );
+  }
+  return void 0;
+}
+function readNativeAgentFile(cwd, harness, agentName) {
+  const file = nativeAgentFilePath(cwd, harness, agentName);
+  if (!file) return void 0;
+  try {
+    return readFileSync(file, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+
+export { COMPILE_MANIFEST_FILENAME, CompileManifestEntrySchema, CompositionError, UnknownCompositionKindError, agentPromptInput, assembleRunnerAgent, buildRunnerAgentSections, compileComposition, createCompositionContentSource, hashContent, isCompilePinCurrent, isCompositionError, isEmptyKnowledgeIndex, loadCompileManifest, loadCompileManifestFromDir, loadKnowledgeDir, nativeAgentFilePath, readNativeAgentFile, resolveBinding, resolveMixin, stripFrontmatter };
+//# sourceMappingURL=chunk-4ZNKEDYH.js.map
+//# sourceMappingURL=chunk-4ZNKEDYH.js.map