@north-light/crouter 0.3.252 → 0.3.253

package/dist/commands/node/lifecycle.js

@@ -109,15 +109,15 @@ const nodeClose = defineLeaf({
         return `Closed ${r['node_id']} and its exclusive subtree — ${r['count']} node(s) closed${spared > 0 ? `, ${spared} spared (still managed from outside the subtree)` : ''}.`;
     },
 });
-// node config — reconfigure a node's settings headlessly (model/lifecycle/kind/mode/name)
+// node config — reconfigure a node's settings headlessly (model/lifecycle/kind/mode/name/cwd repair)
 const NODE_CONFIG_MODEL_EFFECT = 'Model change first: a live broker switches immediately over its socket; a dormant node persists the durable model override and launch recipe for its next revive.';
 export const nodeConfig = defineLeaf({
     name: 'config',
-    description: 'reconfigure a node\'s settings headlessly — model, lifecycle (terminal/resident), kind, mode, name',
-    whenToUse: 'you want to reconfigure a node\'s settings headlessly after spawn — swap its model/provider, flip it terminal↔resident (interactable), respecialize its kind, switch base↔orchestrator mode, or rename it — without opening its viewer. The durable attribute setter; reuses the same recipes a revive reads. Use `node promote` for the opinionated self-promotion path, and `node lifecycle` for teardown actions (recycle/close/demote).',
+    description: 'reconfigure a node\'s settings headlessly — model, lifecycle (terminal/resident), kind, mode, name; repair a missing cwd',
+    whenToUse: 'you want to reconfigure a node\'s settings headlessly after spawn — swap its model/provider, flip it terminal↔resident (interactable), respecialize its kind, switch base↔orchestrator mode, or rename it — without opening its viewer. It also repairs a dormant node whose recorded cwd is gone, starting its next revive in a fresh conversation. The durable attribute setter; reuses the same recipes a revive reads. Use `node promote` for the opinionated self-promotion path, and `node lifecycle` for teardown actions (recycle/close/demote).',
     help: {
         name: 'node config',
-        summary: 'reconfigure a node\'s settings headlessly — model, lifecycle, kind, mode, name',
+        summary: 'reconfigure a node\'s settings headlessly — model, lifecycle, kind, mode, name; repair a missing cwd',
         params: [
             { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Target node id. Defaults to the node in --pane, else CRTR_NODE_ID.' },
             { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id to resolve the node from. Defaults to $TMUX_PANE.' },
@@ -140,20 +140,23 @@ export const nodeConfig = defineLeaf({
             { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Persona kind. The <kinds> list below names every top-level installable kind and when to use each; a registered sub-kind is valid too by exact path but not listed here.' },
             { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, constraint: 'Set persona mode headlessly. base is hands-on; orchestrator holds a roadmap and delegates. orchestrator seeds a roadmap scaffold if absent.' },
             { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Rename the node; if the node has a live window, also rename that viewer window.' },
+            { kind: 'flag', name: 'cwd', type: 'string', required: false, constraint: 'Repair-only replacement launch directory. Must be a non-empty absolute existing directory and used alone; the daemon accepts it only for a dormant, non-forked node with no open managed worktree whose recorded cwd is gone. Clears the saved Pi session, so the next revive starts fresh while durable node work remains.' },
         ],
         output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The reconfigured node.' },
+            { name: 'node_id', type: 'string', required: false, constraint: 'The reconfigured node, present for ordinary config changes.' },
             { name: 'model', type: 'string', required: false, constraint: 'The resolved model, present only when --model changed it.' },
             { name: 'lifecycle', type: 'string', required: false, constraint: 'The new lifecycle, present only when --lifecycle changed it.' },
             { name: 'kind', type: 'string', required: false, constraint: 'The new kind, present only when --kind changed it.' },
             { name: 'mode', type: 'string', required: false, constraint: 'The new mode, present only when --mode changed it.' },
             { name: 'name', type: 'string', required: false, constraint: 'The new name, present only when --name changed it.' },
+            { name: 'cwd', type: 'string', required: false, constraint: 'The lexically resolved replacement directory, present only after a cwd repair.' },
         ],
         outputKind: 'object',
         effects: [
             NODE_CONFIG_MODEL_EFFECT,
             'Kind, mode, and lifecycle changes rebuild the launch spec from the fresh node meta; setting mode to orchestrator seeds a roadmap scaffold if absent.',
             'Name changes update the row and, when the node already has a live window, rename that viewer window to the new full name.',
+            'A cwd repair writes only the lexically resolved cwd and clears saved Pi session pointers; the old transcript and durable node work remain untouched.',
         ],
         dynamicState: () => kindsStateBlock(),
     },
@@ -165,6 +168,10 @@ export const nodeConfig = defineLeaf({
         // kind is validated against the caller's installed personas here for the
         // clean listing error, and re-validated server-side against the TARGET
         // node's scope as a backstop.
+        const cwdSpec = input['cwd'];
+        if (cwdSpec !== undefined && ['model', 'kind', 'lifecycle', 'mode', 'name'].some((flag) => input[flag] !== undefined)) {
+            throw new InputError({ error: 'cwd_not_exclusive', message: 'cwd repair cannot be combined with another config flag', field: 'cwd', next: 'Pass --cwd alone.' });
+        }
         const modelSpec = input['model']?.trim();
         if (modelSpec === '') {
             throw new InputError({ error: 'empty_spec', message: 'a model spec is required', field: 'model', next: 'Run `crtr node config --model -h` and read the focused contract before retrying.' });
@@ -203,12 +210,18 @@ export const nodeConfig = defineLeaf({
             patch.name = nameSpec;
             applied.push('name');
         }
+        if (cwdSpec !== undefined) {
+            patch.cwd = cwdSpec;
+            applied.push('cwd');
+        }
         if (applied.length === 0) {
-            throw new InputError({ error: 'no_change', message: 'no config changes requested', next: 'Pass at least one of --model, --lifecycle, --kind, --mode, --name.' });
+            throw new InputError({ error: 'no_change', message: 'no config changes requested', next: 'Pass at least one of --model, --lifecycle, --kind, --mode, --name, --cwd.' });
         }
         const detail = await cliClient()
             .patchConfig(nodeId, patch)
             .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
+        if (cwdSpec !== undefined)
+            return { cwd: detail.cwd };
         const result = { node_id: nodeId };
         if (applied.includes('model'))
             result.model = detail.model_override ?? modelSpec;
@@ -223,6 +236,8 @@ export const nodeConfig = defineLeaf({
         return result;
     },
     render: (r) => {
+        if (r['cwd'] !== undefined)
+            return `Repaired cwd: ${r['cwd']}.`;
         const bits = [];
         if (r['model'] !== undefined)
             bits.push(`model=${r['model']}`);

package/dist/core/runtime/revive.js

@@ -230,10 +230,15 @@ function launchRevive(nodeId, meta, opts) {
     // fail deep inside the crash/doctrine-wake catch below, where it would
     // surface as an opaque `internal error` (toErrorBody masks every 5xx).
     if (!existsSync(meta.cwd)) {
+        const next = meta.fork_from != null
+            ? `Restore ${meta.cwd}, then revive the fork normally with \`crtr node lifecycle revive ${nodeId}\`.`
+            : meta.managed_worktree?.state === 'open'
+                ? 'Restore or reconcile the recorded checkout, then use the managed-worktree close or abandon recovery.'
+                : `Recreate ${meta.cwd}, or repair it with \`crtr node config --cwd <path> --node ${nodeId}\`; durable node work resumes in a fresh conversation. Then retry \`crtr node lifecycle revive ${nodeId}\`.`;
         throw new InputError({
             error: 'cwd_missing',
             message: `${nodeId} cannot be revived — its recorded cwd no longer exists: ${meta.cwd}`,
-            next: `Recreate ${meta.cwd}, or update the node's cwd, then retry \`crtr node lifecycle revive ${nodeId}\`.`,
+            next,
         });
     }
     // Lazy host_kind coerce (§C): every launch now uses the broker host. Persist

package/dist/daemon/api/handlers/nodes.js

@@ -7,8 +7,8 @@
 //
 // `{id}` is the target node.
 import { envProfileId } from '../../../shared/env.js';
-import { readdirSync } from 'node:fs';
-import { basename } from 'node:path';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, isAbsolute, resolve } from 'node:path';
 import { appendSituationalContext, formatSituationalProse } from '../../../core/runtime/situational-context.js';
 import { closeNode } from '../../../core/runtime/close.js';
 import { reviveNode } from '../../../core/runtime/revive.js';
@@ -35,6 +35,7 @@ import { BrokerUnreachableError } from '../../../core/runtime/broker-request.js'
 import { readFault } from '../../../core/runtime/fault.js';
 import { activeFaultForDisplay } from '../../../core/canvas/render-source.js';
 import { isBrokerLive, persistDormantModel, setModelLive } from '../../../core/runtime/model-swap.js';
+import { boundFleet } from '../../../core/runtime/fleet.js';
 import { writeOutputSchema } from '../../../core/runtime/structured-output.js';
 import { claimWarmNode, refillWarmPool, warmPoolEnabled } from '../../../core/runtime/warm-pool.js';
 import { resolveLaunchTarget } from '../../../core/runtime/launch-target.js';
@@ -45,6 +46,7 @@ import { cronWakeOrigin } from '../../../core/runtime/bearings.js';
 import { notFound, usage } from '../../../core/errors.js';
 import { toCloseResultDTO, toNodeDetailDTO, toNodeSummaryDTO, toReviveResultDTO } from '../map.js';
 import { ApiError } from '../../../api/index.js';
+import { InputError } from '../../../core/io.js';
 // Shared helpers
 function requireMeta(id) {
     const meta = getNode(id);
@@ -622,11 +624,129 @@ function handleReviveAll() {
     };
     return { status: 200, body };
 }
-// PATCH /v1/nodes/{id}/config — model / situational-context (spec §6.2)
+// PATCH /v1/nodes/{id}/config — durable config and repair-only cwd (spec §6.2)
 export async function handleConfig(ctx, deps = {}) {
     const id = ctx.params['id'];
+    const body = ctx.body;
+    let patch;
+    if (body === undefined) {
+        patch = {};
+    }
+    else if (typeof body === 'object' && body !== null && !Array.isArray(body)) {
+        patch = body;
+    }
+    else {
+        throw new InputError({
+            error: 'cwd_invalid',
+            message: 'cwd repair requires a non-null object with a non-empty cwd string',
+            received: body,
+            field: 'cwd',
+            next: 'Send a config patch with a non-empty absolute cwd string.',
+        });
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'cwd')) {
+        const cwd = patch.cwd;
+        if (typeof cwd !== 'string' || cwd === '') {
+            throw new InputError({
+                error: 'cwd_invalid',
+                message: 'cwd must be a non-empty string',
+                received: cwd,
+                field: 'cwd',
+                next: 'Send a non-empty absolute cwd string.',
+            });
+        }
+        if (Object.keys(patch).some((key) => key !== 'cwd' && patch[key] !== undefined)) {
+            throw new InputError({
+                error: 'cwd_not_exclusive',
+                message: 'cwd repair cannot be combined with another config field',
+                received: patch,
+                field: 'cwd',
+                next: 'Send cwd as the only config field.',
+            });
+        }
+        const meta = requireMeta(id);
+        if (boundFleet().has(id)) {
+            const message = `${id} cannot repair its cwd while its broker is live`;
+            throw new ApiError(409, 'cwd_node_live', message, {
+                error: 'cwd_node_live',
+                message,
+                received: cwd,
+                field: 'cwd',
+                next: 'Let the node become dormant, then retry the cwd repair.',
+            });
+        }
+        if (meta.fork_from != null) {
+            throw new InputError({
+                error: 'cwd_node_forked',
+                message: `${id} is a fork and cannot repair its cwd; recorded cwd: ${meta.cwd}`,
+                received: cwd,
+                field: 'cwd',
+                next: `Restore ${meta.cwd}, then revive the fork normally.`,
+            });
+        }
+        if (meta.managed_worktree?.state === 'open') {
+            throw new InputError({
+                error: 'cwd_node_managed_worktree_open',
+                message: `${id} owns an open managed worktree and cannot repair its cwd`,
+                received: cwd,
+                field: 'cwd',
+                next: 'Restore or reconcile the recorded checkout, then use the managed-worktree close or abandon flow.',
+            });
+        }
+        if (existsSync(meta.cwd)) {
+            throw new InputError({
+                error: 'cwd_still_present',
+                message: `${id} recorded cwd still exists: ${meta.cwd}; cwd repair is not a relocation command`,
+                received: cwd,
+                field: 'cwd',
+                next: 'This command only repairs a node whose recorded cwd is gone.',
+            });
+        }
+        if (!isAbsolute(cwd)) {
+            throw new InputError({
+                error: 'cwd_not_absolute',
+                message: `cwd must be an absolute path: ${cwd}`,
+                received: cwd,
+                field: 'cwd',
+                next: 'Send an absolute path.',
+            });
+        }
+        const resolved = resolve(cwd);
+        if (!existsSync(resolved)) {
+            throw new InputError({
+                error: 'cwd_missing',
+                message: `cwd does not exist: ${resolved}`,
+                received: cwd,
+                field: 'cwd',
+                next: 'Create the replacement directory or send an existing absolute directory.',
+            });
+        }
+        try {
+            if (!statSync(resolved).isDirectory()) {
+                throw new InputError({
+                    error: 'cwd_not_a_directory',
+                    message: `cwd is not a directory: ${resolved}`,
+                    received: cwd,
+                    field: 'cwd',
+                    next: 'Send an existing absolute directory.',
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof InputError)
+                throw error;
+            throw new InputError({
+                error: 'cwd_missing',
+                message: `cwd does not exist: ${resolved}`,
+                received: cwd,
+                field: 'cwd',
+                next: 'Create the replacement directory or send an existing absolute directory.',
+            });
+        }
+        updateNode(id, { cwd: resolved, pi_session_id: null, pi_session_file: null });
+        return { status: 200, body: detailOf(id) };
+    }
     let meta = requireMeta(id);
-    const patch = ctx.body ?? {};
     if (patch.situational_context !== undefined) {
         appendSituationalContext(id, formatSituationalProse(patch.situational_context));
     }

package/dist/daemon/api/map.d.ts

@@ -112,7 +112,7 @@ export declare function errorToStatus(thrown: unknown): {
 };
 /** Build the uniform JSON error body (spec §8) for a thrown value, using
  *  `errorToStatus` for the status/code. Structured `details` are surfaced for a
- *  CrtrError (they let the client reconstruct the error verbatim). A 500 still
+ *  CrtrError or ApiError (they let the client reconstruct the error verbatim). A 500 still
  *  omits `details` for hygiene, but NO LONGER strips the message to a bare
  *  `internal error`: it surfaces the bounded cause (`boundedCause`) so a caller
  *  is never left with a causeless internal, while the router logs the full

package/dist/daemon/api/map.js

@@ -17,6 +17,7 @@ import { NodeIdConflictError } from '../../core/runtime/nodes.js';
 import { readContextTokens } from '../../core/canvas/telemetry.js';
 import { CrtrError } from '../../core/errors.js';
 import { WorktreeError } from '../../core/worktree.js';
+import { ApiError } from '../../api/errors.js';
 import { ExitCode } from '../../types.js';
 import { sinkDisplay } from '../cron-sink.js';
 import { responsePath } from '../../core/human/convention.js';
@@ -563,7 +564,7 @@ function boundedCause(err) {
 }
 /** Build the uniform JSON error body (spec §8) for a thrown value, using
  *  `errorToStatus` for the status/code. Structured `details` are surfaced for a
- *  CrtrError (they let the client reconstruct the error verbatim). A 500 still
+ *  CrtrError or ApiError (they let the client reconstruct the error verbatim). A 500 still
  *  omits `details` for hygiene, but NO LONGER strips the message to a bare
  *  `internal error`: it surfaces the bounded cause (`boundedCause`) so a caller
  *  is never left with a causeless internal, while the router logs the full
@@ -577,7 +578,7 @@ export function toErrorBody(thrown) {
     const message = err instanceof Error ? err.message : String(err);
     const details = err instanceof ReviewOperationErrorClass
         ? reviewErrorDetails(err)
-        : err instanceof CrtrError && err.details !== undefined
+        : (err instanceof CrtrError || err instanceof ApiError) && err.details !== undefined
             ? err.details
             : undefined;
     const body = { error: { code, message } };

package/package.json

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