thincoder 0.12.11 → 0.12.13

package/src/acp.mjs

@@ -0,0 +1,335 @@
+/**
+ * acp.mjs — `thincoder acp` entry: expose the thincoder agent over the
+ * Agent Client Protocol (schema v1) on stdio, so ACP clients (Zed, JetBrains
+ * AI Chat, Paseo) can drive sessions directly.
+ *
+ * M1 scope (see docs/design/ACP-CLIENT.md §9):
+ *   initialize / authenticate / session/new / session/prompt / session/cancel / session/close
+ * M2: tools + request_permission + fs reverse-RPC. M3: session load/resume/list/delete + config options.
+ *
+ * Auth: reuse the terminal config (~/.thincoder/config.json) — a resolvable
+ * provider API key means "configured". No account system; `logout` is absent.
+ *
+ * `isConfigured` / `createSession` are injectable for tests.
+ */
+import { readFileSync } from "node:fs"
+import { resolve } from "node:path"
+import { loadConfig } from "./config.mjs"
+import { assembleAgent } from "./cli/make-agent.mjs"
+import { createAcpServer, ACP_ERRORS } from "./acp/transport.mjs"
+import { createAcpSession } from "./acp/session.mjs"
+import { replayHistory } from "./acp/bridge.mjs"
+import { listSlots, applySession, deleteSlot, sessionPath, normalizeCwd, isLegacyTransient } from "./session.mjs"
+
+const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version
+
+/** Load a specific slot file (not the active one) — session/load by id.
+ *  Same validation as loadSession: version 1/2, cwd match, legacy-transient
+ *  filtering (pre-filtering slot files must not leak machine lines into replay). */
+function loadSlotFile(cwd, slot) {
+  const path = `${sessionPath(cwd)}.${slot}`
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"))
+    if (data?.version !== 1 && data?.version !== 2) return null
+    if (!Array.isArray(data.history)) return null
+    if (data.cwd && normalizeCwd(data.cwd).toLowerCase() !== normalizeCwd(cwd).toLowerCase()) return null
+    data.history = data.history.filter((m) => !isLegacyTransient(m))
+    return data
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Apply a session-level config option to the agent instance (memory only —
+ * the session's own runtime state, last-write-wins; not persisted to config.json).
+ * Returns true when the configId is known.
+ */
+function applyConfigOption(agent, configId, value) {
+  switch (configId) {
+    case "model": {
+      if (typeof value !== "string" || !value.trim()) return false
+      if (!agent.provider) return false // nothing to configure
+      // Split on the FIRST colon only — model names may contain colons.
+      const ci = value.indexOf(":")
+      const provider = ci >= 0 ? value.slice(0, ci) : null
+      const model = (ci >= 0 ? value.slice(ci + 1) : value).trim()
+      if (provider && provider !== agent.provider.name) agent.provider.name = provider
+      agent.provider.model = model
+      return true
+    }
+    case "thinking": {
+      if (typeof value !== "boolean" || !agent.provider) return false
+      agent.provider.thinking = value ? { type: "enabled" } : { type: "disabled" }
+      return true
+    }
+    case "mode": {
+      if (value !== "plan" && value !== "normal") return false
+      agent.planMode = value === "plan"
+      return true
+    }
+    default:
+      return false
+  }
+}
+
+/** Config is "configured" when the active provider has a resolvable API key (env fallback included). */
+export function defaultIsConfigured() {
+  try {
+    return !!loadConfig().provider?.apiKey?.trim()
+  } catch {
+    return false
+  }
+}
+
+/** M1/M2 session factory: one agent per session, built from the process cwd (single-cwd model).
+ *  `id` is the ACP session id — it is baked into the callbacks at construction time
+ *  (buildAcpCallbacks closure), so it must be known BEFORE createAcpSession runs.
+ *  `request` is the transport's reverse-RPC channel (permissions + fs routing). */
+export async function defaultCreateSession({ id, notify, request, log }) {
+  const agent = await assembleAgent()
+  return createAcpSession({ id, agent, notify, request, log })
+}
+
+/**
+ * Build the ACP method handlers. Returns { handlers, sessions, notifyRef } —
+ * notifyRef.current is set by runAcpServer once the transport exists; sessions
+ * are created lazily (session/new), by which time the reference is live.
+ * @param {{ version?: string, notify?: (method, params) => void, log?: (s: string) => void,
+ *           isConfigured?: () => boolean, createSession?: (ctx) => Promise<object> }} deps
+ */
+export function buildAcpHandlers({
+  version = VERSION,
+  notify = () => {},
+  log = () => {},
+  isConfigured = defaultIsConfigured,
+  createSession = defaultCreateSession,
+  cwd = () => process.cwd(),
+}) {
+  const getCwd = cwd
+  const notifyRef = { current: notify }
+  const requestRef = { current: async () => { throw new Error("no request channel") } }
+  const sessions = new Map()
+  let nextId = 1
+  let authenticated = false
+  const findSession = (params) => {
+    const s = sessions.get(String(params?.sessionId))
+    if (!s) return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `unknown session ${params?.sessionId}` } }
+    return { session: s }
+  }
+
+  return {
+    handlers: {
+      initialize: () => ({
+        protocolVersion: 1,
+        agentInfo: { name: "thincoder", version },
+        authMethods: ["terminal"],
+        capabilities: { fs: { read: true, write: true }, terminal: false },
+      }),
+
+      authenticate: () => {
+        if (!isConfigured()) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        authenticated = true
+        return { authenticated: true }
+      },
+
+      "session/new": async (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        if (params.cwd !== undefined && typeof params.cwd !== "string") {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: "cwd must be a string" } }
+        }
+        // Normalized comparison: resolve() collapses trailing slashes, and
+        // normalizeCwd().toLowerCase() makes the check case-insensitive on
+        // Windows (drive letter + path — a client sending "c:\users\…" vs
+        // process.cwd() "C:\Users\…" must match). The ternary guards against
+        // resolve(undefined) — it would coerce undefined to the literal
+        // "undefined" and resolve a nonsense path. Note: `requested` never
+        // feeds any path operation — the agent always runs in getCwd() — so
+        // a case-insensitive match on case-sensitive platforms is harmless.
+        const norm = (p) => normalizeCwd(p).toLowerCase()
+        const requested = params.cwd ? resolve(params.cwd) : getCwd()
+        if (norm(requested) !== norm(getCwd())) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `v1: cwd must equal the process working directory (${getCwd()})` } }
+        }
+        if (params.mcpServers?.length) {
+          log(`[acp] MCP forwarding is M2 scope — ignoring ${params.mcpServers.length} server(s)`)
+        }
+        try {
+          const id = String(nextId++)
+          const session = await createSession({ id, notify: notifyRef.current, request: requestRef.current, log })
+          // `id` is immutable after construction (baked into the callbacks) — never reassign.
+          sessions.set(id, session)
+          return { id, configOptions: [{ configId: "model" }, { configId: "thinking" }, { configId: "mode" }] }
+        } catch (e) {
+          return { error: { code: ACP_ERRORS.INTERNAL.code, message: `failed to create session: ${e.message}` } }
+        }
+      },
+
+      "session/prompt": async (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const found = findSession(params)
+        if (found.error) return found
+        const blocks = Array.isArray(params?.content) ? params.content : []
+        const text = blocks.find((b) => b?.type === "text")?.text ?? ""
+        if (!text) return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: "prompt requires a text content block" } }
+        try {
+          await found.session.run(text)
+          return { stopReason: "end_turn" }
+        } catch (e) {
+          // Cancelled/interrupted turns are not errors on the wire.
+          if (e?.name === "AbortError" || e?.code === "ABORT_ERR") return { stopReason: "cancelled" }
+          return { error: { code: ACP_ERRORS.INTERNAL.code, message: e?.message ?? String(e) } }
+        }
+      },
+
+      "session/cancel": (params) => {
+        const found = findSession(params)
+        if (found.error) return found
+        found.session.cancel()
+        return {}
+      },
+
+      "session/close": (params) => {
+        const found = findSession(params)
+        if (!found.error) {
+          // Abort any in-flight turn first — the client is gone, the agent must
+          // stop consuming LLM tokens and emitting notifications.
+          found.session.cancel()
+          sessions.delete(String(params.sessionId))
+          log(`session ${params.sessionId} closed by client`)
+        }
+        return {}
+      },
+
+      // ─── M3: persisted slots (thincoder session archive) + config options ───
+
+      "session/list": () => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const slots = listSlots(getCwd())
+        return {
+          sessions: slots.map((s) => ({
+            id: String(s.slot),
+            cwd: getCwd(), // single-cwd model (design §4.5)
+            updatedAt: s.updatedAt ?? 0,
+            title: s.title ?? "",
+            messageCount: s.messageCount ?? 0,
+          })),
+        }
+      },
+
+      "session/load": async (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const slot = Number(params.sessionId)
+        if (!Number.isInteger(slot) || slot < 1) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `invalid session id: ${params.sessionId}` } }
+        }
+        const data = loadSlotFile(getCwd(), slot)
+        if (!data) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `session ${slot} not found (corrupt or deleted)` } }
+        }
+        try {
+          const id = String(nextId++)
+          const session = await createSession({ id, notify: notifyRef.current, request: requestRef.current, log })
+          applySession(session.agent, data)
+          sessions.set(id, session)
+          // Replay the human line (role → chunk mapping, design §4.5) so the
+          // client renders the restored conversation.
+          replayHistory({ sessionId: id, notify: notifyRef.current, history: data.history, log })
+          log(`session ${slot} loaded as session ${id} (${data.history?.length ?? 0} messages replayed)`)
+          return { id, cwd: getCwd(), configOptions: [{ configId: "model" }, { configId: "thinking" }, { configId: "mode" }] }
+        } catch (e) {
+          return { error: { code: ACP_ERRORS.INTERNAL.code, message: `failed to load session ${slot}: ${e.message}` } }
+        }
+      },
+
+      "session/resume": async (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const slot = Number(params.sessionId)
+        if (!Number.isInteger(slot) || slot < 1) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `invalid session id: ${params.sessionId}` } }
+        }
+        const data = loadSlotFile(getCwd(), slot)
+        if (!data) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `session ${slot} not found (corrupt or deleted)` } }
+        }
+        try {
+          const id = String(nextId++)
+          const session = await createSession({ id, notify: notifyRef.current, request: requestRef.current, log })
+          applySession(session.agent, data)
+          sessions.set(id, session)
+          // resume: no history replay — the client keeps its own rendering.
+          log(`session ${slot} resumed as session ${id} (no replay)`)
+          return { id, cwd: getCwd(), configOptions: [{ configId: "model" }, { configId: "thinking" }, { configId: "mode" }] }
+        } catch (e) {
+          return { error: { code: ACP_ERRORS.INTERNAL.code, message: `failed to resume session ${slot}: ${e.message}` } }
+        }
+      },
+
+      "session/delete": (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const slot = Number(params.sessionId)
+        if (!Number.isInteger(slot) || slot < 1) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `invalid session id: ${params.sessionId}` } }
+        }
+        // Only the persisted archive is removed; an active in-memory session
+        // with the same id keeps running (design §4.5).
+        if (!deleteSlot(getCwd(), slot)) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `session ${slot} not found` } }
+        }
+        log(`session ${slot} archive deleted`)
+        return {}
+      },
+
+      "session/set_config_option": (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const found = findSession(params)
+        if (found.error) return found
+        const { configId, value } = params
+        if (!configId || value === undefined) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: "set_config_option requires configId and value" } }
+        }
+        const applied = applyConfigOption(found.session.agent, configId, value)
+        if (!applied) {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `unknown configId: ${configId}` } }
+        }
+        // Last-write-wins on the internal state; notify the client of the change.
+        notifyRef.current("session/update", {
+          sessionId: String(params.sessionId),
+          update: { sessionUpdate: "config_option_update", configId, value },
+        })
+        return {}
+      },
+
+      "session/set_mode": (params) => {
+        if (!authenticated) return { error: ACP_ERRORS.AUTH_REQUIRED }
+        const found = findSession(params)
+        if (found.error) return found
+        if (params.mode !== "plan" && params.mode !== "normal") {
+          return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: "mode must be plan or normal" } }
+        }
+        found.session.agent.planMode = params.mode === "plan"
+        notifyRef.current("session/update", {
+          sessionId: String(params.sessionId),
+          update: { sessionUpdate: "current_mode_update", mode: params.mode },
+        })
+        return {}
+      },
+    },
+    sessions,
+    notifyRef,
+    requestRef,
+  }
+}
+
+/** `thincoder acp` — start the server and block until the client closes the pipe. */
+export async function runAcpServer() {
+  const log = (...a) => process.stderr.write(a.join(" ") + "\n")
+  // Build handlers first, then wire the transport — no window where requests
+  // hit an empty handler map. notifyRef/requestRef become live with the server.
+  const built = buildAcpHandlers({ log })
+  const server = createAcpServer(built.handlers, { log })
+  built.notifyRef.current = server.notify
+  built.requestRef.current = server.request
+  log(`[acp] thincoder ${VERSION} — ACP v1 over stdio, waiting for initialize`)
+  server.start()
+}

