@open-tomato/rafa 0.16.0 → 0.17.0

package/dist/cli.js

@@ -559,7 +559,8 @@ var init_config_schema = __esm(() => {
     cleanupStaleDays: 30,
     cleanupWorktreeIdleDays: 7,
     cleanupKeep: Object.freeze([]),
-    dangerousAcceptStaleRefs: false
+    dangerousAcceptStaleRefs: false,
+    statusNotice: true
   });
   directory = text("a directory path");
   trackerKind = text("a tracker kind name");
@@ -650,7 +651,8 @@ var init_config_schema = __esm(() => {
       key: "dangerous.acceptStaleRefs",
       read: flag,
       cli: false
-    }
+    },
+    statusNotice: { key: "status.notice", read: flag, cli: false }
   };
   SETTING_NAMES = Object.keys(SETTINGS);
   SETTING_BY_KEY = new Map(SETTING_NAMES.map((setting) => [
@@ -722,7 +724,8 @@ function readLayer(rawOf, atOf) {
     cleanupStaleDays: read("cleanupStaleDays"),
     cleanupWorktreeIdleDays: read("cleanupWorktreeIdleDays"),
     cleanupKeep: read("cleanupKeep"),
-    dangerousAcceptStaleRefs: read("dangerousAcceptStaleRefs")
+    dangerousAcceptStaleRefs: read("dangerousAcceptStaleRefs"),
+    statusNotice: read("statusNotice")
   };
   return { layer, problems, extras };
 }
@@ -1413,7 +1416,7 @@ function restoreRunningCommand(previous) {
 var running = null;
 
 // package.json
-var name = "@open-tomato/rafa", version = "0.16.0";
+var name = "@open-tomato/rafa", version = "0.17.0";
 var init_package = () => {};
 
 // src/cli/version.ts
@@ -5529,7 +5532,7 @@ var init_issue_values = __esm(() => {
 
 // src/adapters/tracker/github.ts
 function createGhRunner(options) {
-  const { cwd, command = "gh", env } = options;
+  const { cwd, command = "gh", env, timeoutMs } = options;
   return async (args) => {
     const executable = env === undefined ? command : Bun.which(command, { PATH: env.PATH ?? "", cwd });
     if (executable === null) {
@@ -5543,17 +5546,37 @@ function createGhRunner(options) {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const [stdout, stderr, exitCode] = await Promise.all([
+      const finished = Promise.all([
         new Response(proc.stdout).text(),
         new Response(proc.stderr).text(),
         proc.exited
       ]);
+      const outcome = await withDeadline(finished, timeoutMs);
+      if (outcome === TIMED_OUT) {
+        proc.kill("SIGKILL");
+        await proc.exited;
+        return { ok: false, stdout: "", stderr: `${command} in ${cwd} timed out after ${timeoutMs}ms and was killed` };
+      }
+      const [stdout, stderr, exitCode] = outcome;
       return { ok: exitCode === 0, stdout, stderr };
     } catch (error) {
       return { ok: false, stdout: "", stderr: `could not run ${command} in ${cwd}: ${messageOf(error)}` };
     }
   };
 }
+async function withDeadline(work, timeoutMs) {
+  if (timeoutMs === undefined)
+    return work;
+  let timer;
+  const deadline = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3(TIMED_OUT), timeoutMs);
+  });
+  try {
+    return await Promise.race([work, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function notOnPath(command, cwd, path) {
   const searched = path === undefined ? "an environment with no PATH" : `PATH ${JSON.stringify(path)}`;
   return `could not run ${command} in ${cwd}: not found on ${searched} (ENOENT)`;
@@ -5830,7 +5853,7 @@ function createGithubTracker(options) {
   };
   return Object.freeze(tracker);
 }
-var PREFIX2 = "github tracker", GITHUB_LABELS, VIEW_FIELDS = "number,title,body,state,stateReason,labels,url", LIST_FIELDS = "number,url,labels", DEFAULT_FIND_LIMIT = 30, NOT_PLANNED = "NOT_PLANNED", ISSUE_NUMBER, REPO_PART, CREATED_ISSUE_URL, REST_STATES, DRAFT_CHECKS;
+var PREFIX2 = "github tracker", GITHUB_LABELS, VIEW_FIELDS = "number,title,body,state,stateReason,labels,url", LIST_FIELDS = "number,url,labels", DEFAULT_FIND_LIMIT = 30, NOT_PLANNED = "NOT_PLANNED", ISSUE_NUMBER, REPO_PART, CREATED_ISSUE_URL, REST_STATES, TIMED_OUT, DRAFT_CHECKS;
 var init_github = __esm(() => {
   init_config_sections();
   init_issue_values();
@@ -5853,6 +5876,7 @@ var init_github = __esm(() => {
     released: "closed",
     cancelled: "closed"
   };
+  TIMED_OUT = Symbol("timed out");
   DRAFT_CHECKS = [
     ["opt", (value) => typeof value === "number" && Number.isFinite(value), "a number"],
     ["title", (value) => typeof value === "string", "a string"],
@@ -9639,7 +9663,7 @@ function isProbedTag(tag) {
   return tag === "auto" || tag === "start";
 }
 function extractProbe(description) {
-  const probe = BACKTICK_RE.exec(description)?.[1]?.trim();
+  const probe = PROBE_RE.exec(description)?.[1]?.trim();
   return probe || null;
 }
 function readItem(lines, lineIndex, inherited) {
@@ -9686,24 +9710,36 @@ function requiredItemsTagged(items, tag) {
   const probed = items.filter(isProbed).filter((item) => item.tag === tag);
   return Object.freeze(probed.map(requiredItem));
 }
-function reminderOf(item) {
+function namedItemOf(item) {
   return Object.freeze({ description: item.description, tag: item.tag, line: item.lineIndex + 1 });
 }
+function isMalformed(item) {
+  return isProbedTag(item.tag) && item.probe === null;
+}
 function planPrerequisites(content) {
   const items = parsePrerequisites(content);
   return Object.freeze({
     required: requiredItemsTagged(items, "auto"),
     startRequired: requiredItemsTagged(items, "start"),
-    reminders: Object.freeze(items.filter((item) => !isProbed(item)).map(reminderOf))
+    reminders: Object.freeze(items.filter((item) => !isProbedTag(item.tag)).map(namedItemOf)),
+    malformed: Object.freeze(items.filter(isMalformed).map(namedItemOf))
   });
 }
+function malformedPrerequisiteLines(file, malformed) {
+  return [
+    `${file} holds ${malformed.length} malformed [auto] or [start] item(s): no command ends the item after a final ": ".`,
+    ...malformed.map((item) => `  line ${item.line} [${item.tag}]: ${item.description}`),
+    `Write each as ${PROBE_ITEM_EXAMPLE}, its one backticked span a complete command run as written;` + " prove a tool is there with `<tool> --version`, `<tool> --help` or `which <tool>`."
+  ];
+}
 function mergePlanPrerequisites(settings, content) {
   const plan = planPrerequisites(content ?? "");
   return Object.freeze({
     required: Object.freeze([...settings.prerequisitesRequired, ...plan.required]),
     startRequired: plan.startRequired,
     optional: Object.freeze([...settings.prerequisitesOptional]),
-    reminders: plan.reminders
+    reminders: plan.reminders,
+    malformed: plan.malformed
   });
 }
 function prerequisitesPathForPlan(planPath) {
@@ -9727,7 +9763,7 @@ async function loadPlanPrerequisites(planPath, settings) {
   const content = path === null ? null : await readIfPresent2(path);
   return mergePlanPrerequisites(settings, content);
 }
-var SECTION_AUTO_RE, SECTION_START_RE, SECTION_HUMAN_RE, ITEM_RE, INLINE_AUTO_RE, INLINE_HUMAN_RE, INLINE_START_RE, BACKTICK_RE, HEADING_MARKS_RE, FENCE_RE, NESTED_LIST_ITEM_RE, PLAN_FILE_RE;
+var SECTION_AUTO_RE, SECTION_START_RE, SECTION_HUMAN_RE, ITEM_RE, INLINE_AUTO_RE, INLINE_HUMAN_RE, INLINE_START_RE, PROBE_RE, HEADING_MARKS_RE, FENCE_RE, NESTED_LIST_ITEM_RE, PLAN_FILE_RE, PROBE_ITEM_EXAMPLE = "- [ ] uv installed: `uvx --version`";
 var init_prerequisites_md = __esm(() => {
   init_config_sections();
   SECTION_AUTO_RE = /\[auto\]/i;
@@ -9737,7 +9773,7 @@ var init_prerequisites_md = __esm(() => {
   INLINE_AUTO_RE = /^-\s+\[\s*\]\s+\[auto\]\s+/i;
   INLINE_HUMAN_RE = /^-\s+\[\s*\]\s+\[human\]\s+/i;
   INLINE_START_RE = /^-\s+\[\s*\]\s+\[start\]\s+/i;
-  BACKTICK_RE = /`([^`]+)`/;
+  PROBE_RE = /:\s+`([^`]+)`\s*$/;
   HEADING_MARKS_RE = /^#+/;
   FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
   NESTED_LIST_ITEM_RE = /^\s+(?:[-*+]|\d+[.)])\s/;
@@ -10972,6 +11008,18 @@ async function loadItems(options) {
 `));
   }
 }
+function refuseMalformedItems(planPath, items) {
+  if (items.malformed.length === 0)
+    return;
+  const file = basename4(prerequisitesPathForPlan(planPath) ?? planPath);
+  const [head = "", ...rest] = malformedPrerequisiteLines(file, items.malformed);
+  throw new CommandExit(1, [
+    `\u274C Refusing to start: ${head}`,
+    ...rest.map((line) => `   ${line}`),
+    "   Nothing was checked and nothing was dispatched."
+  ].join(`
+`));
+}
 function skippedStartLine(item, tracker) {
   return `\u23ED start-only item ${item.kind} ${JSON.stringify(item.name)} was not checked:` + " it is probed on a first dispatch alone," + ` and ${tracker} already holds a ticked task`;
 }
@@ -11029,6 +11077,7 @@ async function runStartPreflight(options) {
   const runId = (options.newRunId ?? randomUUID6)();
   refuseUnresolvableAgents(options);
   const items = await loadItems(options);
+  refuseMalformedItems(options.planPath, items);
   announceReminders(options.planPath, items.reminders);
   const tiers = {
     required: [...automaticItems(options), ...startTier(options.planPath, items), ...items.required],
@@ -12296,6 +12345,15 @@ var init_blocked = __esm(() => {
 });
 
 // src/board/readiness.ts
+function codeSpanEnd(text2, limit) {
+  const open = text2.indexOf(CODE_TICK);
+  if (open === -1 || open > limit)
+    return -1;
+  const close = text2.indexOf(CODE_TICK, open + 1);
+  if (close === -1)
+    return -1;
+  return close + 1;
+}
 function stripComments(line, carried) {
   const comments = [];
   let visible = "";
@@ -12315,6 +12373,12 @@ function stripComments(line, carried) {
       visible += rest;
       break;
     }
+    const quoted = codeSpanEnd(rest, start);
+    if (quoted !== -1) {
+      visible += rest.slice(0, quoted);
+      rest = rest.slice(quoted);
+      continue;
+    }
     visible += rest.slice(0, start);
     const body = rest.slice(start + COMMENT_OPEN.length);
     const end = body.indexOf(COMMENT_CLOSE);
@@ -12335,6 +12399,9 @@ function headingOf2(visible) {
   const [, hashes = "", title2 = ""] = match;
   return { level: hashes.length, title: title2.replace(/\s+#+\s*$/u, "").trim() };
 }
+function fencedLine(number, text2) {
+  return { number, fenced: true, visible: text2, comments: [], heading: null };
+}
 function readLines2(body) {
   const raw = body.split(`
 `).map((line) => line.replace(/\r$/u, ""));
@@ -12342,18 +12409,21 @@ function readLines2(body) {
   let carried = false;
   let fenced = false;
   raw.forEach((text2, index) => {
+    const number = index + 1;
+    const isFence2 = FENCE_LINE2.test(text2);
+    if (fenced || !carried && isFence2) {
+      fenced = !fenced || !isFence2;
+      lines.push(fencedLine(number, text2));
+      return;
+    }
     const stripped = stripComments(text2, carried);
     carried = stripped.open;
-    const isFence2 = FENCE_LINE2.test(stripped.visible);
-    const inFence = fenced || isFence2;
-    if (isFence2)
-      fenced = !fenced;
     lines.push({
-      number: index + 1,
-      fenced: inFence,
+      number,
+      fenced: false,
       visible: stripped.visible,
       comments: stripped.comments,
-      heading: inFence ? null : headingOf2(stripped.visible)
+      heading: headingOf2(stripped.visible)
     });
   });
   return lines;
@@ -12393,13 +12463,13 @@ function gapAt(kind, heading, what, line) {
   return { kind, heading, what, line };
 }
 function placeholdersInLine(heading, line) {
+  if (line.fenced)
+    return [];
   const found = [];
   const unfilled = line.comments.some((comment) => !comment.trim().startsWith(MARKER_PREFIX));
   if (unfilled) {
     found.push(gapAt("placeholder", heading, `holds an unfilled template comment on line ${String(line.number)}`, line.number));
   }
-  if (line.fenced)
-    return found;
   const prose = line.visible.replace(CODE_SPAN2, " ");
   for (const shape of PLACEHOLDER_SHAPES) {
     if (!shape.pattern.test(prose))
@@ -12479,7 +12549,7 @@ function requireCompleteSpec(source, body) {
     return;
   throw new CommandExit(READINESS_REFUSAL_EXIT, readinessRefusalMessage(source, gaps));
 }
-var SPEC_READY_LABEL = "spec:ready", READINESS_REFUSAL_EXIT = 2, TEMPLATE_HEADINGS, LIST_HEADINGS, PREAMBLE_HEADING = "the opening", MARKER_PREFIX = "rafa:", HEADING_LINE, FENCE_LINE2, LIST_ITEM, CODE_SPAN2, HEADING_DRESS, HEADING_TAIL, COMMENT_OPEN = "<!--", COMMENT_CLOSE = "-->", PLACEHOLDER_SHAPES, REMEDY2 = "fill each gap in the spec and rerun";
+var SPEC_READY_LABEL = "spec:ready", READINESS_REFUSAL_EXIT = 2, TEMPLATE_HEADINGS, LIST_HEADINGS, PREAMBLE_HEADING = "the opening", MARKER_PREFIX = "rafa:", HEADING_LINE, FENCE_LINE2, LIST_ITEM, CODE_SPAN2, CODE_TICK = "`", HEADING_DRESS, HEADING_TAIL, COMMENT_OPEN = "<!--", COMMENT_CLOSE = "-->", PLACEHOLDER_SHAPES, REMEDY2 = "fill each gap in the spec and rerun";
 var init_readiness = __esm(() => {
   init_command();
   TEMPLATE_HEADINGS = [
@@ -22662,6 +22732,17 @@ async function loadItems2(plan, config) {
     throw refusal4(["rafa doctor: the plan's prerequisites cannot be read:", `  ${messageOf(error)}`]);
   }
 }
+function refuseMalformedItems2(plan, items) {
+  if (plan === null || items.malformed.length === 0)
+    return;
+  const file = basename12(prerequisitesPathForPlan(plan) ?? plan);
+  const [head = "", ...rest] = malformedPrerequisiteLines(file, items.malformed);
+  throw refusal4([
+    `rafa doctor: ${head}`,
+    ...rest,
+    "rafa loop start would refuse here, before any probe. No run was started and nothing was stored."
+  ]);
+}
 function mergedFile(plan) {
   const file = plan === null ? null : prerequisitesPathForPlan(plan);
   return file !== null && isFile(file) ? file : null;
@@ -22693,6 +22774,7 @@ async function checkPreflight(context, project, seams) {
   const { config } = resolved;
   const { plan, lookedFor } = choosePlan(project.root, config, named);
   const items = await loadItems2(plan, config);
+  refuseMalformedItems2(plan, items);
   const automatic = readProvider(project.root, config, seams);
   const start = readStartTier(plan, items);
   const tiers = {
@@ -24093,7 +24175,9 @@ var init_scaffold = __esm(() => {
     `#   worktreeIdleDays: ${String(CONFIG_DEFAULTS.cleanupWorktreeIdleDays)}          # days before rafa cleanup lists a worktree as idle`,
     "#   keep: []                     # glob patterns naming branches rafa cleanup never lists",
     "# dangerous:",
-    `#   acceptStaleRefs: ${String(CONFIG_DEFAULTS.dangerousAcceptStaleRefs)}       # true plans past dangling and suspect spec references on every run`
+    `#   acceptStaleRefs: ${String(CONFIG_DEFAULTS.dangerousAcceptStaleRefs)}       # true plans past dangling and suspect spec references on every run`,
+    "# status:",
+    `#   notice: ${String(CONFIG_DEFAULTS.statusNotice)}                 # false drops the one-line notice of what is new since the last command`
   ]);
   VERSION_LINE = `version: ${String(CONFIG_DEFAULTS.version)}`;
   PROJECT_HEADER = Object.freeze([
@@ -27955,7 +28039,7 @@ function backtickRunLength(text2, start) {
     end += 1;
   return end - start;
 }
-function codeSpanEnd(text2, from, length) {
+function codeSpanEnd2(text2, from, length) {
   let index = text2.indexOf("`", from);
   while (index !== -1) {
     const run = backtickRunLength(text2, index);
@@ -27971,7 +28055,7 @@ function firstClause(text2) {
     const character = text2.charAt(index);
     if (character === "`") {
       const run = backtickRunLength(text2, index);
-      const end = codeSpanEnd(text2, index + run, run);
+      const end = codeSpanEnd2(text2, index + run, run);
       index = end === -1 ? index + run : end;
       continue;
     }
@@ -38007,6 +38091,360 @@ var init_show7 = __esm(() => {
   show_default6 = createSkillShowCommand();
 });
 
+// src/status/render.ts
+function counted6(count, noun, plural7 = `${noun}s`) {
+  return `${String(count)} ${count === 1 ? noun : plural7}`;
+}
+function info(text2) {
+  return { level: "info", text: text2 };
+}
+function branchText(reading2) {
+  const plan2 = reading2.plan === null ? "no plan" : `plan \`${reading2.plan.stub}\` (${formatCounts(reading2.plan.tasks)})`;
+  return `\`${reading2.branch}\`, ${plan2}`;
+}
+function blockedTaskCount(blocked2) {
+  return blocked2.reduce((sum, one) => sum + one.tasks.length, 0);
+}
+function loopsText(reading2) {
+  const tasks = blockedTaskCount(reading2.blocked);
+  return `${String(reading2.live.length)} running, ${counted6(tasks, "task")} blocked`;
+}
+function loopsBody(reading2) {
+  const running2 = reading2.live.map((record) => info(`${INDENT15}${sessionLine(record)}`));
+  const blocked2 = reading2.blocked.flatMap((one) => one.tasks.map((task) => {
+    const blocker = task.blocker === null ? "" : ` (${task.blocker})`;
+    return info(`${INDENT15}blocked: plan \`${planLabel(one.session)}\` line ${String(task.line)}: ${task.text}${blocker}`);
+  }));
+  return [...running2, ...blocked2];
+}
+function pullText(reading2) {
+  if (reading2.pull === null)
+    return "none open";
+  const { summary, mergeable, verdict } = reading2.pull;
+  return `#${String(summary.number)} ${summary.title}, ${MERGEABILITY_WORDS[mergeable]}, ${VERDICT_WORDS[verdict]}`;
+}
+function boardText(reading2) {
+  const roadmap = `roadmap #${String(reading2.roadmap)}`;
+  const next = reading2.next === null ? `${roadmap} has no line left` : `next is #${String(reading2.next.line.issue)} on ${roadmap}, ${nextStanding(reading2.next)}`;
+  const blocked2 = reading2.blockedIssues === null ? `the ${SPEC_BLOCKED_LABEL} issues were not read` : `${counted6(reading2.blockedIssues, "issue")} labelled ${SPEC_BLOCKED_LABEL}`;
+  return `${next}; ${blocked2}`;
+}
+function nextStanding(next) {
+  if (next.blocked !== null)
+    return blockedLineSentence(next.blocked);
+  return next.ready ? "ready" : "not ready";
+}
+function housekeepingText(reading2) {
+  const { merged: merged2, stale, notPushed, worktrees } = reading2.counts;
+  return `${String(merged2)} merged, ${String(stale)} stale, ${String(notPushed)} not pushed,` + ` ${counted6(worktrees, "worktree")} (${String(reading2.idleWorktrees)} idle)`;
+}
+function sectionLines(key, section3, text2, body = () => []) {
+  const title2 = STATUS_SECTION_TITLES[key];
+  if (!section3.read)
+    return [{ level: "warn", text: `${title2}: not read: ${section3.problem}` }];
+  return [info(`${title2}: ${text2(section3)}`), ...body(section3)];
+}
+function renderStatus3(sections2) {
+  return [
+    ...sectionLines("branch", sections2.branch, branchText),
+    ...sectionLines("loops", sections2.loops, loopsText, loopsBody),
+    ...sectionLines("pull", sections2.pull, pullText),
+    ...sectionLines("board", sections2.board, boardText),
+    ...sectionLines("housekeeping", sections2.housekeeping, housekeepingText)
+  ];
+}
+function sectionData(section3) {
+  const copy = JSON.parse(JSON.stringify(section3));
+  const reading2 = Object.fromEntries(Object.entries(copy).filter(([key]) => key !== "read"));
+  return { read: section3.read, ...reading2 };
+}
+function statusData(sections2) {
+  return {
+    branch: sectionData(sections2.branch),
+    loops: sectionData(sections2.loops),
+    pull: sectionData(sections2.pull),
+    board: sectionData(sections2.board),
+    housekeeping: sectionData(sections2.housekeeping)
+  };
+}
+var STATUS_SECTION_TITLES, INDENT15 = "  ", MERGEABILITY_WORDS, VERDICT_WORDS;
+var init_render = __esm(() => {
+  init_blocked_line();
+  init_blocked();
+  init_loop_sessions();
+  init_plan_files();
+  STATUS_SECTION_TITLES = Object.freeze({
+    branch: "Branch",
+    loops: "Loops",
+    pull: "Pull request",
+    board: "Board",
+    housekeeping: "Housekeeping"
+  });
+  MERGEABILITY_WORDS = Object.freeze({
+    mergeable: "mergeable",
+    conflicting: "conflicting",
+    unknown: "mergeability unknown"
+  });
+  VERDICT_WORDS = Object.freeze({
+    green: "checks green",
+    red: "checks red",
+    pending: "checks pending",
+    none: "no checks"
+  });
+});
+
+// src/status/sections.ts
+function isIdleWorktree(row2) {
+  return !row2.blockers.some((blocker) => blocker.kind === "recent");
+}
+function unread2(problem2) {
+  return { read: false, problem: problem2 };
+}
+function read2(reading2) {
+  return { ...reading2, read: true };
+}
+function localSection(work) {
+  try {
+    const reading2 = work();
+    return isUnread(reading2) ? reading2 : read2(reading2);
+  } catch (error) {
+    return unread2(messageOf(error));
+  }
+}
+function isUnread(value) {
+  return typeof value === "object" && value !== null && value.read === false;
+}
+function openDeadline(ms) {
+  let endsAt = null;
+  return {
+    ms,
+    start: () => {
+      endsAt = Date.now() + ms;
+    },
+    left: () => endsAt === null ? ms : endsAt - Date.now()
+  };
+}
+function boundedRunner(open, root, deadline) {
+  return (args) => {
+    const left = deadline.left();
+    if (left <= 0) {
+      return Promise.resolve({
+        ok: false,
+        stdout: "",
+        stderr: `gh ${args.join(" ")} was not run: the ${String(deadline.ms)}ms network deadline had passed`
+      });
+    }
+    return open(root, left)(args);
+  };
+}
+async function networkSection(what, deadline, work) {
+  let timer;
+  const expired = new Promise((resolve29) => {
+    timer = setTimeout(() => {
+      resolve29(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+    }, Math.max(0, deadline.left()));
+  });
+  try {
+    return await Promise.race([work().then((reading2) => read2(reading2)), expired]);
+  } catch (error) {
+    return unread2(messageOf(error));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function notGhProblem(what, provider) {
+  const from = provider.source === "config" ? "as the config names it" : "as origin is no GitHub remote";
+  return `pr.provider is ${provider.provider}, ${from}, and rafa status reads the ${what} through gh alone`;
+}
+function readBranchSection(sources) {
+  let notes = [];
+  const note = (problem2) => {
+    notes = [...notes, problem2];
+  };
+  const branch = readBranch(sources, note);
+  if (branch === "") {
+    return unread2(notes.join("; ") || "the branch at the project root could not be read");
+  }
+  const plans = readPlans(sources, note);
+  return { branch, plan: readBranchPlan(branch, plans), notes };
+}
+function blockedSessions(root, records) {
+  let seen = new Set;
+  let found = [];
+  for (const session of [...records].reverse()) {
+    const checklist = readSessionChecklist(root, session);
+    if (checklist === null || seen.has(checklist.file))
+      continue;
+    seen = new Set([...seen, checklist.file]);
+    const tasks = blockedTasks(checklist);
+    if (tasks.length > 0)
+      found = [...found, { session, checklist: checklist.file, tasks }];
+  }
+  return found;
+}
+function readLoopsSection(root, sources) {
+  return localSection(() => {
+    const records = sources.runs();
+    return { live: records.filter((record) => isLive(record)), blocked: blockedSessions(root, records) };
+  });
+}
+function pullSection(sources, branch, provider, deadline) {
+  if (provider.provider !== "gh")
+    return Promise.resolve(unread2(notGhProblem("pull request", provider)));
+  if (!branch.read) {
+    return Promise.resolve(unread2(`no pull request was looked for, as the branch was not read: ${branch.problem}`));
+  }
+  return networkSection("pull request", deadline, () => readPull(sources, branch.branch));
+}
+async function readPull(sources, branch) {
+  let notes = [];
+  const pull = await readOpenPull(sources, branch, (problem2) => {
+    notes = [...notes, problem2];
+  });
+  return { pull, notes };
+}
+async function readBoard(board, blocked2) {
+  const [walk, report3] = await Promise.all([board.next(), blocked2]);
+  const { line } = walk;
+  const next = line === null ? null : { line, ready: await board.isReady(line.issue), blocked: await board.blocking(line.issue) };
+  const listed3 = report3.problem === null ? [] : [`the issues labelled ${SPEC_BLOCKED_LABEL} could not be read: ${report3.problem}`];
+  return {
+    roadmap: walk.roadmap,
+    next,
+    passed: walk.passed,
+    blockedIssues: report3.problem === null ? report3.readings.length : null,
+    notes: [...walk.problems, ...listed3]
+  };
+}
+async function readHousekeeping(input, cleanup, now) {
+  try {
+    const settings = doctorCleanupSettings({ root: input.root, home: input.home, config: input.config, gh: null }, now);
+    const reading2 = await readCleanup(cleanup, settings);
+    if (!reading2.ok)
+      return unread2(reading2.detail);
+    const idle = reading2.worktrees.filter((row2) => isIdleWorktree(row2));
+    return read2({ counts: cleanupCounts(reading2), idleWorktrees: idle.length, notes: reading2.notes });
+  } catch (error) {
+    return unread2(messageOf(error));
+  }
+}
+async function readStatusSections(input, seams = {}) {
+  const { root, config } = input;
+  const git = (seams.openGit ?? createGitRunner)(root);
+  const openGh2 = seams.openGh ?? ((cwd, timeoutMs) => createGhRunner({ cwd, timeoutMs }));
+  const deadline = openDeadline(seams.timeoutMs ?? STATUS_NETWORK_TIMEOUT_MS);
+  const gh = boundedRunner(openGh2, root, deadline);
+  const pulls = (seams.pullRequests ?? ((runner) => createGhPullRequests({ gh: runner })))(gh);
+  const board = (seams.board ?? ghNextBoard)({ gh, git, configured: config.roadmapIssue });
+  const sources = {
+    base: config.prBase ?? DEFAULT_BASE_BRANCH,
+    plans: plansDirAt(root, config.planDir),
+    runs: () => readSessions(root, { isAlive: seams.isAlive }),
+    git,
+    pulls,
+    board
+  };
+  const branch = localSection(() => readBranchSection(sources));
+  const loops = readLoopsSection(root, sources);
+  const provider = resolvePrProvider({ configured: config.prProvider, dir: root, readRemote: seams.readRemote });
+  const isGh = provider.provider === "gh";
+  const cleanup = (seams.cleanupSeams ?? defaultCleanupSeams)(root, isGh ? pulls : null);
+  const now = (seams.now ?? (() => new Date))();
+  const blockedIssues = seams.blockedIssues ?? ((runner) => readBlockedIssues({ gh: runner }));
+  deadline.start();
+  const pull = pullSection(sources, branch, provider, deadline);
+  const boardSection = isGh ? networkSection("board", deadline, () => readBoard(board, blockedIssues(gh))) : Promise.resolve(unread2(notGhProblem("board", provider)));
+  const housekeeping = readHousekeeping(input, cleanup, now);
+  return {
+    branch,
+    loops,
+    pull: await pull,
+    board: await boardSection,
+    housekeeping: await housekeeping
+  };
+}
+var STATUS_NETWORK_TIMEOUT_MS = 5000;
+var init_sections = __esm(() => {
+  init_github();
+  init_blocked();
+  init_cleanup();
+  init_doctor_blocked();
+  init_doctor_cleanup();
+  init_loop_sessions();
+  init_status2();
+  init_plan_files();
+  init_config_sections();
+  init_sessions();
+  init_readings();
+  init_sources();
+  init_pr();
+});
+
+// src/commands/status.ts
+function projectOf15(context) {
+  if (context.project === null)
+    throw new Error("rafa status runs inside a project, and was handed none");
+  return context.project;
+}
+function expectNoWord(args) {
+  if (args.length === 0)
+    return;
+  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME6}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
+Usage: ${STATUS_USAGE}`);
+}
+async function runStatus2(context, seams) {
+  expectNoWord(context.args);
+  const project = projectOf15(context);
+  const config = resolveProjectConfig(project, COMMAND_NAME6, (message) => {
+    context.output.warn(message);
+  });
+  const read3 = seams.read ?? ((input) => readStatusSections(input));
+  const sections2 = await read3({ root: project.root, home: project.home, config });
+  if (context.outputMode === "json") {
+    context.output.result(statusData(sections2));
+    return;
+  }
+  for (const line of renderStatus3(sections2)) {
+    if (line.level === "warn")
+      context.output.warn(line.text);
+    else
+      context.output.info(line.text);
+  }
+}
+function createStatusCommand(seams = DEFAULT_STATUS_SEAMS) {
+  const command = {
+    name: "status",
+    subject: "status",
+    action: "status",
+    summary: "where the project stands: branch and plan, loops, pull request, board and housekeeping",
+    description: "Prints one line for each of five sections. Branch: the branch checked out at the project root" + " and the plan its `feat/<stub>` names, with its task counts. Loops: how many sessions are running and" + " how many tasks are blocked, with a line under it for each running loop and each blocked task. Pull" + " request: the branch's open pull request, whether it can be merged and its checks. Board: the" + " Roadmap's next issue and whether it is ready, and how many issues carry `spec:blocked`. Housekeeping:" + " what `rafa cleanup` would list, counted per group, and how many worktrees are idle. Git, the session" + " records and the plans are read first; the pull request and the board are read through `gh` under a" + " short deadline, and nothing is fetched. A section that cannot be read is one `warn` line saying why," + " and the others are printed all the same: it exits 1 only for a config that cannot be used. With" + " `--output=json` the five sections are the data of the terminal result event. Starts no session.",
+    args: [],
+    flags: [],
+    examples: [
+      {
+        cmd: "rafa status",
+        note: "Prints the five sections, one line each, with the running loops and blocked tasks under Loops."
+      },
+      {
+        cmd: "rafa status --output=json",
+        note: "Gives the five sections as data, each with `read` and its reading or the problem."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => runStatus2(context, seams)
+  };
+  return Object.freeze(command);
+}
+var COMMAND_NAME6 = "rafa status", STATUS_USAGE = "rafa status", STATUS_ARGUMENT_EXIT = 2, DEFAULT_STATUS_SEAMS, status_default3;
+var init_status4 = __esm(() => {
+  init_command();
+  init_render();
+  init_sections();
+  init_plan_files();
+  DEFAULT_STATUS_SEAMS = Object.freeze({});
+  status_default3 = createStatusCommand();
+});
+
 // src/usage.ts
 async function usage(_args) {
   const pct = await getClaudeUsagePercent();
@@ -38113,6 +38551,7 @@ var init_commands2 = __esm(() => {
   init_list();
   init_search2();
   init_show7();
+  init_status4();
   init_usage2();
   CORE_SUBJECTS = Object.freeze([
     { name: "plan", summary: "create plans from specs; list, show and validate them; read their risk and needs" },
@@ -38173,6 +38612,7 @@ var init_commands2 = __esm(() => {
     show_default2,
     status_default2,
     tag_default,
+    status_default3,
     next_default,
     roadmap_default,
     init_default,
@@ -38606,9 +39046,31 @@ function placeCommand(command, settings) {
     return { kind: "refused", message: error.message };
   }
 }
+async function callHook(half, call, base) {
+  try {
+    return await call();
+  } catch (error) {
+    base.output.debug(`command hook ${half}: ${messageOf2(error)}`);
+    return null;
+  }
+}
 async function settleCommand(route, base, registry, settings) {
   const placement = placeCommand(route.command, settings);
-  return placement.kind === "refused" ? failure("no_project", placement.message) : runCommand(route, base, registry, placement.project, settings);
+  if (placement.kind === "refused")
+    return failure("no_project", placement.message);
+  const { project } = placement;
+  const hook = base.outputMode === "text" ? settings.commandHook : null;
+  if (hook === null || project === null)
+    return runCommand(route, base, registry, project, settings);
+  const line = await callHook("before", async () => hook.before(route, project), base);
+  if (line !== null)
+    settings.stderr.write(`${line}
+`);
+  try {
+    return await runCommand(route, base, registry, project, settings);
+  } finally {
+    await callHook("after", async () => hook.after(route, project), base);
+  }
 }
 async function settle(route, base, problem, registry, settings) {
   switch (route.kind) {
@@ -38665,7 +39127,8 @@ async function dispatch(argv, options) {
     now: options.now ?? (() => new Date),
     renderHelp: options.renderHelp ?? renderUsage,
     cwd: () => options.cwd ?? process.cwd(),
-    home: () => options.home ?? homedir()
+    home: () => options.home ?? homedir(),
+    commandHook: options.commandHook ?? null
   };
   const loaded = await loadModuleCommands(options.registry, options.modules ?? [], options.importModule);
   const route = routeLine(loaded.registry, argv);
@@ -38688,11 +39151,191 @@ async function dispatch(argv, options) {
 init_help();
 init_commands2();
 init_load();
+
+// src/status/hook.ts
+init_config_load();
+
+// src/status/notice.ts
+var CLEANUP_COMMAND2 = "rafa cleanup";
+var STATUS_COMMAND = "rafa status";
+var NOTICE_PREFIX = "rafa: since your last command: ";
+var LIVE_STATES2 = new Set(["running", "paused"]);
+function added(previous, current) {
+  const seen = new Set(previous);
+  return current.filter((item) => !seen.has(item)).sort();
+}
+function hasStopped(before, now) {
+  return before !== undefined && LIVE_STATES2.has(before.state) && !LIVE_STATES2.has(now.state);
+}
+function hasNewBlocked(before, now) {
+  const seen = new Set(before?.blocked ?? []);
+  return now.blocked.some((line) => !seen.has(line));
+}
+function compareSeen(previous, current) {
+  const ids = Object.keys(current.sessions).sort();
+  const before = (id) => Object.hasOwn(previous.sessions, id) ? previous.sessions[id] : undefined;
+  return {
+    idleWorktrees: added(previous.idleWorktrees, current.idleWorktrees),
+    mergedBranches: added(previous.mergedBranches, current.mergedBranches),
+    stoppedSessions: ids.filter((id) => hasStopped(before(id), current.sessions[id])),
+    blockedSessions: ids.filter((id) => hasNewBlocked(before(id), current.sessions[id]))
+  };
+}
+function counted7(count, singular, many) {
+  return count === 1 ? `1 ${singular}` : `${count} ${many}`;
+}
+function newsLine(news) {
+  const parts = [
+    [news.idleWorktrees.length, "worktree went idle", "worktrees went idle"],
+    [news.mergedBranches.length, "merged branch left behind", "merged branches left behind"],
+    [news.stoppedSessions.length, "loop stopped", "loops stopped"],
+    [news.blockedSessions.length, "loop has a new blocked task", "loops have new blocked tasks"]
+  ];
+  const said = parts.filter(([count]) => count > 0).map(([count, one, many]) => counted7(count, one, many));
+  if (said.length === 0)
+    return null;
+  const loops = news.stoppedSessions.length + news.blockedSessions.length;
+  const command = loops > 0 ? STATUS_COMMAND : CLEANUP_COMMAND2;
+  return `${NOTICE_PREFIX}${said.join(", ")}; run ${command}`;
+}
+function noticeLine(previous, current) {
+  if (previous === null)
+    return null;
+  return newsLine(compareSeen(previous, current));
+}
+
+// src/status/seen.ts
+init_cleanup();
+init_doctor_cleanup();
+init_loop_sessions();
+init_status2();
+init_config_sections();
+init_sessions();
+init_scope();
+init_sections();
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync54, renameSync as renameSync5, writeFileSync as writeFileSync21 } from "fs";
+import { dirname as dirname20, join as join61 } from "path";
+var SEEN_FILE = "status-seen.json";
+var SEEN_VERSION = 1;
+function seenFilePath(root) {
+  return join61(scopeAt(root).dir, SEEN_FILE);
+}
+function readSeenSessions(root, isAlive) {
+  const sessions = {};
+  for (const record of readSessions(root, { isAlive })) {
+    const blocked2 = blockedTasks(readSessionChecklist(root, record)).map((task) => task.line);
+    sessions[record.sessionId] = { state: record.state, blocked: [...blocked2].sort((a, b) => a - b) };
+  }
+  return sessions;
+}
+async function takeSeenSnapshot(input, seams = {}) {
+  try {
+    const now = (seams.now ?? (() => new Date))();
+    const worktreeSeams = (seams.worktreeSeams ?? defaultWorktreeSeams)(input.root);
+    const settings = doctorCleanupSettings({ ...input, gh: null }, now);
+    const reading2 = await readCleanup({ ...worktreeSeams, pulls: null }, { ...settings, fetch: false });
+    if (!reading2.ok)
+      return { ok: false, detail: reading2.detail };
+    const idle = reading2.worktrees.filter((row2) => isIdleWorktree(row2)).map((row2) => row2.path);
+    const merged2 = reading2.merged.map((row2) => row2.branch.name);
+    return {
+      ok: true,
+      snapshot: {
+        version: SEEN_VERSION,
+        idleWorktrees: [...idle].sort(),
+        mergedBranches: [...merged2].sort(),
+        sessions: readSeenSessions(input.root, seams.isAlive)
+      }
+    };
+  } catch (error) {
+    return { ok: false, detail: messageOf(error) };
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStrings(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isSeenSession(value) {
+  return isRecord2(value) && SESSION_STATES.includes(value.state) && Array.isArray(value.blocked) && value.blocked.every((line) => Number.isInteger(line) && line > 0);
+}
+function asSnapshot(value) {
+  if (!isRecord2(value) || value.version !== SEEN_VERSION)
+    return null;
+  const { idleWorktrees, mergedBranches, sessions } = value;
+  if (!isStrings(idleWorktrees) || !isStrings(mergedBranches) || !isRecord2(sessions))
+    return null;
+  if (!Object.values(sessions).every((session) => isSeenSession(session)))
+    return null;
+  return { version: SEEN_VERSION, idleWorktrees, mergedBranches, sessions };
+}
+function readSeenFile(root) {
+  let text2;
+  try {
+    text2 = readFileSync54(seenFilePath(root), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return asSnapshot(JSON.parse(text2));
+  } catch {
+    return null;
+  }
+}
+function writeSeenFile(root, snapshot) {
+  const file = seenFilePath(root);
+  mkdirSync19(dirname20(file), { recursive: true });
+  const temporary = `${file}.${String(process.pid)}.tmp`;
+  writeFileSync21(temporary, `${JSON.stringify(snapshot, null, 2)}
+`);
+  renameSync5(temporary, file);
+}
+
+// src/status/hook.ts
+var QUIET_COMMANDS = Object.freeze(["status", "cleanup"]);
+function projectConfig(project) {
+  return loadConfig({ root: project.root, home: project.home }, {}, () => {
+    return;
+  }).config;
+}
+function isQuietCommand(route) {
+  return route.module === null && QUIET_COMMANDS.includes(route.command.name);
+}
+function createStatusHook(seams = {}) {
+  const configOf = seams.config ?? projectConfig;
+  const take = seams.take ?? (async (input) => takeSeenSnapshot(input));
+  const snapshot = async (project) => {
+    const config = configOf(project);
+    if (!config.statusNotice)
+      return null;
+    const reading2 = await take({ root: project.root, home: project.home, config });
+    if (!reading2.ok)
+      throw new Error(`the status reading failed: ${reading2.detail}`);
+    return reading2.snapshot;
+  };
+  return Object.freeze({
+    before: async (route, project) => {
+      if (isQuietCommand(route))
+        return null;
+      const current = await snapshot(project);
+      return current === null ? null : noticeLine(readSeenFile(project.root), current);
+    },
+    after: async (_route, project) => {
+      const current = await snapshot(project);
+      if (current !== null)
+        writeSeenFile(project.root, current);
+    }
+  });
+}
+
+// src/rafa.ts
 var modules = await loadInvocationModules({ cwd: process.cwd(), home: homedir10() });
 var { exitCode } = await dispatch(process.argv.slice(2), {
   registry: CORE_REGISTRY,
   renderHelp,
   modules: modules.commands,
-  warnings: modules.warnings
+  warnings: modules.warnings,
+  commandHook: createStatusHook()
 });
 process.exitCode = exitCode;