opencode-swarm 7.122.0 → 7.123.0

package/dist/cli/{index-jzpv74mq.js → index-7g91saha.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-68aggz0v.js";
+} from "./index-6sgqnvpw.js";
 import {
   handleGuardrailLog
-} from "./index-zvae4m8g.js";
+} from "./index-17eybc3z.js";
 import {
   COMMAND_REGISTRY,
   SWARM_COMMAND_TOOL_ALLOWLIST,
@@ -83,49 +83,51 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-ahxrne50.js";
-import"./index-kyvg2cmp.js";
-import"./index-vqcgmy4y.js";
-import"./index-emkb0bbe.js";
+} from "./index-jyrhy4ww.js";
+import"./index-19zn67q6.js";
+import"./index-det5jwfk.js";
+import"./index-7cspygmb.js";
 import"./index-4905hd2m.js";
 import"./index-nprawcc0.js";
-import"./index-gr7ssnj9.js";
-import"./index-xdsj4qtd.js";
-import"./index-rkd6qwjh.js";
+import"./index-q00e4s1s.js";
+import"./index-j9kxwshw.js";
+import"./index-hns7xjm7.js";
 import"./index-vxv732ex.js";
 import"./index-c8s9a3zh.js";
 import"./index-816rkp4y.js";
 import"./index-22e127jw.js";
-import"./index-j33zb3cx.js";
-import"./index-3r1w7xky.js";
+import"./index-m0bmh3w0.js";
+import"./index-cqsak7bf.js";
 import"./index-rtry5xyf.js";
-import"./index-ny13nr0x.js";
-import"./index-3sx27bxt.js";
+import"./index-n2712byd.js";
+import"./index-dywekeen.js";
 import"./index-ae75rja9.js";
-import"./index-3jvqw5hy.js";
-import"./index-9xpgytj9.js";
-import"./index-qt2yaghg.js";
+import"./index-q27bajqb.js";
+import"./index-3rr0ese8.js";
+import"./index-vcgfqd8f.js";
 import"./index-gnp9x6se.js";
 import {
   AGENT_TOOL_MAP,
   ORCHESTRATOR_NAME,
   stripKnownSwarmPrefix
-} from "./index-tftv9xh9.js";
+} from "./index-wr8qgpz5.js";
 import"./index-4rhcth7a.js";
 import"./index-8fwhhayc.js";
 import"./index-q1exe2b3.js";
-import"./index-51gg9947.js";
-import"./index-wtn8wf7h.js";
+import"./index-d6h5hq91.js";
+import"./index-ctpgsj84.js";
+import"./index-m1abzg93.js";
+import"./index-gw3m5fw0.js";
 import"./index-ye3fndsw.js";
 import"./index-kzj3fp7c.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-zgwm4ryv.js";
 import"./index-dqh3zhhc.js";
-import"./index-qg11yf8q.js";
-import"./index-h07wn84h.js";
-import"./index-76kvm9z5.js";
+import"./index-6xnxz6z0.js";
+import"./index-7mkpsw6g.js";
 import"./index-fsrp8wp3.js";
+import"./index-76kvm9z5.js";
 import"./index-q2rrv0cy.js";
 import"./index-293f68mj.js";
 import"./index-7g4c7s5r.js";

package/dist/cli/{index-3r1w7xky.js → index-cqsak7bf.js}

@@ -4,13 +4,13 @@ import {
 } from "./index-rtry5xyf.js";
 import {
   readKnowledgeEvents
-} from "./index-3sx27bxt.js";
+} from "./index-dywekeen.js";
 import {
   isLinked,
   readLinkPointer,
   resolveKnowledgeStoreDir,
   resolveLinkDir
-} from "./index-3jvqw5hy.js";
+} from "./index-q27bajqb.js";
 
 // src/knowledge/curation-policy.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";

package/dist/cli/index-ctpgsj84.js