package/src/advisor/citations.mjs

@@ -0,0 +1,77 @@
+/**
+ * citations.mjs — host-verified citation checking (decision d698434).
+ * Extracted from advisor/run.mjs (file-size split). The evidence rule becomes
+ * a host fact: every `file:line: content` reference in a review is mechanically
+ * checked against the CURRENT disk state; mismatches mark the finding
+ * unverified and cannot support a push-back.
+ */
+import { readFileSync, realpathSync } from "node:fs"
+import { resolve, sep } from "node:path"
+
+// `file:line: content` citations — the file group is narrowed to source/config
+// extensions so URLs (`example.com:8080: …`) don't become false-positive
+// citations that fail as "file unreadable" in the verification report.
+// Single-letter extensions (c/h) are kept — false positives (e.g. "a.c:1: x")
+// are rare and only add a failed-citation line to the report; the report is
+// advisory for the parent agent, never a crash path.
+const CITATION_RE = /([\w./\\-]+\.(?:mjs|cjs|js|ts|jsx|tsx|mts|cts|py|rs|go|c|h|cpp|hpp|java|rb|php|sh|bash|json|md|markdown|mdx|yaml|yml|toml|css|html)):(\d+):\s*([^`\n]{4,})/g
+
+/** Extract `file:line: content` citations from a review text. */
+export function extractCitations(text) {
+  const out = []
+  for (const m of text.matchAll(CITATION_RE)) {
+    out.push({ file: m[1], line: Number(m[2]), content: m[3].trim() })
+  }
+  return out
+}
+
+/**
+ * Mechanically verify citations against the CURRENT file state: read the file,
+ * take the exact line, check it CONTAINS the quoted content. Reports
+ * N/M matched + the mismatches. Unverified citations cannot support a
+ * push-back — the evidence rule becomes a host fact, not a prompt wish.
+ */
+export function verifyCitations(text, cwd) {
+  const citations = extractCitations(text)
+  const matched = []
+  const failed = []
+  const root = resolve(cwd) + sep
+  for (const c of citations) {
+    try {
+      // Path confinement: citation paths are LLM-generated — never trust them.
+      // A hallucinated "../config.json" would otherwise read (and leak via the
+      // report) files outside the project, including API-key configs.
+      // realpathSync resolves symlinks too — a link inside the project that
+      // points outside must not pass the prefix check.
+      const resolved = realpathSync(resolve(cwd, c.file))
+      if (!resolved.startsWith(root)) {
+        failed.push({ ...c, reason: "path traversal" })
+        continue
+      }
+      const line = readFileSync(resolved, "utf8").split("\n")[c.line - 1] ?? ""
+      if (line.includes(c.content)) matched.push(c)
+      else failed.push(c)
+    } catch {
+      failed.push({ ...c, reason: "file unreadable" })
+    }
+  }
+  return { total: citations.length, matched, failed }
+}
+
+/** Append the verification report to the review text (visible to the parent agent). */
+export function appendCitationReport(text, cwd) {
+  const { total, matched, failed } = verifyCitations(text, cwd)
+  if (total === 0) return text // no citations — nothing to verify
+  const lines = [
+    "",
+    "---",
+    `[host-verified] ${matched.length}/${total} citations match current file state.`,
+  ]
+  if (failed.length > 0) {
+    lines.push("Citations that do NOT match the current file state (treat their claims as unverified):")
+    for (const f of failed.slice(0, 10)) {
+      lines.push(`- ${f.file}:${f.line}: ${f.content.slice(0, 80)}${f.reason ? ` (${f.reason})` : ""}`)
+    }
+  }
+  return text + lines.join("\n")
+}

package/src/advisor/convergence.mjs

@@ -0,0 +1,80 @@
+/**
+ * advisor/convergence.mjs — shared convergence-round message building (round 2+).
+ * SINGLE source for the round-2+ sections used by BOTH the normal flow
+ * (buildAdvisorFollowUp in advisor.mjs) and the legacy path (buildAdvisorUserMessage
+ * in messages.mjs) — fixes must not be replicated in two places. Lives in its
+ * own module to avoid the messages.mjs ↔ advisor.mjs import cycle.
+ */
+
+/**
+ * Shared convergence-round instructions — single source for BOTH paths
+ * (buildAdvisorUserMessage's legacy convergence block and
+ * buildAdvisorFollowUp), so the wording cannot diverge.
+ * Round 2 may flag obvious new issues; round 3+ is strict verification.
+ * @param {number} round — convergence round number (2+)
+ * @param {string[]|null} scopeFiles — optional file list for the no-response fallback
+ * @returns {string[]} the numbered instruction lines (callers spread them)
+ */
+export function buildConvergenceInstructions(round, scopeFiles = null) {
+  const fileList = scopeFiles?.length
+    ? ` The review surface is: ${scopeFiles.slice(0, 10).join(", ")}.`
+    : ""
+  return [
+    `1. IMPORTANT: verify EVERY item of the prior review output against the CURRENT FILE STATE with \`read\` — never decide based on earlier snapshots alone.${fileList}`,
+    "2. STALE-CONTEXT WARNING: any diff or file content from earlier messages is a historical snapshot — treat it as expired. Only fresh `read` results describe the current state.",
+    "3. You have no git tool; git output in earlier messages is historical and untrustworthy (committed fixes never show in a diff).",
+    "4. `read` the files named in the prior review output (or the review surface above) in full — ALWAYS. Batch reads/greps in a single reply.",
+    "5. Evidence rule: every 'Unfixed'/'New' finding MUST quote the exact line content from THIS round's `read` output (e.g. `run.mjs:180: timeoutId = setTimeout(...)`). Line numbers alone are NOT evidence — they may be stale or fabricated. Findings without a fresh quoted line are treated as unverified and will not be accepted.",
+    "6. Produce your verification table. Do not re-read content you already have.",
+    round === 2
+      ? "7. You may flag obvious NEW issues introduced by the fixes (crashes, data loss, logic errors — not style)."
+      : "7. Do NOT look for new issues.",
+  ]
+}
+
+/**
+ * Shared convergence body — SINGLE source for the round-2+ message sections
+ * (decision 2026-08-08): the FULL verbatim prior review output is the only
+ * complete verification list; the agent response table is a focus aid only.
+ * Used by buildAdvisorFollowUp (the normal flow) and the legacy path in
+ * messages.mjs (direct external callers of buildAdvisorUserMessage) — fixes
+ * must not be replicated in two places.
+ * @param {string} p — full prior review output (verbatim)
+ * @param {string} response — agent fix-claims table (or fallback text)
+ * @param {number} round — next round number (>= 2)
+ * @param {string[]|null} [scopeFiles] — review surface for instructions
+ * @returns {string} the convergence message
+ */
+export function buildConvergenceBody(p, response, round, scopeFiles) {
+  const label = round === 2 ? "Verify Prior Table + Flag New Issues" : "Strict Verification"
+  const reminder = round === 2
+    ? "verify every item in the prior review output and flag only obvious new issues introduced by the fixes"
+    : "strictly verify only the prior review output — do NOT look for new issues"
+  const parts = [
+    `## Round ${round} — ${label}`,
+    "",
+    `[System reminder: this is round ${round} of the convergence protocol. ` +
+      `The system prompt for this round has already narrowed the review scope — follow it: ${reminder}.]`,
+    "",
+    // Prior review output IS in the context (decision 2026-08-08): the FULL
+    // verbatim output of the last review — the only complete verification list.
+    // The agent response table covers only issues the agent chose to answer,
+    // so issues the agent skipped would silently escape convergence without
+    // the prior output. The model understands the review output directly —
+    // no table/header/phrase parsing. Restatement risk is handled
+    // mechanically: host-verified citations reject references that do not
+    // match the CURRENT disk state, and fresh sessions exclude old read data.
+    // The agent response table stays as a focus aid ("I fixed X"), not as the
+    // to-verify list.
+    "## Prior Review Output (verify every item it raises)",
+    p,
+    "",
+    "## Agent Response (fix claims — reference only)",
+    response,
+    "",
+    "## Instructions",
+    ...buildConvergenceInstructions(round, scopeFiles),
+    "",
+  ]
+  return parts.join("\n")
+}

