@agentproto/apps 0.20.1 → 0.20.3

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

@@ -64,7 +64,7 @@ export function isUsefulLoopCommand(signature) {
 }
 
 const READ_TOOLS = new Set(["read", "cat", "rg", "grep", "sed", "head", "tail", "less", "view", "readfile"])
-const READ_COMMAND = /\b(cat|rg|grep|sed|head|tail|less|view)\b/
+const READ_VERB_WORD = /^["']?(cat|rg|grep|sed|head|tail|less|view)["']?$/
 
 /**
  * The file a read-like call targeted, or `null`. Best-effort: an in-agent
@@ -76,15 +76,26 @@ export function readTargetOf(record) {
   const tool = String(record?.tool ?? "").toLowerCase()
   const command = str(record?.command)
   const args = Array.isArray(record?.args) ? record.args.map(String) : []
-  const isRead = READ_TOOLS.has(tool) || (command !== undefined && READ_COMMAND.test(command))
-  if (!isRead) return null
-  const tokens = command !== undefined ? command.split(/\s+/) : args
-  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
+  const readTool = READ_TOOLS.has(tool)
+  if (!readTool && command === undefined) return null
+  // A shell line is several commands: only a segment that STARTS with a read
+  // verb reads a file. `cd <dir> &&`, `git log | head` and `--grep=…` do not.
+  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
+    if (seg !== undefined) {
+      const first = tokens.findIndex((t) => !t.includes("=") || t.startsWith("-"))
+      if (first < 0 || !READ_VERB_WORD.test(tokens[first])) continue
+      tokens = tokens.slice(first + 1)
+    }
+    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 (seg === undefined) return args[0] ?? null
   }
-  return args[0] ?? null
+  return null
 }
 
 function topEntry(counts) {
@@ -115,7 +126,11 @@ export function detectLoop(records, opts = {}) {
     const ts = Date.parse(r?.ts)
     return Number.isFinite(ts) && ts <= nowMs + 1000 && nowMs - ts <= windowMs
   })
-  const calls = inWindow.filter((r) => !isUsefulLoopCommand(callSignature(r)))
+  // A record with no command and no args (an in-agent `read`/`edit` call) has
+  // nothing but its tool name to compare, so three of them in ten minutes is
+  // normal work, not a loop — leave it out of every repetition signal.
+  const informative = inWindow.filter((r) => str(r?.command) !== undefined || (Array.isArray(r?.args) && r.args.length > 0))
+  const calls = informative.filter((r) => !isUsefulLoopCommand(callSignature(r)))
   const counts = new Map()
   const reads = new Map()
   for (const r of calls) {
@@ -146,7 +161,8 @@ export function detectLoop(records, opts = {}) {
       ratio: Math.round(ratio * 100) / 100,
       maxVerbatim,
       maxReads,
-      usefulExcluded: inWindow.length - total,
+      usefulExcluded: informative.length - total,
+      anonymousExcluded: inWindow.length - informative.length,
       topCommand: top ? top.key : null,
       topCommandCount: top ? top.count : 0,
     },
@@ -262,22 +278,100 @@ export function detectFastPathDone(input = {}) {
 
 const TERMINAL_STATUSES = new Set(["killed", "exited", "error", "stopped", "completed", "failed"])
 
+/** PR numbers a `session_list` row records: `openedPrs[].number` plus the
+ *  `outcome.artifacts` `pr` entries (`#N` title or a `…/pull/N` ref). Sorted,
+ *  de-duplicated. */
+export function prNumbersOf(session) {
+  const nums = new Set()
+  for (const pr of Array.isArray(session?.openedPrs) ? session.openedPrs : []) {
+    if (Number.isInteger(pr?.number)) nums.add(pr.number)
+  }
+  for (const a of Array.isArray(session?.outcome?.artifacts) ? session.outcome.artifacts : []) {
+    if (a?.type !== "pr") continue
+    const m = /#(\d+)$/.exec(String(a.title ?? "")) ?? /\/pull\/(\d+)/.exec(String(a.ref ?? ""))
+    if (m) nums.add(Number(m[1]))
+  }
+  return [...nums].sort((a, b) => a - b)
+}
+
+/** Relabel verdict for "no positive evidence either way". */
+export const UNKNOWN_VERDICT = "unknown"
+
+const fmtPrs = nums => nums.map(n => `#${n}`).join(", ")
+const isMergedState = state => state === "merged" || state === "MERGED"
+
 /**
  * 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 worktree/PR proves the work
- * merged, else `abandoned` (the ambiguous ones still go to a judge).
+ * 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`).
  */
 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 prState = session?.worktree?.pr?.state
-  const merged = prState === "merged" || prState === "MERGED"
-  const outcomePrs = Array.isArray(session?.outcome?.pullRequests) ? session.outcome.pullRequests : []
-  const mergedPr = merged || outcomePrs.some((p) => p?.state === "MERGED" || p?.state === "merged")
-  if (mergedPr) return { candidate: true, proposedVerdict: "done", reason: "terminal, PR merged, no outcome recorded" }
-  return { candidate: true, proposedVerdict: "abandoned", reason: "terminal, no outcome recorded" }
+  const prs = prNumbersOf(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 (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: "terminal, no PR recorded — outcome unknown", prs }
+}
+
+/**
+ * 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.
+ */
+export function refineRelabel(item, evidence) {
+  if (!evidence) return item
+  const wt = evidence.worktree?.pr
+  const state = wt?.state ?? evidence.pullRequests?.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) {
+    if (typeof evidence.lastTurnError === "string" && evidence.lastTurnError.trim()) {
+      return { ...item, proposedVerdict: "abandoned", reason: `no PR, last turn errored: ${evidence.lastTurnError.trim().slice(0, 80)}` }
+    }
+    if (evidence.turnsCompleted === 0) return { ...item, proposedVerdict: "abandoned", reason: "no PR, no turn ever completed" }
+  }
+  return item
 }
 
 // ── self-exclusion (mission item 7) ──────────────────────────────────────

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

