@north-light/crouter 0.3.276 → 0.3.277

package/dist/core/__tests__/integration/command-plugins.test.js

@@ -821,9 +821,9 @@ describe('typed validation issues', () => {
 describe('plugin help addenda', () => {
     const gate = (paths) => ({
         reservedCoreNames: RESERVED,
-        coreCommandPaths: new Set(paths),
+        coreCommandPaths: () => Promise.resolve(new Set(paths)),
     });
-    test('a helpAddenda entry survives validation and is collected attributed to its plugin', () => {
+    test('a helpAddenda entry survives validation and is collected attributed to its plugin', async () => {
         const m = commandsJson();
         m['helpAddenda'] = { cron: 'Gate on the device: exit 75 parks the occurrence.' };
         installPlugin(userRoot, 'northlight-fixture', { manifest: m });
@@ -833,12 +833,12 @@ describe('plugin help addenda', () => {
         assert.equal(v.issues.length, 0, JSON.stringify(v.issues));
         assert.deepEqual(v.manifest?.helpAddenda, { cron: 'Gate on the device: exit 75 parks the occurrence.' });
         // The help-render lookup: attributed, and empty for an unaddended path.
-        assert.deepEqual(collectHelpAddenda('cron', gate(['cron', 'node']), emptyStart), [
+        assert.deepEqual(await collectHelpAddenda('cron', gate(['cron', 'node']), emptyStart), [
             { plugin: 'northlight-fixture', text: 'Gate on the device: exit 75 parks the occurrence.' },
         ]);
-        assert.deepEqual(collectHelpAddenda('node', gate(['cron', 'node']), emptyStart), []);
+        assert.deepEqual(await collectHelpAddenda('node', gate(['cron', 'node']), emptyStart), []);
     });
-    test('a key naming no core command path fails the strict gate and renders nothing, even beside a valid key', () => {
+    test('a key naming no core command path fails the strict gate and renders nothing, even beside a valid key', async () => {
         const m = commandsJson();
         m['helpAddenda'] = {
             cron: 'a valid target beside the typo',
@@ -860,7 +860,7 @@ describe('plugin help addenda', () => {
         // The render lookup reproduces the GATE verdict, not the compose one: the
         // rejected map contributes nothing — including its valid key — so render
         // can never show what the install report said was rejected.
-        assert.deepEqual(collectHelpAddenda('cron', gate(['cron', 'cron add']), emptyStart), []);
+        assert.deepEqual(await collectHelpAddenda('cron', gate(['cron', 'cron add']), emptyStart), []);
     });
     test('an installed addendum renders through the real help path as an attributed block', async () => {
         const m = commandsJson();

package/dist/core/command-manifests/manifest.d.ts

@@ -29,8 +29,10 @@ export declare function validateCommandManifest(raw: unknown, options: {
      *  (install, bundle parse, doctor/inspect reports) so a helpAddenda key
      *  naming no core command fails there — and by the help-render lookup
      *  (`collectHelpAddenda`), which reproduces the gate's verdict so render
-     *  and ingress report can never disagree. Omitted only on the tolerant
-     *  compose path, where mounting ignores addenda entirely. */
+     *  and ingress report can never disagree. Omitted on the tolerant compose
+     *  path, where mounting ignores addenda entirely, and on that lookup's
+     *  claimant pass, which only needs to know whether any addendum targets the
+     *  rendered path at all. */
     coreCommandPaths?: ReadonlySet<string>;
     /** A repository fragment attaches roots below an existing extensible branch. */
     extensionFragment?: boolean;

package/dist/core/command-plugins/help-addenda.d.ts

@@ -5,8 +5,17 @@ export interface HelpAddendum {
 /** Collect every enabled plugin's addendum targeting `commandPath` (the
  *  space-joined walked path, e.g. "cron add"), in plugin-name order. `gate`
  *  carries the strict-validation inputs the install/bundle gates use; the
- *  help renderer already holds both (build-root exports them). */
+ *  help renderer already holds both (build-root exports them).
+ *
+ *  `coreCommandPaths` arrives as a thunk because producing that set walks EVERY
+ *  core subtree — the whole command tree loaded on a path that renders one
+ *  leaf's help. So the claimant pass below runs the SAME validator without it:
+ *  the core path set can only reject an addendum, never introduce one, so a
+ *  commandPath no manifest claims tolerantly claims none under the gate either,
+ *  and the expensive input is never forced. Claimants then re-validate strictly,
+ *  reproducing the gate's exact verdict — a manifest the gate rejects renders
+ *  nothing, including its valid keys. */
 export declare function collectHelpAddenda(commandPath: string, gate: {
     reservedCoreNames: ReadonlySet<string>;
-    coreCommandPaths: ReadonlySet<string>;
-}, startDir?: string, profileId?: string | null): HelpAddendum[];
+    coreCommandPaths: () => Promise<ReadonlySet<string>>;
+}, startDir?: string, profileId?: string | null): Promise<HelpAddendum[]>;

package/dist/core/command-plugins/help-addenda.js

@@ -15,13 +15,26 @@ import { effectiveCommandPlugins, validatePluginCommands } from './discovery.js'
 /** Collect every enabled plugin's addendum targeting `commandPath` (the
  *  space-joined walked path, e.g. "cron add"), in plugin-name order. `gate`
  *  carries the strict-validation inputs the install/bundle gates use; the
- *  help renderer already holds both (build-root exports them). */
-export function collectHelpAddenda(commandPath, gate, startDir, profileId) {
+ *  help renderer already holds both (build-root exports them).
+ *
+ *  `coreCommandPaths` arrives as a thunk because producing that set walks EVERY
+ *  core subtree — the whole command tree loaded on a path that renders one
+ *  leaf's help. So the claimant pass below runs the SAME validator without it:
+ *  the core path set can only reject an addendum, never introduce one, so a
+ *  commandPath no manifest claims tolerantly claims none under the gate either,
+ *  and the expensive input is never forced. Claimants then re-validate strictly,
+ *  reproducing the gate's exact verdict — a manifest the gate rejects renders
+ *  nothing, including its valid keys. */
+export async function collectHelpAddenda(commandPath, gate, startDir, profileId) {
     if (commandPath.length === 0)
         return [];
+    const claimants = effectiveCommandPlugins(startDir, profileId).filter((plugin) => validatePluginCommands(plugin, gate.reservedCoreNames).manifest?.helpAddenda?.[commandPath] !== undefined);
+    if (claimants.length === 0)
+        return [];
+    const coreCommandPaths = await gate.coreCommandPaths();
     const out = [];
-    for (const plugin of effectiveCommandPlugins(startDir, profileId)) {
-        const text = validatePluginCommands(plugin, gate.reservedCoreNames, gate.coreCommandPaths).manifest?.helpAddenda?.[commandPath];
+    for (const plugin of claimants) {
+        const text = validatePluginCommands(plugin, gate.reservedCoreNames, coreCommandPaths).manifest?.helpAddenda?.[commandPath];
         if (text !== undefined)
             out.push({ plugin: plugin.name, text });
     }

package/dist/core/command.js

@@ -209,9 +209,9 @@ async function renderNodeWithAddenda(node, path, focusedFlag) {
         import('./command-plugins/help-addenda.js'),
         import('../build-root.js'),
     ]);
-    const addenda = collectHelpAddenda(path.join(' '), {
+    const addenda = await collectHelpAddenda(path.join(' '), {
         reservedCoreNames: new Set(SUBTREE_NAMES),
-        coreCommandPaths: await coreCommandPaths(),
+        coreCommandPaths,
     });
     return body + addenda.map((a) => `\n\n<plugin-help plugin="${a.plugin}">\n${a.text}\n</plugin-help>`).join('');
 }

package/dist/daemon/reconcilers/live-obligation.d.ts

@@ -20,8 +20,9 @@ export declare function hasHumanViewer(nodeId: string): boolean;
 /** What parking an unattended node actually amounts to — the one rule both the
  *  live-broker park clock and the lifecycle tick apply.
  *
- *  `release` — something can still wake it, or a person is watching it, so
- *              parking is a pause.
+ *  `release` — something can still wake it, a person is watching it, or a
+ *              fatal provider fault prevents its engine from completing the
+ *              summary turn; parking is a pause.
  *  `park`    — a resident with nothing left to wake it has completed its
  *              conversation, and the row becomes prunable history. The live
  *              clock asks it for a summary turn first; this verdict is what

package/dist/daemon/reconcilers/live-obligation.js

@@ -6,6 +6,7 @@ import { readOutputRequest } from '../../core/runtime/structured-output.js';
 import { focusOf } from '../../core/runtime/placement.js';
 import { hasAttachedBrokerViewers } from '../../core/runtime/broker/client-registry.js';
 import { fanDoctrineWake } from '../../core/runtime/close.js';
+import { readFault } from '../../core/runtime/fault.js';
 import { transition } from '../../core/runtime/lifecycle.js';
 /** Durable work that requires a node to remain automatically wakeable. */
 export function hasLiveObligation(nodeId) {
@@ -50,6 +51,9 @@ export function parkEvent(nodeId, lifecycle) {
         return 'release';
     if (hasLiveObligation(nodeId))
         return 'release';
+    const fault = readFault(nodeId);
+    if (fault?.link === 'pi→provider' && fault.retry.disposition === 'fatal')
+        return 'release';
     if (lifecycle === 'resident')
         return hasUnseenWakeMail(nodeId) ? 'release' : 'park';
     if (readInboxSince(nodeId, readCursor(nodeId)).length > 0)

package/dist/types.d.ts

@@ -311,11 +311,11 @@ export interface ScopeConfig {
     /** Fold every SETTLED tool call in the attach viewer down to its single call
      *  line (`/fold-tools`, Alt+C → z → f). A tool still running is never folded —
      *  it folds itself once it settles. Toggling it in a viewer writes back here,
-     *  so the choice carries into later chats and later viewers. Default false. */
+     *  so the choice carries into later chats and later viewers. Default true. */
     fold_finished_tools: boolean;
     /** Replace completed folded tool-call groups with a broker-generated one-line
      * summary when one is available. Pending and failed groups stay as calls.
-     * Default false. */
+     * Default true. */
     summarize_tool_calls: boolean;
     /** Show individual memory reads and edited files in a folded tool recap.
      * Off shows the compact activity-count line instead. Default true. */

package/dist/types.js

@@ -97,8 +97,8 @@ export function defaultScopeConfig() {
         live_cycles: DEFAULT_LIVE_CYCLES,
         condensed_history: DEFAULT_CONDENSED_HISTORY,
         bash_tool_purpose: true,
-        fold_finished_tools: false,
-        summarize_tool_calls: false,
+        fold_finished_tools: true,
+        summarize_tool_calls: true,
         detailed_tool_recaps: true,
         keybindings: {},
         tmux_passthrough: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.276",
+  "version": "0.3.277",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",
@@ -70,6 +70,8 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
+    "activate": "npm run build && npm run install-runtime && crtr sys daemon restart",
+    "activate:pull": "git pull && npm install && npm run activate",
     "build:api": "tsc -p packages/crouter-api/tsconfig.json",
     "typecheck:pi-packages": "npx tsc -p src/builtin-pi-packages/pi-crtr-extensions/tsconfig.json",
     "test:build-output": "node scripts/build-concurrency-test.mjs",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.276",
+  "version": "0.3.277",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.276",
+      "version": "0.3.277",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {