codex-relay 1.1.0 → 1.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 Codex Relay runs a local bridge server for the Codex Relay mobile app. Keep Codex on your computer, then use your phone to pair with that local session, send prompts, watch streamed output, and respond to approval requests.
 
+Codex Relay is an independent project. It is not affiliated with, endorsed by, or sponsored by OpenAI or the OpenAI Codex team.
+
 ## Requirements
 
 - Node.js 22.14 or newer
@@ -145,3 +147,11 @@ kill -TERM <pid>
 ```
 
 If the mobile app cannot connect, confirm that the phone can reach the printed `Mobile:` URL and that the chosen port is not blocked by a firewall.
+
+Connection checklist:
+
+- Are the phone and computer on the same Wi-Fi or LAN?
+- If keeping the same network is difficult, are both devices connected through Tailscale or another reachable private network?
+- Can the phone open the exact `Mobile:` URL printed by the relay?
+- Does the computer firewall allow inbound traffic on the relay port, usually `8787`?
+- If the printed URL is not reachable, did you set `CODEX_RELAY_PUBLIC_URL` to a reachable LAN, Tailscale, or tunnel URL?

package/dist/api-schema.js

@@ -1,2 +1,2 @@
-import { $ as SandboxModeSchema, A as PairResponseSchema, At as WorkspaceTerminalResizeRequestSchema, B as QueuedThreadInputSchema, Bt as promptSkillMentionLabel, C as ListQueuedThreadInputsResponseSchema, Ct as WorkspaceMarkdownPreviewTargetSchema, D as ListWorkspaceFilesResponseSchema, Dt as WorkspaceTerminalInputRequestSchema, E as ListWorkspaceDirectoriesResponseSchema, Et as WorkspaceSelectionRequestSchema, F as PromptAttachmentSummarySchema, Ft as createOpenApiDocument, G as ResolveApprovalRequestSchema, H as RateLimitWindowSchema, Ht as promptSkillMentionTextCandidates, I as PromptContextInputSchema, It as isPromptSkillMarkdownMention, J as RunThreadResponseSchema, K as ResolveApprovalResponseSchema, L as PromptContextSchema, Lt as normalizePromptContext, M as PendingInputRequestQuestionSchema, Mt as WorkspaceTerminalStartRequestSchema, N as PendingInputRequestSchema, Nt as apiPaths, O as PairEncryptedPayloadSchema, Ot as WorkspaceTerminalOutputChunkSchema, P as PromptAttachmentSchema, Pt as chatMessageDetailsFromPromptContext, Q as RuntimePreferencesSchema, R as PromptSkillSchema, Rt as promptMarkdownWithSkills, S as ListModelsResponseSchema, St as WorkspaceGitActionResponseSchema, T as ListThreadsResponseSchema, Tt as WorkspacePreviewTabSchema, U as RateLimitsResponseSchema, Ut as stripPromptSkillMentions, V as RateLimitBucketSchema, Vt as promptSkillMentionMarkdown, W as ReasoningEffortSchema, X as RuntimePreferencesByWorkspacePathSchema, Y as RuntimeModeSchema, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, _t as WebPreviewTargetSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, bt as WorkspaceFileContentResponseSchema, c as ChatMessageRoleSchema, ct as ThreadMessageDetailResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadSummarySchema, et as StatusResponseSchema, f as CodexModelSchema, ft as UpdateRuntimePreferencesRequestSchema, g as CreateThreadResponseSchema, gt as WORKSPACE_PREVIEW_TAB_VALUES, h as CreateThreadRequestSchema, ht as WORKSPACE_PREVIEW_OPEN_PROTOCOL, i as ApprovalModeSchema, it as ThreadCollaborationModeSchema, j as PendingInputRequestOptionSchema, jt as WorkspaceTerminalSessionResponseSchema, k as PairRequestSchema, kt as WorkspaceTerminalOutputResponseSchema, l as ChatMessageSchema, lt as ThreadRunOptionsSchema, m as ContextWindowUsageSchema, mt as VersionResponseSchema, n as AgentSkillSourceSchema, nt as StreamThreadRunRequestSchema, o as ChatMessageKindSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as UpdateWorkspaceFileContentRequestSchema, q as RunThreadRequestSchema, r as ApprovalDecisionSchema, rt as SubmitThreadInputResponseSchema, s as ChatMessagePromptDetailsSchema, st as ThreadMessageDetailFieldSchema, t as AgentSkillSchema, tt as StreamThreadRunEventSchema, u as ChatMessageStateSchema, ut as ThreadStateSchema, v as ErrorResponseSchema, vt as WorkspaceChangesResponseSchema, w as ListSkillsResponseSchema, wt as WorkspacePreviewNavigationRequestSchema, x as IsoDateTimeSchema, xt as WorkspaceFileMentionSchema, y as ImageAttachmentUploadResponseSchema, yt as WorkspaceDirectoryEntrySchema, z as QueuedThreadInputActionResponseSchema, zt as promptSkillDisplayName } from "./api-schema2.js";
-export { AgentSkillSchema, AgentSkillSourceSchema, ApprovalDecisionSchema, ApprovalModeSchema, ArchiveThreadResponseSchema, ChatMessageKindSchema, ChatMessagePromptDetailsSchema, ChatMessageRoleSchema, ChatMessageSchema, ChatMessageStateSchema, CheckoutWorkspaceBranchRequestSchema, CodexModelSchema, CommitPushWorkspaceRequestSchema, ContextWindowUsageSchema, CreateThreadRequestSchema, CreateThreadResponseSchema, EncryptedPayloadSchema, ErrorResponseSchema, ImageAttachmentUploadResponseSchema, InterruptThreadRunResponseSchema, IsoDateTimeSchema, ListModelsResponseSchema, ListQueuedThreadInputsResponseSchema, ListSkillsResponseSchema, ListThreadsResponseSchema, ListWorkspaceDirectoriesResponseSchema, ListWorkspaceFilesResponseSchema, PairEncryptedPayloadSchema, PairRequestSchema, PairResponseSchema, PendingInputRequestOptionSchema, PendingInputRequestQuestionSchema, PendingInputRequestSchema, PromptAttachmentSchema, PromptAttachmentSummarySchema, PromptContextInputSchema, PromptContextSchema, PromptSkillSchema, QueuedThreadInputActionResponseSchema, QueuedThreadInputSchema, RateLimitBucketSchema, RateLimitWindowSchema, RateLimitsResponseSchema, ReasoningEffortSchema, ResolveApprovalRequestSchema, ResolveApprovalResponseSchema, RunThreadRequestSchema, RunThreadResponseSchema, RuntimeModeSchema, RuntimePreferencesByWorkspacePathSchema, RuntimePreferencesResponseSchema, RuntimePreferencesSchema, SandboxModeSchema, StatusResponseSchema, StreamThreadRunEventSchema, StreamThreadRunRequestSchema, SubmitThreadInputResponseSchema, ThreadCollaborationModeSchema, ThreadContextWindowResponseSchema, ThreadDetailResponseSchema, ThreadMessageDetailFieldSchema, ThreadMessageDetailResponseSchema, ThreadRunOptionsSchema, ThreadStateSchema, ThreadSummarySchema, UpdateRuntimePreferencesRequestSchema, UpdateWorkspaceFileContentRequestSchema, VersionResponseSchema, WORKSPACE_PREVIEW_OPEN_PROTOCOL, WORKSPACE_PREVIEW_TAB_VALUES, WebPreviewTargetSchema, WorkspaceChangesResponseSchema, WorkspaceDirectoryEntrySchema, WorkspaceFileContentResponseSchema, WorkspaceFileMentionSchema, WorkspaceGitActionResponseSchema, WorkspaceMarkdownPreviewTargetSchema, WorkspacePreviewNavigationRequestSchema, WorkspacePreviewTabSchema, WorkspaceSelectionRequestSchema, WorkspaceTerminalInputRequestSchema, WorkspaceTerminalOutputChunkSchema, WorkspaceTerminalOutputResponseSchema, WorkspaceTerminalResizeRequestSchema, WorkspaceTerminalSessionResponseSchema, WorkspaceTerminalStartRequestSchema, apiPaths, chatMessageDetailsFromPromptContext, createOpenApiDocument, isPromptSkillMarkdownMention, normalizePromptContext, promptMarkdownWithSkills, promptSkillDisplayName, promptSkillMentionLabel, promptSkillMentionMarkdown, promptSkillMentionTextCandidates, stripPromptSkillMentions };
+import { $ as SandboxModeSchema, A as PairResponseSchema, At as WorkspaceSelectionRequestSchema, B as QueuedThreadInputSchema, Bt as isPromptSkillMarkdownMention, C as ListQueuedThreadInputsResponseSchema, Ct as WorkspaceDirectoryEntrySchema, D as ListWorkspaceFilesResponseSchema, Dt as WorkspaceMarkdownPreviewTargetSchema, E as ListWorkspaceDirectoriesResponseSchema, Et as WorkspaceGitActionResponseSchema, F as PromptAttachmentSummarySchema, Ft as WorkspaceTerminalSessionResponseSchema, G as ResolveApprovalRequestSchema, Gt as promptSkillMentionMarkdown, H as RateLimitWindowSchema, Ht as promptMarkdownWithSkills, I as PromptContextInputSchema, It as WorkspaceTerminalStartRequestSchema, J as RunThreadResponseSchema, K as ResolveApprovalResponseSchema, Kt as promptSkillMentionTextCandidates, L as PromptContextSchema, Lt as apiPaths, M as PendingInputRequestQuestionSchema, Mt as WorkspaceTerminalOutputChunkSchema, N as PendingInputRequestSchema, Nt as WorkspaceTerminalOutputResponseSchema, O as PairEncryptedPayloadSchema, Ot as WorkspacePreviewNavigationRequestSchema, P as PromptAttachmentSchema, Pt as WorkspaceTerminalResizeRequestSchema, Q as RuntimePreferencesSchema, R as PromptSkillSchema, Rt as chatMessageDetailsFromPromptContext, S as ListModelsResponseSchema, St as WorkspaceChangesResponseSchema, T as ListThreadsResponseSchema, Tt as WorkspaceFileMentionSchema, U as RateLimitsResponseSchema, Ut as promptSkillDisplayName, V as RateLimitBucketSchema, Vt as normalizePromptContext, W as ReasoningEffortSchema, Wt as promptSkillMentionLabel, X as RuntimePreferencesByWorkspacePathSchema, Y as RuntimeModeSchema, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, _t as UpdateWorkspaceFileContentRequestSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, bt as WORKSPACE_PREVIEW_TAB_VALUES, c as ChatMessageRoleSchema, ct as ThreadGoalSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailResponseSchema, et as StatusResponseSchema, f as CodexModelSchema, ft as ThreadRunOptionsSchema, g as CreateThreadResponseSchema, gt as UpdateThreadGoalRequestSchema, h as CreateThreadRequestSchema, ht as UpdateRuntimePreferencesRequestSchema, i as ApprovalModeSchema, it as ThreadCollaborationModeSchema, j as PendingInputRequestOptionSchema, jt as WorkspaceTerminalInputRequestSchema, k as PairRequestSchema, kt as WorkspacePreviewTabSchema, l as ChatMessageSchema, lt as ThreadGoalStatusSchema, m as ContextWindowUsageSchema, mt as ThreadSummarySchema, n as AgentSkillSourceSchema, nt as StreamThreadRunRequestSchema, o as ChatMessageKindSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as ThreadStateSchema, q as RunThreadRequestSchema, qt as stripPromptSkillMentions, r as ApprovalDecisionSchema, rt as SubmitThreadInputResponseSchema, s as ChatMessagePromptDetailsSchema, st as ThreadGoalResponseSchema, t as AgentSkillSchema, tt as StreamThreadRunEventSchema, u as ChatMessageStateSchema, ut as ThreadMessageDetailFieldSchema, v as ErrorResponseSchema, vt as VersionResponseSchema, w as ListSkillsResponseSchema, wt as WorkspaceFileContentResponseSchema, x as IsoDateTimeSchema, xt as WebPreviewTargetSchema, y as ImageAttachmentUploadResponseSchema, yt as WORKSPACE_PREVIEW_OPEN_PROTOCOL, z as QueuedThreadInputActionResponseSchema, zt as createOpenApiDocument } from "./api-schema2.js";
+export { AgentSkillSchema, AgentSkillSourceSchema, ApprovalDecisionSchema, ApprovalModeSchema, ArchiveThreadResponseSchema, ChatMessageKindSchema, ChatMessagePromptDetailsSchema, ChatMessageRoleSchema, ChatMessageSchema, ChatMessageStateSchema, CheckoutWorkspaceBranchRequestSchema, CodexModelSchema, CommitPushWorkspaceRequestSchema, ContextWindowUsageSchema, CreateThreadRequestSchema, CreateThreadResponseSchema, EncryptedPayloadSchema, ErrorResponseSchema, ImageAttachmentUploadResponseSchema, InterruptThreadRunResponseSchema, IsoDateTimeSchema, ListModelsResponseSchema, ListQueuedThreadInputsResponseSchema, ListSkillsResponseSchema, ListThreadsResponseSchema, ListWorkspaceDirectoriesResponseSchema, ListWorkspaceFilesResponseSchema, PairEncryptedPayloadSchema, PairRequestSchema, PairResponseSchema, PendingInputRequestOptionSchema, PendingInputRequestQuestionSchema, PendingInputRequestSchema, PromptAttachmentSchema, PromptAttachmentSummarySchema, PromptContextInputSchema, PromptContextSchema, PromptSkillSchema, QueuedThreadInputActionResponseSchema, QueuedThreadInputSchema, RateLimitBucketSchema, RateLimitWindowSchema, RateLimitsResponseSchema, ReasoningEffortSchema, ResolveApprovalRequestSchema, ResolveApprovalResponseSchema, RunThreadRequestSchema, RunThreadResponseSchema, RuntimeModeSchema, RuntimePreferencesByWorkspacePathSchema, RuntimePreferencesResponseSchema, RuntimePreferencesSchema, SandboxModeSchema, StatusResponseSchema, StreamThreadRunEventSchema, StreamThreadRunRequestSchema, SubmitThreadInputResponseSchema, ThreadCollaborationModeSchema, ThreadContextWindowResponseSchema, ThreadDetailResponseSchema, ThreadGoalResponseSchema, ThreadGoalSchema, ThreadGoalStatusSchema, ThreadMessageDetailFieldSchema, ThreadMessageDetailResponseSchema, ThreadRunOptionsSchema, ThreadStateSchema, ThreadSummarySchema, UpdateRuntimePreferencesRequestSchema, UpdateThreadGoalRequestSchema, UpdateWorkspaceFileContentRequestSchema, VersionResponseSchema, WORKSPACE_PREVIEW_OPEN_PROTOCOL, WORKSPACE_PREVIEW_TAB_VALUES, WebPreviewTargetSchema, WorkspaceChangesResponseSchema, WorkspaceDirectoryEntrySchema, WorkspaceFileContentResponseSchema, WorkspaceFileMentionSchema, WorkspaceGitActionResponseSchema, WorkspaceMarkdownPreviewTargetSchema, WorkspacePreviewNavigationRequestSchema, WorkspacePreviewTabSchema, WorkspaceSelectionRequestSchema, WorkspaceTerminalInputRequestSchema, WorkspaceTerminalOutputChunkSchema, WorkspaceTerminalOutputResponseSchema, WorkspaceTerminalResizeRequestSchema, WorkspaceTerminalSessionResponseSchema, WorkspaceTerminalStartRequestSchema, apiPaths, chatMessageDetailsFromPromptContext, createOpenApiDocument, isPromptSkillMarkdownMention, normalizePromptContext, promptMarkdownWithSkills, promptSkillDisplayName, promptSkillMentionLabel, promptSkillMentionMarkdown, promptSkillMentionTextCandidates, stripPromptSkillMentions };

package/dist/api-schema2.js

@@ -57,6 +57,14 @@ const ReasoningEffortSchema = z.enum([
 	"xhigh"
 ]);
 const ThreadCollaborationModeSchema = z.enum(["default", "plan"]);
+const ThreadGoalStatusSchema = z.enum([
+	"active",
+	"paused",
+	"blocked",
+	"usageLimited",
+	"budgetLimited",
+	"complete"
+]);
 const VersionResponseSchema = z.object({
 	ok: z.boolean(),
 	service: z.literal("codex-relay-server"),
@@ -145,6 +153,16 @@ const ThreadContextWindowResponseSchema = z.object({
 	usage: ContextWindowUsageSchema.nullable(),
 	rolloutPath: z.string().nullable().optional()
 });
+const ThreadGoalSchema = z.object({
+	threadId: z.string().min(1),
+	objective: z.string().trim().min(1),
+	status: ThreadGoalStatusSchema,
+	tokenBudget: z.number().int().positive().nullable(),
+	tokensUsed: z.number().int().nonnegative(),
+	timeUsedSeconds: z.number().int().nonnegative(),
+	createdAt: IsoDateTimeSchema,
+	updatedAt: IsoDateTimeSchema
+});
 const PromptAttachmentBaseSchema = z.object({
 	type: z.literal("image"),
 	mimeType: z.string().trim().startsWith("image/").optional(),
@@ -247,7 +265,8 @@ const ThreadSummarySchema = z.object({
 	lastActivityAt: IsoDateTimeSchema.optional(),
 	lastPrompt: z.string().optional(),
 	lastResult: z.string().optional(),
-	lastError: z.string().optional()
+	lastError: z.string().optional(),
+	goal: ThreadGoalSchema.nullable().optional()
 });
 const StatusResponseSchema = z.object({
 	ok: z.boolean(),
@@ -473,6 +492,15 @@ const QueuedThreadInputActionResponseSchema = z.object({
 	queueLength: z.number().int().nonnegative(),
 	thread: ThreadSummarySchema
 });
+const UpdateThreadGoalRequestSchema = z.object({
+	objective: z.string().trim().min(1).optional(),
+	status: ThreadGoalStatusSchema.optional(),
+	tokenBudget: z.number().int().positive().nullable().optional()
+}).refine((input) => input.objective || input.status || input.tokenBudget !== void 0, { message: "At least one goal field is required." });
+const ThreadGoalResponseSchema = z.object({
+	goal: ThreadGoalSchema.nullable(),
+	thread: ThreadSummarySchema
+});
 const InterruptThreadRunResponseSchema = z.object({ thread: ThreadSummarySchema });
 const ListQueuedThreadInputsResponseSchema = z.object({
 	inputs: z.array(QueuedThreadInputSchema),
@@ -533,6 +561,11 @@ const StreamThreadRunEventSchema = z.discriminatedUnion("type", [
 		type: z.literal("thread.state.changed"),
 		thread: ThreadSummarySchema
 	}),
+	z.object({
+		type: z.literal("thread.goal.updated"),
+		thread: ThreadSummarySchema,
+		goal: ThreadGoalSchema.nullable()
+	}),
 	z.object({
 		type: z.literal("thread.error"),
 		thread: ThreadSummarySchema.optional(),
@@ -697,6 +730,7 @@ const apiPaths = {
 	thread: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}`,
 	threadArchive: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}`,
 	threadContextWindow: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/context-window`,
