@agentproto/apps 0.21.0 → 0.21.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentproto/apps",
-  "version": "0.21.0",
+  "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",
@@ -175,7 +175,7 @@
     "zod": "^4.6.5",
     "@agentproto/agent": "0.2.5",
     "@agentproto/app-client": "0.4.1",
-    "@agentproto/app-kit": "1.7.0",
+    "@agentproto/app-kit": "1.7.2",
     "@agentproto/workflow": "0.7.1"
   },
   "peerDependencies": {

package/repo-maintenance/.agentproto/workflows/maintain/entry.mjs

@@ -168,13 +168,21 @@ export function reviewableWorktrees(worktreeGcPlanResult) {
   const entries = Array.isArray(worktreeGcPlanResult?.plan) ? worktreeGcPlanResult.plan : []
   for (const w of entries) {
     if (w?.class !== "hold" || !w.branch || !w.path) continue
-    if (w.liveness?.state !== "idle" || w.tree?.state !== "clean") continue
+    if (w.liveness?.state !== "idle" || treeState(w.tree) !== "clean") continue
     if (w.integration?.state === "open") continue
     out.set(w.path, w.branch)
   }
   return out
 }
 
+/** A worktree_gc plan entry's tree state. The daemon's `worktree_gc` tool
+ *  flattens it to the bare discriminant (`tree: "clean"`, `toGcPlanEntryView`
+ *  in packages/cli/src/commands/worktree.ts); the engine's own `GcPlanEntry`
+ *  (and `agentproto worktree gc --json`) carries `{ state, … }`. */
+function treeState(tree) {
+  return typeof tree === "string" ? tree : tree?.state
+}
+
 /** The worktree path a branch_gc entry is held by, when that hold is the only
  *  thing between it and `review`: held for `worktree`, unmerged, old enough,
  *  and the worktree is one {@link reviewableWorktrees} kept. Else null. */

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

@@ -56,6 +56,24 @@ inputs:
       Ask low-confidence idle sessions directly whether they're done. Off by
       default — it spends a turn in someone else's conversation.
     default: false
+  recurring:
+    type: boolean
+    description: >-
+      Set by scheduled runs (the hourly routine). A recurring run closes
+      sessions nobody asked about, so a keepAlive session must also have been
+      idle `keepAliveAskAfterMinutes`. Default false = an on-demand run, which
+      applies no such delay.
+    default: false
+  keepAliveAskAfterMinutes:
+    type: number
+    description: >-
+      With `askSessions`, for `recurring` runs only: a keepAlive session whose
+      worktree is merged or clean (nothing uncommitted, nothing ahead of base)
+      is asked only once idle this many minutes; 0 disables the recurring
+      keepAlive ask. On-demand runs ignore it. keepAlive only re-lights a
+      session after a daemon restart; it does not stop a declared DONE from
+      closing it.
+    default: 1440
   callerSessionId:
     type: string
     description: The calling session's id — never a candidate.
@@ -243,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
@@ -266,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
@@ -342,7 +360,10 @@ steps:
   - id: askQueue
     kind: transform
     name: Low-confidence idle sessions to ask directly
-    description: Entry-based. Empty unless `askSessions`.
+    description: >-
+      Entry-based. Empty unless `askSessions`. A keepAlive session is included
+      only with a merged/clean worktree, and on a `recurring` run only once
+      idle `keepAliveAskAfterMinutes` (default 1440, 0 = never).
 
   - id: ask
     kind: map
@@ -442,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.
@@ -488,8 +510,16 @@ as observed, never nudged.
 - `session_wrapup_apply` re-classifies each id right before acting and always
   refuses `keep`-class ids; this workflow never feeds it one.
 - Rules only ever close `close`/`stuck` ids; a `keepAlive` session is never
-  in those classes, so only a confident judge verdict (with `judgedBy`) can
-  close it — as FIX-9A allows.
+  in those classes, so only a confident judge verdict or a declared DONE (with
+  `judgedBy`) can close it — as FIX-9A allows. `keepAlive` means "re-light
+  after a daemon restart", not "never close": with `askSessions`, a keepAlive
+  session whose worktree is merged or clean (no uncommitted change, nothing
+  ahead of base; unknown worktree is not clean) is asked like any other. Closing
+  is an active act, so an on-demand run (`recurring: false`, e.g. `agentproto
+  steward --ask-sessions`) applies no idle delay to it beyond `idleMinutes`; only
+  a `recurring` run waits `keepAliveAskAfterMinutes` (default 1440 = 24 h, 0
+  disables), so nobody wakes up to find a session closed that they meant to
+  resume. A steward close is a deliberate end, so the sentinel never revives it.
 - A malformed judge reply is `active` with confidence 0 — never acted on.
 - The caller's own session (`callerSessionId`) is dropped from every list.
 - `blocked` / `needs-input` only FLAG a session; it keeps running.

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,
@@ -57,6 +58,11 @@ import {
 
 const DEFAULT_IDLE_MINUTES = 30
 const DEFAULT_MIN_CONFIDENCE = 0.8
+/** Recurring (scheduled) runs only: a keepAlive session must have been idle
+ *  this long before it may be asked, so a session its owner meant to pick up
+ *  tomorrow is not closed overnight. 0 turns the recurring keepAlive ask off.
+ *  An on-demand run (`recurring: false`) has no such delay. */
+const DEFAULT_KEEPALIVE_ASK_AFTER_MINUTES = 1440
 /** Terminal sessions older than this (hours since they ended) are not listed
  *  as relabel candidates. */
 const DEFAULT_RELABEL_WINDOW_HOURS = 24
@@ -118,6 +124,8 @@ export function resolveSettings(input, modelRoles) {
     jevModel: typeof i.jevModel === "string" && i.jevModel.trim() ? i.jevModel.trim() : DEFAULT_JEV_MODEL,
     maxJudged: Math.floor(num(i.maxJudged, DEFAULT_MAX_JUDGED)),
     askSessions: i.askSessions === true,
+    recurring: i.recurring === true,
+    keepAliveAskAfterMinutes: num(i.keepAliveAskAfterMinutes, DEFAULT_KEEPALIVE_ASK_AFTER_MINUTES, { min: 0 }),
     callerSessionId: typeof i.callerSessionId === "string" && i.callerSessionId ? i.callerSessionId : null,
     callerOrigin: typeof i.callerOrigin === "string" && i.callerOrigin ? i.callerOrigin : null,
     appId: typeof i.appId === "string" ? i.appId.trim() : DEFAULT_APP_ID,
@@ -132,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,
@@ -145,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 ────────────────────────────────────────────────────
@@ -183,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),
       })
     }
   }
