@tablation/crew 0.9.0 → 0.10.1

package/dist/cli.js

@@ -3955,6 +3955,13 @@ function fastForward(cwd, branch) {
   if (!s.canFastForward) return false;
   return gitOk(cwd, ["merge", "--ff-only", s.upstream]) !== null;
 }
+function baseBranchUnsafe(r) {
+  return r.action === "diverged" || r.action === "ahead" || r.action === "ff-failed";
+}
+function describeUnsafeBase(r, remote, base) {
+  const counts = r.action === "diverged" ? `${r.ahead} ahead, ${r.behind} behind ${remote}/${base}` : r.action === "ahead" ? `${r.ahead} ahead of ${remote}/${base}` : `${r.behind} behind ${remote}/${base}, cannot fast-forward`;
+  return `${r.detail} [${counts}] \u2014 reconcile it (\`crew sync\` afterwards), or \`git reset --hard ${remote}/${base}\` if the local commits duplicate a release`;
+}
 function refreshBaseBranch(cwd, remote, base, dryRun = false) {
   if (currentBranch(cwd) !== base || status(cwd).length > 0) {
     return { action: "not-applicable", detail: `${cwd} is not on a clean ${base}` };
@@ -3981,6 +3988,9 @@ function refreshBaseBranch(cwd, remote, base, dryRun = false) {
       detail: `${base} has diverged from ${upstream} (${ahead} ahead, ${behind} behind)`
     };
   }
+  if (behind === 0 && ahead > 0) {
+    return { action: "ahead", ahead, detail: `${base} has ${ahead} commit(s) ${upstream} does not` };
+  }
   if (behind === 0) return { action: "level", detail: `${base} is level with ${upstream}` };
   if (dryRun) {
     return { action: "would-fast-forward", behind, detail: `would fast-forward ${base}: ${behind} behind ${upstream}` };
@@ -5979,9 +5989,13 @@ function refreshBase(o) {
     // base. Fast-forwarding is impossible and merging would be this crew
     // inventing a resolution nobody asked for, on the branch everything
     // ships from.
+    // AHEAD is a stop too (CREW-1379): local commits nobody asked for on the
+    // base are how a second ship's release came to diverge from origin's.
+    // Releasing on top of a hand commit is the failure; reconcile it first.
+    case "ahead":
     case "diverged":
     case "ff-failed":
-      return { ok: false, why: r.detail };
+      return { ok: false, why: describeUnsafeBase(r, o.repo.branch.remote, o.repo.branch.base) };
   }
 }
 async function reconfirmLastRelease(o, decision) {
@@ -6825,14 +6839,30 @@ async function fetchDivergedPrompt(route, role, opts) {
     headers: { "User-Agent": opts.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
   });
   let row;
+  let agentsModelId;
   try {
     const agentsModel = await client2.dataModels.get("agents", route.resolved.workspaceId);
-    row = await client2.records.get(agentsModel.id, agentId);
+    agentsModelId = agentsModel.id;
+    row = await client2.records.get(agentsModelId, agentId);
   } catch {
     return void 0;
   }
   const defaultPrompt = personaDefaultPrompt(route.promptsDir, role);
-  return row.prompt !== defaultPrompt ? row.prompt : void 0;
+  if (row.prompt === defaultPrompt) return void 0;
+  const cached = route.resolved.agentPersonas?.[role];
+  if (cached?.agentId === agentId && cached.historyId) {
+    const lastSynced = await fetchLastSyncedPrompt(route, agentsModelId, agentId, cached.historyId, opts.userAgent);
+    if (lastSynced !== void 0 && lastSynced === row.prompt) return void 0;
+  }
+  return row.prompt;
+}
+async function fetchLastSyncedPrompt(route, agentsModelId, recordId, historyId, userAgent) {
+  try {
+    const entries = await fetchHistoryEntries(route, agentsModelId, recordId, userAgent);
+    return entries.find((e) => e.history_id === historyId)?.prompt;
+  } catch {
+    return void 0;
+  }
 }
 async function fetchSeatAgentModel(route, role, opts) {
   const agentId = await resolveAgentId(route, role, opts);
@@ -9270,6 +9300,11 @@ if (command === "passenger-sync-daemon") {
     if (!why) return false;
     emit.emit(`${why} \u2014 release skipped`, { step: "release" });
     return true;
+  }, baseHealth = function(r) {
+    const { remote, base } = r.config.branch;
+    const out = refreshBaseBranch(r.dir, remote, base, true);
+    const unsafe = baseBranchUnsafe(out);
+    return { action: out.action, unsafe, detail: unsafe ? describeUnsafeBase(out, remote, base) : out.detail };
   }, reportUnplaceable = function(c, unplaceable, verified, emit2) {
     if (unplaceableReported.has(c.route)) return;
     unplaceableReported.add(c.route);
@@ -9278,7 +9313,7 @@ if (command === "passenger-sync-daemon") {
       else emit2.emit(note.message, { step: "release" });
     }
   };
-  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, reportUnplaceable2 = reportUnplaceable;
+  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, baseHealth2 = baseHealth, reportUnplaceable2 = reportUnplaceable;
   let cfg;
   let firstRun;
   try {
@@ -11318,14 +11353,16 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       let acted = 0;
       let baseChecked = 0;
       let baseActed = 0;
+      let baseUnsafe = 0;
       for (const r of await resolvedRepos(route)) {
         const base = refreshBaseBranch(r.dir, r.config.branch.remote, r.config.branch.base, dryRun);
         if (base.action !== "not-applicable") {
           baseChecked++;
           if (base.action === "fetch-failed") emit.warn(base.detail);
-          else if (base.action === "diverged" || base.action === "ff-failed") {
+          else if (baseBranchUnsafe(base)) {
             baseActed++;
-            emit.warn(base.detail);
+            baseUnsafe++;
+            emit.error(`${r.name}: DO NOT CUT A WORKTREE FROM THIS BASE \u2014 ${describeUnsafeBase(base, r.config.branch.remote, r.config.branch.base)}`);
           } else if (base.action === "would-fast-forward" || base.action === "fast-forwarded") {
             baseActed++;
             emit.emit(base.detail);
@@ -11357,6 +11394,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
       }
+      if (baseUnsafe > 0) process.exitCode = 1;
       if (baseChecked > 0 && baseActed === 0) emit.emit(`${baseChecked} base branch(es) checked, all level with the remote`);
       if (tracked === 0) emit.emit("no worktree tracks a remote branch \u2014 nothing to sync");
       else if (acted === 0) emit.emit(`${tracked} worktree(s) tracking a remote, all level with it`);
@@ -11487,6 +11525,9 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             repos: repos.map((r) => ({
               name: r.name,
               dir: r.dir,
+              // Additive (CREW-1379): `unsafe` means a ship must not cut a
+              // worktree or release from this base. `version` stays 1.
+              baseBranch: baseHealth(r),
               worktreePrefix: r.config.worktrees.prefix,
               // A repo with no explicit `worktrees.prefix` no longer names its
               // worktrees `<prefix><number>` (ISSUE-969) — the checkout's own
@@ -11527,6 +11568,11 @@ watermark:  ${state.watermark()}
       }
       for (const i of openShipAttention(state)) {
         process.stdout.write(`attention:  ${i.kind} \u2014 ${i.message}
+`);
+      }
+      for (const r of await resolvedRepos(route)) {
+        const bh = baseHealth(r);
+        if (bh.unsafe) process.stdout.write(`base:       ${r.name} \u2014 UNSAFE, no worktree cuts or releases: ${bh.detail}
 `);
       }
       if (waiting) {
@@ -11581,6 +11627,12 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
           process.stdout.write(`                   - ${p2}
 `);
         }
+        const bh = baseHealth(r);
+        if (bh.action !== "not-applicable") {
+          process.stdout.write(`                   base ${config.branch.base}: ${bh.unsafe ? "ERROR \u2014 " : ""}${bh.detail}
+`);
+          if (bh.unsafe) process.exitCode = 1;
+        }
       }
       const missingAuthorship = await tracker.missingAuthorshipColumns();
       process.stdout.write(
@@ -11761,4 +11813,5 @@ var passengerApiKeys2;
 var endpointApiFor2;
 var endpointReconcileDeps2;
 var releaseRefused2;
+var baseHealth2;
 var reportUnplaceable2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",

package/prompts/default/personas/common.md

@@ -346,10 +346,13 @@ if `report_type` is either of those.
    missing commits another ship or a reviewer pushed since the last sync. It
    is quiet, not an alert, about a primary checkout that isn't cleanly on the
    base branch (something else may be mid-edit there) — that's expected, not
-   a fault, and just means this sync is a no-op. A genuinely DIVERGED base
-   branch is reported in `crew sync`'s own output; that's for the operator to
-   reconcile, not something to resolve yourself — carry on and cut the
-   worktree from whatever HEAD the primary checkout actually has. Then, from
+   a fault, and just means this sync is a no-op. A DIVERGED base
+   branch (local commits the remote lacks, or one that cannot fast-forward)
+   makes `crew sync` print `DO NOT CUT A WORKTREE FROM THIS BASE` and exit
+   non-zero. That is a hard stop: do not run `git worktree add`, do not try to
+   reconcile it yourself. Post a comment on the ticket naming the repo and the
+   counts `crew sync` printed, leave the ticket as you found it, and end the
+   run — the operator reconciles the checkout. Otherwise, from
    the primary checkout, `git worktree add` a sibling worktree for this
    ticket, on a new branch cut from the base branch's current HEAD. The
    digest's `worktree` and `branch` columns give this ticket's own directory

package/prompts/dev-qa/personas/common.md

@@ -327,10 +327,13 @@ if `report_type` is either of those.
    missing commits another ship or a reviewer pushed since the last sync. It
    is quiet, not an alert, about a primary checkout that isn't cleanly on the
    base branch (something else may be mid-edit there) — that's expected, not
-   a fault, and just means this sync is a no-op. A genuinely DIVERGED base
-   branch is reported in `crew sync`'s own output; that's for the operator to
-   reconcile, not something to resolve yourself — carry on and cut the
-   worktree from whatever HEAD the primary checkout actually has. Then, from
+   a fault, and just means this sync is a no-op. A DIVERGED base
+   branch (local commits the remote lacks, or one that cannot fast-forward)
+   makes `crew sync` print `DO NOT CUT A WORKTREE FROM THIS BASE` and exit
+   non-zero. That is a hard stop: do not run `git worktree add`, do not try to
+   reconcile it yourself. Post a comment on the ticket naming the repo and the
+   counts `crew sync` printed, leave the ticket as you found it, and end the
+   run — the operator reconciles the checkout. Otherwise, from
    the primary checkout, `git worktree add` a sibling worktree for this
    ticket, on a new branch cut from the base branch's current HEAD. The
    digest's `worktree` and `branch` columns give this ticket's own directory