@dieulc/workflow 0.8.0 → 0.9.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@dieulc/workflow",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "private": false,
   "keywords": ["pi-package", "workflow", "plan-mode", "review-mode", "questionnaire", "rewind"],
   "description": "Plan↔Build mode with an independent Review Mode reviewer, questionnaire, subagent explore, todos and shadow-checkpoint rewind for Pi.",
   "license": "MIT",
   "scripts": {
-    "test": "node --test utils.todo.test.ts permissions.test.ts roles.test.ts profiles.test.ts picker.test.ts questionnaire-layout.test.ts questionnaire-view.test.ts model-default.test.ts review.test.ts review-ui.test.ts commit-policy.test.ts edit-policy.test.ts tab-policy.test.ts tab-editor.test.ts",
+    "test": "node --test utils.todo.test.ts permissions.test.ts roles.test.ts profiles.test.ts thinking-levels.test.ts workflow-status.test.ts picker.test.ts questionnaire-layout.test.ts questionnaire-view.test.ts model-default.test.ts review.test.ts review-ui.test.ts extension.test.ts commit-policy.test.ts edit-policy.test.ts tab-policy.test.ts tab-editor.test.ts",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "check:policy": "node --experimental-transform-types scripts/verify-write-policy.mjs"
   },

package/review-runtime.ts

@@ -532,6 +532,10 @@ export function createReviewRuntime(deps: ReviewRuntimeDeps): ReviewRuntime {
     const remaining = (): number | undefined =>
       deadline === undefined ? undefined : Math.max(1, deadline - Date.now());
     let sendError: unknown;
+    // The losing waiters in the pass race must be cancelled when the winner
+    // settles. Otherwise their timers (up to `timeoutMs`, 5 minutes by
+    // default) stay referenced and keep the process alive after the round.
+    const waitAbort = new AbortController();
 
     const stop = await new Promise<PassStop>((resolve) => {
       let done = false;
@@ -542,6 +546,7 @@ export function createReviewRuntime(deps: ReviewRuntimeDeps): ReviewRuntime {
         done = true;
         if (timer !== undefined) clearTimeout(timer);
         rc.signal.removeEventListener("abort", onAbort);
+        waitAbort.abort();
         resolve(s);
       };
       if (rc.signal.aborted) {
@@ -551,10 +556,10 @@ export function createReviewRuntime(deps: ReviewRuntimeDeps): ReviewRuntime {
       const cap = remaining();
       if (cap !== undefined) timer = setTimeout(() => finish("timeout"), cap);
       rc.signal.addEventListener("abort", onAbort, { once: true });
-      void gate.waitForPassDone(remaining(), rc.signal).then((result) => {
+      void gate.waitForPassDone(remaining(), waitAbort.signal).then((result) => {
         if (result) finish("passDone");
       });
-      void waitForSettle(baseline, remaining(), rc.signal).then((did) => {
+      void waitForSettle(baseline, remaining(), waitAbort.signal).then((did) => {
         if (did) finish("settled");
       });
       void send().catch((e: unknown) => {

package/utils.ts

@@ -934,22 +934,27 @@ export function isPlanWritePath(p: string, cwd: string): boolean {
 /** Inputs for deciding whether this run may hand a plan off. */
 export interface PlanHandoffEligibility {
   mode: "plan" | "build" | null;
-  /** The run started in Plan mode (not a Build turn that flipped to Plan). */
-  runStartedInPlan: boolean;
   /** This run wrote/edited a file under `.pi/plans/`. */
   planWrittenThisRun: boolean;
+  /**
+   * The write happened while Plan mode was active. A run that starts in
+   * Default/Build and switches to Plan mid-run counts; a plan written before
+   * the switch does not. `agent_end`'s current-run message scan sets this too
+   * when the run ends in Plan (the tool_result handler was missed).
+   */
+  planWrittenInPlanMode: boolean;
 }
 
 /**
  * A handoff requires all three: the workflow is in Plan mode NOW, the run
- * started in Plan mode, and the run actually wrote a plan. Session-lifetime
+ * wrote a plan, and that write happened under Plan mode. Session-lifetime
  * plan files and old todos never authorize a handoff.
  */
 export function shouldHandoffPlan(input: PlanHandoffEligibility): boolean {
   return (
     input.mode === "plan" &&
-    input.runStartedInPlan === true &&
-    input.planWrittenThisRun === true
+    input.planWrittenThisRun === true &&
+    input.planWrittenInPlanMode === true
   );
 }
 
@@ -978,6 +983,73 @@ export function findPlanWritePathInMessages(
   return undefined;
 }
 
+/** Where a manual `/review` found the plan it is about to audit. */
+export type PlanPathSource =
+  | "explicit"
+  | "run"
+  | "session"
+  | "handoff"
+  | "branch";
+
+export interface PlanPathCandidate {
+  path?: string | null;
+  source: PlanPathSource;
+}
+
+export interface PlanPathSelection {
+  path: string;
+  source: PlanPathSource;
+}
+
+/**
+ * Pick the first readable plan for a manual `/review`.
+ *
+ * Candidates arrive in priority order (`explicit` → `run` → `session` →
+ * `handoff` → `branch`). Missing, empty and unreadable candidates are skipped;
+ * a plan that disappeared since it was written must never win over the next
+ * candidate. Pure: the caller owns path resolution and the filesystem probe.
+ */
+export function choosePlanPath(
+  candidates: readonly PlanPathCandidate[],
+  isReadable: (absolutePath: string) => boolean,
+): PlanPathSelection | undefined {
+  for (const candidate of candidates) {
+    const p = candidate.path;
+    if (typeof p !== "string" || p.length === 0) continue;
+    if (isReadable(p)) return { path: p, source: candidate.source };
+  }
+  return undefined;
+}
+
+/**
+ * Newest plan reference in a session branch, used as the last manual
+ * `/review` fallback after a reload or when the in-memory path was lost.
+ *
+ * Recognises the persisted `workflow` entry (`planFile`), the
+ * `workflow-handoff-resolve` entry (`planPath`), and an assistant `write`/
+ * `edit` tool call under `.pi/plans/`. Scans newest-first and never throws.
+ */
+export function findLatestPlanWriteInBranch(
+  entries: readonly unknown[],
+  cwd: string,
+): string | undefined {
+  if (!Array.isArray(entries) || entries.length === 0) return undefined;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i] as any;
+    if (!e || typeof e !== "object") continue;
+    if (e.type === "custom") {
+      const p = e.data?.planPath ?? e.data?.planFile;
+      if (typeof p === "string" && p && isPlanWritePath(p, cwd)) return p;
+      continue;
+    }
+    if (e.type === "message" && e.message) {
+      const found = findPlanWritePathInMessages([e.message], cwd);
+      if (found) return found;
+    }
+  }
+  return undefined;
+}
+
 // ── Plan date helpers (UTC) ──────────────────────────────────────
 
 /** Return YYYY-MM-DD in UTC for the given date (default: now). Uses toISOString slice, deterministic across locales. */