@crouton-kit/crouter 0.3.40 → 0.3.42

package/dist/pi-extensions/canvas-context-intro.js

@@ -24,18 +24,23 @@
 // thing a terminal worker's bearings drop). The prose lives in
 // core/runtime/bearings.ts (shared with the promotion guidance dump).
 //
-// IDEMPOTENT across resumes, but FORK-AWARE: a `--session` relaunch restores OUR
-// conversation (whose bearings name OUR node id), so the session_start handler
-// sees it via `sessionManager.getEntries()` and skips — it never accumulates. A
-// `--fork-from` boot, by contrast, COPIES the source node's whole conversation
-// (whose bearings name the SOURCE's node id), so the handler must NOT treat that
-// inherited block as ours; it only skips when a bearings block belonging to OUR
-// node is already present (exact `details.nodeId` stamp, content-match
-// fallback), otherwise it injects ours — whose identity assertion (leading the
-// <crtr-bearings> block) reasserts the fork's identity over the inherited persona. This is ONE of two reinforcing
-// channels: spawn.ts ALSO prepends the same identity assertion to a fork's
-// kickoff prompt (the turn-triggering message), so the override does not rest on
-// a single trailing custom_message.
+// IDEMPOTENT across resumes, but FORK-AWARE and BRANCH-AWARE: the idempotency
+// scan walks only the ACTIVE BRANCH (root-first from the current leaf), not
+// every entry in the file. A `--session` relaunch that is a true resume keeps
+// the same branch, so the scan finds OUR prior bearings (named by OUR node id)
+// and skips — it never accumulates. A post-yield CYCLE roots a fresh branch (the
+// `crtr-cycle` marker), so the scan correctly finds nothing on that fresh branch
+// and injects a new intro, even though an OLDER cycle's intro still sits
+// elsewhere in the same `.jsonl`. A `--fork-from` boot COPIES the source node's
+// whole conversation onto ITS OWN branch (bearings naming the SOURCE's node id,
+// not ours), so the handler must NOT treat that inherited block as ours; it only
+// skips when a bearings block belonging to OUR node is already present on the
+// active branch (exact `details.nodeId` stamp, content-match fallback),
+// otherwise it injects ours — whose identity assertion (leading the
+// <crtr-bearings> block) reasserts the fork's identity over the inherited
+// persona. This is ONE of two reinforcing channels: spawn.ts ALSO prepends the
+// same identity assertion to a fork's kickoff prompt (the turn-triggering
+// message), so the override does not rest on a single trailing custom_message.
 //
 // COLLAPSED BY DEFAULT: a `registerMessageRenderer` keyed to our customType
 // renders the block as a single one-line stub; the full body only appears when
@@ -166,22 +171,28 @@ export function registerCanvasContextIntro(pi) {
             const nodeId = process.env['CRTR_NODE_ID'];
             if (nodeId === undefined || nodeId.trim() === '')
                 return; // not a canvas node
-            // Idempotent on RESUME, but NOT fooled by a FORK. A `--session` relaunch
-            // restores OUR conversation, whose bearings name OUR node id — skip then,
-            // so the block never accumulates. A `--fork-from` boot instead copies the
-            // SOURCE node's whole conversation (its bearings name ITS node id, not
-            // ours), so a naive "any crtr-context present?" check would suppress our
-            // own intro and let the fork inherit — and impersonate — the source. So we
-            // only skip when a bearings block belonging to OUR node is already present.
-            // Primary discriminator: the EXACT `details.nodeId` stamp (machine-
+            // Branch-aware idempotency: scan only the ACTIVE branch (root-first from
+            // the current leaf), not every entry in the file. A post-yield cycle roots a
+            // FRESH branch (the crtr-cycle marker), so scanning the whole file would
+            // find a PRIOR cycle's intro and wrongly skip injecting this cycle's own —
+            // the node's first turn would lack its crtr-context bearings entirely.
+            // Falls back to a whole-file scan only if the engine doesn't expose
+            // getBranch (older/degraded engine). Not fooled by a FORK either way: a
+            // `--fork-from` boot copies the source's whole conversation onto ITS OWN
+            // branch (bearings naming the SOURCE's node id, not ours), so a naive
+            // "any crtr-context present?" check would suppress our own intro and let
+            // the fork inherit — and impersonate — the source. So we only skip when a
+            // bearings block belonging to OUR node is already present on the scanned
+            // branch. Primary discriminator: the EXACT `details.nodeId` stamp (machine-
             // readable, copied on fork, never sent to the LLM). Fallback: a substring
             // match on the block text (our id appears in the identity line AND the
             // context-dir path `…/nodes/<nodeId>/context`) — covers legacy blocks
             // persisted before the stamp existed. Either match ⇒ this is our own
             // resume, not an inherited fork block, so skip.
-            const ours = ctx.sessionManager
-                .getEntries()
-                .some((e) => e.type === 'custom_message' &&
+            const scan = typeof ctx.sessionManager.getBranch === 'function'
+                ? ctx.sessionManager.getBranch()
+                : ctx.sessionManager.getEntries();
+            const ours = scan.some((e) => e.type === 'custom_message' &&
                 e.customType === CONTEXT_INTRO_CUSTOM_TYPE &&
                 (e.details?.nodeId === nodeId || entryText(e).includes(nodeId)));
             if (ours)

package/dist/pi-extensions/canvas-stophook.js

@@ -314,16 +314,22 @@ export function registerCanvasStophook(pi) {
             }
             // Boot / startup / resume / reload / fork → (re)bind this process to its
             // session id, record our OS pid (the daemon's broker-liveness signal), and
-            // CONFIRM any pending refresh-yield. Reaching session_start proves a fresh
-            // engine actually booted, so it is now safe to clear intent='refresh' — a
-            // refresh shuts the broker down and the daemon relaunches it FRESH, which
-            // leaves intent='refresh' set until this boot clears it (the only proof the
-            // relaunch worked; otherwise a failed relaunch would look like a success).
+            // CONFIRM any pending refresh-yield / pending cycle. Reaching session_start
+            // proves a fresh engine actually booted, so it is now safe to clear
+            // intent='refresh' — a refresh shuts the broker down and the daemon
+            // relaunches it FRESH, which leaves intent='refresh' set until this boot
+            // clears it (the only proof the relaunch worked; otherwise a failed relaunch
+            // would look like a success). Clearing `cycle_pending` here is the same
+            // proof for reviveNode's cycling-attempt marker (revive.ts) — it is always
+            // safe to clear on ANY confirmed boot (cycling, resuming, or fresh), since a
+            // pre-session_start crash-retry (crtrd.ts) only needs the flag while boot is
+            // still unconfirmed.
             const existing = getNode(nodeId);
             // Identity (session id/file) → meta; runtime (pid, intent) → atomic row setters.
             updateNode(nodeId, {
                 pi_session_id: id,
                 pi_session_file: sessionFile,
+                cycle_pending: false,
             });
             recordPid(nodeId, process.pid);
             if (existing?.intent === 'refresh')