issue-flow 0.11.1 → 0.12.0

package/dist/resume-PPCNQVVV.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import {
+  runPipeline
+} from "./chunk-NTMMF5UD.js";
+import "./chunk-FJP3UQGD.js";
+import "./chunk-FADTCQGM.js";
+import "./chunk-A4SLHOW7.js";
+import "./chunk-M5UCXTIT.js";
+import "./chunk-XQUSIEKA.js";
+import {
+  PIPELINE_PHASES,
+  PipelineManager,
+  loadExecutionPlan,
+  nextQueueIssue,
+  parseJournal
+} from "./chunk-56KS3TFQ.js";
+import {
+  acquireRunLock,
+  describeRunLockOwner
+} from "./chunk-BAUPQXPE.js";
+import "./chunk-NS6R37II.js";
+import "./chunk-3QHK4YQA.js";
+import "./chunk-TSOLWK7Y.js";
+import "./chunk-QCPGHBSZ.js";
+import "./chunk-Y5ZDJ4PJ.js";
+import "./chunk-73ATPIYX.js";
+import "./chunk-4JSOYE4G.js";
+import "./chunk-KMMASOA6.js";
+import "./chunk-LWRSMTTZ.js";
+import "./chunk-MJULIKQU.js";
+import "./chunk-LAFNLLQP.js";
+import "./chunk-M66SJHQQ.js";
+import "./chunk-EZATO3DW.js";
+import "./chunk-42PJFMAR.js";
+import {
+  QUEUES_DIR_NAME,
+  describePreflight,
+  getIssuePaths,
+  preflightRepository,
+  resolveProjectPaths
+} from "./chunk-DIDUVL6O.js";
+import {
+  printError,
+  printInfo,
+  printWarning
+} from "./chunk-BYZDPR7N.js";
+import {
+  loadTaskPlan
+} from "./chunk-CD5ULRVC.js";
+
+// src/commands/resume.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+async function runResume(issue, options = {}) {
+  const mode = options.mode ?? "auto";
+  let project;
+  try {
+    project = await resolveProjectPaths();
+  } catch (err) {
+    printError(`Cannot resume: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  const acquisition = await acquireRunLock(project.runLockFile, { target: issue ?? "resume" });
+  if (!acquisition.ok) {
+    printError(
+      `Another issue-flow run owns this project: ${describeRunLockOwner(acquisition.owner)}.`
+    );
+    printInfo("Wait for it to finish, or stop that process before resuming.");
+    return 1;
+  }
+  const handle = acquisition.handle;
+  if (handle.reclaimedFrom !== null) {
+    printWarning(
+      `Taking over an interrupted run: ${describeRunLockOwner(handle.reclaimedFrom)}. Its lock was stale.`
+    );
+  }
+  try {
+    const targets = await findTargets(project, issue, options.all === true);
+    if (targets.length === 0) {
+      printInfo(
+        issue === void 0 ? "Nothing to resume: no issue in this project has an unfinished pipeline." : `Nothing to resume: issue #${issue} has no task plan in this project.`
+      );
+      return 0;
+    }
+    for (const target of targets) {
+      const code = await resumeOne(target, mode);
+      if (code !== 0) return code;
+    }
+    return 0;
+  } finally {
+    await handle.release();
+  }
+}
+async function resumeOne(target, mode) {
+  const phases = activePhases(target.plan);
+  const manager = new PipelineManager(target.plan, target.tasksFile, phases);
+  const next = manager.getNextPhase();
+  if (next === null) {
+    printInfo(`Issue #${target.issue} has every phase complete; nothing to resume.`);
+    return 0;
+  }
+  const interrupted = await lastUnfinishedPhase(target);
+  if (interrupted !== null) {
+    printInfo(`Issue #${target.issue} was interrupted during the '${interrupted}' phase.`);
+  }
+  const sameWork = interrupted === next;
+  const preflight = await preflightRepository({
+    expectedBranch: target.plan.noBranch === true ? null : target.plan.branchName,
+    intent: sameWork ? "resume-same-phase" : "new-phase"
+  });
+  if (!preflight.ok) {
+    printError(`Cannot resume issue #${target.issue}: the repository needs attention first.`);
+    for (const line of describePreflight(preflight)) {
+      printError(line);
+    }
+    return 1;
+  }
+  printInfo(`Resuming issue #${target.issue} from the '${next}' phase.`);
+  return runPipeline(target.issue, mode, next, void 0, void 0, { only: true });
+}
+function activePhases(plan) {
+  const base = plan.noBranch === true ? PIPELINE_PHASES.filter((phase) => phase !== "pr") : [...PIPELINE_PHASES];
+  return plan.prReview?.enabled === true ? [...base, "pr-review"] : base;
+}
+async function lastUnfinishedPhase(target) {
+  const content = `${await readIfPresent(target.rotatedEventsFile)}${await readIfPresent(target.eventsFile)}`;
+  if (content === "") return null;
+  const open = [];
+  for (const entry of parseJournal(content)) {
+    const event = entry.event;
+    if (event.type === "phase:start") {
+      open.push(event.phase);
+    } else if (event.type === "phase:end") {
+      const index = open.lastIndexOf(event.phase);
+      if (index >= 0) open.splice(index, 1);
+    }
+  }
+  return open.at(-1) ?? null;
+}
+async function readIfPresent(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function findTargets(project, issue, all) {
+  if (issue !== void 0) {
+    const target = await loadTarget(project.projectId, issue);
+    return target === null ? [] : [target];
+  }
+  const queued = await queueTarget(project);
+  if (queued !== null && !all) return [queued];
+  const unfinished = await unfinishedTargets(project);
+  if (all) return unfinished;
+  return unfinished.slice(0, 1);
+}
+async function queueTarget(project) {
+  const queuesDir = join(project.projectDir, QUEUES_DIR_NAME);
+  let entries;
+  try {
+    entries = await readdir(queuesDir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const plan = await loadExecutionPlan(join(queuesDir, entry, "execution-plan.json"));
+    if (plan === null) continue;
+    const next = nextQueueIssue(plan);
+    if (next === null) continue;
+    const target = await loadTarget(project.projectId, next.id);
+    if (target !== null) return target;
+  }
+  return null;
+}
+async function unfinishedTargets(project) {
+  let ids;
+  try {
+    ids = await readdir(project.issuesDir);
+  } catch {
+    return [];
+  }
+  const targets = [];
+  for (const id of ids) {
+    const target = await loadTarget(project.projectId, id);
+    if (target === null) continue;
+    if (target.plan.issueStatus === "completed") continue;
+    const manager = new PipelineManager(target.plan, target.tasksFile, activePhases(target.plan));
+    if (manager.getNextPhase() === null) continue;
+    targets.push(target);
+  }
+  return targets.sort((a, b) => attemptedAt(b.plan) - attemptedAt(a.plan));
+}
+function attemptedAt(plan) {
+  const at = Date.parse(plan.lastAttemptAt ?? "");
+  return Number.isNaN(at) ? 0 : at;
+}
+async function loadTarget(projectId, issue) {
+  let paths;
+  try {
+    paths = getIssuePaths(projectId, issue);
+  } catch {
+    return null;
+  }
+  try {
+    const plan = await loadTaskPlan(paths.tasksFile);
+    return {
+      issue,
+      plan,
+      tasksFile: paths.tasksFile,
+      eventsFile: paths.eventsFile,
+      rotatedEventsFile: paths.rotatedEventsFile
+    };
+  } catch {
+    return null;
+  }
+}
+export {
+  runResume
+};
+//# sourceMappingURL=resume-PPCNQVVV.js.map

package/dist/resume-PPCNQVVV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/resume.ts"],"sourcesContent":["import { readdir, readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { parseJournal } from '../core/journal.js';\nimport { PIPELINE_PHASES, PipelineManager, type PipelinePhase } from '../core/pipeline.js';\nimport { loadTaskPlan } from '../core/state-manager.js';\nimport { loadExecutionPlan, nextQueueIssue } from '../execution/plan.js';\nimport { acquireRunLock, describeRunLockOwner, type RunLockHandle } from '../storage/lock.js';\nimport { getIssuePaths, QUEUES_DIR_NAME } from '../storage/paths.js';\nimport { resolveProjectPaths } from '../storage/resolve.js';\nimport type { TaskPlan } from '../types.js';\nimport { printError, printInfo, printWarning } from '../ui/logger.js';\nimport { describePreflight, preflightRepository } from '../utils/git.js';\nimport { runPipeline } from './run.js';\n\n/**\n * `issue-flow resume` — explicit recovery.\n *\n * Resumption already worked before this command existed, but only *implicitly*:\n * the user re-ran the same `run` and the pipeline happened to pick up where it\n * left off, because `PipelineManager` skips the phases already marked complete\n * and `nextQueueIssue()` treats a stale `in_progress` as \"do this one first\".\n * That is a coincidence of two mechanisms, not a contract — nothing said what\n * had been interrupted, nothing checked whether the repository was still in a\n * state to continue, and nothing distinguished \"carry on\" from \"start over\".\n *\n * This command makes each of those steps explicit, in this order:\n *\n * 1. **ownership** — a live owner refuses, a dead one is taken over;\n * 2. **plans** — `execution-plan.json` for a queue, `tasks.json` for an issue;\n * 3. **the journal** — the last `phase:start` with no `phase:end` is what was\n *    running when the process died, which is the one fact no snapshot keeps;\n * 4. **the preflight** — the repository is described, and a state a human has to\n *    settle stops the resume instead of being repaired;\n * 5. **the phase** — `PipelineManager.getNextPhase()`, the same answer `run`\n *    has always used, now stated out loud before anything runs.\n *\n * `run` is untouched: its auto-resume still works exactly as it did.\n */\n\nexport interface ResumeOptions {\n  /** Resume every unfinished issue of the project, not just one. */\n  all?: boolean;\n  /** Execution mode handed to the pipeline. Same values as `run`. */\n  mode?: string;\n}\n\ninterface ResumeTarget {\n  issue: string;\n  plan: TaskPlan;\n  tasksFile: string;\n  eventsFile: string;\n  rotatedEventsFile: string;\n}\n\nexport async function runResume(issue?: string, options: ResumeOptions = {}): Promise<number> {\n  const mode = options.mode ?? 'auto';\n\n  let project: Awaited<ReturnType<typeof resolveProjectPaths>>;\n  try {\n    project = await resolveProjectPaths();\n  } catch (err) {\n    printError(`Cannot resume: ${err instanceof Error ? err.message : String(err)}`);\n    return 1;\n  }\n\n  // 1. Ownership, before reading anything else: a resume that runs beside a\n  // live owner is the collision this whole layer exists to prevent.\n  const acquisition = await acquireRunLock(project.runLockFile, { target: issue ?? 'resume' });\n  if (!acquisition.ok) {\n    printError(\n      `Another issue-flow run owns this project: ${describeRunLockOwner(acquisition.owner)}.`,\n    );\n    printInfo('Wait for it to finish, or stop that process before resuming.');\n    return 1;\n  }\n  const handle: RunLockHandle = acquisition.handle;\n  if (handle.reclaimedFrom !== null) {\n    printWarning(\n      `Taking over an interrupted run: ${describeRunLockOwner(handle.reclaimedFrom)}. Its lock was stale.`,\n    );\n  }\n\n  try {\n    // 2. What is there to resume.\n    const targets = await findTargets(project, issue, options.all === true);\n    if (targets.length === 0) {\n      printInfo(\n        issue === undefined\n          ? 'Nothing to resume: no issue in this project has an unfinished pipeline.'\n          : `Nothing to resume: issue #${issue} has no task plan in this project.`,\n      );\n      return 0;\n    }\n\n    for (const target of targets) {\n      const code = await resumeOne(target, mode);\n      if (code !== 0) return code;\n    }\n    return 0;\n  } finally {\n    await handle.release();\n  }\n}\n\nasync function resumeOne(target: ResumeTarget, mode: string): Promise<number> {\n  const phases = activePhases(target.plan);\n  const manager = new PipelineManager(target.plan, target.tasksFile, phases);\n  const next = manager.getNextPhase();\n\n  if (next === null) {\n    printInfo(`Issue #${target.issue} has every phase complete; nothing to resume.`);\n    return 0;\n  }\n\n  // 3. What was running when the process died. The snapshot cannot answer this\n  // — it only knows the phase failed or never ended — so the journal does.\n  const interrupted = await lastUnfinishedPhase(target);\n  if (interrupted !== null) {\n    printInfo(`Issue #${target.issue} was interrupted during the '${interrupted}' phase.`);\n  }\n\n  // 4. The repository, described and never repaired. Continuing the very phase\n  // that was interrupted is the one case where uncommitted work is expected;\n  // anything else would be carrying changes into work they do not belong to.\n  const sameWork = interrupted === next;\n  const preflight = await preflightRepository({\n    expectedBranch: target.plan.noBranch === true ? null : target.plan.branchName,\n    intent: sameWork ? 'resume-same-phase' : 'new-phase',\n  });\n  if (!preflight.ok) {\n    printError(`Cannot resume issue #${target.issue}: the repository needs attention first.`);\n    for (const line of describePreflight(preflight)) {\n      printError(line);\n    }\n    return 1;\n  }\n\n  // 5. The phase, stated before anything runs.\n  printInfo(`Resuming issue #${target.issue} from the '${next}' phase.`);\n  return runPipeline(target.issue, mode, next, undefined, undefined, { only: true });\n}\n\n/** The phase set this plan's pipeline actually has, so `pr-review` is honoured. */\nfunction activePhases(plan: TaskPlan): readonly PipelinePhase[] {\n  const base =\n    plan.noBranch === true\n      ? PIPELINE_PHASES.filter((phase) => phase !== 'pr')\n      : [...PIPELINE_PHASES];\n  return plan.prReview?.enabled === true ? [...base, 'pr-review'] : base;\n}\n\n/**\n * The phase the journal shows as started and never ended.\n *\n * Both generations are read, oldest first, because a run long enough to rotate\n * its journal is exactly the kind that gets interrupted. A missing or\n * unreadable journal answers `null`: the resume continues from the plan, which\n * is what it did before a journal existed.\n */\nasync function lastUnfinishedPhase(target: ResumeTarget): Promise<string | null> {\n  const content = `${await readIfPresent(target.rotatedEventsFile)}${await readIfPresent(target.eventsFile)}`;\n  if (content === '') return null;\n\n  const open: string[] = [];\n  for (const entry of parseJournal(content)) {\n    const event = entry.event;\n    if (event.type === 'phase:start') {\n      open.push(event.phase);\n    } else if (event.type === 'phase:end') {\n      const index = open.lastIndexOf(event.phase);\n      if (index >= 0) open.splice(index, 1);\n    }\n  }\n  return open.at(-1) ?? null;\n}\n\nasync function readIfPresent(path: string): Promise<string> {\n  try {\n    return await readFile(path, 'utf-8');\n  } catch {\n    return '';\n  }\n}\n\n/**\n * Which issues to resume.\n *\n * A named issue is taken at its word. Without one, the queue decides when there\n * is a queue — `nextQueueIssue()` is already the project's answer to \"which one\n * first\" — and otherwise the unfinished issues are ordered by when they were\n * last attempted, so `resume` alone picks up the most recent work.\n */\nasync function findTargets(\n  project: Awaited<ReturnType<typeof resolveProjectPaths>>,\n  issue: string | undefined,\n  all: boolean,\n): Promise<ResumeTarget[]> {\n  if (issue !== undefined) {\n    const target = await loadTarget(project.projectId, issue);\n    return target === null ? [] : [target];\n  }\n\n  const queued = await queueTarget(project);\n  if (queued !== null && !all) return [queued];\n\n  const unfinished = await unfinishedTargets(project);\n  if (all) return unfinished;\n  return unfinished.slice(0, 1);\n}\n\n/** The issue a queue would hand out next, when this project has a queue. */\nasync function queueTarget(\n  project: Awaited<ReturnType<typeof resolveProjectPaths>>,\n): Promise<ResumeTarget | null> {\n  const queuesDir = join(project.projectDir, QUEUES_DIR_NAME);\n  let entries: string[];\n  try {\n    entries = await readdir(queuesDir);\n  } catch {\n    return null;\n  }\n\n  for (const entry of entries) {\n    const plan = await loadExecutionPlan(join(queuesDir, entry, 'execution-plan.json'));\n    if (plan === null) continue;\n    const next = nextQueueIssue(plan);\n    if (next === null) continue;\n    const target = await loadTarget(project.projectId, next.id);\n    if (target !== null) return target;\n  }\n  return null;\n}\n\n/** Every issue whose plan is not finished, most recently attempted first. */\nasync function unfinishedTargets(\n  project: Awaited<ReturnType<typeof resolveProjectPaths>>,\n): Promise<ResumeTarget[]> {\n  let ids: string[];\n  try {\n    ids = await readdir(project.issuesDir);\n  } catch {\n    return [];\n  }\n\n  const targets: ResumeTarget[] = [];\n  for (const id of ids) {\n    const target = await loadTarget(project.projectId, id);\n    if (target === null) continue;\n    if (target.plan.issueStatus === 'completed') continue;\n    const manager = new PipelineManager(target.plan, target.tasksFile, activePhases(target.plan));\n    if (manager.getNextPhase() === null) continue;\n    targets.push(target);\n  }\n\n  return targets.sort((a, b) => attemptedAt(b.plan) - attemptedAt(a.plan));\n}\n\nfunction attemptedAt(plan: TaskPlan): number {\n  const at = Date.parse(plan.lastAttemptAt ?? '');\n  return Number.isNaN(at) ? 0 : at;\n}\n\nasync function loadTarget(projectId: string, issue: string): Promise<ResumeTarget | null> {\n  let paths: ReturnType<typeof getIssuePaths>;\n  try {\n    paths = getIssuePaths(projectId, issue);\n  } catch {\n    // Not a usable issue identifier — a stray file in `issues/`, for instance.\n    return null;\n  }\n\n  try {\n    const plan = await loadTaskPlan(paths.tasksFile);\n    return {\n      issue,\n      plan,\n      tasksFile: paths.tasksFile,\n      eventsFile: paths.eventsFile,\n      rotatedEventsFile: paths.rotatedEventsFile,\n    };\n  } catch {\n    return null;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/review-3F6MARWH.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  runReview
+} from "./chunk-XQUSIEKA.js";
+import "./chunk-73ATPIYX.js";
+import "./chunk-4JSOYE4G.js";
+import "./chunk-KMMASOA6.js";
+import "./chunk-MJULIKQU.js";
+import "./chunk-LAFNLLQP.js";
+import "./chunk-M66SJHQQ.js";
+import "./chunk-EZATO3DW.js";
+import "./chunk-42PJFMAR.js";
+import "./chunk-DIDUVL6O.js";
+import "./chunk-BYZDPR7N.js";
+import "./chunk-CD5ULRVC.js";
+export {
+  runReview
+};
+//# sourceMappingURL=review-3F6MARWH.js.map

package/dist/run-RXE5GDQO.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  publishIssueDetails,
+  publishStorySeed,
+  runPipeline
+} from "./chunk-NTMMF5UD.js";
+import "./chunk-FJP3UQGD.js";
+import "./chunk-FADTCQGM.js";
+import "./chunk-A4SLHOW7.js";
+import "./chunk-M5UCXTIT.js";
+import "./chunk-XQUSIEKA.js";
+import "./chunk-56KS3TFQ.js";
+import "./chunk-BAUPQXPE.js";
+import "./chunk-NS6R37II.js";
+import "./chunk-3QHK4YQA.js";
+import "./chunk-TSOLWK7Y.js";
+import "./chunk-QCPGHBSZ.js";
+import "./chunk-Y5ZDJ4PJ.js";
+import "./chunk-73ATPIYX.js";
+import "./chunk-4JSOYE4G.js";
+import "./chunk-KMMASOA6.js";
+import "./chunk-LWRSMTTZ.js";
+import "./chunk-MJULIKQU.js";
+import "./chunk-LAFNLLQP.js";
+import "./chunk-M66SJHQQ.js";
+import "./chunk-EZATO3DW.js";
+import "./chunk-42PJFMAR.js";
+import "./chunk-DIDUVL6O.js";
+import "./chunk-BYZDPR7N.js";
+import "./chunk-CD5ULRVC.js";
+export {
+  publishIssueDetails,
+  publishStorySeed,
+  runPipeline
+};
+//# sourceMappingURL=run-RXE5GDQO.js.map

package/dist/run-RXE5GDQO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/state-manager-2EDVDBAR.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {
+  allStoriesPass,
+  applyStoryMetrics,
+  clearLastError,
+  hasPendingCorrection,
+  initializeState,
+  isoNow,
+  loadTaskPlan,
+  markIssueCompleted,
+  markIssueInProgress,
+  markStoryPassing,
+  saveTaskPlan,
+  selectActiveStory,
+  setLastError,
+  trimErrorMessage
+} from "./chunk-CD5ULRVC.js";
+export {
+  allStoriesPass,
+  applyStoryMetrics,
+  clearLastError,
+  hasPendingCorrection,
+  initializeState,
+  isoNow,
+  loadTaskPlan,
+  markIssueCompleted,
+  markIssueInProgress,
+  markStoryPassing,
+  saveTaskPlan,
+  selectActiveStory,
+  setLastError,
+  trimErrorMessage
+};
+//# sourceMappingURL=state-manager-2EDVDBAR.js.map

package/dist/state-manager-2EDVDBAR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{web-ANQQTTRD.js → web-EF5WIIGG.js}

@@ -4,20 +4,25 @@ import {
   getWebLockFile,
   readWebLock,
   removeWebLock
-} from "./chunk-GANSDJV7.js";
-import "./chunk-HQYXVIH6.js";
+} from "./chunk-FJP3UQGD.js";
+import "./chunk-BAUPQXPE.js";
+import "./chunk-LAFNLLQP.js";
+import {
+  loadWebConfig
+} from "./chunk-42PJFMAR.js";
 import {
   ISSUES_DIR_NAME,
   PROJECTS_DIR_NAME,
-  getGlobalRoot,
-  loadWebConfig
-} from "./chunk-VQ5VN7DF.js";
+  getGlobalRoot
+} from "./chunk-DIDUVL6O.js";
 import {
   printError,
   printInfo,
-  printWarning,
+  printWarning
+} from "./chunk-BYZDPR7N.js";
+import {
   sessionSnapshotSchema
-} from "./chunk-HC2MT7BX.js";
+} from "./chunk-CD5ULRVC.js";
 
 // src/web/session-directory.ts
 import { readdir, readFile, stat as statFile } from "fs/promises";
