@iowarp/clio-coder 0.3.4 → 0.3.7

package/dist/{chunk-A2GZF7DC.js → chunk-LADCF22A.js}

@@ -7,10 +7,10 @@ import {
   fingerprintNativeRuntime,
   interopProposals,
   renderProposalEntry
-} from "./chunk-RD5U66HV.js";
+} from "./chunk-SROCI7ZU.js";
 import {
   initializeClioHome
-} from "./chunk-KOHPCX4K.js";
+} from "./chunk-DOOEX22V.js";
 import {
   createDelayedManualCodeInput,
   promptOAuthSelection
@@ -25,11 +25,11 @@ import {
 import {
   credentialWriteFailed,
   printPlaintextCredentialWarning
-} from "./chunk-YCWGATWI.js";
+} from "./chunk-465YSENW.js";
 import {
   printError,
   printOk
-} from "./chunk-ED4KHGC3.js";
+} from "./chunk-PPAMZ32Z.js";
 import {
   buildProviderSupportEntry,
   configuredTargetsForRuntime,
@@ -44,20 +44,20 @@ import {
   probeCapabilitiesForModel,
   registerBuiltinRuntimes,
   supportGroupLabel
-} from "./chunk-QWU7ZBO7.js";
-import {
-  readSettings,
-  removeTargetFromSettings,
-  settingsPath,
-  updateSettings
-} from "./chunk-AD2SYQYC.js";
+} from "./chunk-VQNODYQ4.js";
 import {
   openAuthStorage,
   registerClioOAuthProviders,
   resolveAuthTarget,
   resolveRuntimeAuthTarget,
   targetRequiresAuth
-} from "./chunk-4VP4KH3K.js";
+} from "./chunk-JRIO5UD2.js";
+import {
+  readSettings,
+  removeTargetFromSettings,
+  settingsPath,
+  updateSettings
+} from "./chunk-UHXRNZ2J.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1489,4 +1489,4 @@ export {
   runTargetRename,
   runConfigureCommand
 };
-//# sourceMappingURL=chunk-A2GZF7DC.js.map
+//# sourceMappingURL=chunk-LADCF22A.js.map

package/dist/chunk-LCGCVYZ4.js

