@crouton-kit/crouter 0.3.70 → 0.3.79

package/dist/core/runtime/pi-vendored.js

@@ -10,6 +10,20 @@
 // `node_modules/@earendil-works/pi-coding-agent/dist/core/slash-commands.js`.
 // If the upstream list changes (entries added/removed/reworded), update the copy
 // below to match and adjust the count note.
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** pi's sessions root, VENDORED from pi `config.getSessionsDir()` (= `<agentDir>/
+ *  sessions`). pi's package `exports` map is `.`-only, so config.js can't be
+ *  deep-imported, and a ROOT import of `getAgentDir` would eager-load the entire
+ *  heavy pi SDK index on crtr's front-door hot path (the reason broker-sdk.ts
+ *  dynamic-imports the engine). Mirrors pi: `PI_CODING_AGENT_DIR` env, else
+ *  `~/.pi/agent` (APP_NAME defaults to 'pi'). Re-sync on a pi SDK bump that moves
+ *  the sessions dir — same vendoring rationale as the slash-command list below. */
+export function piSessionsRoot() {
+    const env = process.env['PI_CODING_AGENT_DIR'];
+    const agentDir = env !== undefined && env !== '' ? env : join(homedir(), '.pi', 'agent');
+    return join(agentDir, 'sessions');
+}
 /**
  * pi's builtin slash commands — vendored verbatim from pi `core/slash-commands.js`
  * `BUILTIN_SLASH_COMMANDS` (review C1). **21 entries at 0.78.1** (review n1 — NOT 23).

package/dist/core/runtime/placement.d.ts

@@ -1,7 +1,7 @@
 import { type FocusRow } from '../canvas/index.js';
 export type { FocusRow };
-export { splitWindow, breakPane, selectLayout, selectPane, focusWindow, selectWindow, switchClient, openNodeWindow, ensureSession, paneLocation, paneExists, paneRunning, paneCurrentPath, currentTmux, inTmux, installMenuBinding, setPaneOption, getPaneOption, piCommand, shellQuote, respawnPaneSync, closePane, windowOfPane, renameWindow, paneOfWindow, windowAlive, listLivePanes, } from './tmux.js';
-export type { RespawnPaneOpts } from './tmux.js';
+export { splitWindow, breakPane, selectLayout, selectPane, focusWindow, selectWindow, switchClient, openNodeWindow, ensureSession, paneLocation, paneExists, paneRunning, paneCurrentPath, currentTmux, inTmux, installTmuxBindings, installTmuxBindings as installMenuBinding, setPaneOption, getPaneOption, piCommand, shellQuote, respawnPaneSync, closePane, windowOfPane, renameWindow, paneOfWindow, windowAlive, listLivePanes, } from './tmux.js';
+export type { RespawnPaneOpts, TmuxInstalledPair, TmuxInstallDiagnostic, TmuxInstallResult } from './tmux.js';
 /** The viewer a node has on screen, or null. UNIQUE(node_id) ⇒ at most one. */
 export declare function focusOf(nodeId: string): FocusRow | null;
 /** Does this node have a live viewer on screen? */

package/dist/core/runtime/placement.js

@@ -48,7 +48,10 @@ import { isPidAlive } from '../canvas/pid.js';
 // re-exported for the same reason — callers building the seam's expected
 // bundled-pi command string (e.g. the M1 seam test) need the identical quoting
 // piCommand uses internally, without importing tmux.ts directly.
-export { splitWindow, breakPane, selectLayout, selectPane, focusWindow, selectWindow, switchClient, openNodeWindow, ensureSession, paneLocation, paneExists, paneRunning, paneCurrentPath, currentTmux, inTmux, installMenuBinding, setPaneOption, getPaneOption, piCommand, shellQuote, respawnPaneSync, closePane, windowOfPane, renameWindow, paneOfWindow, windowAlive, listLivePanes, } from './tmux.js';
+export { splitWindow, breakPane, selectLayout, selectPane, focusWindow, selectWindow, switchClient, openNodeWindow, ensureSession, paneLocation, paneExists, paneRunning, paneCurrentPath, currentTmux, inTmux, installTmuxBindings, 
+// Compile seam for attach-cmd.ts, which still calls installMenuBinding();
+// deleted when the attach unit imports installTmuxBindings directly.
+installTmuxBindings as installMenuBinding, setPaneOption, getPaneOption, piCommand, shellQuote, respawnPaneSync, closePane, windowOfPane, renameWindow, paneOfWindow, windowAlive, listLivePanes, } from './tmux.js';
 // ---------------------------------------------------------------------------
 // Viewer registry reads — COMPOSE over the canvas focuses table (§2.3/§4).
 //

package/dist/core/runtime/promote.js

@@ -55,6 +55,10 @@ export function promote(nodeId, opts = {}) {
         // across the polymorph (the persona default is recomputed fresh for
         // targetKind).
         model: targetModel,
+        // Resolve kind/ladder config against the NODE's own cwd + profile, not
+        // this process's ambient scope.
+        cwd: node.cwd,
+        profileId: node.profile_id,
     });
     // Seed a barebones roadmap scaffold if absent so the file exists for a
     // refresh. Pre-fill its Goal from the node's goal doc when present (set at

package/dist/core/runtime/recap.d.ts

@@ -1,8 +1,8 @@
-/** Ask pi headlessly for a three-fragment recap of `conversation`, async. Invokes
- *  `onRecap` with the parsed fragment lines on success, or never (silent) on any
+/** Ask pi headlessly for a concise briefing of `conversation`, async. Invokes
+ *  `onRecap` with the parsed string on success, or never (silent) on any
  *  failure — non-zero exit, timeout, empty/garbled output. Owns the subprocess
  *  mechanics — crucially it hands pi an immediate stdin EOF: `pi -p` reads stdin,
  *  and execFile's default stdin is an OPEN pipe that never closes, so without
  *  this pi blocks waiting for EOF and the call exits non-zero (the same gotcha
  *  naming.ts documents). */
-export declare function generateRecap(conversation: string, onRecap: (lines: string[]) => void): void;
+export declare function generateRecap(conversation: string, onRecap: (briefing: string) => void, liveModel?: string, roadmap?: string): void;

package/dist/core/runtime/recap.js

@@ -1,9 +1,10 @@
-// Inactivity recap — turn a dormant node's conversation into a three-fragment
-// "where it left off" card (goal / doing-now / next) for the recap widget.
+// Inactivity recap — turn a dormant node's conversation into one concise
+// returning-developer briefing for the recap widget.
 //
 // One entry point: generateRecap — async (execFile, non-blocking), mirroring
-// naming.ts's headless-`pi -p` pattern exactly. It runs Haiku over the literal
-// back-and-forth (the caller concatenates user+assistant text) with a stripped-
+// naming.ts's headless-`pi -p` pattern exactly. It runs the live conversation's
+// working model over the literal back-and-forth (the caller concatenates user and
+// assistant text, plus the node's roadmap when one exists) with a stripped-
 // down pi invocation (no tools/session/context/extensions/skills), so it's fast
 // and side-effect free and can never recurse into another spawn.
 //
@@ -15,37 +16,67 @@
 // Plain TS-with-types — no imports from @earendil-works/* so it compiles inside
 // crouter's own tsc build without a dep on the pi packages.
 import { execFile } from 'node:child_process';
-import { resolveBundledPiCliPath } from './pi-cli.js';
+import { bundledPiSubprocessEnv, resolveBundledPiCliPath } from './pi-cli.js';
 /** Wall-clock budget for the headless pi call before we give up (no recap). */
 const RECAP_TIMEOUT_MS = 25_000;
-/** Default recap model — Haiku. A recap is a one-shot summarization, so we pin
- *  the small/fast model rather than the node's heavyweight default. Override
- *  with CRTR_RECAP_MODEL (mirrors CRTR_NAME_MODEL). */
+/** Fallback model when the live session has not resolved one yet. Ordinarily the
+ *  caller passes the provider/model that just completed the conversation's last
+ *  turn, avoiding a dead hard-pinned provider. CRTR_RECAP_MODEL overrides both. */
 const DEFAULT_RECAP_MODEL = 'anthropic/claude-haiku-4-5';
-const RECAP_SYSTEM_PROMPT = 'You write a terse "where we left off" recap of a coding-agent work session, ' +
-    'read at a glance by someone returning to a paused conversation. You are given ' +
-    'the literal back-and-forth between the user and the agent. Output EXACTLY three ' +
-    'lines, nothing else — no labels, no numbering, no bullets, no punctuation at the ' +
-    'end of a line, no prose:\n' +
-    '  Line 1: the GOAL — what this session is ultimately trying to achieve.\n' +
-    '  Line 2: DOING NOW — what was just happening / the active piece of work.\n' +
-    '  Line 3: NEXT — the immediate next step.\n' +
-    'Each line is a short FRAGMENT, not a sentence (e.g. `wire up recap widget above editor`, ' +
-    'not `We are wiring up the recap widget.`). Keep each under ~60 characters. ' +
-    'If the session has barely started or you cannot tell, still give your best three ' +
-    'fragments from whatever text exists. Output JUST the three lines.';
-/** Put the conversation FIRST in a delimited block, then the instruction, so the
- *  model reads the content before being told what to do. */
-function recapUserPrompt(conversation) {
-    return `<conversation>\n${conversation}\n</conversation>\n\nWrite the three-line recap of the session above (goal / doing-now / next). Output JUST the three lines.`;
+const RECAP_SYSTEM_PROMPT = 'You brief a developer returning to a paused coding-agent conversation. They run ' +
+    'many agent sessions in parallel and have lost this one\'s thread: they no longer ' +
+    'know what this conversation is about or what they originally asked for. The ' +
+    'brief exists to solve exactly that — pinned above their input box, it must tell ' +
+    'them at a glance what this conversation is FOR and where it actually stands. ' +
+    'You are given the first and most recent messages of the literal user/agent ' +
+    'back-and-forth (tool output omitted), and the agent\'s roadmap file when one ' +
+    'exists.\n' +
+    '\n' +
+    'Output EXACTLY two plain-text lines, nothing else:\n' +
+    'Goal: <what was requested — the original ask / what this conversation is for>\n' +
+    'State: <catch-them-up: what is ACTUALLY going on right now>\n' +
+    '\n' +
+    'Both lines are extremely short — telegraphic fragments, roughly 8-15 words, no ' +
+    'filler. The State line must NOT restate the most recent message — the last ' +
+    'message is often mid-progress, a question, or noise; instead synthesize the ' +
+    'real position: what has landed, what is in flight, and the live blocker or ' +
+    'needed answer. If the agent is waiting on the developer, say exactly what for. ' +
+    'Be concrete (real file names, branches, SHAs, error messages — one specific ' +
+    'anchor beats abstractions). Never narrate turn by turn, hedge, or pad. If the ' +
+    'conversation has barely started, still emit your best two lines.\n' +
+    '\n' +
+    'Examples of the shape (from other conversations):\n' +
+    'Goal: Validate + commit the Unit 3 attach-keybinding migration in this worktree.\n' +
+    'State: Done — 17/17 tests green, committed and rebased onto main.\n' +
+    '\n' +
+    'Goal: Build the trimmed-v1 command-plugin seam (orchestrating phases).\n' +
+    'State: Phase 1 landed; waiting on the core-seam worker\'s final.\n' +
+    '\n' +
+    'Goal: Standing personal assistant — iMessage wakes, Reddit scans, small tasks.\n' +
+    'State: Idle — waiting on you: hook pick, map export, Omi timing.';
+/** Put the content FIRST in delimited blocks (roadmap, then conversation), then
+ *  the instruction, so the model reads the content before being told what to do. */
+function recapUserPrompt(conversation, roadmap) {
+    const rm = roadmap !== undefined && roadmap.trim() !== ''
+        ? `<roadmap>\n${roadmap.trim()}\n</roadmap>\n\n`
+        : '';
+    return `${rm}<conversation>\n${conversation}\n</conversation>\n\nWrite the two-line Goal:/State: briefing for the conversation above. Output JUST the two lines.`;
 }
 /** The pi argv for a headless recap request. Stripped down (no tools, session,
  *  context files, extensions, skills, templates, themes) so it's fast and
- *  side-effect free. Pinned to Haiku with thinking off. Override the model with
- *  CRTR_RECAP_MODEL. */
-function recapArgs(conversation) {
+ *  side-effect free. Thinking stays off; model precedence is explicit env
+ *  override → the conversation's live working model → the small fallback. */
+function recapArgs(conversation, liveModel, roadmap) {
     const override = process.env['CRTR_RECAP_MODEL'];
-    const model = override !== undefined && override.trim() !== '' ? override.trim() : DEFAULT_RECAP_MODEL;
+    // An explicit operator override wins. Otherwise prefer the live conversation's
+    // current model: it just completed a successful turn, while a hard-pinned
+    // provider (the old Haiku-only path) may be rate-limited and silently produce
+    // no brief. The small default remains for sessions with no resolved model yet.
+    const model = override !== undefined && override.trim() !== ''
+        ? override.trim()
+        : liveModel !== undefined && liveModel.trim() !== ''
+            ? liveModel.trim()
+            : DEFAULT_RECAP_MODEL;
     const argv = [
         '-p',
         '--no-session',
@@ -59,44 +90,41 @@ function recapArgs(conversation) {
         '--thinking', 'off',
         '--model', model,
         '--system-prompt', RECAP_SYSTEM_PROMPT,
-        recapUserPrompt(conversation),
+        recapUserPrompt(conversation, roadmap),
     ];
     return argv;
 }
-/** Parse the model's raw stdout into up to three short fragment lines. Strips any
- *  stray leading labels/bullets the model may have added despite instructions,
- *  drops empties, and hard-caps line length so a runaway line can't blow up the
- *  widget. Returns [] when nothing usable survives (→ no recap). */
+/** Normalize model stdout to the two-line `Goal:`/`State:` briefing. Collapses
+ *  intra-line whitespace and drops blank lines; the viewer paints each line
+ *  (wrapping to its width). A garbled shape still returns whatever lines came
+ *  back — the widget is best-effort chrome, not a contract. */
 function parseRecap(stdout) {
-    const LINE_CAP = 72;
-    const lines = stdout
+    return stdout
         .split('\n')
-        .map((l) => l.trim())
-        // Strip a leading `goal:` / `now:` / `next:` / `- ` / `1.` style prefix.
-        .map((l) => l.replace(/^(?:[-*•]\s*)?(?:\d+[.)]\s*)?(?:goal|now|doing(?:[\s-]now)?|next)\s*[:\-]\s*/i, '').trim())
-        .filter((l) => l !== '');
-    return lines.slice(0, 3).map((l) => (l.length > LINE_CAP ? l.slice(0, LINE_CAP) : l));
+        .map((l) => l.replace(/\s+/g, ' ').trim())
+        .filter((l) => l !== '')
+        .join('\n');
 }
-/** Ask pi headlessly for a three-fragment recap of `conversation`, async. Invokes
- *  `onRecap` with the parsed fragment lines on success, or never (silent) on any
+/** Ask pi headlessly for a concise briefing of `conversation`, async. Invokes
+ *  `onRecap` with the parsed string on success, or never (silent) on any
  *  failure — non-zero exit, timeout, empty/garbled output. Owns the subprocess
  *  mechanics — crucially it hands pi an immediate stdin EOF: `pi -p` reads stdin,
  *  and execFile's default stdin is an OPEN pipe that never closes, so without
  *  this pi blocks waiting for EOF and the call exits non-zero (the same gotcha
  *  naming.ts documents). */
-export function generateRecap(conversation, onRecap) {
+export function generateRecap(conversation, onRecap, liveModel, roadmap) {
     const body = (conversation ?? '').trim();
     if (body === '')
         return;
     try {
-        const child = execFile(process.execPath, [resolveBundledPiCliPath(), ...recapArgs(body)], { encoding: 'utf8', timeout: RECAP_TIMEOUT_MS }, (err, stdout) => {
+        const child = execFile(process.execPath, [resolveBundledPiCliPath(), ...recapArgs(body, liveModel, roadmap)], { encoding: 'utf8', timeout: RECAP_TIMEOUT_MS, env: bundledPiSubprocessEnv() }, (err, stdout) => {
             if (err || typeof stdout !== 'string')
                 return; // silent — no recap
-            const lines = parseRecap(stdout);
-            if (lines.length === 0)
+            const briefing = parseRecap(stdout);
+            if (briefing === '')
                 return;
             try {
-                onRecap(lines);
+                onRecap(briefing);
             }
             catch { /* best-effort */ }
         });

package/dist/core/runtime/recycle.js

@@ -97,7 +97,11 @@ export async function recycleNode(nodeId, callerPane) {
         ensureDaemon();
     }
     catch { /* daemon is best-effort */ }
-    const { launch } = buildLaunchSpec('general', 'base', { lifecycle: 'resident', hasManager: false });
+    // Resolve against the RECYCLED node's cwd + profile (not this process's
+    // ambient scope) and carry the profile onto the fresh root — it is the same
+    // person's seat, so profile-scope defaults (e.g. a persisted /model default)
+    // must keep applying.
+    const { launch } = buildLaunchSpec('general', 'base', { lifecycle: 'resident', hasManager: false, cwd: meta.cwd, profileId: meta.profile_id });
     const root = spawnNode({
         kind: 'general',
         mode: 'base',
@@ -105,6 +109,7 @@ export async function recycleNode(nodeId, callerPane) {
         cwd: meta.cwd,
         name: 'general',
         parent: null,
+        profile_id: meta.profile_id,
         launch,
     });
     // Hand the viewport to the fresh root: reuse M's focus row over the SAME pane

package/dist/core/runtime/reset.js

@@ -86,6 +86,10 @@ export async function relaunchRoot(oldId, deps = {}) {
         lifecycle: 'resident',
         hasManager: false,
         model: old.model_override ?? undefined,
+        // The OLD root's cwd + profile, not this process's ambient scope — the
+        // relaunch is the same seat, so profile-scope kind defaults keep applying.
+        cwd: old.cwd,
+        profileId: old.profile_id,
     });
     const newMeta = spawnNode({
         kind: old.kind,
@@ -94,6 +98,7 @@ export async function relaunchRoot(oldId, deps = {}) {
         cwd: old.cwd,
         name: old.kind,
         parent: null,
+        profile_id: old.profile_id,
         launch,
         modelOverride: old.model_override ?? undefined,
     });

package/dist/core/runtime/session-list-cache.d.ts

@@ -0,0 +1,33 @@
+import type { WireSessionInfo } from './broker-protocol.js';
+export declare function compactSessionSearchText(text: string): string;
+/** In-memory + file-backed cache keyed by absolute `.jsonl` path. One instance
+ *  per broker; the file is shared across brokers (last-writer-wins via atomic
+ *  rename — a lost update just costs one file's rebuild next open, never
+ *  corruption). */
+export declare class SessionListCache {
+    private readonly cacheFile;
+    private cache;
+    private loaded;
+    private persisting;
+    private persistAgain;
+    private persistTimer;
+    constructor(cacheFile: string);
+    /** Fire-and-forget warm of the cwd scope at broker start, so the first
+     *  `/resume` open after this broker launches is already warm. The cold scan
+     *  streams each file via readline (yields per chunk), so it never blocks the
+     *  broker loop — pre-warming beats worker threads here. Errors are swallowed
+     *  by the same paths that guard a normal open. */
+    prewarm(sessionDir: string): void;
+    /** Sessions for one cwd's session dir (the picker's default `cwd` scope). */
+    listDir(sessionDir: string): Promise<WireSessionInfo[]>;
+    /** Sessions across every cwd's dir under the sessions root (`all` scope). */
+    listAll(sessionsRoot: string): Promise<WireSessionInfo[]>;
+    private build;
+    private ensureLoaded;
+    /** Coalesce persists onto a single trailing timer so the tens-of-MB
+     *  `JSON.stringify` never runs on the reply path and rapid opens write once. */
+    private schedulePersist;
+    /** Atomic write (temp + rename) so a concurrent reader never sees a partial
+     *  file. Coalesces overlapping writes into one trailing flush. */
+    private persist;
+}