@dinoxx/dinox-cli 2.15.0 → 2.16.0

package/README.md

@@ -937,6 +937,8 @@ daemon 通过用户数据目录下的私有 Unix domain socket 通信，Windows
 
 ### 6.15 `gateway`：把本机 Agent 挂成远程设备
 
+在 Dinox App 中为每个 Agent 选择工作目录；会话始终保留开始时的目录，开启新话题也不改变。App 可以浏览该会话在这台电脑上的目录。
+
 ```bash
 dino gateway detect
 dino gateway detect --add

package/dist/gateway/adapters/acp.d.ts

@@ -37,11 +37,15 @@ export declare class AcpGatewayAdapter implements GatewayAdapter {
      * MCP servers offered to sessions as they are created or loaded, e.g. the
      * Dinox tools; `sessionToken` lets their `send_file` reach this session.
      */
-    mcpServers?: (sessionToken: string) => McpServer[]);
+    mcpServers?: (sessionToken: string, cwd: string) => McpServer[]);
     info(): GatewayAdapterInfo;
     runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
     sendFile(token: string, file: GatewayFileSource): Promise<GatewaySentFile> | null;
+    private catalogExpiresAt;
+    private catalogRevision;
+    private probing;
     describeConfig(): Promise<GatewayConfigOption[]>;
+    private probeConfig;
     dispose(): Promise<void>;
     /** Codex leaves generated images on disk; send the ones this turn made when it sent nothing itself. */
     private sendGeneratedImages;

package/dist/gateway/adapters/acp.js

@@ -140,7 +140,7 @@ export class AcpGatewayAdapter {
         };
         input.signal.addEventListener('abort', onAbort, { once: true });
         try {
-            const text = created && input.sessionPreamble ? `${input.sessionPreamble}\n\n${input.prompt}` : input.prompt;
+            const text = await input.prompt({ created });
             const prompt = [{ type: 'text', text }];
             for (const resource of input.resources) {
                 prompt.push({ type: 'resource_link', uri: resource.uri, name: resource.name, mimeType: resource.mediaType ?? null });
@@ -170,16 +170,23 @@ export class AcpGatewayAdapter {
         turn.sent += 1;
         return turn.sendFile(file);
     }
+    catalogExpiresAt = 0;
+    catalogRevision = 0;
+    probing = null;
     async describeConfig() {
-        if (this.catalog)
+        if (this.catalog && Date.now() < this.catalogExpiresAt)
             return this.catalog;
+        if (!this.probing)
+            this.probing = this.probeConfig().finally(() => { this.probing = null; });
+        return this.probing;
+    }
+    async probeConfig() {
         const agent = await this.ensureProcess();
-        if (this.catalog)
-            return this.catalog;
         // No session yet: open one only to read the agent's choices. It never runs a turn,
         // so close it where the agent allows, or it shows up in the user's session list.
+        const revision = this.catalogRevision;
         const created = await agent.connection.newSession({ cwd: this.gateway.cwd ?? os.homedir(), mcpServers: [] });
-        this.rememberConfig(agent, created.sessionId, created.configOptions);
+        this.rememberConfig(agent, created.sessionId, created.configOptions, revision === this.catalogRevision);
         if (agent.init.agentCapabilities?.sessionCapabilities?.close) {
             await agent.connection.closeSession({ sessionId: created.sessionId }).catch((error) => this.log('closing the settings session failed', { error: String(error) }));
         }
@@ -221,7 +228,7 @@ export class AcpGatewayAdapter {
             try {
                 // No turn is registered yet, so the history the agent replays is ignored.
                 const token = crypto.randomBytes(18).toString('base64url');
-                const loaded = await agent.connection.loadSession({ sessionId, cwd, mcpServers: this.mcpServers(token) });
+                const loaded = await agent.connection.loadSession({ sessionId, cwd, mcpServers: this.mcpServers(token, cwd) });
                 this.sessionTokens.set(token, sessionId);
                 agent.liveSessions.add(sessionId);
                 this.rememberConfig(agent, sessionId, loaded.configOptions);
@@ -232,7 +239,7 @@ export class AcpGatewayAdapter {
             }
         }
         const token = crypto.randomBytes(18).toString('base64url');
-        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers(token) });
+        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers(token, cwd) });
         this.sessionTokens.set(token, created.sessionId);
         agent.liveSessions.add(created.sessionId);
         this.rememberConfig(agent, created.sessionId, created.configOptions);
@@ -260,12 +267,17 @@ export class AcpGatewayAdapter {
             }
         }
     }
-    rememberConfig(agent, sessionId, options) {
+    rememberConfig(agent, sessionId, options, updateCatalog = true) {
         if (!options)
             return;
         const normalized = normalizeConfigOptions(options);
         agent.sessionConfig.set(sessionId, normalized);
-        this.catalog = normalized;
+        // A slow probe must not overwrite a newer live session update.
+        if (updateCatalog) {
+            this.catalog = normalized;
+            this.catalogExpiresAt = Date.now() + 5 * 60_000;
+            this.catalogRevision += 1;
+        }
     }
     ensureProcess() {
         if (this.process)

package/dist/gateway/adapters/echo.js

@@ -24,18 +24,21 @@ export class EchoGatewayAdapter {
     async runTurn(input) {
         const sessionId = input.sessionId ?? `echo-${generateId()}`;
         try {
-            if (input.prompt.includes('/approve')) {
+            const text = await input.prompt({ created: input.sessionId === null });
+            // Echo the user text while exercising the full prompt factory.
+            const prompt = text.replace(/<dinox_(delivery|knowledge|agent_instructions)>[\s\S]*?<\/dinox_\1>\n\n/g, '');
+            if (prompt.includes('/approve')) {
                 const toolCallId = `tool-${generateId()}`;
                 const approvalId = `approval-${generateId()}`;
-                input.onEvent({ type: 'tool', toolCallId, title: 'echo.write', status: 'pending', input: { text: input.prompt } });
-                input.onEvent({ type: 'approval-request', approvalId, toolCallId, toolName: 'echo.write', input: { text: input.prompt } });
+                input.onEvent({ type: 'tool', toolCallId, title: 'echo.write', status: 'pending', input: { text: prompt } });
+                input.onEvent({ type: 'approval-request', approvalId, toolCallId, toolName: 'echo.write', input: { text: prompt } });
                 const approved = await input.awaitApproval(approvalId);
                 input.onEvent({ type: 'approval-resolved', approvalId, approved });
                 input.onEvent(approved
                     ? { type: 'tool', toolCallId, status: 'completed', output: 'approved' }
                     : { type: 'tool', toolCallId, status: 'failed', output: 'denied by user' });
             }
-            for (const word of `Echo: ${input.prompt}`.split(/(\s+)/)) {
+            for (const word of `Echo: ${prompt}`.split(/(\s+)/)) {
                 await delay(CHUNK_DELAY_MS, input.signal);
                 input.onEvent({ type: 'text-delta', text: word });
             }

package/dist/gateway/adapters/index.d.ts

@@ -8,5 +8,6 @@ import type { GatewayAdapter, GatewayDefinition } from '../types.js';
 export declare function dinoxMcpServerConfig(options: {
     sessionToken: string;
     knowledgeTools: boolean;
+    cwd?: string;
 }): McpServer | null;
 export declare function createGatewayAdapter(gateway: GatewayDefinition, log: (message: string, details?: Record<string, unknown>) => void): GatewayAdapter;

package/dist/gateway/adapters/index.js

@@ -1,4 +1,4 @@
-import { DINOX_MCP_SERVER_NAME, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from '../mcpEnv.js';
+import { DINOX_MCP_SERVER_NAME, GATEWAY_SESSION_CWD_ENV, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from '../mcpEnv.js';
 import { AcpGatewayAdapter } from './acp.js';
 import { EchoGatewayAdapter } from './echo.js';
 /**
@@ -12,6 +12,7 @@ export function dinoxMcpServerConfig(options) {
         return null;
     const inherited = Object.entries(process.env).filter((entry) => entry[0].startsWith('DINOX_') &&
         entry[0] !== GATEWAY_SESSION_TOKEN_ENV &&
+        entry[0] !== GATEWAY_SESSION_CWD_ENV &&
         entry[0] !== GATEWAY_KNOWLEDGE_TOOLS_ENV &&
         typeof entry[1] === 'string');
     return {
@@ -20,6 +21,7 @@ export function dinoxMcpServerConfig(options) {
         args: [...process.execArgv, entrypoint, 'gateway', 'mcp'],
         env: [
             ...inherited,
+            [GATEWAY_SESSION_CWD_ENV, options.cwd ?? process.cwd()],
             [GATEWAY_SESSION_TOKEN_ENV, options.sessionToken],
             [GATEWAY_KNOWLEDGE_TOOLS_ENV, options.knowledgeTools ? '1' : '0'],
         ].map(([name, value]) => ({ name, value })),
@@ -30,8 +32,8 @@ export function createGatewayAdapter(gateway, log) {
         case 'acp':
             // Read per session, so turning the knowledge tools off applies to the next new conversation.
             // `send_file` stays offered either way: it is how the agent hands the user a file.
-            return new AcpGatewayAdapter(gateway, log, (sessionToken) => {
-                const tools = dinoxMcpServerConfig({ sessionToken, knowledgeTools: gateway.dinoxTools !== false });
+            return new AcpGatewayAdapter(gateway, log, (sessionToken, cwd) => {
+                const tools = dinoxMcpServerConfig({ sessionToken, cwd, knowledgeTools: gateway.dinoxTools !== false });
                 return tools ? [tools] : [];
             });
         case 'echo':

package/dist/gateway/deviceHost.d.ts

@@ -77,8 +77,10 @@ export declare class GatewayDeviceHost {
     private publishRunEvent;
     private flushPendingEvents;
     private handleDiscover;
-    /** Only the gateway's own queries are served; desktop queries (skills, workspace) are not advertised. */
+    /** Every reply-bearing query gets a result, including unsupported extensions. */
     private handleQuery;
+    private dispatchQuery;
+    private prepareFolder;
     private settingsResult;
     private changeSettings;
     private listFolders;

package/dist/gateway/deviceHost.js

@@ -1,13 +1,14 @@
 import os from 'node:os';
+import { listGatewayWorkspace } from './workspaceListing.js';
 import { credsAuthenticator, wsconnect, } from '@nats-io/nats-core';
 import { AI_SERVICE_URL } from '../config/serviceEndpoints.js';
 import { toAuthorizationHeaderValue } from '../utils/authToken.js';
 import { REMOTE_DEVICE_PRESENCE_INTERVAL_MS, REMOTE_DEVICE_PROTOCOL_NAME, REMOTE_DEVICE_PROTOCOL_VERSION, remoteDeviceSubject, remoteDiscoverSubject, remotePresenceSubject, remoteRunStreamSubject, } from '../vendor/electron/shared/remote-device-agent.js';
 import { projectPendingApprovals } from './assistantProjection.js';
-import { isAgentConfigQuery, isAgentFoldersQuery, isAgentSettingsQuery, isCancelRequest, isRunStatusRequest, readAgentSettingsUpdate, reconnectDelayMs, validateApprovalRequest, validateRunRequest, } from './protocol.js';
+import { isAgentConfigQuery, isAgentFolderPrepareQuery, isAgentFoldersQuery, isAgentSettingsQuery, isCancelRequest, isRunStatusRequest, readAgentSettingsUpdate, reconnectDelayMs, validateApprovalRequest, validateRunRequest, } from './protocol.js';
 import { GatewayRunExecutor, MAX_QUEUED_TURNS, QueueFullError } from './runExecutor.js';
 import { RunStreamPublisher } from './streamPublisher.js';
-import { findRun, readRecentSessionFolders, resolveTrustedResource, TERMINAL_RUN_STATUSES, threadExists, } from './threadStore.js';
+import { findRun, readRecentSessionFolders, readSessionBinding, resolveTrustedResource, TERMINAL_RUN_STATUSES, threadExists, } from './threadStore.js';
 import { uploadToOfficialStorage } from './fileUpload.js';
 import { agentHomeFolder, ensureAgentHomeFolder, existingWorkspaceFolders, listWorkspaceFolders, resolveWorkspaceFolder, WorkspaceFolderError, } from './workspaceFolders.js';
 export const DEFAULT_NATS_CREDENTIALS_URL = `${AI_SERVICE_URL}/api/nats/credentials`;
@@ -240,6 +241,7 @@ export class GatewayDeviceHost {
             connectedAt: this.connectedAt ?? new Date().toISOString(),
             busyThreadIds: this.executor.busyThreadIds(),
             capabilities: {
+                workspace: { list: true, scope: 'thread', filePreview: false },
                 threadRun: true,
                 cancel: true,
                 stream: 'assistant-snapshot',
@@ -250,6 +252,7 @@ export class GatewayDeviceHost {
         // Additive v2 extension: tells clients this device is an external agent
         // (the agent owns context; Dinox model/tool settings do not apply).
         info.capabilities.executor = {
+            agentWorkspace: true,
             kind: 'gateway',
             gatewayId: this.deps.gateway.id,
             runtime: this.deps.gateway.kind,
@@ -334,17 +337,55 @@ export class GatewayDeviceHost {
             return;
         msg.respond(encode({ protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'device.discovered', requestId, device: this.deviceInfo() }));
     }
-    /** Only the gateway's own queries are served; desktop queries (skills, workspace) are not advertised. */
+    /** Every reply-bearing query gets a result, including unsupported extensions. */
     async handleQuery(msg) {
         const { value, byteLength } = decode(msg);
         if (!msg.reply)
             return;
+        try {
+            await this.dispatchQuery(msg, value, byteLength);
+        }
+        catch (error) {
+            const requestId = value?.requestId;
+            if (typeof requestId !== 'string')
+                return;
+            msg.respond(encode({
+                protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+                type: 'query.error', requestId, ok: false,
+                error: { code: 'query_failed', message: error instanceof Error ? error.message : String(error) },
+            }));
+        }
+    }
+    async dispatchQuery(msg, value, byteLength) {
+        const raw = value;
+        if (raw?.type === 'query.cancel')
+            return;
+        if (raw?.type === 'agent.folder.prepare' && typeof raw.requestId === 'string') {
+            msg.respond(encode(await this.prepareFolder(value, raw.requestId, byteLength)));
+            return;
+        }
+        if (raw?.type === 'workspace.list' && typeof raw.requestId === 'string') {
+            msg.respond(encode(await listGatewayWorkspace(this.deps.db, this.deps.userId, this.deps.gateway, value)));
+            return;
+        }
+        if ((raw?.type === 'workspace.file.read' || raw?.type === 'skills.list') && typeof raw.requestId === 'string') {
+            const base = { protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, requestId: raw.requestId, threadId: String(raw.threadId ?? ''), ok: false, fetchedAt: new Date().toISOString(), error: { code: 'unsupported', message: 'This gateway does not support this query' } };
+            const result = raw.type === 'skills.list'
+                ? { ...base, type: 'skills.list.result', skills: [] }
+                : { ...base, type: 'workspace.file.read.result', path: String(raw.path ?? ''), preview: null, size: null };
+            msg.respond(encode(result));
+            return;
+        }
         if (isAgentConfigQuery(value)) {
             msg.respond(encode(await this.agentConfig(value)));
             return;
         }
         if (isAgentSettingsQuery(value)) {
-            msg.respond(encode(this.settingsResult(value.requestId)));
+            const result = this.settingsResult(value.requestId);
+            if (value.threadId && await threadExists(this.deps.db, value.threadId, this.deps.userId)) {
+                result.threadCwd = (await readSessionBinding(this.deps.db, value.threadId, this.deps.gateway.id))?.cwd ?? null;
+            }
+            msg.respond(encode(result));
             return;
         }
         if (isAgentFoldersQuery(value)) {
@@ -357,7 +398,34 @@ export class GatewayDeviceHost {
             msg.respond(encode('error' in update
                 ? this.settingsResult(requestId, { code: 'invalid_request', message: update.error })
                 : await this.changeSettings(update.update)));
+            return;
+        }
+        if (typeof raw?.requestId === 'string')
+            msg.respond(encode({ protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'query.error', requestId: raw.requestId, ok: false, error: { code: 'unsupported', message: 'Unsupported gateway query' } }));
+    }
+    async prepareFolder(value, requestId, byteLength) {
+        const result = {
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'agent.folder.result',
+            requestId,
+            ok: false,
+            path: null,
+            home: os.homedir(),
+            fetchedAt: new Date().toISOString(),
+        };
+        if (!isAgentFolderPrepareQuery(value, byteLength)) {
+            return { ...result, error: { code: 'invalid_request', message: 'Choose exactly one path or agent name' } };
+        }
+        try {
+            result.path = value.path !== undefined
+                ? await resolveWorkspaceFolder(value.path)
+                : await ensureAgentHomeFolder(value.agentName, undefined, value.agentId);
+            result.ok = true;
+        }
+        catch (error) {
+            result.error = settingsError(error);
         }
+        return result;
     }
     settingsResult(requestId, error) {
         const gateway = this.deps.gateway;
@@ -366,6 +434,7 @@ export class GatewayDeviceHost {
             type: 'agent.settings.result',
             requestId,
             ok: !error,
+            threadCwd: null,
             settings: {
                 cwd: gateway.cwd ?? null,
                 approval: gateway.approval ?? 'ask',

package/dist/gateway/mcpEnv.d.ts

@@ -7,3 +7,5 @@ export declare const GATEWAY_KNOWLEDGE_TOOLS_ENV = "DINOX_GATEWAY_KNOWLEDGE_TOOL
 export declare const DINOX_MCP_SERVER_NAME = "dinox-gateway";
 /** `dino mcp`, the server users register with their own MCP clients. */
 export declare const DINOX_STANDALONE_MCP_SERVER_NAME = "dinox";
+/** Session folder for resolving relative send_file paths. */
+export declare const GATEWAY_SESSION_CWD_ENV = "DINOX_GATEWAY_SESSION_CWD";

package/dist/gateway/mcpEnv.js

@@ -7,3 +7,5 @@ export const GATEWAY_KNOWLEDGE_TOOLS_ENV = 'DINOX_GATEWAY_KNOWLEDGE_TOOLS';
 export const DINOX_MCP_SERVER_NAME = 'dinox-gateway';
 /** `dino mcp`, the server users register with their own MCP clients. */
 export const DINOX_STANDALONE_MCP_SERVER_NAME = 'dinox';
+/** Session folder for resolving relative send_file paths. */
+export const GATEWAY_SESSION_CWD_ENV = 'DINOX_GATEWAY_SESSION_CWD';

package/dist/gateway/mcpServer.js

@@ -4,7 +4,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { sendDaemonRequest } from '../daemon/client.js';
-import { DINOX_MCP_SERVER_NAME, DINOX_STANDALONE_MCP_SERVER_NAME, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from './mcpEnv.js';
+import { DINOX_MCP_SERVER_NAME, DINOX_STANDALONE_MCP_SERVER_NAME, GATEWAY_SESSION_CWD_ENV, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from './mcpEnv.js';
 import { READ_CONVERSATION_MAX_LIMIT } from './conversationContext.js';
 import { getPackageVersion } from '../utils/version.js';
 /**
@@ -204,6 +204,7 @@ async function serveOverStdio(server) {
 }
 export async function serveDinoxMcpOverStdio() {
     await serveOverStdio(createDinoxMcpServer(undefined, {
+        cwd: process.env[GATEWAY_SESSION_CWD_ENV] || process.cwd(),
         knowledgeTools: process.env[GATEWAY_KNOWLEDGE_TOOLS_ENV] !== '0',
         sessionToken: process.env[GATEWAY_SESSION_TOKEN_ENV]?.trim() || undefined,
     }));

package/dist/gateway/protocol.d.ts

@@ -20,8 +20,11 @@ export type AgentConfigResult = {
     };
 };
 export declare function isAgentConfigQuery(value: unknown): value is AgentConfigQuery;
+export declare const MAX_PATH_LENGTH = 4096;
+/** Host-side workspace choice, never forwarded as an ACP session option. */
+export declare const AGENT_CWD_CONFIG_KEY = "dinox.cwd";
 export type AgentHostSettings = {
-    /** Folder new conversations start in; null until chosen (the home folder is used). */
+    /** Fallback when neither the conversation nor its agent has chosen a folder. */
     cwd: string | null;
     approval: GatewayApprovalMode;
     /** Online but refusing new turns. */
@@ -32,7 +35,7 @@ export type AgentHostSettings = {
 export type AgentSettingsChange = {
     /** An existing folder (absolute or `~/...`), checked on this computer. */
     cwd?: string;
-    /** Creates and uses the agent's own folder (`~/Dinox Agents/<name>`). */
+    /** Creates and uses the agent's own folder (`~/dinox-agents/<name>`). */
     useAgentFolder?: true;
     approval?: GatewayApprovalMode;
     paused?: boolean;
@@ -41,6 +44,7 @@ export type AgentSettingsChange = {
 export type AgentSettingsQuery = {
     protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
     type: 'agent.settings.get';
+    threadId?: string;
     requestId: string;
     clientDeviceId: string;
 };
@@ -58,6 +62,8 @@ export type AgentSettingsResult = {
     requestId: string;
     ok: boolean;
     settings: AgentHostSettings;
+    /** The conversation's folder, even after its topic has changed. */
+    threadCwd: string | null;
     /** For showing paths as `~/...`. */
     home: string;
     /** Where `useAgentFolder` puts the agent's own folder. */
@@ -99,6 +105,29 @@ export type AgentFoldersResult = {
         message: string;
     };
 };
+export type AgentFolderPrepareQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folder.prepare';
+    requestId: string;
+    clientDeviceId: string;
+    path?: string;
+    agentName?: string;
+    agentId?: string;
+};
+export type AgentFolderPrepareResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folder.result';
+    requestId: string;
+    ok: boolean;
+    path: string | null;
+    home: string;
+    fetchedAt: string;
+    error?: {
+        code: AgentSettingsErrorCode;
+        message: string;
+    };
+};
+export declare function isAgentFolderPrepareQuery(value: unknown, byteLength: number): value is AgentFolderPrepareQuery;
 export declare function isAgentSettingsQuery(value: unknown): value is AgentSettingsQuery;
 export declare function isAgentFoldersQuery(value: unknown): value is AgentFoldersQuery;
 /** The change an `agent.settings.set` asks for, or why it is malformed. */

package/dist/gateway/protocol.js

@@ -76,9 +76,21 @@ export function isAgentConfigQuery(value) {
  * `agent.settings.set`, and picks a working folder with `agent.folders.list`.
  */
 const MAX_SETTINGS_REQUEST_BYTES = 16 * 1024;
-const MAX_PATH_LENGTH = 4096;
+export const MAX_PATH_LENGTH = 4096;
+/** Host-side workspace choice, never forwarded as an ACP session option. */
+export const AGENT_CWD_CONFIG_KEY = 'dinox.cwd';
+export function isAgentFolderPrepareQuery(value, byteLength) {
+    if (!isMessageOfType(value, 'agent.folder.prepare') || !isDeviceId(value.clientDeviceId) || byteLength > MAX_SETTINGS_REQUEST_BYTES)
+        return false;
+    if ((value.path === undefined) === (value.agentName === undefined))
+        return false;
+    if (value.agentId !== undefined && (value.agentName === undefined || typeof value.agentId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value.agentId)))
+        return false;
+    const text = value.path ?? value.agentName;
+    return typeof text === 'string' && !!text.trim() && text.length <= (value.path === undefined ? MAX_AGENT_CONFIG_TEXT : MAX_PATH_LENGTH);
+}
 export function isAgentSettingsQuery(value) {
-    return isMessageOfType(value, 'agent.settings.get') && isDeviceId(value.clientDeviceId);
+    return isMessageOfType(value, 'agent.settings.get') && isDeviceId(value.clientDeviceId) && (value.threadId === undefined || isSubjectId(value.threadId));
 }
 export function isAgentFoldersQuery(value) {
     if (!isMessageOfType(value, 'agent.folders.list') || !isDeviceId(value.clientDeviceId))
@@ -139,7 +151,7 @@ export function readAgentConfig(request) {
     for (const [id, value] of entries) {
         if (!id || id.length > MAX_AGENT_CONFIG_TEXT)
             return 'invalid';
-        if (typeof value !== 'string' || !value || value.length > MAX_AGENT_CONFIG_TEXT)
+        if (typeof value !== 'string' || !value || value.length > (id === AGENT_CWD_CONFIG_KEY ? MAX_PATH_LENGTH : MAX_AGENT_CONFIG_TEXT))
             return 'invalid';
         config[id] = value;
     }

package/dist/gateway/runExecutor.js

@@ -1,8 +1,8 @@
-import os from 'node:os';
 import { AssistantProjection, projectPendingApprovals, toTranscriptMessage } from './assistantProjection.js';
 import { CONTEXT_MESSAGE_LIMIT, withConversationContext } from './conversationContext.js';
 import { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, TERMINAL_RUN_STATUSES, withdrawQueuedRun, readAgentInstructions, readCurrentTopic, readSessionBinding, readTranscriptPage, resolveTrustedResource, updateRunSnapshot, waitForMessage, withGatewaySession, writeSessionBinding, } from './threadStore.js';
-import { readAgentConfig } from './protocol.js';
+import { AGENT_CWD_CONFIG_KEY, readAgentConfig } from './protocol.js';
+import { resolveTurnWorkspace, queuedTurnPrompt } from './workspace.js';
 const SNAPSHOT_PERSIST_INTERVAL_MS = 1_000;
 /** Turns waiting behind a thread's active one; more are refused as `busy`. */
 export const MAX_QUEUED_TURNS = 10;
@@ -313,24 +313,35 @@ export class GatewayRunExecutor {
                 readSessionBinding(db, active.threadId, gateway.id),
             ]);
             const topicId = topic?.id ?? null;
-            const continued = binding?.topicId === topicId ? binding : null;
+            let continued = binding?.topicId === topicId ? binding : null;
             const turns = [...merged, request];
-            const [resources, context, instructions] = await Promise.all([
+            const tailSynced = this.clientTailSynced(turns[0], active.controller.signal);
+            const [resources, initialContext, instructions] = await Promise.all([
                 Promise.all(turns.map((turn) => this.resolveResources(turn.userMessage))).then((lists) => lists.flat()),
-                this.clientTailSynced(turns[0], active.controller.signal).then((synced) => this.unseenContext(active.threadId, turns[0].userMessage.id, topic?.createdAt ?? null, continued, synced)),
+                tailSynced.then((synced) => this.unseenContext(active.threadId, turns[0].userMessage.id, topic?.createdAt ?? null, continued, synced)),
                 readAgentInstructions(db, active.threadId).catch(() => ''),
             ]);
-            // A session keeps the directory it started in; changing the default only affects new ones.
-            const cwd = continued ? (continued.cwd ?? gateway.previousCwd ?? gateway.cwd ?? os.homedir()) : (gateway.cwd ?? os.homedir());
-            // Validated on receipt; a malformed value never reaches here.
+            let context = initialContext;
             const requestedConfig = readAgentConfig(request);
-            const agentConfig = requestedConfig && requestedConfig !== 'invalid' ? requestedConfig : undefined;
-            const prompt = turns.map((turn) => turn.prompt.trim()).filter(Boolean).join('\n\n');
+            const agentConfig = requestedConfig && requestedConfig !== 'invalid' ? { ...requestedConfig } : undefined;
+            const cwd = await resolveTurnWorkspace(gateway, binding, !!continued, agentConfig);
+            if (agentConfig)
+                delete agentConfig[AGENT_CWD_CONFIG_KEY];
+            const prompt = queuedTurnPrompt(turns.map((turn) => turn.prompt));
             const result = await adapter.runTurn({
                 sessionId: continued?.sessionId ?? null,
                 cwd,
-                sessionPreamble: sessionPreamble(instructions, { delivery: !!this.deps.uploadFile, knowledge: gateway.dinoxTools !== false }),
-                prompt: withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false }),
+                prompt: async ({ created }) => {
+                    if (created && continued) {
+                        continued = null;
+                        // A failed load has no retained history, including this gateway's own replies.
+                        const synced = await tailSynced;
+                        context = await this.unseenContext(active.threadId, turns[0].userMessage.id, topic?.createdAt ?? null, null, synced);
+                    }
+                    const text = withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false });
+                    const preamble = created && sessionPreamble(instructions, { delivery: !!this.deps.uploadFile, knowledge: gateway.dinoxTools !== false });
+                    return preamble ? `${preamble}\n\n${text}` : text;
+                },
                 resources,
                 signal: active.controller.signal,
                 config: agentConfig,

package/dist/gateway/service.d.ts

@@ -15,11 +15,13 @@ export type GatewayServiceDeps = {
  */
 export declare class GatewayService {
     private readonly deps;
+    private readonly definitions;
     private hosts;
     private readonly log;
     private readonly keepAwake;
     constructor(deps: GatewayServiceDeps);
     start(): Promise<void>;
+    private reconcile;
     stop(): Promise<void>;
     /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
     reload(): Promise<DeviceHostStatus[]>;

package/dist/gateway/service.js

@@ -23,6 +23,7 @@ const defaultLog = (message, details) => writeDaemonLogLine('dinox-gateway', mes
  */
 export class GatewayService {
     deps;
+    definitions = new Map();
     hosts = [];
     log;
     keepAwake;
@@ -32,7 +33,9 @@ export class GatewayService {
         this.keepAwake = new KeepAwake(this.log);
     }
     async start() {
-        const configured = await loadGateways(this.deps.userId);
+        await this.reconcile(await loadGateways(this.deps.userId), true);
+    }
+    async reconcile(configured, recoverOrphans) {
         const machineId = await getMachineId();
         // Reconcile before anything else, also when the last gateway was removed.
         const retired = await retireRemovedRobots(this.deps.db, {
@@ -48,10 +51,17 @@ export class GatewayService {
         const gateways = configured.filter((gateway) => gateway.enabled);
         if (gateways.length === 0)
             return;
-        const interrupted = await interruptOrphanedRuns(this.deps.db, this.deps.userId);
+        const interrupted = recoverOrphans && this.hosts.length === 0 ? await interruptOrphanedRuns(this.deps.db, this.deps.userId) : 0;
         if (interrupted > 0)
             this.log('marked runs from a previous host as interrupted', { count: interrupted });
         for (const gateway of gateways) {
+            const existing = this.hosts.find((host) => this.definitions.get(host)?.id === gateway.id);
+            if (existing) {
+                const definition = this.definitions.get(existing);
+                applyLiveSettings(definition, gateway);
+                await upsertRobot(this.deps.db, this.robotRegistration(definition, machineId)).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
+                continue;
+            }
             await upsertRobot(this.deps.db, this.robotRegistration(gateway, machineId)).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
             const host = new GatewayDeviceHost({
                 gateway,
@@ -67,18 +77,33 @@ export class GatewayService {
             });
             host.start();
             this.hosts.push(host);
+            this.definitions.set(host, gateway);
         }
     }
     async stop() {
         const hosts = this.hosts;
         this.hosts = [];
+        this.definitions.clear();
         await Promise.allSettled(hosts.map((host) => host.stop()));
         this.keepAwake.dispose();
     }
     /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
     async reload() {
-        await this.stop();
-        await this.start();
+        const configured = await loadGateways(this.deps.userId);
+        const identity = (gateway) => JSON.stringify([
+            gateway.id, gateway.deviceId, gateway.name, gateway.kind, gateway.command, gateway.args ?? [],
+            Object.entries(gateway.env ?? {}).sort(([a], [b]) => a.localeCompare(b)), gateway.enabled,
+        ]);
+        for (const host of [...this.hosts]) {
+            const previous = this.definitions.get(host);
+            const next = configured.find((gateway) => gateway.id === previous.id);
+            if (next && identity(previous) === identity(next))
+                continue;
+            await host.stop();
+            this.hosts = this.hosts.filter((candidate) => candidate !== host);
+            this.definitions.delete(host);
+        }
+        await this.reconcile(configured, false);
         return this.status();
     }
     /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */

package/dist/gateway/threadStore.d.ts

@@ -219,4 +219,6 @@ export declare function retireRemovedRobots(db: Tx, input: {
     keepIds: string[];
 }): Promise<string[]>;
 export declare function softDeleteRobot(db: Tx, robotId: string): Promise<void>;
+/** Only the settings for this robot may choose its agent's workspace. */
+export declare function readAgentWorkspace(db: Tx, threadId: string, gatewayId: string): Promise<string | null>;
 export {};

package/dist/gateway/threadStore.js

@@ -595,3 +595,16 @@ function robotMachineId(metaData) {
 export async function softDeleteRobot(db, robotId) {
     await db.execute('UPDATE c_robot SET is_del = 1, updated_at = ? WHERE id = ?', [new Date().toISOString(), robotId]);
 }
+/** Only the settings for this robot may choose its agent's workspace. */
+export async function readAgentWorkspace(db, threadId, gatewayId) {
+    const row = await db.getOptional(`SELECT p.meta_data FROM c_thread t JOIN c_project p ON p.id = t.project_id
+     WHERE t.id = ? AND (p.is_del IS NULL OR p.is_del = 0) LIMIT 1`, [threadId]);
+    try {
+        const settings = JSON.parse(row?.meta_data ?? '{}').runSettings;
+        const value = settings?.robotId === gatewayId ? settings.values?.['dinox.cwd'] : null;
+        return typeof value === 'string' && value.length > 0 && value.length <= 4096 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/gateway/types.d.ts

@@ -26,7 +26,7 @@ export type GatewayDefinition = {
     /** ACP: executable started over stdio, e.g. `hermes` with args `["acp"]`. */
     command?: string;
     args?: string[];
-    /** Working directory for new agent sessions (each session keeps the one it started in). */
+    /** Last configured fallback after the conversation's and agent's working folders. */
     cwd?: string;
     /**
      * Directory of sessions bound before sessions recorded their own: the
@@ -118,9 +118,10 @@ export type GatewayTurnInput = {
     sessionId: string | null;
     /** Working directory of the session (a new one starts here; a continued one is loaded with it). */
     cwd: string;
-    prompt: string;
-    /** Prepended to the prompt when the turn starts a new session, e.g. the agent's instructions. */
-    sessionPreamble?: string;
+    /** Build context only after the adapter knows whether history survived. */
+    prompt: (session: {
+        created: boolean;
+    }) => Promise<string>;
     /** Attachments the user sent with this turn (trusted, https). */
     resources: Array<{
         uri: string;

package/dist/gateway/workspace.d.ts

@@ -0,0 +1,5 @@
+import type { GatewayDefinition } from './types.js';
+import type { GatewaySessionBinding } from './threadStore.js';
+/** A topic reset changes context, while the conversation keeps its folder. */
+export declare function resolveTurnWorkspace(gateway: GatewayDefinition, binding: GatewaySessionBinding | null, continued: boolean, config?: Record<string, string>): Promise<string>;
+export declare function queuedTurnPrompt(prompts: string[]): string;

package/dist/gateway/workspace.js

@@ -0,0 +1,30 @@
+import os from 'node:os';
+import { AGENT_CWD_CONFIG_KEY } from './protocol.js';
+import { resolveWorkspaceFolder } from './workspaceFolders.js';
+/** A topic reset changes context, while the conversation keeps its folder. */
+export async function resolveTurnWorkspace(gateway, binding, continued, config) {
+    if (continued)
+        return binding?.cwd ?? gateway.previousCwd ?? gateway.cwd ?? os.homedir();
+    if (binding?.cwd)
+        return binding.cwd;
+    const requested = config?.[AGENT_CWD_CONFIG_KEY];
+    if (requested) {
+        try {
+            return await resolveWorkspaceFolder(requested);
+        }
+        catch (error) {
+            throw new Error(`Working folder is unavailable: ${requested} (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    return gateway.cwd ?? os.homedir();
+}
+export function queuedTurnPrompt(prompts) {
+    if (prompts.length === 1)
+        return prompts[0].trim();
+    return [
+        '<dinox_queued_messages>',
+        'The user sent these messages one after another while you were busy. Answer them together.',
+        ...prompts.map((text, index) => `[Message ${index + 1}] ${text.trim().replaceAll('</dinox_queued_messages>', '<\\/dinox_queued_messages>')}`),
+        '</dinox_queued_messages>',
+    ].join('\n');
+}