@@ -0,0 +1,57 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/toml.ts
+init_esm_shims();
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+var require2 = createRequire(import.meta.url);
+var parse;
+function parser() {
+  parse ??= require2("smol-toml").parse;
+  return parse;
+}
+function parseTomlDocument(raw) {
+  try {
+    return parser()(raw);
+  } catch {
+    return null;
+  }
+}
+function isTomlTable(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function tomlTableAt(document, path) {
+  let value = document;
+  for (const segment of path) {
+    if (!isTomlTable(value) || !Object.hasOwn(value, segment)) return null;
+    value = value[segment];
+  }
+  return isTomlTable(value) ? value : null;
+}
+function createTomlFileReader(root) {
+  const documents = /* @__PURE__ */ new Map();
+  return {
+    read(relativePath) {
+      if (documents.has(relativePath)) return documents.get(relativePath) ?? null;
+      let document = null;
+      try {
+        document = parseTomlDocument(readFileSync(join(root, relativePath), "utf8"));
+      } catch {
+        document = null;
+      }
+      documents.set(relativePath, document);
+      return document;
+    }
+  };
+}
+
+export {
+  parseTomlDocument,
+  tomlTableAt,
+  createTomlFileReader
+};
+//# sourceMappingURL=chunk-LCGCVYZ4.js.map

package/dist/chunk-M4AKACEO.js

@@ -0,0 +1,382 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  fleetLoopCheckStepId,
+  fleetLoopRepairStepId,
+  fleetStepWriteBoundary
+} from "./chunk-KCMKRQX4.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/execution-plan.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+function requireAgentSteps(steps) {
+  return steps.map((step) => {
+    if (step.kind === "code") throw new Error(`execution plan: step '${step.id}' is a code step and has no route`);
+    return step;
+  });
+}
+function canonicalSteps(steps) {
+  return steps.map(
+    (step) => step.kind === "code" ? { ...step, kind: "code", dependencies: [...step.dependencies].sort() } : { ...step, kind: "agent", dependencies: [...step.dependencies].sort() }
+  );
+}
+function executionPlanWaves(steps, maxWorkers) {
+  if (!Number.isInteger(maxWorkers) || maxWorkers < 1)
+    throw new Error("execution plan: maxWorkers must be a positive integer");
+  if (steps.length === 0) throw new Error("execution plan: plan must contain at least one step");
+  const ids = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (step.id.trim().length === 0) throw new Error("execution plan: step id must be non-empty");
+    if (ids.has(step.id)) throw new Error(`execution plan: duplicate step id '${step.id}'`);
+    ids.add(step.id);
+  }
+  for (const step of steps)
+    for (const dependency of step.dependencies) {
+      if (!ids.has(dependency))
+        throw new Error(`execution plan: step '${step.id}' has missing dependency '${dependency}'`);
+      if (dependency === step.id) throw new Error(`execution plan: cycle includes '${step.id}'`);
+    }
+  const remaining = new Set(steps.map((step) => step.id));
+  const completed = /* @__PURE__ */ new Set();
+  const waves = [];
+  while (remaining.size > 0) {
+    const ready = steps.filter((step) => remaining.has(step.id) && step.dependencies.every((id) => completed.has(id)));
+    if (ready.length === 0) throw new Error("execution plan: dependency cycle detected");
+    const codeReady = ready.filter((step) => step.kind === "code").map((step) => step.id);
+    const agentReady = ready.filter((step) => step.kind !== "code").map((step) => step.id);
+    const chunks = [];
+    for (let offset = 0; offset < agentReady.length; offset += maxWorkers) {
+      chunks.push(agentReady.slice(offset, offset + maxWorkers));
+    }
+    if (chunks.length === 0) chunks.push([]);
+    chunks[0] = [...codeReady, ...chunks[0] ?? []];
+    for (const wave of chunks) {
+      waves.push(wave);
+      for (const id of wave) {
+        remaining.delete(id);
+        completed.add(id);
+      }
+    }
+  }
+  return waves;
+}
+function checkLoops(steps, loops) {
+  const byId = new Map(steps.map((step) => [step.id, step]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const loop of loops) {
+    if (seen.has(loop.id)) throw new Error(`execution plan: duplicate loop id '${loop.id}'`);
+    seen.add(loop.id);
+    if (!Number.isInteger(loop.maxAttempts) || loop.maxAttempts < 1) {
+      throw new Error(`execution plan: loop '${loop.id}' must declare a positive attempt bound`);
+    }
+    if (loop.checkStepIds.length !== loop.maxAttempts || loop.repairStepIds.length !== loop.maxAttempts - 1) {
+      throw new Error(`execution plan: loop '${loop.id}' membership does not match its bound of ${loop.maxAttempts}`);
+    }
+    for (const id of [...loop.checkStepIds, ...loop.repairStepIds]) {
+      const step = byId.get(id);
+      if (step === void 0) throw new Error(`execution plan: loop '${loop.id}' names unknown step '${id}'`);
+      if (step.loop?.loopId !== loop.id) {
+        throw new Error(`execution plan: step '${id}' is not a member of loop '${loop.id}'`);
+      }
+    }
+  }
+  for (const step of steps) {
+    if (step.loop !== void 0 && !seen.has(step.loop.loopId)) {
+      throw new Error(`execution plan: step '${step.id}' belongs to undeclared loop '${step.loop.loopId}'`);
+    }
+  }
+}
+function checkWriteBoundaryWaves(steps, waves, writerLimit) {
+  const byId = new Map(steps.map((step) => [step.id, step]));
+  for (const [index, wave] of waves.entries()) {
+    const members = wave.flatMap((id) => {
+      const step = byId.get(id);
+      return step === void 0 ? [] : [step];
+    });
+    const declared = members.filter((step) => step.writes !== void 0);
+    if (declared.length === 0) continue;
+    const undeclared = members.filter((step) => step.writes === void 0);
+    if (undeclared.length > 0 && writerLimit !== 1) {
+      throw new Error(
+        `execution plan: wave ${index} mixes boundary-enforced steps (${declared.map((step) => step.id).join(", ")}) with steps that declare no boundary (${undeclared.map((step) => step.id).join(", ")}); they share one checkout, so the undeclared step's writes cannot be told from a violation`
+      );
+    }
+    const writers = declared.filter((step) => (step.writes?.length ?? 0) > 0);
+    if (writers.length > 1 && writerLimit !== 1) {
+      throw new Error(
+        `execution plan: wave ${index} schedules ${writers.length} steps that may write (${writers.map((step) => step.id).join(
+          ", "
+        )}); a write boundary is verified by diffing one shared checkout, so concurrent writers cannot be attributed. Order them with dependencies or lower maxWorkers`
+      );
+    }
+  }
+}
+function compileExecutionPlan(input) {
+  if (input.writers !== void 0 && input.writers !== 1) {
+    throw new Error("execution plan: writers must be 1 when present");
+  }
+  const steps = canonicalSteps(input.steps);
+  const loops = (input.loops ?? []).map((loop) => ({
+    ...loop,
+    checkStepIds: [...loop.checkStepIds],
+    repairStepIds: [...loop.repairStepIds]
+  }));
+  checkLoops(steps, loops);
+  const waves = executionPlanWaves(steps, input.maxWorkers);
+  checkWriteBoundaryWaves(steps, waves, input.writers);
+  const canonical = {
+    version: 4,
+    topology: input.topology,
+    rootTask: input.rootTask,
+    maxWorkers: input.maxWorkers,
+    ...input.writers === 1 ? { writers: 1 } : {},
+    onFailure: input.onFailure,
+    steps,
+    loops,
+    waves
+  };
+  return { ...canonical, hash: createHash("sha256").update(JSON.stringify(canonical)).digest("hex") };
+}
+function executionPlanAncestors(plan, stepId) {
+  const byId = new Map(plan.steps.map((step) => [step.id, step]));
+  const ancestors = /* @__PURE__ */ new Set();
+  const pending = [...byId.get(stepId)?.dependencies ?? []];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === void 0 || ancestors.has(next)) continue;
+    ancestors.add(next);
+    pending.push(...byId.get(next)?.dependencies ?? []);
+  }
+  return ancestors;
+}
+function spliceExecutionPlan(plan, parentId, tasks) {
+  const parent = plan.steps.find((step) => step.id === parentId);
+  if (parent?.kind !== "agent" || parent.plan === void 0) {
+    throw new Error(`execution plan: '${parentId}' is not a plan step`);
+  }
+  const inserted = tasks.map((task) => ({
+    kind: "agent",
+    id: task.id,
+    agentId: task.agentId,
+    executionRole: task.executionRole,
+    scope: task.writes.length > 0 ? "workspace" : "readonly",
+    expectedResultContract: task.expectedResultContract,
+    requestedAuthority: task.requestedAuthority,
+    approvedAuthority: task.approvedAuthority,
+    dependencies: [parentId, ...task.dependencies],
+    task: task.task,
+    writes: [...task.writes],
+    ...task.target !== void 0 ? { target: task.target } : {},
+    ...task.profile !== void 0 ? { profile: task.profile } : {},
+    planParentId: parentId
+  }));
+  return compileExecutionPlan({
+    topology: plan.topology,
+    rootTask: plan.rootTask,
+    maxWorkers: plan.maxWorkers,
+    ...plan.writers === 1 ? { writers: 1 } : {},
+    onFailure: plan.onFailure,
+    steps: [...plan.steps, ...inserted],
+    loops: plan.loops
+  });
+}
+
+// src/domains/dispatch/fleet-plan.ts
+init_esm_shims();
+function expandDependencies(dependencies, loopMembers) {
+  return dependencies.flatMap((id) => {
+    const loop = loopMembers.get(id);
+    return loop === void 0 ? [id] : [...loop.checkStepIds];
+  });
+}
+function expandCommitSources(sources, loopMembers) {
+  return sources.flatMap((id) => {
+    const loop = loopMembers.get(id);
+    return loop === void 0 ? [id] : [...loop.repairStepIds].reverse();
+  });
+}
+function declaredLoops(steps) {
+  const loops = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    if (step.kind !== "loop") continue;
+    const checkStepIds = [];
+    const repairStepIds = [];
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      checkStepIds.push(fleetLoopCheckStepId(step.id, attempt));
+      if (attempt < step.maxAttempts) repairStepIds.push(fleetLoopRepairStepId(step.id, attempt));
+    }
+    loops.set(step.id, {
+      id: step.id,
+      checkKind: step.check.kind === "gate" ? "code" : step.check.kind,
+      maxAttempts: step.maxAttempts,
+      checkStepIds,
+      repairStepIds
+    });
+  }
+  return loops;
+}
+function compileFleetExecutionPlan(input) {
+  const { contract, task, resolveAgent } = input;
+  const loops = declaredLoops(contract.steps);
+  const steps = [];
+  const boundary = (scope, writes) => {
+    const resolved = fleetStepWriteBoundary(contract.version, scope, writes);
+    return resolved === void 0 ? {} : { writes: [...resolved] };
+  };
+  const agentNode = (context, dependencies, writes, loop, extra) => {
+    const resolved = resolveAgent(context);
+    return {
+      kind: "agent",
+      id: context.stepId,
+      agentId: context.agentId,
+      scope: context.scope,
+      dependencies: [...dependencies],
+      task,
+      expectedResultContract: resolved.expectedResultContract,
+      requestedAuthority: resolved.requestedAuthority,
+      approvedAuthority: resolved.approvedAuthority,
+      executionRole: resolved.executionRole,
+      ...boundary(context.scope, writes),
+      ...loop !== void 0 ? { loop } : {},
+      ...context.target !== void 0 ? { target: context.target } : {},
+      ...context.profile !== void 0 ? { profile: context.profile } : {},
+      ...extra
+    };
+  };
+  const routeOf = (value) => ({
+    ...value.target !== void 0 ? { target: value.target } : {},
+    ...value.profile !== void 0 ? { profile: value.profile } : {}
+  });
+  for (const step of contract.steps) {
+    const dependencies = expandDependencies(step.dependencies, loops);
+    if (step.kind === "agent") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: step.scope, attempt: 0, ...routeOf(step) },
+          dependencies,
+          step.writes
+        )
+      );
+      continue;
+    }
+    if (step.kind === "gate") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: "workspace", attempt: 0, gateAuthorRole: true, ...routeOf(step) },
+          dependencies,
+          [step.path],
+          void 0,
+          { gate: { path: step.path, commandId: step.run } }
+        )
+      );
+      continue;
+    }
+    if (step.kind === "plan") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: step.scope, attempt: 0, planRole: true, ...routeOf(step) },
+          dependencies,
+          step.writes,
+          void 0,
+          { plan: { roster: [...step.roster], maxTasks: step.maxTasks, proposals: step.proposals } }
+        )
+      );
+      continue;
+    }
+    if (step.kind === "code") {
+      steps.push({
+        kind: "code",
+        id: step.id,
+        commandId: step.command,
+        scope: step.scope,
+        dependencies,
+        ...boundary(step.scope, step.writes),
+        ...step.commitFrom !== void 0 ? { commitFrom: expandCommitSources(step.commitFrom, loops) } : {}
+      });
+      continue;
+    }
+    const loop = loops.get(step.id);
+    if (loop === void 0) throw new Error(`fleet plan: loop '${step.id}' failed to compile`);
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      const checkId = loop.checkStepIds[attempt - 1] ?? "";
+      const previousRepair = attempt === 1 ? null : loop.repairStepIds[attempt - 2] ?? "";
+      const checkDependencies = previousRepair === null ? dependencies : [previousRepair];
+      const membership = { loopId: loop.id, role: "check", attempt };
+      if (step.check.kind === "code") {
+        steps.push({
+          kind: "code",
+          id: checkId,
+          commandId: step.check.command,
+          scope: step.check.scope,
+          dependencies: checkDependencies,
+          ...boundary(step.check.scope, step.check.writes),
+          loop: membership,
+          // The green a later step may rely on; the scheduler re-runs it
+          // when a workspace step lands after it.
+          verification: true
+        });
+      } else if (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 plan: gate '${gateId}' failed to resolve`);
+        steps.push({
+          kind: "code",
+          id: checkId,
+          commandId: gate.run,
+          scope: "readonly",
+          dependencies: checkDependencies,
+          writes: [],
+          loop: membership,
+          verification: true,
+          gate: { gateId: gate.id, path: gate.path }
+        });
+      } else {
+        steps.push(
+          agentNode(
+            {
+              stepId: checkId,
+              agentId: step.check.agent,
+              scope: step.check.scope,
+              attempt: 0,
+              gateRole: "reviewer",
+              ...routeOf(step.check)
+            },
+            checkDependencies,
+            step.check.writes,
+            membership
+          )
+        );
+      }
+      if (attempt >= step.maxAttempts) continue;
+      const repairId = loop.repairStepIds[attempt - 1] ?? "";
+      steps.push(
+        agentNode(
+          { stepId: repairId, agentId: step.repair.agent, scope: step.repair.scope, attempt, ...routeOf(step.repair) },
+          [checkId],
+          step.repair.writes,
+          { loopId: loop.id, role: "repair", attempt }
+        )
+      );
+    }
+  }
+  return compileExecutionPlan({
+    topology: "fleet",
+    rootTask: task,
+    maxWorkers: contract.maxWorkers,
+    ...contract.writers === 1 ? { writers: 1 } : {},
+    onFailure: contract.onFailure,
+    steps,
+    loops: [...loops.values()]
+  });
+}
+
+export {
+  requireAgentSteps,
+  compileExecutionPlan,
+  executionPlanAncestors,
+  spliceExecutionPlan,
+  compileFleetExecutionPlan
+};
+//# sourceMappingURL=chunk-M4AKACEO.js.map

package/dist/{chunk-POHLU5DW.js → chunk-M6L6IDJG.js}

@@ -3,7 +3,7 @@ import {
   createSlicer,
   isIndexablePath,
   languageForPath
-} from "./chunk-VJWL6YS5.js";
+} from "./chunk-UUVG37B4.js";
 import {
   CODEWIKI_VERSION
 } from "./chunk-LBMZMYH2.js";
@@ -11,7 +11,7 @@ import {
   WORKSPACE_EXCLUDED_DIRS,
   enumerateWorkspaceFilesAsync,
   filterWorkspaceFileCandidates
-} from "./chunk-EKMEHE4H.js";
+} from "./chunk-33YXPOE3.js";
 import {
   classifyCHeaderLanguage,
   isAmbiguousHeaderPath
@@ -1183,4 +1183,4 @@ export {
   updateCodewikiPaths,
   syncCodewiki
 };
-//# sourceMappingURL=chunk-POHLU5DW.js.map
+//# sourceMappingURL=chunk-M6L6IDJG.js.map

package/dist/{chunk-4JUF2NNX.js → chunk-MXI6J5JF.js}

@@ -2,16 +2,16 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   readLayeredSettings,
   readStrictLayeredSettings
-} from "./chunk-E25LMLRW.js";
+} from "./chunk-YD734TPH.js";
 import {
   formatBootTrace
 } from "./chunk-HKIYEGME.js";
 import {
   initializeClioHome
-} from "./chunk-KOHPCX4K.js";
+} from "./chunk-DOOEX22V.js";
 import {
   readSettings
-} from "./chunk-AD2SYQYC.js";
+} from "./chunk-UHXRNZ2J.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -158,7 +158,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
     } else if (verdict.kind !== "usable") {
       process.stdout.write(`${describeVerdict(verdict)} Starting \`clio-coder configure\`.
 `);
