trellis 3.2.0 → 3.2.2

package/dist/chunk-NSDXU6QX.js

@@ -1,2213 +0,0 @@
-import {
-  createVcsOp,
-  criterionEntityId,
-  decisionEntityId,
-  dirEntityId,
-  fileEntityId,
-  init_ops,
-  init_types,
-  issueEntityId,
-  laneEntityId
-} from "./chunk-V3G7Q3QQ.js";
-import {
-  __esm,
-  __require
-} from "./chunk-2ESYSVXG.js";
-
-// src/vcs/decompose.ts
-import { dirname } from "path";
-function pickFacts(input) {
-  if (!Array.isArray(input)) return [];
-  return input.filter((item) => {
-    const fact = item;
-    return typeof fact.e === "string" && typeof fact.a === "string" && (typeof fact.v === "string" || typeof fact.v === "number" || typeof fact.v === "boolean");
-  });
-}
-function pickLinks(input) {
-  if (!Array.isArray(input)) return [];
-  return input.filter((item) => {
-    const link = item;
-    return typeof link.e1 === "string" && typeof link.a === "string" && typeof link.e2 === "string";
-  });
-}
-function decompose(op) {
-  const result = {
-    addFacts: [],
-    addLinks: [],
-    deleteFacts: [],
-    deleteLinks: []
-  };
-  const vcs = op.vcs;
-  if (!vcs) return result;
-  if (vcs.issueId && vcs.oldIssueStatus) {
-    result.deleteFacts.push({
-      e: issueEntityId(vcs.issueId),
-      a: "status",
-      v: vcs.oldIssueStatus
-    });
-  }
-  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 !== void 0) {
-        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 !== void 0) {
-        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;
-    }
-    // ----- Issue tracking -----
-    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 !== void 0) {
-        result.addFacts.push({
-          e: eid,
-          a: "description",
-          v: vcs.issueDescription
-        });
-      }
-      if (vcs.oldParentIssueId) {
-        result.deleteLinks.push({
-          e1: eid,
-          a: "childOf",
-          e2: issueEntityId(vcs.oldParentIssueId)
-        });
-      }
-      if (vcs.parentIssueId) {
-        result.addLinks.push({
-          e1: eid,
-          a: "childOf",
-          e2: issueEntityId(vcs.parentIssueId)
-        });
-      }
-      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;
-    }
-    // ----- Issue blocking -----
-    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;
-    }
-    // ----- Decision traces -----
-    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;
-    }
-    case "vcs:laneCreate": {
-      if (!vcs.laneId) break;
-      const lid = laneEntityId(vcs.laneId);
-      result.addFacts.push(
-        { e: lid, a: "type", v: "AgentLane" },
-        { e: lid, a: "status", v: "active" },
-        { e: lid, a: "createdAt", v: op.timestamp },
-        { e: lid, a: "createdBy", v: op.agentId }
-      );
-      if (vcs.baseBranch) {
-        result.addFacts.push({ e: lid, a: "baseBranch", v: vcs.baseBranch });
-      }
-      if (vcs.baseOpHash) {
-        result.addFacts.push({ e: lid, a: "baseOpHash", v: vcs.baseOpHash });
-      }
-      if (vcs.targetBranch) {
-        result.addFacts.push({ e: lid, a: "targetBranch", v: vcs.targetBranch });
-      }
-      if (vcs.baseOpHash) {
-        result.addFacts.push({ e: lid, a: "headOpHash", v: vcs.baseOpHash });
-      }
-      if (vcs.issueId) {
-        result.addFacts.push({ e: lid, a: "issueId", v: vcs.issueId });
-      }
-      if (vcs.sessionId) {
-        result.addFacts.push({ e: lid, a: "sessionId", v: vcs.sessionId });
-      }
-      if (vcs.parentLaneId) {
-        result.addFacts.push({ e: lid, a: "parentLaneId", v: vcs.parentLaneId });
-        result.addLinks.push({
-          e1: lid,
-          a: "forkedFrom",
-          e2: laneEntityId(vcs.parentLaneId)
-        });
-      }
-      if (vcs.forkKind) {
-        result.addFacts.push({ e: lid, a: "forkKind", v: vcs.forkKind });
-      }
-      if (vcs.virtualBaseOpHash) {
-        result.addFacts.push({
-          e: lid,
-          a: "virtualBaseOpHash",
-          v: vcs.virtualBaseOpHash
-        });
-      }
-      break;
-    }
-    case "vcs:laneDrop": {
-      if (!vcs.laneId) break;
-      const lid = laneEntityId(vcs.laneId);
-      if (vcs.laneStatus) {
-        result.deleteFacts.push({ e: lid, a: "status", v: "active" });
-        result.addFacts.push({ e: lid, a: "status", v: vcs.laneStatus });
-      }
-      break;
-    }
-    case "vcs:lanePromoteStart": {
-      if (!vcs.laneId) break;
-      const lid = laneEntityId(vcs.laneId);
-      result.deleteFacts.push({ e: lid, a: "status", v: "active" });
-      result.addFacts.push({ e: lid, a: "status", v: "promoting" });
-      break;
-    }
-    case "vcs:lanePromoteComplete": {
-      if (!vcs.laneId) break;
-      const lid = laneEntityId(vcs.laneId);
-      result.deleteFacts.push({ e: lid, a: "status", v: "promoting" });
-      result.addFacts.push({ e: lid, a: "status", v: "promoted" });
-      if (vcs.targetBranch) {
-        result.addFacts.push({ e: lid, a: "promotedToBranch", v: vcs.targetBranch });
-      }
-      break;
-    }
-    case "vcs:lanePromoteAbort": {
-      if (!vcs.laneId) break;
-      const lid = laneEntityId(vcs.laneId);
-      result.deleteFacts.push({ e: lid, a: "status", v: "promoting" });
-      result.addFacts.push({ e: lid, a: "status", v: "active" });
-      break;
-    }
-    // ----- EAV store (CMS / knowledge graph) -----
-    case "vcs:storeAssert": {
-      result.addFacts.push(...pickFacts(vcs.facts));
-      break;
-    }
-    case "vcs:storeRetract": {
-      result.deleteFacts.push(...pickFacts(vcs.facts));
-      break;
-    }
-    case "vcs:storeLink": {
-      result.addLinks.push(...pickLinks(vcs.links));
-      break;
-    }
-    case "vcs:storeUnlink": {
-      result.deleteLinks.push(...pickLinks(vcs.links));
-      break;
-    }
-  }
-  return result;
-}
-var init_decompose = __esm({
-  "src/vcs/decompose.ts"() {
-    "use strict";
-    init_types();
-  }
-});
-
-// src/vcs/blob-store.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-var BlobStore;
-var init_blob_store = __esm({
-  "src/vcs/blob-store.ts"() {
-    "use strict";
-    BlobStore = class {
-      blobDir;
-      constructor(trellisDir) {
-        this.blobDir = join(trellisDir, "blobs");
-        if (!existsSync(this.blobDir)) {
-          mkdirSync(this.blobDir, { recursive: true });
-        }
-      }
-      /**
-       * Store content and return its SHA-256 hash.
-       * Idempotent — storing the same content twice is a no-op.
-       */
-      async put(content) {
-        const hash = await this.hash(content);
-        const blobPath = join(this.blobDir, hash);
-        if (!existsSync(blobPath)) {
-          writeFileSync(blobPath, content);
-        }
-        return hash;
-      }
-      /**
-       * Synchronous put — uses Bun's sync crypto if available.
-       */
-      putSync(content) {
-        const hash = this.hashSync(content);
-        const blobPath = join(this.blobDir, hash);
-        if (!existsSync(blobPath)) {
-          writeFileSync(blobPath, content);
-        }
-        return hash;
-      }
-      /**
-       * Retrieve content by hash. Returns null if not found.
-       */
-      get(hash) {
-        const blobPath = join(this.blobDir, hash);
-        if (!existsSync(blobPath)) {
-          return null;
-        }
-        return readFileSync(blobPath);
-      }
-      /**
-       * Check if a blob exists.
-       */
-      has(hash) {
-        return existsSync(join(this.blobDir, hash));
-      }
-      /**
-       * Compute SHA-256 hash of content (async).
-       */
-      async hash(content) {
-        const hashBuffer = await crypto.subtle.digest(
-          "SHA-256",
-          content
-        );
-        return this.hexFromBuffer(hashBuffer);
-      }
-      /**
-       * Compute SHA-256 hash of content (sync).
-       * Uses Bun.CryptoHasher when running under Bun, else node:crypto.
-       */
-      hashSync(content) {
-        const { createHash } = __require("crypto");
-        return createHash("sha256").update(content).digest("hex");
-      }
-      /**
-       * Returns the number of blobs stored.
-       */
-      count() {
-        try {
-          const { readdirSync: readdirSync2 } = __require("fs");
-          return readdirSync2(this.blobDir).length;
-        } catch {
-          return 0;
-        }
-      }
-      /**
-       * Returns the total size of all blobs in bytes.
-       */
-      totalSize() {
-        try {
-          const { readdirSync: readdirSync2, statSync } = __require("fs");
-          const files = readdirSync2(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";
-function shouldAdvanceBranchHead(kind) {
-  return !BRANCH_ADVANCE_SKIP_KINDS.has(kind);
-}
-function getBranchHeadOpHash(ctx, branchName) {
-  const facts = ctx.store.getFactsByEntity(`branch:${branchName}`).filter((f) => f.a === "headOpHash");
-  return facts[facts.length - 1]?.v;
-}
-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
-    }
-  });
-  await 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 }
-  });
-  await 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,
-          activeLaneId: state.activeLaneId
-        };
-      }
-    } catch {
-    }
-  }
-  return { currentBranch: "main" };
-}
-var BRANCH_ADVANCE_SKIP_KINDS;
-var init_branch = __esm({
-  "src/vcs/branch.ts"() {
-    "use strict";
-    init_ops();
-    BRANCH_ADVANCE_SKIP_KINDS = /* @__PURE__ */ new Set([
-      "vcs:branchAdvance",
-      "vcs:branchCreate",
-      "vcs:branchDelete",
-      "vcs:checkpointCreate"
-    ]);
-  }
-});
-
-// 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
-    }
-  });
-  await 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
-    };
-  });
-}
-var init_milestone = __esm({
-  "src/vcs/milestone.ts"() {
-    "use strict";
-    init_ops();
-  }
-});
-
-// 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 }
-  });
-  await 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")
-    };
-  });
-}
-var init_checkpoint = __esm({
-  "src/vcs/checkpoint.ts"() {
-    "use strict";
-    init_ops();
-  }
-});
-
-// 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 = /* @__PURE__ */ 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("\n");
-  const newLines = newText.split("\n");
-  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("\n");
-}
-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
-  };
-}
-var init_diff = __esm({
-  "src/vcs/diff.ts"() {
-    "use strict";
-  }
-});
-
-// src/vcs/merge.ts
-function threeWayMerge(base, ours, theirs, blobStore) {
-  const mergedFiles = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  const allPaths = /* @__PURE__ */ 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 : void 0;
-    const oursHash = oursExists ? o.contentHash : void 0;
-    const theirsHash = theirsExists ? t.contentHash : void 0;
-    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") : void 0;
-      const theirsContent = theirsHash && blobStore ? blobStore.get(theirsHash)?.toString("utf-8") : void 0;
-      if (oursContent !== void 0 && theirsContent !== void 0) {
-        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") : void 0
-      });
-      continue;
-    }
-    if (!oursExists && theirsExists) {
-      conflicts.push({
-        path,
-        kind: "modify-delete",
-        theirs: theirsHash && blobStore ? blobStore.get(theirsHash)?.toString("utf-8") : void 0
-      });
-      continue;
-    }
-    if (oursExists && theirsExists && oursHash !== theirsHash) {
-      const baseContent = baseHash && blobStore ? blobStore.get(baseHash)?.toString("utf-8") : void 0;
-      const oursContent = oursHash && blobStore ? blobStore.get(oursHash)?.toString("utf-8") : void 0;
-      const theirsContent = theirsHash && blobStore ? blobStore.get(theirsHash)?.toString("utf-8") : void 0;
-      if (baseContent !== void 0 && oursContent !== void 0 && theirsContent !== void 0) {
-        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,
-      // in a merge context, additions from theirs are "modified"
-      deleted,
-      conflicted: conflicts.length
-    }
-  };
-}
-function threeWayTextMerge(baseText, oursText, theirsText) {
-  const baseLines = baseText.split("\n");
-  const oursLines = oursText.split("\n");
-  const theirsLines = theirsText.split("\n");
-  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("\n") === theirsChange.newLines.join("\n")) {
-        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("\n") };
-}
-function applyChange(change, result) {
-  for (const line of change.newLines) {
-    result.push(line);
-  }
-}
-function computeLineChanges(baseLines, newLines) {
-  const changes = /* @__PURE__ */ 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;
-}
-var init_merge = __esm({
-  "src/vcs/merge.ts"() {
-    "use strict";
-  }
-});
-
-// 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,
-  openSync,
-  closeSync,
-  unlinkSync
-} from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-function getIssueCounterPath(rootPath) {
-  return join3(rootPath, ".trellis", "issue-counter.json");
-}
-function nextIssueId(rootPath) {
-  const counterPath = getIssueCounterPath(rootPath);
-  const dir = dirname2(counterPath);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-  const lockPath = `${counterPath}.lock`;
-  const deadline = Date.now() + 5e3;
-  let lockFd;
-  while (Date.now() < deadline) {
-    try {
-      lockFd = openSync(lockPath, "wx");
-      break;
-    } catch (err) {
-      if (err?.code !== "EEXIST") {
-        throw err;
-      }
-    }
-  }
-  if (lockFd === void 0) {
-    throw new Error(
-      `Timed out waiting for issue counter lock: ${lockPath}. Another Trellis process may be stalled.`
-    );
-  }
-  try {
-    let counter = 0;
-    if (existsSync3(counterPath)) {
-      try {
-        counter = JSON.parse(readFileSync3(counterPath, "utf-8")).counter ?? 0;
-      } catch {
-      }
-    }
-    counter++;
-    writeFileSync3(counterPath, JSON.stringify({ counter }, null, 2));
-    return `TRL-${counter}`;
-  } finally {
-    closeSync(lockFd);
-    try {
-      unlinkSync(lockPath);
-    } catch {
-    }
-  }
-}
-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 : void 0;
-}
-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 : void 0;
-    };
-    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 : void 0;
-  };
-  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:/, "") : void 0;
-  const childOfLinks = getIssueLinks(ctx, entityId, "childOf");
-  const parentId = childOfLinks.length > 0 ? childOfLinks[0].replace(/^issue:/, "") : void 0;
-  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") || void 0,
-    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
-    }
-  });
-  await 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 issue = getIssue(ctx, id);
-  if (!issue) {
-    throw new Error(`Issue ${id} not found.`);
-  }
-  const vcs = { issueId: id };
-  if (updates.title !== void 0) vcs.issueTitle = updates.title;
-  if (updates.description !== void 0) vcs.issueDescription = updates.description;
-  if (updates.status !== void 0) {
-    vcs.oldIssueStatus = getIssueFact(ctx, issueEntityId(id), "status");
-    vcs.issueStatus = updates.status;
-  }
-  if (updates.priority !== void 0) vcs.issuePriority = updates.priority;
-  if (updates.labels !== void 0) vcs.issueLabels = updates.labels;
-  if (updates.assignee !== void 0) vcs.issueAssignee = updates.assignee;
-  if (updates.parentId !== void 0) {
-    const newParent = updates.parentId;
-    if (newParent === id) {
-      throw new Error(`Issue ${id} cannot be its own parent.`);
-    }
-    if (newParent) {
-      const parent = getIssue(ctx, newParent);
-      if (!parent) {
-        throw new Error(`Parent issue ${newParent} not found.`);
-      }
-    }
-    const currentParent = issue.parentId;
-    if (newParent !== currentParent) {
-      if (currentParent) vcs.oldParentIssueId = currentParent;
-      if (newParent) vcs.parentIssueId = newParent;
-    }
-  }
-  const op = await createVcsOp("vcs:issueUpdate", {
-    agentId: ctx.agentId,
-    previousHash: ctx.getLastOp()?.hash,
-    vcs
-  });
-  await 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,
-      oldIssueStatus: status,
-      issueAssignee: ctx.agentId,
-      branchName
-    }
-  });
-  await 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,
-      oldIssueStatus: status,
-      pauseNote: note.trim()
-    }
-  });
-  await 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, oldIssueStatus: status }
-  });
-  await 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("\n")
-    );
-  }
-  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, oldIssueStatus: status }
-  });
-  await 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,
-      oldIssueStatus: status,
-      issueStatus: "queue"
-    }
-  });
-  await 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, oldIssueStatus: status }
-  });
-  await 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 }
-  });
-  await 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 }
-  });
-  await 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
-    }
-  });
-  await 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
-    }
-  });
-  await 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: 12e4
-      });
-      output = (result.stdout + "\n" + result.stderr).trim();
-      exitCode = 0;
-      status = "passed";
-    } catch (err) {
-      output = (err.stdout ?? "") + "\n" + (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)
-      }
-    });
-    await 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 !== void 0) {
-    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("\n") };
-}
-var execAsync;
-var init_issue = __esm({
-  "src/vcs/issue.ts"() {
-    "use strict";
-    init_ops();
-    init_types();
-    execAsync = promisify(exec);
-  }
-});
-
-// src/vcs/op-log.ts
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
-  writeFileSync as writeFileSync4,
-  copyFileSync,
-  openSync as openSync2,
-  closeSync as closeSync2,
-  unlinkSync as unlinkSync2,
-  renameSync
-} from "fs";
-import { dirname as dirname3 } from "path";
-function lockTimeoutMs() {
-  const raw = process.env.TRELLIS_OPLOG_LOCK_MS;
-  if (!raw) return 5e3;
-  const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 5e3;
-}
-var JsonOpLog, LaneOpLog;
-var init_op_log = __esm({
-  "src/vcs/op-log.ts"() {
-    "use strict";
-    JsonOpLog = class {
-      ops = [];
-      filePath;
-      lockPath;
-      constructor(filePath) {
-        this.filePath = filePath;
-        this.lockPath = `${filePath}.lock`;
-      }
-      get path() {
-        return this.filePath;
-      }
-      load() {
-        if (existsSync4(this.filePath)) {
-          const raw = readFileSync4(this.filePath, "utf-8");
-          try {
-            this.ops = JSON.parse(raw);
-          } catch {
-            const backupPath = this.filePath + ".bak";
-            if (existsSync4(backupPath)) {
-              const backupRaw = readFileSync4(backupPath, "utf-8");
-              this.ops = JSON.parse(backupRaw);
-              writeFileSync4(this.filePath, backupRaw);
-            } else {
-              throw new Error(
-                `Corrupted ops log at ${this.filePath} and no backup found. Run \`trellis repair\` to attempt recovery.`
-              );
-            }
-          }
-        }
-      }
-      append(op) {
-        this.withLock(() => {
-          const diskOps = this.readOpsFromDisk();
-          this.ops = diskOps;
-          if (this.ops.some((existing) => existing.hash === op.hash)) {
-            return;
-          }
-          this.ops.push(op);
-          this.flush();
-        });
-      }
-      readAll() {
-        return [...this.ops];
-      }
-      getLastOp() {
-        return this.ops.length > 0 ? this.ops[this.ops.length - 1] : void 0;
-      }
-      count() {
-        return this.ops.length;
-      }
-      flush() {
-        const dir = dirname3(this.filePath);
-        if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
-        if (existsSync4(this.filePath)) {
-          const backupPath = this.filePath + ".bak";
-          try {
-            copyFileSync(this.filePath, backupPath);
-          } catch {
-          }
-        }
-        const tempPath = `${this.filePath}.tmp`;
-        writeFileSync4(tempPath, JSON.stringify(this.ops, null, 2));
-        renameSync(tempPath, this.filePath);
-      }
-      readOpsFromDisk() {
-        if (!existsSync4(this.filePath)) {
-          return [];
-        }
-        const raw = readFileSync4(this.filePath, "utf-8");
-        try {
-          const parsed = JSON.parse(raw);
-          return Array.isArray(parsed) ? parsed : [];
-        } catch {
-          const backupPath = this.filePath + ".bak";
-          if (existsSync4(backupPath)) {
-            const backupRaw = readFileSync4(backupPath, "utf-8");
-            const parsedBackup = JSON.parse(backupRaw);
-            writeFileSync4(this.filePath, backupRaw);
-            return Array.isArray(parsedBackup) ? parsedBackup : [];
-          }
-          throw new Error(
-            `Corrupted ops log at ${this.filePath} and no backup found. Run \`trellis repair\` to attempt recovery.`
-          );
-        }
-      }
-      withLock(fn) {
-        const dir = dirname3(this.filePath);
-        if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
-        const deadline = Date.now() + lockTimeoutMs();
-        let lockFd;
-        while (Date.now() < deadline) {
-          try {
-            lockFd = openSync2(this.lockPath, "wx");
-            break;
-          } catch (err) {
-            if (err?.code !== "EEXIST") {
-              throw err;
-            }
-          }
-        }
-        if (lockFd === void 0) {
-          throw new Error(
-            `Timed out waiting for ops log lock: ${this.lockPath}. Another Trellis process may be stalled.`
-          );
-        }
-        try {
-          fn();
-        } finally {
-          closeSync2(lockFd);
-          try {
-            unlinkSync2(this.lockPath);
-          } catch {
-          }
-        }
-      }
-      static repair(filePath) {
-        if (!existsSync4(filePath)) {
-          return { recovered: 0, lost: 0 };
-        }
-        const raw = readFileSync4(filePath, "utf-8");
-        try {
-          const ops = JSON.parse(raw);
-          return { recovered: ops.length, lost: 0 };
-        } catch {
-        }
-        const lastHash = raw.lastIndexOf('"hash": "trellis:op:');
-        if (lastHash === -1) {
-          const bakPath = filePath + ".bak";
-          if (existsSync4(bakPath)) {
-            const bakRaw = readFileSync4(bakPath, "utf-8");
-            try {
-              const ops = JSON.parse(bakRaw);
-              writeFileSync4(filePath, bakRaw);
-              return { recovered: ops.length, lost: 0 };
-            } catch {
-            }
-          }
-          writeFileSync4(filePath, "[]");
-          return { recovered: 0, lost: -1 };
-        }
-        const endOfLine = raw.indexOf("\n", lastHash);
-        const closingBrace = raw.indexOf("  }", endOfLine);
-        if (closingBrace === -1) {
-          writeFileSync4(filePath, "[]");
-          return { recovered: 0, lost: -1 };
-        }
-        const fixed = raw.slice(0, closingBrace + 3) + "\n]";
-        try {
-          const ops = JSON.parse(fixed);
-          writeFileSync4(filePath + ".corrupted", raw);
-          writeFileSync4(filePath, fixed);
-          return { recovered: ops.length, lost: 0 };
-        } catch {
-          writeFileSync4(filePath + ".corrupted", raw);
-          writeFileSync4(filePath, "[]");
-          return { recovered: 0, lost: -1 };
-        }
-      }
-    };
-    LaneOpLog = class extends JsonOpLog {
-      constructor(laneDir2) {
-        super(`${laneDir2}/ops.json`);
-      }
-    };
-  }
-});
-
-// src/vcs/lane.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync5, readdirSync } from "fs";
-import { join as join4 } from "path";
-import { randomUUID } from "crypto";
-function lanesRoot(trellisDir) {
-  return join4(trellisDir, "lanes");
-}
-function laneDir(trellisDir, laneId) {
-  return join4(lanesRoot(trellisDir), laneId);
-}
-function laneMetaPath(trellisDir, laneId) {
-  return join4(laneDir(trellisDir, laneId), "meta.json");
-}
-function newLaneId() {
-  return `lane-${randomUUID()}`;
-}
-function loadLaneMeta(trellisDir, laneId) {
-  const path = laneMetaPath(trellisDir, laneId);
-  if (!existsSync5(path)) return void 0;
-  return JSON.parse(readFileSync5(path, "utf-8"));
-}
-function saveLaneMeta(trellisDir, meta) {
-  const dir = laneDir(trellisDir, meta.id);
-  if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true });
-  writeFileSync5(
-    laneMetaPath(trellisDir, meta.id),
-    JSON.stringify(meta, null, 2) + "\n"
-  );
-}
-function listLaneIds(trellisDir) {
-  const root = lanesRoot(trellisDir);
-  if (!existsSync5(root)) return [];
-  return readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("lane-")).map((d) => d.name);
-}
-function resolveLaneHeadFromJournal(meta, laneOps) {
-  return laneOps.at(-1)?.hash ?? meta.headOpHash ?? meta.baseOpHash;
-}
-function createLaneMeta(trellisDir, params) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const meta = {
-    id: newLaneId(),
-    status: "active",
-    baseBranch: params.baseBranch,
-    baseOpHash: params.baseOpHash,
-    targetBranch: params.targetBranch ?? params.baseBranch,
-    headOpHash: params.baseOpHash,
-    agentId: params.agentId,
-    issueId: params.issueId,
-    sessionId: params.sessionId,
-    parentLaneId: params.parentLaneId,
-    forkKind: params.forkKind,
-    forkedAt: params.forkedAt,
-    virtualBaseOpHash: params.virtualBaseOpHash,
-    worktreePath: params.worktreePath,
-    leaseExpiresAt: params.leaseExpiresAt,
-    createdAt: now,
-    updatedAt: now
-  };
-  saveLaneMeta(trellisDir, meta);
-  return meta;
-}
-function updateLaneHead(trellisDir, laneId, headOpHash) {
-  const meta = loadLaneMeta(trellisDir, laneId);
-  if (!meta) return;
-  meta.headOpHash = headOpHash;
-  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  saveLaneMeta(trellisDir, meta);
-}
-function listLaneMetas(trellisDir) {
-  return listLaneIds(trellisDir).map((id) => loadLaneMeta(trellisDir, id)).filter((m) => m !== void 0);
-}
-var init_lane = __esm({
-  "src/vcs/lane.ts"() {
-    "use strict";
-  }
-});
-
-export {
-  decompose,
-  init_decompose,
-  BlobStore,
-  init_blob_store,
-  shouldAdvanceBranchHead,
-  getBranchHeadOpHash,
-  createBranch,
-  switchBranch,
-  listBranches,
-  deleteBranch,
-  saveBranchState,
-  loadBranchState,
-  init_branch,
-  createMilestone,
-  listMilestones,
-  init_milestone,
-  createCheckpoint,
-  listCheckpoints,
-  init_checkpoint,
-  diffFileStates,
-  buildFileStateAtOp,
-  diffOpRange,
-  generateUnifiedDiff,
-  myersDiff,
-  init_diff,
-  threeWayMerge,
-  threeWayTextMerge,
-  init_merge,
-  createIssue,
-  updateIssue,
-  startIssue,
-  pauseIssue,
-  resumeIssue,
-  closeIssue,
-  triageIssue,
-  reopenIssue,
-  assignIssue,
-  blockIssue,
-  unblockIssue,
-  addCriterion,
-  setCriterionStatus,
-  runCriteria,
-  listIssues,
-  getIssue,
-  getActiveIssues,
-  checkCompletionReadiness,
-  init_issue,
-  JsonOpLog,
-  LaneOpLog,
-  init_op_log,
-  lanesRoot,
-  laneDir,
-  laneMetaPath,
-  newLaneId,
-  loadLaneMeta,
-  saveLaneMeta,
-  listLaneIds,
-  resolveLaneHeadFromJournal,
-  createLaneMeta,
-  updateLaneHead,
-  listLaneMetas,
-  init_lane
-};