@@ -0,0 +1,547 @@
+// @bun
+import {
+  ExecutionProfileSchema,
+  PlanSchema,
+  TaskStatusSchema
+} from "./index-m1abzg93.js";
+import {
+  criticalWarn,
+  init_logger,
+  log
+} from "./index-zgwm4ryv.js";
+import {
+  withEvidenceLock
+} from "./index-76kvm9z5.js";
+import {
+  emit
+} from "./index-q2rrv0cy.js";
+
+// src/plan/utils.ts
+function derivePlanId(plan) {
+  return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+
+// src/plan/ledger.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+init_logger();
+var LEDGER_SCHEMA_VERSION = "1.1.0";
+var LEDGER_FILENAME = "plan-ledger.jsonl";
+var LEDGER_LOCK_PATH = path.join(".swarm", LEDGER_FILENAME);
+var PLAN_JSON_FILENAME = "plan.json";
+
+class LedgerStaleWriterError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LedgerStaleWriterError";
+  }
+}
+function getLedgerPath(directory) {
+  return path.join(directory, ".swarm", LEDGER_FILENAME);
+}
+function getPlanJsonPath(directory) {
+  return path.join(directory, ".swarm", PLAN_JSON_FILENAME);
+}
+function writeFileFsyncedThenRename(tempPath, targetPath, data) {
+  const fd = fs.openSync(tempPath, "w");
+  try {
+    fs.writeFileSync(fd, data, "utf8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tempPath, targetPath);
+}
+function computePlanHash(plan) {
+  const normalized = {
+    schema_version: plan.schema_version,
+    title: plan.title,
+    swarm: plan.swarm,
+    current_phase: plan.current_phase,
+    migration_status: plan.migration_status,
+    execution_profile: plan.execution_profile,
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      name: phase.name,
+      status: phase.status,
+      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
+      tasks: phase.tasks.map((task) => ({
+        id: task.id,
+        phase: task.phase,
+        status: task.status,
+        size: task.size,
+        description: task.description,
+        depends: [...task.depends].sort(),
+        acceptance: task.acceptance,
+        files_touched: [...task.files_touched].sort(),
+        evidence_path: task.evidence_path,
+        blocked_reason: task.blocked_reason
+      }))
+    }))
+  };
+  const jsonString = JSON.stringify(normalized);
+  return crypto.createHash("sha256").update(jsonString, "utf8").digest("hex");
+}
+function computePlanStructureHash(plan) {
+  const normalized = {
+    schema_version: plan.schema_version,
+    title: plan.title,
+    swarm: plan.swarm,
+    current_phase: plan.current_phase,
+    migration_status: plan.migration_status,
+    execution_profile: plan.execution_profile,
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      name: phase.name,
+      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
+      tasks: phase.tasks.map((task) => ({
+        id: task.id,
+        phase: task.phase,
+        size: task.size,
+        description: task.description,
+        depends: [...task.depends].sort(),
+        acceptance: task.acceptance,
+        files_touched: [...task.files_touched].sort(),
+        evidence_path: task.evidence_path,
+        blocked_reason: task.blocked_reason
+      }))
+    }))
+  };
+  const jsonString = JSON.stringify(normalized);
+  return crypto.createHash("sha256").update(jsonString, "utf8").digest("hex");
+}
+function computeCurrentPlanHash(directory) {
+  const planPath = getPlanJsonPath(directory);
+  try {
+    const content = fs.readFileSync(planPath, "utf8");
+    const plan = JSON.parse(content);
+    return computePlanHash(plan);
+  } catch {
+    return "";
+  }
+}
+async function ledgerExists(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  return fs.existsSync(ledgerPath);
+}
+async function getLatestLedgerSeq(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs.existsSync(ledgerPath)) {
+    return 0;
+  }
+  try {
+    const content = fs.readFileSync(ledgerPath, "utf8");
+    const lines = content.trim().split(`
+`).filter((line) => line.trim() !== "");
+    if (lines.length === 0) {
+      return 0;
+    }
+    let maxSeq = 0;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        if (event.seq > maxSeq) {
+          maxSeq = event.seq;
+        }
+      } catch {}
+    }
+    return maxSeq;
+  } catch {
+    return 0;
+  }
+}
+async function readLedgerEvents(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs.existsSync(ledgerPath)) {
+    return [];
+  }
+  try {
+    const content = fs.readFileSync(ledgerPath, "utf8");
+    const lines = content.trim().split(`
+`).filter((line) => line.trim() !== "");
+    const events = [];
+    let skippedCount = 0;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+      } catch {
+        skippedCount++;
+      }
+    }
+    if (skippedCount > 0) {
+      log(`[ledger] Skipped ${skippedCount} malformed line(s) in plan-ledger.jsonl`);
+    }
+    events.sort((a, b) => a.seq - b.seq);
+    return events;
+  } catch {
+    return [];
+  }
+}
+async function initLedger(directory, planId, initialPlanHash, initialPlan) {
+  const ledgerPath = getLedgerPath(directory);
+  const planJsonPath = getPlanJsonPath(directory);
+  if (fs.existsSync(ledgerPath)) {
+    throw new Error("Ledger already initialized. Use appendLedgerEvent to add events.");
+  }
+  let planHashAfter = initialPlanHash ?? "";
+  let embeddedPlan = initialPlan;
+  if (!initialPlanHash) {
+    try {
+      if (fs.existsSync(planJsonPath)) {
+        const content = fs.readFileSync(planJsonPath, "utf8");
+        const plan = JSON.parse(content);
+        planHashAfter = computePlanHash(plan);
+        if (!embeddedPlan)
+          embeddedPlan = plan;
+      }
+    } catch {}
+  }
+  const payload = embeddedPlan ? { plan: embeddedPlan, payload_hash: planHashAfter } : undefined;
+  const event = {
+    seq: 1,
+    timestamp: new Date().toISOString(),
+    plan_id: planId,
+    event_type: "plan_created",
+    source: "initLedger",
+    plan_hash_before: "",
+    plan_hash_after: planHashAfter,
+    schema_version: LEDGER_SCHEMA_VERSION,
+    ...payload ? { payload } : {}
+  };
+  fs.mkdirSync(path.join(directory, ".swarm"), { recursive: true });
+  const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  const line = `${JSON.stringify(event)}
+`;
+  writeFileFsyncedThenRename(tempPath, ledgerPath, line);
+}
+async function appendLedgerEvent(directory, eventInput, options) {
+  return withEvidenceLock(directory, LEDGER_LOCK_PATH, "plan-ledger", "append-ledger-event", async () => {
+    const ledgerPath = getLedgerPath(directory);
+    const latestSeq = await getLatestLedgerSeq(directory);
+    const nextSeq = latestSeq + 1;
+    const planHashBefore = computeCurrentPlanHash(directory);
+    if (options?.expectedSeq !== undefined && options.expectedSeq !== latestSeq) {
+      throw new LedgerStaleWriterError(`Stale writer: expected seq ${options.expectedSeq} but found ${latestSeq}`);
+    }
+    if (options?.expectedHash !== undefined && options.expectedHash !== planHashBefore) {
+      throw new LedgerStaleWriterError(`Stale writer: expected hash ${options.expectedHash} but found ${planHashBefore}`);
+    }
+    const planHashAfter = options?.planHashAfter ?? planHashBefore;
+    const event = {
+      ...eventInput,
+      seq: nextSeq,
+      timestamp: new Date().toISOString(),
+      plan_hash_before: planHashBefore,
+      plan_hash_after: planHashAfter,
+      schema_version: LEDGER_SCHEMA_VERSION
+    };
+    fs.mkdirSync(path.join(directory, ".swarm"), { recursive: true });
+    const tempPath = `${ledgerPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+    const line = `${JSON.stringify(event)}
+`;
+    if (!fs.existsSync(ledgerPath)) {
+      throw new Error("Ledger not initialized. Call initLedger() first.");
+    }
+    const existingContent = fs.readFileSync(ledgerPath, "utf8");
+    writeFileFsyncedThenRename(tempPath, ledgerPath, existingContent + line);
+    return event;
+  });
+}
+async function takeSnapshotWithRetry(directory, plan, options) {
+  const MAX_RETRIES = 3;
+  const TOTAL_ATTEMPTS = 1 + MAX_RETRIES;
+  const telemetrySource = options?.source ?? "save_plan_tool";
+  const snapshotOptions = { planHashAfter: options?.planHashAfter };
+  let lastError;
+  for (let attempt = 1;attempt <= TOTAL_ATTEMPTS; attempt++) {
+    try {
+      await takeSnapshotEvent(directory, plan, snapshotOptions);
+      return;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < TOTAL_ATTEMPTS) {
+        await new Promise((r) => setTimeout(r, 10 * 2 ** (attempt - 1)));
+      }
+    }
+  }
+  criticalWarn(`[takeSnapshotWithRetry] Snapshot failed after ${MAX_RETRIES} retries (${TOTAL_ATTEMPTS} attempts): ${lastError.message}`);
+  try {
+    emit("snapshot_failed", {
+      error: lastError.message,
+      retries: MAX_RETRIES,
+      source: telemetrySource
+    });
+  } catch {}
+}
+async function takeSnapshotEvent(directory, plan, options) {
+  const payloadHash = options?.payloadHashOverride ?? computePlanHash(plan);
+  const snapshotPayload = {
+    plan,
+    payload_hash: payloadHash
+  };
+  if (options?.approvalMetadata) {
+    snapshotPayload.approval = options.approvalMetadata;
+  }
+  const planId = derivePlanId(plan);
+  return appendLedgerEvent(directory, {
+    event_type: "snapshot",
+    source: options?.source ?? "takeSnapshotEvent",
+    plan_id: planId,
+    payload: snapshotPayload
+  }, { planHashAfter: options?.planHashAfter });
+}
+async function replayFromLedger(directory, options) {
+  const { plan } = await replayFromLedgerWithStatus(directory, options);
+  return plan;
+}
+async function replayFromLedgerWithStatus(directory, _options) {
+  const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
+  if (events.length === 0) {
+    return { plan: null, truncated, badSuffix };
+  }
+  if (truncated && badSuffix !== null) {
+    await quarantineLedgerSuffix(directory, badSuffix);
+  }
+  const plan = reconstructPlanFromEvents(directory, events);
+  return { plan, truncated, badSuffix };
+}
+function reconstructPlanFromEvents(directory, events) {
+  const targetPlanId = events[0].plan_id;
+  const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
+  {
+    const snapshotEvents = relevantEvents.filter((e) => e.event_type === "snapshot");
+    if (snapshotEvents.length > 0) {
+      const latestSnapshotEvent = snapshotEvents[snapshotEvents.length - 1];
+      const snapshotPayload = latestSnapshotEvent.payload;
+      let plan2 = snapshotPayload.plan;
+      const eventsAfterSnapshot = relevantEvents.filter((e) => e.seq > latestSnapshotEvent.seq);
+      for (const event of eventsAfterSnapshot) {
+        plan2 = applyEventToPlan(plan2, event);
+        if (plan2 === null) {
+          return null;
+        }
+      }
+      return plan2;
+    }
+  }
+  const createdEvent = relevantEvents.find((e) => e.event_type === "plan_created");
+  if (createdEvent?.payload && typeof createdEvent.payload === "object" && "plan" in createdEvent.payload) {
+    const parseResult = PlanSchema.safeParse(createdEvent.payload.plan);
+    if (parseResult.success) {
+      let plan2 = parseResult.data;
+      const eventsAfterCreated = relevantEvents.filter((e) => e.seq > createdEvent.seq);
+      for (const event of eventsAfterCreated) {
+        if (plan2 === null)
+          return null;
+        plan2 = applyEventToPlan(plan2, event);
+      }
+      return plan2;
+    }
+  }
+  const planJsonPath = getPlanJsonPath(directory);
+  if (!fs.existsSync(planJsonPath)) {
+    return null;
+  }
+  let plan;
+  try {
+    const content = fs.readFileSync(planJsonPath, "utf8");
+    plan = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  for (const event of relevantEvents) {
+    if (plan === null) {
+      return null;
+    }
+    plan = applyEventToPlan(plan, event);
+  }
+  return plan;
+}
+function applyEventToPlan(plan, event) {
+  switch (event.event_type) {
+    case "plan_created":
+      if (event.payload && typeof event.payload === "object" && "plan" in event.payload) {
+        const parsed = PlanSchema.safeParse(event.payload.plan);
+        if (parsed.success)
+          return parsed.data;
+      }
+      return plan;
+    case "task_status_changed":
+      if (event.task_id && event.to_status) {
+        const parseResult = TaskStatusSchema.safeParse(event.to_status);
+        if (!parseResult.success) {
+          return plan;
+        }
+        for (const phase of plan.phases) {
+          const task = phase.tasks.find((t) => t.id === event.task_id);
+          if (task) {
+            task.status = parseResult.data;
+            break;
+          }
+        }
+      }
+      return plan;
+    case "phase_completed":
+      if (event.phase_id) {
+        const phase = plan.phases.find((p) => p.id === event.phase_id);
+        if (phase) {
+          phase.status = "complete";
+        }
+      }
+      return plan;
+    case "plan_exported":
+      return plan;
+    case "task_added":
+      return plan;
+    case "task_removed":
+      if (event.task_id) {
+        for (const phase of plan.phases) {
+          const idx = phase.tasks.findIndex((t) => t.id === event.task_id);
+          if (idx !== -1) {
+            phase.tasks.splice(idx, 1);
+            break;
+          }
+        }
+      }
+      return plan;
+    case "task_updated":
+      return plan;
+    case "plan_rebuilt":
+      return plan;
+    case "task_reordered":
+      return plan;
+    case "snapshot":
+      return plan;
+    case "plan_reset":
+      return null;
+    case "execution_profile_set": {
+      const rawProfile = event.payload?.execution_profile;
+      if (rawProfile !== undefined) {
+        const parsed = ExecutionProfileSchema.safeParse(rawProfile);
+        if (parsed.success) {
+          return { ...plan, execution_profile: parsed.data };
+        }
+      }
+      return plan;
+    }
+    case "execution_profile_locked": {
+      if (plan.execution_profile) {
+        return {
+          ...plan,
+          execution_profile: { ...plan.execution_profile, locked: true }
+        };
+      }
+      return plan;
+    }
+    default:
+      throw new Error(`applyEventToPlan: unhandled event type "${event.event_type}" at seq ${event.seq}`);
+  }
+}
+async function readLedgerEventsWithIntegrity(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs.existsSync(ledgerPath)) {
+    return { events: [], truncated: false, badSuffix: null };
+  }
+  try {
+    const content = fs.readFileSync(ledgerPath, "utf8");
+    const lines = content.split(`
+`);
+    const events = [];
+    let truncated = false;
+    let badSuffix = null;
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "") {
+        continue;
+      }
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+      } catch {
+        truncated = true;
+        badSuffix = lines.slice(i).join(`
+`);
+        break;
+      }
+    }
+    events.sort((a, b) => a.seq - b.seq);
+    return { events, truncated, badSuffix };
+  } catch {
+    return { events: [], truncated: false, badSuffix: null };
+  }
+}
+async function quarantineLedgerSuffix(directory, badSuffix) {
+  let salvagedCount = 0;
+  for (const line of badSuffix.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      JSON.parse(line);
+      salvagedCount++;
+    } catch {}
+  }
+  try {
+    const hash = crypto.createHash("sha256").update(badSuffix, "utf8").digest("hex").slice(0, 12);
+    const swarmDir = path.join(directory, ".swarm");
+    try {
+      const existing = fs.readdirSync(swarmDir).filter((name) => name.startsWith("plan-ledger.quarantine.") && name.endsWith(`.${hash}`));
+      for (const name of existing) {
+        const existingPath = path.join(swarmDir, name);
+        if (fs.readFileSync(existingPath, "utf8") === badSuffix) {
+          return { path: existingPath, salvagedCount };
+        }
+      }
+    } catch {}
+    const quarantinePath = path.join(swarmDir, `plan-ledger.quarantine.${Date.now()}.${hash}`);
+    fs.writeFileSync(quarantinePath, badSuffix, "utf8");
+    log(`[ledger] Corrupted suffix quarantined to ${path.relative(directory, quarantinePath)} (salvageable events: ${salvagedCount})`);
+    return { path: quarantinePath, salvagedCount };
+  } catch {
+    return { path: null, salvagedCount };
+  }
+}
+async function loadLastApprovedPlan(directory, expectedPlanId) {
+  const events = await readLedgerEvents(directory);
+  return findLastApprovedSnapshot(events, expectedPlanId);
+}
+function findLastApprovedSnapshot(events, expectedPlanId, extraFilter) {
+  if (events.length === 0) {
+    return null;
+  }
+  for (let i = events.length - 1;i >= 0; i--) {
+    const event = events[i];
+    if (event.event_type !== "snapshot")
+      continue;
+    if (event.source !== "critic_approved")
+      continue;
+    if (expectedPlanId !== undefined && event.plan_id !== expectedPlanId) {
+      continue;
+    }
+    const payload = event.payload;
+    if (!payload || typeof payload !== "object" || !payload.plan) {
+      continue;
+    }
+    if (expectedPlanId !== undefined) {
+      const payloadPlanId = derivePlanId(payload.plan);
+      if (payloadPlanId !== expectedPlanId) {
+        continue;
+      }
+    }
+    if (extraFilter && !extraFilter(payload)) {
+      continue;
+    }
+    return {
+      plan: payload.plan,
+      seq: event.seq,
+      timestamp: event.timestamp,
+      approval: payload.approval,
+      payloadHash: payload.payload_hash
+    };
+  }
+  return null;
+}
+
+export { derivePlanId, LedgerStaleWriterError, computePlanHash, computePlanStructureHash, computeCurrentPlanHash, ledgerExists, getLatestLedgerSeq, readLedgerEvents, initLedger, appendLedgerEvent, takeSnapshotWithRetry, takeSnapshotEvent, replayFromLedger, replayFromLedgerWithStatus, loadLastApprovedPlan };