@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/core/resolver.d.ts

@@ -1,4 +1,5 @@
 import type { InstalledMarketplace, InstalledPlugin, Scope } from '../types.js';
+export declare function listInstalledPluginsInRoot(scope: Scope, scopeRootPath: string): InstalledPlugin[];
 export declare function listInstalledPlugins(scope: Scope): InstalledPlugin[];
 export declare function listAllPlugins(): InstalledPlugin[];
 export declare function findPluginByName(name: string, scope?: Scope): InstalledPlugin | null;

package/dist/core/resolver.js

@@ -1,40 +1,47 @@
 import { join } from 'node:path';
+import { CONFIG_FILE } from '../types.js';
 import { readConfig } from './config.js';
-import { listDirs, pathExists } from './fs-utils.js';
+import { listDirs, pathExists, readJsonIfExists } from './fs-utils.js';
 import { readMarketplaceManifest, readPluginManifest } from './manifest.js';
 import { InputError } from './io.js';
-import { marketplacesDir, pluginsDir, projectScopeRoot, userScopeRoot, } from './scope.js';
-export function listInstalledPlugins(scope) {
-    // The builtin scope has no scopeRoot, so pluginsDir('builtin') is null and
-    // this returns [] — builtin content is the memory substrate, not plugins.
-    const dir = pluginsDir(scope);
-    if (!dir || !pathExists(dir))
+import { marketplacesDir, projectScopeRoot, scopeRoot, userScopeRoot, } from './scope.js';
+function pluginConfigForRoot(root) {
+    const cfg = readJsonIfExists(join(root, CONFIG_FILE));
+    return cfg && cfg.plugins && typeof cfg.plugins === 'object' ? cfg.plugins : {};
+}
+export function listInstalledPluginsInRoot(scope, scopeRootPath) {
+    const dir = join(scopeRootPath, 'plugins');
+    if (!pathExists(dir))
         return [];
-    const cfg = readConfig(scope);
+    const cfg = pluginConfigForRoot(scopeRootPath);
     const out = [];
     for (const name of listDirs(dir)) {
         const root = join(dir, name);
         const manifest = readPluginManifest(root);
         if (!manifest)
             continue;
-        const entry = cfg.plugins[name];
-        let version;
-        if (entry && entry.version !== undefined)
-            version = entry.version;
-        else if (manifest.version !== undefined)
-            version = manifest.version;
+        const entry = cfg[name];
+        const version = typeof entry?.version === 'string' ? entry.version : manifest.version;
         out.push({
             name,
             scope,
             root,
             manifest,
-            enabled: entry ? entry.enabled : true,
-            sourceMarketplace: entry ? entry.source_marketplace : undefined,
+            enabled: typeof entry?.enabled === 'boolean' ? entry.enabled : true,
+            sourceMarketplace: typeof entry?.source_marketplace === 'string' ? entry.source_marketplace : undefined,
             version,
         });
     }
     return out;
 }
+export function listInstalledPlugins(scope) {
+    // The builtin scope has no scopeRoot, so this returns [] — builtin content is
+    // the memory substrate, not plugins.
+    const root = scopeRoot(scope);
+    if (!root)
+        return [];
+    return listInstalledPluginsInRoot(scope, root);
+}
 export function listAllPlugins() {
     const scopes = [];
     if (projectScopeRoot())

package/dist/core/runtime/auth-reload.d.ts

@@ -0,0 +1,7 @@
+/** Reload a LIVE node's credentials over its view.sock. Connects as an OBSERVER
+ *  (hello only — NO request_control, so an attached human keeps control through
+ *  the fan; the broker's reload_auth handler is open to any client), sends
+ *  `reload_auth`, and resolves on its ack. Rejects on the broker's `error` frame,
+ *  connect failure, a premature close, or timeout — the caller (the daemon fan)
+ *  isolates each broker so one failure never aborts the rest. */
+export declare function reloadAuthLive(nodeId: string): Promise<void>;

package/dist/core/runtime/auth-reload.js

@@ -0,0 +1,69 @@
+// auth-reload.ts — fan a live credential reload to a node's broker over its
+// view.sock, the headless sibling of the viewer's own `reload_auth` frame.
+//
+// Every broker reads the SAME shared `~/.pi/agent/auth.json`. When the user
+// `/login`s (anywhere), the broker that performed it self-reloads — but every
+// OTHER live broker keeps its stale in-memory credentials until told. The
+// daemon watches auth.json's mtime and fans this RPC to each live broker so the
+// whole canvas follows one account switch with no per-broker re-login.
+//
+// connect → hello → reload_auth → await ack. NO request_control: the broker's
+// reload_auth handler is open to any client (it's an idempotent local re-read
+// that doesn't steer the conversation), so the fan must NOT claim controller —
+// request_control ALWAYS preempts, which would silently demote any human
+// attached-and-driving a node every time /login fans canvas-wide.
+import { randomUUID } from 'node:crypto';
+import { ViewSocketClient } from './view-socket-client.js';
+/** How long to wait for the broker's `reload_auth` ack before giving up. The
+ *  reload is an instant local file read + registry refresh, and the daemon's
+ *  supervision loop awaits this on a real change — so the timeout is kept tight
+ *  to cap the worst-case stall if a broker connects but never acks. */
+const ACK_TIMEOUT_MS = 3_000;
+/** Reload a LIVE node's credentials over its view.sock. Connects as an OBSERVER
+ *  (hello only — NO request_control, so an attached human keeps control through
+ *  the fan; the broker's reload_auth handler is open to any client), sends
+ *  `reload_auth`, and resolves on its ack. Rejects on the broker's `error` frame,
+ *  connect failure, a premature close, or timeout — the caller (the daemon fan)
+ *  isolates each broker so one failure never aborts the rest. */
+export function reloadAuthLive(nodeId) {
+    return new Promise((resolve, reject) => {
+        const client = new ViewSocketClient(nodeId);
+        const clientId = randomUUID();
+        let settled = false;
+        const timer = setTimeout(() => finish(() => reject(new Error(`timed out after ${ACK_TIMEOUT_MS}ms waiting for the broker to ack the auth reload`))), ACK_TIMEOUT_MS);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        function finish(act) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                client.close();
+            }
+            catch {
+                /* best-effort */
+            }
+            act();
+        }
+        client.on('error', (err) => finish(() => reject(err)));
+        client.on('close', () => finish(() => reject(new Error('broker connection closed before it acked the auth reload'))));
+        client.on('connect', () => {
+            // Hello as OBSERVER — reload_auth is open to any client, and an observer
+            // hello never touches controllerId, so a human driving this broker keeps
+            // control through the fan. (A `controller` hello also only takes control
+            // when none is held, which is safe; observer is the more honest signal.)
+            client.send({ type: 'hello', role: 'observer', client_id: clientId });
+            client.send({ type: 'reload_auth' });
+        });
+        client.on('frame', (frame) => {
+            if (frame.type === 'ack' && frame.for === 'reload_auth' && frame.ok) {
+                finish(() => resolve());
+            }
+            else if (frame.type === 'error') {
+                finish(() => reject(new Error(frame.message)));
+            }
+        });
+        client.connect();
+    });
+}

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