package/dist/gateway/workspaceFolders.d.ts

@@ -18,10 +18,12 @@ export type WorkspaceFolder = {
 };
 /** The folder an agent may work in, resolved to its real path. */
 export declare function resolveWorkspaceFolder(input: string, home?: string): Promise<string>;
-/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
-export declare function agentHomeFolder(agentName: string, home?: string): string;
+/** A portable folder name, optionally distinguished by the agent ID's last six characters. */
+export declare function agentFolderName(name: string, agentId?: string | null): string;
+/** `~/dinox-agents/<name>`: a folder of the agent's own, offered as the default choice. */
+export declare function agentHomeFolder(agentName: string, home?: string, agentId?: string | null): string;
 /** Creates the agent's own folder when missing; the only folder the app can create. */
-export declare function ensureAgentHomeFolder(agentName: string, home?: string): Promise<string>;
+export declare function ensureAgentHomeFolder(agentName: string, home?: string, agentId?: string | null): Promise<string>;
 /** The visible subfolders of a folder (the home folder included), for browsing. */
 export declare function listWorkspaceFolders(input: string | null | undefined, home?: string): Promise<{
     path: string;

package/dist/gateway/workspaceFolders.js

@@ -13,7 +13,7 @@ const MAX_FOLDERS = 200;
 /** Home-level folders that hold system data rather than the user's work. */
 const SYSTEM_FOLDERS = new Set(['Library', 'Applications']);
 const SKIPPED_FOLDERS = new Set(['node_modules']);
-const AGENT_HOME_PARENT = 'Dinox Agents';
+const AGENT_HOME_PARENT = 'dinox-agents';
 async function realHome(home) {
     return fs.realpath(home).catch(() => path.resolve(home));
 }
@@ -73,14 +73,27 @@ export async function resolveWorkspaceFolder(input, home = os.homedir()) {
     }
     return real;
 }