@@ -12,9 +12,10 @@
 // RE-CLASSIFIES each id itself immediately before acting and refuses
 // `keep`-class ids outright. On top of that, this workflow:
 //   - mutates no SESSION unless `apply` is true (every session-mutating map
-//     runs over an empty list otherwise). The one dry-run write is the
-//     append-only verdict-memory ledger (`app_state_append`) — never a
-//     session, and disableable with `appId: ""`;
+//     runs over an empty list otherwise). A dry run writes nothing at all:
+//     the append-only verdict-memory ledger (`app_state_append`) is read but
+//     only appended to when `apply` is true, so a dry run's verdicts can
+//     never be served as cached verdicts to a later real pass;
 //   - only ever feeds `close`/`stuck` ids to the rules pass — a `keepAlive`
 //     session can only ever be `judge` class, so rules never close it;
 //   - drops the caller's own session from every candidate list;
@@ -47,6 +48,7 @@ import {
   isSelfExcluded,
   saturationHeader,
   shouldRejudge,
+  refineRelabel,
   terminalRelabelCandidate,
   verdictMemoryEvent,
   NUDGE_CONTINUE,
@@ -641,7 +643,7 @@ export function buildReport(b) {
   }
 
   // Terminal sessions with no outcome (mission item 5).
-  const relabel = b.steps.relabelQueue ?? []
+  const relabel = b.steps.relabelFinal ?? b.steps.relabelQueue ?? []
   if (relabel.length > 0) {
     const total = b.steps.scan?.counts?.relabelTotal ?? relabel.length
     const byVerdict = new Map()
@@ -649,6 +651,7 @@ export function buildReport(b) {
     const perLabel = [...byVerdict].map(([v, n]) => `${v}: ${n}`).join(", ")
     lines.push("", "## Terminal sessions missing an outcome (relabel candidates)")
     lines.push(`- ${relabel.length} ended in the last ${s.relabelWindowHours}h (${total} without an outcome in all) — ${perLabel}`)
+    lines.push(`- evidence: PR numbers come from the session record; worktree/PR state was looked up for the newest ${RELABEL_MAX_LINES} only`)
     for (const r of relabel.slice(0, RELABEL_MAX_LINES)) lines.push(`- ${r.sessionId} → ${r.proposedVerdict} — ${r.reason}`)
     const hidden = total - Math.min(relabel.length, RELABEL_MAX_LINES)
     if (hidden > 0) lines.push(`- … and ${hidden} more (older/omitted)`)
@@ -662,6 +665,9 @@ export function buildReport(b) {
   } else if (memory instanceof Map && memory.size > 0) {
     lines.push(`- verdict memory: ${memory.size} session(s) known` + (cachedCount > 0 ? `, ${cachedCount} served from cache` : ""))
   }
+  if (!s.apply && b.steps.memoryApp?.appId) {
+    lines.push("- verdict memory was read but not written (dry run)")
+  }
 
   return lines.join("\n")
 }
@@ -743,7 +749,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, endedAt, endedMs })
+          terminalRelabel.push({ sessionId: id, origin: s.origin, originClass, label, proposedVerdict: cand.proposedVerdict, reason: cand.reason, prs: cand.prs ?? [], endedAt, endedMs })
         }
       }
       continue
