@agentproto/apps 0.21.1 → 0.21.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentproto/apps",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "@agentproto/apps — a home for ready-made agentproto apps (teams of agents + their workflows), declared with @agentproto/app-kit. Import a team (code-team, content-team, …) and use any of its agents/workflows from your own host: in-process via toMastraAgents(), or emit its manifests to disk.",
   "keywords": [
     "agentproto",
@@ -173,9 +173,9 @@
   },
   "dependencies": {
     "zod": "^4.6.5",
-    "@agentproto/app-client": "0.4.1",
-    "@agentproto/app-kit": "1.7.1",
     "@agentproto/agent": "0.2.5",
+    "@agentproto/app-client": "0.4.1",
+    "@agentproto/app-kit": "1.7.2",
     "@agentproto/workflow": "0.7.1"
   },
   "peerDependencies": {

package/session-steward/.agentproto/workflows/session-steward/WORKFLOW.md

@@ -261,7 +261,7 @@ steps:
   - id: relabelQueue
     kind: transform
     name: Terminal sessions missing an outcome (relabel candidates)
-    description: Entry-based — buildRelabelQueue. PR numbers come from the session row.
+    description: Entry-based — buildRelabelQueue. PR numbers (and their owner/repo) come from the session row.
 
   - id: relabelEvidenceQueue
     kind: transform
@@ -284,7 +284,7 @@ steps:
   - id: relabelFinal
     kind: transform
     name: Relabel proposals with their evidence
-    description: Entry-based — applyRelabelEvidence (merged PR/worktree or opened PR → done).
+    description: Entry-based — applyRelabelEvidence. `done` only when the session's own PR is merged and its last message leaves nothing pending; an open PR or pending work → needs-follow-up; a shared worktree's PR credits nobody.
 
   - id: evidence
     kind: map
@@ -463,7 +463,8 @@ Every rule below is a pure function in `cron-rules.mjs`, pinned by
 `session-steward-cron-rules.test.ts`:
 
 - **Loop (1).** `tool_calls_list` per busy session: the same argv verbatim ≥3
-  in 10 min, distinct/total < 0.2, or the same file read ≥4 → `looping`, a
+  in 10 min, distinct/total < 0.2, or the same file read ≥4 (a recursive `rg`/`grep` over a
+  directory, or its pattern, is not a file read) → `looping`, a
   sub-case of `active`. The proposed action is an **interrupt nudge**, never a
   close. Useful loops (watch, test/type-check re-runs, `git status`, `gh pr`
   polling) are excluded.

package/session-steward/.agentproto/workflows/session-steward/cron-rules.mjs

@@ -64,6 +64,7 @@ export function isUsefulLoopCommand(signature) {
 }
 
 const READ_TOOLS = new Set(["read", "cat", "rg", "grep", "sed", "head", "tail", "less", "view", "readfile"])
+const FILE_EXT = /\.(md|ts|tsx|js|mjs|cjs|json|txt|py|go|rs|sql|yml|yaml|toml|log|sh)$/
 const READ_VERB_WORD = /^["']?(cat|rg|grep|sed|head|tail|less|view)["']?$/
 
 /**
@@ -83,15 +84,29 @@ export function readTargetOf(record) {
   const segments = command !== undefined && !readTool ? command.split(/&&|\|\||\||;/) : [undefined]
   for (const seg of segments) {
     let tokens = seg !== undefined ? seg.trim().split(/\s+/) : command !== undefined ? command.split(/\s+/) : args
+    let searchVerb = tool === "rg" || tool === "grep"
     if (seg !== undefined) {
       const first = tokens.findIndex((t) => !t.includes("=") || t.startsWith("-"))
       if (first < 0 || !READ_VERB_WORD.test(tokens[first])) continue
+      searchVerb = /^["']?(rg|grep)["']?$/.test(tokens[first])
       tokens = tokens.slice(first + 1)
     }
+    // `rg`/`grep` take a pattern first, then search roots: the pattern is not
+    // a file, and a root without an extension is a directory (a recursive
+    // search of one tree is not "the same file re-read").
+    let patternPending = searchVerb
     for (const raw of tokens) {
       const t = raw.replace(/^['"]|['"]$/g, "")
       if (!t || t.startsWith("-") || t.includes("=")) continue
-      if (t.includes("/") || /\.(md|ts|tsx|js|mjs|cjs|json|txt|py|go|rs|sql|yml|yaml|toml)$/.test(t)) return t
+      if (patternPending) {
+        patternPending = false
+        continue
+      }
+      if (searchVerb) {
+        if (FILE_EXT.test(t)) return t
+        continue
+      }
+      if (t.includes("/") || FILE_EXT.test(t)) return t
     }
     if (seg === undefined) return args[0] ?? null
   }
@@ -209,7 +224,8 @@ const minutesSince = (ts, nowMs) => {
 
 /**
  * A session that never actually ran: explicit 0 in AND 0 out. `undefined`
- * tokens (not reported) is NOT "never ran" — only a hard 0/0 is. A session
+ * tokens (not reported) is NOT "never ran" — only a hard 0/0 with no cost,
+ * context use or completed turn is. A session
  * that is busy, still starting/provisioning, or has a prompt queued for its
  * first turn is merely young, not stuck. With `opts.nowMs`, the session must
  * also be at least `opts.idleMinutes` old (`startedAt`) AND idle
@@ -217,6 +233,9 @@ const minutesSince = (ts, nowMs) => {
  */
 export function isNeverRan(session, opts = {}) {
   if (!(session?.tokensIn === 0 && session?.tokensOut === 0)) return false
+  // Some adapters (opencode) report 0/0 tokens for a session that ran several
+  // turns; cost, context use or a completed turn prove it ran.
+  if (session.costUsd > 0 || session.contextUsed > 0 || session.lastTurnReason === "completed") return false
   if (session.busy === true || session.status === "starting" || session.provisioning) return false
   if (Array.isArray(session.pendingPrompts) && session.pendingPrompts.length > 0) return false
   if (typeof opts.nowMs === "number") {
@@ -256,7 +275,7 @@ export function isCommitOrPrCall(record) {
 
 /**
  * The done fast-path: the last tool call is `message_parent(kind:done)` AND
- * the window shows a commit/PR (or the worktree/PR state or the derived
+ * the window shows a commit/PR (or a MERGED worktree PR or the derived
  * outcome already proves one). That is `done` without spending a judge.
  * Anything short of both halves returns `{ done: false }`.
  */
@@ -267,9 +286,9 @@ export function detectFastPathDone(input = {}) {
   if (!doneMessage) return { done: false, reason: "no message_parent(kind:done)" }
   const prState = input.worktree?.pr?.state
   const merged = prState === "merged" || prState === "MERGED"
-  const opened = prState === "open" || prState === "OPEN"
   const outcomePrs = Array.isArray(input.outcome?.pullRequests) ? input.outcome.pullRequests.length : 0
-  const hasCommitOrPr = calls.some(isCommitOrPrCall) || merged || opened || outcomePrs > 0
+  // An OPEN worktree PR is work awaiting review, not proof of completion.
+  const hasCommitOrPr = calls.some(isCommitOrPrCall) || merged || outcomePrs > 0
   if (!hasCommitOrPr) return { done: false, reason: "message_parent(kind:done) but no commit/PR" }
   return { done: true, reason: merged || outcomePrs > 0 ? "message_parent(kind:done) + merged/opened PR" : "message_parent(kind:done) + commit" }
 }
@@ -296,82 +315,194 @@ export function prNumbersOf(session) {
 
 /** Relabel verdict for "no positive evidence either way". */
 export const UNKNOWN_VERDICT = "unknown"
+/** Relabel verdict for "a PR/outcome exists but work remains" (report only —
+ *  the steward never closes on it, and a terminal session has nothing to flag). */
+export const FOLLOW_UP_VERDICT = "needs-follow-up"
 
-const fmtPrs = nums => nums.map(n => `#${n}`).join(", ")
 const isMergedState = state => state === "merged" || state === "MERGED"
+const isOpenState = state => state === "open" || state === "OPEN"
+
+/** `owner/repo` out of a GitHub PR URL; undefined when it names no repo. */
+export function repoOfPrUrl(url) {
+  const m = /github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)\/pull\/\d+/.exec(String(url ?? ""))
+  return m ? m[1] : undefined
+}
+
+/** `owner/repo#N` when the repo is known, else `#N` — a bare number is
+ *  ambiguous across repos (G3: `#504` was agentik-studio's, not agentproto's). */
+export const fmtPr = (n, repo) => (repo ? `${repo}#${n}` : `#${n}`)
+const fmtPrs = (nums, repos) => nums.map(n => fmtPr(n, repos?.[n])).join(", ")
+
+/** owner/repo per PR number from the session's `outcome.artifacts` PR refs
+ *  (`…github.com/OWNER/REPO/pull/N`) — the only list-row field that carries
+ *  a repo. Plain object (journal-safe). */
+export function prReposOf(session) {
+  const repos = {}
+  for (const a of Array.isArray(session?.outcome?.artifacts) ? session.outcome.artifacts : []) {
+    if (a?.type !== "pr") continue
+    const m = /\/pull\/(\d+)/.exec(String(a.ref ?? ""))
+    const repo = repoOfPrUrl(a.ref)
+    if (m && repo) repos[Number(m[1])] = repo
+  }
+  return repos
+}
 
 /**
  * A terminal session that still carries no derived outcome and no wrapup
  * flag is a relabel CANDIDATE — visible instead of invisible, as the log
- * asks. The proposed verdict is `done` when the session's own record shows a
- * PR (merged, or merely opened — the PR is the hand-off), else `unknown`: a
- * session with no PR is as likely finished as abandoned, and only evidence
- * ({@link refineRelabel}) can say which.
- * `reason` carries the evidence (`PR #1738 merged`, `PRs #1738, #1740 opened`).
+ * asks. A PR is never proof the session finished, so the proposal is
+ * deliberately cautious: `done` only when the session's OWN record shows its
+ * PR merged (a worktree PR it never recorded is shared with sibling sessions
+ * and credits nobody); otherwise `unknown`. {@link refineRelabel} sharpens
+ * it with evidence and runs the remaining-work check.
  */
 export function terminalRelabelCandidate(session) {
   if (!TERMINAL_STATUSES.has(String(session?.status ?? ""))) return { candidate: false, reason: "not terminal" }
   if (session?.outcome?.verdict) return { candidate: false, reason: "outcome already recorded" }
   if (session?.wrapupFlag) return { candidate: false, reason: "already flagged" }
   const prs = prNumbersOf(session)
+  const repos = prReposOf(session)
   const wt = session?.worktree?.pr
-  // A worktree can be shared by several sessions, so its merged PR is not
-  // proof THIS one finished: a session whose last turn errored is not credited
-  // with it, and a PR the session did not record itself is labelled as the
-  // worktree's.
-  const ownMerged = Number.isInteger(wt?.number) && prs.includes(wt.number)
-  if (isMergedState(wt?.state) && (ownMerged || !session?.lastTurnErroredAt)) {
-    if (Number.isInteger(wt.number)) {
-      return { candidate: true, proposedVerdict: "done", reason: `PR ${fmtPrs([wt.number])} merged${prs.includes(wt.number) ? "" : " (worktree)"}`, prs }
-    }
-    return { candidate: true, proposedVerdict: "done", reason: prs.length > 0 ? `PR ${fmtPrs(prs)} merged` : "PR merged", prs }
+  if (isMergedState(wt?.state) && Number.isInteger(wt?.number) && prs.includes(wt.number)) {
+    return { candidate: true, proposedVerdict: "done", reason: `PR ${fmtPr(wt.number, repos[wt.number])} merged`, prs, repos }
   }
   if (prs.length > 0) {
-    return { candidate: true, proposedVerdict: "done", reason: `PR${prs.length > 1 ? "s" : ""} ${fmtPrs(prs)} opened`, prs }
+    return { candidate: true, proposedVerdict: UNKNOWN_VERDICT, reason: `PR${prs.length > 1 ? "s" : ""} ${fmtPrs(prs, repos)} recorded, state unknown`, prs, repos }
   }
-  return { candidate: true, proposedVerdict: UNKNOWN_VERDICT, reason: "terminal, no PR recorded — outcome unknown", prs }
+  return { candidate: true, proposedVerdict: UNKNOWN_VERDICT, reason: "terminal, no PR recorded — outcome unknown", prs, repos }
 }
 
 /**
- * Sharpen one relabel proposal with its `session_evidence` answer: a merged
- * PR / merged worktree (`pullRequests.merged`, `worktree.pr.state`) →
- * `done` with `PR #N merged`; an open or recorded PR the list row did not
- * carry → `done`. Anything else leaves the proposal untouched.
+ * Sharpen one relabel proposal with its `session_evidence` answer.
+ *  - the worktree PR is merged AND the session recorded it → `done`;
+ *  - merged but NOT recorded by this session (a shared worktree) → `unknown`;
+ *  - open and the session's own → `needs-follow-up` (awaiting review/merge);
+ *    open and not its own → `unknown`;
+ *  - no PR: `abandoned` only on positive evidence (errored / never ran).
+ * Whatever lands on `done` then goes through the remaining-work check on the
+ * last assistant turn: a question or announced next step → `needs-follow-up`.
  */
 export function refineRelabel(item, evidence) {
   if (!evidence) return item
   const wt = evidence.worktree?.pr
-  const state = wt?.state ?? evidence.pullRequests?.state ?? null
+  const state = wt?.state ?? null
   const known = Array.isArray(item?.prs) ? item.prs : []
-  // `pullRequests.merged` and `worktree.pr` describe the whole worktree, which
-  // sibling sessions share: a session that recorded no PR of its own and whose
-  // last turn errored is not credited with a sibling's merge.
-  const ownPr = known.length > 0 || (evidence.pullRequests?.opened ?? 0) > 0
-  const errored = typeof evidence.lastTurnError === "string" && evidence.lastTurnError.trim() !== ""
-  const credited = ownPr || !errored
-  const merged = credited && (isMergedState(state) || (evidence.pullRequests?.merged ?? 0) > 0)
-  if (merged) {
-    const n = Number.isInteger(wt?.number) ? wt.number : known.length === 1 ? known[0] : undefined
-    const others = known.filter(k => k !== n)
-    // A PR number the session did not record itself is the worktree's.
-    const shared = n !== undefined && !known.includes(n) ? " (worktree)" : ""
-    const reason = (n !== undefined ? `PR #${n} merged${shared}` : "PR merged") + (others.length > 0 && n !== undefined ? `; also opened ${fmtPrs(others)}` : "")
-    return { ...item, proposedVerdict: "done", reason }
-  }
-  if (item?.proposedVerdict === "done") return item
-  if (credited && (state === "open" || state === "OPEN")) {
-    return { ...item, proposedVerdict: "done", reason: Number.isInteger(wt?.number) ? `PR #${wt.number} open` : "PR open" }
-  }
-  const opened = evidence.pullRequests?.opened ?? 0
-  if (opened > 0) return { ...item, proposedVerdict: "done", reason: `${opened} PR${opened > 1 ? "s" : ""} opened` }
-  // No PR: `abandoned` needs positive evidence the session did not finish.
-  if (item?.proposedVerdict === UNKNOWN_VERDICT) {
+  const n = Number.isInteger(wt?.number) ? wt.number : undefined
+  const repos = { ...(item?.repos ?? {}) }
+  const wtRepo = repoOfPrUrl(wt?.url)
+  if (n !== undefined && wtRepo) repos[n] = wtRepo
+  const label = n !== undefined ? fmtPr(n, repos[n]) : "PR"
+  const own = n !== undefined && known.includes(n)
+  let next = item
+  if (isMergedState(state) && n !== undefined) {
+    next = own
+      ? { ...item, proposedVerdict: "done", reason: `PR ${label} merged` }
+      : { ...item, proposedVerdict: UNKNOWN_VERDICT, reason: `worktree PR ${label} merged, not recorded by this session (shared worktree)` }
+  } else if (isOpenState(state) && n !== undefined) {
+    next = own
+      ? { ...item, proposedVerdict: FOLLOW_UP_VERDICT, reason: `PR ${label} open — awaiting review/merge` }
+      : { ...item, proposedVerdict: UNKNOWN_VERDICT, reason: `worktree PR ${label} open, not recorded by this session` }
+  } else if ((evidence.pullRequests?.opened ?? 0) > 0) {
+    const opened = evidence.pullRequests.opened
+    next = { ...item, proposedVerdict: UNKNOWN_VERDICT, reason: `${opened} PR${opened > 1 ? "s" : ""} opened, state unknown` }
+  } else if (item?.proposedVerdict === UNKNOWN_VERDICT) {
     if (typeof evidence.lastTurnError === "string" && evidence.lastTurnError.trim()) {
-      return { ...item, proposedVerdict: "abandoned", reason: `no PR, last turn errored: ${evidence.lastTurnError.trim().slice(0, 80)}` }
+      next = { ...item, proposedVerdict: "abandoned", reason: `no PR, last turn errored: ${evidence.lastTurnError.trim().slice(0, 80)}` }
+    } else if (evidence.turnsCompleted === 0) {
+      next = { ...item, proposedVerdict: "abandoned", reason: "no PR, no turn ever completed" }
+    }
+  }
+  if (Object.keys(repos).length > 0) next = { ...next, repos }
+  if (next.proposedVerdict === "done") {
+    const turns = Array.isArray(evidence.turns) ? evidence.turns : []
+    const lastAssistant = [...turns].reverse().find(t => t?.role === "assistant")
+    const pending = remainingWork({ lastAssistantText: lastAssistant?.text })
+    if (pending.length > 0) {
+      return { ...next, proposedVerdict: FOLLOW_UP_VERDICT, reason: `${next.reason}; remaining work: ${pending.join(", ")}` }
     }
-    if (evidence.turnsCompleted === 0) return { ...item, proposedVerdict: "abandoned", reason: "no PR, no turn ever completed" }
   }
-  return item
+  return next
+}
+
+// ── remaining-work detection (G11) ───────────────────────────────────────
+//
+// A PR, a merged worktree or an ended parent says the work MOVED ON, never
+// that THIS session finished: a child whose last message asks something or
+// announces a next step has an orphaned obligation once its parent is gone.
+// Closing it silently drops that. These checks therefore turn a would-be
+// close / `done` into a FLAG; they are conservative on purpose (a false
+// positive costs one flag, a false negative drops a question).
+
+/** A `?` that ends a sentence, a quote or a bracket — not a URL query (`?a=1`). */
+const QUESTION_MARK = /\?(?=\s|$|["'»”’)\]*_`])/
+/** How far back from the end of the message a `?` still counts as "the
+ *  question this session left open". */
+const QUESTION_WINDOW_CHARS = 240
+
+/** Deferred-work phrasing, EN + FR. `kind` names the signal in the flag note. */
+const PENDING_PATTERNS = [
+  { kind: "open question", re: /\b(open\s+question|unanswered|question\s+ouverte|sans\s+réponse|j'?ai\s+posé\s+la\s+question|the\s+question\s+i\s+(?:put|sent|asked))\b/i },
+  { kind: "asks the user", re: /\b(should\s+i|should\s+we|shall\s+i|shall\s+we|do\s+you\s+want|would\s+you\s+like|dois-je|faut-il|je\s+corrige|voulez-vous|veux-tu)\b/i },
+  { kind: "waiting", re: /\b(waiting\s+(?:for|on)|i'?ll\s+report|i\s+will\s+report|en\s+attente|j'?attends|dans\s+l'?attente)\b/i },
+  { kind: "next step", re: /\b(next\s+steps?|to\s+do\s+next|follow[- ]?ups?|todo|à\s+faire|reste\s+à|prochaines?\s+étapes?|il\s+faudrait|avant\s+le\s+prochain|(?:i|we)\s+(?:still\s+)?(?:need|have)\s+to)\b|\breste\s*:/i },
+  { kind: "recommendation", re: /\b(recommandation|je\s+recommande|i\s+recommend|i'?d\s+recommend|recommendation)\b/i },
+]
+/** "nothing left to do", "rien à faire", "no follow-up" — a negation right
+ *  before a marker makes it a clean sign-off, not a pending item. */
+const NEGATION_BEFORE = /\b(nothing|no|none|rien|aucune?|n'?ai\s+rien|ne\s+reste\s+rien|no\s+further|no\s+more)\b[^.!?]{0,30}$/i
+
+/** The last sentence announces an action rather than reporting a result
+ *  ("Now drive it with the built CLI.") — the transcript stops mid-work.
+ *  A sentence that also states an outcome ("Now it works.") does not count. */
+const ANNOUNCES_NEXT = /^(?:now|next|then|ensuite|maintenant|puis|let\s+me(?!\s+know)|let'?s|i'?ll|i\s+will|je\s+vais|on\s+va)\b/i
+const STATES_OUTCOME = /\b(is|are|was|were|works?|passes?|passed|green|done|merged|fixed|complete[d]?|ready|ok|terminé|fini|fonctionne)\b/i
+
+function announcesNextAction(flat) {
+  const sentences = flat.split(/(?<=[.!?])\s+/).filter(Boolean)
+  const last = sentences.at(-1)?.trim()
+  return !!last && last.length <= 160 && ANNOUNCES_NEXT.test(last) && !STATES_OUTCOME.test(last)
+}
+
+/**
+ * Why a session's LAST assistant message still owes something, or `null`
+ * when it reads as a clean final report. Reasons: `question to the user`,
+ * `announced next action`, `open question`, `asks the user`, `waiting`, `next step`,
+ * `recommendation`.
+ * The tail the plan carries is ~600 chars, whitespace-flattened.
+ */
+export function pendingWorkReason(text) {
+  if (typeof text !== "string" || text.trim().length === 0) return null
+  const flat = text.replace(/\s+/g, " ").trim()
+  const recent = flat.slice(-QUESTION_WINDOW_CHARS)
+  if (QUESTION_MARK.test(recent)) return "question to the user"
+  if (announcesNextAction(flat)) return "announced next action"
+  for (const { kind, re } of PENDING_PATTERNS) {
+    const m = re.exec(flat)
+    if (!m) continue
+    if (NEGATION_BEFORE.test(flat.slice(Math.max(0, m.index - 40), m.index))) continue
+    return kind
+  }
+  return null
+}
+
+/** Boolean form of {@link pendingWorkReason}. */
+export const hasPendingWork = text => pendingWorkReason(text) !== null
+
+/** PR states that mean "still waiting on someone" (not merged, not closed). */
+const isOpenPrState = state => state === "open" || state === "OPEN"
+
+/**
+ * The remaining-work check for one session: reasons it must NOT be closed
+ * or labelled `done`. Inputs are whatever the caller has — the last
+ * assistant text and/or the worktree's PR state; missing inputs add no
+ * reason. An empty list means nothing pending was found.
+ */
+export function remainingWork({ lastAssistantText, prState } = {}) {
+  const reasons = []
+  const pending = pendingWorkReason(lastAssistantText)
+  if (pending) reasons.push(pending)
+  if (isOpenPrState(prState)) reasons.push("open PR awaiting review/merge")
+  return reasons
 }
 
 // ── self-exclusion (mission item 7) ──────────────────────────────────────
@@ -577,15 +708,26 @@ export function saturationHeader(hostLoad) {
  * Why there is nothing to do, stated explicitly instead of an empty report:
  * how many live sessions were seen, how many were busy, how many were
  * terminal (and whether any still need a relabel), and how many were
- * excluded (self / same cron job / pinned / pty / keepAlive).
+ * excluded — with a per-reason breakdown (`counts.excludedByReason`) so the
+ * report says exactly WHY (G6), e.g. `6 excluded (2 same_cron_job_as_caller,
+ * 3 pty, 1 archived)`.
  */
 export function explainZeroCandidates(counts = {}) {
   const n = (v) => (typeof v === "number" ? v : 0)
+  const byReason = counts.excludedByReason
+  let excluded = `${n(counts.excluded)} excluded`
+  const breakdown = []
+  if (byReason && typeof byReason === "object") {
+    for (const [reason, count] of Object.entries(byReason)) {
+      if (count > 0) breakdown.push(`${count} ${reason}`)
+    }
+  }
+  if (breakdown.length > 0) excluded += ` (${breakdown.join(", ")})`
   return (
     `0 candidates: ${n(counts.live)} live (` +
     `${n(counts.busy)} busy, ${n(counts.idle)} idle), ` +
     `${n(counts.terminal)} terminal (${n(counts.terminalRelabel)} need a relabel), ` +
-    `${n(counts.excluded)} excluded (self/cron/pinned/pty/keepAlive)`
+    excluded
   )
 }
 

package/session-steward/.agentproto/workflows/session-steward/entry.mjs

@@ -49,6 +49,7 @@ import {
   saturationHeader,
   shouldRejudge,
   refineRelabel,
+  remainingWork,
   terminalRelabelCandidate,
   verdictMemoryEvent,
   NUDGE_CONTINUE,
@@ -139,11 +140,28 @@ function policyOf(settings) {
   return { userOrigins: settings?.userOrigins, closableOrigins: settings?.closableOrigins }
 }
 
+/** Why a would-be close must not happen: the remaining-work check over a plan
+ *  entry — its last assistant message (`signals.lastAssistantTail`) and its
+ *  worktree's PR still open (`signals.worktreePrOpen`). A merged worktree or an
+ *  ended parent only says the work moved on, never that THIS session finished
+ *  (G11: 7 children of an ended parent were closed `done` while their last
+ *  message asked the parent a question that nobody can answer any more). */
+export function remainingWorkOf(entry) {
+  return remainingWork({
+    lastAssistantText: entry?.signals?.lastAssistantTail,
+    prState: entry?.signals?.worktreePrOpen === true ? "open" : undefined,
+  })
+}
+
 /** `decideAction` over one candidate entry, with the run's policy folded in.
  *  Used by both the apply-queue builders and the report, so the action shown
- *  and the action executed can never drift. */
-export function decideFor(entry, planClass, verdict, confidence, settings) {
-  return decideAction({
+ *  and the action executed can never drift. A rule or judged `close` whose
+ *  session still has remaining work becomes a `flag` (`remaining` lists why):
+ *  the operator sees the question instead of the session being closed. A
+ *  `stuck` session never ran, so it has nothing to owe; a session that itself
+ *  declared `STEWARD: DONE` (`opts.declared`) answered the question. */
+export function decideFor(entry, planClass, verdict, confidence, settings, opts = {}) {
+  const d = decideAction({
     session: entry,
     planClass,
     verdict,
@@ -152,6 +170,19 @@ export function decideFor(entry, planClass, verdict, confidence, settings) {
     policy: policyOf(settings),
     minConfidence: settings?.minConfidence,
   })
+  if (d.action !== "close" || planClass === "stuck" || opts.declared === true) return d
+  const remaining = remainingWorkOf(entry)
+  if (remaining.length === 0) return d
+  const reason = `flag (remaining work: ${remaining.join(", ")})`
+  return { action: "flag", reason: settings?.apply === true ? reason : `${reason} (dry run)`, remaining }
+}
+
+/** The flag note for a decision that downgraded a close: the reason plus the
+ *  session's own last words, so the operator sees the question it left open. */
+function flagNote(entry, d, extra) {
+  const tail = typeof entry?.signals?.lastAssistantTail === "string" ? entry.signals.lastAssistantTail.trim().slice(-300) : ""
+  const quoted = d.remaining && tail ? ` — last message: «${tail}»` : ""
+  return `${d.reason}${extra ? ` — ${extra}` : ""}${quoted}`
 }
 
 // ── plan → candidates ────────────────────────────────────────────────────
@@ -190,7 +221,7 @@ export function buildRuleApplyQueue(candidates, settings) {
       queue.push({
         sessionId: e.sessionId,
         verdict: d.action === "close" ? closeVerdict : "needs-input",
-        note: d.action === "close" ? closeNote(e) : d.reason,
+        note: d.action === "close" ? closeNote(e) : flagNote(e, d),
       })
     }
   }
@@ -528,14 +559,14 @@ export function buildJudgedApplyQueue(finalVerdicts, settings) {
   const queue = []
   for (const r of finalVerdicts ?? []) {
     if (r.malformed) continue
-    const d = decideFor(r.entry, "judge", r.verdict, r.confidence, settings)
+    const d = decideFor(r.entry, "judge", r.verdict, r.confidence, settings, { declared: r.source === "declared" })
     if (d.action === "skip") continue
     const isFlagVerdict = r.verdict === "blocked" || r.verdict === "needs-input"
     queue.push({
       sessionId: r.entry.sessionId,
       verdict: d.action === "close" ? r.verdict : isFlagVerdict ? r.verdict : "needs-input",
       judgedBy: r.source === "declared" ? `steward-ask:${r.entry.sessionId}` : r.judgedBy ?? r.judgeSessionId ?? "steward-judge",
-      note: d.action === "close" ? r.reason : `${d.reason}${r.reason ? ` — ${r.reason}` : ""}`,
+      note: d.action === "close" ? r.reason : flagNote(r.entry, d, r.reason),
     })
   }
   return queue
@@ -614,8 +645,10 @@ export function buildReport(b) {
       `| ${cls} | ${cell(e.label ?? e.sessionId)} | ${cell(originCell(e, s))} | ${e.idleMinutes ?? "?"} min | ${fmtMB(e.rssBytes)} | ` +
         `${cell(verdict)} | ${conf === undefined ? "—" : conf.toFixed(2)} | ${cell(reason)} | ${cell(action)} |`,
     )
+  let withRemainingWork = 0
   for (const e of c.close) {
     const d = decideFor(e, "close", "done", 1, s)
+    if (d.remaining) withRemainingWork++
     row("close", e, "done (rules)", undefined, (e.reasons ?? []).join("; "), actionCell(e.sessionId, d, applied))
   }
   for (const e of c.stuck) {
@@ -623,7 +656,8 @@ export function buildReport(b) {
     row("stuck", e, "abandoned (rules)", undefined, (e.reasons ?? []).join("; ") || "stuck starting, never ran", actionCell(e.sessionId, d, applied))
   }
   for (const r of verdicts) {
-    const d = decideFor(r.entry, "judge", r.verdict, r.confidence, s)
+    const d = decideFor(r.entry, "judge", r.verdict, r.confidence, s, { declared: r.source === "declared" })
+    if (d.remaining) withRemainingWork++
     const by = r.source === "declared" ? " (declared)" : r.source === "jev" ? " (jev)" : r.source === "judged" ? " (agent)" : ""
     const reason = r.jevFallback ? `${r.reason} [jev failed: ${r.jevFallback} → agent judge]` : r.reason
     row("judge", r.entry, `${r.verdict}${by}`, r.confidence, reason, actionCell(r.entry.sessionId, d, applied))
@@ -645,6 +679,7 @@ export function buildReport(b) {
     `- candidates: close=${c.close.length} stuck=${c.stuck.length} judge=${verdicts.length}` +
       (c.judgeOverflow?.length ? ` (+${c.judgeOverflow.length} not judged)` : ""),
   )
+  if (withRemainingWork > 0) lines.push(`- ${withRemainingWork} would-be close(s) downgraded to a flag: the session still has remaining work (open question, announced next step, open PR)`)
   if (verdicts.length > 0) lines.push(`- verdicts: ${Object.entries(counts).map(([k, n]) => `${k}=${n}`).join(" ")}`)
   const bySource = { jev: 0, agent: 0 }
   let fallbacks = 0
@@ -781,7 +816,7 @@ export function scanLive(liveSessions, settings, nowMs) {
         const endedAt = s.endedAt ?? s.lastActivityAt ?? s.startedAt
         const endedMs = endedAt ? Date.parse(endedAt) : Number.NaN
         if (Number.isFinite(endedMs) && nowMs - endedMs <= relabelWindowMs) {
-          terminalRelabel.push({ sessionId: id, origin: s.origin, originClass, label, proposedVerdict: cand.proposedVerdict, reason: cand.reason, prs: cand.prs ?? [], endedAt, endedMs })
+          terminalRelabel.push({ sessionId: id, origin: s.origin, originClass, label, proposedVerdict: cand.proposedVerdict, reason: cand.reason, prs: cand.prs ?? [], repos: cand.repos ?? {}, endedAt, endedMs })
         }
       }
       continue
@@ -811,6 +846,10 @@ export function scanLive(liveSessions, settings, nowMs) {
     relabelTotal,
     neverRan: neverRan.length,
     excluded: excluded.length,
+    excludedByReason: excluded.reduce((acc, e) => {
+      acc[e.reason] = (acc[e.reason] ?? 0) + 1
+      return acc
+    }, {}),
   }
   return { busy, idle, terminal, terminalRelabel, neverRan, excluded, loopQueue, stallInputs, counts }
 }

package/session-steward/README.md

@@ -67,6 +67,25 @@ the `userOrigins` / `closableOrigins` inputs:
 A trailing `*` in either list is a prefix wildcard. The report carries the
 origin column and the retained action in dry run as well as apply.
 
+## Remaining work (never close a session that still owes something)
+
+A merged worktree, an open or merged PR, or an ended parent says the work
+moved on — not that *this* session finished. Before any rule or judged
+`close`, `decideFor` (`entry.mjs`) runs `remainingWork`
+(`cron-rules.mjs`) over the plan entry's `lastAssistantTail` and
+`worktreePrOpen` signals. A last message that asks a question, proposes a
+next step, announces its next action ("Now drive it…"), recommends something, or waits on someone — or a still-open
+worktree PR — turns the close into a `needs-input` flag whose note quotes the
+session's own last words (`flag (remaining work: …)`). Only a clean final
+report closes. Exceptions: a `stuck` session (it never ran) and a session that
+itself declared `STEWARD: DONE`. Not covered yet: red CI and unanswered review
+comments (the daemon exposes neither).
+
+The terminal-session relabel (report only) follows the same principle: `done`
+only when the session's *own* recorded PR is merged and nothing is pending; an
+open PR or pending work is `needs-follow-up`; a worktree PR the session never
+recorded (shared worktree) credits nobody. PRs are reported as `owner/repo#N`.
+
 ## Running it
 
 ```bash