-/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
-export function agentHomeFolder(agentName, home = os.homedir()) {
-    const safeName = agentName.replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, '').trim() || 'Agent';
-    return path.join(home, AGENT_HOME_PARENT, safeName.slice(0, 64));
+/** A portable folder name, optionally distinguished by the agent ID's last six characters. */
+export function agentFolderName(name, agentId) {
+    let base = name.normalize('NFC')
+        .replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, '')
+        .replace(/\s+/g, '-')
+        .toLowerCase()
+        .replace(/-+/g, '-')
+        .replace(/^[-.]+|[-.]+$/g, '');
+    base = Array.from(base).slice(0, 48).join('').replace(/[-.]+$/g, '') || 'agent';
+    if (/^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/.test(base))
+        base += '-agent';
+    const suffix = agentId?.replace(/[^a-z0-9]/gi, '').toLowerCase().slice(-6);
+    return suffix ? `${base}-${suffix}` : base;
+}
+/** `~/dinox-agents/<name>`: a folder of the agent's own, offered as the default choice. */
+export function agentHomeFolder(agentName, home = os.homedir(), agentId) {
+    return path.join(home, AGENT_HOME_PARENT, agentFolderName(agentName, agentId));
 }
 /** Creates the agent's own folder when missing; the only folder the app can create. */