@@ -427,8 +465,33 @@ export function collectVerdicts(evidenceResult, judgeQueue, jevResult, jevQueue,
 
 // ── ask (opt-in) ─────────────────────────────────────────────────────────
 
-/** Sessions to ask directly: judged below `minConfidence`, and idle, not
- *  keepAlive, not awaitingInput — only when `askSessions`. */
+/** Nothing to lose in the session's worktree: it is merged (the plan's signal
+ *  or the PR state), or it is a linked worktree with no uncommitted changes
+ *  and no commits beyond the base. No worktree info at all is unknown, not
+ *  clean — a session in a plain checkout stays out. */
+export function worktreeHasNothingToLose(evidence) {
+  if (evidence?.signals?.worktreeMerged === true) return true
+  const wt = evidence?.worktree
+  if (!wt) return false
+  if (wt.pr?.state === "merged") return true
+  return wt.dirty === false && wt.ahead === 0
+}
+
+/** keepAlive is the restart-relight flag; closing is a separate, active
+ *  decision. A keepAlive session whose worktree holds nothing to lose may be
+ *  asked. An on-demand run (a human asked for it) applies no idle delay beyond
+ *  the plan's own `idleMinutes`. A `recurring` run closes things nobody asked
+ *  about, so it also waits `keepAliveAskAfterMinutes` of idleness (0 = never). */
+export function keepAliveAskEligible(evidence, settings) {
+  if (evidence?.keepAlive !== true || !worktreeHasNothingToLose(evidence)) return false
+  if (settings.recurring !== true) return true
+  const after = settings.keepAliveAskAfterMinutes
+  return after > 0 && typeof evidence.idleMinutes === "number" && evidence.idleMinutes >= after
+}
+
+/** Sessions to ask directly: judged below `minConfidence`, not awaitingInput
+ *  or busy, and either not keepAlive or a keepAlive passing
+ *  {@link keepAliveAskEligible} — only when `askSessions`. */
 export function buildAskQueue(verdicts, settings) {
   if (!settings?.askSessions) return []
   return (verdicts ?? [])
@@ -436,7 +499,7 @@ export function buildAskQueue(verdicts, settings) {
       r =>
         r.evidence &&
         r.confidence < settings.minConfidence &&
-        r.evidence.keepAlive !== true &&
+        (r.evidence.keepAlive !== true || keepAliveAskEligible(r.evidence, settings)) &&
         r.evidence.awaitingInput !== true &&
         r.evidence.busy !== true,
     )
@@ -496,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
@@ -582,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) {
@@ -591,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))
@@ -613,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
@@ -749,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
@@ -779,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 }
 }
