@jeffober/thatch 0.2.0 → 0.2.1

package/src/runtime.ts

@@ -28,7 +28,7 @@ import { seedDefaultBehaviors } from "./seed-behaviors";
 import { startVersionChecker, stopVersionChecker, getVersionChecker, readOnDiskVersion, compareSemver } from "./version-check";
 import { WatcherRegistry, ghApiRun, ghAvailable, runWatchedCommand, watcherTarget, withCwdFallback, type Watcher } from "./watchers";
 import { watcherNotificationNudge, watcherRearmNotice, watcherDeathNotice, chatNotificationNudge, chatEchoText, isChatEchoParts } from "./prompts";
-import { ChatPoller, createWakeGate, hostedSessionIds, isDefaultSessionTitle } from "./chat";
+import { ChatPoller, createWakeGate, hostedSessionIds, isDefaultSessionTitle, unexpiredGraceRehosts } from "./chat";
 import { chatEnabled, chatAutoRegister, loadConfig, alertMode, notificationDefaults } from "./config";
 import { sendNotification } from "./notify";
 import { osProcessArgs, startupSessionId, continuesLastSessionFromArgv, continuesLastSessionId } from "./os-args";
@@ -51,6 +51,17 @@ const RECALL_THRESHOLD = parseFloat(process.env.THATCH_RECALL_THRESHOLD ?? "0.55
 // returns to days later.
 const DORMANT_WATCHER_GRACE_MS = 24 * 60 * 60 * 1000;
 
+// Grace rehosting after a RESTART (see the hosted-row branch in the
+// rehydration loop): the dead daemon's hosted set re-hosts for this window.
+// Open TUI tabs reconnect to the new daemon but emit no events until the
+// user types, so without the grace they go falsely stale ("presumed gone")
+// while alive-idle, and mail stops waking them. Sessions that emit activity
+// graduate to permanent hosting via the event stream; still-silent ones
+// (closed tabs) age out at the grace and go stale again. Matches
+// DORMANT_WATCHER_GRACE_MS - same resumability shape, same trade.
+const CHAT_REHOST_GRACE_MS =
+  (Number(process.env.THATCH_CHAT_REHOST_GRACE_MINUTES ?? 0) * 60_000) || 24 * 60 * 60 * 1000;
+
 /**
  * True when every definition in a dormant watcher row is past its TTL plus
  * the dormant grace period - the row is a corpse no resume can usefully
@@ -142,6 +153,14 @@ export async function createRuntime(input: {
   const dbPath = process.env.THATCH_DB_PATH ?? join(configHome, "thatch", "thatch.db");
   const modelName = process.env.THATCH_MODEL ?? "Xenova/bge-small-en-v1.5";
 
+  // Set by dispose(). Delayed async work (the child-reconcile timer, the
+  // extraction pipeline's queued finalization, queued event handlers) can
+  // fire after the db is closed; anything running past this flag must not
+  // touch the db - and journal writes must no-op BEFORE the lazy reopen
+  // accessor (src/db.ts) would hand them a fresh connection, because after
+  // a v2 plugin reload the RELOADED instance owns those rows.
+  let disposed = false;
+
   // The DB must exist before identity detection: detectRepo consults the
   // repo_paths cache when the session directory is gone.
   const db = new ThatchDB(dbPath);
@@ -161,8 +180,13 @@ export async function createRuntime(input: {
   const releaseModel = () => sharedModels.release(dbPath);
 
   // Extraction buffer, journaled to runtime_state so a v2 plugin reload
-  // (same process, graph rebuilt) can rehydrate it.
+  // (same process, graph rebuilt) can rehydrate it. The journal callback
+  // checks the disposed flag FIRST: a finalization delayed past dispose
+  // (await points inside the pipeline) must not write through the lazy
+  // reopen accessor after the reload - the reloaded instance owns those
+  // rows. Same ownership rule as journalChild below.
   const extraction = new ExtractionPipeline((kind, sessionID, value) => {
+    if (disposed) return;
     if (value === undefined) db.runtimeStateDelete(kind, sessionID);
     else db.runtimeStatePut(kind, sessionID, value, directory);
   });
@@ -267,7 +291,13 @@ export async function createRuntime(input: {
   const watchers = new WatcherRegistry({
     // Journal watcher definitions so a v2 plugin reload (same process) can
     // re-arm them; the registry journals after every membership change.
+    // Disposed check FIRST: a poll cycle suspended at an await can outlive
+    // watchers.dispose() and reach this callback after db.close(); with the
+    // lazy reopen it would otherwise hand a stale writer a fresh connection
+    // and resurrect an expired watcher after the reload. Same ownership rule
+    // as the extraction callback and journalChild.
     journal: (sessionID, sessionWatchers) => {
+      if (disposed) return;
       if (sessionWatchers.length === 0) db.runtimeStateDelete("watchers", sessionID);
       else db.runtimeStatePut("watchers", sessionID, sessionWatchers, directory);
     },
@@ -332,16 +362,27 @@ export async function createRuntime(input: {
   const chatPoller = new ChatPoller({
     store: db,
     hostedSessions: () => {
+      const now = Date.now();
       const hosted = hostedSessionIds({
         statusKeys: sessionStatus.keys(),
         resumedSessions: resumedSessions,
-        rehostedSessions: rehostedSessions,
+        rehostedSessions: [...rehostedSessions, ...unexpiredGraceRehosts(rehostGrace, now)],
         exclude: childToParent.keys(),
       });
-      // Journal the set so the NEXT reload (same pid + directory) re-hosts
-      // these sessions and the poller can wake them with pending mail
-      // instead of waiting for the user to type.
-      db.runtimeStatePut("hosted", directory, hosted, directory);
+      // The journal NEVER SHRINKS within a process lifetime: a plugin
+      // reload rebuilds the hosted set empty (sessionStatus is in-memory),
+      // so a session that was idle across a reload would otherwise be
+      // dropped from the set and never re-hosted - falsely stale while its
+      // tab is open. The union means the next reload re-graces everything
+      // this process ever hosted (bounded by the 24h grace decay);
+      // shrinking happens only through session.deleted, which rewrites the
+      // row.
+      const prevRow = db
+        .runtimeStateAll()
+        .find((r) => r.kind === "hosted" && r.sessionID === directory);
+      const prevIds = prevRow && Array.isArray(prevRow.value) ? (prevRow.value as string[]) : [];
+      const merged = [...new Set([...prevIds, ...hosted])];
+      db.runtimeStatePut("hosted", directory, merged, directory);
       return hosted;
     },
     deliver: async (sessionID, senders, count) => {
@@ -470,6 +511,16 @@ export async function createRuntime(input: {
   // Populated from session.created events that carry a parentID.
   const childToParent = new Map<string, string>();
 
+  // Per-child kind ("extraction" | "task"), recorded at session.created from
+  // the live extractionChildren set and at restore from the journal record.
+  // The parent-state mutations a child's lifecycle triggers (snapshot drain
+  // on memory write, whole-set requeue on error/deletion) are only correct
+  // for extraction children - a task sub-agent saving its own findings never
+  // processed the parent's buffer, and treating its lifecycle as extraction
+  // evidence silently dropped in-flight or pending entries (the v2
+  // all-children-linked loss vector, September 2026).
+  const childKinds = new Map<string, "extraction" | "task">();
+
   // Snapshot of the parent's buffer at the moment each child was dispatched.
   // When the child writes a memory, consumeSnapshot drains only these entries
   // (by reference identity), preserving interleaved-turn entries that arrived
@@ -494,9 +545,10 @@ export async function createRuntime(input: {
   // children from task-dispatched sub-agents (code review specialists, the
   // nudge-path fact-extractor, any model-dispatched task). Only extraction
   // children get the full cleanup: buffer drain, session deletion, toast.
-  // Non-extraction children get the old behavior (completeAccepted +
-  // missedNudges.reset) so their sessions are not deleted out from under the
-  // task tool that dispatched them.
+  // Non-extraction children get claim-scoped completion (a no-op for a
+  // child that never fetched a payload) + missedNudges.reset so their
+  // sessions are not deleted out from under the task tool that dispatched
+  // them.
   const extractionChildren = new Set<string>();
 
   // Per-child-session extraction metrics for the toast notification. When the
@@ -507,14 +559,21 @@ export async function createRuntime(input: {
 
   // Journal the child bookkeeping (parent link, buffer snapshot, metrics) so
   // a v2 plugin reload can rehydrate an in-flight extraction instead of
-  // orphaning it. A child with no parent entry journals a delete.
+  // orphaning it. A child with no parent entry journals a delete. The kind
+  // marker distinguishes extraction children from task-dispatched sub-agents
+  // (the live source of truth is the extractionChildren set): restoring a
+  // task sub-agent as an extraction child let its idle take the extraction
+  // branch - consumeSnapshot silently dropped the parent's buffered entries
+  // without extraction, and the task tool's session got a delete call.
   const journalChild = (childId: string) => {
+    if (disposed) return;
     const parentID = childToParent.get(childId);
     if (!parentID) {
       db.runtimeStateDelete("child", childId);
       return;
     }
     db.runtimeStatePut("child", childId, {
+      kind: extractionChildren.has(childId) ? "extraction" : "task",
       parentID,
       snapshot: parentSnapshots.get(childId) ?? [],
       metrics: childMetrics.get(childId) ?? { new: 0, updated: 0, deleted: 0 },
@@ -551,6 +610,11 @@ export async function createRuntime(input: {
   // (same pid + same directory). Written through by the poller's hosted-set
   // read, so the next reload picks up the latest set.
   const rehostedSessions = new Set<string>();
+  // Foreign-pid hosted rows (restart): the dead daemon's hosted set,
+  // re-hosted under a grace window instead of dropped - open TUI tabs
+  // reconnect but emit no events until the user types. id -> grace
+  // deadline (epoch ms).
+  const rehostGrace = new Map<string, number>();
   const rehydrated: Record<string, number> = {};
   for (const row of db.runtimeStateAll()) {
     const samePid = row.pid === process.pid;
@@ -569,6 +633,21 @@ export async function createRuntime(input: {
       if (row.kind === "watchers" && !dormantWatchersStale((row.value as Watcher[] | null) ?? [])) {
         continue;
       }
+      // A foreign-pid HOSTED row re-hosts under a grace window instead of
+      // being pruned: open TUI tabs reconnect to the new daemon but emit
+      // no events until the user types, so dropping the set made them
+      // falsely stale ("presumed gone") while alive-idle, and mail to
+      // them stopped waking the tab. Sessions that emit activity graduate
+      // to permanent hosting via the event stream; still-silent ones
+      // (closed tabs) age out at the grace and go stale. The row itself
+      // stays: the poller's next hosted-set journal rewrites it, and a
+      // further restart re-graces whatever it then holds.
+      if (row.kind === "hosted") {
+        for (const id of (row.value ?? []) as string[]) {
+          rehostGrace.set(id, Date.now() + CHAT_REHOST_GRACE_MS);
+        }
+        continue;
+      }
       db.runtimeStateDelete(row.kind, row.sessionID);
       continue;
     }
@@ -586,26 +665,32 @@ export async function createRuntime(input: {
     } else if (row.kind === "watchers") {
       watchers.hydrate((row.value ?? []) as Watcher[]);
     } else if (row.kind === "hosted") {
-      // Rehydrate only on a same-process reload. A foreign-pid hosted row
-      // (restart) would re-host sessions whose harnesses died - dropping
-      // it is the point: the resumed session re-hosts itself through the
-      // event stream instead.
-      if (!samePid) {
-        db.runtimeStateDelete(row.kind, row.sessionID);
-        continue;
-      }
+      // Same-pid reload: re-host permanently (the plugin re-ran in place;
+      // the sessions may still be running). Foreign-pid rows were graced
+      // in the restart branch above.
       for (const id of (row.value ?? []) as string[]) rehostedSessions.add(id);
     } else if (row.kind === "child") {
-      const rec = row.value as { parentID?: string; snapshot?: ToolInteraction[]; metrics?: { new: number; updated: number; deleted: number } };
+      const rec = row.value as { kind?: "extraction" | "task"; parentID?: string; snapshot?: ToolInteraction[]; metrics?: { new: number; updated: number; deleted: number } };
       if (samePid && rec?.parentID) {
         // Reload: the child may still be running - restore its live
-        // bookkeeping so its idle event finds the maps populated.
+        // bookkeeping so its idle event finds the maps populated. The
+        // default covers rows written before the marker existed; it errs
+        // toward extraction (defaulting to task would strand a legacy
+        // in-flight extraction child with extracting never restored,
+        // suppressing both extraction paths for the session's life), at
+        // the cost of resurrecting the restore-time misclassification for
+        // the rarer pre-upgrade in-flight task child - a one-window trade,
+        // self-healing as rows are rewritten with kinds.
+        const kind = rec.kind ?? "extraction";
+        childKinds.set(row.sessionID, kind);
         childToParent.set(row.sessionID, rec.parentID);
         parentSnapshots.set(row.sessionID, rec.snapshot ?? []);
-        extractionChildren.add(row.sessionID);
-        extracting.add(rec.parentID);
         if (rec.metrics) childMetrics.set(row.sessionID, rec.metrics);
-        restoredChildren.set(row.sessionID, rec.parentID);
+        if (kind === "extraction") {
+          extractionChildren.add(row.sessionID);
+          extracting.add(rec.parentID);
+          restoredChildren.set(row.sessionID, rec.parentID);
+        }
       } else {
         // Restart: the child ran in the dead process and no execution event
         // will ever arrive for it. Recover the snapshot as plain pending
@@ -755,17 +840,14 @@ export async function createRuntime(input: {
   // the reload window.
   const finishExtractionChild = async (sessionID: string, parentID: string) => {
     if (extractionChildren.has(sessionID)) {
-      // Drain the parent's snapshot entries from the pending buffer. If the
-      // child wrote memories, consumeSnapshot already ran in
-      // tool.execute.after and the snapshot is gone - nothing to drain. If
-      // the child did a no-save run, the snapshot entries are still in the
-      // buffer and need to be drained here so they don't replay as a nudge
-      // on the next chat.message. Never drain the entire buffer -
-      // interleaved-turn entries must survive.
-      const snapshot = parentSnapshots.get(sessionID);
-      if (snapshot) {
-        extraction.consumeSnapshot(parentID, snapshot);
-      }
+      // The child's claimed delivery is consumed by completeClaimed below -
+      // the fetch recorded exactly what the child received, so nothing else
+      // is dropped here. Entries the child never received (post-fetch
+      // arrivals, or a never-fetched payload) stay pending and re-nudge;
+      // the old snapshot drain here would have silently dropped the
+      // never-fetched case without extraction. (Snapshot drain removed
+      // September 2026 - claim semantics subsume it. The journal's
+      // snapshot field remains for restart recovery.)
 
       // Fire a toast with the extraction metrics. Only show a toast when
       // memories were actually written - no toast for no-save runs to avoid
@@ -789,9 +871,14 @@ export async function createRuntime(input: {
         }
       }
 
-      extraction.completeAccepted(parentID);
+      // Scope the completion to THIS child's claimed delivery. A fetcher
+      // that never fetched (a sibling sub-agent going idle, an extractor
+      // that crashed before its payload call) has no claim and must not
+      // drop the accepted set - another extractor may hold it in flight.
+      extraction.completeClaimed(sessionID);
       missedNudges.delete(parentID);
       extracting.delete(parentID);
+      childKinds.delete(sessionID);
       childToParent.delete(sessionID);
       parentSnapshots.delete(sessionID);
       childMetrics.delete(sessionID);
@@ -805,10 +892,13 @@ export async function createRuntime(input: {
         // Best-effort - the child is idle and harmless if not deleted.
       }
     } else {
-      // Task-dispatched sub-agent went idle. Complete the parent's accepted
-      // entries (from the nudge-path extraction_done accept) and reset
-      // missedNudges. Retained for the nudge fallback path.
-      extraction.completeAccepted(parentID);
+      // Task-dispatched sub-agent went idle. Complete only what THIS child
+      // claimed via its payload fetch - sibling specialists going idle have
+      // no claim and must be a no-op, or their idle signal drops another
+      // extractor's in-flight accepted payload. An extractor that never
+      // fetched leaves its entries held; requeueStaleAccepted bounds the
+      // linger.
+      extraction.completeClaimed(sessionID);
       missedNudges.delete(parentID);
     }
   };
@@ -826,6 +916,10 @@ export async function createRuntime(input: {
       const t = setTimeout(resolve, 10_000);
       t.unref?.();
     });
+    // Dispose (a v2 plugin reload or process exit) may have closed the db
+    // during the 10s window; finalizing into it would throw on the journal
+    // write. The reloaded instance's own reconciler owns the rows now.
+    if (disposed) return;
     let live: Record<string, { type: string }> = {};
     try {
       live = (await caps.fetchStatuses()) ?? {};
@@ -915,6 +1009,7 @@ export async function createRuntime(input: {
     const cleanupChild = () => {
       extracting.delete(parentID);
       extractionChildren.delete(childId);
+      childKinds.delete(childId);
       childToParent.delete(childId);
       parentSnapshots.delete(childId);
       childMetrics.delete(childId);
@@ -966,6 +1061,10 @@ export async function createRuntime(input: {
   const toolMemoryRemember = async (sessionID: string, overwrite: unknown) => {
     extraction.consume(sessionID);
     missedNudges.delete(sessionID);
+    // A session that fetched its own payload (direct parent-side fetch or a
+    // child's payload call) completes its claim when it writes a memory -
+    // the write proves the delivered entries were processed.
+    extraction.completeClaimed(sessionID);
     // Track extraction metrics for toast display. Counted for any
     // child session (both direct-extraction and nudge-path sub-agents)
     // since childToParent covers both. The toast only fires for
@@ -978,18 +1077,18 @@ export async function createRuntime(input: {
       childMetrics.set(sessionID, metrics);
       journalChild(sessionID);
       // Complete the parent's accepted entries (the extractor confirmed
-      // it is alive and saving) and drain the parent's snapshot entries
-      // from the pending buffer. If no snapshot was recorded (unreachable
-      // when childToParent has the entry, since both are set together in
-      // session.created), skip the drain rather than dropping the entire
-      // buffer - interleaved-turn entries that arrived while the child
-      // was running must survive for the next extraction cycle.
-      extraction.completeAccepted(parentID);
-      const snapshot = parentSnapshots.get(sessionID);
-      if (snapshot) {
-        extraction.consumeSnapshot(parentID, snapshot);
-        parentSnapshots.delete(sessionID);
-      }
+      // it is alive and saving). Completion is scoped to THIS child's
+      // claimed delivery - the fetch IS the delivery record, so whatever
+      // the child received is consumed here and nothing else. Pending
+      // entries the child never received (post-fetch arrivals, or a child
+      // that never fetched) stay pending and re-nudge: no silent loss.
+      // (The old dispatch-time snapshot drain was either a no-op under
+      // claim semantics or a silent-loss vector for children that never
+      // fetched - removed September 2026. The journal's snapshot field
+      // remains for restart recovery.)
+      extraction.completeClaimed(sessionID);
+      journalChild(sessionID);
+      missedNudges.delete(parentID);
       journalChild(sessionID);
       missedNudges.delete(parentID);
     }
@@ -997,7 +1096,14 @@ export async function createRuntime(input: {
   const toolExtractionDone = (sessionID: string, targetID?: string) => {
     const parentID = childToParent.get(sessionID);
     if (parentID) {
-      extraction.completeAccepted(parentID);
+      // The child's completion consumes its own claimed delivery. The
+      // whole-set fallback covers a child that acks without ever fetching
+      // (its payload call errored) - rare, and the ack is a deliberate
+      // processed signal, unlike the automatic idle path which is
+      // claim-scoped only.
+      if (!extraction.completeClaimed(sessionID)) {
+        extraction.completeAccepted(parentID);
+      }
       missedNudges.delete(parentID);
       extraction.consume(sessionID);
     } else if (targetID && targetID !== sessionID) {
@@ -1007,8 +1113,13 @@ export async function createRuntime(input: {
       // relationship and the explicit session_id is the only signal that
       // the target's accepted entries are accounted for. Without this
       // branch the accepted queue lingers forever and a tool-dense session
-      // re-nudges every idle on never-draining exhaust.
-      extraction.completeAccepted(targetID);
+      // re-nudges every idle on never-draining exhaust. Completion is
+      // scoped to the child's claimed delivery; the whole-set fallback
+      // covers the no-claim case (a fetch that errored, or the MCP path
+      // where the file-backed queue was drained instead).
+      if (!extraction.completeClaimed(sessionID)) {
+        extraction.completeAccepted(targetID);
+      }
       missedNudges.delete(targetID);
     } else {
       extraction.accept(sessionID);
@@ -1023,10 +1134,15 @@ export async function createRuntime(input: {
 
   return {
     coreContext: buildCoreContext(db, model, repo, {
-      extractionPayloadProvider: (sessionID: string): string | null => {
-        const interactions = extraction.peek(sessionID);
-        const accepted = extraction.peekAccepted(sessionID);
-        const all = [...accepted, ...interactions];
+      extractionPayloadProvider: (targetID: string, fetcherID?: string): string | null => {
+        // A fetcher identity turns the fetch into the delivery record: the
+        // claimed entries stay accepted, and THAT fetcher's completion
+        // signal consumes only them (claim semantics). Without a fetcher
+        // (no host session context) the fetch is a pure peek - legacy
+        // behavior.
+        const all = fetcherID
+          ? extraction.claim(targetID, fetcherID)
+          : [...extraction.peekAccepted(targetID), ...extraction.peek(targetID)];
         if (all.length === 0) return null;
         return extraction.buildPayload(all, repo);
       },
@@ -1076,6 +1192,13 @@ export async function createRuntime(input: {
     //      extraction_done call in a child session of that parent (the
     //      extractor confirming it processed them), or the child going idle
     //      (a no-save run that never acks still counts as processed).
+    //      Completion is CLAIM-SCOPED: the pipeline records which fetcher
+    //      received the payload (get_extraction_payload), and a completion
+    //      signal consumes only that fetcher's delivery. A sibling
+    //      sub-agent going idle - a code-review specialist, a slow child
+    //      from a previous round - has no claim and is a no-op, so it can
+    //      no longer silently drop another extractor's in-flight payload
+    //      (the accept-then-racing-completion loss, fixed September 2026).
     //    - REQUEUE returns the held entries to pending. Signals: the child
     //      session errors or is deleted before completing.
     //
@@ -1219,7 +1342,12 @@ export async function createRuntime(input: {
       if (wrapUp) {
         pendingWrapUp.set(input.sessionID, wrapUp);
         // Journaled so a v2 plugin reload before the session's next idle
-        // does not silently drop the armed wrap-up.
+        // does not silently drop the armed wrap-up. Disposed check FIRST:
+        // a command execute still in flight when the reload's cleanup runs
+        // must not land a stale wrap-up row through the lazy reopen (the
+        // reloaded instance owns the journal rows; same rule as the
+        // extraction and watcher journal callbacks).
+        if (disposed) return;
         db.runtimeStatePut("wrapup", input.sessionID, wrapUp, directory);
       }
     },
@@ -1352,6 +1480,13 @@ export async function createRuntime(input: {
       // requeue here so they are honestly re-extracted instead of lingering
       // as silent loss.
       extraction.requeueStaleAccepted();
+      // Task-dispatched sub-agent sessions may have restricted tool lists
+      // that exclude the thatch tools, and even where the tools exist the
+      // child is driven by its dispatch prompt, so nudges only burn "No
+      // tool named ..." error rounds or add noise there. Extraction
+      // children are excluded: they run with full tools and are driven by
+      // extractionDirectPrompt.
+      if (childToParent.has(input.sessionID) && !extractionChildren.has(input.sessionID)) return;
       if (!extracting.has(input.sessionID) && extraction.pending(input.sessionID)) {
         const batch = extraction.peek(input.sessionID);
         const missed = missedNudges.get(input.sessionID) ?? 0;
@@ -1511,6 +1646,7 @@ export async function createRuntime(input: {
         const info = event.properties.info;
         if (info.parentID) {
           childToParent.set(info.id, info.parentID);
+          childKinds.set(info.id, extractionChildren.has(info.id) ? "extraction" : "task");
           parentSnapshots.set(info.id, [...extraction.peek(info.parentID)]);
           journalChild(info.id);
           // Child sessions don't need the session-start reminder - only
@@ -1533,8 +1669,17 @@ export async function createRuntime(input: {
         }
         const parentID = childID ? childToParent.get(childID) : undefined;
         if (parentID && childID) {
-          extraction.requeueAccepted(parentID);
+          // Requeue what THIS child actually held: its claimed delivery if
+          // it fetched. ERROR is a terminal death signal, so a claim-less
+          // child (died before fetching - boot failures land here) falls
+          // back to whole-set requeue for immediate recovery, regardless
+          // of kind: the worst case is a benign duplicate extraction, never
+          // silent loss.
+          if (!extraction.requeueClaimed(childID)) {
+            extraction.requeueAccepted(parentID);
+          }
           extracting.delete(parentID);
+          childKinds.delete(childID);
           childToParent.delete(childID);
           parentSnapshots.delete(childID);
           childMetrics.delete(childID);
@@ -1647,8 +1792,18 @@ export async function createRuntime(input: {
         // the topic column instead (refreshed on every idle), so the name
         // and the description stay separate identities. Fire-and-forget: a
         // failed registration or title fetch must never block event
-        // delivery.
-        if (chatOn && chatAutoRegister(loadConfig(dbPath).config) && sessionID && !db.hasChatLeaveTombstone(sessionID)) {
+        // delivery. TOP-LEVEL ONLY: child sessions (extraction sub-agents,
+        // task sub-agents) are machinery, not chat participants - without
+        // this check every fact-extractor run registered a roster row
+        // (the "thatch-extraction" corpse flood, September 2026). The
+        // prompt-register path above has the same check.
+        if (
+          chatOn &&
+          chatAutoRegister(loadConfig(dbPath).config) &&
+          sessionID &&
+          !childToParent.has(sessionID) &&
+          !db.hasChatLeaveTombstone(sessionID)
+        ) {
           void (async () => {
             try {
               const data = await caps.sessionGet(sessionID);
@@ -1730,13 +1885,41 @@ export async function createRuntime(input: {
         // ChatStore.unregister), and the tombstone is cleared only by an
         // explicit chat_register rejoin, so a genuinely new session is
         // unaffected.
-        // A child deleted before completing never processed its payload.
+        // A child deleted before completing never processed its payload -
+        // unless it was a task-kind child: task sub-agents finish and get
+        // deleted ROUTINELY, and a finished task child's later deletion
+        // must not requeue the parent's extraction state (it would yank an
+        // in-flight extractor's accepted set back to pending for duplicate
+        // extraction). Requeue what the child actually held: its claim, or
+        // for a claim-less extraction child the whole accepted set.
         const parentID = childToParent.get(id);
+        const childKind = childKinds.get(id) ?? "extraction";
         if (parentID) {
-          extraction.requeueAccepted(parentID);
-          extracting.delete(parentID);
+          if (!extraction.requeueClaimed(id) && childKind === "extraction") {
+            extraction.requeueAccepted(parentID);
+          }
+          if (childKind === "extraction") extracting.delete(parentID);
         }
+        extraction.dropClaim(id);
+        childKinds.delete(id);
         childToParent.delete(id);
+        // A deleted session's grace rehost ends immediately - the user
+        // closed it deliberately; the roster must not keep it fresh. The
+        // hosted-row journal is pruned too: the union never shrinks on its
+        // own, and a deleted session must not re-host into the grace on
+        // the next reload.
+        rehostGrace.delete(id);
+        const hostedRow = db
+          .runtimeStateAll()
+          .find((r) => r.kind === "hosted" && r.sessionID === directory);
+        if (hostedRow && Array.isArray(hostedRow.value)) {
+          db.runtimeStatePut(
+            "hosted",
+            directory,
+            (hostedRow.value as string[]).filter((sid) => sid !== id),
+            directory,
+          );
+        }
         parentSnapshots.delete(id);
         childMetrics.delete(id);
         extractionChildren.delete(id);
@@ -1747,6 +1930,7 @@ export async function createRuntime(input: {
         // watchers die with it - the session that would receive their
         // notifications no longer exists.
         extraction.completeAccepted(id);
+        extraction.dropClaim(id);
         extracting.delete(id);
         watchers.cancelSession(id);
         // Leaving the chat directory is the graceful-exit fast path; a
@@ -1801,15 +1985,20 @@ export async function createRuntime(input: {
     },
 
     dispose: async () => {
+      disposed = true;
       stopVersionChecker();
       watchers.dispose();
       chatPoller.dispose();
-      await releaseModel();
-      // Note: the runtime_state journal is deliberately NOT cleared here.
-      // Disposal happens before every v2 plugin reload, and the reloaded
-      // setup() rehydrates from it; stale rows from dead processes are
-      // pruned by the setup-time partition instead.
-      db.close();
+      try {
+        await releaseModel();
+      } finally {
+        // In finally so a releaseModel rejection cannot leak the connection.
+        // Note: the runtime_state journal is deliberately NOT cleared here.
+        // Disposal happens before every v2 plugin reload, and the reloaded
+        // setup() rehydrates from it; stale rows from dead processes are
+        // pruned by the setup-time partition instead.
+        db.close();
+      }
     },
   };
 }