+	threadGoal: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/goal`,
 	threadMessageDetail: (threadId, messageId, field) => `/v1/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/details/${encodeURIComponent(field)}`,
 	approval: (approvalId) => `/v1/approvals/${encodeURIComponent(approvalId)}`,
 	threadInput: (threadId) => `/v1/threads/${encodeURIComponent(threadId)}/input`,
@@ -711,7 +745,7 @@ function createOpenApiDocument() {
 		openapi: "3.1.0",
 		info: {
 			title: "Codex Relay Local Codex API",
-			version: "0.1.0"
+			version: "1.2.0"
 		},
 		paths: {
 			"/version": { get: {
@@ -838,6 +872,36 @@ function createOpenApiDocument() {
 					"409": jsonResponse("ErrorResponse")
 				}
 			} },
+			"/v1/threads/{threadId}/goal": {
+				get: {
+					summary: "Read the active goal for a Codex app-server thread",
+					responses: {
+						"200": jsonResponse("ThreadGoalResponse"),
+						"404": jsonResponse("ErrorResponse"),
+						"502": jsonResponse("ErrorResponse")
+					}
+				},
+				post: {
+					summary: "Update the active goal for a Codex app-server thread",
+					requestBody: jsonRequest("UpdateThreadGoalRequest"),
+					responses: {
+						"200": jsonResponse("ThreadGoalResponse"),
+						"400": jsonResponse("ErrorResponse"),
+						"404": jsonResponse("ErrorResponse"),
+						"409": jsonResponse("ErrorResponse"),
+						"502": jsonResponse("ErrorResponse")
+					}
+				},
+				delete: {
+					summary: "Clear the active goal for a Codex app-server thread",
+					responses: {
+						"200": jsonResponse("ThreadGoalResponse"),
+						"404": jsonResponse("ErrorResponse"),
+						"409": jsonResponse("ErrorResponse"),
+						"502": jsonResponse("ErrorResponse")
+					}
+				}
+			},
 			"/v1/threads/{threadId}/input": {
 				post: {
 					summary: "Submit input to an already-running Codex thread",
@@ -970,7 +1034,71 @@ function createOpenApiDocument() {
 					},
 					lastPrompt: { type: "string" },
 					lastResult: { type: "string" },
-					lastError: { type: "string" }
+					lastError: { type: "string" },
+					goal: { anyOf: [{ $ref: "#/components/schemas/ThreadGoal" }, { type: "null" }] }
+				}
+			},
+			ThreadGoal: {
+				type: "object",
+				required: [
+					"threadId",
+					"objective",
+					"status",
+					"tokenBudget",
+					"tokensUsed",
+					"timeUsedSeconds",
+					"createdAt",
+					"updatedAt"
+				],
+				properties: {
+					threadId: { type: "string" },
+					objective: { type: "string" },
+					status: {
+						type: "string",
+						enum: ThreadGoalStatusSchema.options
+					},
+					tokenBudget: { anyOf: [{
+						type: "integer",
+						minimum: 1
+					}, { type: "null" }] },
+					tokensUsed: {
+						type: "integer",
+						minimum: 0
+					},
+					timeUsedSeconds: {
+						type: "integer",
+						minimum: 0
+					},
+					createdAt: {
+						type: "string",
+						format: "date-time"
+					},
+					updatedAt: {
+						type: "string",
+						format: "date-time"
+					}
+				}
+			},
+			UpdateThreadGoalRequest: {
+				type: "object",
+				properties: {
+					objective: { type: "string" },
+					status: {
+						type: "string",
+						enum: ThreadGoalStatusSchema.options
+					},
+					tokenBudget: { anyOf: [{
+						type: "integer",
+						minimum: 1
+					}, { type: "null" }] }
+				}
+			},
+			ThreadGoalResponse: {
+				type: "object",
+				required: ["goal", "thread"],
+				properties: {
+					goal: { anyOf: [{ $ref: "#/components/schemas/ThreadGoal" }, { type: "null" }] },
+					thread: { $ref: "#/components/schemas/ThreadSummary" }
 				}
 			},
 			StatusResponse: {
@@ -1561,4 +1689,4 @@ function jsonResponse(schemaName) {
 	};
 }
 //#endregion
-export { SandboxModeSchema as $, PairResponseSchema as A, WorkspaceTerminalResizeRequestSchema as At, QueuedThreadInputSchema as B, promptSkillMentionLabel as Bt, ListQueuedThreadInputsResponseSchema as C, WorkspaceMarkdownPreviewTargetSchema as Ct, ListWorkspaceFilesResponseSchema as D, WorkspaceTerminalInputRequestSchema as Dt, ListWorkspaceDirectoriesResponseSchema as E, WorkspaceSelectionRequestSchema as Et, PromptAttachmentSummarySchema as F, createOpenApiDocument as Ft, ResolveApprovalRequestSchema as G, RateLimitWindowSchema as H, promptSkillMentionTextCandidates as Ht, PromptContextInputSchema as I, isPromptSkillMarkdownMention as It, RunThreadResponseSchema as J, ResolveApprovalResponseSchema as K, PromptContextSchema as L, normalizePromptContext as Lt, PendingInputRequestQuestionSchema as M, WorkspaceTerminalStartRequestSchema as Mt, PendingInputRequestSchema as N, apiPaths as Nt, PairEncryptedPayloadSchema as O, WorkspaceTerminalOutputChunkSchema as Ot, PromptAttachmentSchema as P, chatMessageDetailsFromPromptContext as Pt, RuntimePreferencesSchema as Q, PromptSkillSchema as R, promptMarkdownWithSkills as Rt, ListModelsResponseSchema as S, WorkspaceGitActionResponseSchema as St, ListThreadsResponseSchema as T, WorkspacePreviewTabSchema as Tt, RateLimitsResponseSchema as U, stripPromptSkillMentions as Ut, RateLimitBucketSchema as V, promptSkillMentionMarkdown as Vt, ReasoningEffortSchema as W, RuntimePreferencesByWorkspacePathSchema as X, RuntimeModeSchema as Y, RuntimePreferencesResponseSchema as Z, EncryptedPayloadSchema as _, WebPreviewTargetSchema as _t, ArchiveThreadResponseSchema as a, ThreadContextWindowResponseSchema as at, InterruptThreadRunResponseSchema as b, WorkspaceFileContentResponseSchema as bt, ChatMessageRoleSchema as c, ThreadMessageDetailResponseSchema as ct, CheckoutWorkspaceBranchRequestSchema as d, ThreadSummarySchema as dt, StatusResponseSchema as et, CodexModelSchema as f, UpdateRuntimePreferencesRequestSchema as ft, CreateThreadResponseSchema as g, WORKSPACE_PREVIEW_TAB_VALUES as gt, CreateThreadRequestSchema as h, WORKSPACE_PREVIEW_OPEN_PROTOCOL as ht, ApprovalModeSchema as i, ThreadCollaborationModeSchema as it, PendingInputRequestOptionSchema as j, WorkspaceTerminalSessionResponseSchema as jt, PairRequestSchema as k, WorkspaceTerminalOutputResponseSchema as kt, ChatMessageSchema as l, ThreadRunOptionsSchema as lt, ContextWindowUsageSchema as m, VersionResponseSchema as mt, AgentSkillSourceSchema as n, StreamThreadRunRequestSchema as nt, ChatMessageKindSchema as o, ThreadDetailResponseSchema as ot, CommitPushWorkspaceRequestSchema as p, UpdateWorkspaceFileContentRequestSchema as pt, RunThreadRequestSchema as q, ApprovalDecisionSchema as r, SubmitThreadInputResponseSchema as rt, ChatMessagePromptDetailsSchema as s, ThreadMessageDetailFieldSchema as st, AgentSkillSchema as t, StreamThreadRunEventSchema as tt, ChatMessageStateSchema as u, ThreadStateSchema as ut, ErrorResponseSchema as v, WorkspaceChangesResponseSchema as vt, ListSkillsResponseSchema as w, WorkspacePreviewNavigationRequestSchema as wt, IsoDateTimeSchema as x, WorkspaceFileMentionSchema as xt, ImageAttachmentUploadResponseSchema as y, WorkspaceDirectoryEntrySchema as yt, QueuedThreadInputActionResponseSchema as z, promptSkillDisplayName as zt };
+export { SandboxModeSchema as $, PairResponseSchema as A, WorkspaceSelectionRequestSchema as At, QueuedThreadInputSchema as B, isPromptSkillMarkdownMention as Bt, ListQueuedThreadInputsResponseSchema as C, WorkspaceDirectoryEntrySchema as Ct, ListWorkspaceFilesResponseSchema as D, WorkspaceMarkdownPreviewTargetSchema as Dt, ListWorkspaceDirectoriesResponseSchema as E, WorkspaceGitActionResponseSchema as Et, PromptAttachmentSummarySchema as F, WorkspaceTerminalSessionResponseSchema as Ft, ResolveApprovalRequestSchema as G, promptSkillMentionMarkdown as Gt, RateLimitWindowSchema as H, promptMarkdownWithSkills as Ht, PromptContextInputSchema as I, WorkspaceTerminalStartRequestSchema as It, RunThreadResponseSchema as J, ResolveApprovalResponseSchema as K, promptSkillMentionTextCandidates as Kt, PromptContextSchema as L, apiPaths as Lt, PendingInputRequestQuestionSchema as M, WorkspaceTerminalOutputChunkSchema as Mt, PendingInputRequestSchema as N, WorkspaceTerminalOutputResponseSchema as Nt, PairEncryptedPayloadSchema as O, WorkspacePreviewNavigationRequestSchema as Ot, PromptAttachmentSchema as P, WorkspaceTerminalResizeRequestSchema as Pt, RuntimePreferencesSchema as Q, PromptSkillSchema as R, chatMessageDetailsFromPromptContext as Rt, ListModelsResponseSchema as S, WorkspaceChangesResponseSchema as St, ListThreadsResponseSchema as T, WorkspaceFileMentionSchema as Tt, RateLimitsResponseSchema as U, promptSkillDisplayName as Ut, RateLimitBucketSchema as V, normalizePromptContext as Vt, ReasoningEffortSchema as W, promptSkillMentionLabel as Wt, RuntimePreferencesByWorkspacePathSchema as X, RuntimeModeSchema as Y, RuntimePreferencesResponseSchema as Z, EncryptedPayloadSchema as _, UpdateWorkspaceFileContentRequestSchema as _t, ArchiveThreadResponseSchema as a, ThreadContextWindowResponseSchema as at, InterruptThreadRunResponseSchema as b, WORKSPACE_PREVIEW_TAB_VALUES as bt, ChatMessageRoleSchema as c, ThreadGoalSchema as ct, CheckoutWorkspaceBranchRequestSchema as d, ThreadMessageDetailResponseSchema as dt, StatusResponseSchema as et, CodexModelSchema as f, ThreadRunOptionsSchema as ft, CreateThreadResponseSchema as g, UpdateThreadGoalRequestSchema as gt, CreateThreadRequestSchema as h, UpdateRuntimePreferencesRequestSchema as ht, ApprovalModeSchema as i, ThreadCollaborationModeSchema as it, PendingInputRequestOptionSchema as j, WorkspaceTerminalInputRequestSchema as jt, PairRequestSchema as k, WorkspacePreviewTabSchema as kt, ChatMessageSchema as l, ThreadGoalStatusSchema as lt, ContextWindowUsageSchema as m, ThreadSummarySchema as mt, AgentSkillSourceSchema as n, StreamThreadRunRequestSchema as nt, ChatMessageKindSchema as o, ThreadDetailResponseSchema as ot, CommitPushWorkspaceRequestSchema as p, ThreadStateSchema as pt, RunThreadRequestSchema as q, stripPromptSkillMentions as qt, ApprovalDecisionSchema as r, SubmitThreadInputResponseSchema as rt, ChatMessagePromptDetailsSchema as s, ThreadGoalResponseSchema as st, AgentSkillSchema as t, StreamThreadRunEventSchema as tt, ChatMessageStateSchema as u, ThreadMessageDetailFieldSchema as ut, ErrorResponseSchema as v, VersionResponseSchema as vt, ListSkillsResponseSchema as w, WorkspaceFileContentResponseSchema as wt, IsoDateTimeSchema as x, WebPreviewTargetSchema as xt, ImageAttachmentUploadResponseSchema as y, WORKSPACE_PREVIEW_OPEN_PROTOCOL as yt, QueuedThreadInputActionResponseSchema as z, createOpenApiDocument as zt };

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { Nt as apiPaths } from "./api-schema2.js";
+import { Lt as apiPaths } from "./api-schema2.js";
 import { n as codexRelayHome, o as getConnectUrlGuidance, r as legacyCodexRelayDataPath, s as createTursoPairingSessionStore, t as codexRelayDataPath } from "./paths.js";
 import { Command } from "@commander-js/extra-typings";
 import qrcode from "qrcode-terminal";

package/dist/src.js

@@ -1,4 +1,4 @@
-import { A as PairResponseSchema, At as WorkspaceTerminalResizeRequestSchema, C as ListQueuedThreadInputsResponseSchema, D as ListWorkspaceFilesResponseSchema, Dt as WorkspaceTerminalInputRequestSchema, E as ListWorkspaceDirectoriesResponseSchema, Ft as createOpenApiDocument, G as ResolveApprovalRequestSchema, K as ResolveApprovalResponseSchema, Lt as normalizePromptContext, Mt as WorkspaceTerminalStartRequestSchema, Nt as apiPaths, Pt as chatMessageDetailsFromPromptContext, Q as RuntimePreferencesSchema, Rt as promptMarkdownWithSkills, S as ListModelsResponseSchema, St as WorkspaceGitActionResponseSchema, T as ListThreadsResponseSchema, U as RateLimitsResponseSchema, Ut as stripPromptSkillMentions, X as RuntimePreferencesByWorkspacePathSchema, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, bt as WorkspaceFileContentResponseSchema, ct as ThreadMessageDetailResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadSummarySchema, et as StatusResponseSchema, ft as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, jt as WorkspaceTerminalSessionResponseSchema, k as PairRequestSchema, kt as WorkspaceTerminalOutputResponseSchema, l as ChatMessageSchema, m as ContextWindowUsageSchema, mt as VersionResponseSchema, nt as StreamThreadRunRequestSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as UpdateWorkspaceFileContentRequestSchema, q as RunThreadRequestSchema, rt as SubmitThreadInputResponseSchema, st as ThreadMessageDetailFieldSchema, tt as StreamThreadRunEventSchema, vt as WorkspaceChangesResponseSchema, w as ListSkillsResponseSchema, y as ImageAttachmentUploadResponseSchema, z as QueuedThreadInputActionResponseSchema } from "./api-schema2.js";
+import { A as PairResponseSchema, C as ListQueuedThreadInputsResponseSchema, D as ListWorkspaceFilesResponseSchema, E as ListWorkspaceDirectoriesResponseSchema, Et as WorkspaceGitActionResponseSchema, Ft as WorkspaceTerminalSessionResponseSchema, G as ResolveApprovalRequestSchema, Ht as promptMarkdownWithSkills, It as WorkspaceTerminalStartRequestSchema, K as ResolveApprovalResponseSchema, Lt as apiPaths, Nt as WorkspaceTerminalOutputResponseSchema, Pt as WorkspaceTerminalResizeRequestSchema, Q as RuntimePreferencesSchema, Rt as chatMessageDetailsFromPromptContext, S as ListModelsResponseSchema, St as WorkspaceChangesResponseSchema, T as ListThreadsResponseSchema, U as RateLimitsResponseSchema, Vt as normalizePromptContext, X as RuntimePreferencesByWorkspacePathSchema, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, _t as UpdateWorkspaceFileContentRequestSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, ct as ThreadGoalSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailResponseSchema, et as StatusResponseSchema, gt as UpdateThreadGoalRequestSchema, h as CreateThreadRequestSchema, ht as UpdateRuntimePreferencesRequestSchema, jt as WorkspaceTerminalInputRequestSchema, k as PairRequestSchema, l as ChatMessageSchema, lt as ThreadGoalStatusSchema, m as ContextWindowUsageSchema, mt as ThreadSummarySchema, nt as StreamThreadRunRequestSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, q as RunThreadRequestSchema, qt as stripPromptSkillMentions, rt as SubmitThreadInputResponseSchema, st as ThreadGoalResponseSchema, tt as StreamThreadRunEventSchema, ut as ThreadMessageDetailFieldSchema, vt as VersionResponseSchema, w as ListSkillsResponseSchema, wt as WorkspaceFileContentResponseSchema, y as ImageAttachmentUploadResponseSchema, z as QueuedThreadInputActionResponseSchema, zt as createOpenApiDocument } from "./api-schema2.js";
 import { a as getConnectUrlCandidates, i as createPairingQrPayload, o as getConnectUrlGuidance, r as legacyCodexRelayDataPath, s as createTursoPairingSessionStore, t as codexRelayDataPath } from "./paths.js";
 import { createRequire } from "node:module";
 import qrcode from "qrcode-terminal";
@@ -73,6 +73,15 @@ var CodexAppServerClient = class {
 	async archiveThread(params) {
 		await this.request("thread/archive", params);
 	}
+	async getThreadGoal(params) {
+		return (await this.request("thread/goal/get", params)).goal;
+	}
+	async setThreadGoal(params) {
+		return (await this.request("thread/goal/set", params)).goal;
+	}
+	async clearThreadGoal(params) {
+		await this.request("thread/goal/clear", params);
+	}
 	onNotification(handler) {
 		this.notificationHandlers.add(handler);
 		return () => this.notificationHandlers.delete(handler);
@@ -155,7 +164,7 @@ var CodexAppServerClient = class {
 			clientInfo: {
 				name: "codex-relay",
 				title: "Codex Relay Mobile Server",
-				version: "0.1.0"
+				version: "1.2.0"
 			},
 			capabilities: { experimentalApi: true }
 		}).then(() => void 0);
@@ -822,6 +831,16 @@ const defaultWebPreviewPorts = [
 	19006
 ];
 const PairApproveRequestSchema = z.object({ approvalCode: z.string().trim().min(1) });
+const AppServerThreadGoalPayloadSchema = z.object({
+	threadId: z.string().min(1),
+	objective: z.string().trim().min(1),
+	status: ThreadGoalStatusSchema,
+	tokenBudget: z.number().int().positive().nullable(),
+	tokensUsed: z.number().int().nonnegative(),
+	timeUsedSeconds: z.number().int().nonnegative(),
+	createdAt: z.number(),
+	updatedAt: z.number()
+});
 const maxResolvedApprovals = 100;
 const maxWorkspaceTerminalOutputChunks = 2e3;
 function createApp(options = {}) {
@@ -1570,6 +1589,72 @@ function createApp(options = {}) {
 			usage: result.usage
 		}));
 	});
+	app.get("/v1/threads/:threadId/goal", async (c) => {
+		const threadId = c.req.param("threadId");
+		if (!appServer) {
+			const thread = threads.get(threadId);
+			if (!thread) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("not_found", `Thread ${threadId} is not known to this server.`), 404);
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, ThreadGoalResponseSchema.parse({
+				goal: thread.goal ?? null,
+				thread
+			}));
+		}
+		try {
+			const thread = rememberAppServerThread(threads, await appServer.readThread(threadId, { includeTurns: false }));
+			const goal = mapAppServerThreadGoal(await appServer.getThreadGoal({ threadId }));
+			const threadWithGoal = rememberThreadGoal(threads, thread, goal);
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, ThreadGoalResponseSchema.parse({
+				goal,
+				thread: threadWithGoal
+			}));
+		} catch (error) {
+			const message = errorMessage(error);
+			const status = /not found|no rollout found/i.test(message) ? 404 : 502;
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError(status === 404 ? "not_found" : "goal_unavailable", message), status);
+		}
+	});
+	app.post("/v1/threads/:threadId/goal", async (c) => {
+		const threadId = c.req.param("threadId");
+		if (!appServer) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("unsupported", "Thread goals require the Codex app-server."), 409);
+		const parsed = await parseRequestJson(c, options.pairing, secureSessionsByTokenHash, UpdateThreadGoalRequestSchema);
+		if (!parsed.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, validationError(parsed.error), 400);
+		try {
+			const body = parsed.data;
+			const thread = rememberAppServerThread(threads, await appServer.readThread(threadId, { includeTurns: false }));
+			const goal = mapAppServerThreadGoal(await appServer.setThreadGoal({
+				threadId,
+				objective: body.objective,
+				status: body.status,
+				tokenBudget: body.tokenBudget
+			}));
+			const threadWithGoal = rememberThreadGoal(threads, thread, goal);
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, ThreadGoalResponseSchema.parse({
+				goal,
+				thread: threadWithGoal
+			}));
+		} catch (error) {
+			const message = errorMessage(error);
+			const status = /not found|no rollout found/i.test(message) ? 404 : 502;
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError(status === 404 ? "not_found" : "goal_unavailable", message), status);
+		}
+	});
+	app.delete("/v1/threads/:threadId/goal", async (c) => {
+		const threadId = c.req.param("threadId");
+		if (!appServer) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("unsupported", "Thread goals require the Codex app-server."), 409);
+		try {
+			const thread = rememberAppServerThread(threads, await appServer.readThread(threadId, { includeTurns: false }));
+			await appServer.clearThreadGoal({ threadId });
+			const threadWithoutGoal = rememberThreadGoal(threads, thread, null);
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, ThreadGoalResponseSchema.parse({
+				goal: null,
+				thread: threadWithoutGoal
+			}));
+		} catch (error) {
+			const message = errorMessage(error);
+			const status = /not found|no rollout found/i.test(message) ? 404 : 502;
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError(status === 404 ? "not_found" : "goal_unavailable", message), status);
+		}
+	});
 	app.get("/openapi.json", (c) => secureJson(c, options.pairing, secureSessionsByTokenHash, createOpenApiDocument()));
 	app.post("/v1/approvals/:approvalId", async (c) => {
 		const approvalId = c.req.param("approvalId");
@@ -2229,16 +2314,17 @@ async function runPromptStreamed(input) {
 			if (kind === "error") throw new Error(text ?? "Codex run failed.");
 			if (!text) continue;
 			if (kind === "assistant") {
-				assistantMessage = appendMessageDelta(input.messagesByThreadId, activeThreadId, assistantMessage.id, text);
+				const assistantPatch = appendMessageDelta(input.messagesByThreadId, activeThreadId, assistantMessage.id, text);
+				assistantMessage = assistantPatch.message;
 				updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
 					state: "running",
 					lastResult: assistantMessage.content
 				});
-				sendSse(input.controller, input.encoder, input.secureSession, {
+				if (assistantPatch.delta) sendSse(input.controller, input.encoder, input.secureSession, {
 					type: "thread.message.delta",
 					threadId: activeThreadId,
 					messageId: assistantMessage.id,
-					delta: text
+					delta: assistantPatch.delta
 				});
 			} else {
 				const structured = structuredStreamMessage(kind, event, text);
@@ -2459,6 +2545,19 @@ async function streamRunningAppServerThread(input) {
 						}
 						return;
 					}
+					case "thread/goal/updated":
+					case "thread/goal/cleared": {
+						const goal = notification.method === "thread/goal/updated" ? mapAppServerThreadGoal(appServerThreadGoalFromParams(params)) : null;
+						const currentThreadSummary = threadSummary ?? input.threads.get(input.threadId);
+						if (!currentThreadSummary) return;
+						threadSummary = rememberThreadGoal(input.threads, currentThreadSummary, goal);
+						sendSse(input.controller, input.encoder, input.secureSession, {
+							type: "thread.goal.updated",
+							thread: threadSummary,
+							goal
+						});
+						return;
+					}
 					case "turn/started":
 						observedTurnActivity = true;
 						activeTurnId = firstString(params, ["turnId"]) ?? turnIdFromParams(params);
@@ -2494,16 +2593,17 @@ async function streamRunningAppServerThread(input) {
 							turnId: firstString(params, ["turnId"]) ?? activeTurnId
 						});
 						assistantMessageId = itemId;
-						const message = appendMessageDelta(input.messagesByThreadId, input.threadId, itemId, delta);
+						const patch = appendMessageDelta(input.messagesByThreadId, input.threadId, itemId, delta);
+						const message = patch.message;
 						updateThread(input.threads, input.messagesByThreadId, input.threadId, {
 							state: "running",
 							lastResult: message.content
 						});
-						sendSse(input.controller, input.encoder, input.secureSession, {
+						if (patch.delta) sendSse(input.controller, input.encoder, input.secureSession, {
 							type: "thread.message.delta",
 							threadId: input.threadId,
 							messageId: itemId,
-							delta
+							delta: patch.delta
 						});
 						return;
 					}
@@ -2697,6 +2797,17 @@ async function runAppServerPromptStreamed(input) {
 						});
 						return;
 					}
+					case "thread/goal/updated":
+					case "thread/goal/cleared": {
+						const goal = notification.method === "thread/goal/updated" ? mapAppServerThreadGoal(appServerThreadGoalFromParams(params)) : null;
+						threadSummary = rememberThreadGoal(input.threads, threadSummary, goal);
+						sendSse(input.controller, input.encoder, input.secureSession, {
+							type: "thread.goal.updated",
+							thread: threadSummary,
+							goal
+						});
+						return;
+					}
 					case "turn/started":
 						activeTurnId = firstString(params, ["turnId"]) ?? turnIdFromParams(params);
 						if (activeTurnId) input.activeAppServerTurnIdsByThreadId.set(activeThreadId, activeTurnId);
@@ -2705,7 +2816,7 @@ async function runAppServerPromptStreamed(input) {
 					case "item/completed": {
 						const item = params?.item;
 						if (!item || typeof item !== "object") return;
-						const canonicalUserMessage = replaceDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, firstString(params, ["turnId"]) ?? activeTurnId, item, userMessage.id, prompt);
+						const canonicalUserMessage = replaceDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, firstString(params, ["turnId"]) ?? activeTurnId, item, userMessage.id, displayPrompt);
 						if (canonicalUserMessage) {
 							userMessage = canonicalUserMessage;
 							return;
@@ -2737,17 +2848,18 @@ async function runAppServerPromptStreamed(input) {
 							turnId: firstString(params, ["turnId"]) ?? activeTurnId
 						});
 						assistantMessageId = itemId;
-						const message = appendMessageDelta(input.messagesByThreadId, activeThreadId, itemId, delta);
+						const patch = appendMessageDelta(input.messagesByThreadId, activeThreadId, itemId, delta);
+						const message = patch.message;
 						producedTurnOutput = true;
 						updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
 							state: "running",
 							lastResult: message.content
 						});
-						sendSse(input.controller, input.encoder, input.secureSession, {
+						if (patch.delta) sendSse(input.controller, input.encoder, input.secureSession, {
 							type: "thread.message.delta",
 							threadId: activeThreadId,
 							messageId: itemId,
-							delta
+							delta: patch.delta
 						});
 						return;
 					}
@@ -3269,8 +3381,9 @@ function isDuplicateInitialUserMessage(messagesByThreadId, threadId, item, local
 	if (item.type !== "userMessage" || !("content" in item) || !Array.isArray(item.content)) return false;
 	const localMessage = messagesByThreadId.get(threadId)?.find((message) => message.id === localMessageId);
 	const skills = appServerUserMessageSkills(item);
-	const normalizedPrompt = stripPromptSkillMentions(prompt, skills);
-	return stripPromptSkillMentions(localMessage?.content ?? "", skills) === normalizedPrompt && stripPromptSkillMentions(appServerUserMessageText(item), skills) === normalizedPrompt;
+	const normalizeContent = (content) => stripPromptSkillMentions(normalizeImageMessageContent(content), skills);
+	const normalizedPrompt = normalizeContent(prompt);
+	return normalizeContent(localMessage?.content ?? "") === normalizedPrompt && normalizeContent(appServerUserMessageText(item)) === normalizedPrompt;
 }
 function messageWithReplacementDetail(message, replacesMessageId) {
 	return ChatMessageSchema.parse({
@@ -3526,10 +3639,18 @@ function isAppServerSkillInput(input) {
 }
 function appendMessageDelta(messagesByThreadId, threadId, messageId, delta) {
 	const existing = messagesByThreadId.get(threadId)?.find((message) => message.id === messageId);
-	return updateMessage(messagesByThreadId, threadId, messageId, {
-		content: `${existing?.content ?? ""}${delta}`,
-		state: "streaming"
-	});
+	const normalizedDelta = normalizeStreamDelta(existing?.content ?? "", delta);
+	return {
+		delta: normalizedDelta,
+		message: updateMessage(messagesByThreadId, threadId, messageId, {
+			content: `${existing?.content ?? ""}${normalizedDelta}`,
+			state: "streaming"
+		})
+	};
+}
+function normalizeStreamDelta(existingContent, incomingDelta) {
+	if (!existingContent || !incomingDelta.startsWith(existingContent)) return incomingDelta;
+	return incomingDelta.slice(existingContent.length);
 }
 function markApprovalMessageResolved(messagesByThreadId, threadId, messageId, decision) {
 	const message = (messagesByThreadId.get(threadId) ?? []).find((candidate) => candidate.id === messageId);
@@ -3932,12 +4053,33 @@ function rememberAppServerThread(threads, thread) {
 	const mappedThread = mapAppServerThread(thread, existingThread?.messageCount);
 	const threadWithLocalRuntime = ThreadSummarySchema.parse({
 		...mappedThread,
+		goal: existingThread?.goal ?? mappedThread.goal,
 		...runtimeMetadataFromOptions(existingThread ?? {}),
 		model: existingThread?.model ?? mappedThread.model
 	});
 	threads.set(threadWithLocalRuntime.id, threadWithLocalRuntime);
 	return threadWithLocalRuntime;
 }
+function mapAppServerThreadGoal(goal) {
+	if (!goal) return null;
+	return ThreadGoalSchema.parse({
+		...goal,
+		createdAt: fromUnixSeconds(goal.createdAt),
+		updatedAt: fromUnixSeconds(goal.updatedAt)
+	});
+}
+function appServerThreadGoalFromParams(params) {
+	const parsed = AppServerThreadGoalPayloadSchema.safeParse(params?.goal);
+	return parsed.success ? parsed.data : null;
+}
+function rememberThreadGoal(threads, thread, goal) {
+	const next = ThreadSummarySchema.parse({
+		...thread,
+		goal
+	});
+	threads.set(next.id, next);
+	return next;
+}
 function preserveKnownRunningThreadState(thread, wasKnownRunning) {
 	if (!wasKnownRunning || thread.state === "running") return thread;
 	return ThreadSummarySchema.parse({
@@ -4092,6 +4234,7 @@ function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePat
 	};
 	const collected = [];
 	const applyPatchInputs = /* @__PURE__ */ new Map();
+	const handledApplyPatchCallIds = /* @__PURE__ */ new Set();
 	const pendingApplyPatchChanges = [];
 	const lines = readFileSync(rolloutPath, "utf8").split("\n");
 	for (let index = 0; index < lines.length; index += 1) {
@@ -4102,7 +4245,7 @@ function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePat
 		try {
 			const record = JSON.parse(line);
 			rememberRolloutApplyPatchInput(record, applyPatchInputs);
-			collectRolloutApplyPatchOutput(record, workspacePath, applyPatchInputs, pendingApplyPatchChanges);
+			collectRolloutApplyPatchOutput(record, workspacePath, applyPatchInputs, handledApplyPatchCallIds, pendingApplyPatchChanges);
 			if (isRolloutTaskComplete(record) && pendingApplyPatchChanges.length > 0) {
 				collected.push(rolloutApplyPatchSummaryMessage(threadId, record, `rollout:${lineNumber}:apply_patch`, pendingApplyPatchChanges));
 				pendingApplyPatchChanges.length = 0;
@@ -4111,6 +4254,11 @@ function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePat
 			const message = rolloutRecordMessage(threadId, record, `rollout:${lineNumber}`, workspacePath);
 			if (!message) continue;
 			collected.push(message);
+			const patchApplyEndCallId = rolloutPatchApplyEndCallId(record);
+			if (patchApplyEndCallId) {
+				handledApplyPatchCallIds.add(patchApplyEndCallId);
+				pendingApplyPatchChanges.splice(0, pendingApplyPatchChanges.length, ...pendingApplyPatchChanges.filter((change) => change.callId !== patchApplyEndCallId));
+			}
 		} catch {}
 	}
 	return {
@@ -4172,7 +4320,7 @@ function rolloutRecordMessage(threadId, record, messageKey, workspacePath = defa
 	if (record.type === "event_msg" && payload.type === "patch_apply_end") {
 		const changes = rolloutPatchApplyChanges(payload.changes, workspacePath);
 		if (changes.length === 0) return;
-		const patchPreview = largeTextPreview(changes.map((change) => change.patch).filter((patch) => Boolean(patch)).join("\n"));
+		const patchPreview = largeTextPreview(rolloutPatchPreview(changes));
 		return ChatMessageSchema.parse({
 			id: `${messageKey}:patch:${firstString(payload, ["call_id"]) ?? ""}`,
 			threadId,
@@ -4182,7 +4330,7 @@ function rolloutRecordMessage(threadId, record, messageKey, workspacePath = defa
 			createdAt: timestamp,
 			state: "completed",
 			details: {
-				changes: changes.map(({ patch: _patch, ...change }) => change),
+				changes: changes.map(publicRolloutPatchChange),
 				patch: patchPreview?.text,
 				patchOriginalLength: patchPreview?.originalLength,
 				patchTruncated: patchPreview?.truncated
@@ -4250,15 +4398,16 @@ function rememberRolloutApplyPatchInput(record, applyPatchInputs) {
 	const input = firstString(payload, ["input"]);
 	if (callId && input) applyPatchInputs.set(callId, input);
 }
-function collectRolloutApplyPatchOutput(record, workspacePath, applyPatchInputs, pendingApplyPatchChanges) {
+function collectRolloutApplyPatchOutput(record, workspacePath, applyPatchInputs, handledApplyPatchCallIds, pendingApplyPatchChanges) {
 	const payload = record.payload;
-	if (record.type !== "response_item" || payload?.type !== "custom_tool_call_output" || !firstString(payload, ["call_id"])) return;
+	const callId = firstString(payload, ["call_id"]);
+	if (record.type !== "response_item" || payload?.type !== "custom_tool_call_output" || !callId || handledApplyPatchCallIds.has(callId)) return;
 	const changes = rolloutApplyPatchOutputChanges(rolloutCustomToolOutputText(payload), workspacePath);
 	if (changes.length === 0) return;
-	const callId = firstString(payload, ["call_id"]);
 	const patch = callId ? applyPatchInputs.get(callId) : void 0;
 	for (const change of changes) pendingApplyPatchChanges.push({
 		...change,
+		callId,
 		patch
 	});
 }
@@ -4274,13 +4423,36 @@ function rolloutApplyPatchSummaryMessage(threadId, record, messageKey, pendingAp
 		createdAt: timestamp,
 		state: "completed",
 		details: {
-			changes: pendingApplyPatchChanges.map(({ patch: _patch, ...change }) => change),
+			changes: pendingApplyPatchChanges.map(publicRolloutPatchChange),
 			patch: patchPreview?.text,
 			patchOriginalLength: patchPreview?.originalLength,
 			patchTruncated: patchPreview?.truncated
 		}
 	});
 }
+function rolloutPatchApplyEndCallId(record) {
+	if (record.type !== "event_msg" || record.payload?.type !== "patch_apply_end") return;
+	return firstString(record.payload, ["call_id"]);
+}
+function publicRolloutPatchChange(change) {
+	const { callId: _callId, patch: _patch, ...publicChange } = change;
+	return publicChange;
+}
+function rolloutPatchPreview(changes) {
+	return changes.flatMap((change) => {
+		if (!change.patch) return [];
+		if (hasPatchFileHeader(change.patch)) return [change.patch];
+		return [`*** ${patchHeaderChangeKind(change.kind)} File: ${change.path}\n${change.patch}`];
+	}).join("\n");
+}
+function hasPatchFileHeader(patch) {
+	return /^(?:diff --git |\*\*\* (?:Add|Update|Delete) File: )/m.test(patch);
+}
+function patchHeaderChangeKind(kind) {
+	if (kind === "added") return "Add";
+	if (kind === "deleted") return "Delete";
+	return "Update";
+}
 function rolloutCustomToolOutputText(payload) {
 	const rawOutput = firstString(payload, ["output"]);
 	if (!rawOutput) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-relay",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Local Codex Relay CLI bridge for the Codex Relay mobile app.",
   "license": "Apache-2.0",
   "repository": {
@@ -40,7 +40,7 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@openai/codex-sdk": "^0.130.0",
+    "@openai/codex-sdk": "0.137.0",
     "@tursodatabase/database": "^0.5.3",
     "base64-js": "1.5.1",
     "commander": "^14.0.3",

package/src/api-schema.ts

@@ -32,6 +32,14 @@ export const RuntimeModeSchema = z.enum(["default", "auto", "full-access", "on-r
 export const SandboxModeSchema = z.enum(["workspace-write", "danger-full-access", "read-only"]);
 export const ReasoningEffortSchema = z.enum(["minimal", "low", "medium", "high", "xhigh"]);
 export const ThreadCollaborationModeSchema = z.enum(["default", "plan"]);
+export const ThreadGoalStatusSchema = z.enum([
+  "active",
+  "paused",
+  "blocked",
+  "usageLimited",
+  "budgetLimited",
+  "complete",
+]);
 
 export const VersionResponseSchema = z.object({
   ok: z.boolean(),
@@ -139,6 +147,17 @@ export const ThreadContextWindowResponseSchema = z.object({
   rolloutPath: z.string().nullable().optional(),
 });
 
+export const ThreadGoalSchema = z.object({
+  threadId: z.string().min(1),
+  objective: z.string().trim().min(1),
+  status: ThreadGoalStatusSchema,
+  tokenBudget: z.number().int().positive().nullable(),
+  tokensUsed: z.number().int().nonnegative(),
+  timeUsedSeconds: z.number().int().nonnegative(),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema,
+});
+
 const PromptAttachmentBaseSchema = z.object({
   type: z.literal("image"),
   mimeType: z.string().trim().startsWith("image/").optional(),
@@ -266,6 +285,7 @@ export const ThreadSummarySchema = z.object({
   lastPrompt: z.string().optional(),
   lastResult: z.string().optional(),
   lastError: z.string().optional(),
+  goal: ThreadGoalSchema.nullable().optional(),
 });
 
 export const StatusResponseSchema = z.object({
@@ -567,6 +587,21 @@ export const QueuedThreadInputActionResponseSchema = z.object({
   thread: ThreadSummarySchema,
 });
 
+export const UpdateThreadGoalRequestSchema = z
+  .object({
+    objective: z.string().trim().min(1).optional(),
+    status: ThreadGoalStatusSchema.optional(),
+    tokenBudget: z.number().int().positive().nullable().optional(),
+  })
+  .refine((input) => input.objective || input.status || input.tokenBudget !== undefined, {
+    message: "At least one goal field is required.",
+  });
+
+export const ThreadGoalResponseSchema = z.object({
+  goal: ThreadGoalSchema.nullable(),
+  thread: ThreadSummarySchema,
+});
+
 export const InterruptThreadRunResponseSchema = z.object({
   thread: ThreadSummarySchema,
 });
@@ -642,6 +677,11 @@ export const StreamThreadRunEventSchema = z.discriminatedUnion("type", [
     type: z.literal("thread.state.changed"),
     thread: ThreadSummarySchema,
   }),
+  z.object({
+    type: z.literal("thread.goal.updated"),
+    thread: ThreadSummarySchema,
+    goal: ThreadGoalSchema.nullable(),
+  }),
   z.object({
     type: z.literal("thread.error"),
     thread: ThreadSummarySchema.optional(),
@@ -691,6 +731,9 @@ export type RateLimitBucket = z.infer<typeof RateLimitBucketSchema>;
 export type RateLimitWindow = z.infer<typeof RateLimitWindowSchema>;
 export type RateLimitsResponse = z.infer<typeof RateLimitsResponseSchema>;
 export type ThreadContextWindowResponse = z.infer<typeof ThreadContextWindowResponseSchema>;
+export type ThreadGoal = z.infer<typeof ThreadGoalSchema>;
+export type ThreadGoalResponse = z.infer<typeof ThreadGoalResponseSchema>;
+export type ThreadGoalStatus = z.infer<typeof ThreadGoalStatusSchema>;
 export type PromptAttachment = z.infer<typeof PromptAttachmentSchema>;
 export type PendingInputRequest = z.infer<typeof PendingInputRequestSchema>;
 export type PendingInputRequestQuestion = z.infer<typeof PendingInputRequestQuestionSchema>;
@@ -734,6 +777,7 @@ export type ImageAttachmentUploadResponse = z.infer<typeof ImageAttachmentUpload
 export type QueuedThreadInput = z.infer<typeof QueuedThreadInputSchema>;
 export type SubmitThreadInputResponse = z.infer<typeof SubmitThreadInputResponseSchema>;
 export type QueuedThreadInputActionResponse = z.infer<typeof QueuedThreadInputActionResponseSchema>;
+export type UpdateThreadGoalRequest = z.infer<typeof UpdateThreadGoalRequestSchema>;
 export type InterruptThreadRunResponse = z.infer<typeof InterruptThreadRunResponseSchema>;
 export type ListQueuedThreadInputsResponse = z.infer<typeof ListQueuedThreadInputsResponseSchema>;
 export type ApprovalDecision = z.infer<typeof ApprovalDecisionSchema>;
@@ -988,6 +1032,7 @@ export const apiPaths = {
   threadArchive: (threadId: string) => `/v1/threads/${encodeURIComponent(threadId)}`,
   threadContextWindow: (threadId: string) =>
     `/v1/threads/${encodeURIComponent(threadId)}/context-window`,
+  threadGoal: (threadId: string) => `/v1/threads/${encodeURIComponent(threadId)}/goal`,
   threadMessageDetail: (threadId: string, messageId: string, field: ThreadMessageDetailField) =>
     `/v1/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/details/${encodeURIComponent(field)}`,
   approval: (approvalId: string) => `/v1/approvals/${encodeURIComponent(approvalId)}`,
@@ -1007,7 +1052,7 @@ export function createOpenApiDocument() {
     openapi: "3.1.0",
     info: {
       title: "Codex Relay Local Codex API",
-      version: "0.1.0",
+      version: "1.2.0",
     },
     paths: {
       "/version": {
@@ -1162,6 +1207,36 @@ export function createOpenApiDocument() {
           },
         },
       },
+      "/v1/threads/{threadId}/goal": {
+        get: {
+          summary: "Read the active goal for a Codex app-server thread",
+          responses: {
+            "200": jsonResponse("ThreadGoalResponse"),
+            "404": jsonResponse("ErrorResponse"),
+            "502": jsonResponse("ErrorResponse"),
+          },
+        },
+        post: {
+          summary: "Update the active goal for a Codex app-server thread",
+          requestBody: jsonRequest("UpdateThreadGoalRequest"),
+          responses: {
+            "200": jsonResponse("ThreadGoalResponse"),
+            "400": jsonResponse("ErrorResponse"),
+            "404": jsonResponse("ErrorResponse"),
+            "409": jsonResponse("ErrorResponse"),
+            "502": jsonResponse("ErrorResponse"),
+          },
+        },
+        delete: {
+          summary: "Clear the active goal for a Codex app-server thread",
+          responses: {
+            "200": jsonResponse("ThreadGoalResponse"),
+            "404": jsonResponse("ErrorResponse"),
+            "409": jsonResponse("ErrorResponse"),
+            "502": jsonResponse("ErrorResponse"),
+          },
+        },
+      },
       "/v1/threads/{threadId}/input": {
         post: {
           summary: "Submit input to an already-running Codex thread",
@@ -1245,6 +1320,50 @@ export function createOpenApiDocument() {
             lastPrompt: { type: "string" },
             lastResult: { type: "string" },
             lastError: { type: "string" },
+            goal: {
+              anyOf: [{ $ref: "#/components/schemas/ThreadGoal" }, { type: "null" }],
+            },
+          },
+        },
+        ThreadGoal: {
+          type: "object",
+          required: [
+            "threadId",
+            "objective",
+            "status",
+            "tokenBudget",
+            "tokensUsed",
+            "timeUsedSeconds",
+            "createdAt",
+            "updatedAt",
+          ],
+          properties: {
+            threadId: { type: "string" },
+            objective: { type: "string" },
+            status: { type: "string", enum: ThreadGoalStatusSchema.options },
+            tokenBudget: { anyOf: [{ type: "integer", minimum: 1 }, { type: "null" }] },
+            tokensUsed: { type: "integer", minimum: 0 },
+            timeUsedSeconds: { type: "integer", minimum: 0 },
+            createdAt: { type: "string", format: "date-time" },
+            updatedAt: { type: "string", format: "date-time" },
+          },
+        },
+        UpdateThreadGoalRequest: {
+          type: "object",
+          properties: {
+            objective: { type: "string" },
+            status: { type: "string", enum: ThreadGoalStatusSchema.options },
+            tokenBudget: { anyOf: [{ type: "integer", minimum: 1 }, { type: "null" }] },
+          },
+        },
+        ThreadGoalResponse: {
+          type: "object",
+          required: ["goal", "thread"],
+          properties: {
+            goal: {
+              anyOf: [{ $ref: "#/components/schemas/ThreadGoal" }, { type: "null" }],
+            },
+            thread: { $ref: "#/components/schemas/ThreadSummary" },
           },
         },
         StatusResponse: {