@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-Y3M2T5RO.js

@@ -1,891 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  loadSkills,
-  parseAgentRecipeSchema,
-  projectCompatTrusted,
-  recipeIdFromPath,
-  skillCatalogValidity
-} from "./chunk-7FBCRWVT.js";
-import {
-  COMPAT_RESOURCE_PRECEDENCE,
-  defaultScopedResourceRoots,
-  sourceInfoForRoot,
-  splitYamlFrontmatter,
-  stringField
-} from "./chunk-YJCCMYYT.js";
-import {
-  parseFleetContract,
-  resolveFleetReferences
-} from "./chunk-7QQRPB2E.js";
-import {
-  parseFrontmatter,
-  pluginResourcePath,
-  readPluginManifest,
-  resolvePackageReferences
-} from "./chunk-6UJ7RDI7.js";
-import {
-  assertAgentSpecPolicy,
-  normalizeAgentSpec
-} from "./chunk-I47EJPYL.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-Y3M2T5RO.js.map