@@ -1,44 +1,58 @@
-import { type WakeKind, type Wakeup } from '../canvas/index.js';
-/** Base framing — present for every node. No path baked in: the caller carries
- *  the dir in the `<crtr-context dir="…">` attribute. */
-export declare const BASE_CONTEXT_NOTE: string;
+import { type Trigger } from '../canvas/index.js';
+/** The `<project_context>` block for the files discovered from `cwd`, plus the
+ *  cwd/git environment snapshot that now rides at the end of the wrapper.
+ *  Always emits the wrapper because the environment snapshot is always present
+ *  even when no project instructions exist. Exported for testing. */
+export declare function buildProjectContextBlock(cwd: string): string;
+/** The context-directory note — names the path INLINE (no XML attribute, so it
+ *  never scopes a sibling block) and frames the dir as durable, shared scratch.
+ *  Present for every node, rendered as the `## Your context directory`
+ *  subsection of <crtr-bearings>. */
+export declare function contextDirNote(nodeId: string): string;
 /** Orchestrator-only framing: a resident orchestrator survives refresh cycles,
  *  so its context dir is also where a future cycle of itself resumes the work.
  *  Used inside the bearings block AND in the promotion guidance dump, so a
  *  promoted node gets the same note a born-orchestrator gets. */
 export declare function orchestratorContextNote(nodeId: string): string;
