@tablation/crew 0.11.0 → 0.12.1

package/dist/cli.js

@@ -1682,7 +1682,8 @@ var DEFAULT_CONTRACT = {
     reportType: "report_type",
     epic: "epic_id",
     author: "filed_by_id",
-    ship: "ship_id"
+    ship: "ship_id",
+    heldBy: "held_by_ship_id"
   },
   comments: {
     parent: "ticket_id",
@@ -2971,6 +2972,20 @@ var Tracker = class {
       ...auth.commentShip && auth.shipId ? { [this.contract.comments.ship]: auth.shipId } : {}
     });
   }
+  /**
+   * Ship affinity for a claim (CREW-1386): stamp this ship's Ships row on the
+   * ticket in the claim's own write, in the `held_by_ship_id` column (not
+   * `ship_id`, which means "filed from"). `undefined` — claim exactly as
+   * before — when the Issues table has no hold column or this ship has no row.
+   */
+  async claimAffinity() {
+    const auth = await this.authorshipProbe();
+    if (!auth.issueHeld || !auth.shipId) return void 0;
+    return {
+      column: this.contract.columns.heldBy,
+      shipId: auth.shipId
+    };
+  }
   /**
    * The authorship probe (CREW-1371), read once per process: which optional
    * `filed_by_id`/`ship_id` columns exist on Issues and Comments, and this
@@ -2992,6 +3007,7 @@ var Tracker = class {
     return {
       issueAuthor: issueFields.has(this.contract.columns.author),
       issueShip: issueFields.has(this.contract.columns.ship),
+      issueHeld: issueFields.has(this.contract.columns.heldBy),
       commentShip: commentFields.has(this.contract.comments.ship),
       shipId: shipRow?.id ?? null
     };
@@ -3013,6 +3029,7 @@ var Tracker = class {
     const missing = [];
     if (!auth.issueAuthor) missing.push(`Issues.${this.contract.columns.author}`);
     if (!auth.issueShip) missing.push(`Issues.${this.contract.columns.ship}`);
+    if (!auth.issueHeld) missing.push(`Issues.${this.contract.columns.heldBy}`);
     if (!auth.commentShip) missing.push(`Comments.${this.contract.comments.ship}`);
     return missing;
   }
@@ -3333,6 +3350,63 @@ function agedRankScalar(rawRank, aging, now) {
   return Math.round(rawRank * (1 - fraction));
 }
 
+// src/ship-affinity.ts
+var CYCLE_SECONDS = 120;
+var SHIP_DEAD_AFTER_CYCLES = 10;
+function shipIsAlive(ship, now) {
+  if (!ship?.last_seen) return false;
+  const seen = Date.parse(ship.last_seen);
+  return Number.isFinite(seen) && now - seen <= SHIP_DEAD_AFTER_CYCLES * CYCLE_SECONDS * 1e3;
+}
+function ticketHolderShipId(t, contract) {
+  const v = t[contract.columns.heldBy];
+  return typeof v === "string" && v ? v : null;
+}
+function heldByOtherShip(t, a) {
+  const statuses = a.contract.statuses;
+  if ([statuses.handoff, statuses.verifying].includes(t.status)) return false;
+  return heldByLiveOtherShip(t, a);
+}
+function heldByLiveOtherShip(t, a) {
+  if (!a.myShipId) return false;
+  const holder = ticketHolderShipId(t, a.contract);
+  if (!holder || holder === a.myShipId) return false;
+  const owner = a.ships.find((s) => s.id === holder);
+  return shipIsAlive(owner, a.now ?? Date.now());
+}
+function shipIdByName(ships, name) {
+  const mine = ships.filter((r) => (r.name ?? "").trim() === name.trim());
+  return mine.length === 1 ? mine[0].id : null;
+}
+async function noteReaccepted(tracker, result, seat, shipLabel) {
+  if (!result.reaccepted || !result.ticket) return;
+  try {
+    await tracker.postEvent(
+      result.ticket.id,
+      `Re-accepted while held by ${shipLabel}; resuming there, not re-claiming. Setting a held ticket back to \`accepted\` is not needed \u2014 to move it to another ship, clear \`held_by_ship_id\`.`,
+      seat
+    );
+  } catch {
+  }
+}
+function planHoldReleases(tickets, contract) {
+  const ends = [contract.statuses.handoff, contract.statuses.verified];
+  return tickets.filter((t) => ends.includes(t.status) && ticketHolderShipId(t, contract) !== null);
+}
+async function applyHoldReleases(writer, tickets, contract, emit) {
+  let cleared = 0;
+  for (const t of tickets) {
+    try {
+      await writer.updateTicket(t.id, { [contract.columns.heldBy]: null }, t.updated_at);
+      cleared++;
+      emit.emit(`released ship hold (${t.status})`, { ticket: t.issue_id, step: "sweep" });
+    } catch (e) {
+      emit.warn(`could not release ship hold: ${e.message}`, { ticket: t.issue_id, step: "sweep" });
+    }
+  }
+  return cleared;
+}
+
 // src/select.ts
 var qaSlice = (tickets) => tickets.filter((t) => t.status === "fixed" || t.status === "qa");
 var buildingSlice = (tickets, role) => tickets.filter((t) => role === "design" ? t.needs_design === true : t.needs_design !== true);
@@ -3344,10 +3418,23 @@ function sliceFor(tickets, role) {
   return buildingSlice(tickets, role);
 }
 var isHeld = (t, holds2) => !!t.assignee_id && holds2.has(t.assignee_id);
+function affinityContext(i) {
+  return i.ships ? { myShipId: i.ships.myShipId, ships: i.ships.rows, contract: i.contract ?? DEFAULT_CONTRACT, now: i.ships.now } : null;
+}
+function withHoldCheck(affinity, i) {
+  if (!affinity) return void 0;
+  const a = affinityContext(i);
+  return a ? { ...affinity, isHeldElsewhere: (t) => heldByOtherShip(t, a), isLiveHoldElsewhere: (t) => heldByLiveOtherShip(t, a) } : affinity;
+}
+function notHeldByOtherShip(slice, i) {
+  if (!i.ships) return slice;
+  const a = { myShipId: i.ships.myShipId, ships: i.ships.rows, contract: i.contract ?? DEFAULT_CONTRACT, now: i.ships.now };
+  return slice.filter((t) => !heldByOtherShip(t, a));
+}
 function buildingRoleHasWork(role, i) {
   const me = i.seats[role];
   if (!me) return { hasWork: false, reason: "this ship does not crew that role" };
-  const mine = sliceFor(i.tickets, role);
+  const mine = notHeldByOtherShip(sliceFor(i.tickets, role), i);
   const startable = mine.filter(
     (t) => (t.status === "accepted" || t.status === "blocked") && !i.blocked.has(t.id) && !isHeld(t, i.holds)
   );
@@ -3397,7 +3484,7 @@ function roleCandidates(role, i) {
   if (role === "pair") return [];
   const me = i.seats[role];
   if (!me) return [];
-  return sliceFor(i.tickets, role).filter(
+  return notHeldByOtherShip(sliceFor(i.tickets, role), i).filter(
     (t) => ((t.status === "accepted" || t.status === "blocked") && !i.blocked.has(t.id) || t.status === "in_progress" && (t.assignee_id === me || !t.assignee_id)) && !isHeld(t, i.holds)
   );
 }
@@ -4220,6 +4307,7 @@ async function decideCycle(o) {
     emit.warn(`ticket(s) blocking themselves, parked permanently: ${diag.selfBlocked.join(", ")}`);
   }
   const sweep = planSweep(tickets, info, blocked);
+  const holdReleases = planHoldReleases(tickets, tracker.contract);
   const blockedIssues = tickets.filter((t) => blocked.has(t.id)).map((t) => t.issue_id);
   emit.emit(`${blockedIssues.length} ticket(s) parked as blocked`, { data: { blocked: blockedIssues } });
   const qaHeld = tickets.filter((t) => t.status === tracker.contract.statuses.verifying).map((t) => t.issue_id);
@@ -4287,7 +4375,8 @@ async function decideCycle(o) {
     holds: holds2,
     seats: route.resolved.seats,
     paused: state.pausedRoles(["dev", "design", "qa"]),
-    contract: tracker.contract
+    contract: tracker.contract,
+    ships: { myShipId: shipIdByName(ships, ship.name), rows: ships }
   };
   const selection = selectRole(selectionInput);
   const actionable = actionableSummary(selectionInput, selection.pending);
@@ -4300,6 +4389,7 @@ async function decideCycle(o) {
     info,
     sweep,
     epicSync,
+    holdReleases,
     stranded,
     selection,
     actionable,
@@ -4400,22 +4490,65 @@ function rosterFor(d, route, role) {
 
 // src/claim.ts
 import { StaleWriteError as StaleWriteError4 } from "@tablation/client";
-async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, buildingStatus, isServable) {
+async function stampResumption(tracker, t, affinity) {
+  let current = t;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const stamped = await tracker.updateTicket(current.id, { [affinity.column]: affinity.shipId }, current.updated_at);
+      return { outcome: "stamped", ticket: { ...current, ...stamped } };
+    } catch (e) {
+      if (!(e instanceof StaleWriteError4)) throw e;
+    }
+    if (!tracker.ticket) return { outcome: "unknown" };
+    try {
+      current = await tracker.ticket(t.id);
+    } catch {
+      return { outcome: "unknown" };
+    }
+    if ((affinity.isLiveHoldElsewhere ?? affinity.isHeldElsewhere)?.(current)) return { outcome: "held" };
+    if (current[affinity.column] === affinity.shipId) return { outcome: "stamped", ticket: current };
+  }
+  return { outcome: "unknown" };
+}
+async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, buildingStatus, isServable, affinity) {
   const contended = [];
   const unservable = [];
+  const held = [];
   for (const t of candidates) {
+    if (affinity?.isHeldElsewhere?.(t)) {
+      held.push(t.issue_id);
+      continue;
+    }
     if (isServable && !isServable(t)) {
       unservable.push(t.issue_id);
       continue;
     }
-    if (t.status !== approvedStatus) return { ticket: t, claimed: false, contended, unservable };
+    if (t.status !== approvedStatus) {
+      if (affinity?.isLiveHoldElsewhere?.(t)) {
+        return { ticket: t, claimed: false, contended, unservable, held, reaccepted: false };
+      }
+      if (affinity && t[affinity.column] !== affinity.shipId) {
+        const stamp = await stampResumption(tracker, t, affinity);
+        if (stamp.outcome === "stamped") {
+          return { ticket: stamp.ticket, claimed: false, contended, unservable, held, reaccepted: false };
+        }
+        (stamp.outcome === "held" ? held : contended).push(t.issue_id);
+        continue;
+      }
+      return { ticket: t, claimed: false, contended, unservable, held, reaccepted: false };
+    }
     try {
       const claimed = await tracker.updateTicket(
         t.id,
-        { status: buildingStatus, assignee_id: seat },
+        {
+          status: buildingStatus,
+          assignee_id: seat,
+          ...affinity ? { [affinity.column]: affinity.shipId } : {}
+        },
         t.updated_at
       );
-      return { ticket: { ...t, ...claimed }, claimed: true, contended, unservable };
+      const reaccepted = !!affinity && t[affinity.column] === affinity.shipId;
+      return { ticket: { ...t, ...claimed }, claimed: true, contended, unservable, held, reaccepted };
     } catch (e) {
       if (e instanceof StaleWriteError4) {
         contended.push(t.issue_id);
@@ -4424,7 +4557,7 @@ async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, bu
       throw e;
     }
   }
-  return { ticket: null, claimed: false, contended, unservable };
+  return { ticket: null, claimed: false, contended, unservable, held, reaccepted: false };
 }
 
 // src/conflict.ts
@@ -8976,6 +9109,10 @@ async function runOnePass(o) {
       emit.warn(`could not sweep: ${e.message}`, { step: "sweep" });
     }
   }
+  if (decision.holdReleases?.length) {
+    const tracker = new Tracker(o.route, o.ship);
+    await applyHoldReleases(tracker, decision.holdReleases, tracker.contract, emit);
+  }
   const order = [...decision.selection.pending].sort(
     (a, b) => (decision.selection.ranks[a] ?? Number.POSITIVE_INFINITY) - (decision.selection.ranks[b] ?? Number.POSITIVE_INFINITY)
   );
@@ -9052,7 +9189,8 @@ async function runRoleAgent(role, decision, ctx) {
         seat,
         contract.statuses.approved,
         contract.statuses.building,
-        (t) => dirForRepo(route, t.repo_id) !== null
+        (t) => dirForRepo(route, t.repo_id) !== null,
+        withHoldCheck(await tracker.claimAffinity(), decision.selectionInput)
       );
       if (result.contended.length) {
         emit.emit(`claim contended for ${result.contended.join(", ")} \u2014 moved to the next candidate`, {
@@ -9066,6 +9204,10 @@ async function runRoleAgent(role, decision, ctx) {
           role
         });
       }
+      if (result.held.length) {
+        emit.emit(`skipped ${result.held.join(", ")} \u2014 held by another live ship`, { step: "select", role });
+      }
+      await noteReaccepted(tracker, result, seat, ship.name);
       if (!result.ticket) {
         emit.emit(`${role} skipped this cycle \u2014 every candidate was already claimed elsewhere`);
         return;
@@ -9160,12 +9302,12 @@ async function buildEnvironment(route, ship, ticket) {
 // src/cli.ts
 var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname10(process.execPath) : resolve4(dirname10(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
-var CYCLE_SECONDS = 120;
+var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
 function renderShipLine(s, issueLabelById) {
   const name = s.name ?? "(unnamed)";
   if (!s.last_seen) return `${name.padEnd(20)} never seen`;
-  const staleAfterMs = STALE_CYCLES * CYCLE_SECONDS * 1e3;
+  const staleAfterMs = STALE_CYCLES * CYCLE_SECONDS2 * 1e3;
   const ageMs = Date.now() - Date.parse(s.last_seen);
   if (ageMs > staleAfterMs) {
     return `${name.padEnd(20)} not seen recently \u2014 last seen ${since(s.last_seen)} ago`;
@@ -10012,6 +10154,11 @@ ${changed2.map((c) => `  - ${c}
           const tracker = new Tracker(e.route, cfg.ship);
           await applyEpicSync(tracker, e.decision.epicSync, tracker.contract, remit);
         }
+        for (const e of fleet.entries) {
+          if (dryRun || e.error || !e.decision?.holdReleases?.length) continue;
+          const tracker = new Tracker(e.route, cfg.ship);
+          await applyHoldReleases(tracker, e.decision.holdReleases, tracker.contract, emit.forRoute(e.route.route));
+        }
         for (const e of fleet.entries) {
           if (e.error || !e.decision || !e.decision.sweep.length) continue;
           const remit = emit.forRoute(e.route.route);
@@ -10103,7 +10250,8 @@ ${changed2.map((c) => `  - ${c}
               seat,
               contract.statuses.approved,
               contract.statuses.building,
-              (t) => dirForRepo(w.route, t.repo_id) !== null
+              (t) => dirForRepo(w.route, t.repo_id) !== null,
+              withHoldCheck(await fleetTracker.claimAffinity(), w.decision.selectionInput)
             );
             if (result.contended.length) {
               wemit.emit(`claim contended for ${result.contended.join(", ")} \u2014 moved to the next candidate`, {
@@ -10117,6 +10265,10 @@ ${changed2.map((c) => `  - ${c}
                 { step: "select", role: w.role }
               );
             }
+            if (result.held.length) {
+              wemit.emit(`skipped ${result.held.join(", ")} \u2014 held by another live ship`, { step: "select", role: w.role });
+            }
+            await noteReaccepted(fleetTracker, result, seat, cfg.ship.name);
             if (!result.ticket) {
               wemit.emit(`${w.role} skipped this cycle \u2014 every candidate was already claimed elsewhere`);
               if (!skipInlineRelease) await releaseFleet();
@@ -10227,6 +10379,10 @@ ${changed2.map((c) => `  - ${c}
           await applyEpicSync(tracker, decision.epicSync, tracker.contract, emit);
         }
       }
+      if (!dryRun && decision.holdReleases?.length) {
+        const tracker = new Tracker(route, cfg.ship);
+        await applyHoldReleases(tracker, decision.holdReleases, tracker.contract, emit);
+      }
       const role = value("role") ?? decision.selection.selected;
       if (command === "poll") break;
       if (!dryRun) {
@@ -10275,7 +10431,8 @@ ${changed2.map((c) => `  - ${c}
               seat,
               contract.statuses.approved,
               contract.statuses.building,
-              (t) => dirForRepo(route, t.repo_id) !== null
+              (t) => dirForRepo(route, t.repo_id) !== null,
+              withHoldCheck(await tracker2.claimAffinity(), decision.selectionInput)
             );
             if (result.contended.length) {
               emit.emit(`claim contended for ${result.contended.join(", ")} \u2014 moved to the next candidate`, {
@@ -10289,6 +10446,10 @@ ${changed2.map((c) => `  - ${c}
                 { step: "select", role: current }
               );
             }
+            if (result.held.length) {
+              emit.emit(`skipped ${result.held.join(", ")} \u2014 held by another live ship`, { step: "select", role: current });
+            }
+            await noteReaccepted(tracker2, result, seat, cfg.ship.name);
             if (!result.ticket) {
               emit.emit(`${current} skipped this cycle \u2014 every candidate was already claimed elsewhere`);
               dropLock();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.11.0",
+  "version": "0.12.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

@@ -198,7 +198,7 @@ since your last comment: an answer to a question, new direction, or a
   the remote has moved), stop: comment on the ticket with what it printed and
   set `needs_info`; do not merge or rebase it yourself.
 - A ticket QA has bounced back to you comes in as `in_progress`,
-  reassigned to your row, with a comment saying what still fails. Treat
+  reassigned to your row (or unassigned, when your ship holds it), with a comment saying what still fails. Treat
   that exactly like new direction from a hold: read the comment, fix what
   it names, and take it back to `fixed` when it's genuinely right. QA
   bouncing a ticket is the system working, not an accusation.
@@ -532,6 +532,10 @@ if `report_type` is either of those.
    part).
 9. Set the ticket's `status` to `fixed` once you have verified it yourself,
    and **clear `assignee_id`** — that pair is the hand-off to the QA lane.
+   If the Issues table has a `held_by_ship_id` column, clear it in the same
+   write (the hold is for the building roles; QA on any ship may take a `fixed`
+   ticket). A QA bounce or `needs_info` park leaves it set; QA clears it again
+   when it sets `verified`.
    **Push the branch first, in the same step:**
    `git push --set-upstream <remote> <branch>` from the worktree (the remote is
    `origin` unless the repo's `.crew.yaml` says otherwise; a repo with no remote

package/prompts/default/personas/lane-qa.md

@@ -114,7 +114,11 @@ human review, so "probably fine" is not a pass.
      covered.
    - **It doesn't** → `status` = `in_progress`, `assignee_id` = the building
      lane's own Crew row id from the roster above — the dev seat if
-     `needs_design` is false or null, the design seat if true. The comment
+     `needs_design` is false or null, the design seat if true. **Exception:** when the ticket carries a `held_by_ship_id`, leave that column
+     untouched and **clear** `assignee_id` instead of naming a seat — seats are
+     per ship, and the ship that holds the branch resumes an unassigned
+     `in_progress` ticket because it is the holder. Naming this ship's seat
+     would hand the bounce to a ship that never built it. The comment
      must be actionable:
      exactly what you did, what you expected, what happened, with a
      screenshot or the failing output. This includes a red suite, a

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

@@ -179,7 +179,7 @@ since your last comment: an answer to a question, new direction, or a
   the remote has moved), stop: comment on the ticket with what it printed and
   set `needs_info`; do not merge or rebase it yourself.
 - A ticket QA has bounced back to you comes in as `in_progress`,
-  reassigned to your row, with a comment saying what still fails. Treat
+  reassigned to your row (or unassigned, when your ship holds it), with a comment saying what still fails. Treat
   that exactly like new direction from a hold: read the comment, fix what
   it names, and take it back to `fixed` when it's genuinely right. QA
   bouncing a ticket is the system working, not an accusation.
@@ -514,6 +514,10 @@ if `report_type` is either of those.
    part).
 9. Set the ticket's `status` to `fixed` once you have verified it yourself,
    and **clear `assignee_id`** — that pair is the hand-off to the QA lane.
+   If the Issues table has a `held_by_ship_id` column, clear it in the same
+   write (the hold is for the building roles; QA on any ship may take a `fixed`
+   ticket). A QA bounce or `needs_info` park leaves it set; QA clears it again
+   when it sets `verified`.
    **Push the branch first, in the same step:**
    `git push --set-upstream <remote> <branch>` from the worktree (the remote is
    `origin` unless the repo's `.crew.yaml` says otherwise; a repo with no remote

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

@@ -104,7 +104,11 @@ human review, so "probably fine" is not a pass.
      the comment what you exercised, so the record shows what "verified"
      covered.
    - **It doesn't** → `status` = `in_progress`, `assignee_id` = the dev
-     seat's own Crew row id from the roster above. The comment must be
+     seat's own Crew row id from the roster above. **Exception:** when the ticket carries a `held_by_ship_id`, leave that column
+     untouched and **clear** `assignee_id` instead of naming a seat — seats are
+     per ship, and the ship that holds the branch resumes an unassigned
+     `in_progress` ticket because it is the holder. Naming this ship's seat
+     would hand the bounce to a ship that never built it. The comment must be
      actionable:
      exactly what you did, what you expected, what happened, with a
      screenshot or the failing output. This includes a red suite, a