diff --git a/.changeset/assistant-lifecycle-actions.md b/.changeset/assistant-lifecycle-actions.md new file mode 100644 index 000000000..313113830 --- /dev/null +++ b/.changeset/assistant-lifecycle-actions.md @@ -0,0 +1,5 @@ +--- +"@sapiom/harness": patch +--- + +Add authenticated Assistant inspection, Resume and Continue action routes with public provenance. diff --git a/packages/harness/docs/assistant-history.md b/packages/harness/docs/assistant-history.md index 9781a058c..d1cd8ea1d 100644 --- a/packages/harness/docs/assistant-history.md +++ b/packages/harness/docs/assistant-history.md @@ -102,3 +102,10 @@ seed before permitting Attach. Retries consult the original allocation identity and receipt before reading a newer source record. Completed retries only verify saved preparation and preserve an already-running child's lease and execution. End and authority changes fence each asynchronous step and final attachment. + +Boot-authorized POST actions at `/api/sessions/:id/assistant/inspect`, `/resume` +and `/continue` accept exact lifecycle revisions. Resume and Continue also require +an operation UUID; Continue includes the displayed record revision. Responses +project public session/lifecycle/provenance fields only. Continue retry storage +uses an opaque server-projected scope stable across restarts and separated by +authorized account, workspace, project, harness and native binding. diff --git a/packages/harness/src/core/assistant-history.test.ts b/packages/harness/src/core/assistant-history.test.ts index 9de6fd53d..73d639a94 100644 --- a/packages/harness/src/core/assistant-history.test.ts +++ b/packages/harness/src/core/assistant-history.test.ts @@ -113,6 +113,52 @@ it("discovers distinct same-folder Assistant identities with no Terminal vendor expect(await history.list(other)).toEqual([]); }); +it("provides stable opaque Continue retry scope only for an authorized project identity", async () => { + const session = sessions[0]!; + expect((await history.entry(session.id))?.continuationScope).toBeUndefined(); + session.agentMapIdentity = { + sessionId: session.id, + projectId: "project-a", + userId: "user-a", + }; + const before = (await history.entry(session.id))!.continuationScope!; + expect(before).toMatch(/^[a-f\d]{64}$/); + expect((await history.entry(session.id))?.continuationScope).toBe(before); + for (const update of [ + () => Object.assign(session.agentMapIdentity!, { projectId: "project-b" }), + () => Object.assign(session.agentMapIdentity!, { userId: "user-b" }), + () => Object.assign(session, { harness: "codex" }), + () => + Object.assign(bindings.get(session.id)!, { conversationId: "ses_new" }), + () => + Object.assign(bindings.get(session.id)!, { + contextAuthorityScope: "9".repeat(64), + }), + ]) { + const previous = (await history.entry(session.id))!.continuationScope; + update(); + expect((await history.entry(session.id))!.continuationScope).not.toBe( + previous, + ); + } +}); + +it("rejects a project rebind during retained history IO", async () => { + const session = sessions[0]!; + session.agentMapIdentity = { + sessionId: session.id, + projectId: "project-a", + userId: "user-a", + }; + const read = records.read.bind(records); + vi.spyOn(records, "read").mockImplementationOnce(async (binding) => { + const value = await read(binding); + Object.assign(session.agentMapIdentity!, { projectId: "project-b" }); + return value; + }); + await expect(history.entry(session.id)).rejects.toThrow(OpenCodeAccessError); +}); + it("distinguishes missing, partial and failed retained records", async () => { const first = bindings.get("studio-a")!; await records.write({ diff --git a/packages/harness/src/core/assistant-history.ts b/packages/harness/src/core/assistant-history.ts index 5ecc31112..0882ccc2a 100644 --- a/packages/harness/src/core/assistant-history.ts +++ b/packages/harness/src/core/assistant-history.ts @@ -1,4 +1,5 @@ import { realpath } from "node:fs/promises"; +import { createHash } from "node:crypto"; import { isAbsolute } from "node:path"; import type { AssistantHistoryEntry } from "../shared/assistant-history.js"; import type { HarnessSession } from "../shared/types.js"; @@ -25,14 +26,13 @@ export class AssistantHistory { return (await this.read(id))?.entry ?? null; } - private async read( - id: string, - ): Promise<{ + private async read(id: string): Promise<{ entry: AssistantHistoryEntry; binding: AssistantAssociation; } | null> { const session = this.options.sessions.get(id); if (!session) return null; + const project = JSON.stringify([session.harness, session.agentMapIdentity]); const binding = await this.options.authorize(id); if (!binding) return null; const lifecycle = await this.options.lifecycle.describe(id); @@ -65,7 +65,11 @@ export class AssistantHistory { ) throw new OpenCodeAccessError("Assistant binding changed"); const current = this.options.sessions.get(id); - if (!current || current.cwd !== session.cwd) + if ( + !current || + current.cwd !== session.cwd || + JSON.stringify([current.harness, current.agentMapIdentity]) !== project + ) throw new OpenCodeAccessError("Workspace changed"); return { binding, @@ -80,6 +84,22 @@ export class AssistantHistory { history, nativeResume: "unchecked", recordRevision, + ...(current.agentMapIdentity + ? { + continuationScope: createHash("sha256") + .update( + JSON.stringify([ + "studio-assistant-continue-retry/v1", + binding.contextAuthorityScope, + binding.conversationId, + current.agentMapIdentity.projectId, + current.agentMapIdentity.userId, + current.harness, + ]), + ) + .digest("hex"), + } + : {}), }, }; } diff --git a/packages/harness/src/server/assistant-lifecycle.test.ts b/packages/harness/src/server/assistant-lifecycle.test.ts new file mode 100644 index 000000000..2bd6224c0 --- /dev/null +++ b/packages/harness/src/server/assistant-lifecycle.test.ts @@ -0,0 +1,305 @@ +import express from "express"; +import { createServer, type Server } from "node:http"; +import { beforeEach, afterEach, expect, it, vi } from "vitest"; +import { + createAssistantLifecycleRouter, + projectAssistantContinuation, +} from "./assistant-lifecycle.js"; +import { + OpenCodeAccessError, + OpenCodeTransportError, +} from "../core/opencode-host.js"; +import { AssistantContinuationUnconfirmedError } from "../core/assistant-continuation-native.js"; +import { + AssistantContinuationConflictError, + type AssistantContinuationReceipt, +} from "../core/assistant-continuation-store.js"; +import { openCodeTransportFailure } from "../shared/opencode-errors.js"; +import { parseAssistantContinuationView } from "../shared/assistant-continuation.js"; +import type { HarnessSession } from "../shared/types.js"; + +const op = "11111111-1111-4111-8111-111111111111"; +let server: Server, origin: string; +const entry = vi.fn(), + inspect = vi.fn(), + resume = vi.fn(), + continuation = vi.fn(); +const lifecycle = { + version: 1, + harnessSessionId: "studio-a", + revision: 4, + lifecycle: "ended", + execution: "paused", + updatedAt: 1, +}; +const savedEntry = { + kind: "assistant", + harnessSessionId: "studio-a", + cwd: "/workspace", + title: "Saved", + createdAt: "2026-09-14T00:00:00.000Z", + updatedAt: "2026-09-14T00:00:00.000Z", + lifecycle, + history: "partial", + nativeResume: "unchecked", + recordRevision: 7, +}; +const session = { + id: "studio-a", + cwd: "/workspace", + title: "Saved", + harness: "claude-code", + status: "exited", + ready: false, + createdAt: savedEntry.createdAt, + lastActiveAt: savedEntry.updatedAt, +} as HarnessSession; +const attachment = { + conversationId: "ses_original", + lease: op, + lifecycle: { ...lifecycle, lifecycle: "open", revision: 5 }, +}; +const receipt = { + phase: "prepared", + operationId: op, + sourceBinding: { + harnessSessionId: "studio-a", + contextAuthorityScope: "private-source-scope", + }, + sourceRecordRevision: 7, + childBinding: { + conversationId: "ses_child", + contextAuthorityScope: "private-child-scope", + }, + seedMessageId: "msg_seed", + seedPartId: "prt_seed", + brief: { + capturedAt: savedEntry.updatedAt, + text: "Recorded brief", + sha256: "a".repeat(64), + retainedTurns: 1, + omittedTurns: 3, + }, + frozenCandidate: { materials: ["private-input"] }, + acceptedRef: { acceptanceId: "private-acceptance" }, +} as unknown as AssistantContinuationReceipt; +const post = ( + action = "inspect", + body: unknown = { expectedRevision: 4 }, + token = "boot", +) => + fetch(`${origin}/sessions/studio-a/assistant/${action}`, { + method: "POST", + headers: { "X-Harness-Token": token, "Content-Type": "application/json" }, + body: JSON.stringify(body), + }); +beforeEach(async () => { + entry.mockReset().mockResolvedValue(savedEntry); + inspect.mockReset().mockResolvedValue({ + nativeHistory: "available", + nativeResume: "available", + savedSystem: "private-system", + sourceMessageId: "private-message", + }); + resume.mockReset().mockResolvedValue(attachment); + continuation.mockReset().mockResolvedValue({ + session: { ...session, id: "child", terminalState: "not-started" }, + attachment, + receipt, + }); + const app = express(); + app.use( + createAssistantLifecycleRouter({ + bootToken: "boot", + history: { entry }, + native: { inspect }, + getSession: () => session, + resume, + continue: continuation, + }), + ); + server = createServer(app); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + origin = `http://127.0.0.1:${(server.address() as { port: number }).port}`; +}); +afterEach(async () => { + server.closeAllConnections(); + await new Promise((resolve) => server.close(() => resolve())); +}); + +it("requires the boot token before history or native work", async () => { + for (const action of ["inspect", "resume", "continue"]) + expect((await post(action, {}, "wrong")).status).toBe(401); + expect(entry).not.toHaveBeenCalled(); + expect(inspect).not.toHaveBeenCalled(); + expect(resume).not.toHaveBeenCalled(); + expect(continuation).not.toHaveBeenCalled(); +}); +it("rejects ambiguous bodies, client bindings, invalid revisions and operation IDs", async () => { + for (const body of [ + [], + null, + {}, + { expectedRevision: -1 }, + { expectedRevision: 1.5 }, + { expectedRevision: 4, cwd: "/other" }, + ]) + expect((await post("inspect", body)).status).toBe(400); + expect((await post("inspect?other=1")).status).toBe(400); + expect( + (await post("resume", { expectedRevision: 4, operationId: "invalid" })) + .status, + ).toBe(400); + expect( + ( + await post("continue", { + expectedRevision: 4, + operationId: op, + expectedRecordRevision: 0, + }) + ).status, + ).toBe(400); + expect((await post("unknown")).status).toBe(404); + expect(inspect).not.toHaveBeenCalled(); +}); +it("projects selected availability without private saved system or source-message data", async () => { + const response = await post(); + expect(response.status).toBe(200); + expect(response.headers.get("cache-control")).toBe("no-store"); + const body = await response.json(); + expect(body.entry).toEqual({ ...savedEntry, nativeResume: "available" }); + expect(JSON.stringify(body)).not.toContain("private"); + expect(inspect).toHaveBeenCalledWith("studio-a", 4); +}); +it("keeps missing native history and unavailable original context separate from readable records", async () => { + for (const [nativeResume, code] of [ + ["missing", "native_history_missing"], + ["unavailable", "context_unavailable"], + ] as const) { + inspect.mockResolvedValueOnce({ + nativeResume, + nativeHistory: nativeResume, + resumeFailure: openCodeTransportFailure(code), + }); + const response = await post(); + expect(response.status).toBe(200); + expect((await response.json()).entry).toMatchObject({ + history: "partial", + nativeResume, + resumeFailure: { code }, + }); + } +}); +it("rejects a stale inspection before startup and a late lifecycle change after native read", async () => { + expect((await post("inspect", { expectedRevision: 3 })).status).toBe(409); + expect(inspect).not.toHaveBeenCalled(); + entry.mockResolvedValueOnce(savedEntry).mockResolvedValueOnce({ + ...savedEntry, + lifecycle: { ...lifecycle, revision: 5 }, + }); + expect((await post()).status).toBe(409); +}); +it("returns the same Resume Studio identity and normalizes legacy null fields without starting Terminal", async () => { + entry + .mockResolvedValueOnce(savedEntry) + .mockResolvedValueOnce({ ...savedEntry, lifecycle: attachment.lifecycle }); + const response = await post("resume", { + expectedRevision: 4, + operationId: op, + }); + expect(response.status).toBe(200); + expect(await response.json()).toEqual({ + session: { ...session, agentSessionId: null, boundWorkflowPath: null }, + attachment, + }); + expect(resume).toHaveBeenCalledWith("studio-a", 4, op); + expect(continuation).not.toHaveBeenCalled(); +}); +it("discards Resume when a newer lifecycle or authorization wins before the response", async () => { + entry.mockResolvedValueOnce(savedEntry).mockResolvedValueOnce({ + ...savedEntry, + lifecycle: { ...lifecycle, revision: 6 }, + }); + expect( + (await post("resume", { expectedRevision: 4, operationId: op })).status, + ).toBe(409); + entry + .mockResolvedValueOnce(savedEntry) + .mockRejectedValueOnce( + new OpenCodeAccessError("private authorization detail"), + ); + const response = await post("resume", { + expectedRevision: 4, + operationId: op, + }); + expect(response.status).toBe(403); + expect(await response.text()).not.toContain("private"); +}); +it("projects Continue provenance without receipt inputs or accepted-reference authority", async () => { + const response = await post("continue", { + expectedRevision: 4, + expectedRecordRevision: 7, + operationId: op, + }); + expect(response.status).toBe(200); + const body = await response.json(); + expect( + parseAssistantContinuationView(body.continuation, "ses_child"), + ).toEqual(projectAssistantContinuation(receipt)); + expect(body.session).toMatchObject({ + id: "child", + terminalState: "not-started", + agentSessionId: null, + }); + expect(JSON.stringify(body)).not.toContain("private"); + expect(continuation).toHaveBeenCalledWith("studio-a", { + expectedRevision: 4, + expectedRecordRevision: 7, + operationId: op, + }); +}); +it("returns safe typed uncertainty and conflicts instead of raw storage/native diagnostics", async () => { + for (const [error, status, code] of [ + [ + new AssistantContinuationUnconfirmedError(), + 409, + "continuation_unconfirmed", + ], + [new AssistantContinuationConflictError(), 409, "lifecycle_changed"], + [ + new OpenCodeTransportError( + openCodeTransportFailure("context_unavailable"), + ), + 503, + "context_unavailable", + ], + [new Error("private storage diagnostics"), 503, "transport_unavailable"], + ] as const) { + continuation.mockRejectedValueOnce(error); + const response = await post("continue", { + expectedRevision: 4, + expectedRecordRevision: 7, + operationId: op, + }); + expect(response.status).toBe(status); + const body = await response.json(); + expect(body.error.code).toBe(code); + expect(JSON.stringify(body)).not.toContain("private"); + } +}); +it("does not publish provenance from an unfinished receipt or accept foreign seed attestations", () => { + expect(() => + projectAssistantContinuation({ ...receipt, phase: "seeding" }), + ).toThrow(AssistantContinuationUnconfirmedError); + const view = projectAssistantContinuation(receipt); + expect(parseAssistantContinuationView(view, "ses_foreign")).toBeNull(); + expect( + parseAssistantContinuationView({ + ...view, + seed: { ...view.seed, text: "x".repeat(24_001) }, + }), + ).toBeNull(); + expect( + parseAssistantContinuationView({ ...view, operationId: "invalid" }), + ).toBeNull(); +}); diff --git a/packages/harness/src/server/assistant-lifecycle.ts b/packages/harness/src/server/assistant-lifecycle.ts new file mode 100644 index 000000000..776550db3 --- /dev/null +++ b/packages/harness/src/server/assistant-lifecycle.ts @@ -0,0 +1,200 @@ +import express, { type Response, type Router } from "express"; +import { z } from "zod"; +import type { AssistantHistory } from "../core/assistant-history.js"; +import type { AssistantNativeHistory } from "../core/assistant-native-history.js"; +import type { AssistantAttachment } from "../core/assistant-lifecycle.js"; +import type { + AssistantContinueRequest, + PreparedAssistantContinuation, +} from "../core/assistant-continuation.js"; +import { + AssistantContinuationConflictError, + type AssistantContinuationReceipt, +} from "../core/assistant-continuation-store.js"; +import { AssistantContinuationUnconfirmedError } from "../core/assistant-continuation-native.js"; +import { OpenCodeTransportError } from "../core/opencode-host.js"; +import type { HarnessSession } from "../shared/types.js"; +import type { AssistantContinuationView } from "../shared/assistant-continuation.js"; +import { openCodeTransportFailure } from "../shared/opencode-errors.js"; +import { createBootTokenMiddleware } from "./auth.js"; + +const inspectionRequest = z + .object({ expectedRevision: z.number().int().nonnegative().safe() }) + .strict(); +const resumeRequest = inspectionRequest + .extend({ operationId: z.string().uuid() }) + .strict(); +const continueRequest = resumeRequest + .extend({ expectedRecordRevision: z.number().int().positive().safe() }) + .strict(); +const changed = () => + new OpenCodeTransportError(openCodeTransportFailure("lifecycle_changed")); +const sessionView = (session: HarnessSession): HarnessSession => ({ + ...session, + agentSessionId: session.agentSessionId ?? null, + boundWorkflowPath: session.boundWorkflowPath ?? null, +}); + +/** No private binding, accepted reference, system, or frozen source input crosses this boundary. */ +export function projectAssistantContinuation( + receipt: AssistantContinuationReceipt, +): AssistantContinuationView { + if (receipt.phase !== "prepared" || !receipt.childBinding) + throw new AssistantContinuationUnconfirmedError(); + return { + operationId: receipt.operationId, + sourceSessionId: receipt.sourceBinding.harnessSessionId, + sourceRecordRevision: receipt.sourceRecordRevision, + capturedAt: receipt.brief.capturedAt, + retainedTurns: receipt.brief.retainedTurns, + omittedTurns: receipt.brief.omittedTurns, + seed: { + conversationId: receipt.childBinding.conversationId, + messageId: receipt.seedMessageId, + partId: receipt.seedPartId, + text: receipt.brief.text, + sha256: receipt.brief.sha256, + }, + }; +} + +function failure(res: Response, error: unknown) { + const value = + error instanceof OpenCodeTransportError + ? error.failure + : error instanceof AssistantContinuationConflictError + ? openCodeTransportFailure("lifecycle_changed") + : error instanceof AssistantContinuationUnconfirmedError + ? openCodeTransportFailure("continuation_unconfirmed") + : openCodeTransportFailure("transport_unavailable"); + const status = [ + "access_denied", + "access_expired", + "authentication_required", + ].includes(value.code) + ? 403 + : [ + "lifecycle_changed", + "session_ended", + "cleanup_unconfirmed", + "continuation_unconfirmed", + ].includes(value.code) + ? 409 + : 503; + res.status(status).json({ error: value }); +} + +export function createAssistantLifecycleRouter(options: { + bootToken: string; + history: Pick; + native: Pick; + getSession: (id: string) => HarnessSession | undefined; + resume: ( + id: string, + expectedRevision: number, + operationId: string, + ) => Promise; + continue?: ( + id: string, + request: AssistantContinueRequest, + ) => Promise; +}): Router { + const router = express.Router(); + router.use( + createBootTokenMiddleware(options.bootToken), + express.json({ limit: "8kb" }), + ); + router.post("/sessions/:id/assistant/:action", (req, res) => { + void (async () => { + res.setHeader("Cache-Control", "no-store"); + const { id, action } = req.params; + const schema = + action === "inspect" + ? inspectionRequest + : action === "resume" + ? resumeRequest + : action === "continue" + ? continueRequest + : null; + if (!schema) { + res.sendStatus(404); + return; + } + const parsed = schema.safeParse(req.body); + if ( + !/^[A-Za-z0-9_-]{1,128}$/.test(id) || + Object.keys(req.query).length || + !parsed.success + ) { + res.sendStatus(400); + return; + } + try { + const entry = await options.history.entry(id); + if (!entry) { + res.sendStatus(404); + return; + } + if (action === "inspect") { + if (entry.lifecycle.revision !== parsed.data.expectedRevision) + throw changed(); + const checked = await options.native.inspect( + id, + parsed.data.expectedRevision, + ); + const current = await options.history.entry(id); + if ( + !current || + current.lifecycle.revision !== parsed.data.expectedRevision || + current.cwd !== entry.cwd + ) + throw changed(); + res.json({ + entry: { + ...current, + nativeResume: checked.nativeResume, + ...(checked.resumeFailure + ? { resumeFailure: checked.resumeFailure } + : {}), + }, + }); + } else if (action === "resume") { + const request = resumeRequest.parse(parsed.data); + const attachment = await options.resume( + id, + request.expectedRevision, + request.operationId, + ); + const session = options.getSession(id); + const current = await options.history.entry(id); + if ( + !session || + !current || + current.cwd !== entry.cwd || + current.lifecycle.revision !== attachment.lifecycle.revision || + current.lifecycle.lifecycle !== "open" + ) + throw changed(); + res.json({ session: sessionView(session), attachment }); + } else { + if (!options.continue) + throw new OpenCodeTransportError( + openCodeTransportFailure("context_unavailable"), + ); + const prepared = await options.continue( + id, + continueRequest.parse(parsed.data), + ); + res.json({ + session: sessionView(prepared.session), + attachment: prepared.attachment, + continuation: projectAssistantContinuation(prepared.receipt), + }); + } + } catch (error) { + failure(res, error); + } + })(); + }); + return router; +} diff --git a/packages/harness/src/shared/assistant-continuation.ts b/packages/harness/src/shared/assistant-continuation.ts new file mode 100644 index 000000000..b4fd0a899 --- /dev/null +++ b/packages/harness/src/shared/assistant-continuation.ts @@ -0,0 +1,73 @@ +/** Public provenance and exact seed attestation, projected only from a verified receipt. */ +export interface AssistantContinuationView { + operationId: string; + sourceSessionId: string; + sourceRecordRevision: number; + capturedAt: string; + retainedTurns: number; + omittedTurns: number; + seed: { + conversationId: string; + messageId: string; + partId: string; + text: string; + sha256: string; + }; +} + +export function parseAssistantContinuationView( + value: unknown, + conversationId?: string, +): AssistantContinuationView | null { + if (!value || typeof value !== "object" || Array.isArray(value)) return null; + const v = value as Record; + const seed = v.seed as Record | null; + if ( + !seed || + typeof seed !== "object" || + Array.isArray(seed) || + typeof v.operationId !== "string" || + !/^[a-f\d]{8}-[a-f\d]{4}-[a-f\d]{4}-[a-f\d]{4}-[a-f\d]{12}$/i.test( + v.operationId, + ) || + typeof v.sourceSessionId !== "string" || + !/^[A-Za-z0-9_-]{1,128}$/.test(v.sourceSessionId) || + !Number.isSafeInteger(v.sourceRecordRevision) || + (v.sourceRecordRevision as number) < 1 || + typeof v.capturedAt !== "string" || + !Number.isFinite(Date.parse(v.capturedAt)) || + !Number.isSafeInteger(v.retainedTurns) || + (v.retainedTurns as number) < 1 || + (v.retainedTurns as number) > 12 || + !Number.isSafeInteger(v.omittedTurns) || + (v.omittedTurns as number) < 0 || + typeof seed.conversationId !== "string" || + !/^ses_[A-Za-z0-9_-]{1,128}$/.test(seed.conversationId) || + (conversationId !== undefined && conversationId !== seed.conversationId) || + typeof seed.messageId !== "string" || + !/^msg_[A-Za-z0-9_-]{1,128}$/.test(seed.messageId) || + typeof seed.partId !== "string" || + !/^prt_[A-Za-z0-9_-]{1,128}$/.test(seed.partId) || + typeof seed.text !== "string" || + !seed.text || + seed.text.length > 24_000 || + typeof seed.sha256 !== "string" || + !/^[a-f\d]{64}$/.test(seed.sha256) + ) + return null; + return { + operationId: v.operationId, + sourceSessionId: v.sourceSessionId, + sourceRecordRevision: v.sourceRecordRevision as number, + capturedAt: v.capturedAt, + retainedTurns: v.retainedTurns as number, + omittedTurns: v.omittedTurns as number, + seed: { + conversationId: seed.conversationId, + messageId: seed.messageId, + partId: seed.partId, + text: seed.text, + sha256: seed.sha256, + }, + }; +} diff --git a/packages/harness/src/shared/assistant-history.ts b/packages/harness/src/shared/assistant-history.ts index 8d196ac43..277a7f800 100644 --- a/packages/harness/src/shared/assistant-history.ts +++ b/packages/harness/src/shared/assistant-history.ts @@ -17,4 +17,6 @@ export interface AssistantHistoryEntry { nativeResume: AssistantSessionView["nativeResume"]; resumeFailure?: OpenCodeTransportFailure; recordRevision: number | null; + /** Opaque stable retry partition, authorized and projected by the server. */ + continuationScope?: string; } diff --git a/packages/harness/src/shared/opencode-errors.ts b/packages/harness/src/shared/opencode-errors.ts index 13e9189d1..ded445453 100644 --- a/packages/harness/src/shared/opencode-errors.ts +++ b/packages/harness/src/shared/opencode-errors.ts @@ -11,6 +11,7 @@ export const openCodeTransportErrorCodes = [ "session_ended", "execution_paused", "cleanup_unconfirmed", + "continuation_unconfirmed", ] as const; export type OpenCodeTransportErrorCode = (typeof openCodeTransportErrorCodes)[number]; @@ -49,6 +50,13 @@ export interface OpenCodeStudioErrorEvent { } const fixedFailures = { + continuation_unconfirmed: { + code: "continuation_unconfirmed", + message: + "Studio could not verify the prepared continuation. Retry this operation to check its saved result.", + retryable: true, + action: "reconnect", + }, lifecycle_changed: { code: "lifecycle_changed", message: