@amistio/cli 0.1.44 → 0.1.45

package/README.md

@@ -88,7 +88,7 @@ Approved implementation work uses Git as the handoff boundary. During worktree p
 
 Failed or stale work can be requeued from the web Tasks panel. Requeue creates a new linked work attempt and preserves the original terminal attempt for audit history; Requeue all sends one backend batch that recomputes safe candidates, reports already-active and skipped rows, and still uses linked attempts. Requeue is blocked while equivalent work is already active or when the paired runner does not advertise the needed work kind. Completed implementation status is separate from proof: queue `implementationVerification` from Tasks when a plan needs source-aware evidence before cleanup or implementation status decisions.
 
-Runner setup and local-tool execution use bounded failure controls. `amistio run --watch` retries Git worktree preflight failures by releasing the claim for another attempt, then fails the work item after `--max-preflight-attempts` attempts, defaulting to 3. Active local-tool runs renew the work lease, and `--tool-timeout-seconds` caps tool execution, defaulting to 1800 seconds.
+Runner setup and local-tool execution use bounded failure controls. During Git worktree preflight, `amistio run --watch` repairs safe stale Git registrations when the target worktree directory is missing and Git marks the registration prunable; dirty, present, or ambiguous worktrees are preserved. Other Git worktree preflight failures are retried by releasing the claim for another attempt, then fail the work item after `--max-preflight-attempts` attempts, defaulting to 3. Active local-tool runs renew the work lease, and `--tool-timeout-seconds` caps tool execution, defaulting to 1800 seconds.
 
 The environment doctor blocks work before local AI/tool execution when `git`, `node`, Corepack, the package manager, required package scripts, dependencies, setup allowlist, Docker, or the requested execution profile is not ready. Foreground, background, and startup-service runners accept `--execution-profile`; use `--setup-package-manager-install` with `hostWorktreeWithSetup` when the runner may run the fixed package-manager install step in the execution worktree. Work and Runner surfaces receive sanitized profile/readiness metadata only; raw host paths, command lines, environment values, and secrets are not uploaded. Watch mode also performs a Git PATH preflight before auto-sync or work claiming. If the runner reports that Git is not available to the runner PATH, install Git or restart the foreground, background, or startup-service runner from an environment where `git --version` works. On macOS, service and GUI-launched runner environments may not inherit the same PATH as an interactive shell, so restart or reinstall the service after changing PATH.
 

package/dist/index.js

@@ -9505,6 +9505,7 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
     const preparedLocalEnvironmentFileCount2 = await prepareLocalWorktreeEnvironment(repoRoot, worktreePath);
     return { ...identity, baseRevision, worktreePath, ...preparedLocalEnvironmentFileCount2 ? { preparedLocalEnvironmentFileCount: preparedLocalEnvironmentFileCount2 } : {} };
   }
+  await repairMissingRegisteredWorktree(repoRoot, worktreePath, identity.branch, identity.worktreeKey);
   await mkdir12(path17.dirname(worktreePath), { recursive: true });
   const branchExists = await gitCommandSucceeds(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${identity.branch}`]);
   const worktreeArgs = branchExists ? ["worktree", "add", worktreePath, identity.branch] : ["worktree", "add", "-b", identity.branch, worktreePath, baseRevision];
@@ -9534,6 +9535,63 @@ async function assertExistingWorktree(worktreePath, branch) {
     throw new Error(`Existing worktree is on ${currentBranch}; expected ${branch}.`);
   }
 }
+async function repairMissingRegisteredWorktree(repoRoot, worktreePath, branch, worktreeKey) {
+  const registeredWorktree = await findRegisteredWorktree(repoRoot, worktreePath);
+  if (!registeredWorktree) {
+    return;
+  }
+  const expectedBranchRef = `refs/heads/${branch}`;
+  if (registeredWorktree.branch !== expectedBranchRef) {
+    throw new Error(`Registered Git worktree ${worktreeKey} is missing on disk but belongs to ${registeredWorktree.branch ?? "detached HEAD"}; expected ${expectedBranchRef}. Repair local Git worktrees before retrying.`);
+  }
+  if (registeredWorktree.locked || !registeredWorktree.prunable) {
+    throw new Error(`Registered Git worktree ${worktreeKey} is missing on disk but is not safely prunable. Repair local Git worktrees before retrying.`);
+  }
+  await gitOutput(repoRoot, ["worktree", "prune", "--expire", "now"]);
+  const remainingWorktree = await findRegisteredWorktree(repoRoot, worktreePath);
+  if (remainingWorktree) {
+    throw new Error(`Registered Git worktree ${worktreeKey} remained after pruning. Repair local Git worktrees before retrying.`);
+  }
+}
+async function findRegisteredWorktree(repoRoot, worktreePath) {
+  const worktrees = parseRegisteredGitWorktrees(await gitOutput(repoRoot, ["worktree", "list", "--porcelain"]));
+  const targetPath = normalizeGitWorktreePath(worktreePath);
+  return worktrees.find((worktree) => normalizeGitWorktreePath(worktree.path) === targetPath);
+}
+function parseRegisteredGitWorktrees(output) {
+  const worktrees = [];
+  let current;
+  for (const line of output.split(/\r?\n/)) {
+    if (!line) {
+      current = void 0;
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      current = { locked: false, path: line.slice("worktree ".length), prunable: false };
+      worktrees.push(current);
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length);
+      continue;
+    }
+    if (line.startsWith("locked")) {
+      current.locked = true;
+      continue;
+    }
+    if (line.startsWith("prunable")) {
+      current.prunable = true;
+    }
+  }
+  return worktrees;
+}
+function normalizeGitWorktreePath(value) {
+  const resolved = path17.resolve(value);
+  return resolved.startsWith("/private/var/") ? resolved.replace("/private/var/", "/var/") : resolved;
+}
 async function assertBaseRevision(repoRoot, baseRevision, currentHead) {
   if (!baseRevision || baseRevision === currentHead) {
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amistio/cli",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "type": "module",
   "repository": {
     "type": "git",