omp-conductor 0.3.24 → 0.4.0

package/src/unblock.ts

@@ -40,6 +40,11 @@ export interface UnblockOutcome {
   continuationsUsed: number;
   /** Newest attempt, when the store has one for this issue at all. */
   latest?: RunRecord;
+  /** Set when nothing was cleared because the newest attempt's work exists
+   *  only in its worktree. Carries the salvage failure verbatim. */
+  refused?: string;
+  /** Set when `--force` recorded an operator's acceptance of that loss. */
+  forced?: true;
 }
 
 /**
@@ -81,11 +86,35 @@ export async function unblockIssue(
   tracker: Tracker,
   store: Store,
   issue: number,
+  opts: { force?: boolean } = {},
 ): Promise<UnblockOutcome> {
   // Read before any label is touched: terminality is the whole of the argument
   // for clearing in-progress, so the row that carries it decides the set.
   const latest = store.latestRun(project.name, issue);
   const terminal = latest !== undefined && !LIVE_STATES.includes(latest.state);
+  const counts = {
+    attemptsUsed: store.attemptsFor(project.name, issue),
+    failuresUsed: store.failuresFor(project.name, issue),
+    continuationsUsed: store.continuationsFor(project.name, issue),
+  };
+
+  // The one case where this verb refuses. Clearing the labels here re-queues an
+  // issue whose next claim starts by force-removing the worktree that holds the
+  // only copy of the last attempt's work (#118) — and unlike every other state
+  // this function reasons about, that is unrecoverable. `--force` is the way
+  // through, and it is deliberately a separate keystroke rather than a prompt
+  // the operator can wave past: it records, on the row, that a human accepted
+  // the loss or recovered the tree themselves. Narrowed to the row rather than
+  // a boolean so the reason printed and the acknowledgement written are
+  // provably about the same run.
+  const held =
+    latest !== undefined && latest.salvageError !== undefined && latest.salvageAckAt === undefined
+      ? latest
+      : undefined;
+  if (held !== undefined && opts.force !== true) {
+    return { cleared: [], ...counts, latest: held, refused: held.salvageError };
+  }
+  if (held !== undefined) store.updateRun(held.id, { salvageAckAt: Date.now() });
 
   const cleared: string[] = [];
   for (const label of new Set([
@@ -99,10 +128,9 @@ export async function unblockIssue(
 
   return {
     cleared,
-    attemptsUsed: store.attemptsFor(project.name, issue),
-    failuresUsed: store.failuresFor(project.name, issue),
-    continuationsUsed: store.continuationsFor(project.name, issue),
+    ...counts,
     ...(latest === undefined ? {} : { latest }),
+    ...(held === undefined ? {} : { forced: true as const }),
   };
 }
 
@@ -116,6 +144,11 @@ export async function unblockIssue(
  * run row at all, where that label may still be sitting there unread. #18 was
  * filed against this function saying `next tick eligible again` in a case where
  * it was not, so the wording is a contract rather than prose.
+ *
+ * A refusal is the loudest thing this verb prints, and it prints instead of
+ * everything else: the operator asked to re-queue an issue whose only copy of
+ * real work is a directory, and the next line they read has to be the one that
+ * stops them typing the same command again with `--force` on the end.
  */
 export function formatUnblock(
   issue: number,
@@ -124,7 +157,24 @@ export function formatUnblock(
   caps: Caps,
 ): string {
   const latest = o.latest;
+
+  if (o.refused !== undefined) {
+    return [
+      `#${issue}: REFUSED — nothing was cleared`,
+      `  reason     attempt ${latest?.attempt ?? "?"} could not commit its work: ${o.refused}`,
+      `  only copy  ${latest?.worktree === undefined || latest.worktree === "" ? "(worktree path not recorded)" : latest.worktree}`,
+      "  why        re-claiming this issue removes that worktree, and the work is not on any ref",
+      `  recover    inspect the tree and commit or copy what matters, then re-run with --force`,
+    ].join("\n");
+  }
+
   const lines = [`#${issue}: cleared ${o.cleared.join(", ")}`];
+  if (o.forced === true) {
+    lines.push(
+      `  forced     the unsalvaged worktree was accepted as lost or already recovered by hand — ` +
+        "the next claim removes it",
+    );
+  }
 
   if (latest === undefined) {
     lines.push("  runs       none recorded — the terminal labels were cleared anyway; eligibility is read off the tracker");