+/** The graph mini-map: the ancestry trunk (root first), then this node marked
+ *  `● you`, then its immediate children. Returns '' for a lone root with no
+ *  children (nothing to map). Exported for testing. */
+export declare function buildGraphMap(nodeId: string): string;
 /** The IDENTITY assertion that opens every boot intro — the load-bearing fix
  *  for the `--fork-from` impersonation bug. A fork copies the SOURCE node's
  *  entire first-person conversation into its own session, so without an explicit
  *  re-assertion the forked agent reads that copied narrative as its own and
  *  impersonates the source (it kept "monitoring itself" as a phantom child).
- *  This block names the node unambiguously. ONLY when the node IS a fork does it
- *  additionally name the source AND disown the copied first-person narrative as
- *  inherited reference material — a non-fork node's bearings are its first session
- *  entry, so there is no earlier narrative to disown (emitting a disown line there
- *  is dead weight that reads as a contradiction with no referent). Always the FIRST
- *  thing the node reads. Exported for testing. */
+ *  These lines name the node unambiguously and lead the <crtr-bearings> block
+ *  (no wrapper of their own — identity is the first prose the model reads). ONLY
+ *  when the node IS a fork do they additionally name the source AND disown the
+ *  copied first-person narrative as inherited reference material — a non-fork
+ *  node's bearings are its first session entry, so there is no earlier narrative
+ *  to disown (emitting a disown line there is dead weight that reads as a
+ *  contradiction with no referent). Also prepended to a fork's kickoff prompt in
+ *  spawn.ts. Exported for testing. */
 export declare function buildIdentityAssertion(nodeId: string): string;
-/** Why a node woke or was born, as carried from the fired wakeup row to the
+/** Why a node woke or was born, as carried from the fired trigger row to the
  *  injection seam. `ownerName` is the armer's resolved display name when it
  *  still exists (a reaped cron's armer renders as a bare id, never crashes). */
 export interface WakeOrigin {
-    /** The firing kind. The <crtr-wake> block is rendered for 'spawn' (birth) and
-     *  'bare' (revive); 'noted'/'deadline' self-mark at the message seam instead. */
-    kind: WakeKind;
-    /** The armer node id (wakeups.owner_id), or null if somehow absent. */
+    /** Which enactment birthed/woke the node — the only two action_modes that
+     *  ever route through this provenance block; inbox_message/deadline_message
+     *  self-mark via their inbox label at the message seam instead. */
+    kind: 'fresh_revive' | 'node_birth';
+    /** The armer node id (triggers.owner_id), or null if somehow absent. */
     ownerId: string | null;
     /** The armer's display name, resolved if it still exists. */
     ownerName?: string;
-    /** wakeups.created — when the wake was armed (ISO). */
+    /** triggers.created — when the trigger was armed (ISO). */
     armedAt: string;
-    /** wakeups.recur JSON when recurring, else null/undefined for a one-shot. */
+    /** triggers.recur JSON when recurring, else null/undefined for a one-shot. */
     recur?: string | null;
 }
-/** Build a WakeOrigin from a fired wakeup row, resolving the armer's display
+/** Build a WakeOrigin from a fired trigger row, resolving the armer's display
  *  name if the node still exists. The daemon calls this at fire time for the
  *  bare-revive and spawn-birth seams. */
-export declare function wakeOriginFrom(w: Wakeup): WakeOrigin;
+export declare function wakeOriginFrom(t: Trigger): WakeOrigin;
 /** The <crtr-wake> provenance block — load-bearing agent-facing prose read by
  *  every wake-born or wake-woken node. Decision-first: it leads with the fact a
  *  TIMER (not a message/event) caused this turn, names the wake kind, surfaces
@@ -52,10 +66,17 @@ export declare function wakeOriginFrom(w: Wakeup): WakeOrigin;
  *  agent cannot cheaply turn into an elapsed delta). Rendered for 'spawn' and
  *  'bare'; other kinds self-mark elsewhere. */
 export declare function buildWakeBearings(origin: WakeOrigin): string;
-/** The full boot intro: the IDENTITY assertion (always first, so it overrides
- *  any copied-in persona) followed by the `<crtr-context>` bearings block. Base
- *  framing rides for EVERY node; the across-cycles context-dir note is added
- *  ONLY for an orchestrator (by mode) — the one node whose dir a future cycle
- *  resumes from. The `<knowledge>` block carries the substrate knowledge docs
- *  + node-local docs. */
+/** The full boot intro, three top-level sections:
+ *
+ *   1. `<crtr-bearings>` — the orienting facts about THIS node: the identity
+ *      assertion (always first, so it overrides any copied-in persona), then a
+ *      `## Your place in the canvas` graph map and a `## Your context directory`
+ *      note. The across-cycles context-dir framing is added ONLY for an
+ *      orchestrator (by mode) — the one node whose dir a future cycle resumes
+ *      from.
+ *   2. `<memory kind="knowledge">` — the consultable catalog, a SIBLING of the
+ *      bearings (never nested under the context dir). Dropped when empty.
+ *   3. `<project_context>` — the AGENTS.md/CLAUDE.md instructions + the cwd/git
+ *      environment snapshot, moved OUT of the system prompt (pi's copy is
+ *      suppressed via noContextFiles in broker.ts) so it rides this message. */
 export declare function buildContextBearings(nodeId: string): string;