baro-ai 0.110.0 → 0.111.0

package/dist/cli.mjs

@@ -44476,6 +44476,14 @@ var WorktreeManager = class {
     try {
       await this.autoCommitLeftovers(storyId, path6);
       const mergeTarget = candidateSeal ? await this.sealedMergeTarget(storyId, path6, candidateSeal) : branch;
+      const blocked = await this.hostCheckoutBlocks(mergeTarget);
+      if (blocked.length) {
+        this.markPreserved(storyId);
+        throw new WorktreeRefusalError(
+          "host_checkout_dirty",
+          `story ${storyId} cannot land: the host checkout has uncommitted changes on [${blocked.join(", ")}]; the story is intact on ${branch} \u2014 commit or stash those files, then merge it`
+        );
+      }
       const msg = `baro: merge story ${storyId}`;
       try {
         await runRepositoryCommand("git", ["merge", "--no-ff", "-m", msg, mergeTarget], {
@@ -44501,8 +44509,9 @@ var WorktreeManager = class {
         }
         if (!this.resolveConflictsWithTheirs) {
           this.markPreserved(storyId);
-          throw new Error(
-            `story ${storyId} conflicts with already-merged work` + (conflicts.length ? ` on [${conflicts.join(", ")}]` : "")
+          throw new WorktreeRefusalError(
+            "merge_conflict",
+            conflicts.length ? `story ${storyId} conflicts with already-merged work on [${conflicts.join(", ")}]` : `story ${storyId} merge-back failed without a conflict: ${gitFailureDetail(error)}`
           );
         }
         this.log(
@@ -44997,6 +45006,23 @@ ${missing.join("\n")}
     }
     this.preserved.delete(storyId);
   }
+  /** Tracked paths dirty in the host checkout that the merge would also
+   * write. git refuses such a merge outright; reported as a conflict it
+   * sent two recoveries after the same wall on the first self-hosting run. */
+  async hostCheckoutBlocks(mergeTarget) {
+    const [{ stdout: status }, { stdout: touched }] = await Promise.all([
+      runRepositoryCommand("git", ["status", "--porcelain", "--untracked-files=no"], {
+        cwd: this.repoRoot
+      }),
+      runRepositoryCommand("git", ["diff", "--name-only", "HEAD", mergeTarget], {
+        cwd: this.repoRoot
+      })
+    ]);
+    const dirty = new Set(
+      status.split("\n").filter(Boolean).map(porcelainPath)
+    );
+    return touched.split("\n").map((line) => line.trim()).filter((path6) => path6 && dirty.has(path6));
+  }
   async conflictedPaths() {
     try {
       const { stdout } = await runRepositoryCommand(
@@ -45077,6 +45103,18 @@ function rmSyncQuiet(path6) {
 function errMsg(e2) {
   return e2?.message ?? String(e2);
 }
+function gitFailureDetail(e2) {
+  if (e2 instanceof RepositoryCommandError) {
+    const line = e2.stderr.split("\n").find((l) => l.trim());
+    if (line) return line.trim();
+  }
+  return errMsg(e2);
+}
+function porcelainPath(line) {
+  const entry = line.slice(3);
+  const renamed = entry.indexOf(" -> ");
+  return (renamed === -1 ? entry : entry.slice(renamed + 4)).trim();
+}
 
 // ../baro-orchestrator/src/runtime/story-outcome-authority.ts
 var StoryOutcomeAuthority = class {
@@ -66597,6 +66635,10 @@ function translateDeclaredTests(cwd, requirements, packageManagers) {
     if (requirement.declarationError) {
       return incomplete(requirement, requirement.declarationError);
     }
+    const scoped = splitCdPrefix(requirement.command);
+    if (scoped) {
+      return translateCdScoped(cwd, requirement, scoped, packageManagers);
+    }
     const parsed = tokenize2(requirement.command);
     if (typeof parsed === "string") return incomplete(requirement, parsed);
     return dispatchDeclared(
@@ -66660,6 +66702,68 @@ function dispatchDeclared(cwd, requirement, parsed, packageManagers, insideDdev)
     "unsupported declared test; allowed tools are npm/pnpm/yarn, exact npx rstest run paths, cargo, node, git diff --check, composer, vendor/bin/phpunit, and ddev exec"
   );
 }
+var CD_PREFIX = /^cd\s+([^\s&]+)\s*&&\s*([^]*)$/;
+function splitCdPrefix(command) {
+  if (typeof command !== "string" || command.length > MAX_COMMAND_LENGTH) {
+    return null;
+  }
+  const match = CD_PREFIX.exec(command.trim());
+  return match ? { dir: match[1], inner: match[2] } : null;
+}
+function translateCdScoped(root, requirement, scoped, packageManagers) {
+  const dirTokens = tokenize2(scoped.dir);
+  if (typeof dirTokens === "string") return incomplete(requirement, dirTokens);
+  const parsed = tokenize2(scoped.inner);
+  if (typeof parsed === "string") return incomplete(requirement, parsed);
+  const dir = dirTokens.tokens[0];
+  const contained = containedPath(root, dir, false);
+  let isDirectory = false;
+  if (contained.path) {
+    try {
+      isDirectory = statSync3(
+        realpathSync(resolve4(root, contained.path))
+      ).isDirectory();
+    } catch {
+      isDirectory = false;
+    }
+  }
+  if (!contained.path || !isDirectory) {
+    return incomplete(
+      requirement,
+      `cd target '${dir}' must be an existing directory inside the repository`
+    );
+  }
+  if (contained.path === ".") {
+    return dispatchDeclared(root, requirement, parsed, packageManagers, false);
+  }
+  const rel = contained.path;
+  const scopeCwd = resolve4(root, rel);
+  const scopedIncomplete = (reason) => incomplete(requirement, `cd ${rel}: ${reason}`);
+  const tool = parsed.tokens[0];
+  if (tool === "ddev" || tool === "npx") {
+    return scopedIncomplete(
+      `'${tool}' declarations cannot be scoped with cd; declare them from the repository root`
+    );
+  }
+  const alias = trustedScriptAlias(scopeCwd, parsed.tokens);
+  if (alias || /^(npm|pnpm|yarn)$/.test(tool ?? "")) {
+    const base = alias ? ["npm", "run", alias] : parsed.tokens;
+    const [manager, operation, ...rest] = base;
+    const tokens2 = operation === void 0 ? base : [manager, operation, `--workspace=${rel}`, ...rest];
+    const spec2 = translatePackage(
+      root,
+      requirement,
+      { normalized: tokens2.join(" "), tokens: tokens2 },
+      packageManagers
+    );
+    return spec2.incompleteReason === void 0 ? spec2 : scopedIncomplete(spec2.incompleteReason);
+  }
+  const spec = tool === "node" ? translateNode(scopeCwd, requirement, parsed, root) : dispatchDeclared(scopeCwd, requirement, parsed, packageManagers, false);
+  if (spec.incompleteReason !== void 0) {
+    return scopedIncomplete(spec.incompleteReason);
+  }
+  return { ...spec, label: `cd ${rel} && ${spec.label}`, cwd: scopeCwd };
+}
 function unwrapQuotedToken(token) {
   if (!/["']/.test(token)) return token;
   if (token.length >= 2 && (token[0] === '"' || token[0] === "'") && token[token.length - 1] === token[0]) {
@@ -67166,12 +67270,12 @@ function containedPath(cwd, candidate, requireFile) {
   }
   return { path: (fromRoot || ".").replace(/\\/g, "/") };
 }
-function translateNode(cwd, requirement, parsed) {
+function translateNode(cwd, requirement, parsed, manifestRoot = cwd) {
   const hasTsxLoader = parsed.tokens[1] === "--import" && parsed.tokens[2] === "tsx";
   const loaderArgs = hasTsxLoader ? ["--import", "tsx"] : [];
   const rest = parsed.tokens.slice(1 + loaderArgs.length);
   const mode = rest[0];
-  if (rest.length === 1 && typeof mode === "string" && !mode.startsWith("-") && !existsSync5(join8(cwd, "package.json"))) {
+  if (rest.length === 1 && typeof mode === "string" && !mode.startsWith("-") && !existsSync5(join8(cwd, "package.json")) && !existsSync5(join8(manifestRoot, "package.json"))) {
     const contained = containedPath(cwd, mode, true);
     if (!contained.path) {
       return incomplete(
@@ -69255,27 +69359,31 @@ var GitCoordinator = class extends SerializedObserver {
         );
       } catch (e2) {
         const error = e2?.message ?? String(e2);
+        const invariant = e2?.invariant ?? "unknown";
         let branch = worktrees.branchName(storyId);
         let retryable = false;
         let preparationError = null;
-        try {
-          branch = await worktrees.prepareConflictRetry(storyId);
-          retryable = true;
-        } catch (prepareError) {
-          preparationError = prepareError?.message ?? String(prepareError);
-          retryable = isRepositoryCommandSignalDeath(e2);
+        const blockedByHost = invariant === "host_checkout_dirty";
+        if (!blockedByHost) {
+          try {
+            branch = await worktrees.prepareConflictRetry(storyId);
+            retryable = true;
+          } catch (prepareError) {
+            preparationError = prepareError?.message ?? String(prepareError);
+            retryable = isRepositoryCommandSignalDeath(e2);
+          }
         }
         this.emitIntegrationRefused({
           storyId,
           runId: correlation?.runId ?? null,
           leaseId: correlation?.leaseId ?? null,
-          invariant: e2?.invariant ?? "unknown",
+          invariant,
           detail: error,
           branch,
           retryable,
           // Only a successful prepareConflictRetry mints an immutable
           // recovery ref; otherwise `branch` is still the logical one.
-          recoveryRef: preparationError ? null : branch
+          recoveryRef: preparationError || blockedByHost ? null : branch
         });
         this.emitBus(
           StoryMergeFailed.create({
@@ -69287,7 +69395,7 @@ var GitCoordinator = class extends SerializedObserver {
           })
         );
         log2(
-          retryable ? `[git] merge-back failed; attempt preserved at ${branch} and queued for recovery: ${error}` : `[git] merge-back failed; worktree preserved for manual recovery: ${error}`
+          retryable ? `[git] merge-back failed; attempt preserved at ${branch} and queued for recovery: ${error}` : blockedByHost ? `[git] merge-back blocked by the host checkout; story kept on ${branch}: ${error}` : `[git] merge-back failed; worktree preserved for manual recovery: ${error}`
         );
         if (emitTui) {
           emit({ type: "push_status", id: storyId, success: false, error });