@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-7QQRPB2E.js

@@ -0,0 +1,915 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  enabledPluginResourceRoots,
+  parseFrontmatter,
+  resolvePackagePathReference,
+  resolvePackageReferences
+} from "./chunk-6UJ7RDI7.js";
+import {
+  PATH_BOUNDARY_MAX_ENTRIES,
+  normalizePathBoundary,
+  normalizePathBoundaryEntry,
+  pathBoundaryCovers
+} from "./chunk-R2P2U3ZS.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  value_exports
+} from "./chunk-SER7RRAE.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/agents/fleet-commands.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, normalize } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+var FLEET_COMMAND_MAX_TIMEOUT_MS = 36e5;
+var FLEET_COMMAND_MIN_TIMEOUT_MS = 1e3;
+var FLEET_COMMAND_DEFAULT_TIMEOUT_MS = 6e5;
+var FLEET_COMMAND_BASE_ENV = ["PATH", "HOME", "LANG", "LC_ALL", "TZ", "TMPDIR"];
+var CommandSchema = typebox_exports.Object(
+  {
+    argv: typebox_exports.Array(typebox_exports.String({ minLength: 1 }), { minItems: 1 }),
+    argumentSlots: typebox_exports.Optional(
+      typebox_exports.Array(
+        typebox_exports.Object(
+          {
+            name: typebox_exports.String({ pattern: "^[A-Za-z][A-Za-z0-9_-]{0,63}$" }),
+            maxLength: typebox_exports.Integer({ minimum: 1, maximum: 8192 })
+          },
+          { additionalProperties: false }
+        ),
+        { minItems: 1, maxItems: 64 }
+      )
+    ),
+    cwd: typebox_exports.Optional(typebox_exports.String({ minLength: 1 })),
+    timeoutMs: typebox_exports.Optional(
+      typebox_exports.Integer({ minimum: FLEET_COMMAND_MIN_TIMEOUT_MS, maximum: FLEET_COMMAND_MAX_TIMEOUT_MS })
+    ),
+    env: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ minLength: 1 }))),
+    description: typebox_exports.Optional(typebox_exports.String())
+  },
+  { additionalProperties: false }
+);
+var RegistrySchema = typebox_exports.Object(
+  {
+    version: typebox_exports.Literal(1),
+    commands: typebox_exports.Record(typebox_exports.String({ minLength: 1 }), CommandSchema, { minProperties: 1 })
+  },
+  { additionalProperties: false }
+);
+var COMMAND_ID_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+var ENV_NAME_RE = /^[A-Z_][A-Z0-9_]*$/u;
+function fleetCommandsPath(cwd) {
+  return join(cwd, ".clio-coder", "fleets", "commands.yaml");
+}
+function firstSchemaError(value) {
+  if (value_exports.Check(RegistrySchema, value)) return null;
+  const first = [...value_exports.Errors(RegistrySchema, value)][0];
+  return first ? `${first.instancePath || "(root)"}: ${first.message}` : "command registry failed validation";
+}
+function checkCwd(id, value, sourcePath) {
+  if (isAbsolute(value)) {
+    throw new Error(`fleet commands ${sourcePath}: command '${id}' cwd must be workspace-relative`);
+  }
+  const normalized = normalize(value);
+  if (normalized === ".." || normalized.startsWith(`..${"/"}`) || normalized.split(/[\\/]/u).includes("..")) {
+    throw new Error(`fleet commands ${sourcePath}: command '${id}' cwd escapes the workspace`);
+  }
+  return normalized === "." ? "" : normalized;
+}
+function parseFleetCommands(raw, sourcePath) {
+  let parsed;
+  try {
+    parsed = import_yaml.default.parse(raw);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`fleet commands ${sourcePath}: invalid YAML (${reason})`);
+  }
+  const schemaError = firstSchemaError(parsed);
+  if (schemaError !== null) throw new Error(`fleet commands ${sourcePath}: ${schemaError}`);
+  const registry = parsed;
+  const commands = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(registry.commands)) {
+    if (!COMMAND_ID_RE.test(id)) {
+      throw new Error(`fleet commands ${sourcePath}: command id '${id}' must match ${COMMAND_ID_RE.source}`);
+    }
+    const executable = entry.argv[0] ?? "";
+    if (executable.trim().length === 0) {
+      throw new Error(`fleet commands ${sourcePath}: command '${id}' has an empty executable`);
+    }
+    for (const name of entry.env ?? []) {
+      if (!ENV_NAME_RE.test(name)) {
+        throw new Error(`fleet commands ${sourcePath}: command '${id}' env name '${name}' is not a variable name`);
+      }
+    }
+    if (entry.argumentSlots)
+      validateFleetCommandArgs(
+        { id, argv: entry.argv, cwd: "", timeoutMs: 1e3, env: [], description: "", argumentSlots: entry.argumentSlots },
+        entry.argumentSlots.map(() => "{{slot}}"),
+        { allowTemplates: true }
+      );
+    commands.set(id, {
+      id,
+      argv: [...entry.argv],
+      ...entry.argumentSlots ? { argumentSlots: entry.argumentSlots.map((slot) => ({ ...slot })) } : {},
+      cwd: entry.cwd === void 0 ? "" : checkCwd(id, entry.cwd, sourcePath),
+      timeoutMs: entry.timeoutMs ?? FLEET_COMMAND_DEFAULT_TIMEOUT_MS,
+      env: [...entry.env ?? []],
+      description: entry.description ?? ""
+    });
+  }
+  return { version: 1, commands, path: sourcePath };
+}
+function loadFleetCommands(cwd) {
+  const path = fleetCommandsPath(cwd);
+  if (!existsSync(path)) return null;
+  return parseFleetCommands(readFileSync(path, "utf8"), path);
+}
+function resolveFleetCommandArgs(args, vars = {}) {
+  if (args.length > 64) throw new Error("fleet code args: at most 64 arguments are allowed");
+  return args.map((token) => {
+    const match = /^\{\{\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\}\}$/u.exec(token);
+    if (!match && token.includes("{{")) throw new Error("fleet code args: placeholders must occupy a whole argument");
+    const value = match ? vars[match[1] ?? ""] : token;
+    if (value === void 0) throw new Error(`fleet code args: missing variable ${match?.[1]} (pass --var name=value)`);
+    if (value.includes("\0") || value.length > 8192)
+      throw new Error("fleet code args: invalid NUL or oversized argument");
+    return value;
+  });
+}
+function validateFleetCommandArgs(command, args, options = {}) {
+  const slots = command.argumentSlots ?? [];
+  if (slots.length > 64 || new Set(slots.map((slot) => slot.name)).size !== slots.length || slots.some(
+    (slot) => !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/u.test(slot.name) || !Number.isInteger(slot.maxLength) || slot.maxLength < 1 || slot.maxLength > 8192
+  )) {
+    throw new Error(`fleet command '${command.id}': invalid argumentSlots declaration`);
+  }
+  if (args.length !== slots.length) {
+    throw new Error(
+      `fleet command '${command.id}': expected ${slots.length} declared argument slots, got ${args.length}; the operator must declare argumentSlots in commands.yaml`
+    );
+  }
+  for (let index = 0; index < slots.length; index++) {
+    const slot = slots[index];
+    const value = args[index];
+    if (!slot || typeof value !== "string") throw new Error(`fleet command '${command.id}': invalid argument`);
+    if (options.allowTemplates && /^\{\{\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\}\}$/u.test(value)) continue;
+    if (value.length === 0 || value.length > slot.maxLength || value.includes("\0") || value.startsWith("-")) {
+      throw new Error(
+        `fleet command '${command.id}': argument '${slot.name}' must be nonempty data of at most ${slot.maxLength} characters, without NUL or a leading dash; fixed flags belong in argv`
+      );
+    }
+  }
+}
+
+// src/domains/agents/fleet-contract.ts
+init_esm_shims();
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { basename, join as join2 } from "node:path";
+
+// src/domains/agents/write-boundary.ts
+init_esm_shims();
+var WRITE_BOUNDARY_MAX_ENTRIES = PATH_BOUNDARY_MAX_ENTRIES;
+function normalizeWriteBoundaryEntry(entry) {
+  return normalizePathBoundaryEntry(entry);
+}
+function normalizeWriteBoundary(entries) {
+  return normalizePathBoundary(entries);
+}
+function writeBoundaryCovers(boundary, path) {
+  return pathBoundaryCovers(boundary, path);
+}
+function describeWriteBoundary(boundary) {
+  return boundary.length === 0 ? "(nothing: readonly)" : boundary.join(", ");
+}
+
+// src/domains/agents/fleet-contract.ts
+var FLEET_WRITE_BOUNDARY_VERSION = 4;
+var FLEET_DYNAMIC_STEP_VERSION = 5;
+var FLEET_LOOP_MAX_ATTEMPTS = 5;
+var FleetScopeSchema = typebox_exports.Union([typebox_exports.Literal("readonly"), typebox_exports.Literal("workspace")]);
+function writesSchema(version) {
+  return version >= FLEET_WRITE_BOUNDARY_VERSION ? { writes: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ minLength: 1 }), { maxItems: WRITE_BOUNDARY_MAX_ENTRIES })) } : {};
+}
+function routeSchema(version) {
+  return version >= FLEET_DYNAMIC_STEP_VERSION ? { target: typebox_exports.Optional(typebox_exports.String({ minLength: 1 })), profile: typebox_exports.Optional(typebox_exports.String({ minLength: 1 })) } : {};
+}
+function agentStepSchema(version) {
+  return typebox_exports.Object(
+    {
+      kind: typebox_exports.Optional(typebox_exports.Literal("agent")),
+      id: typebox_exports.String({ minLength: 1 }),
+      agent: typebox_exports.String({ minLength: 1 }),
+      scope: FleetScopeSchema,
+      dependencies: typebox_exports.Array(typebox_exports.String({ minLength: 1 })),
+      ...writesSchema(version),
+      ...routeSchema(version)
+    },
+    { additionalProperties: false }
+  );
+}
+function gateStepSchema() {
+  return typebox_exports.Object(
+    {
+      kind: typebox_exports.Literal("gate"),
+      id: typebox_exports.String({ minLength: 1 }),
+      agent: typebox_exports.String({ minLength: 1 }),
+      path: typebox_exports.String({ minLength: 1 }),
+      run: typebox_exports.String({ minLength: 1 }),
+      scope: typebox_exports.Optional(typebox_exports.Literal("workspace")),
+      dependencies: typebox_exports.Array(typebox_exports.String({ minLength: 1 })),
+      ...routeSchema(5)
+    },
+    { additionalProperties: false }
+  );
+}
+function planStepSchema() {
+  return typebox_exports.Object(
+    {
+      kind: typebox_exports.Literal("plan"),
+      id: typebox_exports.String({ minLength: 1 }),
+      agent: typebox_exports.Optional(typebox_exports.String({ minLength: 1 })),
+      roster: typebox_exports.Array(typebox_exports.String({ minLength: 1 }), { minItems: 1, maxItems: 16 }),
+      maxTasks: typebox_exports.Integer({ minimum: 1, maximum: 16 }),
+      proposals: typebox_exports.Optional(typebox_exports.Boolean()),
+      scope: FleetScopeSchema,
+      dependencies: typebox_exports.Array(typebox_exports.String({ minLength: 1 })),
+      ...writesSchema(5),
+      ...routeSchema(5)
+    },
+    { additionalProperties: false }
+  );
+}
+function codeStepSchema(version) {
+  return typebox_exports.Object(
+    {
+      kind: typebox_exports.Literal("code"),
+      id: typebox_exports.String({ minLength: 1 }),
+      command: typebox_exports.String({ minLength: 1 }),
+      args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ maxLength: 8192, pattern: "^[^\\u0000]*$" }), { maxItems: 64 })),
+      scope: FleetScopeSchema,
+      dependencies: typebox_exports.Array(typebox_exports.String({ minLength: 1 })),
+      ...version >= 3 ? { commitFrom: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ minLength: 1 }), { minItems: 1 })) } : {},
+      ...writesSchema(version)
+    },
+    { additionalProperties: false }
+  );
+}
+function loopStepSchema(version) {
+  return typebox_exports.Object(
+    {
+      kind: typebox_exports.Literal("loop"),
+      id: typebox_exports.String({ minLength: 1 }),
+      // Required and finite: this is the whole point of the construct.
+      maxAttempts: typebox_exports.Integer({ minimum: 1, maximum: FLEET_LOOP_MAX_ATTEMPTS }),
+      dependencies: typebox_exports.Array(typebox_exports.String({ minLength: 1 })),
+      check: typebox_exports.Union([
+        typebox_exports.Object(
+          {
+            kind: typebox_exports.Literal("code"),
+            command: typebox_exports.String({ minLength: 1 }),
+            args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String({ maxLength: 8192, pattern: "^[^\\u0000]*$" }), { maxItems: 64 })),
+            scope: FleetScopeSchema,
+            ...writesSchema(version)
+          },
+          { additionalProperties: false }
+        ),
+        ...version >= FLEET_DYNAMIC_STEP_VERSION ? [
+          typebox_exports.Object(
+            { kind: typebox_exports.Literal("gate"), gate: typebox_exports.String({ minLength: 1 }) },
+            { additionalProperties: false }
+          )
+        ] : [],
+        typebox_exports.Object(
+          {
+            kind: typebox_exports.Literal("agent"),
+            agent: typebox_exports.String({ minLength: 1 }),
+            scope: FleetScopeSchema,
+            ...writesSchema(version),
+            ...routeSchema(version)
+          },
+          { additionalProperties: false }
+        )
+      ]),
+      repair: typebox_exports.Object(
+        {
+          kind: typebox_exports.Optional(typebox_exports.Literal("agent")),
+          agent: typebox_exports.String({ minLength: 1 }),
+          scope: FleetScopeSchema,
+          ...writesSchema(version),
+          ...routeSchema(version)
+        },
+        { additionalProperties: false }
+      )
+    },
+    { additionalProperties: false }
+  );
+}
+function stepSchema(version) {
+  if (version === 1) return agentStepSchema(1);
+  if (version === 2) return typebox_exports.Union([agentStepSchema(2), codeStepSchema(2)]);
+  if (version === 5) {
+    return typebox_exports.Union([
+      agentStepSchema(version),
+      codeStepSchema(version),
+      loopStepSchema(version),
+      gateStepSchema(),
+      planStepSchema()
+    ]);
+  }
+  return typebox_exports.Union([agentStepSchema(version), codeStepSchema(version), loopStepSchema(version)]);
+}
+function frontmatterSchema(version) {
+  return typebox_exports.Object(
+    {
+      version: typebox_exports.Literal(version),
+      name: typebox_exports.String({ minLength: 1 }),
+      description: typebox_exports.Optional(typebox_exports.String()),
+      steps: typebox_exports.Array(stepSchema(version), { minItems: 1 }),
+      maxWorkers: typebox_exports.Integer({ minimum: 1 }),
+      budgetUsd: typebox_exports.Optional(typebox_exports.Number()),
+      onFailure: typebox_exports.Union([typebox_exports.Literal("stop"), typebox_exports.Literal("continue")]),
+      ...version >= FLEET_DYNAMIC_STEP_VERSION ? { writers: typebox_exports.Optional(typebox_exports.Literal(1)) } : {}
+    },
+    { additionalProperties: false }
+  );
+}
+var SCHEMAS = {
+  1: frontmatterSchema(1),
+  2: frontmatterSchema(2),
+  3: frontmatterSchema(3),
+  4: frontmatterSchema(4),
+  5: frontmatterSchema(5)
+};
+function contractVersion(frontmatter) {
+  const value = frontmatter.version;
+  return value === 1 || value === 2 || value === 3 || value === 4 || value === 5 ? value : null;
+}
+function firstSchemaError2(frontmatter, version) {
+  const schema = SCHEMAS[version];
+  if (value_exports.Check(schema, frontmatter)) return null;
+  const first = [...value_exports.Errors(schema, frontmatter)][0];
+  return first ? `${first.instancePath || "(root)"}: ${first.message}` : "front matter failed validation";
+}
+function fleetsDir(cwd) {
+  return join2(cwd, ".clio-coder", "fleets");
+}
+function normalizedWrites(writes) {
+  return writes === void 0 ? {} : { writes: normalizeWriteBoundary(writes) };
+}
+function normalizeStep(step) {
+  const route = (value) => ({
+    ...value.target !== void 0 ? { target: value.target } : {},
+    ...value.profile !== void 0 ? { profile: value.profile } : {}
+  });
+  if (step.kind === "gate") {
+    return {
+      kind: "gate",
+      id: step.id,
+      agent: step.agent ?? "",
+      path: step.path ?? "",
+      run: step.run ?? "",
+      scope: "workspace",
+      dependencies: [...step.dependencies],
+      ...route(step)
+    };
+  }
+  if (step.kind === "plan") {
+    return {
+      kind: "plan",
+      id: step.id,
+      agent: step.agent ?? "architect",
+      roster: [...step.roster ?? []],
+      maxTasks: step.maxTasks ?? 0,
+      proposals: step.proposals ?? false,
+      scope: step.scope,
+      dependencies: [...step.dependencies],
+      ...normalizedWrites(step.writes),
+      ...route(step)
+    };
+  }
+  if (step.kind === "loop") {
+    const check = step.check;
+    const repair = step.repair;
+    return {
+      kind: "loop",
+      id: step.id,
+      maxAttempts: step.maxAttempts ?? 0,
+      dependencies: [...step.dependencies],
+      check: check.kind === "code" ? {
+        kind: "code",
+        command: check.command ?? "",
+        ...check.args ? { args: [...check.args] } : {},
+        scope: check.scope,
+        ...normalizedWrites(check.writes)
+      } : check.kind === "gate" ? { kind: "gate", gate: check.gate ?? "" } : {
+        kind: "agent",
+        agent: check.agent ?? "",
+        scope: check.scope,
+        ...normalizedWrites(check.writes),
+        ...route(check)
+      },
+      repair: {
+        kind: "agent",
+        agent: repair.agent,
+        scope: repair.scope,
+        ...normalizedWrites(repair.writes),
+        ...route(repair)
+      }
+    };
+  }
+  if (step.kind === "code") {
+    return {
+      kind: "code",
+      id: step.id,
+      command: step.command ?? "",
+      ...step.args ? { args: [...step.args] } : {},
+      scope: step.scope,
+      dependencies: [...step.dependencies],
+      ...step.commitFrom !== void 0 ? { commitFrom: [...step.commitFrom] } : {},
+      ...normalizedWrites(step.writes)
+    };
+  }
+  return {
+    kind: "agent",
+    id: step.id,
+    agent: step.agent ?? "",
+    scope: step.scope,
+    dependencies: [...step.dependencies],
+    ...normalizedWrites(step.writes),
+    ...route(step)
+  };
+}
+function fleetLoopCheckStepId(loopId, attempt) {
+  return `${loopId}.check.${attempt}`;
+}
+function fleetLoopRepairStepId(loopId, attempt) {
+  return `${loopId}.repair.${attempt}`;
+}
+function occupiedIds(contract) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const step of contract.steps) {
+    owners.set(step.id, step.id);
+    if (step.kind !== "loop") continue;
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      owners.set(fleetLoopCheckStepId(step.id, attempt), step.id);
+      if (attempt < step.maxAttempts) owners.set(fleetLoopRepairStepId(step.id, attempt), step.id);
+    }
+  }
+  return owners;
+}
+function validateFleetGraph(contract) {
+  const declared = /* @__PURE__ */ new Set();
+  for (const step of contract.steps) {
+    if (declared.has(step.id)) throw new Error(`fleet contract ${contract.path}: duplicate step id '${step.id}'`);
+    declared.add(step.id);
+  }
+  const owners = /* @__PURE__ */ new Map();
+  for (const step of contract.steps) {
+    if (step.kind !== "loop") continue;
+    for (const [generated, owner] of occupiedIds({ steps: [step] })) {
+      if (generated === step.id) continue;
+      if (declared.has(generated)) {
+        throw new Error(
+          `fleet contract ${contract.path}: step id '${generated}' collides with an id loop '${owner}' generates`
+        );
+      }
+      owners.set(generated, owner);
+    }
+  }
+  for (const step of contract.steps) {
+    if (step.kind === "loop" && step.check.kind === "gate") {
+      const gateId = step.check.gate;
+      const gate = contract.steps.find((candidate) => candidate.id === gateId);
+      if (gate?.kind !== "gate") {
+        throw new Error(`fleet contract ${contract.path}: loop '${step.id}' names unknown gate '${gateId}'`);
+      }
+    }
+    for (const dependency of step.dependencies) {
+      if (dependency === step.id) throw new Error(`fleet contract ${contract.path}: step '${step.id}' depends on itself`);
+      if (!declared.has(dependency)) {
+        throw new Error(`fleet contract ${contract.path}: step '${step.id}' has unknown dependency '${dependency}'`);
+      }
+    }
+  }
+  const remaining = new Set(declared);
+  const settled = /* @__PURE__ */ new Set();
+  while (remaining.size > 0) {
+    const ready = contract.steps.filter(
+      (step) => remaining.has(step.id) && step.dependencies.every((dependency) => settled.has(dependency))
+    );
+    if (ready.length === 0) {
+      throw new Error(`fleet contract ${contract.path}: dependency cycle among steps ${[...remaining].sort().join(", ")}`);
+    }
+    for (const step of ready) {
+      remaining.delete(step.id);
+      settled.add(step.id);
+    }
+  }
+  const ancestors = fleetStepAncestors(contract.steps);
+  for (const step of contract.steps) {
+    if (step.kind !== "code" || step.commitFrom === void 0) continue;
+    for (const source of step.commitFrom) {
+      const target = contract.steps.find((candidate) => candidate.id === source);
+      if (target === void 0) {
+        throw new Error(`fleet contract ${contract.path}: commit step '${step.id}' names unknown source '${source}'`);
+      }
+      if (target.kind === "code") {
+        throw new Error(
+          `fleet contract ${contract.path}: commit step '${step.id}' source '${source}' is a code step and authors no commit message`
+        );
+      }
+      if (!(ancestors.get(step.id)?.has(source) ?? false)) {
+        throw new Error(
+          `fleet contract ${contract.path}: commit step '${step.id}' must depend on its message source '${source}'`
+        );
+      }
+    }
+  }
+}
+function fleetStepWriteBoundary(version, scope, writes) {
+  if (version < FLEET_WRITE_BOUNDARY_VERSION) return void 0;
+  return scope === "readonly" ? [] : [...writes ?? []];
+}
+function fleetStepBoundaries(contract) {
+  const boundaries = [];
+  const add = (id, scope, writes) => {
+    boundaries.push({ id, scope, writes: fleetStepWriteBoundary(contract.version, scope, writes) });
+  };
+  for (const step of contract.steps) {
+    if (step.kind === "loop") {
+      if (step.check.kind === "gate") {
+        const gateId = step.check.gate;
+        const gate = contract.steps.find((candidate) => candidate.id === gateId);
+        if (gate?.kind === "gate") add(`${step.id}.check`, "workspace", [gate.path]);
+      } else add(`${step.id}.check`, step.check.scope, step.check.writes);
+      add(`${step.id}.repair`, step.repair.scope, step.repair.writes);
+      continue;
+    }
+    if (step.kind === "gate") {
+      add(step.id, "workspace", [step.path]);
+      continue;
+    }
+    add(step.id, step.scope, step.writes);
+  }
+  return boundaries;
+}
+function validateWriteBoundaries(contract) {
+  if (contract.version < FLEET_WRITE_BOUNDARY_VERSION) return;
+  for (const position of fleetStepBoundaries(contract)) {
+    if (position.scope === "workspace" && (position.writes?.length ?? 0) === 0) {
+      throw new Error(
+        `fleet contract ${contract.path}: step '${position.id}' has scope 'workspace' and must declare a non-empty 'writes' allowlist at version ${FLEET_WRITE_BOUNDARY_VERSION}`
+      );
+    }
+  }
+  for (const step of contract.steps) {
+    const declared = step.kind === "loop" ? [
+      ...step.check.kind === "gate" ? [] : [{ id: `${step.id}.check`, scope: step.check.scope, writes: step.check.writes }],
+      { id: `${step.id}.repair`, scope: step.repair.scope, writes: step.repair.writes }
+    ] : step.kind === "gate" ? [] : [{ id: step.id, scope: step.scope, writes: step.writes }];
+    for (const position of declared) {
+      if (position.scope === "readonly" && position.writes !== void 0) {
+        throw new Error(
+          `fleet contract ${contract.path}: step '${position.id}' is 'readonly', which is the empty allowlist; remove its 'writes' or give it scope 'workspace'`
+        );
+      }
+    }
+  }
+}
+function fleetStepAncestors(steps) {
+  const direct = new Map(steps.map((step) => [step.id, step.dependencies]));
+  const closure = /* @__PURE__ */ new Map();
+  const resolve = (id, seen) => {
+    const cached = closure.get(id);
+    if (cached !== void 0) return cached;
+    const result = /* @__PURE__ */ new Set();
+    if (seen.has(id)) return result;
+    seen.add(id);
+    for (const dependency of direct.get(id) ?? []) {
+      result.add(dependency);
+      for (const inherited of resolve(dependency, seen)) result.add(inherited);
+    }
+    closure.set(id, result);
+    return result;
+  };
+  for (const step of steps) resolve(step.id, /* @__PURE__ */ new Set());
+  return closure;
+}
+function parseFleetContract(raw, sourcePath) {
+  const { frontmatter, body } = parseFrontmatter(raw, sourcePath);
+  const version = contractVersion(frontmatter);
+  if (version === null) {
+    throw new Error(`fleet contract ${sourcePath}: version must be 1, 2, 3, 4, or 5`);
+  }
+  if (version < FLEET_WRITE_BOUNDARY_VERSION) assertNoWritesBefore(frontmatter, sourcePath, version);
+  if (version < FLEET_DYNAMIC_STEP_VERSION) assertNoV5FieldsBefore(frontmatter, sourcePath, version);
+  if (version >= FLEET_DYNAMIC_STEP_VERSION) assertNoGateWrites(frontmatter, sourcePath);
+  const schemaError = firstSchemaError2(frontmatter, version);
+  if (schemaError !== null) {
+    throw new Error(`fleet contract ${sourcePath}: ${schemaError}`);
+  }
+  const fm = frontmatter;
+  if (fm.budgetUsd !== void 0 && !(fm.budgetUsd > 0)) {
+    throw new Error(`fleet contract ${sourcePath}: budgetUsd must be a positive number`);
+  }
+  const trimmedBody = body.trim();
+  if (trimmedBody.length === 0) {
+    throw new Error(`fleet contract ${sourcePath}: prompt body is empty`);
+  }
+  const contract = {
+    version,
+    name: fm.name,
+    description: fm.description ?? "",
+    steps: fm.steps.map(normalizeStep),
+    maxWorkers: fm.maxWorkers,
+    budgetUsd: fm.budgetUsd ?? null,
+    onFailure: fm.onFailure,
+    ...fm.writers === 1 ? { writers: 1 } : {},
+    body: trimmedBody,
+    path: sourcePath
+  };
+  validateFleetGraph(contract);
+  validateWriteBoundaries(contract);
+  validateV5Declarations(contract);
+  return contract;
+}
+function validateV5Declarations(contract) {
+  if (contract.version < FLEET_DYNAMIC_STEP_VERSION) return;
+  const route = (id, value) => {
+    if (value.target !== void 0 && value.profile !== void 0) {
+      throw new Error(`fleet contract ${contract.path}: step '${id}' may declare target or profile, never both`);
+    }
+  };
+  for (const step of contract.steps) {
+    if (step.kind === "agent" || step.kind === "plan" || step.kind === "gate") route(step.id, step);
+    if (step.kind === "plan" && new Set(step.roster).size !== step.roster.length) {
+      throw new Error(`fleet contract ${contract.path}: plan step '${step.id}' roster contains duplicate agents`);
+    }
+    if (step.kind === "gate") {
+      let normalized;
+      try {
+        normalized = normalizeWriteBoundary([step.path]);
+      } catch (error) {
+        throw new Error(
+          `fleet contract ${contract.path}: gate '${step.id}' path is invalid: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (normalized[0] !== step.path.replaceAll("\\", "/")) {
+        throw new Error(
+          `fleet contract ${contract.path}: gate '${step.id}' path must be normalized and repository-relative`
+        );
+      }
+    }
+    if (step.kind !== "loop") continue;
+    if (step.check.kind === "agent") route(`${step.id}.check`, step.check);
+    route(`${step.id}.repair`, step.repair);
+  }
+}
+function assertNoWritesBefore(frontmatter, sourcePath, version) {
+  const steps = Array.isArray(frontmatter.steps) ? frontmatter.steps : [];
+  const declaresWrites = (value) => typeof value === "object" && value !== null && "writes" in value;
+  for (const step of steps) {
+    const raw = step;
+    if (declaresWrites(raw) || declaresWrites(raw.check) || declaresWrites(raw.repair)) {
+      throw new Error(
+        `fleet contract ${sourcePath}: 'writes' requires contract version ${FLEET_WRITE_BOUNDARY_VERSION}; this contract declares version ${version}, where the declaration would not be enforced`
+      );
+    }
+  }
+}
+function assertNoGateWrites(frontmatter, sourcePath) {
+  for (const value of Array.isArray(frontmatter.steps) ? frontmatter.steps : []) {
+    if (typeof value !== "object" || value === null) continue;
+    const step = value;
+    if (step.kind !== "gate" || typeof step.id !== "string" || step.id.length === 0 || !("writes" in step)) continue;
+    throw new Error(
+      `fleet contract ${sourcePath}: gate step '${step.id}' must not declare 'writes'; its write boundary is derived from 'path'`
+    );
+  }
+}
+function assertNoV5FieldsBefore(frontmatter, sourcePath, version) {
+  const forbidden = ["target", "profile"];
+  if ("writers" in frontmatter) {
+    throw new Error(
+      `fleet contract ${sourcePath}: 'writers' requires contract version ${FLEET_DYNAMIC_STEP_VERSION}; this contract declares version ${version}`
+    );
+  }
+  for (const value of Array.isArray(frontmatter.steps) ? frontmatter.steps : []) {
+    if (typeof value !== "object" || value === null) continue;
+    const step = value;
+    if (step.kind === "plan" || step.kind === "gate") {
+      throw new Error(
+        `fleet contract ${sourcePath}: kind '${String(step.kind)}' requires contract version ${FLEET_DYNAMIC_STEP_VERSION}; this contract declares version ${version}`
+      );
+    }
+    for (const candidate of [step, step.check, step.repair]) {
+      if (typeof candidate !== "object" || candidate === null) continue;
+      for (const field of forbidden) {
+        if (field in candidate) {
+          throw new Error(
+            `fleet contract ${sourcePath}: '${field}' requires contract version ${FLEET_DYNAMIC_STEP_VERSION}; this contract declares version ${version}`
+          );
+        }
+      }
+    }
+  }
+}
+function fleetCodeSteps(contract) {
+  const steps = [];
+  for (const step of contract.steps) {
+    if (step.kind === "code")
+      steps.push({ id: step.id, command: step.command, ...step.args ? { args: step.args } : {} });
+    else if (step.kind === "gate") steps.push({ id: step.id, command: step.run });
+    else if (step.kind === "loop" && step.check.kind === "code") {
+      steps.push({
+        id: fleetLoopCheckStepId(step.id, 1),
+        command: step.check.command,
+        ...step.check.args ? { args: step.check.args } : {}
+      });
+    }
+  }
+  return steps;
+}
+var FLEET_COMMANDS_REPO_PATH = ".clio-coder/fleets/commands.yaml";
+var FLEET_COMMANDS_REMEDY = "declare each id there under `commands:` with an `argv` list; `clio-coder docs fleet_dispatch` has the schema";
+var FleetCommandRegistryMissingError = class extends Error {
+  constructor(contractPath, commands) {
+    super(
+      `fleet contract ${contractPath}: code steps require a command registry at ${FLEET_COMMANDS_REPO_PATH} declaring ${commands.join(", ")}`
+    );
+    this.contractPath = contractPath;
+    this.commands = commands;
+    this.name = "FleetCommandRegistryMissingError";
+  }
+  contractPath;
+  commands;
+};
+function validateFleetCommands(contract, registry, vars) {
+  const codeSteps = fleetCodeSteps(contract);
+  if (codeSteps.length === 0) return;
+  if (registry === null) {
+    throw new FleetCommandRegistryMissingError(contract.path, [...new Set(codeSteps.map((step) => step.command))].sort());
+  }
+  for (const step of codeSteps) {
+    const command = registry.commands.get(step.command);
+    if (!command) {
+      const known = [...registry.commands.keys()].sort().join(", ");
+      throw new Error(
+        `fleet contract ${contract.path}: step '${step.id}' names unknown command '${step.command}' (registered: ${known || "none"})`
+      );
+    }
+    const args = vars === void 0 ? step.args ?? [] : resolveFleetCommandArgs(step.args ?? [], vars);
+    validateFleetCommandArgs(command, args, { allowTemplates: vars === void 0 });
+  }
+}
+function builtinFleetsDir() {
+  return join2(resolvePackageRoot(), "src", "domains", "agents", "fleets");
+}
+function resolveFleetReferences(contract, source) {
+  if (!source.rootPath) return contract;
+  const context = { rootPath: source.rootPath, plugin: source.source === "plugin" };
+  return {
+    ...contract,
+    body: resolvePackageReferences(contract.body, context),
+    steps: contract.steps.map((step) => {
+      if (step.kind === "code" && step.args)
+        return { ...step, args: step.args.map((arg) => resolvePackagePathReference(arg, context)) };
+      if (step.kind === "loop" && step.check.kind === "code" && step.check.args)
+        return {
+          ...step,
+          check: { ...step.check, args: step.check.args.map((arg) => resolvePackagePathReference(arg, context)) }
+        };
+      return step;
+    })
+  };
+}
+function fleetSources(cwd) {
+  return [
+    { dir: builtinFleetsDir(), source: "builtin" },
+    ...enabledPluginResourceRoots("fleets", cwd).sort((left, right) => left.source.localeCompare(right.source)).map((root) => ({ dir: root.path, rootPath: root.rootPath, source: "plugin" })),
+    { dir: join2(clioConfigDir(), "fleets"), source: "user" },
+    { dir: fleetsDir(cwd), source: "project" }
+  ];
+}
+function fleetContractPath(cwd, name) {
+  for (const source of [...fleetSources(cwd)].reverse()) {
+    const candidate = join2(source.dir, `${name}.md`);
+    if (existsSync2(candidate))
+      return { path: candidate, source: source.source, ...source.rootPath ? { rootPath: source.rootPath } : {} };
+  }
+  return null;
+}
+function loadFleetContract(cwd, name) {
+  const located = fleetContractPath(cwd, name);
+  if (located === null) {
+    throw new Error(`fleet contract not found: ${join2(fleetsDir(cwd), `${name}.md`)} (and no builtin named '${name}')`);
+  }
+  const contract = resolveFleetReferences(parseFleetContract(readFileSync2(located.path, "utf8"), located.path), located);
+  validateFleetCommands(contract, loadFleetCommands(cwd));
+  return contract;
+}
+function listDirectory(dir) {
+  if (!existsSync2(dir)) return [];
+  try {
+    return readdirSync(dir).filter((name) => name.endsWith(".md")).sort();
+  } catch {
+    return [];
+  }
+}
+function listFleetContracts(cwd) {
+  let registry = null;
+  let registryError = null;
+  try {
+    registry = loadFleetCommands(cwd);
+  } catch (err) {
+    registryError = err instanceof Error ? err.message : String(err);
+  }
+  const listings = /* @__PURE__ */ new Map();
+  const sources = fleetSources(cwd);
+  for (const { dir, source, rootPath } of sources) {
+    for (const file of listDirectory(dir)) {
+      const path = join2(dir, file);
+      const name = basename(file, ".md");
+      try {
+        const contract = resolveFleetReferences(parseFleetContract(readFileSync2(path, "utf8"), path), {
+          source,
+          ...rootPath ? { rootPath } : {}
+        });
+        if (registryError !== null && fleetCodeSteps(contract).length > 0) throw new Error(registryError);
+        validateFleetCommands(contract, registry);
+        listings.set(name, { name, path, source, contract, error: null, needsCommands: null });
+      } catch (err) {
+        listings.set(name, {
+          name,
+          path,
+          source,
+          contract: null,
+          error: err instanceof Error ? err.message : String(err),
+          // A registry this repo never wrote is unfinished setup. A registry
+          // that exists and does not parse, or one missing an id the contract
+          // names, is a real error and stays one.
+          needsCommands: err instanceof FleetCommandRegistryMissingError ? err.commands : null
+        });
+      }
+    }
+  }
+  return [...listings.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+var PLACEHOLDER_RE = /\{\{\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\}\}/g;
+function renderFleetPrompt(body, vars) {
+  const missing = /* @__PURE__ */ new Set();
+  const rendered = body.replace(PLACEHOLDER_RE, (_match, name) => {
+    const value = vars[name];
+    if (value === void 0) {
+      missing.add(name);
+      return "";
+    }
+    return value;
+  });
+  if (missing.size > 0) {
+    throw new Error(`fleet prompt: unresolved template variables: ${[...missing].join(", ")} (pass --var name=value)`);
+  }
+  return rendered;
+}
+
+export {
+  FLEET_COMMAND_BASE_ENV,
+  loadFleetCommands,
+  resolveFleetCommandArgs,
+  validateFleetCommandArgs,
+  normalizeWriteBoundaryEntry,
+  normalizeWriteBoundary,
+  writeBoundaryCovers,
+  describeWriteBoundary,
+  fleetLoopCheckStepId,
+  fleetLoopRepairStepId,
+  validateFleetGraph,
+  fleetStepWriteBoundary,
+  fleetStepBoundaries,
+  parseFleetContract,
+  fleetCodeSteps,
+  FLEET_COMMANDS_REPO_PATH,
+  FLEET_COMMANDS_REMEDY,
+  FleetCommandRegistryMissingError,
+  validateFleetCommands,
+  resolveFleetReferences,
+  loadFleetContract,
+  listFleetContracts,
+  renderFleetPrompt
+};
+//# sourceMappingURL=chunk-7QQRPB2E.js.map