@shipers-dev/multi 0.63.0 → 0.64.0

package/dist/index.js

@@ -17116,29 +17116,49 @@ async function ensureWorktree(workingDir, issueKey, issueId, opts) {
     return { path: workingDir, branch: "", created: false };
   }
   ensureGitignoreEntry(workingDir, ".multi/");
-  const key = normalizeKey(issueKey);
-  const branch = `multi/${key}`;
+  const slug = normalizeKey(opts?.worktreeName ?? issueKey);
+  const branch = `multi/${slug}`;
   const wtDir = join5(workingDir, ".multi", "worktrees");
-  const wtPath = join5(wtDir, key);
+  const wtPath = join5(wtDir, slug);
+  let baseRef = "HEAD";
+  const explicit = opts?.baseBranch || opts?.parentBranch || null;
+  if (explicit) {
+    const localOk = await branchExists(workingDir, explicit);
+    if (localOk) {
+      baseRef = explicit;
+    } else {
+      const fetched = await run3(workingDir, "git", ["fetch", "origin", `${explicit}:${explicit}`]);
+      if (fetched.code === 0)
+        baseRef = explicit;
+    }
+  }
   if (existsSync3(wtPath)) {
+    if (await isDirty(wtPath)) {
+      throw new WorktreeDirtyError({ path: wtPath, branch, reason: "dirty" });
+    }
+    if (opts?.baseBranch) {
+      const mergeBase = await run3(wtPath, "git", ["merge-base", branch, opts.baseBranch]);
+      if (mergeBase.code === 0 && mergeBase.stdout) {
+        const forkOnBase = await run3(workingDir, "git", ["merge-base", "--is-ancestor", mergeBase.stdout, opts.baseBranch]);
+        if (forkOnBase.code === 1) {
+          const baseHead = await run3(workingDir, "git", ["rev-parse", "--verify", `${opts.baseBranch}^{commit}`]);
+          throw new WorktreeDirtyError({
+            path: wtPath,
+            branch,
+            reason: "base_mismatch",
+            expectedBase: opts.baseBranch,
+            actualBase: baseHead.code === 0 ? baseHead.stdout : mergeBase.stdout
+          });
+        }
+      }
+    }
     if (issueId)
-      setWorktreeIndexEntry(workingDir, key, issueId);
+      setWorktreeIndexEntry(workingDir, slug, issueId);
     return { path: wtPath, branch, created: false };
   }
   try {
     mkdirSync3(wtDir, { recursive: true });
   } catch {}
-  let baseRef = "HEAD";
-  if (opts?.parentBranch) {
-    const localOk = await branchExists(workingDir, opts.parentBranch);
-    if (localOk) {
-      baseRef = opts.parentBranch;
-    } else {
-      const fetched = await run3(workingDir, "git", ["fetch", "origin", `${opts.parentBranch}:${opts.parentBranch}`]);
-      if (fetched.code === 0)
-        baseRef = opts.parentBranch;
-    }
-  }
   const exists4 = await branchExists(workingDir, branch);
   const args2 = exists4 ? ["worktree", "add", wtPath, branch] : ["worktree", "add", "-b", branch, wtPath, baseRef];
   const r = await run3(workingDir, "git", args2);
@@ -17147,7 +17167,7 @@ async function ensureWorktree(workingDir, issueKey, issueId, opts) {
   }
   await linkIgnoredFiles(workingDir, wtPath);
   if (issueId)