-      const { runConfigureCommand } = await import("./configure-PUQOSIXQ.js");
+      const { runConfigureCommand } = await import("./configure-OLCVPHNM.js");
       const configured = await runConfigureCommand([]);
       if (configured !== 0) return configured;
       startupSettings = readStrictLayeredSettings(process.cwd()).settings;
@@ -167,7 +167,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
   let terminalLease;
   try {
     if (terminalLeaseEligible(options)) {
-      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-ULWXWNVY.js");
+      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-WUZY7ZV5.js");
       if (instantShellEnabled()) {
         let stage0FrameId = null;
         terminalLease = createProcessTerminalLease({
@@ -190,7 +190,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
         throw new Error("injected Stage 1 hydration failure");
       }
     }
-    const { bootOrchestrator } = await import("./orchestrator-ORHT43JB.js");
+    const { bootOrchestrator } = await import("./orchestrator-WZYB54DM.js");
     const result = await bootOrchestrator({
       ...options,
       ...startupSettings ? { startupSettings } : {},
@@ -214,4 +214,4 @@ export {
   terminalLeaseEligible,
   runClioCommand
 };
-//# sourceMappingURL=chunk-4JUF2NNX.js.map
+//# sourceMappingURL=chunk-MXI6J5JF.js.map

package/dist/{chunk-X4RCMKVQ.js → chunk-NDINPTJ4.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   computeFingerprint,
   computeFingerprintAsync
-} from "./chunk-VJWL6YS5.js";
+} from "./chunk-UUVG37B4.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -638,4 +638,4 @@ export {
   wikiStaleness,
   wikiStalenessAsync
 };
-//# sourceMappingURL=chunk-X4RCMKVQ.js.map
+//# sourceMappingURL=chunk-NDINPTJ4.js.map

package/dist/{chunk-TTNYS3EA.js → chunk-OB5HIGJY.js}

@@ -67,4 +67,4 @@ export {
   BusChannels,
   isRunAbortedPayload
 };
-//# sourceMappingURL=chunk-TTNYS3EA.js.map
+//# sourceMappingURL=chunk-OB5HIGJY.js.map