remote-codex 0.11.0 → 0.11.2

package/bin/remote-codex-plugin-mcp.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const MOLECULE_ARTIFACT_TYPE = 'chemistry.molecule3d';
+const XYZ_VIEWER_PLUGIN_ID = 'remote-codex.xyz-viewer';
+
+function isFiniteNumberToken(value) {
+  return typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value));
+}
+
+function looksLikeXyzMolecule(content) {
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const atomCount = Number(lines[0]);
+  if (!Number.isInteger(atomCount) || atomCount <= 0 || atomCount > 100000) {
+    return false;
+  }
+
+  const atomLines = lines.slice(2);
+  if (atomLines.length < atomCount) {
+    return false;
+  }
+
+  return atomLines.slice(0, atomCount).every((line) => {
+    const parts = line.split(/\s+/);
+    return (
+      parts.length >= 4 &&
+      /^([A-Za-z][A-Za-z]?|\d+)$/.test(parts[0] ?? '') &&
+      isFiniteNumberToken(parts[1]) &&
+      isFiniteNumberToken(parts[2]) &&
+      isFiniteNumberToken(parts[3])
+    );
+  });
+}
+
+function looksLikePdbMolecule(content) {
+  return content.split(/\r?\n/).some((line) => /^(ATOM|HETATM)\s+/i.test(line));
+}
+
+function looksLikeCifMolecule(content) {
+  return /\bdata_[^\s]*/i.test(content) && /_atom_site\./i.test(content);
+}
+
+function looksLikeMoleculeStructure(content, format) {
+  switch (format) {
+    case 'xyz':
+    case 'extxyz':
+      return looksLikeXyzMolecule(content);
+    case 'pdb':
+      return looksLikePdbMolecule(content);
+    case 'cif':
+      return looksLikeCifMolecule(content);
+    default:
+      return false;
+  }
+}
+
+function pluginEnabled(pluginId) {
+  const enabledIds = process.env.REMOTE_CODEX_ENABLED_PLUGIN_IDS;
+  if (!enabledIds) {
+    return true;
+  }
+  return enabledIds.split(',').map((entry) => entry.trim()).filter(Boolean).includes(pluginId);
+}
+
+const server = new McpServer({
+  name: 'remote-codex-plugin-mcp',
+  title: 'Remote Codex Plugin MCP',
+  version: '0.1.0',
+});
+
+if (pluginEnabled(XYZ_VIEWER_PLUGIN_ID)) {
+  server.registerTool(
+    'remote_codex_render_molecule',
+    {
+      title: 'Render 3D Molecule',
+      description:
+        'Create a Remote Codex 3D molecule artifact from valid xyz, extxyz, cif, or pdb content. Use this when the user asks for a renderable molecular structure. Do not invent coordinates unless the user explicitly asks you to generate an example.',
+      inputSchema: {
+        title: z.string().trim().min(1).describe('Short display title for the molecule.'),
+        format: z.enum(['xyz', 'extxyz', 'cif', 'pdb']).describe('Molecular source format.'),
+        content: z.string().trim().min(1).describe('Raw molecule source text in the selected format.'),
+        summaryText: z.string().trim().optional().describe('Optional short summary shown in the timeline.'),
+        sourceDescription: z.string().trim().optional().describe('Optional note about where the coordinates came from.'),
+      },
+    },
+    async ({ title, format, content, summaryText, sourceDescription }) => {
+      if (!looksLikeMoleculeStructure(content, format)) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: 'text',
+              text: `Unable to create molecule artifact: content does not look like valid ${format} data.`,
+            },
+          ],
+        };
+      }
+
+      const artifact = {
+        type: 'remote-codex.artifact',
+        artifactType: MOLECULE_ARTIFACT_TYPE,
+        title,
+        summaryText: summaryText ?? sourceDescription ?? `${format.toUpperCase()} molecule`,
+        payload: {
+          format,
+          content: [content],
+          name: title,
+          sourceDescription: sourceDescription ?? null,
+        },
+      };
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: [
+              `Created a 3D molecule artifact for ${title}.`,
+              '',
+              '```remote-codex-artifact',
+              JSON.stringify(artifact, null, 2),
+              '```',
+            ].join('\n'),
+          },
+        ],
+        structuredContent: {
+          pluginId: XYZ_VIEWER_PLUGIN_ID,
+          artifactType: MOLECULE_ARTIFACT_TYPE,
+          title,
+          format,
+        },
+      };
+    },
+  );
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await server.connect(new StdioServerTransport());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",
@@ -20,12 +20,16 @@
     "packages/opencode/src/",
     "packages/db/src/",
     "packages/db/migrations/*.sql",
