trellis 1.0.8 → 2.0.6

package/dist/index-3s0eak0p.js

@@ -0,0 +1,1556 @@
+// @bun
+import {
+  createVcsOp,
+  criterionEntityId,
+  decisionEntityId,
+  dirEntityId,
+  fileEntityId,
+  issueEntityId
+} from "./index-fd4e26s4.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/vcs/decompose.ts
+import { dirname } from "path";
+function decompose(op) {
+  const result = {
+    addFacts: [],
+    addLinks: [],
+    deleteFacts: [],
+    deleteLinks: []
+  };
+  const vcs = op.vcs;
+  if (!vcs)
+    return result;
+  switch (op.kind) {
+    case "vcs:fileAdd": {
+      if (!vcs.filePath)
+        break;
+      const eid = fileEntityId(vcs.filePath);
+      const dir = dirname(vcs.filePath);
+      const did = dirEntityId(dir === "." ? "" : dir);
+      result.addFacts.push({ e: eid, a: "type", v: "FileNode" }, { e: eid, a: "path", v: vcs.filePath });
+      if (vcs.contentHash) {
+        result.addFacts.push({ e: eid, a: "contentHash", v: vcs.contentHash });
+      }
+      if (vcs.size !== undefined) {
+        result.addFacts.push({ e: eid, a: "size", v: vcs.size });
+      }
+      if (vcs.language) {
+        result.addFacts.push({ e: eid, a: "language", v: vcs.language });
+      }
+      result.addFacts.push({ e: eid, a: "lastModified", v: op.timestamp });
+      result.addFacts.push({ e: did, a: "type", v: "DirectoryNode" }, { e: did, a: "path", v: dir === "." ? "" : dir });
+      result.addLinks.push({ e1: did, a: "contains", e2: eid });
+      break;
+    }
+    case "vcs:fileModify": {
+      if (!vcs.filePath)
+        break;
+      const eid = fileEntityId(vcs.filePath);
+      if (vcs.oldContentHash) {
+        result.deleteFacts.push({
+          e: eid,
+          a: "contentHash",
+          v: vcs.oldContentHash
+        });
+      }
+      if (vcs.contentHash) {
+        result.addFacts.push({ e: eid, a: "contentHash", v: vcs.contentHash });
+      }
+      if (vcs.size !== undefined) {
+        result.addFacts.push({ e: eid, a: "size", v: vcs.size });
+      }
+      result.addFacts.push({ e: eid, a: "lastModified", v: op.timestamp });
+      break;
+    }
+    case "vcs:fileDelete": {
+      if (!vcs.filePath)
+        break;
+      const eid = fileEntityId(vcs.filePath);
+      const dir = dirname(vcs.filePath);
+      const did = dirEntityId(dir === "." ? "" : dir);
+      result.deleteFacts.push({ e: eid, a: "type", v: "FileNode" }, { e: eid, a: "path", v: vcs.filePath });
+      if (vcs.contentHash) {
+        result.deleteFacts.push({
+          e: eid,
+          a: "contentHash",
+          v: vcs.contentHash
+        });
+      }
+      result.deleteLinks.push({ e1: did, a: "contains", e2: eid });
+      break;
+    }
+    case "vcs:fileRename": {
+      if (!vcs.filePath || !vcs.oldFilePath)
+        break;
+      const eid = fileEntityId(vcs.oldFilePath);
+      const oldDir = dirname(vcs.oldFilePath);
+      const newDir = dirname(vcs.filePath);
+      const oldDid = dirEntityId(oldDir === "." ? "" : oldDir);
+      const newDid = dirEntityId(newDir === "." ? "" : newDir);
+      result.deleteFacts.push({ e: eid, a: "path", v: vcs.oldFilePath });
+      result.addFacts.push({ e: eid, a: "path", v: vcs.filePath });
+      result.addFacts.push({ e: eid, a: "lastModified", v: op.timestamp });
+      result.deleteLinks.push({ e1: oldDid, a: "contains", e2: eid });
+      result.addFacts.push({ e: newDid, a: "type", v: "DirectoryNode" }, { e: newDid, a: "path", v: newDir === "." ? "" : newDir });
+      result.addLinks.push({ e1: newDid, a: "contains", e2: eid });
+      break;
+    }
+    case "vcs:branchCreate": {
+      if (!vcs.branchName)
+        break;
+      const bid = `branch:${vcs.branchName}`;
+      result.addFacts.push({ e: bid, a: "type", v: "Branch" }, { e: bid, a: "name", v: vcs.branchName }, { e: bid, a: "createdAt", v: op.timestamp }, { e: bid, a: "createdBy", v: op.agentId });
+      if (vcs.targetOpHash) {
+        result.addFacts.push({ e: bid, a: "headOpHash", v: vcs.targetOpHash });
+      }
+      if (vcs.baseBranch) {
+        result.addLinks.push({
+          e1: bid,
+          a: "forkedFrom",
+          e2: `branch:${vcs.baseBranch}`
+        });
+      }
+      break;
+    }
+    case "vcs:branchDelete": {
+      if (!vcs.branchName)
+        break;
+      const bid = `branch:${vcs.branchName}`;
+      result.deleteFacts.push({ e: bid, a: "type", v: "Branch" }, { e: bid, a: "name", v: vcs.branchName });
+      break;
+    }
+    case "vcs:branchAdvance": {
+      if (!vcs.branchName || !vcs.targetOpHash)
+        break;
+      const bid = `branch:${vcs.branchName}`;
+      result.addFacts.push({ e: bid, a: "headOpHash", v: vcs.targetOpHash });
+      break;
+    }
+    case "vcs:milestoneCreate": {
+      if (!vcs.milestoneId)
+        break;
+      const mid = vcs.milestoneId;
+      result.addFacts.push({ e: mid, a: "type", v: "Milestone" }, { e: mid, a: "createdAt", v: op.timestamp }, { e: mid, a: "createdBy", v: op.agentId });
+      if (vcs.message) {
+        result.addFacts.push({ e: mid, a: "message", v: vcs.message });
+      }
+      if (vcs.fromOpHash) {
+        result.addFacts.push({ e: mid, a: "fromOpHash", v: vcs.fromOpHash });
+      }
+      if (vcs.toOpHash) {
+        result.addFacts.push({ e: mid, a: "toOpHash", v: vcs.toOpHash });
+      }
+      break;
+    }
+    case "vcs:checkpointCreate": {
+      const cid = `checkpoint:${op.hash}`;
+      result.addFacts.push({ e: cid, a: "type", v: "Checkpoint" }, { e: cid, a: "createdAt", v: op.timestamp }, { e: cid, a: "atOpHash", v: op.hash });
+      if (vcs.trigger) {
+        result.addFacts.push({ e: cid, a: "trigger", v: vcs.trigger });
+      }
+      break;
+    }
+    case "vcs:issueCreate": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      result.addFacts.push({ e: eid, a: "type", v: "Issue" }, { e: eid, a: "status", v: vcs.issueStatus ?? "backlog" }, { e: eid, a: "createdAt", v: op.timestamp }, { e: eid, a: "createdBy", v: op.agentId });
+      if (vcs.issueTitle) {
+        result.addFacts.push({ e: eid, a: "title", v: vcs.issueTitle });
+      }
+      if (vcs.issueDescription) {
+        result.addFacts.push({
+          e: eid,
+          a: "description",
+          v: vcs.issueDescription
+        });
+      }
+      if (vcs.issuePriority) {
+        result.addFacts.push({ e: eid, a: "priority", v: vcs.issuePriority });
+      }
+      if (vcs.issueLabels && vcs.issueLabels.length > 0) {
+        result.addFacts.push({
+          e: eid,
+          a: "labels",
+          v: vcs.issueLabels.join(",")
+        });
+      }
+      if (vcs.issueAssignee) {
+        result.addFacts.push({ e: eid, a: "assignee", v: vcs.issueAssignee });
+      }
+      if (vcs.parentIssueId) {
+        result.addLinks.push({
+          e1: eid,
+          a: "childOf",
+          e2: issueEntityId(vcs.parentIssueId)
+        });
+      }
+      break;
+    }
+    case "vcs:issueUpdate": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      if (vcs.issueStatus) {
+        result.addFacts.push({ e: eid, a: "status", v: vcs.issueStatus });
+      }
+      if (vcs.issuePriority) {
+        result.addFacts.push({ e: eid, a: "priority", v: vcs.issuePriority });
+      }
+      if (vcs.issueLabels) {
+        result.addFacts.push({
+          e: eid,
+          a: "labels",
+          v: vcs.issueLabels.join(",")
+        });
+      }
+      if (vcs.issueTitle) {
+        result.addFacts.push({ e: eid, a: "title", v: vcs.issueTitle });
+      }
+      if (vcs.issueAssignee) {
+        result.addFacts.push({ e: eid, a: "assignee", v: vcs.issueAssignee });
+      }
+      if (vcs.issueDescription !== undefined) {
+        result.addFacts.push({
+          e: eid,
+          a: "description",
+          v: vcs.issueDescription
+        });
+      }
+      break;
+    }
+    case "vcs:issueStart": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      result.addFacts.push({ e: eid, a: "status", v: "in_progress" }, { e: eid, a: "startedAt", v: op.timestamp });
+      if (vcs.issueAssignee) {
+        result.addFacts.push({ e: eid, a: "assignee", v: vcs.issueAssignee });
+      }
+      if (vcs.branchName) {
+        result.addLinks.push({
+          e1: eid,
+          a: "trackedOn",
+          e2: `branch:${vcs.branchName}`
+        });
+      }
+      break;
+    }
+    case "vcs:issuePause": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      result.addFacts.push({ e: eid, a: "status", v: "paused" }, { e: eid, a: "pausedAt", v: op.timestamp });
+      if (vcs.pauseNote) {
+        result.addFacts.push({ e: eid, a: "pauseNote", v: vcs.pauseNote });
+      }
+      break;
+    }
+    case "vcs:issueResume": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      result.addFacts.push({ e: eid, a: "status", v: "in_progress" }, { e: eid, a: "resumedAt", v: op.timestamp }, { e: eid, a: "pauseNote", v: "" });
+      break;
+    }
+    case "vcs:issueClose": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      result.addFacts.push({ e: eid, a: "status", v: "closed" }, { e: eid, a: "closedAt", v: op.timestamp });
+      break;
+    }
+    case "vcs:issueReopen": {
+      if (!vcs.issueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      result.addFacts.push({ e: eid, a: "status", v: "queue" });
+      break;
+    }
+    case "vcs:criterionAdd": {
+      if (!vcs.criterionId || !vcs.issueId)
+        break;
+      const ceid = vcs.criterionId;
+      result.addFacts.push({ e: ceid, a: "type", v: "Criterion" }, { e: ceid, a: "status", v: "pending" }, { e: ceid, a: "createdAt", v: op.timestamp });
+      if (vcs.criterionDescription) {
+        result.addFacts.push({
+          e: ceid,
+          a: "description",
+          v: vcs.criterionDescription
+        });
+      }
+      if (vcs.criterionCommand) {
+        result.addFacts.push({
+          e: ceid,
+          a: "command",
+          v: vcs.criterionCommand
+        });
+      }
+      result.addLinks.push({
+        e1: ceid,
+        a: "criterionOf",
+        e2: issueEntityId(vcs.issueId)
+      });
+      break;
+    }
+    case "vcs:criterionUpdate": {
+      if (!vcs.criterionId)
+        break;
+      const ceid = vcs.criterionId;
+      if (vcs.criterionStatus) {
+        result.addFacts.push({ e: ceid, a: "status", v: vcs.criterionStatus });
+      }
+      if (vcs.criterionOutput) {
+        result.addFacts.push({
+          e: ceid,
+          a: "lastOutput",
+          v: vcs.criterionOutput
+        });
+      }
+      result.addFacts.push({ e: ceid, a: "lastRunAt", v: op.timestamp });
+      break;
+    }
+    case "vcs:issueBlock": {
+      if (!vcs.issueId || !vcs.blockedByIssueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      const blockerEid = issueEntityId(vcs.blockedByIssueId);
+      result.addLinks.push({ e1: eid, a: "blockedBy", e2: blockerEid });
+      break;
+    }
+    case "vcs:issueUnblock": {
+      if (!vcs.issueId || !vcs.blockedByIssueId)
+        break;
+      const eid = issueEntityId(vcs.issueId);
+      const blockerEid = issueEntityId(vcs.blockedByIssueId);
+      result.deleteLinks.push({ e1: eid, a: "blockedBy", e2: blockerEid });
+      break;
+    }
+    case "vcs:decisionRecord": {
+      if (!vcs.decisionId)
+        break;
+      const did = decisionEntityId(vcs.decisionId);
+      result.addFacts.push({ e: did, a: "type", v: "Decision" }, { e: did, a: "createdAt", v: op.timestamp }, { e: did, a: "createdBy", v: op.agentId });
+      if (vcs.decisionToolName) {
+        result.addFacts.push({
+          e: did,
+          a: "toolName",
+          v: vcs.decisionToolName
+        });
+      }
+      if (vcs.decisionToolInput) {
+        result.addFacts.push({
+          e: did,
+          a: "toolInput",
+          v: vcs.decisionToolInput
+        });
+      }
+      if (vcs.decisionToolOutput) {
+        result.addFacts.push({
+          e: did,
+          a: "outputSummary",
+          v: vcs.decisionToolOutput
+        });
+      }
+      if (vcs.decisionContext) {
+        result.addFacts.push({ e: did, a: "context", v: vcs.decisionContext });
+      }
+      if (vcs.decisionRationale) {
+        result.addFacts.push({
+          e: did,
+          a: "rationale",
+          v: vcs.decisionRationale
+        });
+      }
+      if (vcs.decisionAlternatives) {
+        result.addFacts.push({
+          e: did,
+          a: "alternatives",
+          v: vcs.decisionAlternatives
+        });
+      }
+      break;
+    }
+  }
+  return result;
+}
+
+// src/vcs/blob-store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+class BlobStore {
+  blobDir;
+  constructor(trellisDir) {
+    this.blobDir = join(trellisDir, "blobs");
+    if (!existsSync(this.blobDir)) {
+      mkdirSync(this.blobDir, { recursive: true });
+    }
+  }
+  async put(content) {
+    const hash = await this.hash(content);
+    const blobPath = join(this.blobDir, hash);
+    if (!existsSync(blobPath)) {
+      writeFileSync(blobPath, content);
+    }
+    return hash;
+  }
+  putSync(content) {
+    const hash = this.hashSync(content);
+    const blobPath = join(this.blobDir, hash);
+    if (!existsSync(blobPath)) {
+      writeFileSync(blobPath, content);
+    }
+    return hash;
+  }
+  get(hash) {
+    const blobPath = join(this.blobDir, hash);
+    if (!existsSync(blobPath)) {
+      return null;
+    }
+    return readFileSync(blobPath);
+  }
+  has(hash) {
+    return existsSync(join(this.blobDir, hash));
+  }
+  async hash(content) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", content);
+    return this.hexFromBuffer(hashBuffer);
+  }
+  hashSync(content) {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(content);
+    return hasher.digest("hex");
+  }
+  count() {
+    try {
+      const { readdirSync } = __require("fs");
+      return readdirSync(this.blobDir).length;
+    } catch {
+      return 0;
+    }
+  }
+  totalSize() {
+    try {
+      const { readdirSync, statSync } = __require("fs");
+      const files = readdirSync(this.blobDir);
+      return files.reduce((sum, f) => {
+        try {
+          return sum + statSync(join(this.blobDir, f)).size;
+        } catch {
+          return sum;
+        }
+      }, 0);
+    } catch {
+      return 0;
+    }
+  }
+  hexFromBuffer(buffer) {
+    return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+}
+
+// src/vcs/branch.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+async function createBranch(ctx, name, currentBranch) {
+  const existing = ctx.store.getFactsByAttribute("type").filter((f) => f.v === "Branch" && f.e === `branch:${name}`);
+  if (existing.length > 0) {
+    throw new Error(`Branch '${name}' already exists`);
+  }
+  const op = await createVcsOp("vcs:branchCreate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      branchName: name,
+      baseBranch: currentBranch,
+      targetOpHash: ctx.getLastOp()?.hash
+    }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+function switchBranch(ctx, name) {
+  const branchFacts = ctx.store.getFactsByEntity(`branch:${name}`).filter((f) => f.a === "type" && f.v === "Branch");
+  if (branchFacts.length === 0) {
+    throw new Error(`Branch '${name}' does not exist`);
+  }
+}
+function listBranches(ctx, currentBranch) {
+  const branchFacts = ctx.store.getFactsByAttribute("type").filter((f) => f.v === "Branch");
+  return branchFacts.map((f) => {
+    const nameFact = ctx.store.getFactsByEntity(f.e).find((ef) => ef.a === "name");
+    const createdFact = ctx.store.getFactsByEntity(f.e).find((ef) => ef.a === "createdAt");
+    const name = nameFact?.v ?? f.e.replace("branch:", "");
+    return {
+      name,
+      isCurrent: name === currentBranch,
+      createdAt: createdFact?.v
+    };
+  });
+}
+async function deleteBranch(ctx, name, currentBranch) {
+  if (name === currentBranch) {
+    throw new Error(`Cannot delete the current branch '${name}'`);
+  }
+  const branchFacts = ctx.store.getFactsByEntity(`branch:${name}`).filter((f) => f.a === "type" && f.v === "Branch");
+  if (branchFacts.length === 0) {
+    throw new Error(`Branch '${name}' does not exist`);
+  }
+  const op = await createVcsOp("vcs:branchDelete", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { branchName: name }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+function saveBranchState(rootPath, state) {
+  const statePath = join2(rootPath, ".trellis", "state.json");
+  writeFileSync2(statePath, JSON.stringify(state));
+}
+function loadBranchState(rootPath) {
+  const statePath = join2(rootPath, ".trellis", "state.json");
+  if (existsSync2(statePath)) {
+    try {
+      const raw = readFileSync2(statePath, "utf-8");
+      const state = JSON.parse(raw);
+      if (state.currentBranch) {
+        return { currentBranch: state.currentBranch };
+      }
+    } catch {}
+  }
+  return { currentBranch: "main" };
+}
+
+// src/vcs/milestone.ts
+async function createMilestone(ctx, message, opts) {
+  const ops = ctx.readAllOps();
+  const toOpHash = opts?.toOpHash ?? ops[ops.length - 1]?.hash;
+  let fromOpHash = opts?.fromOpHash;
+  if (!fromOpHash) {
+    const milestones = ops.filter((o) => o.kind === "vcs:milestoneCreate");
+    if (milestones.length > 0) {
+      const lastMilestone = milestones[milestones.length - 1];
+      fromOpHash = lastMilestone.vcs?.toOpHash ?? lastMilestone.hash;
+    } else {
+      fromOpHash = ops[0]?.hash;
+    }
+  }
+  const idBase = `${message}:${Date.now()}`;
+  const msgUint8 = new TextEncoder().encode(idBase);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  const milestoneId = `milestone:${hashHex.slice(0, 12)}`;
+  const fromIdx = ops.findIndex((o) => o.hash === fromOpHash);
+  const toIdx = ops.findIndex((o) => o.hash === toOpHash);
+  const rangeOps = fromIdx >= 0 && toIdx >= 0 ? ops.slice(fromIdx, toIdx + 1) : ops;
+  const affectedFiles = [
+    ...new Set(rangeOps.filter((o) => o.vcs?.filePath).map((o) => o.vcs.filePath))
+  ];
+  const op = await createVcsOp("vcs:milestoneCreate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      milestoneId,
+      message,
+      fromOpHash,
+      toOpHash
+    }
+  });
+  ctx.applyOp(op);
+  for (const file of affectedFiles) {
+    ctx.store.addFacts([{ e: milestoneId, a: "affectsFile", v: file }]);
+  }
+  return op;
+}
+function listMilestones(ctx) {
+  const milestoneFacts = ctx.store.getFactsByAttribute("type").filter((f) => f.v === "Milestone");
+  return milestoneFacts.map((f) => {
+    const facts = ctx.store.getFactsByEntity(f.e);
+    const get = (attr) => facts.find((ef) => ef.a === attr)?.v;
+    const affectedFiles = facts.filter((ef) => ef.a === "affectsFile").map((ef) => ef.v);
+    return {
+      id: f.e,
+      message: get("message"),
+      createdAt: get("createdAt"),
+      createdBy: get("createdBy"),
+      fromOpHash: get("fromOpHash"),
+      toOpHash: get("toOpHash"),
+      affectedFiles
+    };
+  });
+}
+
+// src/vcs/checkpoint.ts
+async function createCheckpoint(ctx, trigger = "manual") {
+  const op = await createVcsOp("vcs:checkpointCreate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { trigger }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+function listCheckpoints(ctx) {
+  const cpFacts = ctx.store.getFactsByAttribute("type").filter((f) => f.v === "Checkpoint");
+  return cpFacts.map((f) => {
+    const facts = ctx.store.getFactsByEntity(f.e);
+    const get = (attr) => facts.find((ef) => ef.a === attr)?.v;
+    return {
+      id: f.e,
+      createdAt: get("createdAt"),
+      trigger: get("trigger"),
+      atOpHash: get("atOpHash")
+    };
+  });
+}
+
+// src/vcs/diff.ts
+function diffFileStates(stateA, stateB, blobStore) {
+  const diffs = [];
+  for (const [path, bState] of stateB) {
+    if (bState.deleted)
+      continue;
+    const aState = stateA.get(path);
+    if (!aState || aState.deleted) {
+      diffs.push({
+        kind: "fileAdded",
+        path,
+        newContentHash: bState.contentHash
+      });
+    } else if (aState.contentHash !== bState.contentHash) {
+      const diff = {
+        kind: "fileModified",
+        path,
+        oldContentHash: aState.contentHash,
+        newContentHash: bState.contentHash
+      };
+      if (blobStore && aState.contentHash && bState.contentHash) {
+        const oldContent = blobStore.get(aState.contentHash);
+        const newContent = blobStore.get(bState.contentHash);
+        if (oldContent && newContent) {
+          diff.unifiedDiff = generateUnifiedDiff(path, oldContent.toString("utf-8"), newContent.toString("utf-8"));
+        }
+      }
+      diffs.push(diff);
+    }
+  }
+  for (const [path, aState] of stateA) {
+    if (aState.deleted)
+      continue;
+    const bState = stateB.get(path);
+    if (!bState || bState.deleted) {
+      diffs.push({
+        kind: "fileDeleted",
+        path,
+        oldContentHash: aState.contentHash
+      });
+    }
+  }
+  const stats = {
+    added: diffs.filter((d) => d.kind === "fileAdded").length,
+    modified: diffs.filter((d) => d.kind === "fileModified").length,
+    removed: diffs.filter((d) => d.kind === "fileDeleted").length,
+    renamed: diffs.filter((d) => d.kind === "fileRenamed").length
+  };
+  return {
+    diffs,
+    filesChanged: diffs.map((d) => d.path),
+    stats
+  };
+}
+function buildFileStateAtOp(ops, atOpHash) {
+  const state = new Map;
+  for (const op of ops) {
+    if (op.vcs?.filePath) {
+      switch (op.kind) {
+        case "vcs:fileAdd":
+        case "vcs:fileModify":
+          state.set(op.vcs.filePath, { contentHash: op.vcs.contentHash });
+          break;
+        case "vcs:fileDelete":
+          state.set(op.vcs.filePath, { deleted: true });
+          break;
+        case "vcs:fileRename":
+          if (op.vcs.oldFilePath) {
+            state.set(op.vcs.oldFilePath, { deleted: true });
+          }
+          state.set(op.vcs.filePath, { contentHash: op.vcs.contentHash });
+          break;
+      }
+    }
+    if (atOpHash && op.hash === atOpHash)
+      break;
+  }
+  return state;
+}
+function diffOpRange(ops, fromHash, toHash, blobStore) {
+  const stateA = buildFileStateAtOp(ops, fromHash);
+  const stateB = buildFileStateAtOp(ops, toHash);
+  return diffFileStates(stateA, stateB, blobStore);
+}
+function generateUnifiedDiff(filePath, oldText, newText, contextLines = 3) {
+  const oldLines = oldText.split(`
+`);
+  const newLines = newText.split(`
+`);
+  const edits = myersDiff(oldLines, newLines);
+  const hunks = buildHunks(edits, contextLines);
+  if (hunks.length === 0)
+    return "";
+  const lines = [`--- a/${filePath}`, `+++ b/${filePath}`];
+  for (const hunk of hunks) {
+    lines.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`);
+    for (const edit of hunk.edits) {
+      switch (edit.kind) {
+        case "equal":
+          lines.push(` ${edit.line}`);
+          break;
+        case "delete":
+          lines.push(`-${edit.line}`);
+          break;
+        case "insert":
+          lines.push(`+${edit.line}`);
+          break;
+      }
+    }
+  }
+  return lines.join(`
+`);
+}
+function myersDiff(oldLines, newLines) {
+  const n = oldLines.length;
+  const m = newLines.length;
+  if (n === 0 && m === 0)
+    return [];
+  if (n === 0)
+    return newLines.map((line) => ({ kind: "insert", line }));
+  if (m === 0)
+    return oldLines.map((line) => ({ kind: "delete", line }));
+  const max = n + m;
+  const size = 2 * max + 1;
+  const v = new Int32Array(size);
+  const trace = [];
+  const off = max;
+  outer:
+    for (let d = 0;d <= max; d++) {
+      trace.push(v.slice());
+      for (let k = -d;k <= d; k += 2) {
+        let x2;
+        if (k === -d || k !== d && v[k - 1 + off] < v[k + 1 + off]) {
+          x2 = v[k + 1 + off];
+        } else {
+          x2 = v[k - 1 + off] + 1;
+        }
+        let y2 = x2 - k;
+        while (x2 < n && y2 < m && oldLines[x2] === newLines[y2]) {
+          x2++;
+          y2++;
+        }
+        v[k + off] = x2;
+        if (x2 >= n && y2 >= m)
+          break outer;
+      }
+    }
+  let x = n;
+  let y = m;
+  const edits = [];
+  for (let d = trace.length - 1;d >= 0; d--) {
+    const tv = trace[d];
+    const k = x - y;
+    let prevK;
+    if (d === 0) {
+      while (x > 0 && y > 0) {
+        x--;
+        y--;
+        edits.push({ kind: "equal", line: oldLines[x] });
+      }
+      break;
+    }
+    if (k === -d || k !== d && tv[k - 1 + off] < tv[k + 1 + off]) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevX = tv[prevK + off];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      x--;
+      y--;
+      edits.push({ kind: "equal", line: oldLines[x] });
+    }
+    if (prevK === k + 1) {
+      y--;
+      edits.push({ kind: "insert", line: newLines[y] });
+    } else {
+      x--;
+      edits.push({ kind: "delete", line: oldLines[x] });
+    }
+  }
+  edits.reverse();
+  return edits;
+}
+function buildHunks(edits, contextLines) {
+  if (edits.length === 0)
+    return [];
+  const changeIndices = [];
+  for (let i = 0;i < edits.length; i++) {
+    if (edits[i].kind !== "equal") {
+      changeIndices.push(i);
+    }
+  }
+  if (changeIndices.length === 0)
+    return [];
+  const hunks = [];
+  let hunkStart = Math.max(0, changeIndices[0] - contextLines);
+  let hunkEnd = Math.min(edits.length - 1, changeIndices[0] + contextLines);
+  for (let i = 1;i < changeIndices.length; i++) {
+    const changeStart = changeIndices[i] - contextLines;
+    const changeEnd = Math.min(edits.length - 1, changeIndices[i] + contextLines);
+    if (changeStart <= hunkEnd + 1) {
+      hunkEnd = changeEnd;
+    } else {
+      hunks.push(createHunk(edits, hunkStart, hunkEnd));
+      hunkStart = changeStart;
+      hunkEnd = changeEnd;
+    }
+  }
+  hunks.push(createHunk(edits, hunkStart, hunkEnd));
+  return hunks;
+}
+function createHunk(edits, start, end) {
+  const hunkEdits = edits.slice(start, end + 1);
+  let oldLine = 1;
+  let newLine = 1;
+  for (let i = 0;i < start; i++) {
+    if (edits[i].kind === "equal" || edits[i].kind === "delete")
+      oldLine++;
+    if (edits[i].kind === "equal" || edits[i].kind === "insert")
+      newLine++;
+  }
+  let oldCount = 0;
+  let newCount = 0;
+  for (const edit of hunkEdits) {
+    if (edit.kind === "equal" || edit.kind === "delete")
+      oldCount++;
+    if (edit.kind === "equal" || edit.kind === "insert")
+      newCount++;
+  }
+  return {
+    oldStart: oldLine,
+    oldCount,
+    newStart: newLine,
+    newCount,
+    edits: hunkEdits
+  };
+}
+
+// src/vcs/merge.ts
+function threeWayMerge(base, ours, theirs, blobStore) {
+  const mergedFiles = new Map;
+  const conflicts = [];
+  const allPaths = new Set;
+  for (const [p, s] of base)
+    if (!s.deleted)
+      allPaths.add(p);
+  for (const [p, s] of ours)
+    if (!s.deleted)
+      allPaths.add(p);
+  for (const [p, s] of theirs)
+    if (!s.deleted)
+      allPaths.add(p);
+  for (const [p, s] of ours)
+    if (s.deleted)
+      allPaths.add(p);
+  for (const [p, s] of theirs)
+    if (s.deleted)
+      allPaths.add(p);
+  for (const path of allPaths) {
+    const b = base.get(path);
+    const o = ours.get(path);
+    const t = theirs.get(path);
+    const baseExists = b && !b.deleted;
+    const oursExists = o && !o.deleted;
+    const theirsExists = t && !t.deleted;
+    const baseHash = baseExists ? b.contentHash : undefined;
+    const oursHash = oursExists ? o.contentHash : undefined;
+    const theirsHash = theirsExists ? t.contentHash : undefined;
+    if (oursHash === theirsHash) {
+      continue;
+    }
+    if (theirsHash === baseHash && oursHash !== baseHash) {
+      if (!oursExists) {
+        mergedFiles.set(path, null);
+      }
+      continue;
+    }
+    if (oursHash === baseHash && theirsHash !== baseHash) {
+      if (!theirsExists) {
+        mergedFiles.set(path, null);
+      } else if (theirsHash && blobStore) {
+        const content = blobStore.get(theirsHash);
+        if (content) {
+          mergedFiles.set(path, content.toString("utf-8"));
+        }
+      }
+      continue;
+    }
+    if (!baseExists && oursExists && theirsExists) {
+      if (oursHash === theirsHash) {
+        continue;
+      }
+      const oursContent = oursHash && blobStore ? blobStore.get(oursHash)?.toString("utf-8") : undefined;
+      const theirsContent = theirsHash && blobStore ? blobStore.get(theirsHash)?.toString("utf-8") : undefined;
+      if (oursContent !== undefined && theirsContent !== undefined) {
+        const textResult = threeWayTextMerge("", oursContent, theirsContent);
+        if (textResult.clean) {
+          mergedFiles.set(path, textResult.merged);
+          continue;
+        }
+        conflicts.push({
+          path,
+          kind: "add-add",
+          ours: oursContent,
+          theirs: theirsContent,
+          mergedWithMarkers: textResult.merged
+        });
+      } else {
+        conflicts.push({ path, kind: "add-add", ours: oursContent, theirs: theirsContent });
+      }
+      continue;
+    }
+    if (oursExists && !theirsExists) {
+      conflicts.push({
+        path,
+        kind: "modify-delete",
+        ours: oursHash && blobStore ? blobStore.get(oursHash)?.toString("utf-8") : undefined
+      });
+      continue;
+    }
+    if (!oursExists && theirsExists) {
+      conflicts.push({
+        path,
+        kind: "modify-delete",
+        theirs: theirsHash && blobStore ? blobStore.get(theirsHash)?.toString("utf-8") : undefined
+      });
+      continue;
+    }
+    if (oursExists && theirsExists && oursHash !== theirsHash) {
+      const baseContent = baseHash && blobStore ? blobStore.get(baseHash)?.toString("utf-8") : undefined;
+      const oursContent = oursHash && blobStore ? blobStore.get(oursHash)?.toString("utf-8") : undefined;
+      const theirsContent = theirsHash && blobStore ? blobStore.get(theirsHash)?.toString("utf-8") : undefined;
+      if (baseContent !== undefined && oursContent !== undefined && theirsContent !== undefined) {
+        const textResult = threeWayTextMerge(baseContent, oursContent, theirsContent);
+        if (textResult.clean) {
+          mergedFiles.set(path, textResult.merged);
+        } else {
+          conflicts.push({
+            path,
+            kind: "modify-modify",
+            base: baseContent,
+            ours: oursContent,
+            theirs: theirsContent,
+            mergedWithMarkers: textResult.merged
+          });
+        }
+      } else {
+        conflicts.push({
+          path,
+          kind: "modify-modify",
+          base: baseContent,
+          ours: oursContent,
+          theirs: theirsContent
+        });
+      }
+      continue;
+    }
+  }
+  const added = [...mergedFiles.values()].filter((v) => v !== null).length;
+  const deleted = [...mergedFiles.values()].filter((v) => v === null).length;
+  return {
+    clean: conflicts.length === 0,
+    mergedFiles,
+    conflicts,
+    stats: {
+      added,
+      modified: added,
+      deleted,
+      conflicted: conflicts.length
+    }
+  };
+}
+function threeWayTextMerge(baseText, oursText, theirsText) {
+  const baseLines = baseText.split(`
+`);
+  const oursLines = oursText.split(`
+`);
+  const theirsLines = theirsText.split(`
+`);
+  const oursChanges = computeLineChanges(baseLines, oursLines);
+  const theirsChanges = computeLineChanges(baseLines, theirsLines);
+  const result = [];
+  let clean = true;
+  let baseIdx = 0;
+  let oursIdx = 0;
+  let theirsIdx = 0;
+  while (baseIdx < baseLines.length || oursIdx < oursLines.length || theirsIdx < theirsLines.length) {
+    const oursChange = oursChanges.get(baseIdx);
+    const theirsChange = theirsChanges.get(baseIdx);
+    if (baseIdx >= baseLines.length) {
+      while (oursIdx < oursLines.length) {
+        result.push(oursLines[oursIdx++]);
+      }
+      while (theirsIdx < theirsLines.length) {
+        result.push(theirsLines[theirsIdx++]);
+      }
+      break;
+    }
+    if (!oursChange && !theirsChange) {
+      result.push(baseLines[baseIdx]);
+      baseIdx++;
+      oursIdx++;
+      theirsIdx++;
+    } else if (oursChange && !theirsChange) {
+      applyChange(oursChange, result);
+      baseIdx += oursChange.baseCount;
+      oursIdx += oursChange.newCount;
+      theirsIdx += oursChange.baseCount;
+    } else if (!oursChange && theirsChange) {
+      applyChange(theirsChange, result);
+      baseIdx += theirsChange.baseCount;
+      oursIdx += theirsChange.baseCount;
+      theirsIdx += theirsChange.newCount;
+    } else if (oursChange && theirsChange) {
+      if (oursChange.baseCount === theirsChange.baseCount && oursChange.newLines.join(`
+`) === theirsChange.newLines.join(`
+`)) {
+        applyChange(oursChange, result);
+        baseIdx += oursChange.baseCount;
+        oursIdx += oursChange.newCount;
+        theirsIdx += theirsChange.newCount;
+      } else {
+        clean = false;
+        result.push("<<<<<<< ours");
+        for (const line of oursChange.newLines)
+          result.push(line);
+        result.push("=======");
+        for (const line of theirsChange.newLines)
+          result.push(line);
+        result.push(">>>>>>> theirs");
+        baseIdx += Math.max(oursChange.baseCount, theirsChange.baseCount);
+        oursIdx += oursChange.newCount;
+        theirsIdx += theirsChange.newCount;
+      }
+    }
+  }
+  return { clean, merged: result.join(`
+`) };
+}
+function applyChange(change, result) {
+  for (const line of change.newLines) {
+    result.push(line);
+  }
+}
+function computeLineChanges(baseLines, newLines) {
+  const changes = new Map;
+  const matches = lcsMatch(baseLines, newLines);
+  let baseIdx = 0;
+  let newIdx = 0;
+  for (const match of matches) {
+    if (baseIdx < match.baseIdx || newIdx < match.newIdx) {
+      const baseCount = match.baseIdx - baseIdx;
+      const newCount = match.newIdx - newIdx;
+      if (baseCount > 0 || newCount > 0) {
+        changes.set(baseIdx, {
+          baseStart: baseIdx,
+          baseCount,
+          newCount,
+          newLines: newLines.slice(newIdx, newIdx + newCount)
+        });
+      }
+    }
+    baseIdx = match.baseIdx + 1;
+    newIdx = match.newIdx + 1;
+  }
+  if (baseIdx < baseLines.length || newIdx < newLines.length) {
+    const baseCount = baseLines.length - baseIdx;
+    const newCount = newLines.length - newIdx;
+    if (baseCount > 0 || newCount > 0) {
+      changes.set(baseIdx, {
+        baseStart: baseIdx,
+        baseCount,
+        newCount,
+        newLines: newLines.slice(newIdx)
+      });
+    }
+  }
+  return changes;
+}
+function lcsMatch(a, b) {
+  const n = a.length;
+  const m = b.length;
+  if (n === 0 || m === 0)
+    return [];
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = 1;i2 <= n; i2++) {
+    for (let j2 = 1;j2 <= m; j2++) {
+      if (a[i2 - 1] === b[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const matches = [];
+  let i = n;
+  let j = m;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      matches.unshift({ baseIdx: i - 1, newIdx: j - 1 });
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return matches;
+}
+
+// src/vcs/issue.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+var execAsync = promisify(exec);
+function getIssueCounterPath(rootPath) {
+  return join3(rootPath, ".trellis", "issue-counter.json");
+}
+function nextIssueId(rootPath) {
+  const counterPath = getIssueCounterPath(rootPath);
+  let counter = 0;
+  if (existsSync3(counterPath)) {
+    try {
+      counter = JSON.parse(readFileSync3(counterPath, "utf-8")).counter ?? 0;
+    } catch {}
+  }
+  counter++;
+  const dir = dirname2(counterPath);
+  if (!existsSync3(dir))
+    mkdirSync2(dir, { recursive: true });
+  writeFileSync3(counterPath, JSON.stringify({ counter }, null, 2));
+  return `TRL-${counter}`;
+}
+function getIssueFact(ctx, entityId, attr) {
+  const facts = ctx.store.getFactsByEntity(entityId);
+  const matches = facts.filter((f) => f.a === attr);
+  return matches.length > 0 ? matches[matches.length - 1].v : undefined;
+}
+function getIssueLinks(ctx, entityId, attr) {
+  const links = ctx.store.getLinksByEntity(entityId);
+  return links.filter((l) => l.a === attr && l.e1 === entityId).map((l) => l.e2);
+}
+function getCriteriaForIssue(ctx, issueId) {
+  const eid = issueEntityId(issueId);
+  const criterionLinks = ctx.store.getLinksByAttribute("criterionOf").filter((l) => l.e2 === eid);
+  return criterionLinks.map((link) => {
+    const ceid = link.e1;
+    const facts = ctx.store.getFactsByEntity(ceid);
+    const getLast = (a) => {
+      const matches = facts.filter((f) => f.a === a);
+      return matches.length > 0 ? matches[matches.length - 1].v : undefined;
+    };
+    return {
+      id: ceid,
+      description: getLast("description"),
+      command: getLast("command"),
+      status: getLast("status"),
+      lastRunAt: getLast("lastRunAt"),
+      lastOutput: getLast("lastOutput")
+    };
+  });
+}
+function buildIssueInfo(ctx, entityId) {
+  const facts = ctx.store.getFactsByEntity(entityId);
+  const get = (a) => {
+    const matches = facts.filter((f) => f.a === a);
+    return matches.length > 0 ? matches[matches.length - 1].v : undefined;
+  };
+  const labelsStr = get("labels");
+  const labels = labelsStr ? labelsStr.split(",").filter(Boolean) : [];
+  const trackedOnLinks = getIssueLinks(ctx, entityId, "trackedOn");
+  const branchName = trackedOnLinks.length > 0 ? trackedOnLinks[0].replace(/^branch:/, "") : undefined;
+  const childOfLinks = getIssueLinks(ctx, entityId, "childOf");
+  const parentId = childOfLinks.length > 0 ? childOfLinks[0].replace(/^issue:/, "") : undefined;
+  const bareId = entityId.replace(/^issue:/, "");
+  const blockedByLinks = getIssueLinks(ctx, entityId, "blockedBy");
+  const blockedBy = blockedByLinks.map((e) => e.replace(/^issue:/, ""));
+  const allBlockedByLinks = ctx.store.getLinksByAttribute("blockedBy");
+  const blocking = allBlockedByLinks.filter((l) => l.e2 === entityId).map((l) => l.e1.replace(/^issue:/, ""));
+  const isBlocked = blockedByLinks.some((blockerEid) => {
+    const blockerStatus = getIssueFact(ctx, blockerEid, "status");
+    return blockerStatus !== "closed";
+  });
+  return {
+    id: bareId,
+    title: get("title"),
+    description: get("description"),
+    status: get("status"),
+    priority: get("priority"),
+    labels,
+    assignee: get("assignee"),
+    createdAt: get("createdAt"),
+    createdBy: get("createdBy"),
+    startedAt: get("startedAt"),
+    pausedAt: get("pausedAt"),
+    pauseNote: get("pauseNote") || undefined,
+    closedAt: get("closedAt"),
+    parentId,
+    branchName,
+    blockedBy,
+    blocking,
+    isBlocked,
+    criteria: getCriteriaForIssue(ctx, bareId)
+  };
+}
+async function createIssue(ctx, rootPath, title, opts) {
+  const id = nextIssueId(rootPath);
+  const op = await createVcsOp("vcs:issueCreate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      issueId: id,
+      issueTitle: title,
+      issueDescription: opts?.description,
+      issueStatus: opts?.status ?? "backlog",
+      issuePriority: opts?.priority ?? "medium",
+      issueLabels: opts?.labels,
+      issueAssignee: opts?.assignee,
+      parentIssueId: opts?.parentId
+    }
+  });
+  ctx.applyOp(op);
+  if (opts?.criteria) {
+    for (let i = 0;i < opts.criteria.length; i++) {
+      await addCriterion(ctx, id, opts.criteria[i].description, opts.criteria[i].command);
+    }
+  }
+  return op;
+}
+async function updateIssue(ctx, id, updates) {
+  const op = await createVcsOp("vcs:issueUpdate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      issueId: id,
+      issueTitle: updates.title,
+      issueDescription: updates.description,
+      issueStatus: updates.status,
+      issuePriority: updates.priority,
+      issueLabels: updates.labels,
+      issueAssignee: updates.assignee
+    }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function startIssue(ctx, id, branchName) {
+  const eid = issueEntityId(id);
+  const status = getIssueFact(ctx, eid, "status");
+  if (status === "closed") {
+    throw new Error(`Cannot start closed issue ${id}. Reopen it first.`);
+  }
+  if (status === "in_progress") {
+    throw new Error(`Issue ${id} is already in progress.`);
+  }
+  const op = await createVcsOp("vcs:issueStart", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      issueId: id,
+      issueAssignee: ctx.agentId,
+      branchName
+    }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function pauseIssue(ctx, id, note) {
+  if (!note || !note.trim()) {
+    throw new Error(`A pause note is required. Explain why the issue is paused and what must happen before resuming.`);
+  }
+  const eid = issueEntityId(id);
+  const status = getIssueFact(ctx, eid, "status");
+  if (status !== "in_progress") {
+    throw new Error(`Cannot pause issue ${id} \u2014 status is '${status}', expected 'in_progress'.`);
+  }
+  const op = await createVcsOp("vcs:issuePause", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { issueId: id, pauseNote: note.trim() }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function resumeIssue(ctx, id) {
+  const eid = issueEntityId(id);
+  const status = getIssueFact(ctx, eid, "status");
+  if (status !== "paused") {
+    throw new Error(`Cannot resume issue ${id} \u2014 status is '${status}', expected 'paused'.`);
+  }
+  const op = await createVcsOp("vcs:issueResume", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { issueId: id }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function closeIssue(ctx, id, opts) {
+  const eid = issueEntityId(id);
+  const status = getIssueFact(ctx, eid, "status");
+  if (status === "closed") {
+    throw new Error(`Issue ${id} is already closed.`);
+  }
+  const criteria = getCriteriaForIssue(ctx, id);
+  const results = criteria.map((c) => ({
+    id: c.id,
+    description: c.description,
+    command: c.command,
+    status: c.status ?? "pending"
+  }));
+  const allPassed = results.length === 0 || results.every((r) => r.status === "passed");
+  if (!allPassed) {
+    const failing = results.filter((r) => r.status !== "passed");
+    throw new Error(`Cannot close issue ${id}: ${failing.length} criteria not passing:
+` + failing.map((f) => `  - ${f.description ?? f.id} (${f.status})`).join(`
+`));
+  }
+  if (!opts?.confirm) {
+    return { criteriaResults: results };
+  }
+  const startedAt = getIssueFact(ctx, eid, "startedAt");
+  const op = await createVcsOp("vcs:issueClose", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { issueId: id }
+  });
+  ctx.applyOp(op);
+  if (startedAt) {
+    const durationMs = Date.now() - new Date(startedAt).getTime();
+    ctx.store.addFacts([{ e: eid, a: "durationMs", v: durationMs }]);
+  }
+  return { op, criteriaResults: results };
+}
+async function triageIssue(ctx, id) {
+  const eid = issueEntityId(id);
+  const status = getIssueFact(ctx, eid, "status");
+  if (status !== "backlog") {
+    throw new Error(`Cannot triage issue ${id} \u2014 status is '${status}', expected 'backlog'.`);
+  }
+  const op = await createVcsOp("vcs:issueUpdate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      issueId: id,
+      issueStatus: "queue"
+    }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function reopenIssue(ctx, id) {
+  const eid = issueEntityId(id);
+  const status = getIssueFact(ctx, eid, "status");
+  if (status !== "closed") {
+    throw new Error(`Cannot reopen issue ${id} \u2014 status is '${status}', expected 'closed'.`);
+  }
+  const op = await createVcsOp("vcs:issueReopen", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { issueId: id }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function assignIssue(ctx, id, agentId) {
+  return updateIssue(ctx, id, { assignee: agentId });
+}
+async function blockIssue(ctx, id, blockedById) {
+  const eid = issueEntityId(id);
+  const blockerEid = issueEntityId(blockedById);
+  if (!getIssueFact(ctx, eid, "type")) {
+    throw new Error(`Issue ${id} not found.`);
+  }
+  if (!getIssueFact(ctx, blockerEid, "type")) {
+    throw new Error(`Blocking issue ${blockedById} not found.`);
+  }
+  if (id === blockedById) {
+    throw new Error(`Issue cannot block itself.`);
+  }
+  const op = await createVcsOp("vcs:issueBlock", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { issueId: id, blockedByIssueId: blockedById }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function unblockIssue(ctx, id, blockedById) {
+  const op = await createVcsOp("vcs:issueUnblock", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: { issueId: id, blockedByIssueId: blockedById }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function addCriterion(ctx, issueId, description, command) {
+  const existing = getCriteriaForIssue(ctx, issueId);
+  const index = existing.length + 1;
+  const cid = criterionEntityId(issueId, index);
+  const op = await createVcsOp("vcs:criterionAdd", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      issueId,
+      criterionId: cid,
+      criterionDescription: description,
+      criterionCommand: command
+    }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function setCriterionStatus(ctx, issueId, criterionIndex, status) {
+  const criteria = getCriteriaForIssue(ctx, issueId);
+  if (criterionIndex < 1 || criterionIndex > criteria.length) {
+    throw new Error(`Criterion index ${criterionIndex} out of range (1\u2013${criteria.length})`);
+  }
+  const c = criteria[criterionIndex - 1];
+  const op = await createVcsOp("vcs:criterionUpdate", {
+    agentId: ctx.agentId,
+    previousHash: ctx.getLastOp()?.hash,
+    vcs: {
+      issueId,
+      criterionId: c.id,
+      criterionStatus: status
+    }
+  });
+  ctx.applyOp(op);
+  return op;
+}
+async function runCriteria(ctx, issueId, rootPath) {
+  const criteria = getCriteriaForIssue(ctx, issueId);
+  const results = [];
+  for (const c of criteria) {
+    if (!c.command) {
+      results.push({
+        id: c.id,
+        description: c.description,
+        status: c.status ?? "skipped"
+      });
+      continue;
+    }
+    let status = "failed";
+    let output = "";
+    let exitCode = 1;
+    try {
+      const result = await execAsync(c.command, {
+        cwd: rootPath,
+        timeout: 120000
+      });
+      output = (result.stdout + `
+` + result.stderr).trim();
+      exitCode = 0;
+      status = "passed";
+    } catch (err) {
+      output = (err.stdout ?? "") + `
+` + (err.stderr ?? err.message ?? "");
+      output = output.trim();
+      exitCode = err.code ?? 1;
+      status = "failed";
+    }
+    const updateOp = await createVcsOp("vcs:criterionUpdate", {
+      agentId: ctx.agentId,
+      previousHash: ctx.getLastOp()?.hash,
+      vcs: {
+        criterionId: c.id,
+        criterionStatus: status,
+        criterionOutput: output.slice(0, 4096)
+      }
+    });
+    ctx.applyOp(updateOp);
+    results.push({
+      id: c.id,
+      description: c.description,
+      command: c.command,
+      status,
+      output,
+      exitCode
+    });
+  }
+  return results;
+}
+function listIssues(ctx, filters) {
+  const issueFacts = ctx.store.getFactsByAttribute("type").filter((f) => f.v === "Issue");
+  let issues = issueFacts.map((f) => buildIssueInfo(ctx, f.e));
+  if (filters?.status) {
+    issues = issues.filter((i) => i.status === filters.status);
+  }
+  if (filters?.assignee) {
+    issues = issues.filter((i) => i.assignee === filters.assignee);
+  }
+  if (filters?.label) {
+    issues = issues.filter((i) => i.labels.includes(filters.label));
+  }
+  if (filters?.parentId) {
+    issues = issues.filter((i) => i.parentId === filters.parentId);
+  }
+  if (filters?.blocked !== undefined) {
+    issues = issues.filter((i) => i.isBlocked === filters.blocked);
+  }
+  return issues;
+}
+function getIssue(ctx, id) {
+  const eid = issueEntityId(id);
+  const typeFact = ctx.store.getFactsByEntity(eid).find((f) => f.a === "type" && f.v === "Issue");
+  if (!typeFact)
+    return null;
+  return buildIssueInfo(ctx, eid);
+}
+function getActiveIssues(ctx) {
+  return listIssues(ctx, { status: "in_progress" });
+}
+function checkCompletionReadiness(ctx) {
+  const all = listIssues(ctx);
+  const queue = all.filter((i) => i.status === "queue");
+  const paused = all.filter((i) => i.status === "paused");
+  const inProgress = all.filter((i) => i.status === "in_progress");
+  const ready = queue.length === 0 && paused.length === 0 && inProgress.length === 0;
+  const parts = [];
+  if (ready) {
+    parts.push("\u2713 All clear \u2014 no queue, paused, or in-progress issues.");
+  } else {
+    parts.push("\u2717 Not ready for completion:");
+    if (queue.length > 0) {
+      parts.push(`  Queue (${queue.length}): ${queue.map((i) => i.id).join(", ")}`);
+    }
+    if (inProgress.length > 0) {
+      parts.push(`  In progress (${inProgress.length}): ${inProgress.map((i) => i.id).join(", ")}`);
+    }
+    if (paused.length > 0) {
+      parts.push(`  Paused (${paused.length}): ${paused.map((i) => `${i.id}${i.pauseNote ? ` \u2014 ${i.pauseNote}` : ""}`).join(", ")}`);
+    }
+  }
+  return { ready, queue, paused, inProgress, summary: parts.join(`
+`) };
+}
+
+export { decompose, BlobStore, createBranch, switchBranch, listBranches, deleteBranch, saveBranchState, loadBranchState, createMilestone, listMilestones, createCheckpoint, listCheckpoints, diffFileStates, buildFileStateAtOp, diffOpRange, generateUnifiedDiff, myersDiff, threeWayMerge, threeWayTextMerge, createIssue, updateIssue, startIssue, pauseIssue, resumeIssue, closeIssue, triageIssue, reopenIssue, assignIssue, blockIssue, unblockIssue, addCriterion, setCriterionStatus, runCriteria, listIssues, getIssue, getActiveIssues, checkCompletionReadiness };