@north-light/crouter 0.3.270 → 0.3.272

package/dist/commands/memory/__tests__/command-selector-and-mutation-guards.test.js

@@ -283,6 +283,42 @@ test('a failing lint returns its declared rows and fails by exit code', async ()
         process.exitCode = 0;
     }
 });
+test('initializing a repository-root store does not lint its valid namespace as misplaced', async () => {
+    const fresh = join(base, 'fresh-root');
+    mkdirSync(fresh, { recursive: true });
+    const result = (await writeLeaf.run({
+        name: 'fresh-root',
+        kind: 'knowledge',
+        dir: fresh,
+        body: 'FRESH ROOT BODY',
+        whenAndWhyToRead: 'When opening this repository, read this because it explains the workspace.',
+        surface: ['{on: workspace-open, at: content}', '{on: read, match: "./**", at: content}'],
+    }));
+    assert.equal(result.findings, undefined, JSON.stringify(result.findings));
+});
+test('a targeted read suppresses malformed descendant-store warnings', async () => {
+    const noisy = join(base, 'noisy');
+    mkdirSync(storeDir(noisy), { recursive: true });
+    writeDoc(join(home, '.crouter', 'memory', 'quiet-target.md'), 'kind: knowledge', 'QUIET TARGET BODY');
+    writeDoc(join(noisy, 'unrelated', '.crouter', 'memory', 'doc.md'), 'kind: knowledge', 'UNRELATED BODY');
+    process.chdir(noisy);
+    resetScopeCache();
+    const stderr = process.stderr;
+    const originalWrite = stderr.write;
+    const writes = [];
+    stderr.write = ((chunk) => {
+        writes.push(String(chunk));
+        return true;
+    });
+    try {
+        const read = (await readLeaf.run({ name: 'quiet-target', kind: undefined, frontmatter: false, scope: undefined, dir: undefined }));
+        assert.match(read.content, /QUIET TARGET BODY/);
+    }
+    finally {
+        stderr.write = originalWrite;
+    }
+    assert.equal(writes.some((line) => line.includes('memory store not mounted')), false, writes.join(''));
+});
 test('deleted history points at the revision holding the retained text, never a read that cannot answer', async () => {
     await deleteLeaf.run({ name: 'acme/disposable', dir: root });
     const result = (await historyLeaf.run({ name: 'acme/disposable', dir: root }));

package/dist/commands/memory/read.js

@@ -4,7 +4,7 @@ import { defineLeaf } from '../../core/command.js';
 import { CrtrError } from '../../core/errors.js';
 import { memoryExtensionEffectiveCatalog, projectEffectiveMemoryExtensions } from '../../core/memory/extensions.js';
 import { docLinkNames } from '../../core/memory/doc-link-grammar.js';
-import { createMemoryDocSnapshot, listAllMemoryDocs, loadMemoryStoreView, readMemoryDocContent, resolveMemoryCandidates, resolveMemoryDocs, } from '../../core/memory-resolver.js';
+import { ambientMemoryTarget, createMemoryDocSnapshot, listAllMemoryDocs, loadMemoryStoreView, readMemoryDocContent, resolveMemoryCandidates, resolveMemoryDocs, } from '../../core/memory-resolver.js';
 import { expandShellBlocks, hasShellBlocks, makeNodeShellRunner } from '../../core/runtime/shell-expansion.js';
 import { emptyContextExposureState, exposureTarget, loadContextExposureState, registerDocumentExposure, registerExposure, saveContextExposureState, } from '../../core/substrate/injected-store.js';
 import { dirDedupKey, docsByName, isDirName, renderDirListing } from '../../core/substrate/listings.js';
@@ -121,7 +121,10 @@ export const readLeaf = defineLeaf({
                 ...(selector.scope === undefined ? {} : { scope: selector.scope }),
                 includeDescendants: true,
             };
-            listingByName = linkByName = docsByName(listAllMemoryDocs(selector.scope, false, true));
+            // A named read must not turn malformed stores elsewhere in the corpus
+            // into warnings about the requested document. `memory lint` owns that
+            // corpus health report; resolution still includes every candidate.
+            listingByName = linkByName = docsByName(listAllMemoryDocs(selector.scope, true, true));
             try {
                 set = resolveMemoryCandidates(nameRaw, resolveOpts);
             }
@@ -190,6 +193,7 @@ export const readLeaf = defineLeaf({
             subject,
             target,
             byName: listingByName,
+            memoryTarget: ambientMemoryTarget(),
             listings: 'blocks',
             explicit: true,
         });

package/dist/commands/memory/write.js

@@ -1,12 +1,12 @@
 import { envNodeId, envProfileId } from '../../shared/env.js';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { defineLeaf } from '../../core/command.js';
 import { usage } from '../../core/errors.js';
 import { docLinkNames } from '../../core/memory/doc-link-grammar.js';
 import { lintMemoryDocument, resolvableCanonicalNames } from '../../core/memory/lint.js';
 import { descendantStoreRoots } from '../../core/nested-stores.js';
 import { projectScopeRoots } from '../../core/scope.js';
-import { loadMemoryTargetView } from '../../core/memory-resolver.js';
+import { loadMemoryTargetView, openProjectMemoryStore } from '../../core/memory-resolver.js';
 import { parsedSubstrateSurfaces } from '../../core/substrate/frontmatter-validation.js';
 import { ensureDir, realpathOrSelf, walkFiles, writeText } from '../../core/fs-utils.js';
 import { associateRepository } from '../../core/memory/repository-association.js';
@@ -187,7 +187,11 @@ export const writeLeaf = defineLeaf({
         const surfaceEntries = parsedSubstrateSurfaces(frontmatter);
         const carriesReference = docLinkNames(body).length > 0 || surfaceEntries.some((entry) => entry.on === 'memory-read');
         const carriesBootEntry = surfaceEntries.some((entry) => entry.on === 'boot');
-        const lint = lintMemoryDocument(store, path, {
+        // Initializing created the root declaration after selector resolution, so
+        // validate against a freshly described store: the stale descriptor has no
+        // repository-root association yet and would reject its valid namespace.
+        const lintStore = initializing ? openProjectMemoryStore(store.ownerDir ?? dirname(dirname(memoryDir))) : store;
+        const lint = lintMemoryDocument(lintStore, path, {
             ...(carriesReference
                 ? {
                     resolvable: resolvableCanonicalNames(loadMemoryTargetView({

package/dist/core/__tests__/canvas-inbox-watcher-hold.test.js

@@ -28,7 +28,7 @@ import { ApiError } from '../../api/errors.js';
 // debounce window before asserting, exactly as against the real 800/1000 cadence.
 const TICK_MS = 20;
 const DEBOUNCE_MS = 25;
-const SETTLE_MS = TICK_MS * 2 + DEBOUNCE_MS + 30;
+const SETTLE_MS = TICK_MS * 2 + DEBOUNCE_MS + 200;
 let origHome;
 let origNode;
 const homes = [];
@@ -302,7 +302,7 @@ describe('canvas inbox watcher — hold + idle delivery', () => {
             },
         };
         const drive = createEngineDriver({
-            registry: { sendFrame: () => undefined },
+            registry: { sendFrame: () => undefined, broadcast: () => undefined },
             replies: {},
             session: () => session,
             dispatches: { track: (promise) => promise },

package/dist/core/__tests__/helpers/harness.js

@@ -282,6 +282,7 @@ export async function createHarness(opts = {}) {
             ...cleanBaseEnv(),
             CRTR_HOME: home,
             HOME: tmpHome,
+            CRTR_RUNTIME_HOME: realRuntimeHome,
             CRTR_PI_BINARY: FAKE_PI_BINARY,
             CRTR_BROKER_ENGINE: FAKE_ENGINE,
         },

package/dist/core/__tests__/seam/broker-provider-retry.test.js

@@ -109,6 +109,8 @@ test('a managed-cooling terminal authors a rate-limit auto fault whose deadline
     seedPool('openai-codex', false);
     const child = await h.spawnHeadlessChild(parent, 'cooling terminal', { model: OPENAI_STRONG.spec });
     await h.waitFor(() => agentStartCount(child) >= 1, { label: 'initial cooling fixture turn started' });
+    const kickoffObserver = await attachUntil(child, 'observer', 'cooling-terminal-kickoff-settled', (a) => a.welcome.snapshot.state.isStreaming === false, 'cooling terminal kickoff settled');
+    kickoffObserver.close();
     const baselineStarts = agentStartCount(child);
     // A terminal managed-cooling error at agent_end: its explanatory prose avoids
     // rate-limit words entirely; the typed diagnostic alone must classify the

package/dist/core/memory-resolver.d.ts

@@ -195,7 +195,7 @@ export declare function openProjectMemoryStore(ownerDir: string): MemoryStoreDes
 /** Every store a target sees, in precedence order: node, each project store
  *  nearest-first (its enabled plugins after it), then profile, user, builtin.
  *  One real store reached twice contributes once, at its first position. */
-export declare function memoryStoresInPrecedence(target: MemoryTarget, scope?: MemoryScope, includeDescendants?: boolean): MemoryStoreDescriptor[];
+export declare function memoryStoresInPrecedence(target: MemoryTarget, scope?: MemoryScope, includeDescendants?: boolean, quiet?: boolean): MemoryStoreDescriptor[];
 /** The native (non-plugin) MOUNTED store dirs in resolution precedence.
  *  Addresses a store directly when the document itself may be absent, which is
  *  how a DELETED doc's revision log is still found: history outlives the doc,

package/dist/core/memory-resolver.js

@@ -193,7 +193,7 @@ export function openProjectMemoryStore(ownerDir) {
 /** Every store a target sees, in precedence order: node, each project store
  *  nearest-first (its enabled plugins after it), then profile, user, builtin.
  *  One real store reached twice contributes once, at its first position. */
-export function memoryStoresInPrecedence(target, scope, includeDescendants = false) {
+export function memoryStoresInPrecedence(target, scope, includeDescendants = false, quiet = false) {
     const out = [];
     const projectStores = (crtrRoot, projectMemory) => {
         out.push(projectStoreDescriptor(dirname(crtrRoot), join(crtrRoot, 'memory'), projectMemory));
@@ -211,7 +211,7 @@ export function memoryStoresInPrecedence(target, scope, includeDescendants = fal
             // nested one. They carry the neutral ceiling — no profile entry names
             // them, and descendant discovery is off for every automatic delivery path.
             if (includeDescendants) {
-                for (const root of descendantStoreRoots(annotated.map(({ root: r }) => r))) {
+                for (const root of descendantStoreRoots(annotated.map(({ root: r }) => r), quiet)) {
                     projectStores(root, NEUTRAL_PROJECT_MEMORY);
                 }
             }
@@ -438,7 +438,7 @@ function makeView(stores, docs, scope) {
  *  with its migration remedy and contributes nothing. */
 export function loadMemoryTargetView(target, opts = {}) {
     const quiet = opts.quiet ?? false;
-    const stores = memoryStoresInPrecedence(target, opts.scope, opts.includeDescendants ?? false);
+    const stores = memoryStoresInPrecedence(target, opts.scope, opts.includeDescendants ?? false, quiet);
     const docs = [];
     for (const store of stores) {
         if (store.mountStatus === 'absent')

package/dist/core/nested-stores.d.ts

@@ -9,7 +9,7 @@
  * excluding centrally gives the resolver and lint the identical call with no
  * duplicated dedupe logic.
  */
-export declare function descendantStoreRoots(ancestorRoots: string[]): string[];
+export declare function descendantStoreRoots(ancestorRoots: string[], quiet?: boolean): string[];
 /** Complete descendant-store discovery for state migrations. Unlike the
  *  interactive addressing lane, this filesystem walk has no time or depth
  *  budget, crosses embedded repositories, admits plugin-only `.crouter` roots,

package/dist/core/nested-stores.js

@@ -39,7 +39,7 @@ const cache = new Map();
  * excluding centrally gives the resolver and lint the identical call with no
  * duplicated dedupe logic.
  */
-export function descendantStoreRoots(ancestorRoots) {
+export function descendantStoreRoots(ancestorRoots, quiet = false) {
     const key = [...ancestorRoots].sort().join('\n');
     const cached = cache.get(key);
     if (cached !== undefined)
@@ -56,7 +56,9 @@ export function descendantStoreRoots(ancestorRoots) {
         owners.push(owner);
     }
     const tripBudget = (owner) => {
-        warn(`memory: nested-store discovery under ${owner} exceeded its ${TIME_BUDGET_MS}ms budget — nested stores may be missing from this listing; register deep stores explicitly (add their dirs to the selected profile's projects)`);
+        if (!quiet) {
+            warn(`memory: nested-store discovery under ${owner} exceeded its ${TIME_BUDGET_MS}ms budget — nested stores may be missing from this listing; register deep stores explicitly (add their dirs to the selected profile's projects)`);
+        }
     };
     const found = [];
     const foundSeen = new Set();

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

@@ -47,9 +47,8 @@ export interface FleetRegistry {
     get(nodeId: string): FleetEntry | undefined;
     /** The capacity count: registered brokers only, excluding reservations. */
     size(): number;
-    /** Every slot the cap accounts for — registered brokers plus in-flight
-     *  reservations (a launch that has claimed a slot but not yet registered, and
-     *  an exited broker whose exit-policy job has not yet run). */
+    /** Every slot the cap accounts for — registered brokers plus launch
+     *  reservations that have not registered yet. */
     occupancy(): number;
     /** Claim a slot for `nodeId`. True means the caller may launch; false means
      *  the cap is reached and the caller must freeze or refuse. Idempotent — a
@@ -62,9 +61,9 @@ export interface FleetRegistry {
     /** Drop an entry without policy (terminal exits + close paths). */
     forget(nodeId: string): void;
     /** Wired by `headlessBrokerHost.launch` to the handle's `exited` promise.
-     *  Removes the entry (freeing the capacity slot), then enqueues an
-     *  exit-policy job on the daemon's serial work lane — policy never runs
-     *  inline on the Node event callback (design D-3). */
+     *  Removes the entry (freeing the capacity slot), then enqueues its
+     *  observation on the daemon's serial work lane — it never runs inline on
+     *  the Node event callback (design D-3). */
     onChildExit(nodeId: string, status: FleetExitStatus): void;
     /** Test seam — delivers a synthetic exit through the SAME path as
      *  onChildExit, so fabricated-row tests drive policy without a process. */

package/dist/core/runtime/nodes.js

@@ -12,7 +12,7 @@
 //             learns when the work finishes — this seeds the subscription
 //             graph to mirror the spawn structure. A `spawned_by` audit edge
 //             is also recorded.
-import { envHomeOverride } from '../../shared/env.js';
+import { envHomeOverride, envRuntimeHomeOverride } from '../../shared/env.js';
 import { randomBytes } from 'node:crypto';
 import { mkdirSync } from 'node:fs';
 import { createNode, getNode, getRow, subscribe, recordSpawn, subscribersOf, contextDir, } from '../canvas/index.js';
@@ -206,6 +206,11 @@ export function nodeEnv(meta) {
     const home = envHomeOverride();
     if (home !== undefined && home !== '')
         env['CRTR_HOME'] = home;
+    // Propagate an explicit runtime home so broker-side `crtr` invocations use
+    // the same installed generation despite an isolated HOME.
+    const runtimeHome = envRuntimeHomeOverride();
+    if (runtimeHome !== undefined && runtimeHome !== '')
+        env['CRTR_RUNTIME_HOME'] = runtimeHome;
     // Propagate the subtree-root node id. The broker uses it to group a subtree;
     // each launch site also emits the authoritative rootOfSpine(nodeId) over this
     // passthrough.

package/dist/daemon/fleet.js

@@ -122,10 +122,7 @@ export class DaemonFleet {
     #enqueue;
     #now;
     #map = new Map();
-    /** Slots claimed but not yet held by a registered broker: a launch in flight,
-     *  or a broker that exited and whose exit-policy job has not yet decided
-     *  whether to relaunch it. Counting both against the cap is what keeps a
-     *  1:1 respawn from losing its own slot to a concurrent launcher. */
+    /** Slots claimed by launches that have not registered a broker yet. */
     #reservations = new Set();
     #lastCapacityLogAt = Number.NEGATIVE_INFINITY;
     constructor(opts) {
@@ -191,13 +188,15 @@ export class DaemonFleet {
         this.#reservations.delete(nodeId);
     }
     onChildExit(nodeId, status) {
-        // Move the slot from the registry to a reservation in ONE synchronous
-        // step: the exit-policy job about to be enqueued may relaunch this node,
-        // and holding the slot through the exit observation prevents a concurrent
-        // launch from entering before the registry reflects the exit.
+        // The real child exit is the liveness boundary. Its queued observation only
+        // records diagnostics, so it cannot retain capacity after the process is
+        // gone and make an explicit replacement look already live.
+        const meta = getNode(nodeId);
+        const launchedMs = meta?.launched_at == null ? Number.NaN : Date.parse(meta.launched_at);
+        const uptimeMs = Number.isFinite(launchedMs) ? Math.max(0, this.#now() - launchedMs) : null;
+        const consecutiveFailures = meta?.respawn_failures ?? 0;
         this.#map.delete(nodeId);
-        this.#reservations.add(nodeId);
-        this.#enqueue(() => this.#runExitPolicy(nodeId, status));
+        this.#enqueue(() => this.#emitExitObserved(nodeId, status, uptimeMs, consecutiveFailures));
     }
     deliverExit(nodeId, status) {
         this.onChildExit(nodeId, status);
@@ -223,17 +222,6 @@ export class DaemonFleet {
         return true;
     }
     dispose() { }
-    async #runExitPolicy(nodeId, status) {
-        try {
-            const launchedAt = getNode(nodeId)?.launched_at;
-            const launchedMs = launchedAt == null ? Number.NaN : Date.parse(launchedAt);
-            const uptimeMs = Number.isFinite(launchedMs) ? Math.max(0, this.#now() - launchedMs) : null;
-            this.#emitExitObserved(nodeId, status, uptimeMs, getNode(nodeId)?.respawn_failures ?? 0);
-        }
-        finally {
-            this.releaseReservation(nodeId);
-        }
-    }
     #emitExitObserved(nodeId, status, uptimeMs, consecutiveFailures) {
         emitEvent({
             level: 'info',

package/dist/shared/env.d.ts

@@ -15,6 +15,8 @@ export declare function envModelExact(): boolean;
  *  only when a caller needs the override itself — to check whether one is
  *  set, or to propagate it verbatim into a child process's env. */
 export declare function envHomeOverride(): string | undefined;
+/** The raw installed-runtime directory override, unresolved. */
+export declare function envRuntimeHomeOverride(): string | undefined;
 /** Dead-provider watchdog timeout (`CRTR_STREAM_WATCHDOG_MS`), 5 minutes by
  *  default. See `runtime/stream-watchdog.ts` for what it guards. */
 export declare function envStreamWatchdogMs(): number;

package/dist/shared/env.js

@@ -51,6 +51,10 @@ export function envModelExact() {
 export function envHomeOverride() {
     return process.env['CRTR_HOME'];
 }
+/** The raw installed-runtime directory override, unresolved. */
+export function envRuntimeHomeOverride() {
+    return process.env['CRTR_RUNTIME_HOME'];
+}
 // Tuning
 /** Generic `Number(raw)` parse with a positive-finite guard, shared by every
  *  millisecond tuning var below (each previously reimplemented this locally,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.270",
+  "version": "0.3.272",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

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