@crouton-kit/crouter 0.3.12 → 0.3.14

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

@@ -0,0 +1,114 @@
+// canvas-passive-context.ts — pi extension for pi-native canvas agent nodes.
+//
+// Loaded into every canvas node's pi process via the node's launch.extensions
+// list. INERT when CRTR_NODE_ID is absent (plain pi session or legacy job agent).
+//
+// The passive-subscription drain. A PASSIVE subscription (active=false edge)
+// never wakes its subscriber: `push` routes its pointers to passive.jsonl, which
+// the inbox-watcher never polls. They simply accumulate. This extension is what
+// finally surfaces them — the moment the node is MESSAGED.
+//
+// pi fires an `input` event for every user message (human-typed, an RPC, or an
+// extension's sendUserMessage — including the inbox-watcher's own wake). On that
+// event we DRAIN the node's passive accumulator and, when non-empty, prepend
+// every entry as timestamped XML to the message text via the `transform` action.
+// So the backlog rides in as pre-text on whatever message next engages the node,
+// before the LLM sees it — and is cleared in the same step (drain = read+clear),
+// so it surfaces exactly once.
+//
+// Plain TS-with-types — no imports from @earendil-works/* so this compiles inside
+// crouter's own tsc build without a dep on the pi packages.
+import { existsSync, readFileSync } from 'node:fs';
+import { drainPassive } from '../core/feed/passive.js';
+// Per-entry body cap so a single fat report can't blow the context budget. The
+// full report stays on disk at `ref` if the agent needs more.
+const BODY_CAP = 4_000;
+// ---------------------------------------------------------------------------
+// Report dereference — turn a passive pointer into the message text it carries.
+// ---------------------------------------------------------------------------
+/** Strip the leading YAML frontmatter block a report is written with, returning
+ *  just the body. Tolerant: no frontmatter → returns the input unchanged. */
+function stripFrontmatter(raw) {
+    if (!raw.startsWith('---\n'))
+        return raw;
+    const end = raw.indexOf('\n---\n', 4);
+    return end === -1 ? raw : raw.slice(end + 5);
+}
+/** The content for one accumulated entry: the dereferenced report body when the
+ *  pointer carries a `ref`, else the entry's own label/data. Capped + trimmed. */
+function entryContent(e) {
+    if (e.ref !== undefined && e.ref !== '' && existsSync(e.ref)) {
+        try {
+            const body = stripFrontmatter(readFileSync(e.ref, 'utf8')).trim();
+            if (body !== '') {
+                return body.length > BODY_CAP
+                    ? `${body.slice(0, BODY_CAP)}\n… (truncated; full report at ${e.ref})`
+                    : body;
+            }
+        }
+        catch {
+            /* fall through to the label */
+        }
+    }
+    const data = e.data?.['body'];
+    if (typeof data === 'string' && data.trim() !== '')
+        return data.trim();
+    return e.label;
+}
+/** Minimal XML attribute escaping for the values we interpolate. */
+function attr(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Render drained passive entries (oldest first) into one XML pre-text block.
+ * Each accumulated message is its own timestamped `<update>` element.
+ */
+export function formatPassive(entries) {
+    const blocks = entries
+        .map((e) => {
+        const from = attr(e.from ?? 'system');
+        const refAttr = e.ref !== undefined && e.ref !== '' ? ` ref="${attr(e.ref)}"` : '';
+        return (`<update from="${from}" kind="${attr(e.kind)}" at="${attr(e.ts)}"${refAttr}>\n` +
+            `${entryContent(e)}\n` +
+            `</update>`);
+    })
+        .join('\n');
+    return (`<passive-subscription-backlog count="${entries.length}" ` +
+        `note="Reports accumulated from nodes you passively subscribe to while you were not actively listening. ` +
+        `Surfaced now because you were messaged. Oldest first.">\n` +
+        `${blocks}\n` +
+        `</passive-subscription-backlog>`);
+}
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+/**
+ * Register the passive-context drain on `pi`.
+ *
+ * Returns immediately (inert) when CRTR_NODE_ID is absent. The `input` handler
+ * is the whole extension: drain on every message, prepend when non-empty.
+ */
+export function registerCanvasPassiveContext(pi) {
+    pi.on('input', (event) => {
+        try {
+            const nodeId = process.env['CRTR_NODE_ID'];
+            if (nodeId === undefined || nodeId.trim() === '')
+                return; // not a canvas node
+            const drained = drainPassive(nodeId);
+            if (drained.length === 0)
+                return; // nothing accumulated → leave the message as-is
+            const preText = formatPassive(drained);
+            const text = event.text.trim() === '' ? preText : `${preText}\n\n${event.text}`;
+            return { action: 'transform', text, images: event.images };
+        }
+        catch {
+            // Best-effort: a drain/format failure must never drop the user's message.
+            return;
+        }
+    });
+}
+export default registerCanvasPassiveContext;

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

@@ -132,29 +132,52 @@ function extractText(msg) {
         .trim();
 }
 // ---------------------------------------------------------------------------
-// Context-size steering bands — first nudge at 100k input tokens, then one
-// every 50k thereafter (150k, 200k, 250k, …). Unbounded: a long-lived node
-// keeps getting reminded as it grows.
+// Context-size steering bands — mode-specific schedules that ESCALATE in tone
+// as input context grows. The first band is a gentle "consider it"; a later
+// band turns firm. Past the last explicit band the firmest nudge repeats every
+// 50k, so a long-lived node keeps getting reminded.
+//
+//   orchestrator: 130k gentle (consider yielding) → 150k+ firm (do it now)
+//   base worker:  130k suggest promote → 160k+ suggest promote (+ "ignore if
+//                 nearly done")
 // ---------------------------------------------------------------------------
-const STEER_FLOOR = 100_000;
 const STEER_STEP = 50_000;
-/** The highest band boundary at or below `tokens` (100k, 150k, 200k, …), or
- *  null below the floor. */
-function steerBand(tokens) {
-    if (tokens < STEER_FLOOR)
+const ORCH_BANDS = [130_000, 150_000]; // gentle, then firm (firm repeats +50k)
+const WORKER_BANDS = [130_000, 160_000]; // suggest, then suggest+ignore (repeats +50k)
+/** The highest band threshold at or below `tokens` for `mode`. Below the first
+ *  band → null. At/past the last listed band, bands continue every STEER_STEP
+ *  (so the firmest nudge keeps recurring). */
+function steerBand(tokens, mode) {
+    const bands = mode === 'orchestrator' ? ORCH_BANDS : WORKER_BANDS;
+    const first = bands[0];
+    const last = bands[bands.length - 1];
+    if (tokens < first)
         return null;
-    return STEER_FLOOR + Math.floor((tokens - STEER_FLOOR) / STEER_STEP) * STEER_STEP;
+    if (tokens >= last)
+        return last + Math.floor((tokens - last) / STEER_STEP) * STEER_STEP;
+    let chosen = first;
+    for (const b of bands)
+        if (tokens >= b)
+            chosen = b;
+    return chosen;
 }
-/** The nudge text for a crossed band, specialized to the node's mode. An
- *  orchestrator is steered to checkpoint its roadmap and yield; a non-
- *  orchestrator (base worker) is steered to PROMOTE itself — become a resident
- *  orchestrator — when work remains, or finish if it's nearly done. */
+/** The nudge text for a crossed band, specialized to the node's mode + how far
+ *  along the escalation it is. An orchestrator is steered to checkpoint its
+ *  roadmap and yield (gently first, then firmly); a non-orchestrator (base
+ *  worker) is steered to PROMOTE itself — become a resident orchestrator — when
+ *  work remains, with an "ignore if nearly done" once it's deeper in. */
 function steerNote(at, mode) {
     const k = Math.round(at / 1000);
     if (mode === 'orchestrator') {
+        if (at < 150_000) {
+            return `Context ~${k}k and growing. When you reach a good stopping point, consider updating context/roadmap.md and running \`crtr node yield\` to refresh against it — no rush yet.`;
+        }
         return `Context ~${k}k. Update context/roadmap.md so a fresh revive can continue, delegate any outstanding work, then \`crtr node yield\` to refresh.`;
     }
-    return `Context ~${k}k and climbing. If more work remains than this context can finish, \`crtr node promote\` to become a resident orchestrator (seeds a roadmap, lets you delegate and \`crtr node yield\` to refresh). If you're nearly done, finish with \`crtr push final\`.`;
+    const suggest = `If much more work remains than this context can finish, consider \`crtr node promote\` to become a resident orchestrator (seeds a roadmap, lets you delegate and \`crtr node yield\` to refresh).`;
+    if (at < 160_000)
+        return `Context ~${k}k. ${suggest}`;
+    return `Context ~${k}k. ${suggest} If you're nearly done, ignore this suggestion and finish with \`crtr push final\`.`;
 }
 // ---------------------------------------------------------------------------
 // Extension
@@ -179,9 +202,9 @@ export function registerCanvasStophook(pi) {
     let totalOut = 0;
     let model = '';
     // Context-size steering. As input context grows we nudge the node once per
-    // band (100k, then every 50k). The nudge depends on the node's CURRENT mode,
-    // read at fire time since a base worker can promote mid-session: an
-    // orchestrator checkpoints + yields; a base worker is steered to promote.
+    // band on an escalating, mode-specific schedule (see steerBand/steerNote).
+    // Mode is read at fire time since a base worker can promote mid-session: an
+    // orchestrator is steered to checkpoint + yield; a base worker to promote.
     const firedBands = new Set();
     // ---------------------------------------------------------------------------
     // session_start — capture pi's session id, and detect `/new`.
@@ -246,10 +269,10 @@ export function registerCanvasStophook(pi) {
         // Context-size steering: fire the current band once, with mode-specific
         // guidance (mode is read live — a worker may have promoted since launch).
         try {
-            const at = steerBand(totalIn);
+            const mode = getNode(nodeId)?.mode ?? 'base';
+            const at = steerBand(totalIn, mode);
             if (at !== null && !firedBands.has(at)) {
                 firedBands.add(at);
-                const mode = getNode(nodeId)?.mode ?? 'base';
                 pi.sendUserMessage(`[crtr] ${steerNote(at, mode)}`, { deliverAs: 'followUp' });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crouton-kit/crouter",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "crtr — fast access to skills, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",