@taskforcehq/taskforce 0.3.328 → 0.3.329

package/dist/services/codexAppServerModelGateway.js

@@ -0,0 +1,438 @@
+import { spawn } from 'child_process';
+import { tmpdir } from 'os';
+import readline from 'readline';
+import { ModelGatewayConfigurationError } from './modelGateway.js';
+import { TASKFORCE_AGENT_MODEL_OPTIONS, isTaskforceAgentSubscriptionDevModelsEnabled } from '../shared/taskforceAgentModels.js';
+const CODEX_APP_SERVER_STDERR_LIMIT = 4_096;
+export const DEFAULT_CODEX_APP_SERVER_MODEL_KEY_IDS = {
+    ...Object.fromEntries(TASKFORCE_AGENT_MODEL_OPTIONS
+        .filter((model) => model.runtime === 'subscription-dev' && model.providerKey === 'openai')
+        .map((model) => [model.key, model.runtimeModelId])),
+};
+const CODEX_APP_SERVER_ENV_ALLOWLIST = [
+    'HOME',
+    'USER',
+    'LOGNAME',
+    'PATH',
+    'SHELL',
+    'TMPDIR',
+    'TEMP',
+    'TMP',
+    'LANG',
+    'LC_ALL',
+    'LC_CTYPE',
+    'TERM',
+    'COLORTERM',
+    'NO_COLOR',
+    'CODEX_HOME',
+    'XDG_CONFIG_HOME',
+    'XDG_CACHE_HOME',
+    'XDG_DATA_HOME',
+];
+export function buildCodexAppServerEnv(source = process.env) {
+    const env = {};
+    for (const key of CODEX_APP_SERVER_ENV_ALLOWLIST) {
+        const value = source[key];
+        if (typeof value === 'string' && value.length > 0)
+            env[key] = value;
+    }
+    return env;
+}
+export function sanitizeCodexAppServerStderr(value) {
+    return String(value || '')
+        .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret)\s*[:=]\s*)[^\s]+/gi, '$1[redacted]')
+        .replace(/sk-[A-Za-z0-9_-]{8,}/g, '[redacted OpenAI credential]')
+        .replace(/(Bearer\s+)[^\s]+/gi, '$1[redacted]')
+        .replace(/[^\x09\x0A\x0D\x20-\x7E]/g, '?');
+}
+export function collectCodexAppServerStderr(current, chunk) {
+    return (current + String(chunk || '')).slice(-CODEX_APP_SERVER_STDERR_LIMIT);
+}
+export function assertCodexChatGptSubscriptionAccount(result) {
+    const accountType = readStringPath(result, ['account', 'type']);
+    if (accountType !== 'chatgpt') {
+        throw new ModelGatewayConfigurationError('Codex is not signed in with a ChatGPT subscription. Run codex login on this machine and choose Sign in with ChatGPT.', 'MODEL_SOURCE_UNAVAILABLE');
+    }
+}
+export function isCodexSubscriptionDevRuntimeAllowed(source = process.env) {
+    const runtimeMode = String(source.TASKFORCE_RUNTIME_MODE || '').trim().toLowerCase();
+    return runtimeMode === 'local';
+}
+function resolveCodexAppServerCwd(cwd) {
+    return String(cwd || process.env.TASKFORCE_CODEX_APP_SERVER_CWD || tmpdir()).trim() || tmpdir();
+}
+function buildCodexAppServerRuntimePolicy(cwd) {
+    return {
+        cwd,
+        approvalPolicy: 'never',
+        sandbox: 'read-only',
+        sandboxPolicy: {
+            type: 'readOnly',
+            networkAccess: false,
+        },
+    };
+}
+export function extractCodexTurnCompletion(messages) {
+    const jsonMessages = messages;
+    const completed = jsonMessages.find((message) => message.method === 'turn/completed');
+    if (!completed)
+        return null;
+    const stopReason = readStringPath(completed.params, ['turn', 'status'])
+        || readStringPath(completed.params, ['status'])
+        || 'completed';
+    if (stopReason !== 'completed') {
+        const errorMessage = readStringPath(completed.params, ['turn', 'error', 'message'])
+            || readStringPath(completed.params, ['error', 'message'])
+            || `Codex app-server turn ended with status ${stopReason}.`;
+        throw new Error(errorMessage);
+    }
+    return {
+        text: extractAgentText(jsonMessages),
+        stopReason,
+    };
+}
+export class CodexAppServerJsonRpcClient {
+    process;
+    pending = new Map();
+    notifications = [];
+    nextId = 1;
+    initialized = false;
+    lineReader;
+    requestTimeoutMs;
+    turnRejectors = new Set();
+    terminalError = null;
+    stderrTail = '';
+    constructor(options = {}) {
+        const command = options.command || process.env.TASKFORCE_CODEX_APP_SERVER_COMMAND || 'codex';
+        const args = options.args || ['app-server', '--listen', 'stdio://'];
+        const cwd = resolveCodexAppServerCwd(options.cwd);
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
+        this.process = spawn(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: options.env || buildCodexAppServerEnv(),
+            cwd,
+        });
+        this.lineReader = readline.createInterface({ input: this.process.stdout });
+        this.lineReader.on('line', (line) => this.handleLine(line));
+        this.process.on('error', (error) => {
+            this.fail(new Error(`Codex app-server failed to start: ${error.message}`));
+        });
+        this.process.on('exit', (code, signal) => {
+            const reason = signal ? `signal ${signal}` : `exit code ${code ?? 'unknown'}`;
+            const details = sanitizeCodexAppServerStderr(this.stderrTail).trim();
+            this.fail(new Error(`Codex app-server stopped before completing the request (${reason}).${details ? ` ${details}` : ''}`));
+        });
+        this.process.stderr.on('data', (chunk) => {
+            this.stderrTail = collectCodexAppServerStderr(this.stderrTail, chunk);
+        });
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.request('initialize', {
+            clientInfo: {
+                name: 'taskforce_dev',
+                title: 'Taskforce Dev',
+                version: '0.1.0',
+            },
+        });
+        this.sendNotification('initialized', {});
+        this.initialized = true;
+    }
+    async assertChatGptSubscriptionAuth() {
+        const result = await this.request('account/read', { refreshToken: false });
+        assertCodexChatGptSubscriptionAccount(result);
+    }
+    async startThread(input) {
+        const result = await this.request('thread/start', {
+            model: input.model,
+            cwd: input.cwd,
+            approvalPolicy: input.approvalPolicy,
+            sandbox: input.sandbox,
+            serviceName: 'taskforce_agent_manager_dev',
+            ...(input.developerInstructions
+                ? { developerInstructions: input.developerInstructions }
+                : {}),
+        });
+        const threadId = readStringPath(result, ['thread', 'id']) || readStringPath(result, ['id']);
+        if (!threadId)
+            throw new Error('Codex app-server did not return a thread id.');
+        return { threadId };
+    }
+    async startTurnAndCollectText(input) {
+        const startedAt = this.notifications.length;
+        await this.request('turn/start', {
+            threadId: input.threadId,
+            input: [{ type: 'text', text: input.prompt }],
+            cwd: input.cwd,
+            approvalPolicy: input.approvalPolicy,
+            sandboxPolicy: input.sandboxPolicy,
+            model: input.model,
+        });
+        return this.waitForTurnCompletion(startedAt, input.timeoutMs);
+    }
+    close() {
+        this.lineReader.close();
+        this.process.kill();
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        const message = { jsonrpc: '2.0', id, method, params };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Timed out waiting for Codex app-server ${method} response.`));
+            }, this.requestTimeoutMs);
+            this.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timeout);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+            });
+            this.process.stdin.write(JSON.stringify(message) + '\n', (error) => {
+                if (error) {
+                    const pending = this.pending.get(id);
+                    if (!pending)
+                        return;
+                    this.pending.delete(id);
+                    pending.reject(error);
+                }
+            });
+        });
+    }
+    sendNotification(method, params) {
+        this.process.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let message;
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id === 'number') {
+            const pending = this.pending.get(message.id);
+            if (!pending) {
+                if (message.method) {
+                    this.sendResponseError(message.id, -32601, `Taskforce does not support Codex app-server request ${message.method}.`);
+                }
+                return;
+            }
+            this.pending.delete(message.id);
+            if (message.error) {
+                pending.reject(new Error(message.error.message || 'Codex app-server request failed.'));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (message.method)
+            this.notifications.push(message);
+    }
+    sendResponseError(id, code, message) {
+        this.process.stdin.write(JSON.stringify({
+            jsonrpc: '2.0',
+            id,
+            error: { code, message },
+        }) + '\n');
+    }
+    waitForTurnCompletion(startIndex, timeoutMs) {
+        const startedAt = Date.now();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const rejectTurn = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.turnRejectors.delete(rejectTurn);
+                reject(error);
+            };
+            const resolveTurn = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.turnRejectors.delete(rejectTurn);
+                resolve(value);
+            };
+            this.turnRejectors.add(rejectTurn);
+            if (this.terminalError) {
+                rejectTurn(this.terminalError);
+                return;
+            }
+            const poll = () => {
+                if (settled)
+                    return;
+                const messages = this.notifications.slice(startIndex);
+                try {
+                    const completion = extractCodexTurnCompletion(messages);
+                    if (completion) {
+                        resolveTurn(completion);
+                        return;
+                    }
+                }
+                catch (error) {
+                    rejectTurn(error instanceof Error ? error : new Error(String(error)));
+                    return;
+                }
+                if (Date.now() - startedAt > timeoutMs) {
+                    rejectTurn(new Error('Timed out waiting for Codex app-server turn completion.'));
+                    return;
+                }
+                setTimeout(poll, 50);
+            };
+            poll();
+        });
+    }
+    rejectAll(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+    fail(error) {
+        if (!this.terminalError)
+            this.terminalError = error;
+        this.rejectAll(this.terminalError);
+        for (const rejectTurn of [...this.turnRejectors])
+            rejectTurn(this.terminalError);
+    }
+}
+export class CodexAppServerModelGateway {
+    client;
+    clientFactory;
+    modelKeyIds;
+    timeoutMs;
+    cwd;
+    constructor(options = {}) {
+        this.client = options.client;
+        this.cwd = resolveCodexAppServerCwd(options.cwd);
+        this.clientFactory = options.clientFactory || (() => new CodexAppServerJsonRpcClient({
+            command: options.command,
+            args: options.args,
+            cwd: this.cwd,
+            env: options.env,
+            requestTimeoutMs: options.requestTimeoutMs,
+        }));
+        this.modelKeyIds = {
+            ...DEFAULT_CODEX_APP_SERVER_MODEL_KEY_IDS,
+            ...(options.modelKeyIds ?? {}),
+        };
+        this.timeoutMs = options.timeoutMs ?? 120_000;
+    }
+    async generate(input) {
+        if (!isTaskforceAgentSubscriptionDevModelsEnabled()) {
+            throw new ModelGatewayConfigurationError('OpenAI Codex subscription-dev models are disabled. Set TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS=true for this development runtime.', 'MODEL_SOURCE_UNAVAILABLE');
+        }
+        if (!isCodexSubscriptionDevRuntimeAllowed()) {
+            throw new ModelGatewayConfigurationError('OpenAI Codex subscription-dev models are only available in the local Taskforce runtime.', 'MODEL_SOURCE_UNAVAILABLE');
+        }
+        const modelId = this.resolveModelId(input);
+        const client = this.client || this.clientFactory();
+        const shouldClose = !this.client;
+        const runtimePolicy = buildCodexAppServerRuntimePolicy(this.cwd);
+        const startedAt = Date.now();
+        try {
+            await client.initialize();
+            await client.assertChatGptSubscriptionAuth();
+            const thread = await client.startThread({
+                model: modelId,
+                developerInstructions: input.system,
+                ...runtimePolicy,
+            });
+            const result = await client.startTurnAndCollectText({
+                threadId: thread.threadId,
+                prompt: this.formatMessages(input),
+                model: modelId,
+                timeoutMs: this.timeoutMs,
+                ...runtimePolicy,
+            });
+            return {
+                text: result.text.trim(),
+                provider: 'openai-codex-subscription-dev',
+                modelId,
+                stopReason: result.stopReason,
+                latencyMs: Date.now() - startedAt,
+            };
+        }
+        finally {
+            if (shouldClose)
+                client.close();
+        }
+    }
+    resolveModelId(input) {
+        const modelKey = String(input.modelKey || '').trim();
+        if (!modelKey)
+            throw new Error('No OpenAI Codex subscription-dev model selected.');
+        const modelId = this.modelKeyIds[modelKey];
+        if (!modelId)
+            throw new Error('No OpenAI Codex subscription-dev model configured for the selected model.');
+        return modelId;
+    }
+    formatMessages(input) {
+        return input.messages
+            .map((message) => `${message.role === 'assistant' ? 'Assistant' : 'User'}: ${message.content}`)
+            .join('\n\n');
+    }
+}
+function readStringPath(value, path) {
+    let cursor = value;
+    for (const segment of path) {
+        if (!cursor || typeof cursor !== 'object')
+            return '';
+        cursor = cursor[segment];
+    }
+    return typeof cursor === 'string' ? cursor.trim() : '';
+}
+function readTextPath(value, path) {
+    let cursor = value;
+    for (const segment of path) {
+        if (!cursor || typeof cursor !== 'object')
+            return '';
+        cursor = cursor[segment];
+    }
+    return typeof cursor === 'string' ? cursor : '';
+}
+function extractAgentText(messages) {
+    const deltaTextParts = [];
+    const finalAnswerTextParts = [];
+    const legacyCompletedTextParts = [];
+    for (const message of messages) {
+        if (message.method === 'item/agentMessage/delta') {
+            const text = readTextPath(message.params, ['delta'])
+                || readTextPath(message.params, ['text'])
+                || readTextPath(message.params, ['message', 'delta']);
+            if (text)
+                deltaTextParts.push(text);
+        }
+        if (message.method === 'item/completed') {
+            const itemType = readStringPath(message.params, ['item', 'type']);
+            if (itemType && itemType !== 'agentMessage')
+                continue;
+            const phase = readStringPath(message.params, ['item', 'phase']);
+            if (phase === 'commentary')
+                continue;
+            const text = readTextPath(message.params, ['item', 'text'])
+                || readTextPath(message.params, ['item', 'content', 'text']);
+            if (!text)
+                continue;
+            if (phase === 'final_answer')
+                finalAnswerTextParts.push(text);
+            else
+                legacyCompletedTextParts.push(text);
+        }
+    }
+    const textParts = finalAnswerTextParts.length > 0
+        ? finalAnswerTextParts
+        : legacyCompletedTextParts.length > 0
+            ? legacyCompletedTextParts
+            : deltaTextParts;
+    return textParts.join('').trim();
+}

package/dist/services/taskforceAgentMcpBridge.d.ts

@@ -1,4 +1,5 @@
 import { type TaskforceCore } from '../core/Taskforce.js';
+import { createTaskforceMcpServer } from '../mcp/runtime.js';
 import { type ManagedAgentMcpToolProfile } from '../mcp/toolProfiles.js';
 import { type McpToolName } from '../mcp/toolRegistry.js';
 import type { AgentToolPolicy } from '../shared/taskforceAgentDefinition.js';
@@ -33,8 +34,12 @@ export type PrepareTaskforceAgentMcpBridgeInput = {
     readOnly?: boolean;
     toolProfile?: ManagedAgentMcpToolProfile;
     toolPolicy?: AgentToolPolicy;
+    executionRequestId: string;
     system: string;
 };
+type PrepareTaskforceAgentMcpBridgeDependencies = {
+    createMcpServer?: typeof createTaskforceMcpServer;
+};
 export declare const MANAGED_AGENT_LIST_TASKS_DEFAULT_LIMIT = 25;
 export declare const MANAGED_AGENT_LIST_TASKS_MAX_LIMIT = 50;
 export declare const MANAGED_AGENT_TOOL_RESULT_MAX_BYTES: number;
@@ -50,6 +55,7 @@ type McpToolDescriptor = {
 export declare function hashTaskforceAgentMcpToolContract(tools: McpToolDescriptor[]): string;
 export declare function isTaskforceAgentMutationToolName(name: string): boolean;
 export declare function taskforceAgentMutationCallKey(name: string, argumentsValue: Record<string, unknown>): string | null;
+export declare function taskforceAgentMcpRequestId(call: TaskforceAgentMcpToolCall): string;
 declare const MANAGED_AGENT_CAPABILITY_TOOLS: Readonly<{
     readonly tasks: readonly ["add_comment", "add_task_checklist_item", "complete_workflow_step", "get_schedule_board", "get_stats", "get_task", "get_task_attachments", "get_task_checklist", "get_task_workflow", "list_task_relationships", "list_tasks", "replace_task_checklist", "search_tasks"];
     readonly planning: readonly ["add_initiative_comment", "add_workstream_comment", "get_initiative", "get_workstream", "list_initiatives", "list_workstreams"];
@@ -72,6 +78,6 @@ type BoundedManagedAgentToolResult = {
     rejected: boolean;
 };
 export declare function boundManagedAgentMcpToolResult(toolName: string, text: string): BoundedManagedAgentToolResult;
-export declare function prepareTaskforceAgentMcpBridge(input: PrepareTaskforceAgentMcpBridgeInput): Promise<PreparedTaskforceAgentMcpBridge | null>;
+export declare function prepareTaskforceAgentMcpBridge(input: PrepareTaskforceAgentMcpBridgeInput, dependencies?: PrepareTaskforceAgentMcpBridgeDependencies): Promise<PreparedTaskforceAgentMcpBridge | null>;
 export declare function serializeTaskforceAgentMcpToolResult(result: TaskforceAgentMcpToolResult): Record<string, unknown>;
 export {};

package/dist/services/taskforceAgentMcpBridge.js

@@ -31,6 +31,15 @@ export function taskforceAgentMutationCallKey(name, argumentsValue) {
         return null;
     return `${normalizedName}:${serializeCanonicalJson(argumentsValue || {})}`;
 }
+export function taskforceAgentMcpRequestId(call) {
+    return `managed-agent-${createHash('sha256')
+        .update(serializeCanonicalJson({
+        name: String(call.name || '').trim(),
+        arguments: call.arguments || {},
+    }))
+        .digest('hex')
+        .slice(0, 32)}`;
+}
 const TASK_SCOPED_MUTATION_TOOL_NAMES = new Set([
     'add_comment',
     'add_task_checklist_item',
@@ -284,6 +293,14 @@ function utf8ByteLength(value) {
     return Buffer.byteLength(value, 'utf8');
 }
 export function normalizeManagedAgentMcpToolCall(call) {
+    if (call.name === 'get_task_workflow' || call.name === 'complete_workflow_step') {
+        const args = { ...call.arguments };
+        if (!String(args.taskId || '').trim() && String(args.id || '').trim()) {
+            args.taskId = args.id;
+        }
+        delete args.id;
+        return { name: call.name, arguments: args };
+    }
     if (call.name !== 'list_tasks')
         return call;
     const args = { ...call.arguments };
@@ -438,7 +455,7 @@ function buildManagedAgentToolResultMessage(result, workflowReminder) {
         'Use a narrower Taskforce read before answering the user.',
     ].join('\n');
 }
-export async function prepareTaskforceAgentMcpBridge(input) {
+export async function prepareTaskforceAgentMcpBridge(input, dependencies = {}) {
     if (!input.core)
         return null;
     if (input.runtimeMode !== 'cloud') {
@@ -454,7 +471,7 @@ export async function prepareTaskforceAgentMcpBridge(input) {
     }
     if (!input.agentProfileId)
         managedToolNames.delete('complete_workflow_step');
-    const runtime = createTaskforceMcpServer({
+    const runtime = (dependencies.createMcpServer || createTaskforceMcpServer)({
         core: input.core,
         workspaceId: input.workspaceId,
         runtimeMode: input.runtimeMode,
@@ -469,6 +486,7 @@ export async function prepareTaskforceAgentMcpBridge(input) {
             aiProfileProvider: input.providerKey || 'taskforce_hq',
             aiProfileModel: input.modelKey || null,
             aiProfileSurfaceType: 'agent',
+            requestId: input.executionRequestId,
         },
     });
     const tools = (await listRuntimeTools(runtime))
@@ -499,7 +517,9 @@ export async function prepareTaskforceAgentMcpBridge(input) {
                     name: effectiveCall.name,
                     arguments: effectiveCall.arguments,
                 },
-            }, {});
+            }, {
+                requestId: taskforceAgentMcpRequestId(effectiveCall),
+            });
             const bounded = boundManagedAgentMcpToolResult(effectiveCall.name, extractToolResultText(result));
             return {
                 name: effectiveCall.name,

package/dist/shared/taskforceAgentDefinition.js

@@ -1,4 +1,4 @@
-import { getTaskforceAgentModel, isTaskforceAgentModelSource, normalizeTaskforceAgentConnectionScope, normalizeTaskforceAgentModelSource, } from './taskforceAgentModels.js';
+import { getTaskforceAgentModel, isTaskforceAgentModelVisible, isTaskforceAgentModelSource, normalizeTaskforceAgentConnectionScope, normalizeTaskforceAgentModelSource, } from './taskforceAgentModels.js';
 export const AGENT_DEFINITION_SCHEMA_VERSION = 1;
 const FIELD_LIMITS = {
     name: 80,
@@ -305,6 +305,12 @@ export function inspectAgentDefinition(value) {
         if (value.model.connectionScope !== undefined && !connectionScope) {
             issue(issues, 'invalid_model_connection_scope', 'model.connectionScope', 'Must be taskforce, workspace, personal, or local_dev when provided.');
         }
+        if (catalogModel && !isTaskforceAgentModelVisible(catalogModel)) {
+            issue(issues, 'model_unavailable', 'model.modelKey', 'The selected model is not available in this runtime.');
+        }
+        if (modelSource === 'subscription_dev' && connectionScope !== 'local_dev') {
+            issue(issues, 'invalid_subscription_dev_connection_scope', 'model.connectionScope', 'Subscription-dev models require local_dev connection scope.');
+        }
         const connectionId = readOptionalString(value.model.connectionId, 'model.connectionId', FIELD_LIMITS.referenceId, issues);
         if (catalogModel && catalogModel.providerKey === providerKey && modelSource === catalogModel.source && MODEL_TIERS.has(value.model.tier)) {
             model = {

package/dist/shared/taskforceAgentModels.d.ts

@@ -36,6 +36,7 @@ export declare const DEFAULT_TASKFORCE_AGENT_MODEL_KEY = "anthropic.claude-sonne
 export declare const TASKFORCE_AGENT_MODEL_SOURCES: TaskforceAgentModelSource[];
 export declare const TASKFORCE_AGENT_PROVIDER_OPTIONS: TaskforceAgentProviderOption[];
 export declare const TASKFORCE_AGENT_MODEL_OPTIONS: TaskforceAgentModelOption[];
+export declare function isTaskforceAgentSubscriptionDevModelsEnabled(): boolean;
 export declare function isTaskforceAgentModelVisible(model: TaskforceAgentModelOption): boolean;
 export declare function getTaskforceAgentModel(modelKey: unknown): TaskforceAgentModelOption | null;
 export declare function normalizeTaskforceAgentModelSource(value: unknown, fallback?: TaskforceAgentModelSource): TaskforceAgentModelSource;

package/dist/shared/taskforceAgentModels.js

@@ -214,6 +214,20 @@ export const TASKFORCE_AGENT_MODEL_OPTIONS = [
         supportsTemperature: true,
         defaultMaxTokens: 512,
     },
+    {
+        key: 'openai.codex-gpt-5-6-sol',
+        providerKey: 'openai',
+        label: 'Codex GPT-5.6 Sol',
+        source: 'subscription_dev',
+        runtime: 'subscription-dev',
+        defaultTier: 'advanced',
+        runtimeModelId: 'gpt-5.6-sol',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+        devOnly: true,
+    },
     {
         key: 'openai.gpt-5-4',
         providerKey: 'openai',
@@ -228,8 +242,20 @@ export const TASKFORCE_AGENT_MODEL_OPTIONS = [
         defaultMaxTokens: 1024,
     },
 ];
+function isTruthy(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+export function isTaskforceAgentSubscriptionDevModelsEnabled() {
+    const globals = globalThis;
+    return (typeof __TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS__ !== 'undefined' && __TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS__)
+        || isTruthy(globals.__TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS__)
+        || isTruthy(globals.process?.env?.TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS);
+}
 export function isTaskforceAgentModelVisible(model) {
-    return model.visible && model.availability !== 'account_unavailable';
+    return model.visible
+        && model.availability !== 'account_unavailable'
+        && (!model.devOnly || isTaskforceAgentSubscriptionDevModelsEnabled());
 }
 export function getTaskforceAgentModel(modelKey) {
     const key = String(modelKey || '').trim();
@@ -292,6 +318,9 @@ export function normalizeTaskforceAgentModelSelection(input) {
         && !connectionScope) {
         return null;
     }
+    if (modelSource === 'subscription_dev' && connectionScope !== 'local_dev') {
+        return null;
+    }
     const connectionId = String(input.connectionId || '').trim();
     return {
         providerKey: model.providerKey,

package/dist/storage/postgresAdapter.d.ts

@@ -1,4 +1,14 @@
 import { type DatabaseAdapter, type DatabaseStatement } from './databaseAdapter.js';
+import { type PostgresAdapterDeadlineOptions, type PostgresWorkerOperation } from './postgresWorkerProtocol.js';
+export declare class PostgresWorkerOutcomeUnknownError extends Error {
+    readonly code = "POSTGRES_WORKER_OUTCOME_UNKNOWN";
+    readonly operation: PostgresWorkerOperation;
+    constructor(operation: PostgresWorkerOperation, detail?: string);
+}
+export declare class PostgresWorkerUnavailableError extends Error {
+    readonly code = "POSTGRES_WORKER_UNAVAILABLE";
+    constructor();
+}
 export declare function replaceQMarkParams(sql: string, params: unknown[]): {
     text: string;
     values: unknown[];
@@ -6,13 +16,20 @@ export declare function replaceQMarkParams(sql: string, params: unknown[]): {
 export declare function translateInsertOrReplace(sql: string): string;
 export declare class PostgresAdapter implements DatabaseAdapter {
     readonly provider: "postgres";
-    readonly open = true;
-    private readonly worker;
+    private worker;
+    private readonly connectionString;
+    private readonly deadlines;
+    private readonly retiringWorkers;
+    private consecutiveUnexpectedExits;
+    private closed;
     private readonly encoder;
     private readonly decoder;
     private txId;
     private savepointCounter;
-    constructor(connectionString?: string);
+    constructor(connectionString?: string, deadlineOptions?: PostgresAdapterDeadlineOptions);
+    get open(): boolean;
+    private createWorker;
+    private quarantineWorker;
     private callWorker;
     private query;
     private bindParams;