gm-plugkit 2.0.1506 → 2.0.1508

package/SKILL.md

@@ -6,7 +6,7 @@ allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
 
 # gm
 
-**A turn that ends without a tool call is a stop, and stopping mid-chain is the cardinal failure.** Every programming agent reads only tool calls and their outputs; an assistant message that ends in prose with no tool call IS the turn ending, and the session halts there. So while the chain is in-flight (phase ≠ COMPLETE OR prd_pending_count > 0) you NEVER end a turn in prose, every turn ends in a tool call that advances the chain (the next `instruction` dispatch, the next verb the prose named, the next `transition`). You do NOT summarize, you do NOT write a "here's what I did" wrap-up, you do NOT narrate closure, summary is a stop, and stopping is only authorized when plugkit itself returns `phase=COMPLETE` AND `prd_pending_count=0`. Before you are ever tempted to stop or summarize, you dispatch `phase-status` and read it: if it is not terminal, that temptation was a drift signal, dispatch `instruction` and keep walking. This is tool-agnostic by construction: it depends on nothing but the verb spool, so it holds identically on every agent, with no hook and no tool-specific feature. The one and only thing that authorizes the prose-only turn is plugkit's COMPLETE pronouncement; until then, the answer to "am I done?" is another tool call.
+**A turn that ends without a tool call is a stop, and stopping mid-chain is the cardinal failure.** Every programming agent reads only tool calls and their outputs; an assistant message that ends in prose with no tool call IS the turn ending, and the session halts there. So while the chain is in-flight (phase ≠ COMPLETE OR prd_pending_count > 0) you NEVER end a turn in prose, every turn ends in a tool call that advances the chain (the next `instruction` dispatch, the next verb the prose named, the next `transition`). You do NOT summarize, you do NOT write a "here's what I did" wrap-up, you do NOT narrate closure, summary is a stop, and stopping is only authorized when plugkit itself returns `phase=COMPLETE` AND `prd_pending_count=0`. A turn-final sentence that names the next move instead of making it is the same stop facing forward — announcing a read, a verb, a re-dispatch is not doing it, and the chain strands exactly where the prose pointed. Take the move you were about to describe. Surfacing a decision is a tool call too (`AskUserQuestion` or `prd-add`), never a prose-only "confirming direction." Before you are ever tempted to stop, you dispatch `phase-status` and read it: if it is not terminal, that temptation was a drift signal, dispatch `instruction` and keep walking. This is tool-agnostic by construction: it depends on nothing but the verb spool, so it holds identically on every agent, with no hook and no tool-specific feature. The one and only thing that authorizes the prose-only turn is plugkit's COMPLETE pronouncement; until then, the answer to "am I done?" is another tool call.
 
 **Done is what plugkit says is done, never your claim.** The COMPLETE gate is the single arbiter. If the chain is not at COMPLETE, there is a next transition to seek; idle mid-chain is a deviation.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1506",
+  "version": "2.0.1508",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform binary, verifies SHA256, and starts the spool watcher daemon. Includes plugkit-wasm-wrapper for WASM-based spool watching.",
   "main": "index.js",
   "bin": {

package/plugkit-wasm-wrapper.js

@@ -330,7 +330,7 @@ function endTurn(sess, t, idleSpanned) {
   });
 }
 
-function turnTick(sess, verb, taskBase, phase) {
+function turnTick(sess, verb, taskBase, phase, prdPending) {
   const key = sess || '(no-session)';
   const now = Date.now();
   let t = _turns.get(key);
@@ -349,14 +349,46 @@ function turnTick(sess, verb, taskBase, phase) {
     if (verb !== 'instruction') return;
     const idx = ((_turns.get(key + ':lastIdx') || 0) + 1);
     _turns.set(key + ':lastIdx', idx);
-    t = { idx, startTs: now, lastTs: now, dispatches: 0, verbs: new Map(), phases: new Set(), deviations: 0, lastPhase: phase };
+    t = { idx, startTs: now, lastTs: now, dispatches: 0, verbs: new Map(), phases: new Set(), deviations: 0, lastPhase: phase, prdPending: null, stallEmitted: false };
     _turns.set(key, t);
     logEvent('plugkit', 'turn.start', { sess, turn_idx: idx, phase: phase || null });
   }
   t.lastTs = now;
   t.dispatches++;
+  // A verb arriving resumes the turn — clear any prior stall flag so a later re-stall
+  // is a fresh episode, not silently suppressed by the one-shot guard.
+  t.stallEmitted = false;
   t.verbs.set(verb, (t.verbs.get(verb) || 0) + 1);
   if (phase) { t.phases.add(phase); t.lastPhase = phase; }
+  if (typeof prdPending === 'number') t.prdPending = prdPending;
+}
+
+// turn.end fires only when a NEW verb arrives after idle, so a turn that simply never
+// receives another verb stays open forever and emits no signal — a permanent stall is
+// silence, not an event, which is how a mid-EXECUTE stop stays invisible for days. The
+// heartbeat scan closes that hole: for each open turn idle past STALL_MS whose last phase
+// is non-terminal (or carries open PRD rows), emit turn.stalled once. One-shot per episode
+// (stallEmitted), reset when a verb resumes the turn. A COMPLETE turn with no open rows
+// idling is the authorized prose-only state and never stalls.
+const STALL_MS = 300_000;
+function scanStalledTurns() {
+  const now = Date.now();
+  for (const [key, t] of _turns) {
+    if (!t || typeof t !== 'object' || !Number.isFinite(t.startTs)) continue;
+    if (t.stallEmitted) continue;
+    if ((now - t.lastTs) < STALL_MS) continue;
+    const terminal = t.lastPhase === 'COMPLETE' && (t.prdPending === 0 || t.prdPending == null);
+    if (terminal) continue;
+    t.stallEmitted = true;
+    logEvent('hook', 'deviation.mid-chain-stall', {
+      sess: key,
+      turn_idx: t.idx,
+      ended_in_phase: t.lastPhase || null,
+      prd_pending: t.prdPending,
+      idle_ms: now - t.lastTs,
+      dispatches: t.dispatches,
+    });
+  }
 }
 
 let __sessCache = { value: '', mtimeMs: 0, readAt: 0, srcMtimeMs: 0 };
@@ -504,7 +536,7 @@ function emitOrchestratorEvents(verb, taskBase, resultStr) {
   }
   const data = parsed.data || {};
   const sess = readCurrentSess();
-  turnTick(sess, verb, taskBase, data.phase);
+  turnTick(sess, verb, taskBase, data.phase, typeof data.prd_pending_count === 'number' ? data.prd_pending_count : undefined);
   switch (verb) {
     case 'transition':
       logEvent('plugkit', 'phase.transitioned', { task: taskBase, phase: data.phase, next_skill: data.nextSkill, recall_count: Array.isArray(data.recall_hits) ? data.recall_hits.length : 0 });
@@ -2900,10 +2932,13 @@ async function runSpoolWatcher(instance, spoolDir) {
       // (the VERB ABORT). Stamp a busy_until window before the synchronous dispatch so the
       // supervisor's heartbeat-stale check honors it, exactly as the browser runner does.
       // codesearch is the longest synchronous verb: a cold first call loads the 133MB bge-small
-      // bert model AND re-indexes the tree, far exceeding the 30s stale limit. Without busy_until
-      // the supervisor reaps the watcher mid-index and respawns it, which cold-loads again =
-      // respawn-thrash that never completes the index (the codeinsight-stale symptom).
-      if (verb === 'git_finalize' || verb === 'git_push' || verb === 'git_fetch' || verb === 'codesearch') {
+      // bert model AND re-indexes the tree. A cold build was witnessed at ~252s (dispatch log
+      // codesearch ms=251772), so a 180s window let the supervisor reap the watcher mid-index and
+      // respawn it, cold-loading again = respawn-thrash that never completes (the codeinsight-stale
+      // symptom). codesearch gets a 360s window; the bounded git verbs keep 180s.
+      if (verb === 'codesearch') {
+        try { _writeStatusBusy(360000); } catch (_) {}
+      } else if (verb === 'git_finalize' || verb === 'git_push' || verb === 'git_fetch') {
         try { _writeStatusBusy(180000); } catch (_) {}
       }
 
@@ -3062,6 +3097,7 @@ async function runSpoolWatcher(instance, spoolDir) {
   }
   _writeStatusBusy = (ms) => { try { writeStatus(ms); } catch (_) {} };
   setInterval(() => writeStatus(), 5000);
+  setInterval(() => { try { scanStalledTurns(); } catch (_) {} }, 30000);
   writeStatus();
 
   const TURN_SUMMARY_PATH = path.join(spoolDir, '.turn-summary.json');