package/src/advisor/history.mjs

@@ -1,14 +1,11 @@
 /**
- * advisor/history.mjs — advisor history extraction: issue/response tables and conversation background.
+ * advisor/history.mjs — advisor history extraction: agent response table and conversation background.
  */
 import { readFileSync } from "node:fs"
 import { join } from "node:path"
 
 export const ADVISOR_MD_PATH = ".thincoder/advisor.md"
-export const ADVISOR_TABLE_HEADER = "| # | File | Severity | Issue | Suggestion |"
-const CONVERGENCE_TABLE_HEADER = "| # | Orig# | File | Severity | Status | Notes |"
 const AGENT_RESPONSE_HEADER = "| # | Action | Detail |"
-export const LEGACY_ADVISOR_HEADER = "| # | 文件 | 严重程度 | 问题描述 | 建议修复 |"
 
 const DEFAULT_CRITERIA = `Review the code changes, focusing on:
 1. Correctness: logic errors, edge cases, off-by-one, incomplete modifications
@@ -18,60 +15,28 @@ const DEFAULT_CRITERIA = `Review the code changes, focusing on:
 5. Maintainability: vague naming, missing comments, overly complex logic`
 
 /**
- * Extract the most recent advisor review table from history.
- * Returns { text, sinceIdx } where sinceIdx is the index of the advisor call's
- * own history entry — extractAgentResponseTable skips it (role is "tool", not
- * "assistant") and scans forward for the agent's response table.
- * Returns null when: no advisor call, empty output, or the last review is
- * all-clear (nothing to follow up on).
- */
-export function extractPriorIssueTable(history) {
-  // allClear: exact phrases the prompts instruct the advisor to use on a clean review.
-  // NOTE: "已修复" (Fixed) is NOT here — it's a per-row Status value in convergence tables,
-  // and a mixed table must continue convergence even if some rows are Fixed.
-  const allClear = ["no 🔴", "all clear", "全部通过", "review passed", "no issues found", "no new issues"]
-  // Negative signals: a table listing SOME items as unfixed is NOT all-clear.
-  // Applied when the message carries a Status column (English or Chinese convergence
-  // format) — "failed"/"❌" in a round-1 Issue description must NOT trigger it.
-  const partiallyFixedRe = /\bunfixed\b|未修复|❌|\bfailed\b/i
-  const entries = Array.isArray(history) ? history : []
-
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const m = entries[i]
-    if (m.role !== "tool" || typeof m.content !== "string") continue
-    // Only review outputs carry one of these table headers. Matched at LINE START:
-    // an `includes()` match would also fire on advisor output that quotes the
-    // header constants' own source code (e.g. history.mjs), producing a phantom
-    // "prior issue table" and re-opening convergence rounds against stale data.
-    if (!lineHasHeader(m.content, ADVISOR_TABLE_HEADER)
-      && !lineHasHeader(m.content, CONVERGENCE_TABLE_HEADER)
-      && !lineHasHeader(m.content, LEGACY_ADVISOR_HEADER)) continue
-    const text = m.content
-    const lower = text.toLowerCase()
-    // Has a Status column? (English convergence format or any table with a Status-like
-    // column) — Chinese legacy tables lack it, but they are issue tables, not convergence.
-    const hasStatusColumn = lineHasHeader(text, CONVERGENCE_TABLE_HEADER)
-      || /Status|状态/.test(text.slice(0, text.indexOf("\n") + 1))
-    if (hasStatusColumn && partiallyFixedRe.test(lower)) return { text, sinceIdx: i }
-    if (allClear.some((s) => lower.includes(s))) return null
-    // sinceIdx = the advisor call's own index; extractAgentResponseTable skips it (role !== assistant)
-    return { text, sinceIdx: i }
-  }
-  return null
-}
-
-/** True when some line of `text` starts with `header` — table headers always sit at line start. */
-function lineHasHeader(text, header) {
-  return text.split("\n").some((l) => l.trimStart().startsWith(header))
-}
-
-/**
- * Extract the agent's response table (| # | Action | Detail |) that follows
- * the advisor review. Returns null when missing or no advisor review precedes.
+ * Extract the agent's response table (| # | Action | Detail |) — the fix-claims
+ * reference for convergence rounds.
+ * Semantics (decision 2026-08-08): without sinceIdx, scan BACKWARD for the
+ * MOST RECENT response table (no prior-table index is carried anymore — the
+ * agent response is a focus aid only; format drift falls back to the
+ * no-response text and never drives control flow). With sinceIdx, scan
+ * FORWARD from it (legacy callers/tests).
+ * @param {Array} history — message history
+ * @param {number} [sinceIdx] — legacy: start scanning forward from this index
+ * @returns {string|null} the response table content, or null
  */
 export function extractAgentResponseTable(history, sinceIdx) {
   const entries = Array.isArray(history) ? history : []
-  for (let i = sinceIdx ?? 0; i < entries.length; i++) {
+  if (sinceIdx !== undefined) {
+    for (let i = sinceIdx; i < entries.length; i++) {
+      const m = entries[i]
+      if (m.role !== "assistant" || typeof m.content !== "string") continue
+      if (m.content.includes(AGENT_RESPONSE_HEADER)) return m.content
+    }
+    return null
+  }
+  for (let i = entries.length - 1; i >= 0; i--) {
     const m = entries[i]
     if (m.role !== "assistant" || typeof m.content !== "string") continue
     if (m.content.includes(AGENT_RESPONSE_HEADER)) return m.content