@@ -802,6 +808,24 @@ export function mergeNeverRan(candidates, scan) {
   }
 }
 
+/** A rule-certain `close` whose session's last turn errored did not finish —
+ *  parentEnded / merged-worktree only says the parent moved on. Closing it
+ *  would record `done` on a failed run, so demote it to the judge list. */
+export function demoteErroredCloses(candidates, scan) {
+  const errored = new Set((scan?.idle ?? []).filter(r => r?.lastTurnErroredAt).map(r => r.sessionId))
+  const close = candidates?.close ?? []
+  const demoted = close.filter(e => errored.has(e.sessionId))
+  if (demoted.length === 0) return candidates
+  return {
+    ...candidates,
+    close: close.filter(e => !errored.has(e.sessionId)),
+    judge: [
+      ...(candidates?.judge ?? []),
+      ...demoted.map(e => ({ ...e, class: "judge", reasons: [...(e.reasons ?? []), "last turn errored — not auto-closed"] })),
+    ],
+  }
+}
+
 /** `tool_calls_list` map item → the loop verdict + stats for one session. */
 export function analyzeLoopItem(b) {
   const item = b.item ?? {}
@@ -898,10 +922,35 @@ export function buildRelabelQueue(scan) {
   return (scan?.terminalRelabel ?? []).map(t => ({ ...t })).sort((a, b) => b.endedMs - a.endedMs)
 }
 
-/** The `app_state` events to append for this pass's verdicts. The memory is
- *  written on every pass (it is a ledger, never a session action) so streaks
- *  accumulate and the cache can engage. */
+/** The sessions that get a per-session `session_evidence` lookup: only the
+ *  newest {@link RELABEL_MAX_LINES} of the (already windowed) relabel queue —
+ *  the ones the report lists — never every terminal session. */
+export function buildRelabelEvidenceQueue(relabelQueue) {
+  return (relabelQueue ?? []).slice(0, RELABEL_MAX_LINES).map(r => ({ sessionId: r.sessionId }))
+}
+
+/** One relabel evidence map item: the `session_evidence` answer, id-checked. */
+function foldRelabelEvidence(b) {
+  const raw = b.steps.relabelEvidenceOne
+  if (!raw || raw.sessionId !== b.item?.sessionId) {
+    throw new Error(`session_evidence answered for '${raw?.sessionId}', expected '${b.item?.sessionId}'`)
+  }
+  return { sessionId: b.item.sessionId, evidence: raw }
+}
+
+/** Relabel proposals sharpened by the evidence lookups (a failed lookup
+ *  leaves its proposal as the list row had it). Order is preserved. */
+export function applyRelabelEvidence(relabelQueue, evidenceResult) {
+  const bySession = new Map(settled(evidenceResult).ok.map(r => [r.value?.sessionId, r.value?.evidence]))
+  return (relabelQueue ?? []).map(r => (bySession.has(r.sessionId) ? refineRelabel(r, bySession.get(r.sessionId)) : r))
+}
+
+/** The `app_state` events to append for this pass's verdicts. Written only on
+ *  an `apply` pass (so streaks accumulate and the cache can engage); a dry run
+ *  reads memory but never writes it, or its verdicts would be reused by the
+ *  next real pass instead of being re-judged. */
 export function buildMemoryWriteQueue(finalVerdicts, settings) {
+  if (!settings?.apply) return []
   if (!settings?.appId) return []
   const out = []
   for (const r of finalVerdicts ?? []) {
@@ -975,7 +1024,7 @@ export default {
     { id: "liveSessions", kind: "tool", tool: "session_list", inputs: { full: true } },
     { id: "scan", kind: "transform", compute: b => scanLive(b.steps.liveSessions, b.steps.settings, Date.now()) },
     // Never-ran 0/0 sessions are `stuck` immediately, never judged (item 3).
-    { id: "candidatesPlus", kind: "transform", compute: b => mergeNeverRan(b.steps.candidates, b.steps.scan) },
+    { id: "candidatesPlus", kind: "transform", compute: b => demoteErroredCloses(mergeNeverRan(b.steps.candidates, b.steps.scan), b.steps.scan) },
     { id: "ruleApplyQueue", kind: "transform", compute: b => buildRuleApplyQueue(b.steps.candidatesPlus, b.steps.settings) },
     {
       // Empty unless `apply` — a dry run dispatches no apply call at all.
@@ -1031,6 +1080,19 @@ export default {
     // continue, at most one per session per pass, user origins observed only.
     { id: "proposals", kind: "transform", compute: b => buildProposalsStep(b.steps.scan, b.steps.loopResults, b.steps.settings, Date.now()) },
     { id: "relabelQueue", kind: "transform", compute: b => buildRelabelQueue(b.steps.scan) },
+    { id: "relabelEvidenceQueue", kind: "transform", compute: b => buildRelabelEvidenceQueue(b.steps.relabelQueue) },
+    {
+      id: "relabelEvidence",
+      kind: "map",
+      over: "$steps.relabelEvidenceQueue",
+      parallelism: 4,
+      onError: "collect",
+      steps: [
+        { id: "relabelEvidenceOne", kind: "tool", tool: "session_evidence", inputs: { sessionId: "$item.sessionId" } },
+        { id: "relabelEvidenceFold", kind: "transform", compute: foldRelabelEvidence },
+      ],
+    },
+    { id: "relabelFinal", kind: "transform", compute: b => applyRelabelEvidence(b.steps.relabelQueue, b.steps.relabelEvidence) },
     {
       id: "evidence",
       kind: "map",
@@ -1172,7 +1234,8 @@ export default {
       ],
     },
     // Verdict memory write-back (item 10) — a ledger append, never a session
-    // action; best-effort (an uninstalled app just yields no memory).
+    // action; empty unless `apply`; best-effort (an uninstalled app just
+    // yields no memory).
     { id: "memoryWriteQueue", kind: "transform", compute: b => buildMemoryWriteQueue(b.steps.finalVerdicts, { ...b.steps.settings, appId: b.steps.memoryApp?.appId ?? "" }) },
     {
       id: "memoryWrite",
@@ -1194,7 +1257,7 @@ export default {
     autoApply: "$steps.autoApply",
     judgedApply: "$steps.judgedApply",
     proposals: "$steps.proposals",
-    relabel: "$steps.relabelQueue",
+    relabel: "$steps.relabelFinal",
     scan: "$steps.scan",
   },
 }