-    setWorktreeIndexEntry(workingDir, key, issueId);
+    setWorktreeIndexEntry(workingDir, slug, issueId);
   return { path: wtPath, branch, created: true };
 }
 async function linkIgnoredFiles(workingDir, wtPath) {
@@ -17274,7 +17294,17 @@ async function squashMergeChild(wtPath, childBranch, childKey) {
   result.message = `${childKey} squash-merged (${stagedFiles.length} file${stagedFiles.length === 1 ? "" : "s"})`;
   return result;
 }
-var init_worktree = () => {};
+var WorktreeDirtyError;
+var init_worktree = __esm(() => {
+  WorktreeDirtyError = class WorktreeDirtyError extends Error {
+    details;
+    code = "E_WORKTREE_DIRTY";
+    constructor(details) {
+      super(`worktree dirty or base-mismatched at ${details.path} (${details.reason})`);
+      this.details = details;
+    }
+  };
+});
 
 // ../../node_modules/zod/v4/core/core.js
 function $constructor(name, initializer, params) {
@@ -34022,7 +34052,8 @@ var init_streams = __esm(() => {
     "stopped",
     "queued",
     "worktree_created",
-    "worktree_error"
+    "worktree_error",
+    "worktree_dirty"
   ];
   StreamEventTypeSchema = exports_external.enum(STREAM_EVENT_TYPES);
   StreamEventInputSchema = exports_external.object({
@@ -34220,7 +34251,7 @@ function parsePlanBlocks(text) {
   }
   return { actions, errors: errors3 };
 }
-var PLAN_SCHEMA_VERSION = 10, Priority, AssigneeType, IssueStatus, SessionRole, SkillFile, EvalPolicy, PlanActionSchema, PlanEnvelopeSchema, UiBlockSchema, UI_FENCE_RE, FENCE_RE;
+var PLAN_SCHEMA_VERSION = 11, Priority, AssigneeType, IssueStatus, SessionRole, SkillFile, EvalPolicy, PlanActionSchema, PlanEnvelopeSchema, UiBlockSchema, UI_FENCE_RE, FENCE_RE;
 var init_plans = __esm(() => {
   init_zod();
   Priority = exports_external.enum(["low", "medium", "high"]);
@@ -34243,6 +34274,8 @@ var init_plans = __esm(() => {
       priority: Priority.optional(),
       assignee_type: AssigneeType.optional(),
       assignee_id: exports_external.string().optional(),
+      base_ref: exports_external.string().min(1).max(200).optional(),
+      worktree: exports_external.string().min(1).max(60).regex(/^[a-z0-9][a-z0-9_\-\/]*$/i).optional(),
       parent_id: exports_external.string().optional(),
       blocked_by: exports_external.array(exports_external.string().min(1)).optional(),
       await_children: exports_external.boolean().optional(),
@@ -34853,9 +34886,54 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
   const ISSUE_BASE = tenantWsId && projectId ? `${apiUrl}/api/workspaces/${tenantWsId}/projects/${projectId}/issues/${issueId}` : null;
   let workingDir = baseWorkingDir;
   let worktreeBranch = "";
-  if (baseWorkingDir) {
+  const inlineMode = task.inline_mode === true;
+  const baseBranch = task.base_branch ?? null;
+  const worktreeName = task.worktree_name ?? null;
+  let inlineRestoreHead = null;
+  const blockOnDirty = async (reason, extra = {}) => {
+    await postStream(apiUrl, issueId, "worktree_dirty", { reason, ...extra });
+    if (tenantWsId) {
+      try {
+        await patchIssueStatus(apiUrl, tenantWsId, issueId, "blocked");
+      } catch {}
+    }
+    await postStream(apiUrl, issueId, "run_finished", { stopReason: "blocked", duration_ms: 0 });
+  };
+  if (baseWorkingDir && inlineMode) {
     try {
-      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId, issueId, { parentBranch: task.parent_branch ?? undefined });
+      const status3 = Bun.spawnSync(["git", "status", "--porcelain"], { cwd: baseWorkingDir, stdout: "pipe" });
+      const dirty = (status3.stdout?.toString() || "").trim().length > 0;
+      if (dirty) {
+        await blockOnDirty("inline_dirty", { path: baseWorkingDir });
+        return;
+      }
+      if (baseBranch) {
+        const origSymRef = Bun.spawnSync(["git", "symbolic-ref", "--quiet", "HEAD"], { cwd: baseWorkingDir, stdout: "pipe" });
+        if (origSymRef.exitCode === 0) {
+          inlineRestoreHead = (origSymRef.stdout?.toString() || "").trim().replace(/^refs\/heads\//, "") || null;
+        } else {
+          const origSha = Bun.spawnSync(["git", "rev-parse", "HEAD"], { cwd: baseWorkingDir, stdout: "pipe" });
+          inlineRestoreHead = (origSha.stdout?.toString() || "").trim() || null;
+        }
+        const co = Bun.spawnSync(["git", "checkout", baseBranch], { cwd: baseWorkingDir, stdout: "pipe", stderr: "pipe" });
+        if (co.exitCode !== 0) {
+          await postStream(apiUrl, issueId, "worktree_error", { mode: "inline", message: co.stderr?.toString() || "checkout failed" });
+          await blockOnDirty("inline_checkout_failed", { baseBranch });
+          return;
+        }
+        worktreeBranch = baseBranch;
+      }
+      await postStream(apiUrl, issueId, "worktree_created", { path: baseWorkingDir, branch: worktreeBranch, reused: true, inline: true });
+    } catch (e) {
+      await postStream(apiUrl, issueId, "worktree_error", { mode: "inline", message: fmtError(e) });
+    }
+  } else if (baseWorkingDir) {
+    try {
+      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId, issueId, {
+        baseBranch: baseBranch ?? undefined,
+        parentBranch: task.parent_branch ?? undefined,
+        worktreeName: worktreeName ?? undefined
+      });
       workingDir = wt.path;
       worktreeBranch = wt.branch;
       await postStream(apiUrl, issueId, "worktree_created", { path: wt.path, branch: wt.branch, reused: !wt.created });
@@ -34867,6 +34945,10 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
         }
       }
     } catch (e) {
+      if (e?.code === "E_WORKTREE_DIRTY") {
+        await blockOnDirty("worktree_dirty", { details: e.details });
+        return;
+      }
       await postStream(apiUrl, issueId, "worktree_error", { message: fmtError(e) });
     }
   }
@@ -35398,6 +35480,12 @@ ${userPart}` : userPart;
         await apiClient.post(`${ISSUE_BASE}/fail`, {});
       log3(`  ✗ ${task.key} failed: ${msg}`);
     }
+  } finally {
+    if (inlineMode && inlineRestoreHead && baseWorkingDir) {
+      try {
+        Bun.spawnSync(["git", "checkout", inlineRestoreHead], { cwd: baseWorkingDir, stdout: "pipe", stderr: "pipe" });
+      } catch {}
+    }
   }
 }
 async function buildPlanningPreamble(apiUrl, task, _wsId) {
@@ -38681,7 +38769,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.63.0",
+  version: "0.64.0",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"