@north-light/crouter 0.3.269 → 0.3.271

package/dist/daemon/reconcilers/node-lifecycle/freeze-lane.js

@@ -83,9 +83,9 @@ export class FreezeLaneReconciler {
         const id = entry.row.node_id;
         try {
             if (entry.enact === 'thaw')
-                return this.enactThaw(entry.row);
+                return await this.enactThaw(entry.row);
             if (entry.enact === 'idle-release')
-                return this.enactIdleRelease(now, entry.row);
+                return await this.enactIdleRelease(now, entry.row);
             // The SAME policy table an exit event runs, so tick recovery and exit
             // recovery can never diverge. It relaunches through
             // `reviveNode(capacity: 'freeze')`, which freezes the row when the ledger
@@ -106,17 +106,17 @@ export class FreezeLaneReconciler {
             return 'skipped';
         }
     }
-    enactThaw(row) {
+    async enactThaw(row) {
         if (row.lifecycle === 'resident' && getNode(row.node_id)?.pi_session_id != null && !hasPendingWake(row.node_id)) {
             transition(row.node_id, 'release');
             clearFrozen(row.node_id);
             return 'skipped';
         }
-        return reviveNode(row.node_id, { resume: true, capacity: 'freeze', recovery: true }).outcome === 'frozen'
+        return (await reviveNode(row.node_id, { resume: true, capacity: 'freeze', recovery: true })).outcome === 'frozen'
             ? 'frozen'
             : 'launched';
     }
-    enactIdleRelease(now, row) {
+    async enactIdleRelease(now, row) {
         const id = row.node_id;
         const cursorNow = readCursor(id);
         const prior = this.relaunchState.get(id);
@@ -147,7 +147,7 @@ export class FreezeLaneReconciler {
         // A relaunch the broker cap froze got no slot and therefore proved nothing
         // about this delivery, so it must not spend an attempt: only a launch that
         // actually happened advances the episode toward exhaustion.
-        if (reviveNode(id, { resume: true, capacity: 'freeze' }).outcome === 'frozen')
+        if ((await reviveNode(id, { resume: true, capacity: 'freeze' })).outcome === 'frozen')
             return 'frozen';
         this.relaunchState.set(id, { cursor: cursorNow, attempts: attempts + 1, lastAttempt: now });
         emitEvent({

package/dist/hook-authoring.d.ts

@@ -6,6 +6,23 @@ export interface HookContext {
     cwd: string;
     providedParams: string[];
 }
+export interface LifecycleHookNode {
+    id: string;
+    name: string;
+    kind: string;
+    mode: string;
+    lifecycle: string;
+    cwd: string;
+    nodeDir: string;
+    contextDir: string;
+    jobDir: string;
+    reportsDir: string;
+}
+export interface LifecycleHookRuntime {
+    isBirth: boolean;
+    canvasHome: string;
+    profile: string | null;
+}
 interface HookRequestBase {
     protocolVersion: 1;
     op: string;
@@ -26,7 +43,20 @@ export interface AfterHookRequest extends HookRequestBase {
 export interface ReplaceHookRequest extends HookRequestBase {
     phase: 'replace';
 }
-export type HookRequest = BeforeHookRequest | AfterHookRequest | ReplaceHookRequest;
+/** Lifecycle handlers run on every matching event. They must be idempotent because `node:start` fires for birth and every revive. */
+export interface LifecycleHookRequest {
+    protocolVersion: 1;
+    op: string;
+    event: 'node:start';
+    phase: 'on';
+    operationId: string;
+    node: LifecycleHookNode;
+    runtime: LifecycleHookRuntime;
+    context: {
+        cwd: string;
+    };
+}
+export type HookRequest = BeforeHookRequest | AfterHookRequest | ReplaceHookRequest | LifecycleHookRequest;
 export interface HookSuccess {
     protocolVersion: 1;
     ok: true;

package/dist/hook-authoring.js

@@ -239,18 +239,40 @@ function concatBytes(chunks, total) {
 function validateRequest(value) {
     if (!isRecord(value))
         return invalid('request must be an object');
-    if (!hasOnlyKeys(value, ['protocolVersion', 'op', 'phase', 'command', 'operationId', 'input', 'context', 'result'])) {
-        return invalid('request contains unknown fields');
-    }
     if (value['protocolVersion'] !== 1)
         return invalid('unsupported hook protocol version');
     if (typeof value['op'] !== 'string' || value['op'] === '')
         return invalid('op must be a non-empty string');
-    if (!isStringArray(value['command']) || value['command'].length === 0)
-        return invalid('command must be a non-empty string array');
     if (typeof value['operationId'] !== 'string' || !/^[0-9a-f]{32}$/.test(value['operationId'])) {
         return invalid('operationId must be a 32-character lowercase hexadecimal string');
     }
+    if (value['phase'] === 'on') {
+        if (!hasOnlyKeys(value, ['protocolVersion', 'op', 'event', 'phase', 'operationId', 'node', 'runtime', 'context']))
+            return invalid('lifecycle request contains unknown fields');
+        if (value['event'] !== 'node:start')
+            return invalid('unsupported lifecycle event');
+        if (!isLifecycleNode(value['node']))
+            return invalid('lifecycle request node contains invalid fields');
+        if (!isLifecycleRuntime(value['runtime']))
+            return invalid('lifecycle request runtime contains invalid fields');
+        if (!isLifecycleContext(value['context']))
+            return invalid('lifecycle request context must contain cwd');
+        return valid({
+            protocolVersion: 1,
+            op: value['op'],
+            event: 'node:start',
+            phase: 'on',
+            operationId: value['operationId'],
+            node: value['node'],
+            runtime: value['runtime'],
+            context: value['context'],
+        });
+    }
+    if (!hasOnlyKeys(value, ['protocolVersion', 'op', 'phase', 'command', 'operationId', 'input', 'context', 'result'])) {
+        return invalid('request contains unknown fields');
+    }
+    if (!isStringArray(value['command']) || value['command'].length === 0)
+        return invalid('command must be a non-empty string array');
     if (!isRecord(value['input']) || !isJson(value['input']))
         return invalid('input must be a JSON object');
     if (!isContext(value['context']))
@@ -317,6 +339,21 @@ function isContext(value) {
         && typeof value['cwd'] === 'string'
         && isStringArray(value['providedParams']);
 }
+function isLifecycleContext(value) {
+    return isRecord(value) && hasOnlyKeys(value, ['cwd']) && typeof value['cwd'] === 'string';
+}
+function isLifecycleNode(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['id', 'name', 'kind', 'mode', 'lifecycle', 'cwd', 'nodeDir', 'contextDir', 'jobDir', 'reportsDir'])
+        && ['id', 'name', 'kind', 'mode', 'lifecycle', 'cwd', 'nodeDir', 'contextDir', 'jobDir', 'reportsDir'].every((field) => typeof value[field] === 'string');
+}
+function isLifecycleRuntime(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['isBirth', 'canvasHome', 'profile'])
+        && typeof value['isBirth'] === 'boolean'
+        && typeof value['canvasHome'] === 'string'
+        && (typeof value['profile'] === 'string' || value['profile'] === null);
+}
 function isHookError(value) {
     return isRecord(value)
         && hasOnlyKeys(value, ['code', 'message', 'field', 'next'])

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export type { CloseNodeResult } from './core/runtime/close.js';
 export { appendInbox } from './core/feed/inbox.js';
 export type { InboxEntry, InboxTier, InboxKind } from './core/feed/inbox.js';
 export { appendSituationalContext } from './core/runtime/situational-context.js';
+export { isTurnInternal } from './core/runtime/turn-visibility.js';
 export { getNode, listNodes } from './core/canvas/canvas.js';
 export { nodeDir } from './core/canvas/paths.js';
 export type { NodeMeta, NodeRow, NodeStatus, Lifecycle, Mode, } from './core/canvas/types.js';

package/dist/index.js

@@ -21,6 +21,9 @@ export { appendInbox } from './core/feed/inbox.js';
 // upsert-only, narrow surface so an external composer (e.g. Hearth) never needs to
 // learn the storage file itself.
 export { appendSituationalContext } from './core/runtime/situational-context.js';
+// In-process extensions use crouter's admitted turn classification rather than
+// attempting to reconstruct origin and route state independently.
+export { isTurnInternal } from './core/runtime/turn-visibility.js';
 // ── Canvas reads ─────────────────────────────────────────────────────────
 export { getNode, listNodes } from './core/canvas/canvas.js';
 export { nodeDir } from './core/canvas/paths.js';

package/dist/pi-extensions/canvas-stamp.js

@@ -18,7 +18,7 @@
 // join is by `msgTs`, so tree position carries no meaning here.
 import { envNodeId } from '../shared/env.js';
 import { crtrVersion } from '../shared/crtr-version.js';
-import { claimMessageOrigin, drainStampExt, hasPendingStampExt, } from '../core/runtime/stamp/channel.js';
+import { claimMessageAnnouncement, drainStampExt, hasPendingStampExt, } from '../core/runtime/stamp/channel.js';
 import { CRTR_STAMP_CUSTOM_TYPE, latestSessionStamp, STAMP_SCHEMA_VERSION, } from '../core/runtime/stamp/protocol.js';
 /** Plain text of a message's content (string or content blocks). */
 function messageText(content) {
@@ -61,10 +61,10 @@ export function registerCanvasStamp(pi) {
             return;
         const msgTs = message.timestamp;
         if (message.role === 'user') {
-            const origin = claimMessageOrigin(messageText(message.content));
+            const announcement = claimMessageAnnouncement(messageText(message.content));
             pi.appendEntry(CRTR_STAMP_CUSTOM_TYPE, envelope('message', {
                 msgTs,
-                ...(origin === null ? {} : { origin }),
+                ...(announcement === null ? {} : announcement),
             }));
             return;
         }

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/dist/shared/generated-context.d.ts

@@ -11,8 +11,7 @@ export declare const STALL_REPROMPT: string;
 /** The daemon's parking mandate: the last turn of a conversation the unattended
  *  clock is concluding. Delivered live, wrapped in a `park` runtime card. It
  *  governs both the node's durable inheritance and reader-facing output:
- *  one update for subscribers and history, then a silent stop with no assistant
- *  prose for an external channel to relay.
+ *  one update for subscribers and history, then a brief completion reply.
  *
  *  The durable inheritance shares a CONTRACT with `node yield`'s pre-invocation
  *  guide (roadmap current, short and shrinking; context dir for in-progress

package/dist/shared/generated-context.js

@@ -16,8 +16,7 @@ export const STALL_REPROMPT = "You've stopped but you're not waiting on anyone a
 /** The daemon's parking mandate: the last turn of a conversation the unattended
  *  clock is concluding. Delivered live, wrapped in a `park` runtime card. It
  *  governs both the node's durable inheritance and reader-facing output:
- *  one update for subscribers and history, then a silent stop with no assistant
- *  prose for an external channel to relay.
+ *  one update for subscribers and history, then a brief completion reply.
  *
  *  The durable inheritance shares a CONTRACT with `node yield`'s pre-invocation
  *  guide (roadmap current, short and shrinking; context dir for in-progress
@@ -28,8 +27,8 @@ export const PARK_SUMMARY_PROMPT = 'This conversation has been idle with nothing
     + '2. Rewrite `$CRTR_CONTEXT_DIR/roadmap.md` for a fresh context window. This is the only handoff document a later fresh cycle receives in full. Preserve the current goal and exit criteria when they still apply, then state the present outcome; what remains or is blocked; decisions or questions still open; exact recovery handles for in-flight state; and the first safe move on return. Keep strategy and present state, not a transcript recap. Delete stale and completed steps instead of marking them done; the roadmap should stay short and shrink. Write a minimal one now if none exists.\n\n'
     + '3. Put supporting material in your context directory only when the roadmap would become bulky without it. Rewrite existing living documents rather than leave superseded versions. Name every supporting file the next cycle must read from the roadmap and say what it is for—the revive shows filenames but does not inject their contents. Task state, identifiers, and recovery detail belong here, not in memory.\n\n'
     + '4. Use memory only for a non-obvious, reusable lesson that should survive this task and is not already recorded. Read `crtr memory write -h`, find before writing, and choose the narrowest scope that will reach the next agent who needs it. Do not put a conversation recap, task status, recovery handles, or facts already captured in code or docs into memory.\n\n'
-    + '5. Push exactly one regular update with `crtr push update --tier deferred`, never `crtr push final`. Write it for subscribers and history, not as a second roadmap. Its first line must stand alone as the current outcome, blocker, or decision that matters; then include only unfinished work, a needed decision, and concrete handles a subscriber may need. This concludes the conversation; it does not finish the mandate.\n\n'
-    + '6. Keep this entire turn silent in the conversation: produce no assistant prose before, between, or after tool calls, and do not narrate the work. Once every required tool call has finished, end the response immediately without emitting any text, sign-off, summary, acknowledgement, or other visible content by emitting the `stop` token with no text. The deferred update from step 5 is the only reader-facing conclusion. A later message reopens you on a fresh context window grounded in your goal and roadmap, so the inheritance you leave now is what you get back.';
+    + '5. Push exactly one regular update with `crtr push update --tier deferred`, never `crtr push final`. Write for someone who has not seen this conversation: name the work in plain terms, say where it stands, and say what remains or is blocked. Put the current outcome in the first line; include only needed decisions and recovery handles. This concludes the conversation, not the mandate.\n\n'
+    + '6. When finished, reply with exactly `done`.';
 /** Static recovery prompts shared by the broker producer and display classifier. */
 export const AUTH_FAULT_RECOVERY_BODY = 'Provider credentials were just updated (a new login landed). Your previous turn stopped on a provider authentication failure. Continue from where you left off and retry the work that failed.';
 export const CONNECTION_FAULT_RECOVERY_BODY = 'The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.269",
+  "version": "0.3.271",
   "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.269",
+  "version": "0.3.271",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.269",
+      "version": "0.3.271",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {