@iowarp/clio-coder 0.4.5 → 0.4.7

package/dist/chunk-WB7POC6M.js

@@ -0,0 +1,891 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  loadSkills,
+  parseAgentRecipeSchema,
+  projectCompatTrusted,
+  recipeIdFromPath,
+  skillCatalogValidity
+} from "./chunk-MZNWZUJM.js";
+import {
+  COMPAT_RESOURCE_PRECEDENCE,
+  defaultScopedResourceRoots,
+  sourceInfoForRoot,
+  splitYamlFrontmatter,
+  stringField
+} from "./chunk-RXFPB32E.js";
+import {
+  parseFleetContract,
+  resolveFleetReferences
+} from "./chunk-KKEYGFX4.js";
+import {
+  parseFrontmatter,
+  pluginResourcePath,
+  readPluginManifest,
+  resolvePackageReferences
+} from "./chunk-YKRJTYNP.js";
+import {
+  assertAgentSpecPolicy,
+  normalizeAgentSpec
+} from "./chunk-34XHRVKG.js";
+import {
+  INTEROP_AGENT_KINDS
+} from "./chunk-5EQO5NWP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/resources/library-validation.ts
+init_esm_shims();
+import { existsSync, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
+import path2 from "node:path";
+
+// src/domains/resources/prompts/loader.ts
+init_esm_shims();
+import { lstatSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+// src/engine/prompt-templates.ts
+init_esm_shims();
+import { parseCommandArgs, substituteArgs as substituteParsedArgs } from "@earendil-works/pi-agent-core";
+var RAW_ARGUMENTS_PLACEHOLDER = /\$ARGUMENTS/g;
+function substituteArgs(content, args, rawArguments) {
+  if (rawArguments === void 0) return substituteParsedArgs(content, args);
+  return content.split(RAW_ARGUMENTS_PLACEHOLDER).map((segment) => substituteParsedArgs(segment, args)).join(rawArguments);
+}
+
+// src/domains/resources/collision.ts
+init_esm_shims();
+var SCOPE_RANK = {
+  package: 0,
+  user: 1,
+  project: 2,
+  cli: 3
+};
+function rankOf(info) {
+  return info.precedence ?? SCOPE_RANK[info.scope];
+}
+function compareCandidates(a, b) {
+  const rankDelta = rankOf(a.source) - rankOf(b.source);
+  if (rankDelta !== 0) return rankDelta;
+  return a.source.path.localeCompare(b.source.path);
+}
+function resolveResourceCollisions(candidates) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = candidate.name.trim();
+    if (key.length === 0) continue;
+    const list = byName.get(key) ?? [];
+    list.push(candidate);
+    byName.set(key, list);
+  }
+  const winners = [];
+  const diagnostics = [];
+  for (const [name, entries] of byName.entries()) {
+    const sorted = [...entries].sort(compareCandidates);
+    const winner = sorted[sorted.length - 1];
+    if (!winner) continue;
+    winners.push(winner.value);
+    for (const loser of sorted.slice(0, -1)) {
+      diagnostics.push({
+        type: "collision",
+        message: `${name} from ${winner.source.scope} overrides ${loser.source.scope}`,
+        path: loser.source.path,
+        collision: {
+          name,
+          winnerPath: winner.source.path,
+          loserPath: loser.source.path,
+          winnerScope: winner.source.scope,
+          loserScope: loser.source.scope
+        }
+      });
+    }
+  }
+  return { winners, diagnostics };
+}
+
+// src/domains/resources/prompts/loader.ts
+function defaultPromptTemplateRoots(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const home = input.home ?? homedir();
+  const trustProject = projectCompatTrusted(input.trustProjectCompatRoots);
+  const compat = [];
+  for (const kind of INTEROP_AGENT_KINDS) {
+    if (kind.userPromptRoot !== void 0) {
+      compat.push({
+        path: path.join(home, kind.userPromptRoot),
+        scope: "user",
+        source: `${kind.id}-user`,
+        precedence: COMPAT_RESOURCE_PRECEDENCE.userCompat,
+        trusted: true
+      });
+    }
+    if (kind.projectPromptRoot !== void 0) {
+      compat.push({
+        path: path.join(cwd, kind.projectPromptRoot),
+        scope: "project",
+        source: `${kind.id}-project`,
+        precedence: COMPAT_RESOURCE_PRECEDENCE.projectCompat,
+        trusted: trustProject
+      });
+    }
+  }
+  return [
+    ...defaultScopedResourceRoots("prompts", cwd).map((root) => ({
+      ...root,
+      trusted: root.trusted !== false || trustProject
+    })),
+    ...compat
+  ];
+}
+function splitOptionalFrontmatter(raw, filePath, diagnostics) {
+  const split = splitYamlFrontmatter(raw);
+  if (split.ok) return split;
+  if (split.reason === "missing") return { frontmatter: {}, body: raw };
+  const message = split.reason === "missing closing delimiter" ? "prompt template frontmatter is missing a closing delimiter; treating the file as plain markdown" : split.reason === "must be a YAML object" ? "prompt template frontmatter must be a YAML object" : `prompt template frontmatter is ${split.reason}`;
+  diagnostics.push({ type: "warning", message, path: filePath });
+  return { frontmatter: {}, body: split.body };
+}
+function fallbackDescription(body) {
+  const line = body.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry.length > 0);
+  if (!line) return "Prompt template";
+  const normalized = line.replace(/^#{1,6}\s+/, "");
+  return normalized.length > 60 ? `${normalized.slice(0, 57)}...` : normalized;
+}
+function resolvePackageRootReferences(body, root) {
+  if (!root.plugin) return { body };
+  try {
+    return { body: resolvePackageReferences(body, root) };
+  } catch (error) {
+    return { reason: `prompt template: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function unavailableTemplate(name, filePath, root, reason, diagnostics, description) {
+  diagnostics.push({ type: "warning", message: reason, path: filePath });
+  const sourceInfo = sourceInfoForRoot(root, filePath);
+  return {
+    name,
+    value: {
+      name,
+      description: description ?? "Prompt template (unavailable)",
+      content: "",
+      filePath,
+      sourceInfo,
+      trusted: root.trusted !== false,
+      unavailable: `${reason} (${filePath})`,
+      displayOnly: false
+    },
+    source: sourceInfo
+  };
+}
+function booleanField(frontmatter, key) {
+  const value = frontmatter[key];
+  return typeof value === "boolean" ? value : null;
+}
+function promptTemplateDisplayText(template) {
+  const content = template.content.replace(/\r\n?/g, "\n");
+  const lines = content.split("\n");
+  for (let start = 0; start < lines.length; start++) {
+    const opening = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(lines[start] ?? "");
+    const fence = opening?.[1];
+    if (!fence || fence[0] === "`" && opening?.[2]?.includes("`")) continue;
+    for (let end = start + 1; end < lines.length; end++) {
+      const closing = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(lines[end] ?? "")?.[1];
+      if (closing && closing[0] === fence[0] && closing.length >= fence.length)
+        return lines.slice(start + 1, end).join("\n").trimEnd();
+    }
+    break;
+  }
+  return content.trimEnd();
+}
+function loadPromptFile(filePath, root, diagnostics) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext !== ".md") return null;
+  const relativePath = path.relative(root.path, filePath);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+    diagnostics.push({ type: "warning", message: "prompt template escaped its discovery root", path: filePath });
+    return null;
+  }
+  const name = relativePath.slice(0, -ext.length).split(path.sep).join(":");
+  if (name.trim().length === 0) return null;
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return unavailableTemplate(name, filePath, root, `prompt template could not be read: ${reason}`, diagnostics);
+  }
+  const { frontmatter, body } = splitOptionalFrontmatter(raw, filePath, diagnostics);
+  const declaredDescription = stringField(frontmatter, "description");
+  const resolution = resolvePackageRootReferences(body, root);
+  if ("reason" in resolution) {
+    return unavailableTemplate(name, filePath, root, resolution.reason, diagnostics, declaredDescription ?? void 0);
+  }
+  const description = declaredDescription ?? fallbackDescription(resolution.body);
+  const argumentHint = stringField(frontmatter, "argument-hint") ?? stringField(frontmatter, "argumentHint");
+  const sourceInfo = sourceInfoForRoot(root, filePath);
+  const template = {
+    name,
+    description,
+    content: resolution.body.trim(),
+    filePath,
+    sourceInfo,
+    trusted: root.trusted !== false,
+    displayOnly: booleanField(frontmatter, "display-only") ?? booleanField(frontmatter, "displayOnly") ?? false
+  };
+  if (argumentHint) template.argumentHint = argumentHint;
+  return { name, value: template, source: sourceInfo };
+}
+function loadPromptRoot(root, diagnostics) {
+  const candidates = [];
+  const pending = [root.path];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (!directory) continue;
+    let entries;
+    try {
+      const stat = lstatSync(directory);
+      if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        diagnostics.push({
+          type: "warning",
+          message: "prompt template root contains a non-directory or symbolic link",
+          path: directory
+        });
+        continue;
+      }
+      entries = readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      diagnostics.push({
+        type: "warning",
+        message: `prompt template directory could not be read: ${error instanceof Error ? error.message : String(error)}`,
+        path: directory
+      });
+      continue;
+    }
+    for (const entry of [...entries].reverse()) {
+      const filePath = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        diagnostics.push({ type: "warning", message: "prompt template symbolic link was ignored", path: filePath });
+      } else if (entry.isDirectory()) {
+        pending.push(filePath);
+      } else if (entry.isFile()) {
+        const candidate = loadPromptFile(filePath, root, diagnostics);
+        if (candidate) candidates.push(candidate);
+      }
+    }
+  }
+  return candidates;
+}
+function loadPromptTemplates(input = {}) {
+  const roots = input.roots ?? defaultPromptTemplateRoots(input);
+  const diagnostics = [];
+  const candidates = roots.flatMap((root) => loadPromptRoot(root, diagnostics));
+  const resolved = resolveResourceCollisions(candidates);
+  const items = [];
+  for (const template of resolved.winners) {
+    if (input.reservedNames?.has(template.name) === true) {
+      diagnostics.push({
+        type: "collision",
+        message: `prompt template /${template.name} conflicts with the built-in slash command /${template.name} and was ignored`,
+        path: template.filePath
+      });
+      continue;
+    }
+    items.push(template);
+  }
+  return {
+    items: items.sort((a, b) => a.name.localeCompare(b.name)),
+    diagnostics: [...diagnostics, ...resolved.diagnostics]
+  };
+}
+function parsePromptCommand(input) {
+  const framed = input.trimStart();
+  if (!framed.startsWith("/")) return null;
+  const withoutSlash = framed.slice(1);
+  const separator = withoutSlash.search(/\s/);
+  const name = separator === -1 ? withoutSlash : withoutSlash.slice(0, separator);
+  if (name.length === 0 || name.includes("/")) return null;
+  const delimiterWidth = separator !== -1 && withoutSlash.slice(separator, separator + 2) === "\r\n" ? 2 : 1;
+  const rest = separator === -1 ? "" : withoutSlash.slice(separator + delimiterWidth);
+  return { name, rest };
+}
+function expandPromptTemplateInput(input, templates) {
+  const command = parsePromptCommand(input);
+  if (!command) return { expanded: false, text: input, args: [], diagnostics: templates.diagnostics };
+  const template = templates.items.find((entry) => entry.name === command.name);
+  if (!template) return { expanded: false, text: input, args: [], diagnostics: templates.diagnostics };
+  if (template.unavailable !== void 0) {
+    const message = `prompt template /${template.name} cannot run: ${template.unavailable}`;
+    return {
+      expanded: false,
+      text: input,
+      args: [],
+      diagnostics: templates.diagnostics,
+      refusal: { template, message }
+    };
+  }
+  if (!template.trusted) {
+    const message = `prompt template ${template.name} comes from an untrusted project root; set integrations.projectResources.trustProjectImports to use it`;
+    return {
+      expanded: false,
+      text: input,
+      args: [],
+      diagnostics: [...templates.diagnostics, { type: "warning", message, path: template.filePath }],
+      refusal: { template, message }
+    };
+  }
+  const args = parseCommandArgs(command.rest);
+  if (template.displayOnly) {
+    return {
+      expanded: false,
+      text: input,
+      args,
+      diagnostics: templates.diagnostics,
+      display: { template, text: promptTemplateDisplayText(template) }
+    };
+  }
+  return {
+    expanded: true,
+    text: substituteArgs(template.content, args, command.rest),
+    args,
+    template,
+    diagnostics: templates.diagnostics
+  };
+}
+
+// src/domains/resources/library-validation.ts
+function normalizePathRel(root, targetPath) {
+  return path2.relative(root, targetPath).split(path2.sep).join("/");
+}
+function parseRefErrorCode(message, fallback) {
+  return message.includes("component reference") || message.includes("package path") ? "ERR_PACKAGE_REFERENCE" : fallback;
+}
+function validateLibraryPackage(packageRoot, _options = {}) {
+  const resolved = path2.resolve(packageRoot);
+  const candidate = readPluginManifest(resolved);
+  if (!candidate.valid || !candidate.manifest) {
+    const manifestErrors = candidate.diagnostics.map((diag) => ({
+      severity: diag.type === "error" ? "error" : "warning",
+      code: "ERR_MANIFEST",
+      message: diag.message,
+      path: diag.path
+    }));
+    return {
+      ...candidate,
+      manifestValid: false,
+      valid: false,
+      validation: {
+        contentValid: false,
+        resources: [],
+        diagnostics: manifestErrors,
+        prerequisites: []
+      }
+    };
+  }
+  const manifest = candidate.manifest;
+  const packageKind = manifest.clio.kind ?? "plugin";
+  const declaredResources = manifest.clio.resources ?? {};
+  const declaredComponents = manifest.clio.components ?? [];
+  const contentDiagnostics = [];
+  const resources = [];
+  const prerequisites = [];
+  const loadedSkills = /* @__PURE__ */ new Map();
+  let skillRootDir;
+  if (declaredResources.skills !== void 0 || existsSync(path2.join(resolved, "skills"))) {
+    const relativeSkills = declaredResources.skills ?? "skills";
+    try {
+      skillRootDir = pluginResourcePath(resolved, relativeSkills, packageKind === "skill" && relativeSkills === ".");
+      const skillRoot = {
+        path: skillRootDir,
+        scope: "package",
+        source: "plugin",
+        rootPath: resolved,
+        containment: resolved
+      };
+      const skillList = loadSkills({ roots: [skillRoot], disableDiscovery: true, cwd: resolved });
+      const validity = skillCatalogValidity(skillList);
+      const loadedPaths = new Set(skillList.items.map((s) => s.filePath));
+      if (!validity.ok) {
+        contentDiagnostics.push({
+          severity: "error",
+          code: "ERR_SKILL",
+          message: `skill catalog invalid: ${validity.reason}`,
+          path: skillRootDir,
+          kind: "skill"
+        });
+      }
+      for (const skill of skillList.items) {
+        loadedSkills.set(skill.name, skill);
+        const relPath = normalizePathRel(resolved, skill.filePath);
+        const hasHardError = skill.diagnostics.some((d) => d.type === "error" || d.type === "collision");
+        const skillDiags = skill.diagnostics.map((d) => ({
+          severity: d.type === "error" || d.type === "collision" ? "error" : "warning",
+          code: d.type === "error" || d.type === "collision" ? "ERR_SKILL" : "WARN_SKILL",
+          message: d.message,
+          path: d.path ?? skill.filePath,
+          kind: "skill"
+        }));
+        for (const d of skillDiags) {
+          if (d.severity === "error") contentDiagnostics.push(d);
+        }
+        resources.push({
+          kind: "skill",
+          name: skill.name,
+          path: relPath,
+          description: skill.description,
+          valid: !hasHardError,
+          diagnostics: skillDiags
+        });
+      }
+      for (const diag of skillList.diagnostics) {
+        const isUnloadable = diag.path !== void 0 && !loadedPaths.has(diag.path);
+        const isHard = diag.type === "error" || diag.type === "collision" || isUnloadable;
+        if (isHard) {
+          contentDiagnostics.push({
+            severity: "error",
+            code: "ERR_SKILL",
+            message: diag.message,
+            path: diag.path,
+            kind: "skill"
+          });
+        }
+      }
+    } catch (err) {
+      contentDiagnostics.push({
+        severity: "error",
+        code: "ERR_SKILL",
+        message: err instanceof Error ? err.message : String(err),
+        path: path2.join(resolved, relativeSkills),
+        kind: "skill"
+      });
+    }
+  }
+  if (declaredResources.prompts !== void 0) {
+    try {
+      const promptsDir = pluginResourcePath(resolved, declaredResources.prompts);
+      const promptRoot = {
+        path: promptsDir,
+        scope: "package",
+        source: "plugin",
+        plugin: true,
+        trusted: true,
+        rootPath: resolved
+      };
+      const promptList = loadPromptTemplates({ roots: [promptRoot] });
+      const loadedPromptPaths = new Set(promptList.items.map((p) => p.filePath));
+      for (const template of promptList.items) {
+        const relPath = normalizePathRel(resolved, template.filePath);
+        const isUnavailable = template.unavailable !== void 0;
+        const templateDiags = [];
+        if (isUnavailable) {
+          const diag = {
+            severity: "error",
+            code: "ERR_PROMPT",
+            message: `prompt template /${template.name} cannot run: ${template.unavailable}`,
+            path: template.filePath,
+            kind: "prompt"
+          };
+          templateDiags.push(diag);
+          contentDiagnostics.push(diag);
+        }
+        resources.push({
+          kind: "prompt",
+          name: template.name,
+          path: relPath,
+          description: template.description,
+          valid: !isUnavailable,
+          diagnostics: templateDiags
+        });
+      }
+      for (const diag of promptList.diagnostics) {
+        const isDropped = diag.path !== void 0 && !loadedPromptPaths.has(diag.path);
+        const isHard = diag.type === "error" || diag.type === "collision" || isDropped;
+        if (isHard) {
+          contentDiagnostics.push({
+            severity: "error",
+            code: "ERR_PROMPT",
+            message: diag.message,
+            path: diag.path,
+            kind: "prompt"
+          });
+        }
+      }
+    } catch (err) {
+      contentDiagnostics.push({
+        severity: "error",
+        code: "ERR_PROMPT",
+        message: err instanceof Error ? err.message : String(err),
+        path: path2.join(resolved, declaredResources.prompts),
+        kind: "prompt"
+      });
+    }
+  }
+  if (declaredResources.agents !== void 0) {
+    try {
+      const agentsDir = pluginResourcePath(resolved, declaredResources.agents);
+      let agentEntries = [];
+      try {
+        agentEntries = readdirSync2(agentsDir, { withFileTypes: true });
+      } catch (err) {
+        contentDiagnostics.push({
+          severity: "error",
+          code: "ERR_AGENT",
+          message: `cannot read agents directory: ${err instanceof Error ? err.message : String(err)}`,
+          path: agentsDir,
+          kind: "agent"
+        });
+      }
+      for (const entry of agentEntries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+        const filepath = path2.join(agentsDir, entry.name);
+        const relPath = normalizePathRel(resolved, filepath);
+        const agentDiags = [];
+        let recipeName = path2.basename(entry.name, ".md");
+        let recipeDescription;
+        try {
+          const id = recipeIdFromPath(filepath, agentsDir);
+          recipeName = id;
+          const raw = readFileSync2(filepath, "utf8");
+          const { frontmatter, body: rawBody } = parseFrontmatter(raw, filepath);
+          const body = resolvePackageReferences(rawBody, { rootPath: resolved, plugin: true });
+          const recipe = parseAgentRecipeSchema({ id, source: "plugin", filepath, body, frontmatter });
+          recipeDescription = recipe.description;
+          if (recipe.skills.length > 0) {
+            if (packageKind === "agent") {
+              agentDiags.push({
+                severity: "error",
+                code: "ERR_AGENT",
+                message: `agent recipe: ${filepath}: standalone recipe cannot bind external skills; must declare skills: []`,
+                path: filepath,
+                kind: "agent"
+              });
+            } else if (!skillRootDir) {
+              agentDiags.push({
+                severity: "error",
+                code: "ERR_AGENT",
+                message: `agent recipe: ${filepath}: plugin declares bound skills but no skills resource root`,
+                path: filepath,
+                kind: "agent"
+              });
+            } else {
+              const canonicalSkillRoot = realpathSync(skillRootDir);
+              for (const skillName of recipe.skills) {
+                const skill = loadedSkills.get(skillName);
+                if (!skill?.trusted) {
+                  agentDiags.push({
+                    severity: "error",
+                    code: "ERR_AGENT",
+                    message: `agent recipe: ${filepath}: bound skill unavailable: ${skillName}`,
+                    path: filepath,
+                    kind: "agent"
+                  });
+                } else {
+                  const canonicalSkill = realpathSync(skill.filePath);
+                  const relative = path2.relative(canonicalSkillRoot, canonicalSkill);
+                  if (relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
+                    agentDiags.push({
+                      severity: "error",
+                      code: "ERR_AGENT",
+                      message: `agent recipe: ${filepath}: bound skill escapes its plugin: ${skill.filePath}`,
+                      path: filepath,
+                      kind: "agent"
+                    });
+                  }
+                }
+              }
+            }
+          }
+          assertAgentSpecPolicy(normalizeAgentSpec(recipe));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          agentDiags.push({
+            severity: "error",
+            code: parseRefErrorCode(message, "ERR_AGENT"),
+            message,
+            path: filepath,
+            kind: "agent"
+          });
+        }
+        for (const d of agentDiags) contentDiagnostics.push(d);
+        resources.push({
+          kind: "agent",
+          name: recipeName,
+          path: relPath,
+          ...recipeDescription !== void 0 ? { description: recipeDescription } : {},
+          valid: agentDiags.length === 0,
+          diagnostics: agentDiags
+        });
+      }
+    } catch (err) {
+      contentDiagnostics.push({
+        severity: "error",
+        code: "ERR_AGENT",
+        message: err instanceof Error ? err.message : String(err),
+        path: path2.join(resolved, declaredResources.agents),
+        kind: "agent"
+      });
+    }
+  }
+  if (declaredResources.fleets !== void 0) {
+    try {
+      const fleetsDir = pluginResourcePath(resolved, declaredResources.fleets);
+      let fleetEntries = [];
+      try {
+        fleetEntries = readdirSync2(fleetsDir, { withFileTypes: true });
+      } catch (err) {
+        contentDiagnostics.push({
+          severity: "error",
+          code: "ERR_FLEET",
+          message: `cannot read fleets directory: ${err instanceof Error ? err.message : String(err)}`,
+          path: fleetsDir,
+          kind: "fleet"
+        });
+      }
+      for (const entry of fleetEntries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+        const filepath = path2.join(fleetsDir, entry.name);
+        const relPath = normalizePathRel(resolved, filepath);
+        const fleetDiags = [];
+        let publicName = path2.basename(entry.name, ".md");
+        let fleetDescription;
+        try {
+          const raw = readFileSync2(filepath, "utf8");
+          const contract = parseFleetContract(raw, filepath);
+          publicName = contract.name;
+          fleetDescription = contract.description;
+          const resolvedContract = resolveFleetReferences(contract, { source: "plugin", rootPath: resolved });
+          for (const step of resolvedContract.steps) {
+            if (step.kind === "code") {
+              prerequisites.push({
+                type: "command",
+                identifier: step.command,
+                sourcePath: filepath,
+                description: `fleet step '${step.id}' requires command '${step.command}'`
+              });
+            } else if (step.kind === "agent") {
+              const isLocal = resources.some((r) => r.kind === "agent" && r.name === step.agent);
+              if (!isLocal) {
+                prerequisites.push({
+                  type: "agent",
+                  identifier: step.agent,
+                  sourcePath: filepath,
+                  description: `fleet step '${step.id}' requires agent '${step.agent}'`
+                });
+              }
+            } else if (step.kind === "plan") {
+              const isLocal = resources.some((r) => r.kind === "agent" && r.name === step.agent);
+              if (!isLocal) {
+                prerequisites.push({
+                  type: "agent",
+                  identifier: step.agent,
+                  sourcePath: filepath,
+                  description: `fleet plan step '${step.id}' requires agent '${step.agent}'`
+                });
+              }
+              for (const rosterAgent of step.roster) {
+                const isLocalRoster = resources.some((r) => r.kind === "agent" && r.name === rosterAgent);
+                if (!isLocalRoster) {
+                  prerequisites.push({
+                    type: "agent",
+                    identifier: rosterAgent,
+                    sourcePath: filepath,
+                    description: `fleet plan step '${step.id}' roster requires agent '${rosterAgent}'`
+                  });
+                }
+              }
+            } else if (step.kind === "gate") {
+              const isLocal = resources.some((r) => r.kind === "agent" && r.name === step.agent);
+              if (!isLocal) {
+                prerequisites.push({
+                  type: "agent",
+                  identifier: step.agent,
+                  sourcePath: filepath,
+                  description: `fleet gate step '${step.id}' requires agent '${step.agent}'`
+                });
+              }
+            } else if (step.kind === "loop") {
+              if (step.check.kind === "code") {
+                prerequisites.push({
+                  type: "command",
+                  identifier: step.check.command,
+                  sourcePath: filepath,
+                  description: `fleet loop step '${step.id}' check requires command '${step.check.command}'`
+                });
+              } else if (step.check.kind === "agent") {
+                const checkAgent = step.check.agent;
+                const isLocal = resources.some((r) => r.kind === "agent" && r.name === checkAgent);
+                if (!isLocal) {
+                  prerequisites.push({
+                    type: "agent",
+                    identifier: checkAgent,
+                    sourcePath: filepath,
+                    description: `fleet loop step '${step.id}' check requires agent '${checkAgent}'`
+                  });
+                }
+              }
+              const repairAgent = step.repair.agent;
+              const isLocalRepair = resources.some((r) => r.kind === "agent" && r.name === repairAgent);
+              if (!isLocalRepair) {
+                prerequisites.push({
+                  type: "agent",
+                  identifier: step.repair.agent,
+                  sourcePath: filepath,
+                  description: `fleet loop step '${step.id}' repair requires agent '${step.repair.agent}'`
+                });
+              }
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          fleetDiags.push({
+            severity: "error",
+            code: parseRefErrorCode(message, "ERR_FLEET"),
+            message,
+            path: filepath,
+            kind: "fleet"
+          });
+        }
+        for (const d of fleetDiags) contentDiagnostics.push(d);
+        resources.push({
+          kind: "fleet",
+          name: publicName,
+          path: relPath,
+          ...fleetDescription !== void 0 ? { description: fleetDescription } : {},
+          valid: fleetDiags.length === 0,
+          diagnostics: fleetDiags
+        });
+      }
+    } catch (err) {
+      contentDiagnostics.push({
+        severity: "error",
+        code: "ERR_FLEET",
+        message: err instanceof Error ? err.message : String(err),
+        path: path2.join(resolved, declaredResources.fleets),
+        kind: "fleet"
+      });
+    }
+  }
+  for (const comp of declaredComponents) {
+    const componentRef = `${comp.kind}:${comp.id}`;
+    let fullCompPath;
+    try {
+      fullCompPath = pluginResourcePath(resolved, comp.path);
+    } catch (err) {
+      contentDiagnostics.push({
+        severity: "error",
+        code: "ERR_COMPONENT",
+        message: `component ${componentRef} path invalid: ${err instanceof Error ? err.message : String(err)}`,
+        path: path2.join(resolved, comp.path),
+        componentRef,
+        kind: comp.kind
+      });
+      continue;
+    }
+    const normalizedCompPath = normalizePathRel(resolved, fullCompPath);
+    if (["agent", "fleet", "skill", "prompt"].includes(comp.kind)) {
+      if (comp.kind === "agent") {
+        const agentsDir = declaredResources.agents ? pluginResourcePath(resolved, declaredResources.agents) : null;
+        if (agentsDir && path2.dirname(fullCompPath) !== agentsDir) {
+          contentDiagnostics.push({
+            severity: "error",
+            code: "ERR_COMPONENT",
+            message: `component agent:${comp.id} at ${comp.path} is nested and cannot be discovered by runtime loader`,
+            path: fullCompPath,
+            componentRef,
+            kind: "agent"
+          });
+        }
+      } else if (comp.kind === "fleet") {
+        const fleetsDir = declaredResources.fleets ? pluginResourcePath(resolved, declaredResources.fleets) : null;
+        if (fleetsDir && path2.dirname(fullCompPath) !== fleetsDir) {
+          contentDiagnostics.push({
+            severity: "error",
+            code: "ERR_COMPONENT",
+            message: `component fleet:${comp.id} at ${comp.path} is nested and cannot be discovered by runtime loader`,
+            path: fullCompPath,
+            componentRef,
+            kind: "fleet"
+          });
+        }
+      }
+      const matched = resources.find((r) => r.path === normalizedCompPath && r.kind === comp.kind);
+      if (!matched) {
+        contentDiagnostics.push({
+          severity: "error",
+          code: "ERR_COMPONENT",
+          message: `component ${componentRef} declared in manifest was not successfully loaded from ${comp.path}`,
+          path: fullCompPath,
+          componentRef,
+          kind: comp.kind
+        });
+      } else {
+        matched.componentRef = componentRef;
+      }
+    } else {
+      const exists = existsSync(fullCompPath) && statSync(fullCompPath).isFile();
+      const diags = exists ? [] : [
+        {
+          severity: "error",
+          code: "ERR_COMPONENT",
+          message: `ancillary component ${componentRef} file does not exist: ${comp.path}`,
+          path: fullCompPath,
+          componentRef,
+          kind: comp.kind
+        }
+      ];
+      for (const d of diags) contentDiagnostics.push(d);
+      resources.push({
+        kind: comp.kind,
+        name: comp.id,
+        path: normalizedCompPath,
+        componentRef,
+        valid: exists,
+        diagnostics: diags
+      });
+    }
+  }
+  if (declaredResources.themes !== void 0) {
+    const themesDir = pluginResourcePath(resolved, declaredResources.themes);
+    const exists = existsSync(themesDir) && statSync(themesDir).isDirectory();
+    resources.push({
+      kind: "theme",
+      name: path2.basename(themesDir),
+      path: normalizePathRel(resolved, themesDir),
+      valid: exists,
+      diagnostics: exists ? [] : [
+        {
+          severity: "error",
+          code: "ERR_THEME",
+          message: `declared themes resource root directory does not exist: ${declaredResources.themes}`,
+          path: themesDir,
+          kind: "theme"
+        }
+      ]
+    });
+  }
+  const contentValid = !contentDiagnostics.some((d) => d.severity === "error");
+  const valid = contentValid;
+  return {
+    ...candidate,
+    manifestValid: true,
+    valid,
+    validation: {
+      contentValid,
+      resources,
+      diagnostics: contentDiagnostics,
+      prerequisites
+    }
+  };
+}
+
+export {
+  parseCommandArgs,
+  substituteArgs,
+  resolveResourceCollisions,
+  promptTemplateDisplayText,
+  loadPromptTemplates,
+  expandPromptTemplateInput,
+  validateLibraryPackage
+};
+//# sourceMappingURL=chunk-WB7POC6M.js.map