@@ -995,6 +1066,8 @@ export default {
     judgeModel: { type: "string", description: `Model for the agent judge. Default: the \`${ROLE_JUDGE_SESSION}\` model role (repo agentproto.json \`models\` > daemon config \`models\` > built-in).` },
     maxJudged: { type: "number", description: `Most \`judge\` sessions judged per run, most RAM first. Default ${DEFAULT_MAX_JUDGED}.`, default: DEFAULT_MAX_JUDGED },
     askSessions: { type: "boolean", description: "Ask low-confidence idle sessions directly whether they're done. Default false — it spends a turn in someone else's conversation.", default: false },
+    recurring: { type: "boolean", description: "Set by scheduled runs (the hourly routine). A recurring run closes sessions nobody asked about, so a keepAlive session must also have been idle `keepAliveAskAfterMinutes`. Default false = an on-demand run, which applies no such delay.", default: false },
+    keepAliveAskAfterMinutes: { type: "number", description: `With \`askSessions\`, for \`recurring\` runs only: a keepAlive session whose worktree is merged or clean (nothing uncommitted, nothing ahead of base) is asked only once idle this many minutes; 0 disables the recurring keepAlive ask. On-demand runs ignore it. keepAlive only re-lights a session after a daemon restart; it does not stop a declared DONE from closing it. Default ${DEFAULT_KEEPALIVE_ASK_AFTER_MINUTES}.`, default: DEFAULT_KEEPALIVE_ASK_AFTER_MINUTES },
     callerSessionId: { type: "string", description: "The calling session's id — never a candidate. The CLI passes AGENTPROTO_SESSION_ID." },
     callerOrigin: { type: "string", description: "The calling session's origin (`cron:<jobId>`) — an older run of the SAME cron job is never judged as user work." },
     appId: { type: "string", description: `Installed app whose \`app_state\` ledger holds the verdict memory. Default ${DEFAULT_APP_ID}.` },

package/session-steward/README.md

@@ -33,10 +33,18 @@ loader path can carry.
      judge session is released (killed + archived) when its item settles.
    Verdicts: `done|abandoned|blocked|needs-input|active`. A judge error never
    closes anything.
-5. `ask` (only with `askSessions`) — low-confidence, idle, non-keepAlive,
-   not-awaiting-input sessions get ONE prompt asking them to reply
+5. `ask` (only with `askSessions`) — low-confidence, idle, not-awaiting-input
+   sessions get ONE prompt asking them to reply
    `STEWARD: DONE …` / `STEWARD: NOT-DONE …`; a ~3 min bounded wait; the
-   answer becomes a `declared` verdict.
+   answer becomes a `declared` verdict. `keepAlive` only re-lights a session
+   after a daemon restart, so it does not exempt one from the ask: a keepAlive
+   session whose worktree is merged or clean (nothing uncommitted, nothing
+   ahead of base; no worktree info counts as not clean) is asked too. Closing
+   is an active act: an on-demand run (`agentproto steward --ask-sessions`)
+   adds no idle delay beyond `--idle`. Only a scheduled run (`recurring: true`,
+   as the hourly routine sets) waits `keepAliveAskAfterMinutes` (default 1440,
+   24 h; 0 turns it off), so a session you meant to resume is not closed
+   overnight.
 6. `judgedApply` (only with `apply`) — confident `done`/`abandoned` close
    (resumable, with a recorded outcome); confident `blocked`/`needs-input`
    only flag. Everything else is left alone and reported.
@@ -59,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

package/session-steward/routines/session-steward-hourly/ROUTINE.md

@@ -21,6 +21,9 @@ target:
   inputs:
     apply: true
     askSessions: false
+    # Scheduled run: if askSessions is ever turned on here, a keepAlive session
+    # is asked only after keepAliveAskAfterMinutes idle (default 1440, 0 = never).
+    recurring: true
     # Origin policy (the committed default): never close a human's session.
     # `chat-starter`/`vscode` (and any root with no origin and no parent) are
     # FLAG-ONLY; `cron:*` jobs, `gate`, `workflow` and `review` sessions, and executors (a session with