@platless/axom-cli 0.6.36 → 0.6.52

package/dist/keepers/terminal/manifest.json

@@ -1,9 +1,9 @@
 {
   "kind": "terminal",
-  "protocolVersion": 1,
-  "buildVersion": "c0f319e5906ddf108ac7f65222a35db8423b49702609c2ea74aca69937ad1a05",
+  "protocolVersion": 2,
+  "buildVersion": "80542c28e2e2ce561c3acc8dab28422a0df482b778665e982272e923261c775c",
   "daemonProtocol": [
-    1,
-    1
+    2,
+    2
   ]
 }

package/dist/workstation/acp/acpAgents.js

@@ -510,6 +510,7 @@ export class AcpAgents {
     /** {@link OPEN_INSTALL_BUDGET_MS}, overridable for tests. */
     openInstallBudgetMs;
     cacheDir;
+    ownership;
     transports;
     generations;
     /** The once-per-daemon adoption's discovery ({@link adoptKeeperSessions}). */
@@ -583,9 +584,10 @@ export class AcpAgents {
         this.patchAssetRoot = options.patchAssetRoot;
         this.commandRetryFirstBroadcastMs = options.commandRetryFirstBroadcastMs ?? COMMAND_RETRY_FIRST_BROADCAST_MS;
         this.openInstallBudgetMs = options.openInstallBudgetMs ?? OPEN_INSTALL_BUDGET_MS;
-        this.adapterRoot = path.join(options.cacheDir, 'acp-adapters');
+        this.adapterRoot = path.join(options.adapterCacheDirectory ?? options.cacheDir, 'acp-adapters');
         this.builds = new BuildStore(this.adapterRoot);
         this.cacheDir = options.cacheDir;
+        this.ownership = options.ownership;
         this.transports = { ...options.transports };
         this.generations = options.keeperGenerations;
         this.initializeTimeoutMs = options.initializeTimeoutMs ?? DEFAULT_SESSION_INITIALIZE_TIMEOUT_MS;
@@ -1843,6 +1845,8 @@ export class AcpAgents {
      * be listed. One at a time; never rejects (failures are logged).
      */
     collectBuilds(options = {}) {
+        if (this.ownership)
+            return Promise.resolve({ removed: [], discarded: [], kept: [], legacyRemoved: [], skipped: 'Device-wide build references are incomplete' });
         const previous = this.collecting;
         let run;
         run = (async () => {
@@ -2065,15 +2069,18 @@ export class AcpAgents {
     }
     /** The fallback transport (spec §5.7), made on first use. */
     localTransport() {
-        this.transports.local ??= new LocalTransport({ configDir: this.cacheDir });
+        this.transports.local ??= new LocalTransport({ configDir: this.cacheDir, ownership: this.ownership });
         return this.transports.local;
     }
     /** Daemon shutdown: keeper-acp's connection is dropped (its adapters keep running); local adapters are stopped. */
-    closeTransports() {
+    async closeTransports() {
         this.clearQuotaReaders();
         this.transports.keeper?.close();
         this.generations?.close();
-        this.transports.local?.close();
+        if (this.transports.local instanceof LocalTransport)
+            await this.transports.local.dispose();
+        else
+            this.transports.local?.close();
     }
     clearQuotaReaders(agentId) {
         for (const [key, reader] of this.quotaReaders)

package/dist/workstation/acp/outbox.js

@@ -22,7 +22,7 @@
  * ## Residual (documented, not fixed)
  *
  * While the producing window is full — a server parked on an approval with ≥ 256 root frames held, a connection that is down, an
- * applier that never acknowledges — the record loop folds nothing: a steer or config RPC waits for the processor's reply and can
+ * applier that never acknowledges — the record loop folds nothing: an already-admitted steer or config RPC waits for the processor's reply and can
  * time out on the server; an `agent_interrupt` note is folded (and the `session/cancel` written) only once the server unparks.
  */
 /** Unacknowledged events per session (spec §5.6, `W_EVT`). `ACK_EVERY_EVENTS(32) < W_EVT ≤ HOLD_OFF_CAPACITY(512)`. */
@@ -278,16 +278,22 @@ export class SessionOutbox {
     }
     /**
      * A new connection: everything recorded so far — sent on an earlier connection or produced while none was bound — is held until
-     * the server reopens the ref and says how far it got ({@link SENT_EARLIER}); what is recorded from now on is sent at once. (The
-     * journal's semantics: frames produced while unbound were replayed by the reopen, never sent on their own.)
+     * the server reopens the ref and says how far it got ({@link SENT_EARLIER}). Newly recorded frames wait behind those older
+     * entries so a higher seq cannot advance the server's watermark past retained output.
      */
     connectionChanged() {
         for (const item of this.items)
             item.sentOn = SENT_EARLIER;
     }
-    /** The first entry never sent (the sender's next candidate), in seq order. */
+    /** The first entry never sent, without overtaking an older entry held for reopen. */
     nextUnsent() {
-        return this.items.find((item) => item.sentOn === null);
+        for (const item of this.items) {
+            if (item.sentOn === SENT_EARLIER)
+                return undefined;
+            if (item.sentOn === null)
+                return item;
+        }
+        return undefined;
     }
     /** Resolves when this life's unacknowledged backlog is below the window (immediately once {@link stopWaiting} ran). */
     room() {
@@ -295,6 +301,7 @@ export class SessionOutbox {
             return undefined;
         return new Promise((resolve) => { this.roomWaiters.add(resolve); });
     }
+    /** Whether another raw record can be folded now, without registering a waiter. */
     hasRoom() {
         if (this.stopped)
             return true;

package/dist/workstation/acp/permission.js

@@ -174,7 +174,8 @@ export function buildPermissionRequestedEvent(input) {
  * forced into a selection the user never made.
  */
 export async function handleRequestPermission(input, sink) {
-    if (input.options.length === 0) {
+    const optionIds = new Set(input.options.map((option) => option.optionId));
+    if (input.options.length === 0 || optionIds.size !== input.options.length) {
         return { outcome: 'rejected' };
     }
     if (input.signal?.aborted) {
@@ -192,7 +193,6 @@ export async function handleRequestPermission(input, sink) {
         console.error(`[acp] refusing to raise a permission card that fails validateWireEvent: ${rejection.reason}`);
         return { outcome: 'rejected' };
     }
-    const optionIds = new Set(input.options.map((option) => option.optionId));
     return new Promise((resolve) => {
         let settled = false;
         const settle = (decision) => {

package/dist/workstation/acp/processor/checkpoint.js

@@ -8,9 +8,10 @@ import { initialState, PROCESSOR_STATE_SCHEMA } from './state.js';
  * 6 — child status precedes process results; ended calls release data;
  * 7 — install outcomes become step events;
  * 8 — loaded-session levels fold live; output gaps become steps;
- * 9 — adapter compatibility folds moved out and retired optional state removed.
+ * 9 — adapter compatibility folds moved out and retired optional state removed;
+ * 10 — ended replay scopes cannot leak late level snapshots into the live journal.
  */
-export const PROCESSOR_VERSION = 9;
+export const PROCESSOR_VERSION = 10;
 export const CHECKPOINT_SCHEMA = 1;
 export class CheckpointUnreadableError extends Error {
 }
@@ -64,7 +65,7 @@ export function decodeCheckpoint(blob) {
         || !('activity' in state)) {
         throw new CheckpointUnreadableError('checkpoint state has no open-session layer (Task 17b)');
     }
-    return { schema: CHECKPOINT_SCHEMA, processorVersion, offset, state: clone({ ...(state.schema === 4 ? upgradeStateFromSchema4(state) : state), ...(!Object.hasOwn(state, 'draftSubagents') ? { draftSubagents: { children: {}, overflow: false } } : {}) }) };
+    return { schema: CHECKPOINT_SCHEMA, processorVersion, offset, state: clone({ ...(state.schema === 4 ? upgradeStateFromSchema4(state) : state), ...(!Object.hasOwn(state, 'draftSubagents') ? { draftSubagents: { children: {}, overflow: false } } : {}), ...(!Object.hasOwn(state, 'closedReplayScopes') ? { closedReplayScopes: {} } : {}) }) };
 }
 /** Read only the current neutral keys; retired adapter state is deliberately not copied. */
 function upgradeStateFromSchema4(state) {

package/dist/workstation/acp/processor/control.js

@@ -3,7 +3,7 @@ import { newSessionMetaFor } from '../activityReporting.js';
 import { flatChoicesOf, modesAlreadyRepresented, modelsAlreadyRepresented, normalizeConfigOptions, SYNTHESIZED_MODES_CONFIG_ID, SYNTHESIZED_MODEL_CONFIG_ID } from '../configOptions.js';
 import { ASYNC_TASK_STOP_METHOD, mapSteerOutcome, STEER_METHOD } from '../steering.js';
 import { emitEvent, isRecord } from './emit.js';
-import { settlementErrorCode } from './jsonrpc.js';
+import { jsonRpcErrorText, settlementErrorCode } from './jsonrpc.js';
 import { sameCause } from './record.js';
 import { onLaunchNote } from './runtime.js';
 import { bindRootSession, closeErrorText, connected } from './session.js';
@@ -58,7 +58,7 @@ export function settleOpen(state, entry, settlement, out) {
     const { mode } = ctx;
     if (settlement.outcome !== 'result') {
         const code = settlementErrorCode(settlement);
-        const error = settlement.outcome === 'error' ? settlement.error.message : closeErrorText(state);
+        const error = settlement.outcome === 'error' ? jsonRpcErrorText(settlement.error) : closeErrorText(state);
         state.open = { status: 'failed', mode, error, ...(code !== undefined ? { code } : {}) };
         endHistory(state, out, false);
         // A failed open closes the attached session, and its repair with it (`AcpSession.close`).

package/dist/workstation/acp/processor/jsonrpc.js

@@ -132,6 +132,14 @@ export function settlementOf(response) {
     const { code, message, data } = response.error;
     return { outcome: 'error', error: { code, message, data } };
 }
+/**
+ * The text an agent's error is shown as. The ACP SDK's `RequestError.internalError(details)` puts the
+ * real cause only in `data.details` behind a generic "Internal error", so a string detail is kept.
+ */
+export function jsonRpcErrorText(error) {
+    const details = isRecord(error.data) && typeof error.data.details === 'string' ? error.data.details.trim().slice(0, 2000) : '';
+    return details && !error.message.includes(details) ? `${error.message}: ${details}` : error.message;
+}
 /** `jsonRpcErrorCode(err)` for a settlement: the code an agent answered with, if a frame may carry it. */
 export function settlementErrorCode(settlement) {
     return settlement.outcome === 'error' ? jsonRpcErrorCodeOf(settlement.error.code) : undefined;

package/dist/workstation/acp/processor/session.js

@@ -2,7 +2,7 @@
 import { buildElicitationRequestedEvent, buildPermissionRequestedEvent, elicitationFieldKeys, isBlank, permissionRequestId, } from '../permission.js';
 import { validateWireEvent } from '../validate.js';
 import { isRecord, nextSeq } from './emit.js';
-import { inboundKey, settlementErrorCode } from './jsonrpc.js';
+import { inboundKey, jsonRpcErrorText, settlementErrorCode } from './jsonrpc.js';
 import { sameCause } from './record.js';
 import { publishCallbacks, resetRuntime } from './runtime.js';
 import { getOwn, initialCallbacks, initialMessage, PENDING_PERMISSION_LIMIT, SETTLED_PERMISSION_LIMIT, } from './state.js';
@@ -51,6 +51,7 @@ export function resetForSpawn(state) {
     state.steered = [];
     state.asyncTasks = {};
     state.draftSubagents = { children: {}, overflow: false };
+    state.closedReplayScopes = {};
     resetRuntime(state);
     state.turns = [];
     state.exactExecutionUnconfirmed = false;
@@ -246,7 +247,7 @@ export function settlePrompt(state, entry, settlement, out) {
             // The one exit where the agent itself answered (`TurnResult.agentRefused`).
             const errorCode = settlementErrorCode(settlement);
             finishTurn(state, out, index, 'failed', {
-                error: settlement.error.message, agentRefused: true, errorCode, executionEnded: errorCode !== undefined,
+                error: jsonRpcErrorText(settlement.error), agentRefused: true, errorCode, executionEnded: errorCode !== undefined,
             });
             return;
         }

package/dist/workstation/acp/processor/state.js

@@ -43,6 +43,7 @@ export function initialState() {
         open: { status: 'idle' },
         configOptions: null,
         history: null,
+        closedReplayScopes: {},
         mapperScopes: {},
         message: initialMessage(),
         steers: {},

package/dist/workstation/acp/processor/transport/local.js

@@ -19,6 +19,7 @@ import { AcpSession } from '../../../keepers/acp/session.js';
 import { KeeperMethodError } from '../../../keepers/kit/protocol.js';
 import { StreamLog } from '../../../keepers/kit/streamLog.js';
 import { DAEMON_FRAME_INDEX } from '../../outbox.js';
+import { assertOwnedDirectory } from '../../../runtime/ownership.js';
 import { RawTruncatedError, checkpointBlob, rawRecordOf, } from './types.js';
 const DEFAULT_WINDOW = 32;
 /** Longest directory name used as is (file systems cap a name at 255 bytes); longer keys get a hashed name. */
@@ -43,12 +44,15 @@ export class LocalTransport {
     logLine;
     constructor(options) {
         this.options = options;
-        this.root = path.join(options.configDir, 'agents', 'local');
+        this.root = options.outboxDirectory ?? path.join(options.configDir, 'agents', 'local');
         this.now = options.now ?? Date.now;
         this.logLine = options.log ?? (() => { });
     }
     open(sessionKey, label, baseOffset, orphan) {
         const dir = localSessionDir(this.root, sessionKey);
+        assertOwnedDirectory(dir, this.options.ownership, 'local-outbox');
+        if (this.options.ownership)
+            label = { ...label, registrationId: this.options.ownership.registrationId };
         if (path.basename(dir).startsWith('~')) {
             mkdirSync(dir, { recursive: true, mode: 0o700 });
             writeFileSync(path.join(dir, KEY_FILE), sessionKey, { mode: 0o600 });
@@ -71,12 +75,15 @@ export class LocalTransport {
     async importOutbox(key, records) {
         const sessionKey = sessionKeyOf(key);
         const dir = localSessionDir(this.root, sessionKey);
-        if (this.entries.has(sessionKey) || existsSync(dir))
+        if (this.entries.has(sessionKey) || existsSync(dir)) {
+            assertOwnedDirectory(dir, this.options.ownership, 'local-outbox');
             return false;
+        }
         mkdirSync(this.root, { recursive: true, mode: 0o700 });
         const staging = path.join(this.root, `.staging-${randomUUID()}`);
         try {
             mkdirSync(staging, { mode: 0o700 });
+            assertOwnedDirectory(staging, this.options.ownership);
             if (path.basename(dir).startsWith('~'))
                 writeFileSync(path.join(staging, KEY_FILE), sessionKey, { mode: 0o600 });
             const log = StreamLog.open({ dir: staging, now: this.now, immediateKinds: [] });
@@ -127,6 +134,13 @@ export class LocalTransport {
             catch {
                 continue;
             }
+            try {
+                assertOwnedDirectory(path.join(this.root, name), this.options.ownership, 'local-outbox');
+            }
+            catch {
+                this.logLine('ACP local state skipped: registration owner is unknown or mismatched');
+                continue;
+            }
             if (!this.entries.has(key))
                 keys.push(key);
         }
@@ -135,8 +149,10 @@ export class LocalTransport {
     entry(key) {
         const sessionKey = sessionKeyOf(key);
         const existing = this.entries.get(sessionKey);
-        if (existing)
+        if (existing) {
+            assertOwnedDirectory(existing.dir, this.options.ownership, 'local-outbox');
             return existing;
+        }
         if (this.orphans().includes(sessionKey))
             return this.open(sessionKey, {}, undefined, true);
         throw new KeeperMethodError(AcpErrorCode.notFound, 'ACP session not found');

package/dist/workstation/acp/processor/updates.js

@@ -17,6 +17,10 @@ const DRAFT_NAMES = new Set(DRAFT_SESSION_UPDATE_NAMES);
 const LEVEL_UPDATES = new Set([
     'available_commands_update', 'current_mode_update', 'config_option_update', 'usage_update', 'session_info_update',
 ]);
+/** Only configuration snapshots: terminal usage, titles and actual output remain observable. */
+const CLOSED_REPLAY_LEVELS = new Set([
+    'available_commands_update', 'current_mode_update', 'config_option_update',
+]);
 const SESSION_NOTIFICATION = INBOUND_NOTIFICATION_SCHEMAS['session/update'];
 function stringField(payload, key) {
     const value = payload[key];
@@ -49,6 +53,15 @@ export function onSessionUpdate(state, params, out, t) {
         state.diagnostics.droppedUpdates += 1;
         return;
     }
+    // A load may replay and end a child that the host did not request as backfill.
+    // Its later configuration snapshot is still historical, not a live child event.
+    // Keep this narrow: unknown scopes and actual content/tool/lifecycle events retain
+    // their normal routing and ownership checks. A live spawn removes the tombstone.
+    if (sessionId !== root && getOwn(state.closedReplayScopes, sessionId) && CLOSED_REPLAY_LEVELS.has(String(update.sessionUpdate))) {
+        state.diagnostics.droppedUpdates += 1;
+        out.unjournaled({ t: 'processor.closed_replay_level', sessionId, sessionUpdate: update.sessionUpdate });
+        return;
+    }
     const variant = update.sessionUpdate;
     const draft = typeof variant === 'string' && DRAFT_NAMES.has(variant);
     if (!draft && sessionId === root) {
@@ -188,6 +201,11 @@ export function emitSessionEvent(state, out, event) {
 function observe(state, event) {
     if (event.eventName === 'subagent_spawned') {
         observeSubagentSpawned(state, event.acpSessionId ?? state.rootSessionId, event.payload.subagentSessionId);
+        const child = event.payload.subagentSessionId;
+        if (typeof child === 'string' && getOwn(state.permissionOrigins, child) &&
+            getOwn(state.permissionParents, child) === (event.acpSessionId ?? state.rootSessionId)) {
+            delete state.closedReplayScopes[child];
+        }
     }
     trackAsyncTask(state, event);
     trackDraftSubagent(state, event);
@@ -361,6 +379,13 @@ function emitHistory(state, history, out, event, sessionId) {
         observeSubagentSpawned(state, scoped.acpSessionId ?? history.rootSessionId, scoped.payload.subagentSessionId, history.rootSessionId);
     }
     trackDraftSubagent(state, scoped);
+    if (scoped.eventName === 'subagent_state_update' && DRAFT_TERMINALS.has(String(scoped.payload.state))) {
+        const child = scoped.payload.subagentSessionId;
+        // Share the lifecycle tracker's bounded, validated identity set.
+        if (typeof child === 'string' && getOwn(state.draftSubagents.children, child) === false) {
+            putOwn(state.closedReplayScopes, child, true);
+        }
+    }
     observeBackgroundWriter(state, scoped);
     out.unjournaled({
         t: 'processor.history_event',

package/dist/workstation/acp/processorSession.js

@@ -13,6 +13,7 @@ import { pendingRequestIds } from './processor/session.js';
 import { steeredIds } from './processor/control.js';
 import { RawTruncatedError } from './processor/transport/types.js';
 import { AcpKeeperUnavailableError } from '../keepers/acp/client.js';
+import { RegistrationOwnershipError } from '../runtime/ownership.js';
 import { AcpErrorCode } from '../keepers/acp/protocol.js';
 import { KeeperClosedError, KeeperConnectionLostError, KeeperNotConnectedError, KeeperRequestError, KeeperRequestTimeoutError, } from '../keepers/kit/client.js';
 /** What the executor reports when a prompt's blocks are no longer in this daemon's memory (interface-contracts). */
@@ -157,7 +158,7 @@ export class ProcessorSession {
         }
         catch (error) {
             // keeper-acp unreachable is not a launch failure: the caller falls back to the local transport.
-            if (error instanceof AcpKeeperUnavailableError)
+            if (error instanceof AcpKeeperUnavailableError || error instanceof RegistrationOwnershipError)
                 throw error;
             throw spawnFailure(options.spawn.command, error);
         }
@@ -575,6 +576,9 @@ export class ProcessorSession {
                         this.history.push(event);
                     }
                     continue;
+                case 'processor.closed_replay_level':
+                    this.log(`[acp] session ${this.key}: ignored ${String(frame.sessionUpdate)} for ended replay scope ${JSON.stringify(frame.sessionId)}`);
+                    continue;
                 case 'processor.history_end': {
                     const droppedCount = typeof frame.droppedCount === 'number' ? frame.droppedCount : 0;
                     this.historyEnd = { ok: frame.ok === true, droppedCount };
@@ -1015,6 +1019,13 @@ export class ProcessorSession {
     async steer(blocks, priority, id) {
         if (this.pendingReplies.has(`agent_steered:${id}`))
             throw new Error(`A steer with id '${id}' is already in flight`);
+        // A full producing window stops the raw loop, including control notes. Appending here
+        // would leave a steer that can execute long after the server's RPC timed out. Refuse
+        // before recording anything: promptRequired proves this attempt cannot inject later.
+        if (!this.outbox.hasRoom()) {
+            this.log(`[acp] session ${this.key}: steer ${id} not admitted while awaiting event acknowledgements`);
+            return 'promptRequired';
+        }
         const answered = this.reply('agent_steered', id);
         await this.send({ type: 'agent_steer', id, blocksRef: this.holdBlocks(blocks), ...(priority !== undefined ? { priority } : {}) })
             .catch((error) => { this.pendingReplies.delete(`agent_steered:${id}`); throw error; });

package/dist/workstation/acp/registry/catalog.js

@@ -86,7 +86,7 @@ export const AXOM_AGENT_CATALOG = [
         defaultName: 'claude-agent',
         defaultLabel: 'Claude Agent',
         detect: { commands: ['claude'] },
-        // 钉版本的唯一理由是补丁：claude-account-limits 的配方只核验过 0.97.0（runtime.json 的
+        // 钉版本的唯一理由是补丁：账号配额与 replay lifecycle 配方只核验过 0.97.0（runtime.json 的
         // package_patches）。不钉的话 registry 一发新版，Install/Update 就装上一个配方不覆盖的包，
         // 账号配额扩展静默消失——2026-10-14 的 antigravity（registry 已到 1.4.0、native extension
         // 只认 1.3.0）就是这个缺口的实例。钉住后 scan 的 Update 比对（installedVersion vs 本清单的
@@ -204,19 +204,19 @@ export const AXOM_AGENT_CATALOG = [
         // 2026-10-13 真机验证（ZCode 桌面 3.14.5 + 0.69.3）：initialize → session/new → 首轮 prompt 通过，
         // 日志 "serving the coding-plan API key (config.json or store)"。0.63/0.64 那轮不兼容（模型只剩
         // 无授权的 builtin:bigmodel-coding-plan\GLM-5.3，首轮 CONFIGURATION_ERROR "Model creation failed"，
-        // 2026-10-06 两台机器复现）自 0.68.1 起修复。2026-10-27 nightly 升到 0.76.3：subagent 探针在
-        // 0.76.3 补丁副本上通过、pristine 复现缺失（上游仍无 subagent/async 变体、无配额能力、无模型
-        // 兜底）；全部锚点存活，配方纯重哈希。
+        // 2026-10-06 两台机器复现）自 0.68.1 起修复。2026-10-29 升到 0.80.0：迁移配额、模型兜底、
+        // subagent/async 补丁；env 账号包装复用上游 bridge-accounts（不写桌面配置）。
+        // ZCODE_PROVIDER + ZCODE_API_KEY 支持独立个人 Coding Plan，无需复用桌面 OAuth。
         supplement: {
             name: 'ZCode',
-            version: '0.76.3',
+            version: '0.80.0',
             description: 'Community bridge that drives the real ZCode app-server (GLM) over ACP.',
             repository: 'https://github.com/william0wang/zcode-acp',
             website: 'https://github.com/william0wang/zcode-acp',
             authors: ['William Wang'],
             license: 'Apache-2.0',
             icon: 'https://raw.githubusercontent.com/william0wang/zcode-acp/main/registry/zcode-acp/icon.svg',
-            distribution: { npx: { package: 'zcode-acp-server@0.76.3' } },
+            distribution: { npx: { package: 'zcode-acp-server@0.80.0' } },
         },
         prerequisite: {
             label: 'ZCode',

package/dist/workstation/acp/test/keeperWorld.js

@@ -144,12 +144,13 @@ export class KeeperWorld {
         const real = new KeeperTransport(new AcpKeeperClient({ launcher: use }));
         const keeper = (over.wrapKeeper ? over.wrapKeeper(real) : real);
         const generations = keeperGenerations({ launcher: use, current: keeper, log: () => { } });
-        const local = new LocalTransport({ configDir: this.configDir });
+        const journalRoot = use.ownership ? join(this.configDir, 'registrations', use.ownership.registrationId) : this.configDir;
+        const local = new LocalTransport({ configDir: journalRoot, ownership: use.ownership });
         const acp = new AcpAgents({ cacheDir: this.configDir, registry: { load: async () => [] }, transports: { keeper, local }, keeperGenerations: generations,
             sessionStartTimeoutMs: 15_000, ...over.acp });
         const tasks = new TaskRegistry();
         const sent = [];
-        const manager = new AgentSessionManager(acp, null, join(this.configDir, 'agents'), tasks);
+        const manager = new AgentSessionManager(acp, null, join(journalRoot, 'agents'), tasks, () => true, use.ownership);
         manager.bindSend((frame) => { sent.push(frame); server.apply(frame); }, AGENT_WIRE_VERSION);
         let killed = false;
         const result = {
@@ -223,7 +224,7 @@ export class KeeperWorld {
         const n = this.processes.length + 1;
         const framesOut = join(this.configDir, `frames-daemon-${n}.jsonl`);
         const stderrFile = join(this.configDir, `daemon-${n}.stderr`);
-        const child = spawn(join(packageRoot, 'node_modules', '.bin', 'vite-node'), [DAEMON_LIFE,
+        const child = spawn(join(packageRoot, 'node_modules', '.bin', 'vite-node'), ['--config', join(packageRoot, 'src/test/fixtures/nodeRuntime.vite.config.ts'), DAEMON_LIFE,
             JSON.stringify({ configDir: this.configDir, distDir: realDist, framesOut, faults })], { cwd: packageRoot, stdio: ['pipe', 'ignore', 'pipe'] });
         let stderr = '';
         child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); appendFileSync(stderrFile, chunk); });