+    "packages/plugin-terminal/package.json",
+    "packages/plugin-terminal/plugin.json",
+    "packages/plugin-terminal/src/",
     "packages/shared/src/",
     "README.md"
   ],
   "packageManager": "pnpm@10.11.1",
   "pnpm": {
     "onlyBuiltDependencies": [
+      "@homebridge/node-pty-prebuilt-multiarch",
       "better-sqlite3",
       "esbuild"
     ]
@@ -56,6 +60,7 @@
   "dependencies": {
     "@fastify/multipart": "^9.0.3",
     "@fastify/websocket": "^11.0.2",
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.10.0",
     "fastify": "^5.2.1",

package/packages/agent-runtime/src/model-pricing.ts

@@ -197,9 +197,22 @@ function pricingModelKeyForModel(model: string | null | undefined) {
     return modelKey;
   }
 
-  const claudeDateSuffixMatch = modelKey.match(/^(claude-[a-z]+-\d+(?:-\d+)?)-20\d{6}$/);
-  if (claudeDateSuffixMatch?.[1] && models[claudeDateSuffixMatch[1]]) {
-    return claudeDateSuffixMatch[1];
+  const providerSeparatorIndex = modelKey.indexOf('/');
+  const unqualifiedModelKey = providerSeparatorIndex >= 0
+    ? modelKey.slice(providerSeparatorIndex + 1)
+    : null;
+  if (unqualifiedModelKey && models[unqualifiedModelKey]) {
+    return unqualifiedModelKey;
+  }
+
+  for (const candidate of [modelKey, unqualifiedModelKey]) {
+    if (!candidate) {
+      continue;
+    }
+    const claudeDateSuffixMatch = candidate.match(/^(claude-[a-z]+-\d+(?:-\d+)?)-20\d{6}$/);
+    if (claudeDateSuffixMatch?.[1] && models[claudeDateSuffixMatch[1]]) {
+      return claudeDateSuffixMatch[1];
+    }
   }
 
   return modelKey;

package/packages/agent-runtime/src/types.ts

@@ -259,6 +259,7 @@ export interface StartAgentTurnInput {
   sandboxMode?: 'read-only' | 'workspace-write' | 'danger-full-access' | null;
   workspacePath?: string | null;
   performanceMode?: 'standard' | 'fast' | null;
+  developerInstructions?: string | null;
   hidden?: boolean;
   displayTurnId?: string | null;
 }

package/packages/agent-runtime/src/unavailable-runtime.ts

@@ -14,12 +14,7 @@ import type {
   AgentRuntime,
   AgentRuntimeManagementSchema,
   AgentRuntimeStatus,
-  InterruptAgentTurnInput,
-  ReadAgentSessionOptions,
-  ResumeAgentSessionInput,
-  StartAgentSessionInput,
   StartAgentSessionResult,
-  StartAgentTurnInput,
 } from './types';
 import { AgentRuntimeError } from './types';
 
@@ -136,26 +131,23 @@ export class UnavailableRuntimeAdapter extends EventEmitter implements AgentRunt
     return [];
   }
 
-  async readSession(
-    _providerSessionId: string,
-    _options?: ReadAgentSessionOptions,
-  ): Promise<AgentSessionDetail> {
+  async readSession(): Promise<AgentSessionDetail> {
     throw this.unavailableError();
   }
 
-  async startSession(_input: StartAgentSessionInput): Promise<StartAgentSessionResult> {
+  async startSession(): Promise<StartAgentSessionResult> {
     throw this.unavailableError();
   }
 
-  async resumeSession(_input: ResumeAgentSessionInput): Promise<StartAgentSessionResult> {
+  async resumeSession(): Promise<StartAgentSessionResult> {
     throw this.unavailableError();
   }
 
-  async startTurn(_input: StartAgentTurnInput): Promise<AgentTurn> {
+  async startTurn(): Promise<AgentTurn> {
     throw this.unavailableError();
   }
 
-  async interruptTurn(_input: InterruptAgentTurnInput): Promise<AgentTurn | null> {
+  async interruptTurn(): Promise<AgentTurn | null> {
     throw this.unavailableError();
   }
 

package/packages/claude/src/historyItems.ts

@@ -104,6 +104,40 @@ function readableToolName(toolName: string) {
   return toolName;
 }
 
+function projectRelativePathLabel(value: string | null | undefined) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const slashNormalized = normalized.replace(/\\/g, '/');
+  if (!slashNormalized.startsWith('/')) {
+    return slashNormalized.replace(/^\.\//, '');
+  }
+
+  const markers = [
+    '/apps/',
+    '/packages/',
+    '/src/',
+    '/test/',
+    '/tests/',
+    '/docs/',
+    '/config/',
+    '/scripts/',
+    '/e2e/',
+    '/.agents/',
+    '/.codex/',
+  ];
+  for (const marker of markers) {
+    const markerIndex = slashNormalized.indexOf(marker);
+    if (markerIndex >= 0) {
+      return slashNormalized.slice(markerIndex + 1);
+    }
+  }
+
+  return slashNormalized;
+}
+
 function commandFromInput(input: unknown) {
   if (!isRecord(input)) {
     return null;
@@ -115,11 +149,13 @@ function pathFromInput(input: unknown) {
   if (!isRecord(input)) {
     return null;
   }
-  return (
-    stringValue(input.file_path) ??
-    stringValue(input.filePath) ??
-    stringValue(input.path) ??
-    stringValue(input.notebook_path)
+  return projectRelativePathLabel(
+    stringValue(input.relative_path) ??
+      stringValue(input.relativePath) ??
+      stringValue(input.file_path) ??
+      stringValue(input.filePath) ??
+      stringValue(input.path) ??
+      stringValue(input.notebook_path),
   );
 }
 

package/packages/claude/src/runtimeAdapter.test.ts

@@ -2022,6 +2022,16 @@ describe('ClaudeRuntimeAdapter', () => {
                   file_path: 'packages/claude/src/runtimeAdapter.ts',
                 },
               },
+              {
+                type: 'tool_use',
+                id: 'toolu_edit',
+                name: 'Edit',
+                input: {
+                  file_path: '/home/u/dev/remoteCodex/apps/supervisor-api/src/thread-service.ts',
+                  old_string: 'before',
+                  new_string: 'after',
+                },
+              },
               {
                 type: 'tool_use',
                 id: 'toolu_skill',
@@ -2069,6 +2079,11 @@ describe('ClaudeRuntimeAdapter', () => {
                 tool_use_id: 'toolu_read',
                 content: 'export class ClaudeRuntimeAdapter {}',
               },
+              {
+                type: 'tool_result',
+                tool_use_id: 'toolu_edit',
+                content: 'File updated.',
+              },
               {
                 type: 'tool_result',
                 tool_use_id: 'toolu_skill',
@@ -2114,6 +2129,13 @@ describe('ClaudeRuntimeAdapter', () => {
           text: 'Read file: packages/claude/src/runtimeAdapter.ts',
           status: 'completed',
         }),
+        expect.objectContaining({
+          id: 'toolu_edit',
+          kind: 'fileChange',
+          text: 'apps/supervisor-api/src/thread-service.ts',
+          previewText: 'Edit file: apps/supervisor-api/src/thread-service.ts',
+          status: 'completed',
+        }),
         expect.objectContaining({
           id: 'toolu_skill',
           kind: 'skillToolCall',

package/packages/claude/src/runtimeAdapter.ts

@@ -44,7 +44,6 @@ import {
   hiddenInitPrompt,
   isHiddenContinuationMessage,
   isHiddenInitMessage,
-  messageContentText,
   partialReasoningDelta,
   partialTextDelta,
   resultForToolUse,
@@ -172,11 +171,11 @@ interface ClaudeQueryOptions {
   allowDangerouslySkipPermissions?: boolean;
   pathToClaudeCodeExecutable?: string;
 }
-interface GetSessionInfoOptions {}
+type GetSessionInfoOptions = Record<string, never>;
 interface GetSessionMessagesOptions {
   includeSystemMessages?: boolean;
 }
-interface ListSessionsOptions {}
+type ListSessionsOptions = Record<string, never>;
 interface McpServerStatus {
   name: string;
   status: string;
@@ -1471,8 +1470,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
 
   mapProviderRequest(
     request: AgentProviderRequest,
-    _options: { approvalMode: 'yolo' | 'guarded' },
+    options: { approvalMode: 'yolo' | 'guarded' },
   ): AgentProviderRequestMapping | null {
+    void options;
     return mapClaudeAskUserQuestionRequest(request);
   }
 
@@ -1483,7 +1483,9 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     return buildClaudeProviderRequestResponse(pending, input);
   }
 
-  respondToProviderRequest(_id: string | number, _result: unknown) {
+  respondToProviderRequest(id: string | number, result: unknown) {
+    void id;
+    void result;
     // Claude Code's built-in AskUserQuestion arrives as transcripted tool use in
     // this SDK mode. The supervisor records the user's answer locally so the
     // interaction matches other backends, but there is no live JSON-RPC request

package/packages/codex/src/appServerManager.ts

@@ -463,13 +463,13 @@ export class CodexAppServerManager extends EventEmitter {
         input.serviceTier === undefined ? undefined : input.serviceTier,
       effort: input.effort ?? null,
       sandboxPolicy: input.sandboxPolicy ?? null,
-      collaborationMode: input.collaborationMode
+      collaborationMode: input.collaborationMode || input.developerInstructions
         ? {
-            mode: input.collaborationMode,
+            mode: input.collaborationMode ?? 'default',
             settings: {
               model: input.model ?? '',
               reasoning_effort: input.effort ?? null,
-              developer_instructions: null
+              developer_instructions: input.developerInstructions ?? null
             }
           }
         : null

package/packages/codex/src/historyItems.test.ts

@@ -30,9 +30,7 @@ describe('codex history item persistence policy', () => {
       text: 'Streaming draft',
     });
 
-    expect(shouldPersistRuntimeFinalHistoryItem(transientMessage, [transientMessage])).toBe(
-      false,
-    );
+    expect(shouldPersistRuntimeFinalHistoryItem(transientMessage)).toBe(false);
   });
 
   it('hides transient streamed assistant text once a final assistant message exists', () => {
@@ -54,7 +52,7 @@ describe('codex history item persistence policy', () => {
         error: null,
         items: [transientMessage, finalMessage],
       }).items,
-    ).toEqual([finalMessage]);
+    ).toEqual([{ ...finalMessage, transcriptOrder: 0 }]);
   });
 
   it('maps Codex collab agent tool calls to dedicated agent tool call items', () => {
@@ -107,4 +105,31 @@ describe('codex history item persistence policy', () => {
       status: 'running',
     });
   });
+
+  it('shows file changes using project-relative paths when absolute paths are reported', () => {
+    const turn = codexTurnToAgentTurn({
+      id: 'turn-1',
+      status: 'completed',
+      error: null,
+      items: [
+        {
+          id: 'file-change-1',
+          type: 'fileChange',
+          changes: [
+            {
+              path: '/home/u/dev/remoteCodex/apps/supervisor-web/src/App.tsx',
+              additions: 4,
+              deletions: 1,
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(turn.items[0]).toMatchObject({
+      kind: 'fileChange',
+      text: 'apps/supervisor-web/src/App.tsx',
+      detailText: '- apps/supervisor-web/src/App.tsx (+4 -1)',
+    });
+  });
 });

package/packages/codex/src/historyItems.ts

@@ -78,6 +78,40 @@ function uniqueStrings(values: Array<string | null | undefined>) {
   return [...new Set(values.filter((value): value is string => Boolean(value?.trim())))];
 }
 
+function projectRelativePathLabel(value: string | null | undefined) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const slashNormalized = normalized.replace(/\\/g, '/');
+  if (!slashNormalized.startsWith('/')) {
+    return slashNormalized.replace(/^\.\//, '');
+  }
+
+  const markers = [
+    '/apps/',
+    '/packages/',
+    '/src/',
+    '/test/',
+    '/tests/',
+    '/docs/',
+    '/config/',
+    '/scripts/',
+    '/e2e/',
+    '/.agents/',
+    '/.codex/',
+  ];
+  for (const marker of markers) {
+    const markerIndex = slashNormalized.indexOf(marker);
+    if (markerIndex >= 0) {
+      return slashNormalized.slice(markerIndex + 1);
+    }
+  }
+
+  return slashNormalized;
+}
+
 function normalizeTextLines(text: string) {
   const lines = text.replace(/\r\n/g, '\n').split('\n');
 
@@ -401,7 +435,6 @@ export function shouldPersistFinalHistoryItem(item: ThreadHistoryItemDto) {
 
 export function shouldPersistRuntimeFinalHistoryItem(
   item: ThreadHistoryItemDto,
-  allItems: ThreadHistoryItemDto[],
 ) {
   if (item.kind === 'agentMessage' && isTransientAgentHistoryItem(item)) {
     return false;
@@ -451,18 +484,7 @@ function historyItemSequence(item: ThreadHistoryItemDto) {
 }
 
 export function sortHistoryItemsBySequence<T extends ThreadHistoryItemDto>(items: T[]): T[] {
-  if (!items.some(hasHistoryItemSequence)) {
-    return items;
-  }
-
-  return items
-    .map((item, index) => ({ item, index }))
-    .sort((left, right) => {
-      const sequenceDelta =
-        historyItemSequence(left.item) - historyItemSequence(right.item);
-      return sequenceDelta === 0 ? left.index - right.index : sequenceDelta;
-    })
-    .map((entry) => entry.item);
+  return sortTurnItemsByRecordedSequence(items) as T[];
 }
 
 function sortTurnItemsByRecordedSequence(items: ThreadHistoryItemDto[]) {
@@ -602,12 +624,15 @@ function copyPersistedSequence(
   item: ThreadHistoryItemDto,
   persistedItem: ThreadHistoryItemDto,
 ) {
-  if (!hasHistoryItemSequence(persistedItem)) {
-    return item;
+  let nextItem = item;
+  if (hasHistoryItemSequence(persistedItem)) {
+    const sequence = historyItemSequence(persistedItem);
+    if (nextItem.sequence !== sequence) {
+      nextItem = { ...nextItem, sequence };
+    }
   }
 
-  const sequence = historyItemSequence(persistedItem);
-  return item.sequence === sequence ? item : { ...item, sequence };
+  return nextItem;
 }
 
 function shouldAppendPersistedMissingItem(
@@ -1036,7 +1061,9 @@ function extractFileChangeEntries(item: CodexTurnItem) {
           'old_path',
         ]),
       ),
-    ])[0] ?? null;
+    ])
+      .map(projectRelativePathLabel)
+      .find((entry): entry is string => Boolean(entry)) ?? null;
 
     const explicitAdditions =
       numberOrNull(
@@ -1075,7 +1102,8 @@ function extractFileChangeEntries(item: CodexTurnItem) {
         : null;
     const additions = explicitAdditions || diffStats?.additions || 0;
     const deletions = explicitDeletions || diffStats?.deletions || 0;
-    const normalizedPath = path ?? (diffText ? extractPathFromDiffText(diffText) : null);
+    const normalizedPath =
+      path ?? (diffText ? projectRelativePathLabel(extractPathFromDiffText(diffText)) : null);
 
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
@@ -1299,7 +1327,11 @@ export function agentTurnToThreadTurnDto(
     startedAt: turn.startedAt ?? parseUuidV7Timestamp(turn.providerTurnId),
     status: turn.status,
     error: turn.error?.message ?? null,
-    items: visibleRuntimeTurnItems(turn.items),
+    items: visibleRuntimeTurnItems(turn.items).map((item, transcriptIndex) =>
+      item.transcriptOrder === transcriptIndex
+        ? item
+        : { ...item, transcriptOrder: transcriptIndex },
+    ),
   };
 
   return deferredDetails ? deferLargeHistoryItemDetails(baseTurn, deferredDetails) : baseTurn;

package/packages/codex/src/modelPricing.test.ts

@@ -152,6 +152,57 @@ describe('modelPricing', () => {
     });
   });
 
+  it('normalizes provider-qualified runtime model names to local pricing keys', () => {
+    expect(contextWindowForModel('openai/gpt-5.5')).toBe(272000);
+    expect(supportsFastMode('openai/gpt-5.5')).toBe(true);
+    expect(buildTurnPricingSnapshot('openai/gpt-5.5', false)).toEqual({
+      pricingModelKey: 'gpt-5.5',
+      pricingTierKey: 'standard',
+    });
+
+    const estimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'openai/gpt-5.5',
+      pricingTierKey: 'standard',
+    });
+
+    expect(estimate).toMatchObject({
+      pricingModelKey: 'gpt-5.5',
+      pricingTierKey: 'standard',
+      inputUsd: 0.005,
+      cachedInputUsd: 0.00025,
+      outputUsd: 0.045,
+    });
+  });
+
+  it('normalizes provider-qualified Claude date-stamped model names', () => {
+    expect(contextWindowForModel('anthropic/claude-sonnet-4-5-20250929')).toBe(200000);
+    expect(buildTurnPricingSnapshot('anthropic/claude-sonnet-4-5-20250929', false)).toEqual({
+      pricingModelKey: 'claude-sonnet-4-5',
+      pricingTierKey: 'standard',
+    });
+
+    const estimate = estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'anthropic/claude-sonnet-4-5-20250929',
+      pricingTierKey: 'standard',
+    });
+
+    expect(estimate).toMatchObject({
+      pricingModelKey: 'claude-sonnet-4-5',
+      pricingTierKey: 'standard',
+      inputUsd: 0.003,
+      cachedInputUsd: 0.00015,
+      outputUsd: 0.0225,
+    });
+  });
+
+  it('leaves unknown provider-qualified models unpriced', () => {
+    expect(contextWindowForModel('unknown/not-priced')).toBe(null);
+    expect(estimateTurnPrice(sampleUsage, {
+      pricingModelKey: 'unknown/not-priced',
+      pricingTierKey: 'standard',
+    })).toBe(null);
+  });
+
   it('resolves pricing config from the installed package root when provided', async () => {
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-pricing-root-'));
     await fs.mkdir(path.join(tempDir, 'config'), { recursive: true });

package/packages/codex/src/runtime-errors.ts

@@ -27,11 +27,6 @@ export function unwrapCodexJsonRpcError(error: unknown): JsonRpcClientError | nu
   return null;
 }
 
-function isCodexRemoteError(error: unknown) {
-  const codexError = unwrapCodexJsonRpcError(error);
-  return codexError?.code === 'remote_error' ? codexError : null;
-}
-
 export function isCodexRuntimeRequestError(error: unknown) {
   return Boolean(unwrapCodexJsonRpcError(error)) || isRuntimeRequestError(error);
 }

package/packages/codex/src/runtimeAdapter.ts

@@ -667,6 +667,9 @@ export class CodexRuntimeAdapter extends EventEmitter implements AgentRuntime {
     if (input.collaborationMode !== undefined) {
       turnInput.collaborationMode = input.collaborationMode;
     }
+    if (input.developerInstructions !== undefined) {
+      turnInput.developerInstructions = input.developerInstructions;
+    }
     const sandboxPolicy = buildSandboxPolicy(input.sandboxMode, input.workspacePath);
     if (sandboxPolicy !== undefined) {
       turnInput.sandboxPolicy = sandboxPolicy;

package/packages/codex/src/types.ts

@@ -322,6 +322,7 @@ export interface TurnStartInput {
   collaborationMode?: CollaborationModeKind | null;
   sandboxPolicy?: SandboxPolicy | null;
   serviceTier?: ServiceTier | null;
+  developerInstructions?: string | null;
 }
 
 export interface TurnSteerInput {