@north-light/crouter 0.3.248 → 0.3.250

package/README.md

@@ -45,5 +45,5 @@ To opt out of the bootstrap (e.g. in CI), set `CRTR_NO_BOOTSTRAP=1`.
 The node runtime hosts the [pi coding agent](https://pi.dev) in each broker. To set your pi install up the way crouter's author runs it, add these to the `packages` array in `~/.pi/agent/settings.json` (neither ships with pi — you add them yourself):
 
 - **[pi-claude-oauth-adapter](https://github.com/minzique/dotfiles-agents/tree/main/packages/pi-claude-oauth-adapter)** — third-party npm package; Anthropic OAuth / Claude Code compatibility adapter for pi. Install with `"npm:pi-claude-oauth-adapter"`.
-- **pi-crtr-extensions** — crtr's engine-side pi extensions (crtr help-gate, slash-command surfacing, provider rotation, frontmatter rules, statusline). Bundled in this repo at `src/builtin-pi-packages/pi-crtr-extensions` and wired into `~/.pi/agent/settings.json` automatically by `crtr sys setup` — nothing to install separately.
+- **pi-crtr-extensions** — crtr's engine-side pi extensions (crtr help-gate, slash-command surfacing, provider rotation, frontmatter rules). Bundled in this repo at `src/builtin-pi-packages/pi-crtr-extensions` and wired into `~/.pi/agent/settings.json` automatically by `crtr sys setup` — nothing to install separately.
 

package/dist/api/__tests__/integration/client.test.js

@@ -1,6 +1,6 @@
 // client.test.ts — regression for issue #516: a cold-start `/healthz` timeout
 // used to throw a bare `daemon_unavailable` message that discarded the actual
-// startup failure (the tail of crtrd.err). `coldStartTimeoutMessage` is the
+// startup failure (the tail of crtrd.log). `coldStartTimeoutMessage` is the
 // pure composition `handleColdSocket` uses on timeout; this proves an injected
 // diagnostic is appended (not dropped) and that a missing/empty diagnostic
 // still falls back to the original bare message unchanged. `safeColdStartDiagnostic`
@@ -11,19 +11,19 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createServer } from 'node:http';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { coldStartTimeoutMessage, CrtrClient, safeColdStartDiagnostic } from '../../client.js';
 import { ApiError } from '../../errors.js';
 test('coldStartTimeoutMessage appends a present diagnostic to the base message', () => {
-    const msg = coldStartTimeoutMessage('crtrd.err (tail):\nError: bind EADDRINUSE');
+    const msg = coldStartTimeoutMessage('crtrd.log (tail):\nError: bind EADDRINUSE');
     assert.match(msg, /crtrd did not start/);
-    assert.match(msg, /crtrd\.err \(tail\):\nError: bind EADDRINUSE/);
+    assert.match(msg, /crtrd\.log \(tail\):\nError: bind EADDRINUSE/);
 });
 test('coldStartTimeoutMessage falls back to the bare message when no diagnostic is available', () => {
-    assert.equal(coldStartTimeoutMessage(undefined), 'crtrd did not start; run `crtr sys daemon start` and check crtrd.err.');
-    assert.equal(coldStartTimeoutMessage(''), 'crtrd did not start; run `crtr sys daemon start` and check crtrd.err.');
+    assert.equal(coldStartTimeoutMessage(undefined), 'crtrd did not start; run `crtr sys daemon start` and check crtrd.log.');
+    assert.equal(coldStartTimeoutMessage(''), 'crtrd did not start; run `crtr sys daemon start` and check crtrd.log.');
 });
 function startDelayedHealthzServer(socketPath, delayMs) {
     const server = createServer((_req, res) => {
@@ -85,6 +85,27 @@ test('a hang-up mid-mutation reports daemon_restarting, not daemon_unavailable',
         rmSync(dir, { recursive: true, force: true });
     }
 });
+test('a non-socket cold-start path surfaces its diagnostic after autostart times out', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'crtr-client-nonsocket-'));
+    const socketPath = join(dir, 'crtrd.sock');
+    mkdirSync(socketPath);
+    const diagnostic = 'crtrd.log (tail):\napi.server.failed: EADDRINUSE';
+    const client = new CrtrClient({
+        socketPath,
+        autostart: true,
+        onColdSocket: async () => { },
+        coldStartPollWindowMs: 50,
+        coldStartDiagnostic: () => diagnostic,
+    });
+    try {
+        await assert.rejects(() => client.healthz(), (error) => error instanceof ApiError
+            && error.code === 'daemon_unavailable'
+            && error.message.includes(diagnostic));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 test('cliClient-style cold start fails loud when the injected poll window is shorter than the (valid) startup delay', async () => {
     const dir = mkdtempSync(join(tmpdir(), 'crtr-client-coldstart-'));
     const socketPath = join(dir, 'crtrd.sock');
@@ -132,7 +153,7 @@ test('safeColdStartDiagnostic returns undefined for an absent hook', () => {
     assert.equal(safeColdStartDiagnostic(undefined), undefined);
 });
 test('safeColdStartDiagnostic returns the hook result when it succeeds', () => {
-    assert.equal(safeColdStartDiagnostic(() => 'crtrd.err (tail):\nboom'), 'crtrd.err (tail):\nboom');
+    assert.equal(safeColdStartDiagnostic(() => 'crtrd.log (tail):\nboom'), 'crtrd.log (tail):\nboom');
 });
 test('safeColdStartDiagnostic treats a THROWING hook as absent, not a propagated error', () => {
     assert.equal(safeColdStartDiagnostic(() => {

package/dist/api/client.d.ts

@@ -39,7 +39,7 @@ export interface CrtrClientOptions {
     onColdSocket?: () => Promise<void>;
     /** Injected cold-start diagnostic. Called ONLY when the bounded
      *  `/healthz` poll times out after `onColdSocket`, so the caller can attach
-     *  operator-useful context (e.g. a bounded tail of crtrd's stderr log) to the
+     *  operator-useful context (e.g. a bounded tail of `crtrd.log`) to the
      *  `daemon_unavailable` error instead of it staying a bare message. Must
      *  return synchronously and cheaply — it runs on the failure path, not the
      *  happy path. A thrown/undefined result is treated as "no diagnostic". */

package/dist/api/client.js

@@ -668,7 +668,7 @@ export class CrtrClient {
         if (this.socketPath === undefined)
             return false;
         const code = err?.code;
-        return code === 'ECONNREFUSED' || code === 'ENOENT';
+        return code === 'ECONNREFUSED' || code === 'ENOENT' || code === 'ENOTSOCK';
     }
     /** A connection torn down MID-request (Node's "socket hang up" / a broken
      *  pipe) — as distinct from a refused connect, which means nothing is
@@ -817,7 +817,7 @@ function sleep(ms) {
  *  design) purely so the regression test can assert the composition without
  *  waiting out the real poll window. */
 export function coldStartTimeoutMessage(diagnostic) {
-    const base = 'crtrd did not start; run `crtr sys daemon start` and check crtrd.err.';
+    const base = 'crtrd did not start; run `crtr sys daemon start` and check crtrd.log.';
     return diagnostic !== undefined && diagnostic !== '' ? `${base}\n${diagnostic}` : base;
 }
 /** Invoke the injected `coldStartDiagnostic` hook, treating a THROW the same

package/dist/api/dto/lifecycle.d.ts

@@ -47,6 +47,9 @@ export interface ReviveAllResultDTO {
  *  from edges; the flag only opts out of cascading descendants. */
 export interface CloseRequest {
     cascade?: boolean;
+    /** PID of the shell that invoked this close. The daemon excludes this process
+     *  and its descendants from broker teardown so a node can close itself. */
+    caller_pid?: number;
     /** Root close disposition: `true` finalizes the root to `done` (the browse `x`
      *  "finish" semantics); default/`false` cancels it. The cascade set (computed
      *  server-side) is torn down either way. */

package/dist/api/dto/messages.d.ts

@@ -62,6 +62,10 @@ export interface MessageResultDTO {
      *  frozen and the daemon relaunches it when one frees. The entry is durably
      *  appended either way, and delivery follows that relaunch. */
     not_revived_reason?: 'capacity_frozen';
+    /** Present only when the entry was appended ABOVE the requested tier: a
+     *  terminal target never takes the later cycle `normal`/`deferred` wait for,
+     *  so its mail is raised to the steering tier. */
+    delivered_tier?: InboxTierDTO;
     delivered_at?: IsoTime;
     /** Which channel a `delivery:'interactive'` send actually used: `'engine'`
      *  (live broker frame loop, no inbox entry) or `'inbox'` (durable fallback).

package/dist/api/dto/nodes.d.ts

@@ -36,6 +36,8 @@ export interface CreateNodeRequest {
     /** Caller-supplied short description, preserved against automatic naming. */
     description?: string;
     parent?: NodeIdDTO | null;
+    /** Node that created this request; absent for an external process. */
+    creator?: NodeIdDTO;
     root?: boolean;
     /** Lifecycle of the new node. Roots default to `resident`; managed children
      *  default to `terminal`. Use `resident` for a child that remains wakeable
@@ -165,6 +167,8 @@ export interface NodeFaultDTO {
 /** The full node view — summary ∪ identity extras ∪ edges ∪ paths. Returned by
  *  `GET /v1/nodes/{id}` and by the create/lifecycle actions that yield a node. */
 export interface NodeDetailDTO extends NodeSummaryDTO {
+    /** Node that created this node, or null when an external process did. */
+    creator: NodeIdDTO | null;
     description?: string;
     /** The namer's prose form of `description` — sentence case, punctuation intact
      *  (`NodeMeta.title`). What a surface showing this node to a person reads;

package/dist/api/dto/reports.d.ts

@@ -1,9 +1,14 @@
 import type { IsoTime, NodeIdDTO } from './common.js';
-/** Report tier — `crtr push {update,urgent,final}`. */
+/** Report kind — `crtr push {update,final}`; legacy `urgent` rows remain readable. */
 export type ReportTierDTO = 'update' | 'urgent' | 'final';
-/** `POST /v1/nodes/{id}/reports` body ({id} = the reporting node). */
+/** Delivery urgency for an update report's subscriber fan-out. */
+export type ReportDeliveryTierDTO = 'deferred' | 'normal' | 'urgent';
+/** `POST /v1/nodes/{id}/reports` body ({id} = the reporting node).
+ * `tier` is the stored report kind; `delivery_tier` is the optional inbox
+ * delivery urgency for an update's subscriber fan-out. */
 export interface PushReportRequest {
     tier: ReportTierDTO;
+    delivery_tier?: ReportDeliveryTierDTO;
     body: string;
 }
 /** Result of a push. `transitioned` is present only for `final`, which drives a

package/dist/builtin-memory/00-runtime-base/01-escalation.md

@@ -8,7 +8,7 @@ surfaces:
 ---
 
 ## When blocked, want feedback, or need the user
-Ask the user only when the work genuinely requires them: intent that stays ambiguous after you have dug, a tradeoff that is genuinely theirs, a real scope or direction change, a destructive or irreversible action, or sign-off on finished work. Settle everything the code, a tool, or a delegate can settle first — a whole goal costs a handful of asks, not a stream. Ask through the human inbox (`crtr human send -h`), then end your turn: a question posed as prose in a reply or report pings nobody, while an ask lands on their screen and its answer wakes you.
+Ask the user only when the work genuinely requires them: intent that stays ambiguous after you have dug, a tradeoff that is genuinely theirs, a real scope or direction change, a destructive or irreversible action, or sign-off on finished work. Settle everything the code, a tool, or a delegate can settle first — a whole goal costs a handful of asks, not a stream. Ask through the human inbox (`crtr human -h`), then end your turn: a question posed as prose in a reply or report pings nobody, while an ask lands on their screen and its answer wakes you.
 
 ## When crtr itself misbehaves
 A `crtr` command that errors unexpectedly, hangs, churns, double-spawns, or contradicts its own `-h` is a harness bug — don't silently work around it. Run `crtr sys feedback` to report it (`-h` for how), then continue.

package/dist/builtin-memory/05-kinds/review/01-orchestrator.md

@@ -15,3 +15,6 @@ Choose the one decomposition axis that best covers this surface: **units** (file
 Synthesize the child reports yourself into the final review output: one deduplicated, severity-normalized verdict, most important first. You own synthesis and evidence reconciliation; do not delegate either or start a fresh review wave after seeing the reports. The owner disposes findings and validates changed behavior. Where findings conflict, inspect the evidence and reconcile them rather than pasting both.
 
 Steer bug findings toward substance in synthesis: weight a traced failing path over a speculative "could break", and prune speculation no child attempted to confirm rather than forwarding it. Code-quality findings are observable facts and carry no such burden. A child's security concern meets the same exploit-path bar — an unknown threat-model assumption it surfaces comes out of your severity-rated verdict and becomes the question you ask.
+
+## Avoiding overcomplication
+The nodes beneath you can be nitpicky, but your job is to maintain the greater picture and vision. If a reviewer node raises an issue that is out of scope of the intent of the feature or change that's being reviewed, then it's your responsibility to not get "lost in the sauce" and just flag every issue that could possibly happen, but instead have taste as an engineer and an understanding of the broader vision.

package/dist/builtin-memory/internal/nodes-and-canvas.md

@@ -29,7 +29,7 @@ Navigate/steer: `surface node focus` (put an attach viewer for a node in your pa
 Nothing is reported automatically — the feed contains only what a node **pushes**.
 
 - `push update` — routine progress; fans a lightweight pointer to subscribers, no forced wake.
-- `push urgent` — force-wakes every subscriber (you're blocked, scope changed, an error derails the plan).
+- `push update --tier urgent` — force-wakes every subscriber (you're blocked, scope changed, an error derails the plan).
 - `push final` — the ONLY way a terminal node finishes: writes the canonical result, marks the node done, and tears down its broker. Stopping without it is not finishing. Resident/user-facing nodes stay dormant instead of finishing unless explicitly forced.
 
 A push fans a ~30-token **pointer** (a ref path), not the content; subscribers dereference lazily. When a subscriber push wakes you, **the wake message already IS the coalesced digest** — dereference the refs that matter rather than trying to re-read it. An empty feed while workers run is normal — a worker that hasn't pushed yet leaves no pointer; the wake it fires when it does push is automatic, so there's nothing to poll or check in the meantime.

package/dist/builtin-pi-packages/pi-crtr-extensions/README.md

@@ -37,7 +37,6 @@ directory's `node_modules/`.
 | `crtr-commands/` | Auto-generates a slash command per `crtr` CLI node. The tree is derived in-process from crtr's own `buildRoot()` (no subprocesses, no cache on disk); `filters.json` controls which nodes are exposed. |
 | `sysprompt-window.ts` | Registers `/sysprompt`, which runs `crtr sys context sysprompt --window` without injecting the prompt into context. |
 | `frontmatter-rules/` | Injects `.pi/rules/*.md` whose `when:` frontmatter matches a read markdown file. `.claude/rules` are migrated into substrate docs with read-glob `surfaces` entries via `crtr sys sync project-guidance`. Needs the `yaml` dep. See the `pi-frontmatter-rules` skill. |
-| `statusline.ts` | Custom status line. |
 
 Removing pi's self-referential prompt text (the harness identity sentence and
 the pi documentation block) is NOT done here. It runs as a canvas extension, so

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/provider-rotation.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createAssistantMessageEventStream, } from '@earendil-works/pi-ai';
-import { streamSimpleAnthropic, streamSimpleOpenAICodexResponses } from '@earendil-works/pi-ai/compat';
+import { streamSimple as streamAnthropicMessages } from '@earendil-works/pi-ai/api/anthropic-messages';
+import { streamSimple as streamOpenAICodexResponses } from '@earendil-works/pi-ai/api/openai-codex-responses';
 import { ANTHROPIC_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID, INVALID_REFRESH_TOKEN_BACKOFF_MS, formatStatusLine, getProviderLabel, isManagedProvider, isInvalidRefreshTokenError, addSubscription, enrichManagedLoginIdentity, markSubscriptionAuthenticationFailed, markSubscriptionRateLimited, markSubscriptionSuccess, parseRetryAfterHeader, promoteSubscription, readRotationConfig, readSubscriptionPool, refreshSubscriptionCredential, removeManagedAccount, resolveProviderCandidates, upsertSubscriptionWithUniqueAccount, } from '../../../core/subscription-state.js';
 import { readMergedLaunchConfig } from '../../../core/config.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../../core/model-routes.js';
@@ -305,9 +306,9 @@ async function reauthenticateCredential(state, providerId, credential) {
 }
 function defaultStreamForProvider(model, context, options) {
     if (model.provider === ANTHROPIC_PROVIDER_ID) {
-        return streamSimpleAnthropic(model, context, options);
+        return streamAnthropicMessages(model, context, options);
     }
-    return streamSimpleOpenAICodexResponses(model, context, options);
+    return streamOpenAICodexResponses(model, context, options);
 }
 // Indirection so tests can inject a fake per-provider stream without real network calls.
 let activeStreamForProvider = defaultStreamForProvider;

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/provider-rotation.ts

@@ -12,7 +12,8 @@ import {
   type OAuthAuth,
   type SimpleStreamOptions,
 } from '@earendil-works/pi-ai';
-import { streamSimpleAnthropic, streamSimpleOpenAICodexResponses } from '@earendil-works/pi-ai/compat';
+import { streamSimple as streamAnthropicMessages } from '@earendil-works/pi-ai/api/anthropic-messages';
+import { streamSimple as streamOpenAICodexResponses } from '@earendil-works/pi-ai/api/openai-codex-responses';
 import {
   ANTHROPIC_PROVIDER_ID,
   OPENAI_CODEX_PROVIDER_ID,
@@ -441,9 +442,9 @@ async function reauthenticateCredential(state: ProviderRotationState, providerId
 
 function defaultStreamForProvider(model: Model<any>, context: Context, options: SimpleStreamOptions | undefined): AssistantMessageEventStream {
   if (model.provider === ANTHROPIC_PROVIDER_ID) {
-    return streamSimpleAnthropic(model as Model<"anthropic-messages">, context, options);
+    return streamAnthropicMessages(model as Model<"anthropic-messages">, context, options);
   }
-  return streamSimpleOpenAICodexResponses(model as Model<"openai-codex-responses">, context, options);
+  return streamOpenAICodexResponses(model as Model<"openai-codex-responses">, context, options);
 }
 
 // Indirection so tests can inject a fake per-provider stream without real network calls.

package/dist/clients/attach/session/chrome-refresh.d.ts

@@ -8,6 +8,9 @@ export interface ChromeRefreshHooks {
     refreshRoster: () => Promise<void>;
     /** Repaint the graph overlay if open. */
     refreshGraph: () => void;
+    /** Re-read the node's persona/lifecycle/icon from canvas — a runtime
+     *  promote/reshape changes it with no broker event, so the poll catches it. */
+    refreshIdentity: () => void;
     renderFooter: () => void;
     renderExtensionWidgets: () => void;
     /** Re-poll this pane's own git context (owned by the editor chrome). */

package/dist/clients/attach/session/chrome-refresh.js

@@ -59,6 +59,7 @@ export function createChromeRefresh(ctx, hooks) {
     // source (child status flips emit no broker event) and re-poll the ask map asynchronously.
     const pollChrome = () => {
         refresh();
+        hooks.refreshIdentity();
         hooks.renderExtensionWidgets();
         hooks.pollGit();
         // R4: re-evaluate the bash-hint threshold on the existing 5s cadence, so a