newmark-agent 0.3.11 → 0.4.0

package/dist/core/wslAgentClient.js

@@ -317,6 +317,10 @@ class WslAgentClient {
         await this.start();
         return await this.request('checkpoint', { target: await this.mapTarget(target) }, 5_000);
     }
+    async contextCompress(target, options = {}) {
+        await this.start();
+        return await this.request('context_compress', { target: await this.mapTarget(target), options }, 120_000);
+    }
     async rateAutoRoute(target, score, routeId = '') {
         await this.start();
         return await this.request('rate_auto_route', {

package/dist/core/wslAgentProtocol.d.ts

@@ -1,5 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { AgentPromptMessage, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueMode, ConversationStopResult } from './conversationKernel';
+import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueMode, ConversationStopResult } from './conversationKernel';
 import { ConversationRuntimeTarget } from './conversationTarget';
 import { TerminalTakeoverEvent, TerminalTakeoverOwnerFilter, TerminalTakeoverState } from '../tools/terminalTakeover';
 import { BrowserUseRequest } from './browserUse';
@@ -114,6 +114,13 @@ export type WslAgentRequest = {
     params: {
         target: ConversationRuntimeTarget;
     };
+} | {
+    id: string;
+    method: 'context_compress';
+    params: {
+        target: ConversationRuntimeTarget;
+        options?: ConversationContextCompressOptions;
+    };
 } | {
     id: string;
     method: 'rate_auto_route';

package/dist/core/wslAgentRuntimePool.d.ts

@@ -11,6 +11,10 @@ export interface WslTargetRuntimeClient {
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<WslAgentStopResult>;
     enqueueGuide(target: ConversationRuntimeTarget, envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
+    contextCompress?(target: ConversationRuntimeTarget, options?: {
+        keepRecent?: number;
+        force?: boolean;
+    }): Promise<Record<string, unknown>>;
     rateAutoRoute?(target: ConversationRuntimeTarget, score: number, routeId?: string): Promise<WslAutoRouteRatingResult>;
     setWorkRunExpanded(target: ConversationRuntimeTarget, runId: string, expanded: boolean): Promise<boolean>;
     setMode?(target: ConversationRuntimeTarget, mode: AgentMode): Promise<AgentMode>;
@@ -56,6 +60,7 @@ export declare class WslAgentRuntimePool {
     private hostToolHandler;
     private restarting;
     private disposing;
+    private forceStopPromises;
     private capacityTail;
     private accessSequence;
     constructor(distro: string, windowsRoot: string, windowsHostScript: string, createClient?: WslTargetRuntimeClientFactory, options?: WslAgentRuntimePoolOptions);
@@ -68,6 +73,10 @@ export declare class WslAgentRuntimePool {
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<WslPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
+    contextCompress(target: ConversationRuntimeTarget, options?: {
+        keepRecent?: number;
+        force?: boolean;
+    }): Promise<Record<string, unknown>>;
     rateAutoRoute(target: ConversationRuntimeTarget, score: number, routeId?: string): Promise<WslAutoRouteRatingResult>;
     setWorkRunExpanded(target: ConversationRuntimeTarget, runId: string, expanded: boolean): Promise<boolean>;
     setInputMode(target: ConversationRuntimeTarget, mode: string): Promise<'guide' | 'next' | null>;
@@ -90,6 +99,9 @@ export declare class WslAgentRuntimePool {
     hasActiveWorkspace(target: ConversationRuntimeTarget): Promise<boolean>;
     stopWorkspace(target: ConversationRuntimeTarget): Promise<void>;
     stopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    /** Hard-stop a target for destructive lifecycle actions such as archive. */
+    forceStopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    private forceStopTargetInternal;
     stopAll(): Promise<void>;
     private throwStopFailures;
     private stopEntry;

package/dist/core/wslAgentRuntimePool.js

@@ -20,6 +20,7 @@ class WslAgentRuntimePool {
     hostToolHandler = null;
     restarting = new Set();
     disposing = new Set();
+    forceStopPromises = new Map();
     capacityTail = Promise.resolve();
     accessSequence = 0;
     constructor(distro, windowsRoot, windowsHostScript, createClient = (target) => new wslAgentClient_1.WslAgentClient(distro, windowsRoot, windowsHostScript, target), options = {}) {
@@ -213,6 +214,21 @@ class WslAgentRuntimePool {
             this.release(entry, true);
         }
     }
+    async contextCompress(target, options = {}) {
+        const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
+        const entry = await this.acquire(normalized);
+        try {
+            if (entry.stopIntent)
+                return { ok: false, error: 'Context compression is unavailable while this conversation is stopping.' };
+            if (!entry.client.contextCompress)
+                return { ok: false, error: 'Context compression is unavailable in this runtime.' };
+            entry.lastSnapshot = null;
+            return await entry.client.contextCompress(normalized, options);
+        }
+        finally {
+            this.release(entry, true);
+        }
+    }
     async rateAutoRoute(target, score, routeId = '') {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
         const entry = await this.acquireExisting(normalized);
@@ -356,6 +372,61 @@ class WslAgentRuntimePool {
         if (entry)
             await this.stopEntry(entry);
     }
+    /** Hard-stop a target for destructive lifecycle actions such as archive. */
+    async forceStopTarget(target) {
+        const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
+        const existing = this.forceStopPromises.get(normalized.runtimeKey);
+        if (existing)
+            return existing;
+        const operation = this.forceStopTargetInternal(normalized);
+        this.forceStopPromises.set(normalized.runtimeKey, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.forceStopPromises.get(normalized.runtimeKey) === operation) {
+                this.forceStopPromises.delete(normalized.runtimeKey);
+            }
+        }
+    }
+    async forceStopTargetInternal(target) {
+        let entry;
+        await this.serializeCapacity(async () => {
+            entry = this.entries.get(target.runtimeKey);
+            if (entry)
+                this.disposing.add(target.runtimeKey);
+        });
+        if (!entry)
+            return;
+        const intent = entry.stopIntent || {
+            runId: entry.lastRunId,
+            generation: entry.lastGeneration,
+            checkpointed: false,
+            forcePromise: null,
+        };
+        if (!entry.stopIntent)
+            entry.stopIntent = intent;
+        try {
+            await this.forceTerminateEntry(entry, intent);
+            if (entry.client.status().connected) {
+                if (entry.client.forceStopRuntimeGroup)
+                    await entry.client.forceStopRuntimeGroup();
+                else
+                    await entry.client.forceRestartRuntimeGroup();
+            }
+            if (entry.client.status().connected) {
+                throw new Error(`WSL runtime ${target.runtimeKey} remained connected after force stop`);
+            }
+            if (this.entries.get(target.runtimeKey) === entry) {
+                this.entries.delete(target.runtimeKey);
+                entry.unsubscribe();
+                entry.client.setHostToolHandler(null);
+            }
+        }
+        finally {
+            this.disposing.delete(target.runtimeKey);
+        }
+    }
     async stopAll() {
         const targets = Array.from(this.entries.values(), entry => entry.target);
         const results = await Promise.allSettled(targets.map(target => this.stopTarget(target)));

package/dist/launcher.js

@@ -43,19 +43,35 @@ const agent_1 = require("./core/agent");
 const flow_1 = require("./core/flow");
 const flow_runner_1 = require("./core/flow-runner");
 const cli_commands_1 = require("./cli-commands");
+const cli_discovery_1 = require("./cli-discovery");
 const installUpdate_1 = require("./core/installUpdate");
 const cli_help_1 = require("./cli-help");
-const args = process.argv.slice(2);
+const rawArgs = process.argv.slice(2);
+const args = rawArgs[0] === '--' ? rawArgs.slice(1) : rawArgs;
 const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const cliCommand = args.find(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const isEdit = args[0] === 'edit';
+const editFile = isEdit ? args[1] : '';
+const isFlow = args[0] === 'flow';
 const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
-const isVersionArg = !hasCliCommand && args.some(arg => ['--version', '-v'].includes(arg.toLowerCase()));
+const isVersionArg = !hasCliCommand && (0, cli_discovery_1.isVersionArgument)(args);
+const isReadOnlyValidation = hasCliCommand && args.includes('validate-models') && !args.includes('--persist');
 const isTui = args.some(arg => arg.toLowerCase() === '--tui');
 const isGui = args.some(arg => arg.toLowerCase() === '--gui');
 const isCli = args.includes('--cli');
 const isServer = args.includes('--server');
-const isEdit = args[0] === 'edit';
-const editFile = isEdit ? args[1] : '';
-const isFlow = args[0] === 'flow';
+const invalidArgument = (0, cli_discovery_1.invalidTopLevelArgument)(args);
+if (invalidArgument) {
+    console.error(`Invalid Newmark argument: ${invalidArgument}`);
+    process.exit(2);
+}
+// Command help is a terminating, read-only discovery operation. Resolve it
+// before first-run initialization or GUI forwarding so `Newmark.exe send
+// --help` cannot accidentally enter Electron or instantiate an Agent.
+if (hasCliCommand && cliCommand && (0, cli_commands_1.cliHelpRequested)(args)) {
+    console.log((0, cli_commands_1.cliCommandHelp)(cliCommand));
+    process.exit(0);
+}
 function pathArgValue(values, key) {
     const prefix = `${key}=`;
     const inlineIdx = values.findIndex(a => a.startsWith(prefix));
@@ -89,6 +105,15 @@ function pathArgValue(values, key) {
     }
     return best || parts.join(' ') || undefined;
 }
+function resolveTuiWorkspacePath(values, root) {
+    const explicitWorkspace = pathArgValue(values, '--workspace');
+    if (explicitWorkspace)
+        return explicitWorkspace;
+    // An explicitly isolated runtime must not silently register the caller's
+    // cwd as an external workspace. Keep the opt-in --workspace escape hatch,
+    // while making the safe one-argument form fully self-contained.
+    return pathArgValue(values, '--root') ? root : process.cwd();
+}
 function userRuntimeRoot() {
     return path.join(os.homedir(), '.Newmark');
 }
@@ -174,18 +199,30 @@ function writableRuntimeRoot(candidate) {
 const explicitRoot = pathArgValue(args, '--root');
 const root = explicitRoot ? writableRuntimeRoot(explicitRoot) : userRuntimeRoot();
 if (isHelpArg) {
-    console.log((0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    console.log(isFlow ? (0, cli_help_1.newmarkFlowHelpText)() : isEdit ? (0, cli_help_1.newmarkEditHelpText)() : (0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
     process.exit(0);
 }
 if (isVersionArg) {
     console.log((0, installUpdate_1.currentAppVersion)());
     process.exit(0);
 }
-function firstRunInit(r) {
+const unknownCommand = !hasCliCommand && !isTui && !isGui && !isCli && !isServer && !isFlow && !isEdit
+    ? (0, cli_discovery_1.unknownTopLevelCommand)(args)
+    : undefined;
+if (unknownCommand) {
+    console.error(`Unknown Newmark command or argument: ${unknownCommand}. Run --help to see the supported entrypoints.`);
+    process.exit(2);
+}
+function firstRunInit(r, options = {}) {
     fs.mkdirSync(r, { recursive: true });
-    migrateLegacyRuntimeRoot(r);
+    // Legacy AppData migration is only valid for the canonical user runtime.
+    // An explicit --root is an isolation boundary (tests, portable roots, and
+    // caller-selected workspaces) and must never inherit the user's sessions,
+    // archives, providers, or workspaces.
+    if (path.resolve(r) === path.resolve(userRuntimeRoot()))
+        migrateLegacyRuntimeRoot(r);
     const { ensureRootConfig } = require('./core/config');
-    ensureRootConfig(r);
+    ensureRootConfig(r, options);
     if (!fs.existsSync(path.join(r, 'agent.md'))) {
         fs.writeFileSync(path.join(r, 'agent.md'), '# Newmark Agent\n\nYou are a powerful coding assistant.\n', 'utf-8');
     }
@@ -270,13 +307,13 @@ function launchGui() {
     console.error('Unable to locate the Newmark GUI runtime. Reinstall newmark-agent with optional dependencies enabled, or install a Newmark desktop package.');
     process.exit(1);
 }
-firstRunInit(root);
+firstRunInit(root, { readOnly: isReadOnlyValidation });
 if (isGui) {
     launchGui();
 }
 else if (isTui) {
     const { start } = require('./tui/src/app');
-    start({ root, workspacePath: process.cwd(), desktopDist: __dirname });
+    start({ root, workspacePath: resolveTuiWorkspacePath(args, root), desktopDist: __dirname });
 }
 else if (hasCliCommand) {
     (0, cli_commands_1.runCliCommand)(root, args).then(handled => {

package/dist/llm/provider.d.ts

@@ -28,9 +28,12 @@ export declare class LLMProvider {
     explicitProtocol?: ProviderProtocol | undefined;
     openAIMode: OpenAITransportMode | boolean;
     useProviderAdaptersV2: boolean;
+    requestTimeoutMs: number;
     static nodeHttpTransport: ((method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: string) => Promise<NodeHttpResult>) | null;
     static powershellTransport: ((method: 'GET' | 'POST', url: string, headers: Record<string, string>, body?: string) => Promise<NodeHttpResult>) | null;
-    constructor(name: string, baseUrl: string, apiKey: string, explicitProtocol?: ProviderProtocol | undefined, openAIMode?: OpenAITransportMode | boolean, useProviderAdaptersV2?: boolean);
+    constructor(name: string, baseUrl: string, apiKey: string, explicitProtocol?: ProviderProtocol | undefined, openAIMode?: OpenAITransportMode | boolean, useProviderAdaptersV2?: boolean, requestTimeoutMs?: number);
+    private effectiveRequestTimeout;
+    private withRequestTimeout;
     intelligenceConfig(tier: string): IntelligenceConfig;
     private reasoningEffort;
     private applyChatReasoningEffort;
@@ -85,16 +88,16 @@ export declare class LLMProvider {
     private toStreamUsage;
     private shouldDowngradeToResponses;
     /**
-     * Loopback-aware transport injected into adapter `execute`. Mirrors the
-     * legacy orchestration exactly: streaming requests go through fetch with a
-     * 120s timeout and degrade to a non-streaming node-http request on fetch
-     * failure; non-streaming requests reuse postJsonWithFetchFallback.
+     * Loopback-aware transport injected into adapter `execute`. Streaming
+     * requests retain the fetch-to-node fallback for transport failures, while
+     * a local deadline is returned directly so one request cannot become a
+     * second Windows fallback request.
      */
     private buildProviderAdapterTransport;
     private toTransportResponse;
     private toNormalizedMessages;
     private toNormalizedTools;
-    chatStreamWithTools(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, tools: unknown[], signal?: AbortSignal, reasoningTier?: string): AsyncGenerator<StreamToken>;
+    chatStreamWithTools(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, tools: unknown[], signal?: AbortSignal, reasoningTier?: string, sessionId?: string): AsyncGenerator<StreamToken>;
     /**
      * GitHub Models streaming path. Preserved as a dedicated implementation
      * because the provider adapters (V2) do not serialize the GitHub Models

package/dist/llm/provider.js

@@ -43,6 +43,19 @@ const child_process_1 = require("child_process");
 const agentKernelDiagnostics_1 = require("../core/agentKernelDiagnostics");
 const chat_messages_1 = require("../providers/chat-messages");
 const providers_1 = require("../providers");
+// Keep provider requests below the release-harness/user-visible command
+// deadline. A provider that does not answer must produce one bounded error;
+// it must not restart the same request through every Windows transport.
+const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 90_000;
+const MIN_PROVIDER_REQUEST_TIMEOUT_MS = 50;
+function providerTimeoutError(timeoutMs) {
+    const error = new Error(`Provider request timed out after ${timeoutMs}ms`);
+    error.name = 'TimeoutError';
+    return error;
+}
+function isProviderTimeoutError(error) {
+    return error instanceof Error && error.name === 'TimeoutError';
+}
 function abortFailure(signal) {
     const reason = signal?.reason;
     const error = reason instanceof Error ? reason : new Error(reason ? String(reason) : 'LLM request aborted');
@@ -84,15 +97,37 @@ class LLMProvider {
     explicitProtocol;
     openAIMode;
     useProviderAdaptersV2;
+    requestTimeoutMs;
     static nodeHttpTransport = null;
     static powershellTransport = null;
-    constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false) {
+    constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false, requestTimeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
         this.name = name;
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
         this.explicitProtocol = explicitProtocol;
         this.openAIMode = openAIMode;
         this.useProviderAdaptersV2 = useProviderAdaptersV2;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    effectiveRequestTimeout(timeoutMs) {
+        const requested = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
+        const configured = Number.isFinite(this.requestTimeoutMs) && this.requestTimeoutMs > 0
+            ? this.requestTimeoutMs
+            : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
+        return Math.max(MIN_PROVIDER_REQUEST_TIMEOUT_MS, Math.min(requested, configured));
+    }
+    async withRequestTimeout(promise, timeoutMs, signal) {
+        let timer;
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(providerTimeoutError(timeoutMs)), timeoutMs);
+        });
+        try {
+            return await abortable(Promise.race([promise, timeoutPromise]), signal);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
     }
     intelligenceConfig(tier) {
         switch (tier) {
@@ -212,6 +247,7 @@ class LLMProvider {
         };
     }
     async postJsonWithFetchFallback(url, headers, body, timeoutMs = 120000, signal) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         // Electron utility processes can leave an undici response body pending when
         // several isolated workers concurrently call a plain-HTTP local provider.
         // Node's HTTP client owns the full body lifecycle and is deterministic for
@@ -224,7 +260,7 @@ class LLMProvider {
                 return '';
             } })();
             this.transportDiagnostic('loopback:start', pathname);
-            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal);
+            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
             this.transportDiagnostic('loopback:complete', `status=${local.status} bytes=${Buffer.byteLength(local.body || '')}`);
             return {
                 ok: local.status >= 200 && local.status < 300,
@@ -240,7 +276,7 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const timer = setTimeout(() => abort.abort(), timeoutMs);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
             const response = await fetch(url, {
                 method: 'POST',
@@ -253,9 +289,11 @@ class LLMProvider {
         catch (e) {
             if (signal?.aborted)
                 throw abortFailure(signal);
+            if (abort.signal.aborted)
+                throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal);
+            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -270,16 +308,19 @@ class LLMProvider {
         }
     }
     async getJsonWithFetchFallback(url, headers, timeoutMs = 30000) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         const abort = new AbortController();
-        const timer = setTimeout(() => abort.abort(), timeoutMs);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
             const response = await fetch(url, { method: 'GET', headers, signal: abort.signal });
             return response;
         }
         catch (e) {
+            if (abort.signal.aborted)
+                throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('GET', url, headers);
+            const fallback = await this.nodeHttpJson('GET', url, headers, '', undefined, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -293,16 +334,21 @@ class LLMProvider {
         }
     }
     shouldUseNodeHttpFallback(error) {
-        return ((error instanceof TypeError && /fetch failed/i.test(error.message)) ||
-            (error instanceof Error && /abort/i.test(error.name || error.message)));
+        // Abort is a completed control decision (user cancellation or our own
+        // deadline), not evidence that a second transport can succeed. Retrying it
+        // on Windows used to create a second 120s request after the first timeout.
+        return error instanceof TypeError && /fetch failed/i.test(error.message);
     }
-    nodeHttpJson(method, urlValue, headers, body = '', signal) {
+    nodeHttpJson(method, urlValue, headers, body = '', signal, timeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         if (LLMProvider.nodeHttpTransport) {
-            return abortable(LLMProvider.nodeHttpTransport(method, urlValue, headers, body), signal).catch(error => {
+            return this.withRequestTimeout(LLMProvider.nodeHttpTransport(method, urlValue, headers, body), effectiveTimeout, signal).catch(error => {
                 if (signal?.aborted)
                     throw abortFailure(signal);
+                if (isProviderTimeoutError(error))
+                    throw error;
                 if (process.platform === 'win32') {
-                    return this.powershellJson(method, urlValue, headers, body, signal);
+                    return this.powershellJson(method, urlValue, headers, body, signal, effectiveTimeout);
                 }
                 throw error;
             });
@@ -350,8 +396,8 @@ class LLMProvider {
                         fail(new Error('Node HTTP response closed before completion'));
                 });
             });
-            req.setTimeout(120000, () => {
-                req.destroy(new Error('Node HTTP fallback timeout'));
+            req.setTimeout(effectiveTimeout, () => {
+                req.destroy(providerTimeoutError(effectiveTimeout));
             });
             req.on('error', reject);
             const onAbort = () => req.destroy(abortFailure(signal));
@@ -366,15 +412,18 @@ class LLMProvider {
         }).catch(error => {
             if (signal?.aborted)
                 throw abortFailure(signal);
+            if (isProviderTimeoutError(error))
+                throw error;
             if (process.platform === 'win32') {
-                return this.powershellJson(method, urlValue, headers, body, signal);
+                return this.powershellJson(method, urlValue, headers, body, signal, effectiveTimeout);
             }
             throw error;
         });
     }
-    powershellJson(method, urlValue, headers, body = '', signal) {
+    powershellJson(method, urlValue, headers, body = '', signal, timeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         if (LLMProvider.powershellTransport) {
-            return LLMProvider.powershellTransport(method, urlValue, headers, body);
+            return this.withRequestTimeout(LLMProvider.powershellTransport(method, urlValue, headers, body), effectiveTimeout, signal);
         }
         return new Promise((resolve, reject) => {
             const headerJson = JSON.stringify(headers);
@@ -403,7 +452,7 @@ class LLMProvider {
                 '  $raw = $headerJson | ConvertFrom-Json',
                 '  foreach ($p in $raw.PSObject.Properties) { $headers[$p.Name] = [string]$p.Value }',
                 '}',
-                '$params = @{ Uri = $uri; Method = $method; Headers = $headers; UseBasicParsing = $true; TimeoutSec = 120 }',
+                `'$params = @{ Uri = $uri; Method = $method; Headers = $headers; UseBasicParsing = $true; TimeoutSec = ${Math.max(1, Math.ceil(effectiveTimeout / 1000))} }`,
                 'if ($method -eq "POST") { $params["Body"] = $bodyJson }',
                 'if ($method -eq "POST") { $params["ContentType"] = "application/json; charset=utf-8" }',
                 '$resp = Invoke-WebRequest @params',
@@ -437,8 +486,8 @@ class LLMProvider {
             const timer = setTimeout(() => {
                 child.kill();
                 cleanup();
-                reject(new Error('PowerShell HTTP fallback timeout'));
-            }, 130000);
+                reject(providerTimeoutError(effectiveTimeout));
+            }, effectiveTimeout + 5000);
             child.stdout.setEncoding('utf8');
             child.stderr.setEncoding('utf8');
             child.stdout.on('data', chunk => { stdout += chunk; });
@@ -794,7 +843,7 @@ class LLMProvider {
      * The emitted request body and StreamToken stream are byte-equivalent to
      * the legacy inlined path.
      */
-    async *chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier) {
+    async *chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier, sessionId) {
         const mode = this.openAITransportMode();
         if (mode === 'responses') {
             yield* this.adapterResponsesBridge(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier);
@@ -812,6 +861,7 @@ class LLMProvider {
             maxOutputTokens: maxTokens,
             apiKey: this.apiKey,
             baseUrl: this.cleanBaseUrl(),
+            ...(sessionId ? { sessionId } : {}),
         };
         const serialized = await adapter.serializeRequest(request);
         serialized.body.stream = mode === 'chat' ? false : true;
@@ -926,10 +976,10 @@ class LLMProvider {
         return this.shouldUseResponsesFallback(Number(match[1]), errorText);
     }
     /**
-     * Loopback-aware transport injected into adapter `execute`. Mirrors the
-     * legacy orchestration exactly: streaming requests go through fetch with a
-     * 120s timeout and degrade to a non-streaming node-http request on fetch
-     * failure; non-streaming requests reuse postJsonWithFetchFallback.
+     * Loopback-aware transport injected into adapter `execute`. Streaming
+     * requests retain the fetch-to-node fallback for transport failures, while
+     * a local deadline is returned directly so one request cannot become a
+     * second Windows fallback request.
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
@@ -940,7 +990,8 @@ class LLMProvider {
                     forwardAbort();
                 else
                     signal?.addEventListener('abort', forwardAbort, { once: true });
-                const timer = setTimeout(() => abort.abort(), 120000);
+                const effectiveTimeout = this.effectiveRequestTimeout(120000);
+                const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
                 try {
                     try {
                         return await fetch(request.url, {
@@ -953,11 +1004,13 @@ class LLMProvider {
                     catch (error) {
                         if (signal?.aborted)
                             throw abortFailure(signal);
+                        if (abort.signal.aborted)
+                            throw abortFailure(abort.signal);
                         if (!this.shouldUseNodeHttpFallback(error))
                             throw error;
                         const fallbackHeaders = { ...request.headers };
                         delete fallbackHeaders['Accept'];
-                        const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, 120000, signal);
+                        const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, effectiveTimeout, signal);
                         return this.toTransportResponse(fallback);
                     }
                 }
@@ -1028,7 +1081,7 @@ class LLMProvider {
             };
         });
     }
-    async *chatStreamWithTools(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier) {
+    async *chatStreamWithTools(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier, sessionId) {
         if (signal?.aborted)
             throw abortFailure(signal);
         if (this.protocol() === 'anthropic') {
@@ -1040,7 +1093,7 @@ class LLMProvider {
             return;
         }
         if (this.useProviderAdaptersV2) {
-            yield* this.chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier);
+            yield* this.chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier, sessionId);
             return;
         }
         throw new Error('LLMProvider legacy OpenAI streaming was removed in dev-0.3.0: enable provider_adapters_v2 (useProviderAdaptersV2).');
@@ -1071,7 +1124,8 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const timeout = setTimeout(() => abort.abort(), 120000);
+        const effectiveTimeout = this.effectiveRequestTimeout(120000);
+        const timeout = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         let reader = null;
         try {
             let response;
@@ -1084,11 +1138,13 @@ class LLMProvider {
                 });
             }
             catch (e) {
+                if (signal?.aborted)
+                    throw abortFailure(signal);
+                if (abort.signal.aborted)
+                    throw abortFailure(abort.signal);
                 if (!this.shouldUseNodeHttpFallback(e))
                     throw e;
                 clearTimeout(timeout);
-                if (signal?.aborted)
-                    throw abortFailure(signal);
                 yield* this.githubModelsChatNonStreaming(url, body, signal);
                 return;
             }
@@ -1108,12 +1164,9 @@ class LLMProvider {
             let currentReasoningContent = '';
             let contentPolicyBlocked = false;
             let emittedContent = false;
+            const streamSignal = signal || new AbortController().signal;
             while (true) {
-                if (signal?.aborted)
-                    throw abortFailure(signal);
-                const readPromise = reader.read();
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Stream read timeout')), 30000));
-                const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+                const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });