@north-light/api 0.3.419 → 0.3.421

package/dist/api/dto/docs.d.ts

@@ -132,4 +132,11 @@ export interface ReconcilePackagesDTO {
         path: string;
         error: string;
     }>;
+    /** plugin directories with a damaged manifest or command file, moved aside to `<scope>/quarantine/plugins/` */
+    quarantined?: Array<{
+        name: string;
+        file: string;
+        reason: string;
+        movedTo?: string;
+    }>;
 }

package/dist/api/dto/nodes.d.ts

@@ -298,6 +298,7 @@ export interface NodeSnapshotDTO {
             followUp: string[];
         };
         toolGroupSummaries?: Record<string, unknown>;
+        turnReplies?: Record<string, unknown>;
         workingActivity?: string;
     };
     commands: {

package/dist/core/command-plugins/bundle.d.ts

@@ -103,6 +103,9 @@ export declare function isInstalledGeneration(name: string, scope: Scope, root:
 export declare function recordCheckedGeneration(scope: Scope, name: string, etag: string | undefined, options: {
     swapped: boolean;
 }): void;
+/** Every file lands by temp file plus rename, fsynced, so a crash mid-write leaves the previous bytes or
+ *  the whole new ones — never a 0-byte `plugin.json` or `commands.json` that crashes the next boot. */
+export declare function writeStagedBundle(stagingRoot: string, manifest: PluginManifest, bundle: ValidatedBundle): void;
 export interface InstallBundleArchiveOptions<M> {
     scope: Scope;
     /** The scope root whose `tmp/` holds staging, `.prev` and the swap lock. */

package/dist/core/command-plugins/bundle.js

@@ -1,11 +1,11 @@
 import { Parser } from 'tar';
 import { createHash } from 'node:crypto';
-import { chmodSync, renameSync, writeFileSync } from 'node:fs';
+import { chmodSync, renameSync } from 'node:fs';
 import { dirname, join, resolve, sep } from 'node:path';
 import { validateCommandManifest } from '../../api/command-manifest/manifest.js';
 import { ensureScopeInitialized, invalidPluginKindsReasons, readConfig, updateConfig, updateState } from '../config.js';
 import { general } from '../errors.js';
-import { atomicWriteJson, ensureDir, nowIso, pathExists, removePath } from '../fs-utils.js';
+import { atomicWriteJson, atomicWriteText, ensureDir, nowIso, pathExists, removePath, syncDirectory, syncTree } from '../fs-utils.js';
 import { invalidPageComponentsReasons, normalizePageComponents } from '../human/page-catalog.js';
 import { validateMemoryExtensionDeclarations } from '../plugin-extensions.js';
 import { validateHttpPluginTransport } from './endpoint.js';
@@ -481,25 +481,24 @@ function stagedPath(stagingRoot, relative) {
     }
     return path;
 }
-function writeStagedBundle(stagingRoot, manifest, bundle) {
-    atomicWriteJson(stagedPath(stagingRoot, '.crouter-plugin/plugin.json'), manifest);
+/** Every file lands by temp file plus rename, fsynced, so a crash mid-write leaves the previous bytes or
+ *  the whole new ones — never a 0-byte `plugin.json` or `commands.json` that crashes the next boot. */
+export function writeStagedBundle(stagingRoot, manifest, bundle) {
+    const write = (path, content, mode = 0o644) => atomicWriteText(path, content, { mode, durable: true });
+    atomicWriteJson(stagedPath(stagingRoot, '.crouter-plugin/plugin.json'), manifest, { durable: true });
     for (const directory of bundle.directories)
         ensureDir(stagedPath(stagingRoot, directory.path));
-    writeFileSync(stagedPath(stagingRoot, 'commands.json'), bundle.commandsBytes);
-    for (const document of bundle.memory) {
-        const target = stagedPath(stagingRoot, document.path);
-        ensureDir(resolve(target, '..'));
-        writeFileSync(target, document.bytes);
-    }
+    write(stagedPath(stagingRoot, 'commands.json'), bundle.commandsBytes);
+    for (const document of bundle.memory)
+        write(stagedPath(stagingRoot, document.path), document.bytes);
     if (bundle.hooks !== undefined) {
-        writeFileSync(stagedPath(stagingRoot, 'hooks.json'), bundle.hooks.manifest);
-        for (const file of bundle.hooks.files) {
-            const target = stagedPath(stagingRoot, file.path);
-            ensureDir(resolve(target, '..'));
-            writeFileSync(target, file.bytes);
-        }
+        write(stagedPath(stagingRoot, 'hooks.json'), bundle.hooks.manifest);
+        for (const file of bundle.hooks.files)
+            write(stagedPath(stagingRoot, file.path), file.bytes);
         chmodSync(stagedPath(stagingRoot, 'hooks/dispatch'), 0o755);
     }
+    // The staged tree reaches disk before the directory rename publishes it.
+    syncTree(stagingRoot);
 }
 /**
  * Validate `raw`, stage it beside the package root, swap it in, then record
@@ -565,6 +564,7 @@ export async function installBundleArchive(name, raw, options) {
                 renameSync(previous, root);
             throw error;
         }
+        syncDirectory(dirname(root));
         if (movedPrevious)
             removePath(previous);
     }

package/dist/core/config.js

@@ -833,6 +833,7 @@ function mergeConfig(partial) {
     const fold_finished_tools = typeof partial.fold_finished_tools === 'boolean' ? partial.fold_finished_tools : defaults.fold_finished_tools;
     const summarize_tool_calls = typeof partial.summarize_tool_calls === 'boolean' ? partial.summarize_tool_calls : defaults.summarize_tool_calls;
     const detailed_tool_recaps = typeof partial.detailed_tool_recaps === 'boolean' ? partial.detailed_tool_recaps : defaults.detailed_tool_recaps;
+    const consolidate_replies = typeof partial.consolidate_replies === 'boolean' ? partial.consolidate_replies : defaults.consolidate_replies;
     const keybindings = normalizeKeybindings(partial.keybindings);
     const tmux_passthrough = normalizeTmuxPassthrough(partial.tmux_passthrough);
     const modelLadders = mergeModelLadders(partial.modelLadders);
@@ -856,7 +857,7 @@ function mergeConfig(partial) {
     const spawnEnv = mergeSpawnEnv(partial.spawnEnv, defaults.spawnEnv?.allow);
     const bin = normalizeBin(partial.bin);
     const humanActions = normalizeHumanActions(partial.humanActions);
-    return { bin, humanActions, schema_version, marketplaces, plugins, auto_update, max_panes_per_window, auto_open_child_viewers, brokerThresholds, lifecycle, completion_bell, working_gerunds, whip_mode, page_components, page_surface, whip_messages, whip_message_mode, mouse_mode_default, live_cycles, condensed_history, bash_tool_purpose, fold_finished_tools, summarize_tool_calls, detailed_tool_recaps, keybindings, tmux_passthrough, modelLadders, providerOptions, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(Object.keys(routes.legacy).length > 0 ? { legacyModelRoutes: routes.legacy } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), kinds, remoteCanvas, api, ...(paths ? { paths } : {}), ...(store ? { store } : {}), ...(runtime ? { runtime } : {}), spawnEnv };
+    return { bin, humanActions, schema_version, marketplaces, plugins, auto_update, max_panes_per_window, auto_open_child_viewers, brokerThresholds, lifecycle, completion_bell, working_gerunds, whip_mode, page_components, page_surface, whip_messages, whip_message_mode, mouse_mode_default, live_cycles, condensed_history, bash_tool_purpose, fold_finished_tools, summarize_tool_calls, detailed_tool_recaps, consolidate_replies, keybindings, tmux_passthrough, modelLadders, providerOptions, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(Object.keys(routes.legacy).length > 0 ? { legacyModelRoutes: routes.legacy } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), kinds, remoteCanvas, api, ...(paths ? { paths } : {}), ...(store ? { store } : {}), ...(runtime ? { runtime } : {}), spawnEnv };
 }
 /** Raw (un-defaulted) partial config for one scope, or null if the scope has
  *  no root or no config.json. Used by `readMergedLaunchConfig` to layer

package/dist/core/fs-utils.d.ts

@@ -13,6 +13,10 @@ export interface AtomicWriteOptions {
     mode?: number;
     /** Require the parent to exist, rather than recreate a removed project root. */
     createParent?: boolean;
+    /** Fsync the temp file before the rename and the parent directory after it. Without this a power loss
+     *  or a killed VM can persist the rename but not the data — the 0-byte file a plain
+     *  temp-plus-rename still leaves behind. */
+    durable?: boolean;
 }
 export declare function atomicWriteJson(path: string, data: unknown, opts?: AtomicWriteOptions): void;
 /** Force a file's written bytes to stable storage. */
@@ -23,6 +27,9 @@ export declare function syncDirectory(path: string): void;
  *  tmux inbox watcher, or crtrd serving a ticket read — sees either the old
  *  bytes or the new ones and never a truncated file mid-write. */
 export declare function atomicWriteText(path: string, content: string | Uint8Array, opts?: AtomicWriteOptions): void;
+/** Fsync every file and directory under `root` (and `root` itself), so a tree about to be renamed into place
+ *  reaches stable storage before the rename can. */
+export declare function syncTree(root: string): void;
 export declare function readJson<T = unknown>(path: string): T;
 export declare function readJsonIfExists<T = unknown>(path: string): T | null;
 /** Missing or corrupt reads as absent, so a crash artifact never throws. */

package/dist/core/fs-utils.js

@@ -69,13 +69,29 @@ export function atomicWriteText(path, content, opts) {
     try {
         writeFileSync(temp, content, { mode });
         chmodSync(temp, mode);
+        if (opts?.durable === true)
+            syncFile(temp);
         renameSync(temp, path);
+        if (opts?.durable === true)
+            syncDirectory(dirname(path));
     }
     finally {
         if (existsSync(temp))
             rmSync(temp, { force: true });
     }
 }
+/** Fsync every file and directory under `root` (and `root` itself), so a tree about to be renamed into place
+ *  reaches stable storage before the rename can. */
+export function syncTree(root) {
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const child = join(root, entry.name);
+        if (entry.isDirectory())
+            syncTree(child);
+        else if (entry.isFile())
+            syncFile(child);
+    }
+    syncDirectory(root);
+}
 export function readJson(path) {
     return JSON.parse(readFileSync(path, 'utf8'));
 }

package/dist/core/keybindings/catalog.d.ts

@@ -1,6 +1,6 @@
 import type { BindingDefinition, SafetyRequirement } from './types.js';
 import type { AttachBindingId, AttachMenuBindingId } from './attach-control.js';
-type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'provider-options' | 'fold-tools' | 'metadata' | 'promote' | 'demote-mode' | 'resume' | 'fork' | 'demote' | 'make-resident' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'context-admin' | 'providers' | 'plugins' | 'analytics' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
+type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'provider-options' | 'fold-tools' | 'show-working' | 'metadata' | 'promote' | 'demote-mode' | 'resume' | 'fork' | 'demote' | 'make-resident' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'context-admin' | 'providers' | 'plugins' | 'analytics' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
 type TmuxMenuEntryAction = Exclude<TmuxMenuAction, 'open' | 'attach'> | `issue.${'idea' | 'bug'}`;
 type GraphAction = 'down' | 'up' | 'first' | 'last' | 'collapse-or-manager' | 'expand-or-child' | 'focus' | 'revive' | 'focus-manager' | 'close-subtree' | 'dismiss';
 type BrowseAction = 'quit' | 'down' | 'up' | 'first' | 'last' | 'expand-or-child' | 'collapse-or-parent' | 'toggle-fold' | 'tab-next' | 'tab-previous' | `tab.${1 | 2 | 3 | 4 | 5}` | 'close-subtree' | 'confirm-close' | 'sort' | 'scope' | 'profile' | 'residents' | 'preview' | 'report' | 'pin' | 'search' | 'revive-now' | 'focus' | 'focus-background' | 'yank-id';

package/dist/core/keybindings/catalog.js

@@ -52,6 +52,7 @@ export const BINDING_CATALOG = Object.freeze([
     ...menuEntry('show', 'Inspect node', 'Open the focused node’s inspection menu.', ['i'], ['tmux.menu']),
     ...menuEntry('view-settings', 'Display settings', 'Open the viewer display-settings menu.', ['z'], ['tmux.menu']),
     ...menuEntry('fold-tools', 'Fold finished tool calls', 'Fold every finished tool call in the transcript to its single call line.', ['f'], ['tmux.menu.view-settings']),
+    ...menuEntry('show-working', 'Show working', 'With consolidated replies on, show or hide the messages and tool calls behind each reply.', ['w'], ['tmux.menu.view-settings']),
     ...menuEntry('metadata', 'Show metadata', 'Show the focused node’s metadata dossier.', ['m'], ['tmux.menu.show']),
     ...menuEntry('context', 'Browse context', 'Browse the focused node context.', ['c'], ['tmux.menu.show']),
     ...menuEntry('providers', 'Open settings', 'Open the crouter settings panel.', [','], ['tmux.menu']),

package/dist/core/manifest.d.ts

@@ -1,5 +1,20 @@
 import type { MarketplaceManifest, PluginManifest } from '../types.js';
 export declare function pluginManifestPath(pluginRoot: string): string;
 export declare function marketplaceManifestPath(mktRoot: string): string;
+/** What a manifest file holds: `absent` (no file, or JSON `null`), `ok`, or `broken` —
+ *  present but unreadable, not JSON (a 0-byte file from a write cut short), or not an object. */
+export type ManifestRead<T> = {
+    status: 'absent';
+} | {
+    status: 'ok';
+    manifest: T;
+} | {
+    status: 'broken';
+    error: string;
+};
+export declare function readPluginManifestChecked(pluginRoot: string): ManifestRead<PluginManifest>;
+/** The plugin's manifest, or null when it has none or it is unreadable: one damaged plugin
+ *  directory must read as "not installed", never throw through whoever lists plugins. The daemon
+ *  quarantines such a directory (`quarantineBrokenPlugins`); `readPluginManifestChecked` says why. */
 export declare function readPluginManifest(pluginRoot: string): PluginManifest | null;
 export declare function readMarketplaceManifest(mktRoot: string): MarketplaceManifest | null;

package/dist/core/manifest.js

@@ -7,9 +7,31 @@ export function pluginManifestPath(pluginRoot) {
 export function marketplaceManifestPath(mktRoot) {
     return join(mktRoot, MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE);
 }
+function readManifestChecked(path) {
+    let value;
+    try {
+        value = readJsonIfExists(path);
+    }
+    catch (error) {
+        return { status: 'broken', error: error instanceof Error ? error.message : String(error) };
+    }
+    if (value === null)
+        return { status: 'absent' };
+    if (typeof value !== 'object' || Array.isArray(value))
+        return { status: 'broken', error: 'manifest is not a JSON object' };
+    return { status: 'ok', manifest: value };
+}
+export function readPluginManifestChecked(pluginRoot) {
+    return readManifestChecked(pluginManifestPath(pluginRoot));
+}
+/** The plugin's manifest, or null when it has none or it is unreadable: one damaged plugin
+ *  directory must read as "not installed", never throw through whoever lists plugins. The daemon
+ *  quarantines such a directory (`quarantineBrokenPlugins`); `readPluginManifestChecked` says why. */
 export function readPluginManifest(pluginRoot) {
-    return readJsonIfExists(pluginManifestPath(pluginRoot));
+    const read = readPluginManifestChecked(pluginRoot);
+    return read.status === 'ok' ? read.manifest : null;
 }
 export function readMarketplaceManifest(mktRoot) {
-    return readJsonIfExists(marketplaceManifestPath(mktRoot));
+    const read = readManifestChecked(marketplaceManifestPath(mktRoot));
+    return read.status === 'ok' ? read.manifest : null;
 }

package/dist/core/user-settings.d.ts

@@ -290,6 +290,21 @@ export declare const CONFIG_SETTINGS_COVERAGE: {
             setFromString: (config: ScopeConfig, raw: string) => string | null;
         };
     };
+    consolidate_replies: {
+        surface: "settings";
+        setting: {
+            key: "consolidate_replies";
+            label: string;
+            description: string;
+            valueConstraint: string;
+            applies: string;
+            group: "display";
+            order: number;
+            format: (config: ScopeConfig) => "on" | "off";
+            cycle: (config: ScopeConfig) => void;
+            setFromString: (config: ScopeConfig, raw: string) => string | null;
+        };
+    };
     keybindings: {
         surface: "specialized";
         owner: string;

package/dist/core/user-settings.js

@@ -391,6 +391,27 @@ export const CONFIG_SETTINGS_COVERAGE = {
             },
         },
     },
+    consolidate_replies: {
+        surface: 'settings',
+        setting: {
+            key: 'consolidate_replies',
+            label: 'Consolidate replies',
+            description: 'Experiment: show one rewritten agent reply per message you type, with the working folded behind it (/show-working).',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next attach; the broker reads it per turn.',
+            group: 'display',
+            order: 36.5,
+            format: (config) => config.consolidate_replies ? 'on' : 'off',
+            cycle: (config) => { config.consolidate_replies = !config.consolidate_replies; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'consolidate_replies');
+                if (typeof value === 'string')
+                    return value;
+                config.consolidate_replies = value;
+                return null;
+            },
+        },
+    },
     keybindings: { surface: 'specialized', owner: 'Keybindings tab' },
     tmux_passthrough: { surface: 'specialized', owner: 'Keybindings tab' },
     providerOptions: {

package/dist/types.d.ts

@@ -341,6 +341,12 @@ export interface ScopeConfig {
     /** Show individual document reads and edited files in a folded tool recap.
      * Off shows the compact activity-count line instead. Default true. */
     detailed_tool_recaps: boolean;
+    /** Experiment: show one consolidated agent reply per message the person typed.
+     *  The broker rewrites a turn's prose messages into one reply with a light
+     *  model; the attach viewer folds the rest of the turn behind a working row
+     *  (`/show-working`, Alt+C → z → w). Session and model context are untouched.
+     *  Default false. */
+    consolidate_replies: boolean;
     keybindings: KeybindingOverrides;
     /** Attach-viewer actions whose effective gesture may replace an occupied tmux
      *  root binding only while the active pane is an attach viewer. Stored by

package/dist/types.js

@@ -100,6 +100,7 @@ export function defaultScopeConfig() {
         fold_finished_tools: true,
         summarize_tool_calls: true,
         detailed_tool_recaps: true,
+        consolidate_replies: false,
         keybindings: {},
         tmux_passthrough: [],
         modelLadders: defaultModelLaddersConfig(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/api",
-  "version": "0.3.419",
+  "version": "0.3.421",
   "description": "Typed crtrd /v1 API contract — DTOs, route builders, the error contract, the CrtrClient, and the command-plugin manifest format. Zero runtime dependencies.",
   "type": "module",
   "main": "./dist/api/index.js",