@skaile/workspaces 6.9.0 → 6.10.0

package/dist/chunk-2MUUPRIG.js

@@ -0,0 +1,688 @@
+import { loadDeclaredPlugins } from './chunk-2PVYDAFN.js';
+import { listHarnesses } from './chunk-KE5HDORU.js';
+import { softDepName } from './chunk-4I4SBOCS.js';
+import { readLock, LockParseError } from './chunk-MEU2HHGV.js';
+import { resolveRuntimeAssets } from './chunk-CJO3XKO7.js';
+import { resolveAgentDefinitionDir, AgentRefResolutionError, normalizeAgentInstances, agentBlockKeyDiagnostics, agentInstanceDiagnostics, localConnectorMountDir, symlinkEscapeOfProject, isInsideProject, loadSkWorkspaceConfig, SKAILE_YAML_DEFAULT, resolveSkWorkspaceConfig } from './chunk-BNLXZXZN.js';
+import { SUPPORTED_HARNESSES } from './chunk-VTETQCR6.js';
+import fs, { existsSync, readdirSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import path3 from 'path';
+import pc from 'picocolors';
+import { parse } from 'yaml';
+import { Option } from 'commander';
+
+// cli/src/type-guards.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// cli/src/commands/validate-instances.ts
+var AGENT_MANIFEST_FILE = "agent.yaml";
+var TRIGGER_REQUIRED_FIELDS = {
+  schedule: ["cron", "prompt"],
+  webhook: ["prompt"],
+  channel: ["when"],
+  event: ["event"]
+};
+var err = (code, message, at) => ({
+  code,
+  severity: "error",
+  message,
+  path: at
+});
+function readAssetFacts(manifest) {
+  const facts = {
+    lifecycle: manifest.lifecycle,
+    hasIo: manifest.io !== void 0 && manifest.io !== null,
+    connectorSlots: [],
+    otherSlots: [],
+    triggerIds: []
+  };
+  for (const item of Array.isArray(manifest.composes) ? manifest.composes : []) {
+    if (!isRecord(item) || typeof item.id !== "string") continue;
+    (item.kind === "connector" ? facts.connectorSlots : facts.otherSlots).push(item.id);
+  }
+  for (const t of Array.isArray(manifest.triggers) ? manifest.triggers : []) {
+    if (isRecord(t) && typeof t.id === "string") facts.triggerIds.push(t.id);
+  }
+  return facts;
+}
+function agentDefinitionProblem(projectDir, definition) {
+  let dir;
+  try {
+    dir = resolveAgentDefinitionDir(projectDir, definition);
+  } catch (e) {
+    if (!(e instanceof AgentRefResolutionError)) throw e;
+    return e.message;
+  }
+  if (dir === void 0) {
+    return `agent.definition "${definition}": no ai-assets/ directory above the project`;
+  }
+  if (path3.basename(dir) === AGENT_MANIFEST_FILE) dir = path3.dirname(dir);
+  if (!fs.existsSync(path3.join(dir, AGENT_MANIFEST_FILE))) {
+    return `agent.definition "${definition}": no ${AGENT_MANIFEST_FILE} in ${dir}`;
+  }
+  return null;
+}
+function loadAsset(projectDir, id, ref) {
+  const at = `agents.${id}.ref`;
+  let dir;
+  try {
+    dir = resolveAgentDefinitionDir(projectDir, ref);
+  } catch (e) {
+    if (!(e instanceof AgentRefResolutionError)) throw e;
+    return { diagnostic: err("agent_ref_unresolved", `agents.${id}: ${e.message}`, at) };
+  }
+  if (dir === void 0) {
+    return {
+      diagnostic: err(
+        "agent_ref_unresolved",
+        `agents.${id}: ref "${ref}" cannot be resolved \u2014 no ai-assets/ directory above the project`,
+        at
+      )
+    };
+  }
+  const manifestPath = path3.join(dir, AGENT_MANIFEST_FILE);
+  let text;
+  try {
+    text = fs.readFileSync(manifestPath, "utf-8");
+  } catch {
+    return {
+      diagnostic: err(
+        "agent_ref_unresolved",
+        `agents.${id}: ref "${ref}" resolves to ${dir}, which has no ${AGENT_MANIFEST_FILE}`,
+        at
+      )
+    };
+  }
+  let manifest;
+  try {
+    manifest = parse(text);
+  } catch (e) {
+    return {
+      diagnostic: err(
+        "agent_manifest_invalid",
+        `agents.${id}: ${manifestPath} is not valid YAML: ${e instanceof Error ? e.message : String(e)}`,
+        at
+      )
+    };
+  }
+  if (!isRecord(manifest)) {
+    return {
+      diagnostic: err(
+        "agent_manifest_invalid",
+        `agents.${id}: ${manifestPath} is not a mapping`,
+        at
+      )
+    };
+  }
+  return { facts: readAssetFacts(manifest) };
+}
+function instanceRefProblem(projectDir, id, ref) {
+  const loaded = loadAsset(projectDir, id, ref);
+  return "diagnostic" in loaded && loaded.diagnostic.code === "agent_ref_unresolved" ? loaded.diagnostic.message : null;
+}
+function checkTriggers(id, triggers, assetTriggerIds) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  triggers.forEach((trigger, i) => {
+    const at = `agents.${id}.triggers[${i}]`;
+    if (seen.has(trigger.id)) {
+      out.push(
+        err(
+          "agent_trigger_duplicate",
+          `agents.${id}: trigger id "${trigger.id}" is declared twice`,
+          `${at}.id`
+        )
+      );
+      return;
+    }
+    seen.add(trigger.id);
+    if (!assetTriggerIds || assetTriggerIds.includes(trigger.id)) return;
+    if (!trigger.kind) {
+      out.push(
+        err(
+          "agent_trigger_unknown",
+          `agents.${id}: trigger "${trigger.id}" is not declared by the agent asset (${assetTriggerIds.length > 0 ? `has: ${assetTriggerIds.join(", ")}` : "it declares no triggers"}) \u2014 add \`kind\` and the trigger's fields to declare a new one`,
+          `${at}.id`
+        )
+      );
+      return;
+    }
+    const missing = TRIGGER_REQUIRED_FIELDS[trigger.kind].filter(
+      (field) => trigger[field] === void 0
+    );
+    if (missing.length > 0) {
+      out.push(
+        err(
+          "agent_trigger_incomplete",
+          `agents.${id}: trigger "${trigger.id}" (kind ${trigger.kind}) is not in the asset, so it must declare ${missing.join(", ")}`,
+          at
+        )
+      );
+    }
+  });
+  return out;
+}
+function checkConnectors(id, instance, facts, connectorIds) {
+  const out = [];
+  for (const [slot, connectorId] of Object.entries(instance.connectors ?? {})) {
+    const at = `agents.${id}.connectors.${slot}`;
+    if (!facts.connectorSlots.includes(slot)) {
+      const hint = facts.otherSlots.includes(slot) ? `"${slot}" is a slot of a non-connector item` : facts.connectorSlots.length > 0 ? `the asset's connector slots are: ${facts.connectorSlots.join(", ")}` : "the asset declares no connector slots";
+      out.push(
+        err(
+          "agent_connector_slot_unknown",
+          `agents.${id}: connectors.${slot} is not a connector slot id of the agent asset (${hint})`,
+          at
+        )
+      );
+    }
+    if (!connectorIds.includes(connectorId)) {
+      out.push(
+        err(
+          "agent_connector_unknown",
+          `agents.${id}: connectors.${slot} points at "${connectorId}", which is not in skaile.yaml connectors[]${connectorIds.length > 0 ? ` (has: ${connectorIds.join(", ")})` : ""}`,
+          at
+        )
+      );
+    }
+  }
+  return out;
+}
+function checkAgentInstances(projectDir, parsed) {
+  const diagnostics = [];
+  const instances = normalizeAgentInstances(parsed.agents, diagnostics);
+  const agent = isRecord(parsed.agent) ? parsed.agent : void 0;
+  diagnostics.push(...agentBlockKeyDiagnostics(parsed.agent));
+  if (agent?.subagents !== void 0) {
+    diagnostics.push(
+      err(
+        "agent_subagents_removed",
+        "`agent.subagents` was removed \u2014 declare each subagent as an agent asset and bind it under `agents:` with `lifecycle: role`",
+        "agent.subagents"
+      )
+    );
+  }
+  if (agent?.instances !== void 0) {
+    diagnostics.push(
+      err(
+        "misplaced_agent_instances",
+        "`agent.instances` is not a skaile.yaml key \u2014 declare instances under root `agents:`",
+        "agent.instances"
+      )
+    );
+  }
+  diagnostics.push(
+    ...agentInstanceDiagnostics({
+      agent: {
+        definition: typeof agent?.definition === "string" ? agent.definition : void 0,
+        instances
+      }
+    })
+  );
+  if (typeof agent?.definition === "string" && agent.definition !== "") {
+    const problem = agentDefinitionProblem(projectDir, agent.definition);
+    if (problem) diagnostics.push(err("agent_ref_unresolved", problem, "agent.definition"));
+  }
+  if (!instances) return diagnostics;
+  const connectorIds = (Array.isArray(parsed.connectors) ? parsed.connectors : []).flatMap(
+    (c) => isRecord(c) && typeof c.id === "string" ? [c.id] : []
+  );
+  for (const [id, instance] of Object.entries(instances)) {
+    const loaded = loadAsset(projectDir, id, instance.ref);
+    if ("diagnostic" in loaded) {
+      diagnostics.push(loaded.diagnostic, ...checkTriggers(id, instance.triggers ?? [], void 0));
+      continue;
+    }
+    const { facts } = loaded;
+    const lifecycle = instance.lifecycle ?? facts.lifecycle ?? "standing";
+    if (lifecycle === "role" && !facts.hasIo) {
+      diagnostics.push(
+        err(
+          "agent_role_missing_io",
+          `agents.${id}: lifecycle "role" needs the agent asset to declare \`io\` ({ input, output } JSON Schemas)`,
+          `agents.${id}.lifecycle`
+        )
+      );
+    }
+    diagnostics.push(...checkConnectors(id, instance, facts, connectorIds));
+    diagnostics.push(...checkTriggers(id, instance.triggers ?? [], facts.triggerIds));
+  }
+  return diagnostics;
+}
+function unknownHarnessMessage(harness) {
+  const known = listHarnesses().map((d) => d.id);
+  if (known.includes(harness)) return void 0;
+  return `Unknown agent harness: "${harness}". Available: ${known.join(", ")}. ${DEPLOY_COMMANDS} take: ${SUPPORTED_HARNESSES.join(", ")}.`;
+}
+var DEPLOY_COMMANDS = "harness set, init --harness and add --harness";
+function unknownHarnessTargetMessage(harness, extra = []) {
+  const targets = [...SUPPORTED_HARNESSES, ...extra];
+  const registered = listHarnesses().map((d) => d.id);
+  return `Unknown agent harness: "${harness}". Available: ${targets.join(", ")}. run, repl and config set harness take: ${registered.join(", ")}.`;
+}
+function canonicalHarnessId(harness) {
+  return harness === "claude-code" ? "claude-sdk" : harness;
+}
+var warnedDriverFlag = false;
+function warnDriverFlagDeprecated() {
+  if (warnedDriverFlag) return;
+  warnedDriverFlag = true;
+  console.error("--driver is deprecated; use --harness");
+}
+function driverAliasOption() {
+  return new Option("--driver <name>", "Deprecated alias of --harness").hideHelp();
+}
+function foldDriverFlag(opts, fallback) {
+  const { driver, ...rest } = opts;
+  if (driver !== void 0) warnDriverFlagDeprecated();
+  return { ...rest, harness: rest.harness ?? driver ?? fallback };
+}
+function friendlyHarnessError(err2) {
+  const e = err2;
+  if (!e) return null;
+  const isSpawnEnoent = e.code === "ENOENT" && (e.syscall?.startsWith("spawn") === true || /^spawn .*ENOENT/.test(e.message ?? ""));
+  const isConfig = e.category === "config" || e.detail?.category === "config";
+  if (!isSpawnEnoent && !isConfig) return null;
+  const hint = e.hint ?? e.detail?.hint;
+  const base = hint ?? "The configured agent binary is not installed or not on your PATH.";
+  return `${base}
+Try a different harness with \`--harness claude-sdk\`.`;
+}
+function harnessErrorNotes(err2) {
+  const e = err2;
+  const notes = [];
+  const category = e?.category ?? e?.detail?.category;
+  const hint = e?.hint ?? e?.detail?.hint;
+  if (hint && category !== "config") notes.push(hint);
+  else if (category === "auth") notes.push("Check your API key or login.");
+  if (e?.logSessionId) {
+    notes.push(`Full records: .skaile/logs.db (skaile session logs ${e.logSessionId}).`);
+  }
+  return notes;
+}
+
+// cli/src/config-checks.ts
+function unknownKeyWarnings(diagnostics, label) {
+  return diagnostics.filter((d) => d.code === "unknown_config_key" || d.code === "unknown_profile_key").map((d) => `${label}: ${d.message}`);
+}
+var CONNECTOR_ERROR_CODES = [
+  "connector_missing_driver",
+  "connector_missing_id",
+  "connector_duplicate_id",
+  "connector_invalid_access"
+];
+function connectorErrorLines(diagnostics, label) {
+  return diagnostics.filter((d) => CONNECTOR_ERROR_CODES.includes(d.code)).map((d) => `${label} [connectors] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`);
+}
+function connectorMountPathChecks(projectDir, label, connectors) {
+  const errors = [];
+  const warnings = [];
+  for (const c of connectors) {
+    if (typeof c.id !== "string" || c.id === "") continue;
+    if (c.driver !== "local" || c.mount) continue;
+    const dir = localConnectorMountDir(c, projectDir);
+    if (!dir) continue;
+    const escapesTo = symlinkEscapeOfProject(dir, projectDir);
+    if (!fs.existsSync(dir)) {
+      errors.push(
+        `${label} [connectors] \u2014 connector_mount_path_missing: connectors.${c.id}.mountPath: ${dir} does not exist; create the directory or fix the path`
+      );
+    } else if (escapesTo !== null) {
+      errors.push(
+        `${label} [connectors] \u2014 connector_mount_path_symlink: connectors.${c.id}.mountPath: ${dir} is a symlink to ${escapesTo}, outside the project ${projectDir}; point mountPath at the real directory`
+      );
+    } else if (!isInsideProject(dir, projectDir)) {
+      warnings.push(
+        `${label} [connectors] \u2014 connectors.${c.id}.mountPath: ${dir} is outside the project ${projectDir}; the agent reads${c.access === "read-write" ? " and writes" : ""} there`
+      );
+    }
+  }
+  return { errors, warnings };
+}
+async function unknownConnectorDriverErrors(projectDir, label, connectors) {
+  if (connectors.length === 0) return [];
+  await loadDeclaredPlugins(projectDir);
+  const { listConnectors } = await import('./connectors/index.js');
+  const assets = await resolveRuntimeAssets(projectDir, {
+    isDriverRegistered: (driver) => listConnectors().includes(driver)
+  });
+  if (assets.warnings.some((w) => w.code === "repo_unavailable")) return [];
+  return assets.warnings.filter((w) => w.code === "missing_driver" && w.name).map((w) => `${label} [connectors] \u2014 ${w.code}: ${w.message}`);
+}
+var AGENT_CONFIG_KEY_CODES = ["deprecated_harness_key", "retired_agent_key"];
+function agentConfigKeyWarnings(diagnostics, label) {
+  return diagnostics.filter((d) => AGENT_CONFIG_KEY_CODES.includes(d.code)).map((d) => `${label} [agent-config] \u2014 ${d.code}: ${d.message}`);
+}
+function harnessKeyConflictErrors(diagnostics, label) {
+  return diagnostics.filter((d) => d.code === "harness_key_conflict").map((d) => `${label} [agent-config] \u2014 ${d.code}: ${d.message}`);
+}
+async function unknownHarnessErrors(projectDir, config, label) {
+  const profiles = Object.entries(config.agent_config ?? {}).filter(
+    (e) => typeof e[1]?.harness === "string"
+  );
+  if (profiles.every(([, p]) => unknownHarnessMessage(p.harness) === void 0)) return [];
+  await loadDeclaredPlugins(projectDir);
+  const errors = [];
+  for (const [name, p] of profiles) {
+    const refusal = unknownHarnessMessage(p.harness);
+    if (refusal) errors.push(`${label}: agent-config.${name}.harness: ${refusal}`);
+  }
+  return errors;
+}
+async function reportUnknownHarnesses(projectDir) {
+  let file;
+  try {
+    file = loadSkWorkspaceConfig(projectDir);
+  } catch {
+    return 0;
+  }
+  const config = file?.config;
+  if (!config) return 0;
+  const errors = [
+    ...harnessKeyConflictErrors(file?.diagnostics ?? [], "skaile.yaml"),
+    ...await unknownHarnessErrors(projectDir, config, "skaile.yaml")
+  ];
+  for (const line of errors) logErr(line);
+  return errors.length;
+}
+function agentInstanceDiagnostics2(projectDir) {
+  let parsed;
+  try {
+    parsed = parse(fs.readFileSync(path3.join(projectDir, SKAILE_YAML_DEFAULT), "utf-8"));
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) return [];
+  return checkAgentInstances(projectDir, parsed);
+}
+function agentInstanceLine(d) {
+  return `${SKAILE_YAML_DEFAULT} [agents] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`;
+}
+function agentInstanceErrorLines(projectDir) {
+  return agentInstanceDiagnostics2(projectDir).filter((d) => d.severity === "error" && d.code !== "agent_ref_unresolved").map(agentInstanceLine);
+}
+function agentInstanceWarningLines(projectDir) {
+  return agentInstanceDiagnostics2(projectDir).filter(
+    (d) => d.severity === "warning" && (d.code === "unknown_agent_instance_key" || d.code === "unknown_agent_key")
+  ).map(agentInstanceLine);
+}
+var warnedProjects = /* @__PURE__ */ new Set();
+function warnProjectConfig(projectDir, opts = {}) {
+  const key = path3.resolve(projectDir);
+  if (warnedProjects.has(key)) return;
+  let file = opts.file;
+  if (file === void 0) {
+    try {
+      file = loadSkWorkspaceConfig(projectDir);
+    } catch {
+      return;
+    }
+  }
+  if (!file) return;
+  warnedProjects.add(key);
+  const warn = opts.stderr ? logWarnErr : logWarn;
+  for (const line of unknownKeyWarnings(file.diagnostics ?? [], "skaile.yaml")) warn(line);
+  for (const line of agentConfigKeyWarnings(file.diagnostics ?? [], "skaile.yaml")) warn(line);
+  for (const line of agentInstanceWarningLines(projectDir)) warn(line);
+}
+async function reportProjectConfig(projectDir, opts) {
+  let file;
+  try {
+    file = loadSkWorkspaceConfig(projectDir);
+  } catch {
+    return 0;
+  }
+  if (!file) return 0;
+  warnProjectConfig(projectDir, { file });
+  const errors = [
+    ...harnessKeyConflictErrors(file.diagnostics ?? [], "skaile.yaml"),
+    ...opts.harness ? await unknownHarnessErrors(projectDir, file.config, "skaile.yaml") : [],
+    ...opts.instances ? agentInstanceErrorLines(projectDir) : []
+  ];
+  for (const line of errors) logErr(line);
+  return errors.length;
+}
+
+// cli/src/helpers.ts
+var S = {
+  brand: (s) => pc.cyan(pc.bold(s)),
+  cmd: (s) => pc.cyan(s),
+  heading: (s) => pc.bold(s),
+  bold: (s) => pc.bold(s),
+  dim: (s) => pc.dim(s),
+  ok: (s) => pc.green(s),
+  warn: (s) => pc.yellow(s),
+  err: (s) => pc.red(s),
+  label: (s) => pc.dim(s),
+  rule: (w = 40) => pc.dim("\u2500".repeat(w))
+};
+var KIND_COLORS = {
+  skill: pc.blue,
+  agent: pc.magenta,
+  prompt: pc.yellow,
+  flow: pc.green,
+  preset: pc.cyan,
+  contract: pc.red,
+  connector: pc.green,
+  knowledge: pc.cyan,
+  persona: pc.cyan,
+  ruleset: pc.cyan,
+  "mcp-server": pc.magenta
+};
+function fitWidth(s, width) {
+  if (width <= 0) return "";
+  if (s.length > width) return width === 1 ? "\u2026" : `${s.slice(0, width - 1)}\u2026`;
+  return s.padEnd(width);
+}
+function kindColor(kind) {
+  const colorFn = KIND_COLORS[kind] ?? pc.dim;
+  return colorFn(kind);
+}
+var KIND_COL_WIDTH = 10;
+var TARGET_DEFAULT_HINT = "default: the project's configured harness, else claude-code";
+function kindColorPad(kind, width = KIND_COL_WIDTH) {
+  const colorFn = KIND_COLORS[kind] ?? pc.dim;
+  return colorFn(fitWidth(kind, width));
+}
+function colorRef(ref) {
+  const colonIdx = ref.indexOf(":");
+  if (colonIdx === -1) return ref;
+  const kind = ref.slice(0, colonIdx);
+  const rest = ref.slice(colonIdx);
+  return `${kindColor(kind)}${rest}`;
+}
+function logOk(msg) {
+  console.log(`  ${pc.green("\u2713")} ${msg}`);
+}
+function logErr(msg) {
+  console.error(`  ${pc.red("\u2717")} ${msg}`);
+}
+function logWarn(msg) {
+  console.log(`  ${pc.yellow("!")} ${msg}`);
+}
+function logWarnErr(msg) {
+  console.error(`  ${pc.yellow("!")} ${msg}`);
+}
+function warnPlaceholderBodies(bodies, descriptions) {
+  const refs = [.../* @__PURE__ */ new Set([...bodies ?? [], ...descriptions ?? []])];
+  for (const ref of refs) {
+    const parts = [
+      ...descriptions?.includes(ref) ? ["description"] : [],
+      ...bodies?.includes(ref) ? ["body"] : []
+    ];
+    const both = parts.length > 1;
+    logWarn(
+      `${ref} ${parts.join(" and ")} ${both ? "are" : "is"} still the scaffold placeholder; write ${both ? "them" : "it"} (\`skaile validate\` fails ${both ? "them" : "it"})`
+    );
+  }
+}
+function logInfo(msg) {
+  console.log(`  ${pc.dim("\xB7")} ${msg}`);
+}
+var activeCommandPath;
+function setActiveCommand(cmd) {
+  const names = [];
+  for (let c = cmd; c && c.parent; c = c.parent) {
+    names.unshift(c.name());
+  }
+  activeCommandPath = names.length > 0 ? names.join(" ") : void 0;
+}
+function nearestParentProject(dir) {
+  for (let up = path3.dirname(dir); up !== dir; dir = up, up = path3.dirname(dir)) {
+    if (existsSync(path3.join(up, SKAILE_YAML_DEFAULT))) return up;
+  }
+  return void 0;
+}
+function logNoProject(projectDir) {
+  const dir = path3.resolve(projectDir);
+  logErr(`No ${S.cmd("skaile.yaml")} found. Run ${S.cmd("skaile init")} to create one.`);
+  const parent = nearestParentProject(dir);
+  if (parent) {
+    const command = activeCommandPath ?? process.argv.slice(2).find((a) => !a.startsWith("-")) ?? "<command>";
+    logErr(
+      `${S.cmd(parent)} holds a ${S.cmd("skaile.yaml")}: run from there or put the option after the command name: ${S.cmd(`skaile ${command} --project-dir ${parent}`)}.`
+    );
+  }
+}
+function requireProjectConfig(projectDir, opts = {}) {
+  const dir = path3.resolve(projectDir);
+  if (!existsSync(path3.join(dir, SKAILE_YAML_DEFAULT))) {
+    if (opts.allowMissing) return;
+    logNoProject(dir);
+    process.exit(1);
+  }
+  try {
+    resolveSkWorkspaceConfig(dir);
+  } catch (err2) {
+    logErr(err2 instanceof Error ? err2.message : String(err2));
+    process.exit(1);
+  }
+  try {
+    readLock(path3.join(dir, "skaile.lock.yaml"));
+  } catch (err2) {
+    if (err2 instanceof LockParseError) {
+      logErr(err2.message);
+      process.exit(1);
+    }
+  }
+  warnProjectConfig(dir);
+}
+function deferredWarnings() {
+  const held = [];
+  let live = false;
+  return {
+    push: (msg) => {
+      if (live) logWarn(msg);
+      else held.push(msg);
+    },
+    flush: () => {
+      for (const msg of held.splice(0)) logWarn(msg);
+      live = true;
+    }
+  };
+}
+var STALE_COPY_LIST_MAX = 5;
+function warnStaleHarnessCopies(am) {
+  let stale;
+  try {
+    stale = am.listStaleHarnessCopies();
+  } catch {
+    return;
+  }
+  for (const harness of SUPPORTED_HARNESSES) {
+    const rel = stale.filter((s) => s.harness === harness).map((s) => path3.relative(am.projectDir, s.path));
+    if (rel.length === 0) continue;
+    const dir = `${rel[0]?.split(path3.sep)[0] ?? harness}/`;
+    const shown = rel.slice(0, STALE_COPY_LIST_MAX).join(", ");
+    const more = rel.length > STALE_COPY_LIST_MAX ? `, +${rel.length - STALE_COPY_LIST_MAX} more` : "";
+    logWarn(
+      `Stale ${S.cmd(dir)} copies no longer managed (deploying to ${am.harness}): ${shown}${more}. Delete them with ${S.cmd(`skaile harness set ${am.harness} --clean`)}, or pass ${S.cmd(`--target ${harness}`)} to keep using ${dir}.`
+    );
+  }
+}
+function bareSoftDepName(ref) {
+  return softDepName(ref);
+}
+function formatSoftDepHint(edge) {
+  const suffix = edge.toRef ? ` \u2014 run \`skaile add ${edge.toRef}\` to include it.` : "";
+  return `${bareSoftDepName(edge.from)} references ${bareSoftDepName(edge.to)} (soft dependency)${suffix}`;
+}
+function formatSoftDepSection(targets) {
+  if (targets.length === 0) return [];
+  const out = [`  ${S.label("Soft dependencies (inferred)")}:`];
+  for (const t of targets) out.push(`    ${S.dim("\xB7")}  ${t} ${S.dim("(soft)")}`);
+  return out;
+}
+function formatSoftDepAddPreview(name, targets) {
+  if (targets.length === 0) return "";
+  return S.dim(`${name} references ${targets.join(", ")} (soft dep, not auto-added)`);
+}
+function formatSoftDepRemovePreview(name, targets) {
+  if (targets.length === 0) return "";
+  return S.dim(`removing ${name} would orphan ${targets.join(", ")} (soft dep)`);
+}
+function formatRelativeTime(date) {
+  const diff = Date.now() - date.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function reportLegacyOmpCopies(removed, kept = []) {
+  for (const p of removed) {
+    logInfo(
+      S.dim(`removed the old omp copy ${p.replace(homedir(), "~")} (omp reads ~/.omp/agent)`)
+    );
+  }
+  for (const p of kept) {
+    logWarn(
+      `${p.replace(homedir(), "~")} is an old omp location and skaile did not write this copy, so it was kept: delete it if you do not need it`
+    );
+  }
+}
+function parseHarnessFilter(raw) {
+  if (!raw) return void 0;
+  const ids = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const out = [];
+  for (const id of ids) {
+    if (!SUPPORTED_HARNESSES.includes(id)) {
+      logErr(unknownHarnessTargetMessage(id));
+      process.exit(1);
+    }
+    out.push(id);
+  }
+  return out.length > 0 ? out : void 0;
+}
+var SUB_AGENT_MARKER = "You are a sub-agent:";
+function warnFilesOnlyDelegates(projectDir, target) {
+  if (target !== "codex") return;
+  const dir = path3.join(projectDir, ".codex", "skaile-agents");
+  let names;
+  try {
+    names = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return;
+  }
+  const delegates = names.filter((f) => {
+    try {
+      return readFileSync(path3.join(dir, f), "utf8").includes(SUB_AGENT_MARKER);
+    } catch {
+      return false;
+    }
+  }).map((f) => f.replace(/\.md$/, "")).sort();
+  if (delegates.length === 0) return;
+  logWarn(
+    `codex: delegate agents are files only (${delegates.join(", ")}): Codex does not load .codex/agents as sub-agents, so the orchestrator cannot call them`
+  );
+}
+
+export { KIND_COL_WIDTH, S, TARGET_DEFAULT_HINT, agentDefinitionProblem, agentInstanceErrorLines, bareSoftDepName, canonicalHarnessId, checkAgentInstances, colorRef, connectorErrorLines, connectorMountPathChecks, deferredWarnings, driverAliasOption, fitWidth, foldDriverFlag, formatRelativeTime, formatSoftDepAddPreview, formatSoftDepHint, formatSoftDepRemovePreview, formatSoftDepSection, friendlyHarnessError, harnessErrorNotes, instanceRefProblem, isRecord, kindColor, kindColorPad, logErr, logInfo, logNoProject, logOk, logWarn, logWarnErr, parseHarnessFilter, reportLegacyOmpCopies, reportProjectConfig, reportUnknownHarnesses, requireProjectConfig, setActiveCommand, unknownConnectorDriverErrors, unknownHarnessErrors, unknownHarnessMessage, unknownHarnessTargetMessage, unknownKeyWarnings, warnFilesOnlyDelegates, warnPlaceholderBodies, warnProjectConfig, warnStaleHarnessCopies };
+//# sourceMappingURL=chunk-2MUUPRIG.js.map
+//# sourceMappingURL=chunk-2MUUPRIG.js.map