trellis 3.1.30 → 3.1.33

package/dist/{index-a2a394zz.js → index-xhcp6xrn.js}

@@ -7,8 +7,9 @@ import {
   fileEntityId,
   init_ops,
   init_types,
-  issueEntityId
-} from "./index-v9b4hqa7.js";
+  issueEntityId,
+  laneEntityId
+} from "./index-nzb3am4f.js";
 import {
   __esm,
   __require
@@ -16,6 +17,22 @@ import {
 
 // 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: [],
@@ -230,6 +247,20 @@ function decompose(op) {
           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": {
@@ -384,6 +415,102 @@ function decompose(op) {
       }
       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;
+    }
+    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;
 }
@@ -474,6 +601,13 @@ var init_blob_store = () => {};
 // 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) {
@@ -488,7 +622,7 @@ async function createBranch(ctx, name, currentBranch) {
       targetOpHash: ctx.getLastOp()?.hash
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 function switchBranch(ctx, name) {
@@ -523,7 +657,7 @@ async function deleteBranch(ctx, name, currentBranch) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { branchName: name }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 function saveBranchState(rootPath, state) {
@@ -537,14 +671,24 @@ function loadBranchState(rootPath) {
       const raw = readFileSync2(statePath, "utf-8");
       const state = JSON.parse(raw);
       if (state.currentBranch) {
-        return { currentBranch: state.currentBranch };
+        return {
+          currentBranch: state.currentBranch,
+          activeLaneId: state.activeLaneId
+        };
       }
     } catch {}
   }
   return { currentBranch: "main" };
 }
+var BRANCH_ADVANCE_SKIP_KINDS;
 var init_branch = __esm(() => {
   init_ops();
+  BRANCH_ADVANCE_SKIP_KINDS = new Set([
+    "vcs:branchAdvance",
+    "vcs:branchCreate",
+    "vcs:branchDelete",
+    "vcs:checkpointCreate"
+  ]);
 });
 
 // src/vcs/milestone.ts
@@ -583,7 +727,7 @@ async function createMilestone(ctx, message, opts) {
       toOpHash
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   for (const file of affectedFiles) {
     ctx.store.addFacts([{ e: milestoneId, a: "affectsFile", v: file }]);
   }
@@ -617,7 +761,7 @@ async function createCheckpoint(ctx, trigger = "manual") {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { trigger }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 function listCheckpoints(ctx) {
@@ -1155,25 +1299,56 @@ var init_merge = () => {};
 // 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 {
+  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);
-  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}`;
+  const lockPath = `${counterPath}.lock`;
+  const deadline = Date.now() + 5000;
+  let lockFd;
+  while (Date.now() < deadline) {
+    try {
+      lockFd = openSync(lockPath, "wx");
+      break;
+    } catch (err) {
+      if (err?.code !== "EEXIST") {
+        throw err;
+      }
+    }
+  }
+  if (lockFd === undefined) {
+    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);
@@ -1263,7 +1438,7 @@ async function createIssue(ctx, rootPath, title, opts) {
       parentIssueId: opts?.parentId
     }
   });
-  ctx.applyOp(op);
+  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);
@@ -1272,21 +1447,50 @@ async function createIssue(ctx, rootPath, title, opts) {
   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 !== undefined)
+    vcs.issueTitle = updates.title;
+  if (updates.description !== undefined)
+    vcs.issueDescription = updates.description;
+  if (updates.status !== undefined) {
+    vcs.oldIssueStatus = getIssueFact(ctx, issueEntityId(id), "status");
+    vcs.issueStatus = updates.status;
+  }
+  if (updates.priority !== undefined)
+    vcs.issuePriority = updates.priority;
+  if (updates.labels !== undefined)
+    vcs.issueLabels = updates.labels;
+  if (updates.assignee !== undefined)
+    vcs.issueAssignee = updates.assignee;
+  if (updates.parentId !== undefined) {
+    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: {
-      issueId: id,
-      issueTitle: updates.title,
-      issueDescription: updates.description,
-      oldIssueStatus: updates.status ? getIssueFact(ctx, issueEntityId(id), "status") : undefined,
-      issueStatus: updates.status,
-      issuePriority: updates.priority,
-      issueLabels: updates.labels,
-      issueAssignee: updates.assignee
-    }
+    vcs
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function startIssue(ctx, id, branchName) {
@@ -1308,7 +1512,7 @@ async function startIssue(ctx, id, branchName) {
       branchName
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function pauseIssue(ctx, id, note) {
@@ -1329,7 +1533,7 @@ async function pauseIssue(ctx, id, note) {
       pauseNote: note.trim()
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function resumeIssue(ctx, id) {
@@ -1343,7 +1547,7 @@ async function resumeIssue(ctx, id) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { issueId: id, oldIssueStatus: status }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function closeIssue(ctx, id, opts) {
@@ -1375,7 +1579,7 @@ async function closeIssue(ctx, id, opts) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { issueId: id, oldIssueStatus: status }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   if (startedAt) {
     const durationMs = Date.now() - new Date(startedAt).getTime();
     ctx.store.addFacts([{ e: eid, a: "durationMs", v: durationMs }]);
@@ -1397,7 +1601,7 @@ async function triageIssue(ctx, id) {
       issueStatus: "queue"
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function reopenIssue(ctx, id) {
@@ -1411,7 +1615,7 @@ async function reopenIssue(ctx, id) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { issueId: id, oldIssueStatus: status }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function assignIssue(ctx, id, agentId) {
@@ -1434,7 +1638,7 @@ async function blockIssue(ctx, id, blockedById) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { issueId: id, blockedByIssueId: blockedById }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function unblockIssue(ctx, id, blockedById) {
@@ -1443,7 +1647,7 @@ async function unblockIssue(ctx, id, blockedById) {
     previousHash: ctx.getLastOp()?.hash,
     vcs: { issueId: id, blockedByIssueId: blockedById }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function addCriterion(ctx, issueId, description, command) {
@@ -1460,7 +1664,7 @@ async function addCriterion(ctx, issueId, description, command) {
       criterionCommand: command
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function setCriterionStatus(ctx, issueId, criterionIndex, status) {
@@ -1478,7 +1682,7 @@ async function setCriterionStatus(ctx, issueId, criterionIndex, status) {
       criterionStatus: status
     }
   });
-  ctx.applyOp(op);
+  await ctx.applyOp(op);
   return op;
 }
 async function runCriteria(ctx, issueId, rootPath) {
@@ -1521,7 +1725,7 @@ async function runCriteria(ctx, issueId, rootPath) {
         criterionOutput: output.slice(0, 4096)
       }
     });
-    ctx.applyOp(updateOp);
+    await ctx.applyOp(updateOp);
     results.push({
       id: c.id,
       description: c.description,
@@ -1594,4 +1798,262 @@ var init_issue = __esm(() => {
   execAsync = promisify(exec);
 });
 
-export { decompose, init_decompose, BlobStore, init_blob_store, 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 };
+// 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 5000;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 5000;
+}
+
+class JsonOpLog {
+  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] : undefined;
+  }
+  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 === undefined) {
+      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(`
+`, lastHash);
+    const closingBrace = raw.indexOf("  }", endOfLine);
+    if (closingBrace === -1) {
+      writeFileSync4(filePath, "[]");
+      return { recovered: 0, lost: -1 };
+    }
+    const fixed = raw.slice(0, closingBrace + 3) + `
+]`;
+    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 };
+    }
+  }
+}
+var LaneOpLog;
+var init_op_log = __esm(() => {
+  LaneOpLog = class LaneOpLog extends JsonOpLog {
+    constructor(laneDir) {
+      super(`${laneDir}/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;
+  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) + `
+`);
+}
+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 = 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 = new Date().toISOString();
+  saveLaneMeta(trellisDir, meta);
+}
+function listLaneMetas(trellisDir) {
+  return listLaneIds(trellisDir).map((id) => loadLaneMeta(trellisDir, id)).filter((m) => m !== undefined);
+}
+var init_lane = () => {};
+
+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 };