@@ -185,4 +190,4 @@ export {
   runWebServe,
   runWebStop
 };
-//# sourceMappingURL=web-ANQQTTRD.js.map
+//# sourceMappingURL=web-EF5WIIGG.js.map

package/dist/{web-ANQQTTRD.js.map → web-EF5WIIGG.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/web/session-directory.ts","../src/commands/web.ts"],"sourcesContent":["import { readdir, readFile, stat as statFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { ValidatedSessionSnapshot } from '../schemas.js';\nimport { sessionSnapshotSchema } from '../schemas.js';\nimport {\n  type GetGlobalRootOptions,\n  getGlobalRoot,\n  ISSUES_DIR_NAME,\n  PROJECTS_DIR_NAME,\n} from '../storage/paths.js';\n\n/**\n * Multi-session discovery for the web monitoring server (US-003).\n *\n * The single-instance server (`web/lock.ts`) runs decoupled from any one\n * pipeline invocation, so it cannot hold a `SessionPublisher` in memory for\n * \"the\" run being monitored — there may be zero, one or several running at\n * once, each in its own process. Instead this module polls every\n * `~/.issue-flow/projects/<project>/issues/<n>/session.json` on disk (the\n * same file `FilePublisher` already writes) and keeps an in-memory map of the\n * ones that are both well-formed and recently updated.\n *\n * Polling rather than `fs.watch` is a deliberate choice, not a placeholder:\n * `fs.watch`'s `recursive` option is only reliable on macOS and Windows (Linux\n * needs a manual per-directory watch tree, and the whole thing still degrades\n * to polling on network filesystems), while a `~/.issue-flow` tree is small\n * and local — a cheap poll of it is simpler and behaves identically on every\n * platform, which is what the US-003 acceptance criteria ask to validate.\n */\n\n/** How often the directory tree is rescanned, unless overridden. */\nexport const DEFAULT_POLL_INTERVAL_MS = 3000;\n\n/**\n * A session stops being reported once its file has gone this long without an\n * update. `FilePublisher` throttles writes to ~1s and force-flushes on every\n * phase/session boundary, so a live run's file is never quiet for long; this\n * threshold only needs to be comfortably above one throttle window plus one\n * poll interval to avoid flapping a session in and out on timing alone.\n */\nexport const DEFAULT_STALE_AFTER_MS = 30_000;\n\nexport interface ActiveSession {\n  /** Directory the session.json was read from, one level up from the file. */\n  issueDir: string;\n  filePath: string;\n  snapshot: ValidatedSessionSnapshot;\n  /** mtime of the file at the last successful read, in epoch ms. */\n  updatedAtMs: number;\n}\n\nexport interface SessionDirectoryOptions extends GetGlobalRootOptions {\n  /** Poll interval, in ms. Default {@link DEFAULT_POLL_INTERVAL_MS}. */\n  pollIntervalMs?: number;\n  /** Staleness threshold, in ms. Default {@link DEFAULT_STALE_AFTER_MS}. */\n  staleAfterMs?: number;\n  /** Invoked (at most once) when a poll fails unexpectedly. Best-effort logging only. */\n  onWarn?: (message: string) => void;\n}\n\nexport interface SessionDirectoryHandle {\n  /** Snapshot of every session currently considered active. */\n  sessions(): ActiveSession[];\n  /** A single active session by id, or undefined. */\n  getSession(sessionId: string): ActiveSession | undefined;\n  /** Force an immediate rescan instead of waiting for the next tick. Never throws. */\n  refresh(): Promise<void>;\n  /** Stop polling. Idempotent. */\n  close(): void;\n}\n\nasync function listSubdirectories(dir: string): Promise<string[]> {\n  try {\n    const entries = await readdir(dir, { withFileTypes: true });\n    // Symlinks are skipped on purpose, same discipline as the storage\n    // migration walk: following one could pull session data from outside the\n    // global tree into the listing.\n    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);\n  } catch {\n    // Missing/unreadable projects (or issues) directory reads as \"none yet\" —\n    // this is routinely the case before the first --web run ever happens.\n    return [];\n  }\n}\n\n/** Every `session.json` path currently on disk, one per project/issue pair. */\nasync function discoverSessionFiles(root: string): Promise<string[]> {\n  const projectsDir = join(root, PROJECTS_DIR_NAME);\n  const projectIds = await listSubdirectories(projectsDir);\n\n  const perProject = await Promise.all(\n    projectIds.map(async (projectId) => {\n      const issuesDir = join(projectsDir, projectId, ISSUES_DIR_NAME);\n      const issueIds = await listSubdirectories(issuesDir);\n      return issueIds.map((issueId) => join(issuesDir, issueId, 'session.json'));\n    }),\n  );\n\n  return perProject.flat();\n}\n\ninterface ReadResult {\n  snapshot: ValidatedSessionSnapshot;\n  updatedAtMs: number;\n}\n\n/**\n * Read and validate one `session.json`. Anything short of a fully valid file\n * (missing, mid-write, corrupted, written by an incompatible future version)\n * reads as \"not currently a session\" — the directory scan must never fail\n * because one file is momentarily inconsistent (`FilePublisher` writes via a\n * temp file + rename, but a reader can still race a concurrent write).\n */\nasync function readSessionFile(filePath: string): Promise<ReadResult | null> {\n  let raw: string;\n  let mtimeMs: number;\n  try {\n    const [content, stat] = await Promise.all([readFile(filePath, 'utf-8'), statFile(filePath)]);\n    raw = content;\n    mtimeMs = stat.mtimeMs;\n  } catch {\n    return null;\n  }\n\n  try {\n    const parsed = sessionSnapshotSchema.safeParse(JSON.parse(raw));\n    if (!parsed.success || parsed.data.sessionId === null) return null;\n    return { snapshot: parsed.data, updatedAtMs: mtimeMs };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Start polling the global storage tree for active sessions.\n *\n * Returns a handle immediately; the first scan happens synchronously in the\n * background and `sessions()` answers `[]` until it completes, same as \"no\n * sessions found yet\" — there is nothing to await here that would not also\n * delay the server's very first bind.\n */\nexport function watchSessionDirectory(\n  options: SessionDirectoryOptions = {},\n): SessionDirectoryHandle {\n  const root = getGlobalRoot(options);\n  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;\n  const warn = options.onWarn;\n\n  // Keyed by sessionId, not by file path: a session's identity is the id\n  // inside its content, and that is what /api/status?session=<id> looks up.\n  let sessions = new Map<string, ActiveSession>();\n  let warned = false;\n\n  async function scan(): Promise<void> {\n    let files: string[];\n    try {\n      files = await discoverSessionFiles(root);\n    } catch (err) {\n      if (!warned) {\n        warned = true;\n        warn?.(\n          `issue-flow: web monitor could not scan the session directory (will keep retrying silently): ${\n            err instanceof Error ? err.message : String(err)\n          }`,\n        );\n      }\n      return;\n    }\n\n    const now = Date.now();\n    const next = new Map<string, ActiveSession>();\n    for (const filePath of files) {\n      const result = await readSessionFile(filePath);\n      if (result === null) continue;\n      if (now - result.updatedAtMs > staleAfterMs) continue; // stopped updating: not active\n      const sessionId = result.snapshot.sessionId as string;\n      next.set(sessionId, {\n        issueDir: join(filePath, '..'),\n        filePath,\n        snapshot: result.snapshot,\n        updatedAtMs: result.updatedAtMs,\n      });\n    }\n    sessions = next;\n  }\n\n  // The first scan runs immediately (not just after the first interval tick)\n  // so a server started right after a session begins does not report \"no\n  // sessions\" for a whole poll interval.\n  void scan();\n  const timer = setInterval(() => void scan(), pollIntervalMs);\n  timer.unref();\n\n  return {\n    sessions: () => [...sessions.values()],\n    getSession: (sessionId: string) => sessions.get(sessionId),\n    refresh: scan,\n    close: () => clearInterval(timer),\n  };\n}\n","import { loadWebConfig } from '../config.js';\nimport type { WebConfig } from '../schemas.js';\nimport { printError, printInfo, printWarning } from '../ui/logger.js';\nimport { ensureSingleWebServer, getWebLockFile, readWebLock, removeWebLock } from '../web/lock.js';\nimport { watchSessionDirectory } from '../web/session-directory.js';\n\n/**\n * `issue-flow web serve` / `issue-flow web stop` (US-002).\n *\n * `serve` is the process `ensureWebMonitor()` (`web/lock.ts`) spawns detached\n * — it is not meant to be run interactively, though nothing stops a user from\n * doing so to watch every session on the machine without going through a\n * pipeline command first. It never exits on its own: the server stays bound\n * (see `unref: false` in `web/server.ts`) until `stop` sends it `SIGTERM`, at\n * which point `startWebServer`'s own signal handler closes it (removing the\n * lock) and re-raises the signal for the default termination behavior.\n */\n\nconst STOP_POLL_INTERVAL_MS = 100;\nconst STOP_TIMEOUT_MS = 5000;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport interface RunWebServeOptions {\n  port?: number;\n  host?: string;\n  refresh?: number;\n}\n\n/**\n * Bind (or defer to) the single web monitor instance and keep the process\n * alive for as long as it stays bound. Logging is intentionally silent on the\n * happy path: this process is spawned with `stdio: 'ignore'`, so anything\n * printed here goes nowhere — the caller (`ensureWebMonitor`) is the one that\n * tells the user the server is up.\n */\nexport async function runWebServe(options: RunWebServeOptions): Promise<number> {\n  // Built conditionally, not `{ port: options.port, ... }`: loadWebConfig()\n  // spreads this object directly over the lower-precedence layers, and an\n  // explicit `undefined` value would overwrite an env/.issue-flow.json\n  // setting instead of falling through to it (only an *absent* key does).\n  const cli: Partial<WebConfig> = {};\n  if (options.port !== undefined) cli.port = options.port;\n  if (options.host !== undefined) cli.host = options.host;\n  if (options.refresh !== undefined) cli.refreshSeconds = options.refresh;\n  const webConfig = await loadWebConfig({ cli });\n\n  const sessions = watchSessionDirectory();\n\n  const noop = (): void => {};\n  const handle = await ensureSingleWebServer({\n    sessions,\n    port: webConfig.port,\n    host: webConfig.host,\n    refreshSeconds: webConfig.refreshSeconds,\n    unref: false,\n    info: noop,\n    warn: noop,\n  });\n\n  if (handle === null) {\n    sessions.close();\n    return 1;\n  }\n\n  if (handle.server === undefined) {\n    // Another instance already won the race (or was already running by the\n    // time this process got here): nothing to serve, so it exits right away\n    // instead of idling as a redundant detached process.\n    sessions.close();\n    return 0;\n  }\n\n  const originalClose = handle.close;\n  handle.close = async () => {\n    await originalClose();\n    sessions.close();\n  };\n\n  return 0;\n}\n\n/** Stop the single running web monitor instance, if any. */\nexport async function runWebStop(): Promise<number> {\n  const lockFile = getWebLockFile();\n  const lock = await readWebLock(lockFile);\n  if (lock === null) {\n    printInfo('No web monitor is currently running.');\n    return 0;\n  }\n\n  try {\n    process.kill(lock.pid, 'SIGTERM');\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'ESRCH') {\n      printWarning(\n        'The web monitor lock referenced a process that is no longer running; removing it.',\n      );\n      await removeWebLock(lockFile);\n      return 0;\n    }\n    printError(\n      `Failed to stop the web monitor: ${err instanceof Error ? err.message : String(err)}`,\n    );\n    return 1;\n  }\n\n  const deadline = Date.now() + STOP_TIMEOUT_MS;\n  while (Date.now() < deadline) {\n    if ((await readWebLock(lockFile)) === null) {\n      printInfo(`Web monitor (pid ${lock.pid}) stopped.`);\n      return 0;\n    }\n    await sleep(STOP_POLL_INTERVAL_MS);\n  }\n\n  printWarning('Sent the stop signal, but the web monitor did not confirm shutdown in time.');\n  return 0;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/web/session-directory.ts","../src/commands/web.ts"],"sourcesContent":["import { readdir, readFile, stat as statFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { ValidatedSessionSnapshot } from '../schemas.js';\nimport { sessionSnapshotSchema } from '../schemas.js';\nimport {\n  type GetGlobalRootOptions,\n  getGlobalRoot,\n  ISSUES_DIR_NAME,\n  PROJECTS_DIR_NAME,\n} from '../storage/paths.js';\n\n/**\n * Multi-session discovery for the web monitoring server (US-003).\n *\n * The single-instance server (`web/lock.ts`) runs decoupled from any one\n * pipeline invocation, so it cannot hold a `SessionPublisher` in memory for\n * \"the\" run being monitored — there may be zero, one or several running at\n * once, each in its own process. Instead this module polls every\n * `~/.issue-flow/projects/<project>/issues/<n>/session.json` on disk (the\n * same file `FilePublisher` already writes) and keeps an in-memory map of the\n * ones that are both well-formed and recently updated.\n *\n * Polling rather than `fs.watch` is a deliberate choice, not a placeholder:\n * `fs.watch`'s `recursive` option is only reliable on macOS and Windows (Linux\n * needs a manual per-directory watch tree, and the whole thing still degrades\n * to polling on network filesystems), while a `~/.issue-flow` tree is small\n * and local — a cheap poll of it is simpler and behaves identically on every\n * platform, which is what the US-003 acceptance criteria ask to validate.\n */\n\n/** How often the directory tree is rescanned, unless overridden. */\nexport const DEFAULT_POLL_INTERVAL_MS = 3000;\n\n/**\n * A session stops being reported once its file has gone this long without an\n * update. `FilePublisher` throttles writes to ~1s and force-flushes on every\n * phase/session boundary, so a live run's file is never quiet for long; this\n * threshold only needs to be comfortably above one throttle window plus one\n * poll interval to avoid flapping a session in and out on timing alone.\n */\nexport const DEFAULT_STALE_AFTER_MS = 30_000;\n\nexport interface ActiveSession {\n  /** Directory the session.json was read from, one level up from the file. */\n  issueDir: string;\n  filePath: string;\n  snapshot: ValidatedSessionSnapshot;\n  /** mtime of the file at the last successful read, in epoch ms. */\n  updatedAtMs: number;\n}\n\nexport interface SessionDirectoryOptions extends GetGlobalRootOptions {\n  /** Poll interval, in ms. Default {@link DEFAULT_POLL_INTERVAL_MS}. */\n  pollIntervalMs?: number;\n  /** Staleness threshold, in ms. Default {@link DEFAULT_STALE_AFTER_MS}. */\n  staleAfterMs?: number;\n  /** Invoked (at most once) when a poll fails unexpectedly. Best-effort logging only. */\n  onWarn?: (message: string) => void;\n}\n\nexport interface SessionDirectoryHandle {\n  /** Snapshot of every session currently considered active. */\n  sessions(): ActiveSession[];\n  /** A single active session by id, or undefined. */\n  getSession(sessionId: string): ActiveSession | undefined;\n  /** Force an immediate rescan instead of waiting for the next tick. Never throws. */\n  refresh(): Promise<void>;\n  /** Stop polling. Idempotent. */\n  close(): void;\n}\n\nasync function listSubdirectories(dir: string): Promise<string[]> {\n  try {\n    const entries = await readdir(dir, { withFileTypes: true });\n    // Symlinks are skipped on purpose, same discipline as the storage\n    // migration walk: following one could pull session data from outside the\n    // global tree into the listing.\n    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);\n  } catch {\n    // Missing/unreadable projects (or issues) directory reads as \"none yet\" —\n    // this is routinely the case before the first --web run ever happens.\n    return [];\n  }\n}\n\n/** Every `session.json` path currently on disk, one per project/issue pair. */\nasync function discoverSessionFiles(root: string): Promise<string[]> {\n  const projectsDir = join(root, PROJECTS_DIR_NAME);\n  const projectIds = await listSubdirectories(projectsDir);\n\n  const perProject = await Promise.all(\n    projectIds.map(async (projectId) => {\n      const issuesDir = join(projectsDir, projectId, ISSUES_DIR_NAME);\n      const issueIds = await listSubdirectories(issuesDir);\n      return issueIds.map((issueId) => join(issuesDir, issueId, 'session.json'));\n    }),\n  );\n\n  return perProject.flat();\n}\n\ninterface ReadResult {\n  snapshot: ValidatedSessionSnapshot;\n  updatedAtMs: number;\n}\n\n/**\n * Read and validate one `session.json`. Anything short of a fully valid file\n * (missing, mid-write, corrupted, written by an incompatible future version)\n * reads as \"not currently a session\" — the directory scan must never fail\n * because one file is momentarily inconsistent (`FilePublisher` writes via a\n * temp file + rename, but a reader can still race a concurrent write).\n */\nasync function readSessionFile(filePath: string): Promise<ReadResult | null> {\n  let raw: string;\n  let mtimeMs: number;\n  try {\n    const [content, stat] = await Promise.all([readFile(filePath, 'utf-8'), statFile(filePath)]);\n    raw = content;\n    mtimeMs = stat.mtimeMs;\n  } catch {\n    return null;\n  }\n\n  try {\n    const parsed = sessionSnapshotSchema.safeParse(JSON.parse(raw));\n    if (!parsed.success || parsed.data.sessionId === null) return null;\n    return { snapshot: parsed.data, updatedAtMs: mtimeMs };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Start polling the global storage tree for active sessions.\n *\n * Returns a handle immediately; the first scan happens synchronously in the\n * background and `sessions()` answers `[]` until it completes, same as \"no\n * sessions found yet\" — there is nothing to await here that would not also\n * delay the server's very first bind.\n */\nexport function watchSessionDirectory(\n  options: SessionDirectoryOptions = {},\n): SessionDirectoryHandle {\n  const root = getGlobalRoot(options);\n  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;\n  const warn = options.onWarn;\n\n  // Keyed by sessionId, not by file path: a session's identity is the id\n  // inside its content, and that is what /api/status?session=<id> looks up.\n  let sessions = new Map<string, ActiveSession>();\n  let warned = false;\n\n  async function scan(): Promise<void> {\n    let files: string[];\n    try {\n      files = await discoverSessionFiles(root);\n    } catch (err) {\n      if (!warned) {\n        warned = true;\n        warn?.(\n          `issue-flow: web monitor could not scan the session directory (will keep retrying silently): ${\n            err instanceof Error ? err.message : String(err)\n          }`,\n        );\n      }\n      return;\n    }\n\n    const now = Date.now();\n    const next = new Map<string, ActiveSession>();\n    for (const filePath of files) {\n      const result = await readSessionFile(filePath);\n      if (result === null) continue;\n      if (now - result.updatedAtMs > staleAfterMs) continue; // stopped updating: not active\n      const sessionId = result.snapshot.sessionId as string;\n      next.set(sessionId, {\n        issueDir: join(filePath, '..'),\n        filePath,\n        snapshot: result.snapshot,\n        updatedAtMs: result.updatedAtMs,\n      });\n    }\n    sessions = next;\n  }\n\n  // The first scan runs immediately (not just after the first interval tick)\n  // so a server started right after a session begins does not report \"no\n  // sessions\" for a whole poll interval.\n  void scan();\n  const timer = setInterval(() => void scan(), pollIntervalMs);\n  timer.unref();\n\n  return {\n    sessions: () => [...sessions.values()],\n    getSession: (sessionId: string) => sessions.get(sessionId),\n    refresh: scan,\n    close: () => clearInterval(timer),\n  };\n}\n","import { loadWebConfig } from '../config.js';\nimport type { WebConfig } from '../schemas.js';\nimport { printError, printInfo, printWarning } from '../ui/logger.js';\nimport { ensureSingleWebServer, getWebLockFile, readWebLock, removeWebLock } from '../web/lock.js';\nimport { watchSessionDirectory } from '../web/session-directory.js';\n\n/**\n * `issue-flow web serve` / `issue-flow web stop` (US-002).\n *\n * `serve` is the process `ensureWebMonitor()` (`web/lock.ts`) spawns detached\n * — it is not meant to be run interactively, though nothing stops a user from\n * doing so to watch every session on the machine without going through a\n * pipeline command first. It never exits on its own: the server stays bound\n * (see `unref: false` in `web/server.ts`) until `stop` sends it `SIGTERM`, at\n * which point `startWebServer`'s own signal handler closes it (removing the\n * lock) and re-raises the signal for the default termination behavior.\n */\n\nconst STOP_POLL_INTERVAL_MS = 100;\nconst STOP_TIMEOUT_MS = 5000;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport interface RunWebServeOptions {\n  port?: number;\n  host?: string;\n  refresh?: number;\n}\n\n/**\n * Bind (or defer to) the single web monitor instance and keep the process\n * alive for as long as it stays bound. Logging is intentionally silent on the\n * happy path: this process is spawned with `stdio: 'ignore'`, so anything\n * printed here goes nowhere — the caller (`ensureWebMonitor`) is the one that\n * tells the user the server is up.\n */\nexport async function runWebServe(options: RunWebServeOptions): Promise<number> {\n  // Built conditionally, not `{ port: options.port, ... }`: loadWebConfig()\n  // spreads this object directly over the lower-precedence layers, and an\n  // explicit `undefined` value would overwrite an env/.issue-flow.json\n  // setting instead of falling through to it (only an *absent* key does).\n  const cli: Partial<WebConfig> = {};\n  if (options.port !== undefined) cli.port = options.port;\n  if (options.host !== undefined) cli.host = options.host;\n  if (options.refresh !== undefined) cli.refreshSeconds = options.refresh;\n  const webConfig = await loadWebConfig({ cli });\n\n  const sessions = watchSessionDirectory();\n\n  const noop = (): void => {};\n  const handle = await ensureSingleWebServer({\n    sessions,\n    port: webConfig.port,\n    host: webConfig.host,\n    refreshSeconds: webConfig.refreshSeconds,\n    unref: false,\n    info: noop,\n    warn: noop,\n  });\n\n  if (handle === null) {\n    sessions.close();\n    return 1;\n  }\n\n  if (handle.server === undefined) {\n    // Another instance already won the race (or was already running by the\n    // time this process got here): nothing to serve, so it exits right away\n    // instead of idling as a redundant detached process.\n    sessions.close();\n    return 0;\n  }\n\n  const originalClose = handle.close;\n  handle.close = async () => {\n    await originalClose();\n    sessions.close();\n  };\n\n  return 0;\n}\n\n/** Stop the single running web monitor instance, if any. */\nexport async function runWebStop(): Promise<number> {\n  const lockFile = getWebLockFile();\n  const lock = await readWebLock(lockFile);\n  if (lock === null) {\n    printInfo('No web monitor is currently running.');\n    return 0;\n  }\n\n  try {\n    process.kill(lock.pid, 'SIGTERM');\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'ESRCH') {\n      printWarning(\n        'The web monitor lock referenced a process that is no longer running; removing it.',\n      );\n      await removeWebLock(lockFile);\n      return 0;\n    }\n    printError(\n      `Failed to stop the web monitor: ${err instanceof Error ? err.message : String(err)}`,\n    );\n    return 1;\n  }\n\n  const deadline = Date.now() + STOP_TIMEOUT_MS;\n  while (Date.now() < deadline) {\n    if ((await readWebLock(lockFile)) === null) {\n      printInfo(`Web monitor (pid ${lock.pid}) stopped.`);\n      return 0;\n    }\n    await sleep(STOP_POLL_INTERVAL_MS);\n  }\n\n  printWarning('Sent the stop signal, but the web monitor did not confirm shutdown in time.');\n  return 0;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "issue-flow",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Unified CLI for orchestrating the full issue-flow pipeline via Claude Code Headless",
   "type": "module",
   "bin": {

package/prompts/pr.md

@@ -14,10 +14,17 @@ __ISSUE_BODY__
 </issue-body>
 
 Steps:
-1. Read the task plan from __TASKS_PATH__ if it exists
-2. Review the git log for this branch: git log __BASE_BRANCH__..HEAD --oneline
-3. Review the diff: git diff __BASE_BRANCH__...HEAD --stat
-4. Create a well-structured PR using gh pr create
+1. Check whether this branch already has an open Pull Request:
+   `gh pr list --head __BRANCH_NAME__ --state open --json number,url`.
+   If it does, do NOT create a second one — report the existing URL and stop.
+   The pipeline checks this before invoking you and normally skips this phase
+   entirely, so reaching this point with a Pull Request already open means the
+   check could not run: it is the last guard against a duplicate, not a
+   formality.
+2. Read the task plan from __TASKS_PATH__ if it exists
+3. Review the git log for this branch: git log __BASE_BRANCH__..HEAD --oneline
+4. Review the diff: git diff __BASE_BRANCH__...HEAD --stat
+5. Create a well-structured PR using gh pr create
 
 The PR should:
 - Have a clear, concise title (under 70 characters)

package/web/public/app.js

@@ -614,6 +614,18 @@
             ? formatAgo(session.startedAt)
             : '—';
       meta.appendChild(el('span', null, elapsed));
+      // Resilience: how hard this run has had to work, and when it last moved.
+      // A card that only shows a percentage cannot tell a run that is
+      // progressing from one that has been retrying for twenty minutes.
+      if (typeof session.retries === 'number' && session.retries > 0) {
+        meta.appendChild(el('span', null, session.retries + ' retry(s)'));
+      }
+      if (typeof session.correctionCycle === 'number' && session.correctionCycle > 0) {
+        meta.appendChild(el('span', null, 'correção ' + session.correctionCycle));
+      }
+      if (session.updatedAt) {
+        meta.appendChild(el('span', null, 'atividade ' + formatAgo(session.updatedAt)));
+      }
       card.appendChild(meta);
 
       const progress = el('span', 'dashboard-progress');

package/dist/chunk-3BOHTH4V.js

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-import {
-  retryDelaySeconds,
-  sleep
-} from "./chunk-HDV3YDTG.js";
-import {
-  getSessionPublisher,
-  isoNow,
-  printRetry
-} from "./chunk-HC2MT7BX.js";
-
-// src/core/phase-runner.ts
-import { readFile } from "fs/promises";
-var DEFAULT_PHASE_RETRY_LIMIT = 3;
-var DEFAULT_BACKOFF_BASE_SECONDS = 15;
-var DEFAULT_BACKOFF_MAX_SECONDS = 120;
-async function runPhaseWithRetry(options) {
-  const retryLimit = options.retryLimit ?? DEFAULT_PHASE_RETRY_LIMIT;
-  const backoffBaseSeconds = options.backoffBaseSeconds ?? DEFAULT_BACKOFF_BASE_SECONDS;
-  const backoffMaxSeconds = options.backoffMaxSeconds ?? DEFAULT_BACKOFF_MAX_SECONDS;
-  let lastResult = { ok: false, error: "Phase never attempted" };
-  let retryCount = 0;
-  for (let attemptNumber = 1; attemptNumber <= retryLimit; attemptNumber++) {
-    lastResult = await options.attempt(attemptNumber);
-    if (lastResult.ok) return lastResult;
-    if (!lastResult.transient || attemptNumber === retryLimit) return lastResult;
-    retryCount++;
-    const delaySeconds = retryDelaySeconds(retryCount, backoffBaseSeconds, backoffMaxSeconds);
-    getSessionPublisher().publish({
-      type: "retry",
-      at: isoNow(),
-      attempt: retryCount,
-      delaySeconds,
-      reason: lastResult.error
-    });
-    printRetry(
-      `Phase ${options.phase} hit a recoverable failure (attempt ${attemptNumber}/${retryLimit}): ${lastResult.error}. Retrying in ${delaySeconds}s.`
-    );
-    await sleep(delaySeconds);
-  }
-  return lastResult;
-}
-async function readFileWithGrace(path, delaysMs = [300, 800]) {
-  for (let i = 0; ; i++) {
-    try {
-      return await readFile(path, "utf-8");
-    } catch (err) {
-      if (i >= delaysMs.length) throw err;
-      await new Promise((resolve) => setTimeout(resolve, delaysMs[i]));
-    }
-  }
-}
-
-export {
-  runPhaseWithRetry,
-  readFileWithGrace
-};
-//# sourceMappingURL=chunk-3BOHTH4V.js.map

package/dist/chunk-3BOHTH4V.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/phase-runner.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { printRetry } from '../ui/logger.js';\nimport { retryDelaySeconds, sleep } from '../utils/retry.js';\nimport { getSessionPublisher } from './session-publisher.js';\nimport { isoNow } from './state-manager.js';\n\nexport interface PhaseAttemptResult {\n  ok: boolean;\n  /** Whether a failed attempt is worth retrying. Ignored when ok is true. */\n  transient?: boolean;\n  error?: string;\n}\n\nexport interface PhaseRetryOptions {\n  phase: string;\n  attempt: (attemptNumber: number) => Promise<PhaseAttemptResult>;\n  retryLimit?: number;\n  backoffBaseSeconds?: number;\n  backoffMaxSeconds?: number;\n}\n\nconst DEFAULT_PHASE_RETRY_LIMIT = 3;\nconst DEFAULT_BACKOFF_BASE_SECONDS = 15;\nconst DEFAULT_BACKOFF_MAX_SECONDS = 120;\n\n/**\n * Bounded retry wrapper for single-shot phases (prd, plan, pr) that invoke\n * the Claude CLI once and validate an artifact. Mirrors the transient-retry\n * pattern already used by the execute phase's iteration loop (core/engine.ts:\n * isTransientFailure + retryDelaySeconds), applied here to phases that\n * previously aborted the whole pipeline on the first failure with no chance\n * to recover. Non-transient failures (or exhausting the retry budget) still\n * end the phase — this bounds recovery attempts, it never retries forever.\n */\nexport async function runPhaseWithRetry(options: PhaseRetryOptions): Promise<PhaseAttemptResult> {\n  const retryLimit = options.retryLimit ?? DEFAULT_PHASE_RETRY_LIMIT;\n  const backoffBaseSeconds = options.backoffBaseSeconds ?? DEFAULT_BACKOFF_BASE_SECONDS;\n  const backoffMaxSeconds = options.backoffMaxSeconds ?? DEFAULT_BACKOFF_MAX_SECONDS;\n\n  let lastResult: PhaseAttemptResult = { ok: false, error: 'Phase never attempted' };\n  let retryCount = 0;\n\n  for (let attemptNumber = 1; attemptNumber <= retryLimit; attemptNumber++) {\n    lastResult = await options.attempt(attemptNumber);\n    if (lastResult.ok) return lastResult;\n    if (!lastResult.transient || attemptNumber === retryLimit) return lastResult;\n\n    retryCount++;\n    const delaySeconds = retryDelaySeconds(retryCount, backoffBaseSeconds, backoffMaxSeconds);\n    getSessionPublisher().publish({\n      type: 'retry',\n      at: isoNow(),\n      attempt: retryCount,\n      delaySeconds,\n      reason: lastResult.error,\n    });\n    printRetry(\n      `Phase ${options.phase} hit a recoverable failure (attempt ${attemptNumber}/${retryLimit}): ${lastResult.error}. Retrying in ${delaySeconds}s.`,\n    );\n    await sleep(delaySeconds);\n  }\n\n  return lastResult;\n}\n\n/**\n * Re-read a file a few times with short delays before giving up. Absorbs a\n * brief filesystem-visibility lag between the Claude CLI's Write tool\n * completing and this process observing the result, without spending a full\n * phase retry (and a new Claude invocation) on what may just be a timing gap.\n */\nexport async function readFileWithGrace(\n  path: string,\n  delaysMs: number[] = [300, 800],\n): Promise<string> {\n  for (let i = 0; ; i++) {\n    try {\n      return await readFile(path, 'utf-8');\n    } catch (err) {\n      if (i >= delaysMs.length) throw err;\n      await new Promise((resolve) => setTimeout(resolve, delaysMs[i]));\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAAA,SAAS,gBAAgB;AAqBzB,IAAM,4BAA4B;AAClC,IAAM,+BAA+B;AACrC,IAAM,8BAA8B;AAWpC,eAAsB,kBAAkB,SAAyD;AAC/F,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,qBAAqB,QAAQ,sBAAsB;AACzD,QAAM,oBAAoB,QAAQ,qBAAqB;AAEvD,MAAI,aAAiC,EAAE,IAAI,OAAO,OAAO,wBAAwB;AACjF,MAAI,aAAa;AAEjB,WAAS,gBAAgB,GAAG,iBAAiB,YAAY,iBAAiB;AACxE,iBAAa,MAAM,QAAQ,QAAQ,aAAa;AAChD,QAAI,WAAW,GAAI,QAAO;AAC1B,QAAI,CAAC,WAAW,aAAa,kBAAkB,WAAY,QAAO;AAElE;AACA,UAAM,eAAe,kBAAkB,YAAY,oBAAoB,iBAAiB;AACxF,wBAAoB,EAAE,QAAQ;AAAA,MAC5B,MAAM;AAAA,MACN,IAAI,OAAO;AAAA,MACX,SAAS;AAAA,MACT;AAAA,MACA,QAAQ,WAAW;AAAA,IACrB,CAAC;AACD;AAAA,MACE,SAAS,QAAQ,KAAK,uCAAuC,aAAa,IAAI,UAAU,MAAM,WAAW,KAAK,iBAAiB,YAAY;AAAA,IAC7I;AACA,UAAM,MAAM,YAAY;AAAA,EAC1B;AAEA,SAAO;AACT;AAQA,eAAsB,kBACpB,MACA,WAAqB,CAAC,KAAK,GAAG,GACb;AACjB,WAAS,IAAI,KAAK,KAAK;AACrB,QAAI;AACF,aAAO,MAAM,SAAS,MAAM,OAAO;AAAA,IACrC,SAAS,KAAK;AACZ,UAAI,KAAK,SAAS,OAAQ,OAAM;AAChC,YAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,SAAS,CAAC,CAAC,CAAC;AAAA,IACjE;AAAA,EACF;AACF;","names":[]}