-export async function ensureAgentHomeFolder(agentName, home = os.homedir()) {
-    const folder = agentHomeFolder(agentName, home);
+export async function ensureAgentHomeFolder(agentName, home = os.homedir(), agentId) {
+    const folder = agentHomeFolder(agentName, home, agentId);
     await fs.mkdir(folder, { recursive: true, mode: 0o755 });
     return resolveWorkspaceFolder(folder, home);
 }

package/dist/gateway/workspaceListing.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type RemoteDeviceWorkspaceListRequest, type RemoteDeviceWorkspaceListResponse } from '../vendor/electron/shared/remote-device-agent.js';
+import type { GatewayDefinition } from './types.js';
+/** Wire paths stay relative even when a directory on disk is a symlink. */
+export declare function listGatewayWorkspace(db: AbstractPowerSyncDatabase, userId: string, gateway: GatewayDefinition, request: RemoteDeviceWorkspaceListRequest): Promise<RemoteDeviceWorkspaceListResponse>;

package/dist/gateway/workspaceListing.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { REMOTE_DEVICE_PROTOCOL_VERSION, } from '../vendor/electron/shared/remote-device-agent.js';
+import { readAgentWorkspace, readSessionBinding, threadExists } from './threadStore.js';
+import { resolveWorkspaceFolder } from './workspaceFolders.js';
+const SUBJECT_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const DEVICE_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const IGNORED_NAMES = new Set(['node_modules', 'build', 'coverage', 'dist']);
+function withinRoot(root, target) {
+    const relative = path.relative(root, target);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+/** Wire paths stay relative even when a directory on disk is a symlink. */
+export async function listGatewayWorkspace(db, userId, gateway, request) {
+    const base = {
+        protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'workspace.list.result', requestId: request.requestId,
+        threadId: request.threadId, parentPath: '', ok: false, entries: [], nextCursor: null, truncated: false, fetchedAt: new Date().toISOString(),
+    };
+    const fail = (code, message) => ({ ...base, error: { code, message } });
+    const parent = request.parentPath ?? '';
+    if (request.protocolVersion !== REMOTE_DEVICE_PROTOCOL_VERSION ||
+        typeof request.requestId !== 'string' || !SUBJECT_ID.test(request.requestId) ||
+        typeof request.threadId !== 'string' || !SUBJECT_ID.test(request.threadId) ||
+        typeof request.clientDeviceId !== 'string' || !DEVICE_ID.test(request.clientDeviceId))
+        return fail('invalid_request', 'Invalid query identity');
+    if (typeof parent !== 'string' || parent.length > 2048 || parent.includes('\\') ||
+        path.win32.isAbsolute(parent) || parent.startsWith('/') ||
+        (parent && parent.split('/').some((part) => !part || part === '.' || part === '..' || part === '.git' || part === 'node_modules')))
+        return fail('invalid_request', 'Invalid workspace path');
+    base.parentPath = parent;
+    const cursor = request.cursor;
+    const offset = cursor === undefined || cursor === null || cursor === '' ? 0 : typeof cursor === 'string' && /^\d{1,8}$/.test(cursor) ? Number(cursor) : null;
+    if (offset === null)
+        return fail('invalid_request', 'Invalid workspace cursor');
+    try {
+        if (!(await threadExists(db, request.threadId, userId)))
+            return fail('thread_not_found', 'Conversation not found');
+        const binding = await readSessionBinding(db, request.threadId, gateway.id);
+        const agentFolder = binding?.cwd ? null : await readAgentWorkspace(db, request.threadId, gateway.id);
+        const root = binding?.cwd ?? (agentFolder ? await resolveWorkspaceFolder(agentFolder) : gateway.cwd);
+        if (!root)
+            return { ...base, ok: true };
+        const rootReal = await fs.realpath(root);
+        const target = await fs.realpath(path.resolve(rootReal, ...parent.split('/')));
+        if (path.relative(rootReal, target).split(path.sep).some((part) => part === '.git' || part === 'node_modules'))
+            return fail('invalid_request', 'Directory contents are unavailable');
+        if (!withinRoot(rootReal, target))
+            return fail('invalid_request', 'Workspace path escapes its root');
+        if (!(await fs.stat(target)).isDirectory())
+            return fail('invalid_request', 'Workspace path is not a directory');
+        const rank = (entry) => entry.isDirectory() ? 0 : entry.isSymbolicLink() ? 2 : 1;
+        const all = (await fs.readdir(target, { withFileTypes: true }))
+            .filter((entry) => !!entry.name && !entry.name.startsWith('.') && !entry.name.includes('\\') && !IGNORED_NAMES.has(entry.name))
+            .sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name, undefined, { numeric: true }));
+        const bounded = all.slice(0, 5000);
+        if (offset > bounded.length)
+            return fail('invalid_request', 'Invalid workspace cursor');
+        const limit = typeof request.limit === 'number' && Number.isFinite(request.limit) ? Math.min(200, Math.max(1, Math.trunc(request.limit))) : 100;
+        const page = bounded.slice(offset, offset + limit);
+        const entries = await Promise.all(page.map(async (entry) => {
+            const kind = entry.isSymbolicLink() ? 'symlink' : entry.isDirectory() ? 'directory' : 'file';
+            const stat = await fs.lstat(path.join(target, entry.name)).catch(() => null);
+            return {
+                path: parent ? `${parent}/${entry.name}` : entry.name,
+                name: entry.name,
+                kind,
+                hasChildren: kind === 'directory',
+                ...(stat?.isFile() ? { size: stat.size } : {}),
+                ...(stat ? { modifiedAt: stat.mtime.toISOString() } : {}),
+            };
+        }));
+        const next = offset + page.length;
+        return { ...base, ok: true, entries, nextCursor: next < bounded.length ? String(next) : null, truncated: all.length > bounded.length };
+    }
+    catch (error) {
+        return fail('query_failed', error instanceof Error ? error.message : String(error));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {