Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(codex): 修复生图跨设备交付丢图 (#6420)
bobobce1a5f33870
diff --git a/apps/desktop/src/main/__tests__/codexTranslator.test.ts b/apps/desktop/src/main/__tests__/codexTranslator.test.tsindex c65d5667d1..9aadc47d30 100644--- a/apps/desktop/src/main/__tests__/codexTranslator.test.ts+++ b/apps/desktop/src/main/__tests__/codexTranslator.test.ts@@ -58,6 +58,30 @@ function feedItem(phase: 'started' | 'updated' | 'completed', item: Record<strintranslateItemNotification(phase, itemParams(item), coll.queue, { rt, log });}+// #6412: native image data must survive translation when savedPath belongs to another+// computer. The prior suite did not exercise imageGeneration. unit; no IO or timers.+describe('imageGeneration delivery', () => {+ it.each([+ { result: 'iVBORw0KGgo=', expected: { data: 'iVBORw0KGgo=' } },+ { result: '/9j/4AAQSkZJRg==', expected: { data: '/9j/4AAQSkZJRg==' } },+ { result: 'data:image/png;base64,iVBORw0KGgo=', expected: { url: 'data:image/png;base64,iVBORw0KGgo=' } },+ ])('preserves $result independently of savedPath', ({ result, expected }) => {+ feedItem('completed', { type: 'imageGeneration', id: 'img-1', status: 'completed', savedPath: '/other-computer/image.png', result });+ expect(coll.events).toEqual([{ type: 'image', source: 'codex', data: {+ kind: 'generation', blockId: 'img-1', threadId: 't1', turnId: 'turn-1',+ path: '/other-computer/image.png', status: 'completed', ...expected,+ } }]);+ });++ it('keeps bare Base64 without a path, and preserves legacy path-only events', () => {+ feedItem('completed', { type: 'imageGeneration', id: 'bytes', result: '/9j/4AAQSkZJRg==' });+ feedItem('completed', { type: 'imageGeneration', id: 'file', result: '/tmp/generated.png' });+ expect(coll.events[0].data).toMatchObject({ data: '/9j/4AAQSkZJRg==' });+ expect(coll.events[0].data).not.toHaveProperty('path');+ expect(coll.events[1].data).toMatchObject({ path: '/tmp/generated.png' });+ });+});+// ── agentMessage ────────────────────────────────────────────────────────────describe('agentMessage', () => {diff --git a/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.ts b/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.tsnew file mode 100644index 0000000000..9b504846d7--- /dev/null+++ b/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.ts@@ -0,0 +1,587 @@+/** #6412: unit coverage of the native delivery entry, real blob/ledger/journal and restart recovery.+ * Existing materializer tests do not cross transport ACK, durable publication or owner/clear fences.+ * Real main-process translations also cover the misplaced locale namespace reported on PR #6420.+ * The native generator and message writer are boundaries; retries never receive a generator API.+ */+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import fs from 'node:fs/promises';+import os from 'node:os';+import path from 'node:path';+import Database from 'better-sqlite3';+import { drizzle } from 'drizzle-orm/better-sqlite3';+import type { AgentEvent, GeneratedImageEventData } from '@cindy/maker-core';+import type { DbClient } from '../../localDb/client/DbClient';+import * as schema from '../../localDb/schema';+import { clearCurrentDbClient, setCurrentDbClient } from '../../localDb/client/current';+import { setMainLocale } from '../../i18n';+import { createGeneratedImageDelivery } from '../generatedImageDelivery';+import {+ captureGeneratedImageStorage,+ handleGeneratedImageArtifacts,+ prepareGeneratedImageTransport,+ readGeneratedImageEpoch,+} from '../generatedImageStorage';+import { generatedImageId } from '../generatedImageJournal';+import { resolveSafe } from '../blobStore';+import * as ledger from '../ledger';++const state = vi.hoisted(() => ({+ root: '',+ generation: 1,+ failResult: false,+ beforeResult: undefined as (() => void) | undefined,+ insert: undefined as ((sessionId: string, body: Record<string, unknown>) => void) | undefined,+ read: undefined as ((clientId: string) => { content: string; created_at: number }) | undefined,+ broadcast: vi.fn(),+}));+vi.mock('electron', () => ({ app: { getPath: () => state.root } }));+vi.mock('../../appSessionState', () => ({+ getActiveAppSession: () => ({ dataOwnerId: 'owner', generation: state.generation }),+ isAppSessionBoundaryPending: () => false,+ activeOwnerScopeKey: () => `owner:${state.generation}`,+ dataOwnerStorageKey: () => 'a'.repeat(20),+ ownerScopedUserDataPath: (...parts: string[]) =>+ path.join(state.root, 'owners', 'a'.repeat(20), ...parts),+}));+vi.mock('../../device-link/broadcast-tap', () => ({ captureDataOwnerBroadcastScope: () => ({}) }));+vi.mock('../../localDb/ipc/messages', () => ({+ broadcastMessageRow: state.broadcast,+ createMessage: async (+ sid: string,+ body: Record<string, unknown>,+ options: { beforePublish(): Promise<void> },+ ) => {+ if (body.role === 'tool_result') {+ state.beforeResult?.();+ if (state.failResult) throw new Error('disk unavailable');+ }+ await options.beforePublish();+ state.insert!(sid, body);+ const row = state.read!(body.clientId as string);+ return {+ ...body,+ id: body.clientId,+ sessionId: sid,+ content: JSON.parse(row.content),+ createdAt: new Date(row.created_at).toISOString(),+ };+ },+}));++const image: GeneratedImageEventData = {+ kind: 'generation',+ threadId: 'thread',+ turnId: 'turn',+ blockId: 'image',+ status: 'completed',+};+const id = generatedImageId(image);+const event = (data: Partial<GeneratedImageEventData> = {}): AgentEvent => ({+ type: 'image',+ source: 'codex',+ data: { ...image, ...data },+});+const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 42]);+let raw: Database.Database;+beforeEach(async () => {+ setMainLocale('en');+ state.root = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-native-image-'));+ state.generation = 1;+ state.failResult = false;+ state.beforeResult = undefined;+ state.broadcast.mockClear();+ raw = new Database(':memory:');+ raw.exec(`CREATE TABLE sessions (id TEXT PRIMARY KEY, status TEXT, cleared_at INTEGER, agent_device_id TEXT, remote_host_id TEXT, working_dir TEXT);+ CREATE TABLE messages (id TEXT PRIMARY KEY, session_id TEXT, client_id TEXT, role TEXT, content TEXT, rewind_at INTEGER, created_at INTEGER, UNIQUE(session_id, client_id));+ INSERT INTO sessions VALUES ('task', 'active', NULL, NULL, NULL, NULL);`);+ raw.exec(+ await fs.readFile(+ path.resolve(__dirname, '../../../../drizzle/0070_woozy_harpoon.sql'),+ 'utf8',+ ),+ );+ raw.exec('ALTER TABLE media_refs ADD COLUMN label TEXT');+ const client = {+ drizzle: drizzle(raw, { schema }),+ exec: async (sql: string, params: unknown[]) => raw.prepare(sql).run(...params),+ queryOne: async (sql: string, params: unknown[]) => raw.prepare(sql).get(...params),+ } as unknown as DbClient;+ setCurrentDbClient(client, 'owner');+ state.insert = (sid, body) =>+ raw+ .prepare('INSERT OR IGNORE INTO messages VALUES (?, ?, ?, ?, ?, NULL, ?)')+ .run(+ body.clientId,+ sid,+ body.clientId,+ body.role,+ JSON.stringify(body.content),+ body.createdAt,+ );+ state.read = (clientId) =>+ raw.prepare('SELECT content, created_at FROM messages WHERE client_id = ?').get(clientId) as {+ content: string;+ created_at: number;+ };+});+afterEach(async () => {+ vi.restoreAllMocks();+ clearCurrentDbClient();+ raw.close();+ await fs.rm(state.root, { recursive: true, force: true });+});++function prepareTransport(+ scope: string,+ imageEvent: AgentEvent,+ options: Partial<Parameters<typeof prepareGeneratedImageTransport>[2]> = {},+) {+ return prepareGeneratedImageTransport(scope, imageEvent, { retainForRecovery: true, ...options });+}++function controller() {+ const invoke = vi.fn(async (_device: string, _channel: string, args: unknown[]) => {+ const request = args[0] as Parameters<typeof handleGeneratedImageArtifacts>[1];+ return {+ ok: true,+ result:+ request.op === 'images'+ ? await handleGeneratedImageArtifacts('host-task', request)+ : { imageRecovery: true },+ };+ });+ const publish = vi.fn();+ return { ...createGeneratedImageDelivery({ invoke, publish }), invoke, publish };+}+function result() {+ const row = raw.prepare("SELECT content FROM messages WHERE role = 'tool_result'").get() as {+ content: string;+ };+ return JSON.parse(JSON.parse(row.content));+}++describe('native image delivery', () => {+ it('delivers bytes ahead of an unrelated remote path, persists one result and one attachment on duplicate completion', async () => {+ const host = controller();+ await Promise.all([+ host.deliver(+ 'task',+ event({+ data: png.toString('base64'),+ path: '/linux/missing.png',+ pathOrigin: 'remote-agent',+ }),+ ),+ host.deliver('task', event({ data: png.toString('base64') })),+ ]);+ await host.deliver('task', event({ data: png.toString('base64') }));+ expect(result()).toMatchObject({ ok: true, native_image_delivery: { id, state: 'stored' } });+ expect(result().text).toBe('Image delivered');+ expect(await fs.readFile(resolveSafe(result().xdt_image_url).absPath)).toEqual(png);+ expect(raw.prepare('SELECT * FROM messages').all()).toHaveLength(2);+ expect(raw.prepare('SELECT ref_kind FROM media_refs').all()).toEqual([+ { ref_kind: 'session-attachment' },+ ]);+ expect(host.invoke).not.toHaveBeenCalled();+ });++ // #6420: legacy controllers never send images/release, so they must not own durable source pins.+ it('delivers a source-only file to a legacy controller without retaining recovery ownership', async () => {+ const file = path.join(state.root, 'legacy-native.png');+ await fs.writeFile(file, png);+ const transported = await prepareTransport('remote:legacy-task', event({ path: file }), {+ retainForRecovery: false,+ });+ await fs.unlink(file);+ expect(transported.data).toMatchObject({+ url: `data:image/png;base64,${png.toString('base64')}`,+ });+ expect(transported.data).not.toHaveProperty('path');+ expect(await captureGeneratedImageStorage().journal.list('remote:legacy-task')).toEqual([]);+ expect(raw.prepare('SELECT * FROM media_refs').all()).toHaveLength(0);+ expect(raw.prepare('SELECT * FROM media_blobs').all()).toHaveLength(0);+ });++ it('recovers a source-only file after native file deletion and controller restart, then releases the source pin', async () => {+ const file = path.join(state.root, 'native.png');+ const large = Buffer.concat([png, Buffer.alloc(3_200_000)]);+ await fs.writeFile(file, large);+ const transported = await prepareTransport('remote:host-task', event({ path: file }));+ expect(transported.data).not.toHaveProperty('path');+ expect((transported.data as GeneratedImageEventData).url).toMatch(/^data:image\/png;base64,/);+ await fs.unlink(file);+ raw.exec("UPDATE sessions SET agent_device_id = 'source'");+ // The event was ACKed but never reached the controller's durable writer.+ const restarted = controller();+ await restarted.recover('task');+ expect(result().ok).toBe(true);+ expect((await fs.readFile(resolveSafe(result().xdt_image_url).absPath)).equals(large)).toBe(+ true,+ );+ expect(+ restarted.invoke.mock.calls.filter(+ (call) => (call[2][0] as { action?: string }).action === 'read',+ ).length,+ ).toBeGreaterThan(1);+ expect((await captureGeneratedImageStorage().journal.read('remote:host-task', id))?.state).toBe(+ 'released',+ );+ expect(raw.prepare('SELECT ref_kind FROM media_refs').all()).toEqual([+ { ref_kind: 'session-attachment' },+ ]);+ });++ it('keeps paid bytes across a message-writer failure and retries the same artifact without source access', async () => {+ state.failResult = true;+ await expect(+ controller().deliver('task', event({ data: png.toString('base64') })),+ ).rejects.toThrow('disk unavailable');+ expect((await captureGeneratedImageStorage().journal.read('task:task', id))?.state).toBe(+ 'failed',+ );+ state.failResult = false;+ const restarted = controller();+ await restarted.recover('task', id);+ expect(result().ok).toBe(true);+ expect(restarted.invoke).not.toHaveBeenCalled();+ });++ it('persists a delivery failure separately from native generation success without interpreting a remote path locally', async () => {+ const file = path.join(state.root, 'native.png');+ await fs.writeFile(file, png);+ const readSource = vi.fn(async () => ({ buffer: png, mimeType: 'image/png' }));+ const host = createGeneratedImageDelivery({ invoke: vi.fn(), publish: vi.fn(), readSource });+ await host.deliver('task', event({ path: file, pathOrigin: 'remote-agent' }));+ expect(readSource).not.toHaveBeenCalled();+ expect(result()).toMatchObject({+ ok: false,+ text: 'Image delivery failed. Retry transferring the existing image.',+ generation_status: 'completed',+ native_image_delivery: { state: 'failed', errorCode: 'REMOTE_SOURCE_REQUIRED' },+ });+ expect(raw.prepare('SELECT * FROM media_blobs').all()).toHaveLength(0);+ });++ it.each(['clear', 'delete', 'owner'])(+ 'does not publish after %s during delivery',+ async (boundary) => {+ state.beforeResult = () => {+ if (boundary === 'owner') state.generation++;+ else+ raw.exec(+ boundary === 'clear'+ ? 'UPDATE sessions SET cleared_at = 10'+ : "UPDATE sessions SET status = 'deleted'",+ );+ };+ const host = controller();+ if (boundary === 'owner')+ await expect(host.deliver('task', event({ data: png.toString('base64') }))).rejects.toThrow(+ 'SCOPE_CHANGED',+ );+ else await host.deliver('task', event({ data: png.toString('base64') }));+ expect(raw.prepare("SELECT * FROM messages WHERE role = 'tool_result'").all()).toHaveLength(+ 0,+ );+ expect(host.publish).not.toHaveBeenCalled();+ expect(state.broadcast).not.toHaveBeenCalled();+ if (boundary !== 'owner')+ expect(raw.prepare('SELECT * FROM media_refs').all()).toHaveLength(0);+ },+ );++ it('keeps the generation origin when the task changes its SSH location before retry', async () => {+ raw.exec("UPDATE sessions SET remote_host_id = 'original-ssh', working_dir = '/original'");+ const readSource = vi+ .fn()+ .mockRejectedValueOnce(new Error('offline'))+ .mockResolvedValue({ buffer: png, mimeType: 'image/png' });+ const host = createGeneratedImageDelivery({ invoke: vi.fn(), publish: vi.fn(), readSource });+ await host.deliver('task', event({ path: '/original/image.png' }));+ const failedRow = raw+ .prepare("SELECT id, client_id AS clientId FROM messages WHERE role = 'tool_result'")+ .get() as { id: string; clientId: string };+ expect(result().native_image_delivery.state).toBe('failed');+ state.broadcast.mockClear();+ raw.exec("UPDATE sessions SET remote_host_id = NULL, working_dir = '/local'");+ await host.recover('task', id);+ expect(readSource.mock.calls.map((call) => call[2])).toEqual([+ { remoteHostId: 'original-ssh', workingDir: '/original' },+ { remoteHostId: 'original-ssh', workingDir: '/original' },+ ]);+ expect(result().ok).toBe(true);+ // #6420: maker:event alone leaves Mobile's persisted result unchanged. Reuse the row ID.+ const storedRow = state.broadcast.mock.lastCall?.[1];+ expect(storedRow).toBeDefined();+ expect(storedRow).toMatchObject({ id: failedRow.id, clientId: failedRow.clientId });+ expect(JSON.parse(storedRow.content)).toMatchObject({+ ok: true,+ xdt_image_url: result().xdt_image_url,+ native_image_delivery: { id, state: 'stored' },+ });+ expect(state.broadcast.mock.lastCall?.[2]).toBeDefined();+ });++ // PR #6420: upstream pins and unknown artifacts had no durable release path.+ it('retains a relay receipt while the member is offline, then releases only its upstream copy after restart', async () => {+ const source = await prepareTransport(+ 'remote:member-task',+ event({ data: png.toString('base64') }),+ );+ const upstream = { agentDeviceId: 'member', sessionId: 'member-task', relay: 'r'.repeat(16) };+ let online = false;+ let relayCapable = false;+ const invoke = vi.fn(+ async (+ _device: string,+ _channel: string,+ args: unknown[],+ options?: { preSend?: () => void },+ ) => {+ options?.preSend?.();+ if (!online) throw new Error('offline');+ const request = args[0] as Parameters<typeof handleGeneratedImageArtifacts>[1];+ if (request.op !== 'images')+ return { ok: true, result: { imageRecoveryRelay: relayCapable } };+ expect(request).toMatchObject({+ sessionId: upstream.sessionId,+ relay: upstream.relay,+ action: 'release',+ imageId: id,+ });+ return { ok: true, result: await handleGeneratedImageArtifacts('member-task', request) };+ },+ );+ await prepareTransport('remote:relay-task', source, { upstream, invoke });+ expect(raw.prepare('SELECT * FROM media_refs').all()).toHaveLength(2);+ expect(+ (await captureGeneratedImageStorage().journal.read('remote:relay-task', id))+ ?.upstreamReleased,+ ).not.toBe(true);+ online = true;+ await createGeneratedImageDelivery({ invoke, publish: vi.fn() }).reconcile();+ expect(raw.prepare('SELECT * FROM media_refs').all()).toHaveLength(2);+ relayCapable = true;+ await createGeneratedImageDelivery({ invoke, publish: vi.fn() }).reconcile();+ expect(+ (await captureGeneratedImageStorage().journal.read('remote:member-task', id))?.state,+ ).toBe('released');+ const relay = (await captureGeneratedImageStorage().journal.read('remote:relay-task', id))!;+ expect(relay.upstreamReleased).toBe(true);+ expect((await captureGeneratedImageStorage().read(relay)).buffer).toEqual(png);+ expect(raw.prepare('SELECT * FROM media_refs').all()).toHaveLength(1);+ });++ it.each(['clear', 'delete'])(+ 'releases unknown source artifacts after an offline %s and restart without publishing messages',+ async (boundary) => {+ await prepareTransport(+ 'remote:host-task',+ event({ data: png.toString('base64'), deliveryEpoch: 0 }),+ );+ raw.exec("UPDATE sessions SET agent_device_id = 'source', cleared_at = 100");+ if (boundary === 'delete') raw.exec("UPDATE sessions SET status = 'deleted'");+ expect(await readGeneratedImageEpoch('task')).toBe(100);+ const offline = createGeneratedImageDelivery({+ invoke: vi.fn(async () => {+ throw new Error('offline');+ }),+ publish: vi.fn(),+ });+ await offline.cleanup('task');+ expect(await captureGeneratedImageStorage().journal.list('task:task')).toHaveLength(0);+ expect(await captureGeneratedImageStorage().journal.listCleanups()).toHaveLength(1);+ const newImage = { ...image, blockId: 'new-generation', deliveryEpoch: 100 };+ await prepareTransport(+ 'remote:host-task',+ event({ ...newImage, data: png.toString('base64') }),+ );+ if (boundary === 'delete') raw.exec('DELETE FROM sessions'); // The receipt outlives task-row purging.+ const restarted = controller();+ await restarted.reconcile();+ expect(+ (await captureGeneratedImageStorage().journal.read('remote:host-task', id))?.state,+ ).toBe('released');+ const newer = await captureGeneratedImageStorage().journal.read(+ 'remote:host-task',+ generatedImageId(newImage),+ );+ expect(newer?.state === 'released').toBe(boundary === 'delete');+ const remaining = raw.prepare('SELECT * FROM media_refs').all();+ expect(remaining).toHaveLength(boundary === 'clear' ? 1 : 0);+ expect(raw.prepare('SELECT * FROM messages').all()).toHaveLength(0);+ expect(restarted.publish).not.toHaveBeenCalled();+ expect(state.broadcast).not.toHaveBeenCalled();+ await restarted.deliver('task', event({ data: png.toString('base64'), deliveryEpoch: 0 }));+ expect(raw.prepare('SELECT * FROM messages').all()).toHaveLength(0);+ },+ );++ it('finds a cleared task with no local image or cleanup journal after a crash', async () => {+ await prepareTransport(+ 'remote:host-task',+ event({ data: png.toString('base64'), deliveryEpoch: 0 }),+ );+ raw.exec("UPDATE sessions SET agent_device_id = 'source', cleared_at = 100");+ await controller().reconcile();+ expect(raw.prepare('SELECT * FROM media_refs').all()).toHaveLength(0);+ expect(raw.prepare('SELECT * FROM messages').all()).toHaveLength(0);+ });++ it('recovers an unknown image from the new clear generation without reviving the old generation', async () => {+ await prepareTransport(+ 'remote:host-task',+ event({ data: png.toString('base64'), deliveryEpoch: 0 }),+ );+ raw.exec("UPDATE sessions SET agent_device_id = 'source', cleared_at = 100");+ const newer = { blockId: 'after-clear', data: png.toString('base64'), deliveryEpoch: 100 };+ await prepareTransport('remote:host-task', event(newer));+ await controller().recover('task');+ expect(result()).toMatchObject({+ ok: true,+ native_image_delivery: { id: generatedImageId({ ...image, ...newer }) },+ });+ expect(raw.prepare('SELECT * FROM messages').all()).toHaveLength(2);+ expect((await captureGeneratedImageStorage().journal.read('remote:host-task', id))?.state).toBe(+ 'released',+ );+ expect(raw.prepare('SELECT ref_kind FROM media_refs').all()).toEqual([+ { ref_kind: 'session-attachment' },+ ]);+ });++ it.each(['message_tombstone', 'rewound'])(+ 'recovers a later unknown image despite an unrelated %s row',+ async (removed) => {+ await prepareTransport('remote:host-task', event({ data: png.toString('base64') }));+ const removedImage = { ...image, blockId: 'removed-image' };+ await prepareTransport(+ 'remote:host-task',+ event({ ...removedImage, data: png.toString('base64') }),+ );+ const removedId = generatedImageId(removedImage);+ const removedClientId = `codex-image-${removedId}-result`;+ raw.exec("UPDATE sessions SET agent_device_id = 'source'");+ raw+ .prepare('INSERT INTO messages VALUES (?, ?, ?, ?, ?, ?, ?)')+ .run(+ removedClientId,+ 'task',+ removedClientId,+ removed === 'rewound' ? 'assistant' : removed,+ '"old"',+ removed === 'rewound' ? 10 : null,+ 1,+ );+ await controller().recover('task');+ expect(result().ok).toBe(true);+ expect(+ (await captureGeneratedImageStorage().journal.read('remote:host-task', id))?.state,+ ).toBe('released');+ expect(+ raw.prepare('SELECT role, rewind_at FROM messages WHERE id = ?').get(removedClientId),+ ).toMatchObject({+ role: removed === 'rewound' ? 'assistant' : removed,+ rewind_at: removed === 'rewound' ? 10 : null,+ });+ expect(+ (await captureGeneratedImageStorage().journal.read('remote:host-task', removedId))?.state,+ ).toBe('released');+ expect(+ await captureGeneratedImageStorage().journal.read('task:task', removedId),+ ).toMatchObject({ state: 'released' });+ },+ );++ // #6420: clearing while pin/lookup/INSERT is awaiting must not retain a hidden attachment.+ it.each(['pin', 'lookup', 'insert', 'restart', 'borrowed'] as const)(+ 'compensates a clear racing attachment %s while preserving unrelated references',+ async (boundary) => {+ const pin = ledger.pinBlob,+ lookup = ledger.hasRef,+ add = ledger.addRef;+ let cleared = false;+ const clear = async (hash: string) => {+ if (cleared) return;+ cleared = true;+ const at = Date.now() + 1000;+ raw.prepare('UPDATE sessions SET cleared_at = ?').run(at);+ await add(+ {+ hash,+ refKind: 'session-attachment',+ refId: 'other-task',+ originSessionId: 'other-task',+ },+ captureGeneratedImageStorage().db,+ );+ if (boundary === 'borrowed')+ raw+ .prepare('INSERT INTO messages VALUES (?, ?, ?, ?, ?, NULL, ?)')+ .run(+ 'new-message',+ 'task',+ 'new-message',+ 'assistant',+ JSON.stringify(`cindy-media://blobs/${hash}.png`),+ at + 1,+ );+ };+ vi.spyOn(ledger, 'pinBlob').mockImplementation(async (hash, db) => {+ await pin(hash, db);+ if (boundary === 'pin') await clear(hash);+ });+ vi.spyOn(ledger, 'hasRef').mockImplementation(async (params, db) => {+ const exists = await lookup(params, db);+ if (boundary === 'lookup' && params.refKind === 'session-attachment')+ await clear(params.hash);+ return exists;+ });+ vi.spyOn(ledger, 'addRef').mockImplementation(async (params, db) => {+ const added = await add(params, db);+ if (+ ['insert', 'restart', 'borrowed'].includes(boundary) &&+ params.refKind === 'session-attachment'+ )+ await clear(params.hash);+ return added;+ });+ const cleanup = vi.spyOn(ledger, 'removeSessionAttachmentRefIfUnreferencedByLiveMessage');+ if (boundary === 'restart') cleanup.mockRejectedValueOnce(new Error('cleanup unavailable'));+ const host = controller();+ const delivery = host.deliver('task', event({ data: png.toString('base64') }));+ if (boundary === 'restart') {+ await expect(delivery).rejects.toThrow('cleanup unavailable');+ const released = await captureGeneratedImageStorage().journal.read('task:task', id);+ expect(released).toMatchObject({+ state: 'released',+ blobUrl: expect.stringMatching(/^cindy-media:/),+ });+ await controller().reconcile();+ } else await delivery;+ expect(cleared).toBe(true);+ const refs = raw.prepare('SELECT ref_id FROM media_refs ORDER BY ref_id').all();+ expect(refs).toEqual(+ boundary === 'borrowed'+ ? [{ ref_id: 'other-task' }, { ref_id: 'task' }]+ : [{ ref_id: 'other-task' }],+ );+ expect(host.publish).not.toHaveBeenCalled();+ expect(state.broadcast).not.toHaveBeenCalled();+ },+ );++ it('does not resurrect a removed result during retry', async () => {+ const host = controller();+ await host.deliver('task', event({ pathOrigin: 'remote-agent' }));+ raw.exec("UPDATE messages SET role = 'message_tombstone' WHERE role = 'tool_result'");+ host.publish.mockClear();+ state.broadcast.mockClear();+ await host.recover('task', id);+ expect(host.publish).not.toHaveBeenCalled();+ expect(state.broadcast).not.toHaveBeenCalled();+ expect((await captureGeneratedImageStorage().journal.read('task:task', id))?.state).toBe(+ 'released',+ );+ });+});diff --git a/apps/desktop/src/main/cindy-media/__tests__/generatedMedia.test.ts b/apps/desktop/src/main/cindy-media/__tests__/generatedMedia.test.tsindex 518d70de8a..b7bb86454f 100644--- a/apps/desktop/src/main/cindy-media/__tests__/generatedMedia.test.ts+++ b/apps/desktop/src/main/cindy-media/__tests__/generatedMedia.test.ts@@ -164,6 +164,38 @@ describe('materializeGeneratedImage(codex 生成图物化,thin adapter 的逻辑deps.ingestBuffer.mockClear();});+ // #6412: the prior path-only/data-URL-only cases missed their combined shape.+ // unit: production materializer must return a managed result without touching a foreign path.+ it.each(['base64', 'data-url'])('uses valid %s bytes before an unreadable remote path', async (encoding) => {+ deps.ingestFromPath.mockRejectedValueOnce(new Error('MEDIA_SOURCE_MISSING'));+ const source = encoding === 'base64'+ ? { data: PNG_BYTES.toString('base64') }+ : { url: `data:image/jpeg;base64,${PNG_BYTES.toString('base64')}` };+ const saved = await generatedMedia.materializeGeneratedImage({+ ...source, path: '/other-computer/image.png', pathOrigin: 'remote-agent',+ }, deps);+ expect(saved?.url).toBe(`cindy-media://blobs/${'c'.repeat(64)}.png`);+ expect(deps.ingestFromPath).not.toHaveBeenCalled();+ expect(deps.ingestBuffer).toHaveBeenCalledWith({ buffer: PNG_BYTES, mimeType: 'image/png' });+ deps.ingestFromPath.mockReset();+ deps.ingestFromPath.mockImplementation(async ({ originalName }) => ({+ url: `cindy-media://blobs/${'b'.repeat(64)}.png`, filename: originalName ?? 'x.png',+ }));+ });++ it('never reads a remote path on this Host, even if a local namesake exists', async () => {+ await expect(generatedMedia.materializeGeneratedImage({+ path: '/tmp/actual.png', pathOrigin: 'remote-agent',+ }, deps)).rejects.toThrow('REMOTE_SOURCE_REQUIRED');+ expect(deps.ingestFromPath).not.toHaveBeenCalled();+ });++ it.each(['not an image', '%%%'])('rejects invalid image bytes without falling back to a path', async (data) => {+ await expect(generatedMedia.materializeGeneratedImage({ data, path: '/tmp/actual.png' }, deps))+ .rejects.toThrow('INVALID_IMAGE');+ expect(deps.ingestFromPath).not.toHaveBeenCalled();+ });+it('托管地址核验后复用,不重复入仓', async () => {const legacy = await generatedMedia.materializeGeneratedImage({ url: 'xdt-image://sess-1/pic.png' },diff --git a/apps/desktop/src/main/cindy-media/chatAttachments.ts b/apps/desktop/src/main/cindy-media/chatAttachments.tsindex 3f8afadcaa..342d257212 100644--- a/apps/desktop/src/main/cindy-media/chatAttachments.ts+++ b/apps/desktop/src/main/cindy-media/chatAttachments.ts@@ -153,6 +153,8 @@ export async function commitChatImageUrls(urls: string[];/** 出生来源:用户消息附件 'user'(默认);assistant/tool 消息里的生成产物 'tool'。 */originKind?: 'user' | 'tool';+ /** Native delivery must recheck the task after acquiring its media-reference lock. */+ assertStillValid?: () => Promise<void>;},db?: LedgerDb,): Promise<{ committed: number; skipped: number; failed: number }> {@@ -169,6 +171,7 @@ async function commitChatImageUrlsUnlocked(params: Parameters<typeof commitChatImageUrls>[0],db: LedgerDb,): Promise<{ committed: number; skipped: number; failed: number }> {+ await params.assertStillValid?.();let committed = 0;let skipped = 0;let failed = 0;@@ -189,6 +192,7 @@ async function commitChatImageUrlsUnlocked(skipped += 1;continue;}+ await params.assertStillValid?.();await ledger.addRef({hash: parsed.hash,diff --git a/apps/desktop/src/main/cindy-media/generatedImageDelivery.ts b/apps/desktop/src/main/cindy-media/generatedImageDelivery.tsnew file mode 100644index 0000000000..3a84caed64--- /dev/null+++ b/apps/desktop/src/main/cindy-media/generatedImageDelivery.ts@@ -0,0 +1,616 @@+import { createHash } from 'node:crypto';+import { and, eq, isNotNull, or } from 'drizzle-orm';+import type { AgentEvent, GeneratedImageEventData } from '@cindy/maker-core';+import { REMOTE_AGENT_CHANNEL, REMOTE_AGENT_READ_MAX_BYTES } from '@cindy/device-link';+import { sessions, messages } from '../localDb/schema';+import { broadcastMessageRow, createMessage } from '../localDb/ipc/messages';+import { captureDataOwnerBroadcastScope } from '../device-link/broadcast-tap';+import {+ captureGeneratedImageStorage,+ generatedImageErrorCode,+ releaseGeneratedImageUpstream,+} from './generatedImageStorage';+import {+ generatedImageId,+ initialGeneratedImageRecord,+ type GeneratedImageCleanup,+} from './generatedImageJournal';+import { commitChatImageUrls } from './chatAttachments';+import { MAX_GENERATED_IMAGE_BYTES } from './generatedMedia';+import { t } from '../i18n';++const taskFields = {+ id: sessions.id,+ status: sessions.status,+ clearedAt: sessions.clearedAt,+ agentDeviceId: sessions.agentDeviceId,+ remoteHostId: sessions.remoteHostId,+ workingDir: sessions.workingDir,+};++export interface GeneratedImageDeliveryDeps {+ invoke(+ deviceId: string,+ channel: string,+ args: unknown[],+ options?: { preSend?: () => void },+ ): Promise<{ ok: boolean; result?: unknown }>;+ publish(sessionId: string, event: AgentEvent, persistId: string, resolvedContent?: string): void;+ readSource?(+ sessionId: string,+ image: GeneratedImageEventData,+ origin: { remoteHostId: string | null; workingDir: string | null },+ ): Promise<{ buffer: Buffer; mimeType: string }>;+}++/** Deliberately has no Agent.send/imagegen dependency. Every retry reuses an existing artifact. */+export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {+ const inFlight = new Map<string, Promise<void>>();++ async function remote(deviceId: string, request: object, assertCurrent: () => void) {+ assertCurrent();+ const response = await deps.invoke(deviceId, REMOTE_AGENT_CHANNEL, [request], {+ preSend: assertCurrent,+ });+ assertCurrent();+ if (!response.ok || !response.result || typeof response.result !== 'object')+ throw new Error('REMOTE_SOURCE_REQUIRED');+ return response.result as Record<string, unknown>;+ }++ async function download(+ deviceId: string,+ sessionId: string,+ id: string,+ assertCurrent: () => void,+ ) {+ const caps = await remote(deviceId, { op: 'caps' }, assertCurrent);+ assertCurrent();+ if (caps.imageRecovery !== true) throw new Error('REMOTE_SOURCE_REQUIRED');+ const chunks: Buffer[] = [];+ let offset = 0;+ let expected: { hash: string; bytes: number } | undefined;+ for (;;) {+ assertCurrent();+ const result = await remote(+ deviceId,+ {+ op: 'images',+ sessionId,+ action: 'read',+ imageId: id,+ offset,+ },+ assertCurrent,+ );+ assertCurrent();+ if (+ typeof result.data !== 'string' ||+ result.data.length > Math.ceil(REMOTE_AGENT_READ_MAX_BYTES / 3) * 4 ||+ typeof result.bytes !== 'number' ||+ result.bytes <= 0 ||+ result.bytes > MAX_GENERATED_IMAGE_BYTES ||+ typeof result.hash !== 'string' ||+ !/^[a-f0-9]{64}$/.test(result.hash) ||+ result.offset !== offset ||+ typeof result.next !== 'number'+ )+ throw new Error('INVALID_IMAGE');+ if (expected && (expected.hash !== result.hash || expected.bytes !== result.bytes))+ throw new Error('INVALID_IMAGE');+ expected = { hash: result.hash as string, bytes: result.bytes };+ const chunk = Buffer.from(result.data, 'base64');+ if (!chunk.length || result.next !== offset + chunk.length || result.next > result.bytes)+ throw new Error('INVALID_IMAGE');+ chunks.push(chunk);+ offset = result.next;+ if (result.done === true) {+ if (offset !== result.bytes) throw new Error('INVALID_IMAGE');+ // stage() performs the same byte/MIME validation as a live native event.+ const buffer = Buffer.concat(chunks, offset);+ if (createHash('sha256').update(buffer).digest('hex') !== expected.hash)+ throw new Error('INVALID_IMAGE');+ return buffer.toString('base64');+ }+ }+ }++ async function deliver(sessionId: string, event: AgentEvent): Promise<void> {+ const image = event.data as GeneratedImageEventData;+ if (+ event.type !== 'image' ||+ event.source !== 'codex' ||+ image?.kind !== 'generation' ||+ !image.blockId+ )+ return;+ const storage = captureGeneratedImageStorage();+ const id = generatedImageId(image);+ const key = `${storage.snapshot.clientEpoch}:${sessionId}:${id}`;+ const pending = inFlight.get(key);+ if (pending) return pending;+ const operation = perform(storage, sessionId, id, image, event, Date.now());+ inFlight.set(key, operation);+ try {+ await operation;+ } finally {+ if (inFlight.get(key) === operation) inFlight.delete(key);+ }+ }++ async function perform(+ storage: ReturnType<typeof captureGeneratedImageStorage>,+ sessionId: string,+ id: string,+ image: GeneratedImageEventData,+ event: AgentEvent,+ admittedAt: number,+ ) {+ const scope = `task:${sessionId}`;+ const [session] = await storage.db+ .select(taskFields)+ .from(sessions)+ .where(eq(sessions.id, sessionId))+ .limit(1);+ storage.assertCurrent();+ if (!session || session.status === 'deleted') {+ await cleanup(sessionId);+ return;+ }+ if (session.clearedAt !== null && session.clearedAt >= admittedAt) return;+ if (image.deliveryEpoch !== undefined && image.deliveryEpoch !== (session.clearedAt ?? 0)) {+ await cleanup(sessionId);+ return;+ }+ let record = await storage.journal.update(+ scope,+ id,+ (previous) =>+ previous ?? {+ ...initialGeneratedImageRecord(scope, image),+ clearedAt: session.clearedAt,+ remoteHostId: session.remoteHostId,+ workingDir: session.workingDir,+ ...(session.agentDeviceId ? { agentDeviceId: session.agentDeviceId } : {}),+ },+ );+ const toolUseId = `codex-image-${id}`;+ const useClientId = `${toolUseId}-use`,+ resultClientId = `${toolUseId}-result`;+ const ownerScope = captureDataOwnerBroadcastScope();+ const assertTask = async () => {+ storage.assertCurrent();+ const [current] = await storage.db+ .select({ status: sessions.status, clearedAt: sessions.clearedAt })+ .from(sessions)+ .where(eq(sessions.id, sessionId))+ .limit(1);+ const [result] = await storage.db+ .select({ role: messages.role, rewindAt: messages.rewindAt })+ .from(messages)+ .where(and(eq(messages.sessionId, sessionId), eq(messages.clientId, resultClientId)))+ .limit(1);+ storage.assertCurrent();+ if (+ !current ||+ current.status === 'deleted' ||+ current.clearedAt !== record.clearedAt ||+ result?.rewindAt != null ||+ result?.role === 'message_tombstone'+ )+ throw new Error('IMAGE_DELIVERY_RELEASED');+ };+ if (record.state === 'released') {+ await storage.release(scope, id);+ await releaseSource(record);+ return;+ }+ try {+ await assertTask();+ } catch (error) {+ if (!(error instanceof Error) || error.message !== 'IMAGE_DELIVERY_RELEASED') throw error;+ await storage.release(scope, id);+ await releaseSource(record);+ return;+ }+ async function releaseSource(value: typeof record) {+ if (!value.agentDeviceId || value.sourceReleased) return;+ try {+ await remote(+ value.agentDeviceId,+ {+ op: 'images',+ sessionId,+ action: 'release',+ imageId: id,+ },+ storage.assertCurrent,+ );+ storage.assertCurrent();+ await storage.journal.update(scope, id, (current) => ({+ ...current!,+ sourceReleased: true,+ }));+ } catch {+ /* Retry the durable receipt on the next history load. */+ }+ }++ const input = { ...(image.revisedPrompt ? { prompt: image.revisedPrompt } : {}) };+ async function publish(state: 'failed' | 'stored', errorCode?: string) {+ await assertTask();+ const content = JSON.stringify({+ ok: state === 'stored',+ kind: 'generation',+ generation_status: image.status ?? 'completed',+ native_image_delivery: { id, state, ...(errorCode ? { errorCode } : {}) },+ text: t(state === 'stored' ? 'chat.imageDelivery.stored' : 'chat.imageDelivery.failed'),+ ...(state === 'stored'+ ? { xdt_image_url: record.blobUrl, filename: record.blobUrl!.split('/').pop() }+ : {}),+ });+ const meta = (event.agentMeta ?? null) as Parameters<typeof createMessage>[1]['agentMeta'];+ await createMessage(+ sessionId,+ {+ clientId: useClientId,+ role: 'tool_use',+ toolUseId,+ content: { toolUseId, toolName: 'imagegen', input },+ agentKind: 'codex',+ agentMeta: meta,+ createdAt: record.createdAt,+ },+ {+ beforePublish: assertTask,+ deferMediaRefs: true,+ broadcastOwnerScope: ownerScope,+ shouldBroadcast: () => {+ storage.assertCurrent();+ return true;+ },+ },+ );+ await assertTask();+ const resultMessage = await createMessage(+ sessionId,+ {+ clientId: resultClientId,+ role: 'tool_result',+ toolUseId,+ content,+ agentKind: 'codex',+ agentMeta: meta,+ createdAt: record.createdAt + 1,+ },+ {+ beforePublish: assertTask,+ deferMediaRefs: true,+ broadcastOwnerScope: ownerScope,+ shouldBroadcast: () => {+ storage.assertCurrent();+ return true;+ },+ },+ );+ await assertTask();+ // Conditional update cannot rewrite a removed/rewound message or cross a task clear.+ const changed = await storage.snapshot.client.exec(+ `UPDATE messages SET content = ? WHERE session_id = ? AND client_id = ? AND role = 'tool_result'+ AND rewind_at IS NULL AND EXISTS (SELECT 1 FROM sessions WHERE id = ? AND status != 'deleted' AND cleared_at IS ?)`,+ [JSON.stringify(content), sessionId, resultClientId, sessionId, record.clearedAt ?? null],+ );+ if (changed.changes !== 1) throw new Error('IMAGE_DELIVERY_RELEASED');+ await assertTask();+ if (state === 'stored') {+ const refs = await commitChatImageUrls(+ { sessionId, urls: [record.blobUrl!], originKind: 'tool', assertStillValid: assertTask },+ storage.db,+ );+ await assertTask();+ if (refs.failed || refs.committed + refs.skipped !== 1)+ throw new Error('MEDIA_PUBLISH_FAILED');+ }+ // Idempotent createMessage returns the previous row without broadcasting on retry.+ // Mobile consumes persisted row updates, so publish the committed content with its stable ID.+ broadcastMessageRow(sessionId, { ...resultMessage, content }, ownerScope);+ deps.publish(+ sessionId,+ {+ type: 'tool_use',+ source: 'codex',+ agentMeta: event.agentMeta,+ data: { toolUseId, toolName: 'imagegen', input },+ },+ useClientId,+ );+ deps.publish(+ sessionId,+ {+ type: 'tool_result_full',+ source: 'codex',+ agentMeta: event.agentMeta,+ data: { toolUseId, fullText: content, isError: false },+ },+ resultClientId,+ content,+ );+ deps.publish(+ sessionId,+ {+ type: 'tool_result',+ source: 'codex',+ agentMeta: event.agentMeta,+ data: { toolUseIds: [toolUseId], summary: content },+ },+ resultClientId,+ content,+ );+ }++ try {+ if (record.state !== 'stored') {+ let source = image;+ if (!image.data && !image.url?.startsWith('data:') && record.agentDeviceId) {+ let cached = false;+ if (record.blobUrl) {+ try {+ await storage.read(record);+ cached = true;+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;+ }+ }+ if (!cached)+ source = {+ ...image,+ data: await download(record.agentDeviceId, sessionId, id, storage.assertCurrent),+ };+ }+ const staged = await storage.stage(+ scope,+ source,+ !record.agentDeviceId && deps.readSource+ ? () =>+ deps.readSource!(sessionId, source, {+ remoteHostId: record.remoteHostId ?? null,+ workingDir: record.workingDir ?? null,+ })+ : undefined,+ );+ record = staged.record;+ await assertTask();+ await publish('stored');+ record = await storage.journal.update(scope, id, (current) => {+ if (!current || current.state === 'released') throw new Error('IMAGE_DELIVERY_RELEASED');+ return { ...current, state: 'stored', errorCode: undefined };+ });+ // Cleanup failure cannot downgrade a durably published image.+ }+ await storage.unpin(scope, id).catch(() => undefined);+ await releaseSource(record);+ } catch (error) {+ storage.assertCurrent();+ if (error instanceof Error && error.message === 'IMAGE_DELIVERY_RELEASED') {+ await storage.release(scope, id);+ await releaseSource(record);+ return;+ }+ record = await storage.journal.update(scope, id, (current) => {+ if (!current || current.state === 'released') throw new Error('IMAGE_DELIVERY_RELEASED');+ return { ...current, state: 'failed', errorCode: generatedImageErrorCode(error) };+ });+ await publish('failed', record.errorCode);+ }+ }++ // Release-only enumeration: never passes an unknown artifact to the message writer.+ async function cleanupUnknown(receipt: GeneratedImageCleanup) {+ const storage = captureGeneratedImageStorage();+ const caps = await remote(receipt.agentDeviceId, { op: 'caps' }, storage.assertCurrent);+ if (caps.imageRecovery !== true) return;+ let offset = 0;+ for (;;) {+ const page = await remote(+ receipt.agentDeviceId,+ { op: 'images', sessionId: receipt.sessionId, action: 'list', offset },+ storage.assertCurrent,+ );+ if (!Array.isArray(page.images) || page.images.length > 64)+ throw new Error('INVALID_IMAGE_DELIVERY');+ for (const value of page.images as Array<{ id?: unknown; image?: GeneratedImageEventData }>) {+ if (+ !value.image ||+ value.image.kind !== 'generation' ||+ typeof value.image.blockId !== 'string' ||+ generatedImageId(value.image) !== value.id+ )+ throw new Error('INVALID_IMAGE_DELIVERY');+ // Legacy source images without an epoch cannot safely be ordered across a clear.+ const epoch = value.image.deliveryEpoch;+ if (+ !receipt.deleted &&+ !(+ typeof epoch === 'number' &&+ Number.isSafeInteger(epoch) &&+ epoch >= 0 &&+ receipt.clearedAt !== null &&+ epoch < receipt.clearedAt+ )+ )+ continue;+ await remote(+ receipt.agentDeviceId,+ { op: 'images', sessionId: receipt.sessionId, action: 'release', imageId: value.id },+ storage.assertCurrent,+ );+ }+ if (page.next === null) return;+ if (typeof page.next !== 'number' || !Number.isSafeInteger(page.next) || page.next <= offset)+ throw new Error('INVALID_IMAGE_DELIVERY');+ offset = page.next;+ }+ }++ async function cleanup(sessionId: string) {+ const storage = captureGeneratedImageStorage();+ const [session] = await storage.db+ .select(taskFields)+ .from(sessions)+ .where(eq(sessions.id, sessionId))+ .limit(1);+ storage.assertCurrent();+ if (session?.agentDeviceId && (session.status === 'deleted' || session.clearedAt !== null)) {+ const scope = `cleanup:${sessionId}:${session.agentDeviceId}`;+ const receipt = await storage.journal.updateCleanup(scope, (previous) => ({+ version: 1,+ scope,+ sessionId,+ agentDeviceId: session.agentDeviceId!,+ clearedAt: Math.max(previous?.clearedAt ?? 0, session.clearedAt ?? 0),+ deleted: previous?.deleted === true || session.status === 'deleted',+ }));+ await cleanupUnknown(receipt).catch(() => undefined);+ storage.assertCurrent();+ }+ for (const record of await storage.journal.list(`task:${sessionId}`)) {+ if (session && session.status !== 'deleted' && record.clearedAt === session.clearedAt)+ continue;+ await storage.release(record.scope, record.id);+ if (record.agentDeviceId && !record.sourceReleased) {+ try {+ await remote(+ record.agentDeviceId,+ {+ op: 'images',+ sessionId,+ action: 'release',+ imageId: record.id,+ },+ storage.assertCurrent,+ );+ storage.assertCurrent();+ await storage.journal.update(record.scope, record.id, (current) => ({+ ...current!,+ sourceReleased: true,+ }));+ } catch {+ /* Retain the pending release receipt while the source is offline. */+ }+ }+ }+ }++ async function recoverOnce(sessionId: string, imageId?: string) {+ await cleanup(sessionId);+ const storage = captureGeneratedImageStorage();+ const scope = `task:${sessionId}`;+ const records = await storage.journal.list(scope);+ if (imageId && !records.some((record) => record.id === imageId))+ throw new Error('MEDIA_SOURCE_MISSING');+ for (const record of records) {+ if (imageId && record.id !== imageId) continue;+ if (record.state === 'stored' && (!record.agentDeviceId || record.sourceReleased)) {+ await storage.unpin(scope, record.id).catch(() => undefined);+ continue;+ }+ await deliver(sessionId, {+ type: 'image',+ source: 'codex',+ data: { ...record.image, ...(record.sourceUrl ? { url: record.sourceUrl } : {}) },+ });+ }+ if (imageId) return;+ const [session] = await storage.db+ .select(taskFields)+ .from(sessions)+ .where(eq(sessions.id, sessionId))+ .limit(1);+ if (!session?.agentDeviceId || session.status === 'deleted') return;+ // Each stable result ID is checked by perform/assertTask. An unrelated tombstone or+ // rewound row must not permanently disable recovery for all future paid outputs.+ const caps = await remote(session.agentDeviceId, { op: 'caps' }, storage.assertCurrent);+ if (caps.imageRecovery !== true) return;+ let offset = 0;+ for (;;) {+ const page = await remote(+ session.agentDeviceId,+ {+ op: 'images',+ sessionId,+ action: 'list',+ offset,+ },+ storage.assertCurrent,+ );+ storage.assertCurrent();+ if (!Array.isArray(page.images) || page.images.length > 64)+ throw new Error('INVALID_IMAGE_DELIVERY');+ for (const value of page.images as Array<{ id?: unknown; image?: GeneratedImageEventData }>) {+ if (+ !value.image ||+ value.image.kind !== 'generation' ||+ typeof value.image.blockId !== 'string' ||+ generatedImageId(value.image) !== value.id+ )+ throw new Error('INVALID_IMAGE_DELIVERY');+ if (session.clearedAt !== null && value.image.deliveryEpoch !== session.clearedAt) continue;+ await deliver(sessionId, {+ type: 'image',+ source: 'codex',+ data: { ...value.image, pathOrigin: 'remote-agent' },+ });+ }+ if (page.next === null) break;+ if (typeof page.next !== 'number' || page.next <= offset)+ throw new Error('INVALID_IMAGE_DELIVERY');+ offset = page.next;+ }+ }+ const recoveries = new Map<string, Promise<void>>();+ async function recover(sessionId: string, imageId?: string) {+ const storage = captureGeneratedImageStorage();+ const key = `${storage.snapshot.clientEpoch}:${sessionId}:${imageId ?? ''}`;+ const existing = recoveries.get(key);+ if (existing) return existing;+ const operation = recoverOnce(sessionId, imageId);+ recoveries.set(key, operation);+ try {+ await operation;+ } finally {+ if (recoveries.get(key) === operation) recoveries.delete(key);+ }+ }+ async function reconcile() {+ const storage = captureGeneratedImageStorage();+ const tasks = new Set<string>();+ // A crash may precede the first image journal or cleanup receipt write.+ for (const session of await storage.db+ .select({ id: sessions.id })+ .from(sessions)+ .where(+ and(+ isNotNull(sessions.agentDeviceId),+ or(isNotNull(sessions.clearedAt), eq(sessions.status, 'deleted')),+ ),+ ))+ tasks.add(session.id);+ for (const receipt of await storage.journal.listCleanups()) {+ await cleanupUnknown(receipt).catch(() => undefined);+ storage.assertCurrent();+ }+ for (const record of await storage.journal.listAll()) {+ storage.assertCurrent();+ if (record.scope.startsWith('task:')) tasks.add(record.scope.slice(5));+ else {+ if (record.state === 'released') await storage.release(record.scope, record.id);+ await releaseGeneratedImageUpstream(storage, record, deps.invoke).catch(() => undefined);+ }+ }+ for (const sessionId of tasks) {+ storage.assertCurrent();+ await cleanup(sessionId);+ }+ }+ return { deliver, recover, cleanup, reconcile };+}diff --git a/apps/desktop/src/main/cindy-media/generatedImageJournal.ts b/apps/desktop/src/main/cindy-media/generatedImageJournal.tsnew file mode 100644index 0000000000..eb90b0f683--- /dev/null+++ b/apps/desktop/src/main/cindy-media/generatedImageJournal.ts@@ -0,0 +1,279 @@+import { createHash, randomUUID } from 'node:crypto';+import fs from 'node:fs/promises';+import path from 'node:path';+import type { GeneratedImageEventData } from '@cindy/maker-core';+import { withCrossProcessLock } from '../device-link/crossProcessLock';+import { readBoundedFileNoFollow } from '../utils/readBoundedFile';++/** Only recovery metadata lives here. Image bytes always live in cindy-media. */+export interface GeneratedImageUpstream {+ agentDeviceId: string;+ sessionId: string;+ relay: string;+}++export interface GeneratedImageCleanup {+ version: 1;+ scope: string;+ sessionId: string;+ agentDeviceId: string;+ clearedAt: number | null;+ deleted: boolean;+}++export interface GeneratedImageRecord {+ version: 1;+ id: string;+ scope: string;+ createdAt: number;+ image: Omit<GeneratedImageEventData, 'data' | 'url'>;+ sourceUrl?: string;+ blobUrl?: string;+ state: 'pending' | 'stored' | 'failed' | 'released';+ errorCode?: string;+ /** Task clear boundary captured before the asynchronous delivery starts. */+ clearedAt?: number | null;+ agentDeviceId?: string;+ remoteHostId?: string | null;+ workingDir?: string | null;+ sourceReleased?: boolean;+ upstream?: GeneratedImageUpstream;+ upstreamReleased?: boolean;+}++export function generatedImageId(+ image: Pick<GeneratedImageEventData, 'threadId' | 'turnId' | 'blockId'>,+): string {+ return createHash('sha256')+ .update(JSON.stringify([image.threadId ?? '', image.turnId ?? '', image.blockId]))+ .digest('hex');+}++export function createGeneratedImageJournal(root: string, assertCurrent: () => void) {+ const scopeDir = (scope: string) =>+ path.join(root, createHash('sha256').update(scope).digest('hex'));+ const fileFor = (scope: string, id: string) => {+ if (!/^[a-f0-9]{64}$/.test(id)) throw new Error('INVALID_IMAGE_DELIVERY');+ return path.join(scopeDir(scope), `${id}.json`);+ };++ async function read(scope: string, id: string): Promise<GeneratedImageRecord | null> {+ assertCurrent();+ const file = fileFor(scope, id);+ try {+ await fs.lstat(file);+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;+ throw error;+ }+ const source = await readBoundedFileNoFollow(file, 128 * 1024, { nonBlocking: true });+ if (!source) throw new Error('INVALID_IMAGE_DELIVERY');+ const record = JSON.parse(source.toString('utf8')) as GeneratedImageRecord;+ assertCurrent();+ if (+ record.version !== 1 ||+ record.id !== id ||+ record.scope !== scope ||+ !record.image ||+ record.image.kind !== 'generation' ||+ typeof record.image.blockId !== 'string' ||+ generatedImageId(record.image) !== id ||+ !Number.isFinite(record.createdAt) ||+ !['pending', 'stored', 'failed', 'released'].includes(record.state)+ )+ throw new Error('INVALID_IMAGE_DELIVERY');+ return record;+ }++ async function update(+ scope: string,+ id: string,+ change: (+ previous: GeneratedImageRecord | null,+ ) => Promise<GeneratedImageRecord> | GeneratedImageRecord,+ ): Promise<GeneratedImageRecord> {+ fileFor(scope, id); // Validate before deriving a lock or temporary path.+ return updateFile(scope, `${id}.json`, () => read(scope, id), change);+ }++ async function updateFile<T>(+ scope: string,+ name: string,+ previous: () => Promise<T | null>,+ change: (value: T | null) => Promise<T> | T,+ ): Promise<T> {+ assertCurrent();+ const dir = scopeDir(scope);+ await fs.mkdir(dir, { recursive: true, mode: 0o700 });+ const info = await fs.lstat(dir);+ if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('INVALID_IMAGE_DELIVERY');+ return withCrossProcessLock(+ path.join(dir, `${name}.lock`),+ { label: 'generated-image-delivery' },+ async (lock) => {+ if (!lock.held) throw new Error('IMAGE_DELIVERY_BUSY');+ assertCurrent();+ const next = await change(await previous());+ assertCurrent();+ const encoded = JSON.stringify(next);+ if (Buffer.byteLength(encoded) > 128 * 1024) throw new Error('INVALID_IMAGE_DELIVERY');+ const temporary = path.join(dir, `.${name}.${randomUUID()}.tmp`);+ try {+ const handle = await fs.open(temporary, 'wx', 0o600);+ try {+ await handle.writeFile(encoded);+ await handle.sync();+ } finally {+ await handle.close();+ }+ assertCurrent();+ await fs.rename(temporary, path.join(dir, name));+ if (process.platform !== 'win32') {+ const directory = await fs.open(dir, 'r');+ try {+ await directory.sync();+ } finally {+ await directory.close();+ }+ }+ } finally {+ await fs.rm(temporary, { force: true }).catch(() => undefined);+ }+ return next;+ },+ );+ }++ async function list(scope: string): Promise<GeneratedImageRecord[]> {+ assertCurrent();+ let names: string[];+ try {+ names = await fs.readdir(scopeDir(scope));+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];+ throw error;+ }+ const records: GeneratedImageRecord[] = [];+ for (const name of names) {+ if (!/^[a-f0-9]{64}\.json$/.test(name)) continue;+ const record = await read(scope, name.slice(0, -5));+ if (record) records.push(record);+ }+ return records.sort((a, b) => a.createdAt - b.createdAt);+ }++ async function listAll(): Promise<GeneratedImageRecord[]> {+ assertCurrent();+ let dirs: string[];+ try {+ dirs = await fs.readdir(root);+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];+ throw error;+ }+ const records: GeneratedImageRecord[] = [];+ for (const dir of dirs) {+ if (!/^[a-f0-9]{64}$/.test(dir)) continue;+ const info = await fs.lstat(path.join(root, dir));+ if (!info.isDirectory() || info.isSymbolicLink()) continue;+ for (const name of await fs.readdir(path.join(root, dir))) {+ if (!/^[a-f0-9]{64}\.json$/.test(name)) continue;+ const raw = await readBoundedFileNoFollow(path.join(root, dir, name), 128 * 1024, {+ nonBlocking: true,+ });+ if (!raw) continue;+ const value = JSON.parse(raw.toString('utf8')) as { scope?: unknown };+ if (typeof value.scope !== 'string' || path.basename(scopeDir(value.scope)) !== dir)+ continue;+ const record = await read(value.scope, name.slice(0, -5));+ if (record) records.push(record);+ }+ }+ assertCurrent();+ return records;+ }+ async function readCleanup(scope: string): Promise<GeneratedImageCleanup | null> {+ assertCurrent();+ const file = path.join(scopeDir(scope), 'cleanup.json');+ try {+ await fs.lstat(file);+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;+ throw error;+ }+ const raw = await readBoundedFileNoFollow(file, 128 * 1024, { nonBlocking: true });+ assertCurrent();+ if (!raw) throw new Error('INVALID_IMAGE_DELIVERY');+ const value = JSON.parse(raw.toString('utf8')) as GeneratedImageCleanup;+ if (+ value.version !== 1 ||+ value.scope !== scope ||+ typeof value.sessionId !== 'string' ||+ typeof value.agentDeviceId !== 'string' ||+ typeof value.deleted !== 'boolean' ||+ (value.clearedAt !== null && (!Number.isSafeInteger(value.clearedAt) || value.clearedAt < 0))+ )+ throw new Error('INVALID_IMAGE_DELIVERY');+ return value;+ }++ const updateCleanup = (+ scope: string,+ change: (value: GeneratedImageCleanup | null) => GeneratedImageCleanup,+ ) => updateFile(scope, 'cleanup.json', () => readCleanup(scope), change);++ async function listCleanups(): Promise<GeneratedImageCleanup[]> {+ assertCurrent();+ const dirs = await fs.readdir(root).catch((error: NodeJS.ErrnoException) => {+ if (error.code === 'ENOENT') return [];+ throw error;+ });+ const result: GeneratedImageCleanup[] = [];+ for (const dir of dirs) {+ if (!/^[a-f0-9]{64}$/.test(dir)) continue;+ const info = await fs.lstat(path.join(root, dir));+ if (!info.isDirectory() || info.isSymbolicLink()) continue;+ const file = path.join(root, dir, 'cleanup.json');+ const raw = await readBoundedFileNoFollow(file, 128 * 1024, { nonBlocking: true }).catch(+ (error: NodeJS.ErrnoException) => {+ if (error.code === 'ENOENT') return null;+ throw error;+ },+ );+ if (!raw) continue;+ const value = JSON.parse(raw.toString('utf8')) as { scope?: unknown };+ if (typeof value.scope !== 'string' || path.basename(scopeDir(value.scope)) !== dir) continue;+ const record = await readCleanup(value.scope);+ if (record) result.push(record);+ }+ assertCurrent();+ return result;+ }+ return { read, update, list, listAll, readCleanup, updateCleanup, listCleanups };+}++export function initialGeneratedImageRecord(+ scope: string,+ image: GeneratedImageEventData,+): GeneratedImageRecord {+ // Explicit allowlist: no Base64, arbitrary event fields, or in-memory callbacks in the journal.+ return {+ version: 1,+ id: generatedImageId(image),+ scope,+ createdAt: Date.now(),+ state: 'pending',+ image: {+ kind: 'generation',+ blockId: image.blockId,+ ...(image.threadId ? { threadId: image.threadId } : {}),+ ...(image.turnId ? { turnId: image.turnId } : {}),+ ...(image.path ? { path: image.path } : {}),+ ...(image.pathOrigin ? { pathOrigin: image.pathOrigin } : {}),+ ...(image.revisedPrompt ? { revisedPrompt: image.revisedPrompt } : {}),+ ...(image.status ? { status: image.status } : {}),+ ...(image.deliveryEpoch !== undefined ? { deliveryEpoch: image.deliveryEpoch } : {}),+ },+ ...(image.url && !image.url.startsWith('data:') ? { sourceUrl: image.url } : {}),+ };+}diff --git a/apps/desktop/src/main/cindy-media/generatedImageRecovery.ts b/apps/desktop/src/main/cindy-media/generatedImageRecovery.tsnew file mode 100644index 0000000000..2d11414d25--- /dev/null+++ b/apps/desktop/src/main/cindy-media/generatedImageRecovery.ts@@ -0,0 +1,18 @@+/** Read-side recovery hook; registered by the Maker Host, without a localDb → Maker cycle. */+let reconcile: (() => Promise<void>) | undefined;+let recover: ((sessionId: string) => Promise<void>) | undefined;+export function setGeneratedImageRecovery(+ callback: (sessionId: string) => Promise<void>,+ cleanup?: () => Promise<void>,+): void {+ recover = callback;+ reconcile = cleanup;+}+export async function recoverGeneratedImagesForHistory(sessionId: string): Promise<void> {+ await recover?.(sessionId);+}++/** Resume owner-scoped cleanup receipts after restart; never starts generation. */+export async function reconcileGeneratedImageRecovery(): Promise<void> {+ await reconcile?.();+}diff --git a/apps/desktop/src/main/cindy-media/generatedImageStorage.ts b/apps/desktop/src/main/cindy-media/generatedImageStorage.tsnew file mode 100644index 0000000000..67d90075a8--- /dev/null+++ b/apps/desktop/src/main/cindy-media/generatedImageStorage.ts@@ -0,0 +1,416 @@+import { createHash } from 'node:crypto';+import type { AgentEvent, GeneratedImageEventData } from '@cindy/maker-core';+import {+ REMOTE_AGENT_CHANNEL,+ REMOTE_AGENT_READ_MAX_BYTES,+ type RemoteAgentRequest,+} from '@cindy/device-link';+import {+ getActiveAppSession,+ isAppSessionBoundaryPending,+ ownerScopedUserDataPath,+} from '../appSessionState';+import { getCurrentDbClientSnapshot } from '../localDb/client/current';+import { captureMediaRefCompensationScope } from './refCompensationJournal';+import {+ createGeneratedImageJournal,+ generatedImageId,+ initialGeneratedImageRecord,+ type GeneratedImageRecord,+ type GeneratedImageUpstream,+} from './generatedImageJournal';+import { generatedImageBytes, readGeneratedImageFile } from './generatedMedia';+import { blobUrl, extForMime, parseBlobUrl, resolveSafe } from './blobStore';+import { ingestMedia } from './ingest';+import {+ hasRef,+ removeRefs,+ removeSessionAttachmentRefIfUnreferencedByLiveMessage,+ withSessionMediaRefLock,+} from './ledger';++export function captureGeneratedImageStorage() {+ const owner = getActiveAppSession();+ const snapshot = getCurrentDbClientSnapshot();+ if (+ !owner.dataOwnerId ||+ !snapshot ||+ snapshot.userId !== owner.dataOwnerId ||+ isAppSessionBoundaryPending()+ )+ throw new Error('HOST_NOT_READY');+ const assertCurrent = () => {+ const active = getActiveAppSession();+ if (+ isAppSessionBoundaryPending() ||+ active.dataOwnerId !== owner.dataOwnerId ||+ active.generation !== owner.generation ||+ getCurrentDbClientSnapshot() !== snapshot+ )+ throw new Error('IMAGE_DELIVERY_SCOPE_CHANGED');+ };+ const journal = createGeneratedImageJournal(+ ownerScopedUserDataPath('cindy-media', 'generated-images-v1'),+ assertCurrent,+ );+ const db = snapshot.client.drizzle;+ const compensation = captureMediaRefCompensationScope();+ const reference = (scope: string, id: string) => ({+ refKind: 'integration-cache' as const,+ refId: `native-image:${createHash('sha256').update(scope).digest('hex')}:${id}`,+ });++ async function read(record: GeneratedImageRecord) {+ assertCurrent();+ if (record.blobUrl) {+ const parsed = parseBlobUrl(record.blobUrl);+ if (!parsed) throw new Error('INVALID_IMAGE_DELIVERY');+ try {+ const bytes = await readGeneratedImageFile(resolveSafe(record.blobUrl).absPath);+ if (createHash('sha256').update(bytes.buffer).digest('hex') !== parsed.hash)+ throw new Error('INVALID_IMAGE');+ assertCurrent();+ return bytes;+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;+ // A planned address may precede the atomic blob write. Only retry an owned source.+ if (!record.image.path || record.image.pathOrigin || record.remoteHostId) throw error;+ }+ }+ if (record.image.path && !record.image.pathOrigin && !record.remoteHostId) {+ const bytes = await readGeneratedImageFile(record.image.path);+ if (+ record.blobUrl &&+ createHash('sha256').update(bytes.buffer).digest('hex') !==+ parseBlobUrl(record.blobUrl)?.hash+ )+ throw new Error('IMAGE_DELIVERY_CONFLICT');+ assertCurrent();+ return bytes;+ }+ throw new Error(+ record.image.pathOrigin || record.remoteHostId+ ? 'REMOTE_SOURCE_REQUIRED'+ : 'MEDIA_SOURCE_MISSING',+ );+ }++ async function stage(+ scope: string,+ image: GeneratedImageEventData,+ readSource?: () => Promise<{ buffer: Buffer; mimeType: string }>,+ ) {+ assertCurrent();+ const id = generatedImageId(image);+ let record = await journal.update(+ scope,+ id,+ (previous) => previous ?? initialGeneratedImageRecord(scope, image),+ );+ if (record.state === 'released') {+ await removeRefs(reference(scope, id), db);+ throw new Error('IMAGE_DELIVERY_RELEASED');+ }+ try {+ const nativeBytes = generatedImageBytes(image);+ if (!nativeBytes && image.pathOrigin === 'remote-agent' && !record.blobUrl)+ throw new Error('REMOTE_SOURCE_REQUIRED');+ const readSaved = async () => {+ if (!record.blobUrl && readSource) return readSource();+ try {+ return await read(record);+ } catch (error) {+ if (+ !readSource ||+ image.pathOrigin === 'remote-agent' ||+ ((error as NodeJS.ErrnoException).code !== 'ENOENT' &&+ (error as Error).message !== 'REMOTE_SOURCE_REQUIRED')+ )+ throw error;+ return readSource();+ }+ };+ const bytes = nativeBytes ?? (await readSaved());+ assertCurrent();+ const ext = extForMime(bytes.mimeType);+ if (!ext) throw new Error('INVALID_IMAGE');+ const hash = createHash('sha256').update(bytes.buffer).digest('hex');+ const url = blobUrl(hash, ext);+ // Record the deterministic address before ingestion. If ledger writes fail after+ // writeBlob, recovery can still find the same bytes without generating again.+ record = await journal.update(scope, id, (current) => {+ if (!current || current.state === 'released') throw new Error('IMAGE_DELIVERY_RELEASED');+ if (current.blobUrl && current.blobUrl !== url) throw new Error('IMAGE_DELIVERY_CONFLICT');+ return { ...current, blobUrl: url };+ });+ await withSessionMediaRefLock(db, reference(scope, id).refId, async () => {+ assertCurrent();+ if ((await journal.read(scope, id))?.state === 'released')+ throw new Error('IMAGE_DELIVERY_RELEASED');+ const exists = await hasRef({ hash, ...reference(scope, id) }, db);+ await ingestMedia(+ {+ ...bytes,+ isCache: false,+ assertStillValid: assertCurrent,+ refCompensationScope: compensation,+ refs: exists+ ? []+ : [{ ...reference(scope, id), originKind: 'tool', originId: 'codex-imagegen' }],+ },+ db,+ );+ });+ assertCurrent();+ return { record, ...bytes };+ } catch (error) {+ assertCurrent();+ const code = generatedImageErrorCode(error);+ await journal.update(scope, id, (current) => {+ if (!current || current.state === 'released') throw new Error('IMAGE_DELIVERY_RELEASED');+ return { ...current, state: 'failed', errorCode: code };+ });+ throw error;+ }+ }++ async function release(scope: string, id: string) {+ const current = await journal.read(scope, id);+ if (!current) return;+ // A tombstone stops a delayed/replayed event resurrecting deleted task output.+ await journal.update(scope, id, (record) => ({+ ...record!,+ state: 'released',+ image: {+ kind: 'generation',+ blockId: record!.image.blockId,+ threadId: record!.image.threadId,+ turnId: record!.image.turnId,+ },+ // Retain the managed address so restart can finish attachment compensation.+ blobUrl: record!.blobUrl,+ sourceUrl: undefined,+ errorCode: undefined,+ }));+ await withSessionMediaRefLock(db, reference(scope, id).refId, () =>+ removeRefs(reference(scope, id), db),+ );+ assertCurrent();+ const blob = current.blobUrl && parseBlobUrl(current.blobUrl);+ if (scope.startsWith('task:') && blob) {+ await removeSessionAttachmentRefIfUnreferencedByLiveMessage(+ { sessionId: scope.slice(5), hash: blob.hash, visibleOnly: true },+ db,+ );+ assertCurrent();+ }+ }+ const unpin = (scope: string, id: string) => removeRefs(reference(scope, id), db);+ return {+ journal,+ stage,+ read,+ release,+ unpin,+ assertCurrent,+ snapshot,+ db,+ compensation,+ reference,+ };+}++/** Read the task Host's logical clear boundary; source-device clocks are irrelevant. */+export async function readGeneratedImageEpoch(sessionId: string): Promise<number> {+ const storage = captureGeneratedImageStorage();+ const row = await storage.snapshot.client.queryOne<{ cleared_at: number | null }>(+ 'SELECT cleared_at FROM sessions WHERE id = ?',+ [sessionId],+ );+ storage.assertCurrent();+ return row?.cleared_at ?? 0;+}++export function generatedImageErrorCode(error: unknown): string {+ const code = (error as { code?: unknown })?.code;+ if (code === 'ENOENT') return 'MEDIA_SOURCE_MISSING';+ const message = error instanceof Error ? error.message : '';+ return /^(?:INVALID_IMAGE|MEDIA_SOURCE_MISSING|MEDIA_TOO_LARGE|REMOTE_SOURCE_REQUIRED|IMAGE_DELIVERY_CONFLICT)$/.test(+ message,+ )+ ? message+ : 'MEDIA_PUBLISH_FAILED';+}++export type GeneratedImageInvoke = (+ deviceId: string,+ channel: string,+ args: unknown[],+ options?: { preSend?: () => void },+) => Promise<{ ok: boolean; result?: unknown }>;++/** A relay owns its copy before it acknowledges the member's copy. Failed ACKs survive restart. */+export async function releaseGeneratedImageUpstream(+ storage: ReturnType<typeof captureGeneratedImageStorage>,+ record: GeneratedImageRecord,+ invoke: GeneratedImageInvoke,+) {+ if (!record.upstream || record.upstreamReleased) return;+ if (record.state !== 'released') {+ await storage.read(record);+ const parsed = record.blobUrl && parseBlobUrl(record.blobUrl);+ if (+ !parsed ||+ !(await hasRef(+ { hash: parsed.hash, ...storage.reference(record.scope, record.id) },+ storage.db,+ ))+ )+ throw new Error('REMOTE_SOURCE_REQUIRED');+ }+ const { agentDeviceId, sessionId, relay } = record.upstream;+ const call = async (request: object) => {+ storage.assertCurrent();+ const response = await invoke(agentDeviceId, REMOTE_AGENT_CHANNEL, [request], {+ preSend: storage.assertCurrent,+ });+ storage.assertCurrent();+ if (!response.ok) throw new Error('REMOTE_SOURCE_REQUIRED');+ return response.result as Record<string, unknown> | undefined;+ };+ // An older image-recovery Host would silently discard relay and release the wrong namespace.+ if ((await call({ op: 'caps' }))?.imageRecoveryRelay !== true)+ throw new Error('REMOTE_SOURCE_REQUIRED');+ if (+ (await call({ op: 'images', sessionId, relay, action: 'release', imageId: record.id }))?.ok !==+ true+ )+ throw new Error('REMOTE_SOURCE_REQUIRED');+ await storage.journal.update(record.scope, record.id, (current) => ({+ ...current!,+ upstreamReleased: true,+ }));+}++/** Receipted controllers get durable source ownership; legacy controllers get transport bytes only. */+export async function prepareGeneratedImageTransport(+ scope: string,+ event: AgentEvent,+ options: {+ retainForRecovery: boolean;+ upstream?: GeneratedImageUpstream;+ invoke?: GeneratedImageInvoke;+ },+): Promise<AgentEvent> {+ if (event.type !== 'image' || event.source !== 'codex') return event;+ const image = event.data as GeneratedImageEventData;+ if (image?.kind !== 'generation') return event;+ try {+ const storage = captureGeneratedImageStorage();+ const { upstream, invoke } = options;+ let bytes: { buffer: Buffer; mimeType: string };+ if (!options.retainForRecovery) {+ // Legacy controllers cannot ACK durable recovery ownership. Still deliver bytes,+ // but do not create an indefinitely pinned source artifact for them.+ bytes =+ generatedImageBytes(image) ??+ (await storage.read(initialGeneratedImageRecord(scope, image)));+ } else {+ if (upstream)+ await storage.journal.update(scope, generatedImageId(image), (previous) => {+ const current = previous ?? initialGeneratedImageRecord(scope, image);+ if (+ current.upstream &&+ (current.upstream.agentDeviceId !== upstream.agentDeviceId ||+ current.upstream.sessionId !== upstream.sessionId ||+ current.upstream.relay !== upstream.relay)+ )+ throw new Error('IMAGE_DELIVERY_CONFLICT');+ return { ...current, upstream };+ });+ const staged = await storage.stage(scope, image);+ if (invoke)+ await releaseGeneratedImageUpstream(storage, staged.record, invoke).catch(() => undefined);+ bytes = staged;+ }+ const { buffer, mimeType } = bytes;+ storage.assertCurrent();+ // url keeps new-source/old-controller normal delivery compatible. Do not send+ // a path alongside it: old controllers prefer the path and lose the bytes.+ const { data: _data, path: _path, url: _url, ...metadata } = image;+ return {+ ...event,+ data: { ...metadata, url: `data:${mimeType};base64,${buffer.toString('base64')}` },+ };+ } catch (error) {+ // Storage failure must not discard valid native bytes or let an old controller prefer a foreign path.+ const { path: _path, data: _data, url: _url, ...metadata } = image;+ let bytes: ReturnType<typeof generatedImageBytes> = null;+ try {+ bytes = generatedImageBytes(image);+ } catch {+ /* Report invalid/oversized output without copying it into transport. */+ }+ return {+ ...event,+ data: {+ ...metadata,+ pathOrigin: 'remote-agent',+ deliveryError: generatedImageErrorCode(error),+ ...(bytes+ ? { url: `data:${bytes.mimeType};base64,${bytes.buffer.toString('base64')}` }+ : image.url && !image.url.startsWith('data:')+ ? { url: image.url }+ : {}),+ },+ };+ }+}++/** Called only after remote-agent has authenticated the peer and derived its Host task id. */+export async function handleGeneratedImageArtifacts(+ hostSessionId: string,+ request: Extract<RemoteAgentRequest, { op: 'images' }>,+ invoke?: GeneratedImageInvoke,+) {+ const storage = captureGeneratedImageStorage();+ const scope = `remote:${hostSessionId}`;+ if (request.action === 'list') {+ const records = await storage.journal.list(scope);+ const page = records.slice(request.offset, request.offset + 64);+ return {+ images: page+ .filter((record) => record.state !== 'released')+ .map((record) => {+ const { path: _path, pathOrigin: _origin, ...image } = record.image;+ return { id: record.id, createdAt: record.createdAt, image };+ }),+ next: request.offset + page.length < records.length ? request.offset + page.length : null,+ };+ }+ if (request.action === 'release') {+ await storage.release(scope, request.imageId);+ const record = await storage.journal.read(scope, request.imageId);+ if (record && invoke)+ await releaseGeneratedImageUpstream(storage, record, invoke).catch(() => undefined);+ storage.assertCurrent();+ return { ok: true };+ }+ const record = await storage.journal.read(scope, request.imageId);+ if (!record || record.state === 'released') throw new Error('MEDIA_SOURCE_MISSING');+ const { buffer, mimeType } = record.blobUrl+ ? await storage.read(record)+ : await storage.stage(scope, record.image);+ storage.assertCurrent();+ if (request.offset > buffer.length) throw new Error('INVALID_IMAGE_DELIVERY');+ const chunk = buffer.subarray(request.offset, request.offset + REMOTE_AGENT_READ_MAX_BYTES);+ return {+ data: chunk.toString('base64'),+ mimeType,+ hash: createHash('sha256').update(buffer).digest('hex'),+ bytes: buffer.length,+ offset: request.offset,+ next: request.offset + chunk.length,+ done: request.offset + chunk.length === buffer.length,+ };+}diff --git a/apps/desktop/src/main/cindy-media/generatedMedia.ts b/apps/desktop/src/main/cindy-media/generatedMedia.tsindex f553d4ee83..773c45e4cb 100644--- a/apps/desktop/src/main/cindy-media/generatedMedia.ts+++ b/apps/desktop/src/main/cindy-media/generatedMedia.ts@@ -22,6 +22,8 @@ import path from 'node:path';import * as blobStore from './blobStore';import { ingestMedia } from './ingest';import type { LedgerDb } from './ledger';+import { sniffMediaMime } from './sniffMediaMime';+import { readBoundedFileNoFollow } from '../utils/readBoundedFile';/** 与 @cindy/mcps SavedImage 结构对齐(structural typing,不 import 包内类型)。 */export interface SavedBlobImage {@@ -158,8 +160,42 @@ export function createBlobVideoStorage(db?: LedgerDb): {// ── codex 生成图物化(register.ts 的 thin adapter 调用,规则 14:逻辑在此可测)──export interface GeneratedImageSource {+ data?: string;url?: string;path?: string;+ pathOrigin?: 'remote-agent';+}++export const MAX_GENERATED_IMAGE_BYTES = 20 * 1024 * 1024;++/** Decode only in the Host. Declared MIME and filename do not establish the image type. */+export function generatedImageBytes(data: GeneratedImageSource): { mimeType: string; buffer: Buffer } | null {+ const encoded = data.data ?? (data.url?.startsWith('data:')+ ? /^data:image\/[a-zA-Z0-9.+-]+;base64,([\s\S]*)$/.exec(data.url)?.[1]+ : undefined);+ if (encoded === undefined) return null;+ if (encoded.length > Math.ceil(MAX_GENERATED_IMAGE_BYTES / 3) * 4 + 4096)+ throw new Error('MEDIA_TOO_LARGE');+ const compact = encoded.replace(/\s/g, '');+ if (!compact || !/^[A-Za-z0-9+/]*={0,2}$/.test(compact) || compact.length % 4 === 1)+ throw new Error('INVALID_IMAGE');+ const buffer = Buffer.from(compact, 'base64');+ if (buffer.length > MAX_GENERATED_IMAGE_BYTES) throw new Error('MEDIA_TOO_LARGE');+ if (buffer.toString('base64').replace(/=+$/, '') !== compact.replace(/=+$/, ''))+ throw new Error('INVALID_IMAGE');+ const mimeType = sniffMediaMime(buffer);+ if (!mimeType?.startsWith('image/')) throw new Error('INVALID_IMAGE');+ return { buffer, mimeType };+}++/** Read on the machine that owns the native file, before crossing the transport boundary. */+export async function readGeneratedImageFile(sourcePath: string): Promise<{ buffer: Buffer; mimeType: string }> {+ if (/^[\\/]{2}|^[\\/]\?\?[\\/]/.test(sourcePath)) throw new Error('INVALID_IMAGE_SOURCE');+ const buffer = await readBoundedFileNoFollow(sourcePath, MAX_GENERATED_IMAGE_BYTES, { nonBlocking: true });+ if (!buffer?.length) throw new Error('INVALID_IMAGE_SOURCE');+ const mimeType = sniffMediaMime(buffer);+ if (!mimeType?.startsWith('image/')) throw new Error('INVALID_IMAGE');+ return { buffer, mimeType };}/** 从 URL / 路径推导展示文件名;推不出兜底 generated-image.png。 */@@ -177,12 +213,6 @@ export function safeGeneratedImageFilename(raw: string): string {return 'generated-image.png';}-function parseDataImageUrl(url: string): { mimeType: string; buffer: Buffer } | null {- const match = /^data:(image\/[a-zA-Z0-9.+-]+);base64,(.+)$/s.exec(url);- if (!match) return null;- return { mimeType: match[1], buffer: Buffer.from(match[2], 'base64') };-}-/*** codex 生成图 → 总仓物化:托管地址先核验当前 Host 的文件,再复用;* 本地路径 / data: base64 入仓(零引用,合成 tool_result 落库时挂账)。@@ -197,6 +227,10 @@ export async function materializeGeneratedImage(ingestBuffer: (params: { buffer: Uint8Array; mimeType: string }) => Promise<{ url: string; filename: string }>;},): Promise<{ url: string; filename: string } | null> {+ const bytes = generatedImageBytes(data);+ if (bytes) return deps.ingestBuffer(bytes);+ // A remote path is recovery metadata, never permission to read this Host's filesystem.+ if (data.pathOrigin === 'remote-agent') throw new Error('REMOTE_SOURCE_REQUIRED');if (data.url?.startsWith('xdt-image://') || data.url?.startsWith('cindy-media://')) {try {await deps.verifyManagedUrl(data.url);@@ -213,10 +247,5 @@ export async function materializeGeneratedImage(originalName: safeGeneratedImageFilename(data.path),});}- if (data.url?.startsWith('data:')) {- const parsed = parseDataImageUrl(data.url);- if (!parsed) return null;- return deps.ingestBuffer({ buffer: parsed.buffer, mimeType: parsed.mimeType });- }return null;}diff --git a/apps/desktop/src/main/cindy-media/ledger.ts b/apps/desktop/src/main/cindy-media/ledger.tsindex fb9ee15119..fa3486afc3 100644--- a/apps/desktop/src/main/cindy-media/ledger.ts+++ b/apps/desktop/src/main/cindy-media/ledger.ts@@ -404,7 +404,7 @@ export async function removeRefs(* publishing their managed URL; the SQL predicate runs after they settle.*/export async function removeSessionAttachmentRefIfUnreferencedByLiveMessage(- params: { sessionId: string; hash: string },+ params: { sessionId: string; hash: string; visibleOnly?: boolean },db: LedgerDb = defaultDb(),): Promise<number> {if (!/^[0-9a-f]{64}$/.test(params.hash)) return 0;@@ -422,6 +422,10 @@ export async function removeSessionAttachmentRefIfUnreferencedByLiveMessage(WHERE messages.session_id = ${params.sessionId}AND messages.rewind_at IS NULLAND messages.content LIKE ${`%${params.hash}%`}+ ${params.visibleOnly ? sql`AND messages.role != 'message_tombstone'+ AND EXISTS (SELECT 1 FROM sessions+ WHERE sessions.id = messages.session_id AND sessions.status != 'deleted'+ AND (sessions.cleared_at IS NULL OR messages.created_at > sessions.cleared_at))` : sql``})`,),)diff --git a/apps/desktop/src/main/localDb/ipc/__tests__/messagesWriteReadback.test.ts b/apps/desktop/src/main/localDb/ipc/__tests__/messagesWriteReadback.test.tsindex 01e795f4a3..510330327d 100644--- a/apps/desktop/src/main/localDb/ipc/__tests__/messagesWriteReadback.test.ts+++ b/apps/desktop/src/main/localDb/ipc/__tests__/messagesWriteReadback.test.ts@@ -186,6 +186,19 @@ describe('message write paths avoid large-content readback', () => {expect(h.sqlite!.prepare('SELECT count(*) FROM temp.cindy_pending_message_publications').pluck().get()).toBe(0);});+ // #6420: native delivery commits refs under its own task guard; the generic async hook must not race it.+ it('defers automatic attachment refs only for the Host writer that owns their guarded commit', async () => {+ const content = `cindy-media://blobs/${'a'.repeat(64)}.png`;+ await createMessage('s1', { clientId: 'native-image', role: 'tool_result', content }, {+ beforePublish: async () => {}, deferMediaRefs: true,+ });+ expect(h.mediaRefCalls).toEqual([]);+ expect(h.sqlite!.prepare('SELECT content FROM messages WHERE client_id = ?').pluck().get('native-image'))+ .toBe(content);+ await createMessage('s1', { clientId: 'ordinary-image', role: 'tool_result', content });+ expect(h.mediaRefCalls).toEqual([{ sessionId: 's1', role: 'tool_result', content }]);+ });+it.each([false, true])('rolls back a publication revoked during commit before delivery hooks (lostReceipt=%s)', async lostReceipt => {const { tapWindowBroadcast } = await import('../../../device-link/broadcast-tap');const { onMessageCreated } = await import('../../../embedders/chat-history-embedder');diff --git a/apps/desktop/src/main/localDb/ipc/messages.ts b/apps/desktop/src/main/localDb/ipc/messages.tsindex 7cec51a4f8..1a81229dcb 100644--- a/apps/desktop/src/main/localDb/ipc/messages.ts+++ b/apps/desktop/src/main/localDb/ipc/messages.ts@@ -41,6 +41,7 @@ import { throwIpcError, requireString } from '../../utils/ipcValidate';import * as broadcastTap from '../../device-link/broadcast-tap';import { createLogger } from '../../logger';import { collectCindyMediaHashes, commitMessageMediaRefs } from '../../cindy-media/chatAttachments';+import { recoverGeneratedImagesForHistory } from '../../cindy-media/generatedImageRecovery';import { restoreTaskImageRows } from '../../cindy-media/taskImageDelivery';import {removeRefs as removeMediaRefs,@@ -249,6 +250,9 @@ export async function readMessagesList(sessionId: unknown, opts: unknown, skipImconst after = (opts as { after?: string } | undefined)?.after;const imageDbClient = getDbClient();const db = imageDbClient.drizzle;+ if (!before && beforeTs == null && !after && !outline) {+ void recoverGeneratedImagesForHistory(sid).catch(() => undefined);+ }// 外部历史导入(Codex rollout / Claude transcript):device-link 隧道调用// 只在首页请求跑(分页跳过,#318 性能语义;首页判定 = 无任何分页游标),@@ -1610,6 +1614,8 @@ export async function createMessage(/** Host-only admission guard, checked before and after the publication transaction.* Must be repeatable. A failed final check rolls back this exact row before delivery hooks. */beforePublish?: () => Promise<void>;+ /** Host delivery owns its guarded attachment commit and compensation. */+ deferMediaRefs?: boolean;/*** Optional clear-boundary compare-and-set for optimistic user sends. The* insert is accepted only while the session still has this exact@@ -1816,8 +1822,10 @@ export async function createMessage(body.role === 'user' &&opts !== undefined &&Object.prototype.hasOwnProperty.call(opts, 'expectedClearBoundaryMs');- if (shouldAwaitMediaRefs) await commitMediaRefs();- else void commitMediaRefs();+ if (!opts?.deferMediaRefs) {+ if (shouldAwaitMediaRefs) await commitMediaRefs();+ else void commitMediaRefs();+ }// Broadcast 给所有 renderer window — 用于 main 端创建消息 (e.g. feishu /ctr// 接管路径下 persistUserMessage / persistAssistantMessage) 时让 renderer// 的 makerChatStore push 到 in-memory state, 让消息流实时刷新。diff --git a/apps/desktop/src/main/localDb/ipc/registerAll.ts b/apps/desktop/src/main/localDb/ipc/registerAll.tsindex fc2c0e9320..882c716597 100644--- a/apps/desktop/src/main/localDb/ipc/registerAll.ts+++ b/apps/desktop/src/main/localDb/ipc/registerAll.ts@@ -41,6 +41,7 @@ import { createLogger } from '../../logger';import { recordDesktopDevLocalDbStartupResult } from '../../devStartupStatus';import { createOwnerEnsureCoordinator } from './ownerEnsureCoordinator';import { reconcileSessionMediaRefsForDeletedSessions } from '../../cindy-media/sessionCleanup';+import { reconcileGeneratedImageRecovery } from '../../cindy-media/generatedImageRecovery';import { reconcileMediaRefCompensationsForOwner } from '../../cindy-media/refCompensationJournal';import { setSessionRouteLockImplementation } from '../sessionRouteLock';@@ -70,6 +71,7 @@ function startMediaRefCompensationReconcile(}, MEDIA_REF_COMPENSATION_BUSY_RETRY_MS);retry.unref?.();};+ void reconcileGeneratedImageRecovery().catch(() => log.warn('native image cleanup reconciliation deferred'));void run(true).catch((error) => {log.warn('media reference compensation reconcile failed', {userId,diff --git a/apps/desktop/src/main/localDb/ipc/sessions.ts b/apps/desktop/src/main/localDb/ipc/sessions.tsindex b233ab28d5..130c2e283f 100644--- a/apps/desktop/src/main/localDb/ipc/sessions.ts+++ b/apps/desktop/src/main/localDb/ipc/sessions.ts@@ -82,6 +82,7 @@ import type { SessionReference } from '../../../shared/sessionReference.js';import * as broadcastTap from '../../device-link/broadcast-tap.js';import { notifyAgentIslandSessionPatch } from '../agentIslandSessionPatch';import { ensureHiddenSessionRegistryLoaded } from '../hiddenSessionRegistry.js';+import { recoverGeneratedImagesForHistory } from '../../cindy-media/generatedImageRecovery';import { noteSessionClearBoundary } from '../../messagePersistBroadcaster';import {ackSessionTurnEndedDurable,@@ -1191,6 +1192,7 @@ export async function clearSessionContextInDb(sessionId: string, atMs?: number):.where(eq(sessions.id, sessionId)).limit(1);const effectiveClearedAt = updated?.clearedAt ?? ts;+ if (isOwnerScopeCurrent(ownerScope)) void recoverGeneratedImagesForHistory(sessionId).catch(() => undefined);const effectiveUpdatedAt = updated?.updatedAt ?? effectiveClearedAt;// Concurrent clears can make SQLite return a newer monotonic boundary than// this request supplied. Mirror the effective value into the in-memory gate.@@ -2598,6 +2600,7 @@ export async function deleteBotProfileAndDetachSessionsInDb(* 文件在 turn 送出后即无用。所有把 session 置为终态的路径都应调用。*/function removeHookAttachmentDir(sessionId: string, status: unknown): void {+ if (status === 'deleted') void recoverGeneratedImagesForHistory(sessionId).catch(() => undefined);if (status !== 'deleted' && status !== 'archived') return;if (status === 'deleted') {void removeTurnChangeSetsForSession(sessionId).catch((err) => {diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.tsindex 606869207a..628d8ef5d8 100644--- a/apps/desktop/src/main/maker-host/index.ts+++ b/apps/desktop/src/main/maker-host/index.ts@@ -1,3 +1,4 @@+import { readGeneratedImageEpoch } from '../cindy-media/generatedImageStorage';import { readAgentCapabilityCatalog, RUNTIME_MCP_NAMES_KEY, type AgentCapabilityQuery } from './agentCapabilityCatalog.js';import { listCindyManagedSkills, prepareCindyCodexSkills } from './managed-skills.js';import { scanLocalCustomizations } from '../skillhub/customizationScanHost';@@ -2801,6 +2802,7 @@ export function getMaker(): Maker {logger: desktopMakerLogger,// Agent 在同账号另一台电脑上运行、任务与文件留在本机(见 remote-agent/)。startDeviceAgentSession: createDeviceAgentStarter({+ readImageDeliveryEpoch: readGeneratedImageEpoch,remoteInvoke: remoteBackgroundInvoke,rgPath: getRipgrepBinaryPath,// 对方的 Codex 把本机当 exec-server 执行环境:用本机随包的同一个 codex。diff --git a/apps/desktop/src/main/maker-ipc/channels.ts b/apps/desktop/src/main/maker-ipc/channels.tsindex b8ab797889..03d8dc613f 100644--- a/apps/desktop/src/main/maker-ipc/channels.ts+++ b/apps/desktop/src/main/maker-ipc/channels.ts@@ -43,6 +43,7 @@ export const MAKER_INVOKE = {INPUT_STEER: 'maker:input:steer',INPUT_STOP: 'maker:input:stop',INPUT_RESUME: 'maker:input:resume',+ IMAGES_RETRY: 'maker:images:retry',INPUT_RETRY_LAST_ERROR: 'maker:input:retry-last-error',INPUT_CLEAR_ERROR: 'maker:input:clear-error',/** 取消账号限额重置后的自动继续(只撤等待,错误与手动重试保留)。 */diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.tsindex 41ed723175..b51b7d11f5 100644--- a/apps/desktop/src/main/maker-ipc/register.ts+++ b/apps/desktop/src/main/maker-ipc/register.ts@@ -346,7 +346,10 @@ import {} from './atAgentCatalog.js';import * as imageCacheStore from '../imageCacheStore.js';import * as cindyChatAttachments from '../cindy-media/chatAttachments.js';-import { materializeGeneratedImage } from '../cindy-media/generatedMedia.js';+import { materializeSshRemoteMedia } from '../file-browser/ssh-media.js';+import { readGeneratedImageFile, MAX_GENERATED_IMAGE_BYTES } from '../cindy-media/generatedMedia.js';+import { createGeneratedImageDelivery } from '../cindy-media/generatedImageDelivery.js';+import { setGeneratedImageRecovery } from '../cindy-media/generatedImageRecovery.js';import {getCurrentDbClientSnapshot,getDbClient,@@ -2922,15 +2925,6 @@ function summarizeIpcUserMessage(message: IpcUserMessage): Record<string, unknow};}-interface CodexImageEventData {- kind?: 'view' | 'generation';- blockId?: string;- path?: string;- url?: string;- revisedPrompt?: string;- status?: string;-}-/*** 待解决的 interaction 请求(permission/ask/plan 三合一)—— 用 promise 跨 IPC 边界。* key: requestId, value: resolver + owning session. ask/plan intentionally do@@ -19797,6 +19791,16 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)return inputCoordinator.resume(sid);});+ ipcMain.handle(MAKER_INVOKE.IMAGES_RETRY, async (event, sessionId: unknown, imageId: unknown) => {+ const remote = isDeviceLinkInvoke();+ if (!remote) assertTrustedAppRendererEvent(event);+ const sid = requireSessionId(sessionId);+ if (typeof imageId !== 'string' || !/^[a-f0-9]{64}$/.test(imageId)) throwIpcError('INVALID_PARAMS', 'invalid image id');+ await assertRemoteInputControlBoundary(sid, remote, undefined);+ try { await generatedImageDelivery.recover(sid, imageId as string); }+ catch { throwIpcError('INTERNAL', 'Image delivery is unavailable'); }+ });+ipcMain.handle(MAKER_INVOKE.INPUT_RETRY_LAST_ERROR,async (_e, sessionId: unknown, opts?: unknown) => {@@ -23370,66 +23374,36 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)log.info('maker:* IPC handlers registered');}-async function broadcastCodexImageAsToolResult(- sessionId: string,- event: AgentEvent,-): Promise<void> {- const data = event.data as CodexImageEventData | null;- if (data?.kind !== 'generation') return;-- try {- const cached = await materializeCodexImage(sessionId, data);- if (!cached) {- log.warn('codex image event missing materializable image', {- sessionId,- blockId: data.blockId,- hasPath: !!data.path,- hasUrl: !!data.url,- });- return;- }-- const toolUseId = data.blockId || `codex-image-${Date.now()}`;- const toolInput = {- ...(data.revisedPrompt ? { prompt: data.revisedPrompt } : {}),- ...(data.status ? { status: data.status } : {}),- };- const fullText = JSON.stringify({- ok: true,- kind: 'generation',- text: 'image generated',- xdt_image_url: cached.url,- filename: cached.filename,- ...(data.revisedPrompt ? { revised_prompt: data.revisedPrompt } : {}),- ...(data.status ? { status: data.status } : {}),- ...(data.path ? { original_path: data.path } : {}),- });+const generatedImageDelivery = createGeneratedImageDelivery({+ invoke: remoteBackgroundInvoke,+ publish: (sessionId, event, persistId, resolvedContent) => {+ broadcastToAllWindows(MAKER_PUSH.EVENT, { sessionId, event, persistId, resolvedContent }, captureDataOwnerBroadcastScope());+ },+ readSource: async (_sessionId, image, session) => {+ if (image.pathOrigin === 'remote-agent') throw new Error('REMOTE_SOURCE_REQUIRED');+ if (session.remoteHostId) {+ if (!image.path || !session.workingDir) throw new Error('REMOTE_SOURCE_REQUIRED');+ const result = await materializeSshRemoteMedia({ remoteHostId: session.remoteHostId, workdir: session.workingDir },+ `xdt-file://?path=${encodeURIComponent(image.path)}`, undefined, { maxBytes: MAX_GENERATED_IMAGE_BYTES });+ if (!result.ok) throw new Error('REMOTE_SOURCE_REQUIRED');+ return readGeneratedImageFile(result.cachePath);+ }+ const managed = image.url?.startsWith('cindy-media://') ? resolveCindyMediaUrl(image.url)+ : image.url?.startsWith('xdt-image://') ? imageCacheStore.resolveSafe(image.url) : undefined;+ if (managed) {+ try { return await readGeneratedImageFile(managed.absPath); }+ catch (error) { if (!image.path) throw error; }+ }+ const source = image.path;+ if (!source) throw new Error('MEDIA_SOURCE_MISSING');+ return readGeneratedImageFile(source);+ },+});+setGeneratedImageRecovery((sessionId) => generatedImageDelivery.recover(sessionId), () => generatedImageDelivery.reconcile());- broadcastSyntheticToolEvent(sessionId, {- type: 'tool_use',- source: 'codex',- agentMeta: event.agentMeta,- data: { toolUseId, toolName: 'imagegen', input: toolInput },- } satisfies AgentEvent);- broadcastSyntheticToolEvent(sessionId, {- type: 'tool_result_full',- source: 'codex',- agentMeta: event.agentMeta,- data: { toolUseId, fullText, isError: false },- } satisfies AgentEvent);- broadcastSyntheticToolEvent(sessionId, {- type: 'tool_result',- source: 'codex',- agentMeta: event.agentMeta,- data: { summary: 'image generated', toolUseIds: [toolUseId] },- } satisfies AgentEvent);- } catch (err) {- log.warn('failed to materialize codex image event', {- sessionId,- blockId: data?.blockId,- error: err instanceof Error ? err.message : String(err),- });- }+async function broadcastCodexImageAsToolResult(sessionId: string, event: AgentEvent): Promise<void> {+ try { await generatedImageDelivery.deliver(sessionId, event); }+ catch { log.warn('Codex generated image delivery could not be persisted', { sessionId }); }}function broadcastSyntheticToolEvent(@@ -23449,32 +23423,6 @@ function broadcastSyntheticToolEvent(});}-async function materializeCodexImage(- sessionId: string,- data: CodexImageEventData,-): Promise<{ url: string; filename: string } | null> {- // 规则 25:生成图入 cindy-media 总仓(零引用;合成 tool_result- // 消息落库时由 createMessage 的挂账钩子补 session-attachment 引用)。逻辑- // 本体在 cindy-media/generatedMedia.ts(规则 14 可测),这里只做 thin adapter。- try {- return await materializeGeneratedImage(data, {- verifyManagedUrl: async (url) => {- const resolved = url.startsWith('cindy-media://') ? resolveCindyMediaUrl(url) : imageCacheStore.resolveSafe(url);- const source = await fsp.stat(resolved.absPath);- if (!source.isFile()) throw new Error('[MEDIA_SOURCE_MISSING] Generated image is not a file');- },- ingestFromPath: cindyChatAttachments.ingestChatImageFromPath,- ingestBuffer: cindyChatAttachments.ingestChatImageBuffer,- });- } catch (err) {- // 白名单外 mime / 读盘失败:丢图不炸事件流(与旧行为的失败面一致)。- log.warn('materializeCodexImage: ingest failed, dropping image', {- sessionId,- error: err instanceof Error ? err.message : String(err),- });- return null;- }-}/*** 用户在 session 跑到一半把工作目录删了 / 重命名了,之后继续 send 会让 SDK 在diff --git a/apps/desktop/src/main/remote-agent/__tests__/eventProjection.test.ts b/apps/desktop/src/main/remote-agent/__tests__/eventProjection.test.tsindex e6c09e5a70..52f8b5a363 100644--- a/apps/desktop/src/main/remote-agent/__tests__/eventProjection.test.ts+++ b/apps/desktop/src/main/remote-agent/__tests__/eventProjection.test.ts@@ -410,3 +410,13 @@ describe('remote file references on the task computer', () => {expect(streamed).not.toContain('/Users/ag');});});++// #6412: source-local image paths and Base64 are not workspace path projections.+it('preserves native image bytes and marks source-local paths across the controller boundary', async () => {+ const { controller } = setup('/linux/agent');+ const input: AgentEvent = { type: 'image', source: 'codex', data: {+ kind: 'generation', blockId: 'native', path: '/linux/agent/image.png', data: 'abc/linux/agent/xyz',+ } };+ const [output] = await eventsFrom(controller, [input]);+ expect(output.data).toEqual({ ...(input.data as object), pathOrigin: 'remote-agent' });+});diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.tsindex bfc432e979..26334d2623 100644--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts@@ -53,6 +53,8 @@ function fakeAgentHost(name: string, started: Started[], options: {guestRelayCapable?: boolean;purge?: (hostSessionIds: readonly string[], nativeIds: readonly string[]) => Promise<void>;groupRelay?: RemoteAgentGroupRelayDeps;+ prepareImageEvent?: Parameters<typeof createRemoteAgentHost>[0]['prepareImageEvent'];+ imageArtifacts?: Parameters<typeof createRemoteAgentHost>[0]['imageArtifacts'];/** 这台的 Agent 启动失败(启动前受邀者目录已经建好)。 */failStart?: boolean;/** 这台的 Agent 一启动就结束。 */@@ -62,6 +64,8 @@ function fakeAgentHost(name: string, started: Started[], options: {resolveProvider?: NonNullable<Parameters<typeof createRemoteAgentHost>[0]['providerAccess']>['resolve'];}) {return createRemoteAgentHost({+ prepareImageEvent: options.prepareImageEvent,+ imageArtifacts: options.imageArtifacts,isAgentAvailable: () => true,startHosted: async (input) => {if (options.failStart) throw new Error('the agent could not start');@@ -196,7 +200,7 @@ function setup(options: {/** mini 这台的 Agent 表现。 */mini?: { failStart?: boolean; endImmediately?: boolean };/** 组所在电脑本机的 Agent 表现(组选中本机这一台时)。 */- owner?: { failStart?: boolean };+ owner?: { failStart?: boolean; prepareImageEvent?: Parameters<typeof createRemoteAgentHost>[0]['prepareImageEvent'] };/** 截住组所在电脑发给组内电脑的请求(模拟回包丢失、应答慢)。 */intercept?: (agentDeviceId: string, request: Record<string, unknown>, forward: () => Promise<unknown>) => Promise<unknown>;} = {}) {@@ -316,6 +320,36 @@ describe('provider group relay for shared users', () => {await client.close('close', 'navigation');});+ // #6420: the relay must retain the member's task/relay receipt, not just restage its bytes.+ it('carries the upstream artifact identity and clear generation through the provider-group relay', async () => {+ let finishPreparation!: () => void;+ const waiting = new Promise<void>((resolve) => { finishPreparation = resolve; });+ const prepareImageEvent = vi.fn(async (_sessionId: string, event: AgentEvent) => { await waiting; return event; });+ const env = setup({ owner: { prepareImageEvent } });+ const { client, stream, isClosed } = await openAsGuest(env, GUEST_A, openPayload(SESSION, { imageDeliveryEpoch: 123, acceptsImageDeliveryReceipts: true }));+ try {+ env.memberStarted.mini[0].emit({ type: 'image', source: 'codex', data: { kind: 'generation', blockId: 'image', deliveryEpoch: 999, url: 'data:image/png;base64,bytes' } } as AgentEvent);+ env.memberStarted.mini[0].end();+ await vi.waitFor(() => expect(prepareImageEvent).toHaveBeenCalledTimes(1));+ expect(isClosed()).toBe(false);+ finishPreparation();+ const call = prepareImageEvent.mock.calls[0] as unknown as [string, AgentEvent, { agentDeviceId: string; sessionId: string; relay: string }, boolean];+ expect(call[3]).toBe(true);+ expect(call[0]).toBe(hostSessionIdFor(GUEST_A, SESSION));+ expect(call[1].data).toMatchObject({ deliveryEpoch: 123 });+ expect(call[2]).toMatchObject({ agentDeviceId: 'mini', relay: relayKeyFor(GUEST_A) });+ const imageArtifacts = vi.fn(async (_sessionId: string) => ({ ok: true }));+ const member = fakeAgentHost('release-member', [], { trust: () => 'owner', imageArtifacts });+ try {+ await member.handle(OWNER_DEVICE, { op: 'images', ...call[2], action: 'release', imageId: 'a'.repeat(64) });+ expect(imageArtifacts.mock.calls[0]?.[0]).toBe(env.memberStarted.mini[0].input.hostSessionId);+ await member.handle('other-owner', { op: 'images', ...call[2], action: 'release', imageId: 'a'.repeat(64) });+ expect(imageArtifacts.mock.calls[1]?.[0]).not.toBe(imageArtifacts.mock.calls[0]?.[0]);+ } finally { member.dispose(); }+ await vi.waitFor(() => expect(stream.some((item) => item.t === 'event' && item.event.type === 'image')).toBe(true));+ } finally { finishPreparation(); await client.close('close', 'navigation'); }+ });+it('keeps two shared users apart on the computer even with the same task id', async () => {const env = setup({ plans: [{ kind: 'member', ...MEMBER_MINI }, { kind: 'member', ...MEMBER_MINI }] });const a = await openAsGuest(env, GUEST_A, openPayload(SESSION));diff --git a/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts b/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.tsindex fc939e96d3..4bd9c060cd 100644--- a/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts+++ b/apps/desktop/src/main/remote-agent/__tests__/hostLifecycle.test.ts@@ -181,3 +181,57 @@ describe('duplicate op payloads', () => {host.dispose();});});++// #6412: asynchronous source reads used to lose the final image when the native stream ended.+it.each([false, true])('drains image preparation and forwards the controller receipt capability (%s)', async (receipts) => {+ let release!: () => void;+ const waiting = new Promise<void>((resolve) => { release = resolve; });+ const entered = whenStarted();+ const host = createRemoteAgentHost({+ isAgentAvailable: () => true, isControllerAuthorized: () => true,+ captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot,+ startHosted: async (input) => ({ ...idleHandle(input), events: () => ({+ async *[Symbol.asyncIterator]() {+ yield { type: 'image', source: 'codex', data: { kind: 'generation', blockId: 'native', path: '/linux/image.png' } } as AgentEvent;+ yield { type: 'done', source: 'codex', data: {} } as AgentEvent;+ },+ }) }),+ prepareImageEvent: async (_id, event, _upstream, retainForRecovery) => { expect(retainForRecovery).toBe(receipts); expect(event.data).toMatchObject({ deliveryEpoch: 321 }); entered.resolve(); await waiting; return { ...event, data: { kind: 'generation', blockId: 'native', url: 'data:image/png;base64,bytes' } }; },+ });+ try {+ await host.handle('controller', { op: 'open', runId: RUN_1, agentKind: 'codex', payload: { json: { ...openPayload('task-1'), imageDeliveryEpoch: 321, ...(receipts ? { acceptsImageDeliveryReceipts: true } : {}) } } });+ await entered.promise;+ await settle();+ let closeFinished = false;+ const closing = host.handle('controller', { op: 'close', runId: RUN_1, mode: 'close', reason: 'navigation' }).then(() => { closeFinished = true; });+ await settle();+ expect(closeFinished).toBe(false);+ release();+ await closing;+ await settle();+ const result = await host.handle('controller', { op: 'poll', runs: [{ runId: RUN_1, cursor: 0 }], waitMs: 0 }) as { runs: Array<{ data?: string; done?: boolean }> };+ const rows = Buffer.from(result.runs[0].data!, 'base64').toString().trim().split('\n').map((line) => JSON.parse(line));+ expect(rows.filter((row) => row.t === 'event').map((row) => row.event.type)).toEqual(['image', 'done']);+ expect(rows.find((row) => row.t === 'event').event.data).not.toHaveProperty('path');+ expect(rows.at(-1)).toMatchObject({ t: 'closed' });+ expect(result.runs[0].done).toBe(true);+ } finally { release(); host.dispose(); }+});++it.each(['authorization', 'owner'])('scopes image recovery to the caller and rejects %s changes during a read', async (boundary) => {+ let allowed = true;+ let ownerCurrent = true;+ const imageArtifacts = vi.fn(async () => { if (boundary === 'owner') ownerCurrent = false; else allowed = false; return { images: [] }; });+ const host = createRemoteAgentHost({+ isAgentAvailable: () => true, startHosted: async (input) => idleHandle(input),+ isControllerAuthorized: () => allowed, captureOwner: () => 'owner', isOwnerCurrent: () => ownerCurrent,+ runsRoot, imageArtifacts,+ });+ try {+ await expect(host.handle('caller', { op: 'images', sessionId: RUN_1, action: 'list' })).rejects.toThrow('REMOTE_AGENT_UNAVAILABLE');+ expect(imageArtifacts.mock.calls[0]).toEqual([hostSessionIdFor('caller', RUN_1), { op: 'images', sessionId: RUN_1, action: 'list', offset: 0 }]);+ allowed = false;+ await expect(host.handle('other', { op: 'images', sessionId: RUN_1, action: 'list' })).rejects.toThrow('REMOTE_AGENT_UNAVAILABLE');+ expect(imageArtifacts).toHaveBeenCalledTimes(1);+ } finally { host.dispose(); }+});diff --git a/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts b/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.tsindex 9074c235fb..dbd7db15e4 100644--- a/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts+++ b/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts@@ -568,6 +568,27 @@ describe('remote agent round trip', () => {host.dispose();});+ // #6420: a new remote run carries the task Host clear epoch, independent of source clocks.+ it('sends the persisted image clear generation when opening a remote run', async () => {+ const host = createHost();+ const base = makeDeps(host);+ const opened: Array<Record<string, unknown>> = [];+ const invoke: StartRemoteAgentDeps['invoke'] = async (args) => {+ const request = args[0] as { op?: string; payload?: { json?: Record<string, unknown> } };+ if (request.op === 'open' && request.payload?.json) opened.push(request.payload.json);+ return base.invoke(args);+ };+ try {+ for (const epoch of [0, 456]) {+ const handle = await startRemoteAgentSession('codex', { sessionId: 'image-task', workingDir: project, model: 'm' }, {+ ...base, invoke, readImageDeliveryEpoch: async (sessionId) => { expect(sessionId).toBe('image-task'); return epoch; },+ });+ expect(opened.at(-1)).toMatchObject({ imageDeliveryEpoch: epoch, acceptsImageDeliveryReceipts: true });+ await handle.close({ reason: 'navigation' });+ }+ } finally { host.dispose(); }+ });+it('declares provider group switch support and brings back the token after a handoff', async () => {const host = createHost();const base = makeDeps(host);diff --git a/apps/desktop/src/main/remote-agent/controller/eventProjection.ts b/apps/desktop/src/main/remote-agent/controller/eventProjection.tsindex 29adf23413..a90cd0ab4e 100644--- a/apps/desktop/src/main/remote-agent/controller/eventProjection.ts+++ b/apps/desktop/src/main/remote-agent/controller/eventProjection.ts@@ -155,6 +155,10 @@ export class RemoteEventProjection {}project(event: AgentEvent): AgentEvent[] {+ // Native image payloads are bytes and source-side recovery metadata, not+ // virtual-workspace text. In particular JPEG Base64 can start with '/'.+ if (event.type === 'image' && event.source === 'codex'+ && (event.data as { kind?: unknown } | null)?.kind === 'generation') return [event];const data = event.data as { text?: unknown; isFinal?: boolean; isFullText?: boolean; isRunning?: boolean; agentMessageId?: string } | null;const stream = this.streamKey(event);let pending = this.pending.get(stream);diff --git a/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts b/apps/desktop/src/main/remote-agent/controller/proxyHandle.tsindex 4d424ef9f9..2727727b88 100644--- a/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts+++ b/apps/desktop/src/main/remote-agent/controller/proxyHandle.ts@@ -421,7 +421,11 @@ export function createRemoteAgentHandle(deps: RemoteHandleDeps): RemoteAgentHandhandle,onEvent(event) {if (!event || typeof event !== 'object' || typeof (event as AgentEvent).type !== 'string') return;- const typed = event as AgentEvent;+ let typed = event as AgentEvent;+ if (typed.type === 'image' && typed.source === 'codex'+ && (typed.data as { kind?: unknown } | null)?.kind === 'generation') {+ typed = { ...typed, data: { ...(typed.data as object), pathOrigin: 'remote-agent' } };+ }for (const projected of projection.project(deps.mapEvent ? deps.mapEvent(typed) : typed)) queue.push(projected);},onState(next) {diff --git a/apps/desktop/src/main/remote-agent/controller/service.ts b/apps/desktop/src/main/remote-agent/controller/service.tsindex 57c5381e80..e8c8619439 100644--- a/apps/desktop/src/main/remote-agent/controller/service.ts+++ b/apps/desktop/src/main/remote-agent/controller/service.ts@@ -40,6 +40,7 @@ import { RemoteAgentPoller, remoteAgentInvoker } from './runClient';import { startRemoteAgentSession, type PreparedRemoteMcp } from './startRemote';export interface DeviceAgentServiceDeps {+ readImageDeliveryEpoch?(sessionId: string): Promise<number>;remoteInvoke(deviceId: string, channel: string, args: unknown[]): Promise<{ ok: boolean; result?: unknown; error?: { code?: string; message?: string } }>;rgPath(): string;/** 本机 codex 程序(给对方的 Codex 提供 exec-server 执行环境)。 */@@ -179,6 +180,7 @@ export function createDeviceAgentStarter(deps: DeviceAgentServiceDeps) {const webFetch = deps.webFetch && shared ? deps.webFetch : undefined;const collect = { skipCredentials: shared };return startRemoteAgentSession(input.agentKind, opts, {+ readImageDeliveryEpoch: deps.readImageDeliveryEpoch,invoke: poller.invoke,poller,rgPath: deps.rgPath(),diff --git a/apps/desktop/src/main/remote-agent/controller/startRemote.ts b/apps/desktop/src/main/remote-agent/controller/startRemote.tsindex 7f95d51aaa..8fb22e0463 100644--- a/apps/desktop/src/main/remote-agent/controller/startRemote.ts+++ b/apps/desktop/src/main/remote-agent/controller/startRemote.ts@@ -52,6 +52,7 @@ export interface PreparedRemoteMcp {}export interface StartRemoteAgentDeps {+ readImageDeliveryEpoch?(sessionId: string): Promise<number>;invoke: RemoteAgentInvoke;/** 这台电脑的共享拉取器(同一台电脑上的任务共用一个 poll);缺省时本任务单独一个。 */poller?: RemoteAgentPoller;@@ -224,6 +225,7 @@ export async function startRemoteAgentSession(deps: StartRemoteAgentDeps,): Promise<AgentSessionHandle> {if (!opts.sessionId) throw new Error('remote agent sessions require a session id');+ const imageDeliveryEpoch = await deps.readImageDeliveryEpoch?.(opts.sessionId);// 附加目录(只读引用)与可写目录分开跟踪,运行中任一侧变化都重算执行器根目录:// 否则新授予的目录过不了本机 shell/root 判定,撤掉的还被本机上限当可信根。let extraDirs = [...new Set(opts.extraDirs ?? [])];@@ -365,6 +367,8 @@ export async function startRemoteAgentSession(: [];const payload: RemoteAgentOpenPayload = {sessionId: opts.sessionId,+ acceptsImageDeliveryReceipts: true,+ ...(imageDeliveryEpoch !== undefined ? { imageDeliveryEpoch } : {}),virtualWorkspace: true,options: encodeStartOptions(opts),workspace: {diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.tsindex 32abc97141..13cfb8a9af 100644--- a/apps/desktop/src/main/remote-agent/host/runHost.ts+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts@@ -1,3 +1,4 @@+import type { GeneratedImageUpstream } from '../../cindy-media/generatedImageJournal';import { parseProviderSharePeer } from '@cindy/device-link';import { DEFAULT_REMOTE_AGENT_LIMITS, type RemoteAgentLimits, type RemoteAgentLimitUsage } from '../../../shared/remoteAgentLimits.js';/**@@ -40,6 +41,7 @@ import {type RemoteAgentPayload,type RemoteAgentPollResult,type RemoteAgentReply,+ type RemoteAgentRequest,type RemoteAgentReshareBatch,type RemoteAgentReshareEntry,type RemoteAgentReshareResult,@@ -161,6 +163,9 @@ export interface OwnerProviderRouteBinding {}export interface RemoteAgentHostDeps {+ /** Prepare native bytes; retain recovery ownership only for receipted controllers. */+ prepareImageEvent?(hostSessionId: string, event: AgentEvent, upstream: GeneratedImageUpstream | undefined, retainForRecovery: boolean): Promise<AgentEvent>;+ imageArtifacts?(hostSessionId: string, request: Extract<RemoteAgentRequest, { op: 'images' }>): Promise<unknown>;readLimits?(): RemoteAgentLimits;isAgentAvailable(kind: RemoteAgentKind): boolean;startHosted(input: HostedStartInput): Promise<AgentSessionHandle>;@@ -340,6 +345,8 @@ interface Run {trust: RemoteAgentControllerTrust;/** 本机侧任务 id:影子目录按它存放,同一任务多次打开共用。 */hostSessionId?: string;+ imageDeliveryEpoch?: number;+ acceptsImageDeliveryReceipts?: boolean;owner: unknown;kind: RemoteAgentKind;log: EventLog;@@ -790,7 +797,46 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {stopSweepIfIdle();}- function append(run: Run, item: unknown): void {+ const imagePreparation = new WeakMap<Run, Promise<void>>();++ function append(run: Run, item: unknown, upstream?: GeneratedImageUpstream): void {+ let stream = item as { t?: string; event?: AgentEvent };+ if (stream.t === 'event' && stream.event?.type === 'image' && stream.event.source === 'codex') {+ const data = stream.event.data as Record<string, unknown> | null;+ if (data?.kind === 'generation') {+ stream = { ...stream, event: { ...stream.event, data: { ...data, deliveryEpoch: run.imageDeliveryEpoch } } };+ item = stream;+ }+ }+ const prepare = stream.t === 'event' && stream.event?.type === 'image'+ && stream.event.source === 'codex' && deps.prepareImageEvent && run.hostSessionId;+ const previous = imagePreparation.get(run);+ if (prepare || previous) {+ const pending = (previous ?? Promise.resolve()).then(async () => {+ let next = item;+ if (prepare) {+ try {+ next = { ...stream, event: await deps.prepareImageEvent!(run.hostSessionId!, stream.event!, upstream, run.acceptsImageDeliveryReceipts === true) };+ } catch {+ // Even a failed adapter must not advertise the source path as controller-local.+ const data = stream.event!.data as Record<string, unknown> | null;+ if (data?.kind === 'generation') {+ const { path: _path, ...metadata } = data;+ next = { ...stream, event: { ...stream.event!, data: { ...metadata, pathOrigin: 'remote-agent' } } };+ }+ }+ }+ if (deps.isOwnerCurrent(run.owner) && deps.isControllerAuthorized(run.controller)) appendPrepared(run, next);+ });+ imagePreparation.set(run, pending);+ const settled = () => { if (imagePreparation.get(run) === pending) imagePreparation.delete(run); };+ void pending.then(settled, settled);+ return;+ }+ appendPrepared(run, item);+ }++ function appendPrepared(run: Run, item: unknown): void {if (run.log.append(item)) return;if (!run.closing) {deps.log?.warn('remote agent event log overflow; ending run', { runId: run.id });@@ -1006,6 +1052,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {}async function startRun(run: Run, payload: RemoteAgentOpenPayload): Promise<void> {+ run.imageDeliveryEpoch = payload.imageDeliveryEpoch;try {// 中转过来的任务按(控制端, relay)派生:不同受邀者即使任务 id 相同也不会共用本机侧任务。const hostSessionId = hostSessionIdFor(guestScopeOf(run.controller, run.relayKey), payload.sessionId);@@ -1166,6 +1213,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {run.ownerRoute?.release();run.ownerRoute = undefined;await run.tunnel?.close().catch(() => undefined);+ await imagePreparation.get(run);run.tunnel = undefined;// 本机这次尝试里已告诉受邀者打开的连接一并关掉(隧道关闭不会逐个回调);中转的连接编号带尝试前缀,不会撞上。for (const connId of run.localWs ?? []) append(run, { t: 'ws', connId, kind: 'close' });@@ -1430,7 +1478,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {const relayClosed = (reason: string, error?: RemoteAgentErrorInfo) => {const finish = () => {if (run.closing) return;- run.log.append({ t: 'closed', reason, ...(error ? { error: relayErrorForGuest(error) } : {}) });+ append(run, { t: 'closed', reason, ...(error ? { error: relayErrorForGuest(error) } : {}) });void finishRun(run, reason, 'navigation', false, true);};// 一轮进行中那台的任务意外结束(离线、崩溃等):与终态错误一样可以换一台。@@ -1453,7 +1501,11 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {if (run.closing || run.relay !== backend) return;meterRunUsage(run, backend.model, event as AgentEvent);const deliver = () => {- if (!run.closing) append(run, { t: 'event', event });+ if (!run.closing) append(run, { t: 'event', event }, {+ agentDeviceId: current.agentDeviceId,+ sessionId: relaySessionIdFor(run.controller, payload.sessionId),+ relay: relayKeyFor(run.controller),+ });};const failure = relayRunFailureOf(event);if (failure) {@@ -1651,7 +1703,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {skipClosedEvent = false,mode: 'close' | 'detach' = 'close',): Promise<void> {- if (run.closing) return;+ if (run.closing) { await imagePreparation.get(run); return; }run.closing = true;if (run.stateTimer) clearInterval(run.stateTimer);for (const pending of run.pending.values()) pending.reject(new Error('[REMOTE_AGENT_EXPIRED] task has ended'));@@ -1683,6 +1735,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {run.ownerRoute?.release();run.ownerRoute = undefined;await run.tunnel?.close().catch(() => undefined);+ // Native image materialization must finish before the log becomes unreadable.+ await imagePreparation.get(run);// 收尾事件绕过 closing 判断直接写入。if (!skipClosedEvent) run.log.append({ t: 'closed', reason });run.log.end();@@ -2037,6 +2091,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {const request = parseRemoteAgentRequest(raw);if (!deps.isControllerAuthorized(controller)) fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');switch (request.op) {+ case 'images': {+ if (!deps.imageArtifacts) fail('REMOTE_AGENT_INVALID', 'image recovery is unavailable');+ const owner = deps.captureOwner();+ const result = await deps.imageArtifacts!(hostSessionIdFor(guestScopeOf(controller, request.relay), request.sessionId), request);+ if (!deps.isOwnerCurrent(owner) || !deps.isControllerAuthorized(controller)) fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');+ return result;+ }case 'caps': {const guest = trustOf(controller) === 'guest';const caps: RemoteAgentCaps = {@@ -2049,6 +2110,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {uploadChunkBytes: REMOTE_AGENT_UPLOAD_CHUNK_BYTES,maxPayloadBytes: REMOTE_AGENT_MAX_PAYLOAD_BYTES,virtualWorkspace: true,+ ...(deps.imageArtifacts ? { imageRecovery: true, imageRecoveryRelay: true } : {}),// 能按受邀者隔离运行(供应商级授权与出站边界都已接上),才接受组所在电脑中转过来的受邀者任务。...(deps.providerAccess && deps.bindGuestProviderRoute ? { guestRelay: true } : {}),// 转分享的同意只对受邀者(把这里分享的供应商放进自己组的人)有意义。@@ -2199,6 +2261,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {}const run: Run = {id: request.runId,+ acceptsImageDeliveryReceipts: payload.acceptsImageDeliveryReceipts === true,controller,trust,...(relayKey ? { relayKey } : {}),@@ -2226,6 +2289,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {const member = relayTo;// 先登记再中转:中转中途失败时,分享删除也能找到并清理(含通知那台组内电脑)。run.hostSessionId = hostSessionIdFor(controller, payload.sessionId);+ run.imageDeliveryEpoch = payload.imageDeliveryEpoch;const load = reserved;void recordGuestSession(controller, undefined, run.hostSessionId, []).then(() => startRelay(run, payload, member, { fresh: !payload.options.resumeSessionId, avoid, ...(load ? { load } : {}) }))diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.tsindex bd92d20bfe..7addb641fc 100644--- a/apps/desktop/src/main/remote-agent/host/service.ts+++ b/apps/desktop/src/main/remote-agent/host/service.ts@@ -35,6 +35,7 @@ import { isRemoteProviderInvocationAllowed } from '../../maker-host/remote-proviimport { guestProviderModelIds, resolveGuestProviderId, resolveSharedProviderId } from './providerAccess';import { createRemoteAgentHost, type HostedStartInput, type RemoteAgentHost, type RunUsageRecord } from './runHost';import { purgeClaudeHostedSessionArtifacts, purgeClaudeHostedTranscripts, purgePiHostedSubagentRuns } from './transcripts';+import { captureGeneratedImageStorage, generatedImageErrorCode, handleGeneratedImageArtifacts, prepareGeneratedImageTransport } from '../../cindy-media/generatedImageStorage';const log = createLogger('remote-agent:host');@@ -119,6 +120,11 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDatlog,});host = createRemoteAgentHost({+ prepareImageEvent: (sessionId, event, upstream, retainForRecovery) => prepareGeneratedImageTransport(`remote:${sessionId}`, event, { upstream, retainForRecovery, invoke: remoteBackgroundInvoke }),+ imageArtifacts: async (sessionId, request) => {+ try { return await handleGeneratedImageArtifacts(sessionId, request, remoteBackgroundInvoke); }+ catch (error) { throw new Error(generatedImageErrorCode(error)); }+ },readLimits: () => readRemoteAgentLimitsState().value,isAgentAvailable: (kind) => {try {@@ -168,6 +174,10 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat},// Codex 与 Pi 的会话历史在受邀者目录里,随它整体删除;这里清 Claude Code 的项目记录与 Pi 子代理运行目录。purgeHostedTranscripts: async (hostSessionIds, nativeIds) => {+ const images = captureGeneratedImageStorage();+ for (const id of hostSessionIds) {+ for (const record of await images.journal.list(`remote:${id}`)) await images.release(record.scope, record.id);+ }await purgeClaudeHostedTranscripts(hostSessionIds);await purgeClaudeHostedSessionArtifacts(nativeIds);await purgePiHostedSubagentRuns(hostSessionIds, path.join(options.userDataDir, 'pi-agent-home'));diff --git a/apps/desktop/src/main/remote-agent/wire.ts b/apps/desktop/src/main/remote-agent/wire.tsindex 8d9909814f..bd28e756f5 100644--- a/apps/desktop/src/main/remote-agent/wire.ts+++ b/apps/desktop/src/main/remote-agent/wire.ts@@ -154,6 +154,10 @@ export interface RemoteAgentWirePersonal {}export interface RemoteAgentOpenPayload {+ /** Controller can acknowledge durable image delivery; absent on legacy controllers. */+ acceptsImageDeliveryReceipts?: boolean;+ /** Task Host clear generation, preserved through provider-group relays. */+ imageDeliveryEpoch?: number;/** 控制端任务 id。 */sessionId: string;/** 能力增量:Agent 使用本机虚拟工作区;新控制端在 open 前必须确认对端 caps 支持。 */@@ -325,6 +329,9 @@ export function decodeOpenPayload(value: unknown): RemoteAgentOpenPayload {});return {sessionId,+ ...(value.acceptsImageDeliveryReceipts === true ? { acceptsImageDeliveryReceipts: true } : {}),+ ...(typeof value.imageDeliveryEpoch === 'number' && Number.isSafeInteger(value.imageDeliveryEpoch) && value.imageDeliveryEpoch >= 0+ ? { imageDeliveryEpoch: value.imageDeliveryEpoch } : {}),...(value.virtualWorkspace === true ? { virtualWorkspace: true } : {}),...(value.groupAssigned === true ? { groupAssigned: true } : {}),...(typeof value.relay === 'string' && REMOTE_AGENT_RELAY_KEY_PATTERN.test(value.relay) ? { relay: value.relay } : {}),diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.tsindex d63781eace..bbea5a81f5 100644--- a/apps/desktop/src/preload/preload.ts+++ b/apps/desktop/src/preload/preload.ts@@ -7677,6 +7677,8 @@ contextBridge.exposeInMainWorld('electronAPI', {opts?: { expectedClearBoundaryMs?: number | null },): Promise<import('../shared/agentInputQueue').AgentInputProjection> =>ipcRenderer.invoke('maker:input:resume', sessionId, opts),+ retryImageDelivery: (sessionId: string, imageId: string): Promise<void> =>+ ipcRenderer.invoke('maker:images:retry', sessionId, imageId),retryLastError: (sessionId: string,opts?: { expectedClearBoundaryMs?: number | null },diff --git a/apps/desktop/src/renderer/__tests__/agentActionRowRendering.test.ts b/apps/desktop/src/renderer/__tests__/agentActionRowRendering.test.tsindex 88af22bd51..cc22ebc829 100644--- a/apps/desktop/src/renderer/__tests__/agentActionRowRendering.test.ts+++ b/apps/desktop/src/renderer/__tests__/agentActionRowRendering.test.ts@@ -16,9 +16,10 @@* - Codex file_change 与 Claude 文件编辑共用 diff lightbox*/-import { cleanup, fireEvent, render, screen } from '@testing-library/react';+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react';import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';import { createElement } from 'react';+import { i18n } from '../i18n';const ghostFixtures = vi.hoisted(() => ({ ghosts: [] as unknown[] }));const openFileMenuAt = vi.hoisted(() => vi.fn());@@ -26,15 +27,18 @@ vi.mock('@/cindy-brain/useInstalledGhosts', () => ({useInstalledGhosts: () => ghostFixtures.ghosts,}));-vi.mock('react-i18next', () => ({- // t 返回原 key(带 count 时后缀 :count),断言直接对 key 做,避免复制文案表。+vi.mock('react-i18next', async (importOriginal) => ({+ ...(await importOriginal<typeof import('react-i18next')>()),+ // Image delivery uses production translations; other rows retain stable key-based assertions.useTranslation: () => ({t: (key: string, options?: Record<string, unknown>) =>- options && typeof options.count === 'number'- ? `${key}:${String(options.count)}`- : options && typeof options.size === 'string'- ? `${key}:${options.size}`- : key,+ key.startsWith('chat.imageDelivery.')+ ? i18n.t(key, { lng: 'en' })+ : options && typeof options.count === 'number'+ ? `${key}:${String(options.count)}`+ : options && typeof options.size === 'string'+ ? `${key}:${options.size}`+ : key,}),}));@@ -60,6 +64,7 @@ vi.mock('@/lib/filePreview', () => ({ shouldOpenTextLightbox: async () => falsevi.mock('@/lib/localPathResolver', () => ({ toLocalFileUrl: (p: string) => `xdt-file://${p}` }));import { AgentActionRow, humanizeDocumentToolResult } from '@/components/chat/AgentActionRow';+import { ChatSessionFileProvider } from '@/components/chat/ChatSessionFileContext';import { AgentActionsBlock } from '@/components/chat/AgentActionsBlock';import { __test_internals as expandMemory } from '@/hooks/useExpandedBlockMemory';import type { ChatMessage } from '@/lib/makerChatStore';@@ -569,3 +574,29 @@ describe('AgentActionsBlock — 状态判定与块头', () => {expect(screen.getByLabelText('chat.agentActionRow.status.done')).toBeTruthy();});});++// #6412 / PR #6420: real locale lookup catches misplaced keys hidden by the previous identity mock.+// The retry button must display translated text and target the existing artifact on the task host.+it.each(['local', 'device'] as const)('retries image delivery through the %s task route without sending a model message', async (kind) => {+ const retry = vi.fn(async () => {});+ const invoke = vi.fn(async () => {});+ const previous = window.electronAPI;+ window.electronAPI = { maker: { input: { retryImageDelivery: retry } }, deviceLink: { invoke } } as never;+ try {+ render(createElement(ChatSessionFileProvider, { value: {+ sessionId: 'task', workingDir: '/task', origin: kind === 'device' ? { kind, deviceId: 'task-host' } : { kind },+ }, children: createElement(AgentActionRow, {+ message: mkTool('image', 'imagegen', {}),+ toolResult: JSON.stringify({ kind: 'generation', native_image_delivery: { id: 'a'.repeat(64), state: 'failed' } }),+ }) }));+ expect(screen.getByRole('status').textContent).toBe('Image delivery failed. Retry transferring the existing image.');+ await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Retry delivery' })); });+ if (kind === 'device') {+ expect(invoke).toHaveBeenCalledWith('task-host', 'maker:images:retry', ['task', 'a'.repeat(64)]);+ expect(retry).not.toHaveBeenCalled();+ } else {+ expect(retry).toHaveBeenCalledWith('task', 'a'.repeat(64));+ expect(invoke).not.toHaveBeenCalled();+ }+ } finally { window.electronAPI = previous; }+});diff --git a/apps/desktop/src/renderer/components/chat/AgentActionRow.tsx b/apps/desktop/src/renderer/components/chat/AgentActionRow.tsxindex 3429b6e108..60415a8106 100644--- a/apps/desktop/src/renderer/components/chat/AgentActionRow.tsx+++ b/apps/desktop/src/renderer/components/chat/AgentActionRow.tsx@@ -1,4 +1,6 @@-import { readToolProcessMedia, readToolProcessText } from '@cindy/maker-shared/tool-process-media';+import { readFailedImageDelivery, readToolProcessMedia, readToolProcessText } from '@cindy/maker-shared/tool-process-media';+import { isSharedTaskPeer } from '@cindy/device-link';+import { Button } from '@/components/ui/button';import { ChatVideoView } from './ChatVideoView';import { ChatImageView } from './ChatImageView';import { FileTypeIcon } from '@/components/ui/file-type-icon';@@ -1177,6 +1179,7 @@ export function AgentActionRow({{rawCommand}</div>)}+ {readFailedImageDelivery(resultText) && <GeneratedImageRetry imageId={readFailedImageDelivery(resultText)!} />}{processMedia.length > 0 && (<div className="flex min-w-0 flex-col gap-3 py-2 pl-8" data-tool-process-media="true">{processMedia.map((media) => media.kind === 'image'@@ -1253,3 +1256,20 @@ export function AgentActionRow({</div>);}++function GeneratedImageRetry({ imageId }: { imageId: string }) {+ const { t } = useTranslation();+ const { sessionId, origin } = useChatSessionFile();+ const [pending, setPending] = useState(false);+ const [failed, setFailed] = useState(false);+ return <div className="flex flex-wrap items-center gap-2 py-2 pl-8 text-13 text-muted-foreground">+ <span role="status">{t(failed ? 'chat.imageDelivery.retryFailed' : 'chat.imageDelivery.failed')}</span>+ {sessionId && !(origin.kind === 'device' && isSharedTaskPeer(origin.deviceId)) && <Button variant="secondary" size="sm" disabled={pending} onClick={async () => {+ setPending(true); setFailed(false);+ try {+ if (origin.kind === 'device') await window.electronAPI.deviceLink.invoke(origin.deviceId, 'maker:images:retry', [sessionId, imageId]);+ else await window.electronAPI.maker.input.retryImageDelivery(sessionId, imageId);+ } catch { setFailed(true); } finally { setPending(false); }+ }}>{t(pending ? 'chat.imageDelivery.retrying' : 'chat.imageDelivery.retry')}</Button>}+ </div>;+}diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.jsonindex bb4d4f6553..349d1eb214 100644--- a/apps/desktop/src/renderer/i18n/locales/en/common.json+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json@@ -11003,6 +11003,13 @@"verificationFailed": "Cindy couldn’t confirm whether the ChatGPT sign-in has recovered. Check again."},"chat": {+ "imageDelivery": {+ "stored": "Image delivered",+ "failed": "Image delivery failed. Retry transferring the existing image.",+ "retry": "Retry delivery",+ "retrying": "Delivering…",+ "retryFailed": "Delivery is still unavailable. Check that the source computer is online."+ },"failedSamplingAttempt": "This reply did not complete. Its content is for reference only.","jumpToBottom": "Jump to bottom","prevMessageJump": "Jump to previous prompt: {{preview}}",diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.jsonindex 976fd8a1f7..b91dcc521e 100644--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json@@ -10963,6 +10963,13 @@"verificationFailed": "ChatGPT ログインが復旧したか確認できませんでした。再確認してください。"},"chat": {+ "imageDelivery": {+ "stored": "画像を受け取りました",+ "failed": "画像の転送に失敗しました。既存の画像の転送を再試行できます。",+ "retry": "転送を再試行",+ "retrying": "転送中…",+ "retryFailed": "転送できません。画像を生成したパソコンがオンラインか確認してください。"+ },"failedSamplingAttempt": "この返信は完了しませんでした。内容は参考情報としてご覧ください。","jumpToBottom": "一番下へ移動","prevMessageJump": "前の質問へ移動:{{preview}}",diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.jsonindex 835180123e..9ac4ec31cf 100644--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json@@ -10963,6 +10963,13 @@"verificationFailed": "ChatGPT 로그인이 복구되었는지 확인할 수 없습니다. 다시 확인해 주세요."},"chat": {+ "imageDelivery": {+ "stored": "이미지 전달 완료",+ "failed": "이미지 전달에 실패했습니다. 기존 이미지 전송을 다시 시도할 수 있습니다.",+ "retry": "전달 다시 시도",+ "retrying": "전달 중…",+ "retryFailed": "전달할 수 없습니다. 이미지를 생성한 컴퓨터가 온라인인지 확인해 주세요."+ },"failedSamplingAttempt": "완료되지 않은 답변입니다. 내용은 참고용으로만 확인해 주세요.","jumpToBottom": "맨 아래로 이동","prevMessageJump": "이전 질문으로 이동: {{preview}}",diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.jsonindex 0d7485d008..837b8b9731 100644--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json@@ -10963,6 +10963,13 @@"verificationFailed": "暂时无法确认 ChatGPT 登录是否已恢复,请重新检测。"},"chat": {+ "imageDelivery": {+ "stored": "图片已交付",+ "failed": "图片交付失败,可重试传输已有图片。",+ "retry": "重试交付",+ "retrying": "正在交付…",+ "retryFailed": "暂时无法交付,请确认生成图片的电脑在线。"+ },"failedSamplingAttempt": "此回复未完成,内容仅供参考。","jumpToBottom": "跳到底部","prevMessageJump": "跳到上一条提问:{{preview}}",diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.jsonindex ecd0813bac..198fa1a476 100644--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json@@ -10963,6 +10963,13 @@"verificationFailed": "暫時無法確認 ChatGPT 登入是否已恢復,請重新檢測。"},"chat": {+ "imageDelivery": {+ "stored": "圖片已交付",+ "failed": "圖片交付失敗,可重試傳輸已有圖片。",+ "retry": "重試交付",+ "retrying": "正在交付…",+ "retryFailed": "暫時無法交付,請確認產生圖片的電腦在線。"+ },"failedSamplingAttempt": "此回覆未完成,內容僅供參考。","jumpToBottom": "跳到底部","prevMessageJump": "跳到上一則提問:{{preview}}",diff --git a/apps/desktop/src/renderer/lib/makerTransport.ts b/apps/desktop/src/renderer/lib/makerTransport.tsindex 611f639789..ef347c3dcf 100644--- a/apps/desktop/src/renderer/lib/makerTransport.ts+++ b/apps/desktop/src/renderer/lib/makerTransport.ts@@ -230,6 +230,7 @@ export interface RoutableMaker {| 'updateContent'| 'clearError'| 'cancelUsageLimitWait'+ | 'retryImageDelivery'| 'retryLastError'| 'clearSession'| 'persistTurnErrorDeferred'@@ -345,6 +346,7 @@ function remoteMakerApi(deviceId: string): RoutableMaker {updateContent: t('maker:input:update-content') as FullMaker['input']['updateContent'],clearError: t('maker:input:clear-error') as FullMaker['input']['clearError'],cancelUsageLimitWait: t('maker:input:cancel-usage-limit-wait') as FullMaker['input']['cancelUsageLimitWait'],+ retryImageDelivery: t('maker:images:retry') as FullMaker['input']['retryImageDelivery'],retryLastError: t('maker:input:retry-last-error') as FullMaker['input']['retryLastError'],clearSession: t('maker:input:clear-session') as FullMaker['input']['clearSession'],// device-link:auth error 重试失败/放弃时在被控端落库,经隧道路由到被控端 main。diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.tsindex f62088b116..3205699b01 100644--- a/apps/desktop/src/renderer/vite-env.d.ts+++ b/apps/desktop/src/renderer/vite-env.d.ts@@ -6258,6 +6258,7 @@ interface ElectronAPI {sessionId: string,opts?: { expectedClearBoundaryMs?: number | null },) => Promise<import('../shared/agentInputQueue').AgentInputProjection>;+ retryImageDelivery: (sessionId: string, imageId: string) => Promise<void>;retryLastError: (sessionId: string,opts?: { expectedClearBoundaryMs?: number | null },diff --git a/apps/mobile/app/sessions/[sessionId].tsx b/apps/mobile/app/sessions/[sessionId].tsxindex 12d9a6e887..697ddd82a9 100644--- a/apps/mobile/app/sessions/[sessionId].tsx+++ b/apps/mobile/app/sessions/[sessionId].tsx@@ -5097,6 +5097,8 @@ function SessionScreenContent() {}}, [remoteHistoryAvailable, historyView.snapshot.ready, historyView.view, requestSync, abandonInFlightBackfill, deviceId, hasOlderMessages, isScheduleDetail, loadingEarlier, maker, oldestLoadedMessageCursor, sessionId]);+ const retryImageDelivery = useCallback((imageId: string) => maker.input.retryImageDelivery(sessionId, imageId), [maker, sessionId]);+const loadToolInput = useCallback(async (ref: MobileToolInputProjection,): Promise<MobileToolInputDetail> => {@@ -10119,6 +10121,7 @@ function SessionScreenContent() {onForkMessage={isSharedTaskPeer(deviceId) ? undefined : forkAtMessage}onLoadEarlier={loadEarlierMessages}onLoadToolInput={loadToolInput}+ onRetryImageDelivery={isSharedTaskPeer(deviceId) ? undefined : retryImageDelivery}onOpenForkOrigin={forkOrigin ? openForkOrigin : undefined}onOpenOriginSession={openOriginSession}// 设备来源标签只标别的设备发来的消息:本机发出的不标。diff --git a/apps/mobile/src/__tests__/mobileMakerTransport.test.ts b/apps/mobile/src/__tests__/mobileMakerTransport.test.tsindex 71b9035f31..290a66c4b2 100644--- a/apps/mobile/src/__tests__/mobileMakerTransport.test.ts+++ b/apps/mobile/src/__tests__/mobileMakerTransport.test.ts@@ -1331,3 +1331,9 @@ describe("mobile maker transport", () => {expect(invokeMock).not.toHaveBeenCalled();});});++it('retries an existing image artifact on the task Host without sending a new prompt', async () => {+ const { calls, maker } = harness();+ await maker.input.retryImageDelivery('task', 'a'.repeat(64));+ expect(calls).toEqual([{ deviceId: 'dev-1', channel: 'maker:images:retry', args: ['task', 'a'.repeat(64)] }]);+});diff --git a/apps/mobile/src/__tests__/mobileWireToolProjection.test.ts b/apps/mobile/src/__tests__/mobileWireToolProjection.test.tsindex 12179baef9..e873eae27c 100644--- a/apps/mobile/src/__tests__/mobileWireToolProjection.test.ts+++ b/apps/mobile/src/__tests__/mobileWireToolProjection.test.ts@@ -3,6 +3,7 @@ import { MOBILE_TOOL_RESULT_BYTES, projectMobileMessagePage, projectMobileToolMeimport { normalizeRemoteMessages } from '@/session/messageNormalize';import { fetchMobileToolInputDetail } from '@/session/messageToolPayloadProjection';import { remoteSessionStore } from '@/session/remoteSessionStore';+import { readFailedImageDelivery } from '@cindy/maker-shared/tool-process-media';import type { RemoteMessage } from '@/session/types';describe('Desktop tool projection consumed by Mobile', () => {@@ -89,4 +90,30 @@ describe('Desktop tool projection consumed by Mobile', () => {expect(remoteSessionStore.getMessages(tool.sessionId).find((m) => m.id === tool.id)?.mobileToolInputProjection).toEqual((projectMobileToolMessage(tool) as RemoteMessage).mobileToolInputProjection);});++ // #6420: image retries replace the failed row in place; the rendered model must lose its retry+ // state and gain the image without a history reload. Existing coverage only replaced plain text.+ it('replaces failed image delivery with the stored image through a repeated row push', () => {+ const imageId = 'a'.repeat(64);+ const imageUrl = `cindy-media://blobs/${'b'.repeat(64)}.png`;+ const input = { ...tool, content: { toolName: 'imagegen', toolUseId: tool.toolUseId, input: {} } };+ const failed: RemoteMessage = { ...tool, id: 'image-result', clientId: 'image-result',+ role: 'tool_result', content: JSON.stringify({ kind: 'generation', ok: false,+ native_image_delivery: { id: imageId, state: 'failed' } }) };+ remoteSessionStore.setMessages(tool.sessionId, [input, failed]);+ const before = normalizeRemoteMessages(remoteSessionStore.getMessages(tool.sessionId));+ expect(readFailedImageDelivery(before[0].secondaryBody)).toBe(imageId);+ expect(before[0].media ?? []).toHaveLength(0);++ const stored = { ...failed, content: JSON.stringify({ kind: 'generation', ok: true,+ native_image_delivery: { id: imageId, state: 'stored' }, xdt_image_url: imageUrl }) };+ remoteSessionStore.applyRemotePush('wire-device', 'local-db:messages:created',+ projectMobileToolPush('local-db:messages:created', { sessionId: tool.sessionId, message: stored }));++ const rows = remoteSessionStore.getMessages(tool.sessionId);+ expect(rows).toHaveLength(2);+ const after = normalizeRemoteMessages(rows);+ expect(readFailedImageDelivery(after[0].secondaryBody)).toBeNull();+ expect(after[0].media).toEqual(expect.arrayContaining([expect.objectContaining({ kind: 'image', url: imageUrl })]));+ });});diff --git a/apps/mobile/src/device-link/mobileMakerTransport.ts b/apps/mobile/src/device-link/mobileMakerTransport.tsindex 640bc8ef76..d343d797b0 100644--- a/apps/mobile/src/device-link/mobileMakerTransport.ts+++ b/apps/mobile/src/device-link/mobileMakerTransport.ts@@ -862,6 +862,7 @@ export interface MobileMakerTransport {opts?: { keepQueue?: boolean; pauseQueue?: boolean },): Promise<InputProjection>;resume(sessionId: string): Promise<InputProjection>;+ retryImageDelivery(sessionId: string, imageId: string): Promise<void>;retryLastError(sessionId: string): Promise<InputProjection>;clearError(sessionId: string): Promise<InputProjection>;/** 取消账号限额重置后的自动继续;老被控端没有该通道时会被拒(调用方只在投影带等待时显示入口)。 */@@ -1526,6 +1527,7 @@ export function createMobileMakerTransport({},stop: (sessionId, opts) => call("maker:input:stop", [sessionId, opts]),resume: (sessionId) => call("maker:input:resume", [sessionId]),+ retryImageDelivery: (sessionId, imageId) => call("maker:images:retry", [sessionId, imageId]),retryLastError: (sessionId) =>call("maker:input:retry-last-error", [sessionId]),clearError: (sessionId) => call("maker:input:clear-error", [sessionId]),diff --git a/apps/mobile/src/i18n/locales/en/chat.json b/apps/mobile/src/i18n/locales/en/chat.jsonindex 2979dc51e9..efbb5f25e6 100644--- a/apps/mobile/src/i18n/locales/en/chat.json+++ b/apps/mobile/src/i18n/locales/en/chat.json@@ -1,4 +1,11 @@{+ "imageDelivery": {+ "stored": "Image delivered",+ "failed": "Image delivery failed. Retry transferring the existing image.",+ "retry": "Retry delivery",+ "retrying": "Delivering…",+ "retryFailed": "Delivery is still unavailable. Check that the source computer is online."+ },"agentActionRow": {"noContent": "Nothing to display","fileChange": {diff --git a/apps/mobile/src/i18n/locales/ja/chat.json b/apps/mobile/src/i18n/locales/ja/chat.jsonindex 67bc386120..f2372f2893 100644--- a/apps/mobile/src/i18n/locales/ja/chat.json+++ b/apps/mobile/src/i18n/locales/ja/chat.json@@ -1,4 +1,11 @@{+ "imageDelivery": {+ "stored": "画像を受け取りました",+ "failed": "画像の転送に失敗しました。既存の画像の転送を再試行できます。",+ "retry": "転送を再試行",+ "retrying": "転送中…",+ "retryFailed": "転送できません。画像を生成したパソコンがオンラインか確認してください。"+ },"agentActionRow": {"noContent": "表示できる内容はありません","fileChange": {diff --git a/apps/mobile/src/i18n/locales/ko/chat.json b/apps/mobile/src/i18n/locales/ko/chat.jsonindex e7601dc914..a2d54c2735 100644--- a/apps/mobile/src/i18n/locales/ko/chat.json+++ b/apps/mobile/src/i18n/locales/ko/chat.json@@ -1,4 +1,11 @@{+ "imageDelivery": {+ "stored": "이미지 전달 완료",+ "failed": "이미지 전달에 실패했습니다. 기존 이미지 전송을 다시 시도할 수 있습니다.",+ "retry": "전달 다시 시도",+ "retrying": "전달 중…",+ "retryFailed": "전달할 수 없습니다. 이미지를 생성한 컴퓨터가 온라인인지 확인해 주세요."+ },"agentActionRow": {"noContent": "표시할 내용이 없음","fileChange": {diff --git a/apps/mobile/src/i18n/locales/zh-CN/chat.json b/apps/mobile/src/i18n/locales/zh-CN/chat.jsonindex 1603757b6c..8e23964927 100644--- a/apps/mobile/src/i18n/locales/zh-CN/chat.json+++ b/apps/mobile/src/i18n/locales/zh-CN/chat.json@@ -1,4 +1,11 @@{+ "imageDelivery": {+ "stored": "图片已交付",+ "failed": "图片交付失败,可重试传输已有图片。",+ "retry": "重试交付",+ "retrying": "正在交付…",+ "retryFailed": "暂时无法交付,请确认生成图片的电脑在线。"+ },"agentActionRow": {"noContent": "无可展示内容","fileChange": {diff --git a/apps/mobile/src/i18n/locales/zh-TW/chat.json b/apps/mobile/src/i18n/locales/zh-TW/chat.jsonindex d3298b78a1..5b4c12112e 100644--- a/apps/mobile/src/i18n/locales/zh-TW/chat.json+++ b/apps/mobile/src/i18n/locales/zh-TW/chat.json@@ -1,4 +1,11 @@{+ "imageDelivery": {+ "stored": "圖片已交付",+ "failed": "圖片交付失敗,可重試傳輸已有圖片。",+ "retry": "重試交付",+ "retrying": "正在交付…",+ "retryFailed": "暫時無法交付,請確認產生圖片的電腦在線。"+ },"agentActionRow": {"noContent": "無可展示內容","fileChange": {diff --git a/apps/mobile/src/session/MessageRenderer.tsx b/apps/mobile/src/session/MessageRenderer.tsxindex 1c0a45ec38..01779b92b3 100644--- a/apps/mobile/src/session/MessageRenderer.tsx+++ b/apps/mobile/src/session/MessageRenderer.tsx@@ -2,7 +2,7 @@ import { VideoSitePreview } from './VideoSitePreview';import { youtubeVideo } from '@cindy/maker-shared/rich-answer';import { richVisualStyle, splitRichAnswer, richAnswerText, richMediaSource, richMarkdown, richString, type RichNode } from '@cindy/maker-shared/rich-answer';import { RichAnswer } from './RichAnswer';-import { readToolProcessMedia, readToolProcessText } from '@cindy/maker-shared/tool-process-media';+import { readFailedImageDelivery, readToolProcessMedia, readToolProcessText } from '@cindy/maker-shared/tool-process-media';import { PluginCardActions } from '@/plugins/PluginCardActions';import { McpAppCard } from './McpAppCard';import { RichContentContext } from './richContentContext';@@ -654,6 +654,7 @@ export const COMPANION_AVATAR_SIZE = 28;const COMPANION_AVATAR_GAP = 10;interface MessageActions {+ onRetryImageDelivery?: (imageId: string) => Promise<void>;companion?: boolean;onCompanionReadThrough?: (at: number) => void;onOpenCompanionSettings?: (page: 'memory' | 'capabilities') => void;@@ -747,6 +748,7 @@ export function MessageRenderer({onDeleteMessage,onLoadEarlier,onLoadToolInput,+ onRetryImageDelivery,onOpenForkOrigin,onOpenOriginSession,viewerDeviceId,@@ -1774,6 +1776,7 @@ export function MessageRenderer({onOpenPayload: openPayload,onOpenPayloadFromItem: openPayloadFromItem,onLoadToolInput,+ onRetryImageDelivery,onResolveRemoteMedia,// 待发送气泡(pending_send 项)的展开态与队列操作:漏了这一项 actions.pendingSend 就是// undefined,渲染分支直接 null —— 气泡整个不画,乐观显示消失。@@ -1816,6 +1819,7 @@ export function MessageRenderer({viewerDeviceId,onOpenSourceDevice,onLoadToolInput,+ onRetryImageDelivery,onOpenSessionLink,onPreviewRewind,onEnterShareSelection,@@ -4262,7 +4266,7 @@ function ToolGroupCard({* 媒体条 / 结果预览,再点收起。展开态走共享进程内记忆(blockId 前缀 `toolrow-`,* 与组级 `tools-` key 空间天然隔离)。无详情可展的行不显示 chevron、不可点击。*/-type ToolDetailActions = Pick<MessageActions, 'onLoadToolInput' | 'onOpenPayload' | 'onResolveRemoteMedia'>;+type ToolDetailActions = Pick<MessageActions, 'onRetryImageDelivery' | 'onLoadToolInput' | 'onOpenPayload' | 'onResolveRemoteMedia'>;function ToolActionRow({actions,@@ -4330,7 +4334,7 @@ function ToolActionRow({/>) : null}{tool.diff ? <DiffPreview diff={tool.diff} layout={contentLayout} onOpen={actions.onOpenPayload} /> : null}- {tool.secondaryBody ? <ToolResultPreview layout={contentLayout} tool={tool} onOpen={actions.onOpenPayload} /> : null}+ {tool.secondaryBody ? <ToolResultPreview layout={contentLayout} tool={tool} onOpen={actions.onOpenPayload} onRetryImageDelivery={actions.onRetryImageDelivery} /> : null}</View>) : null}</View>@@ -4733,9 +4737,10 @@ function WorkGroupCard({// Keep their callbacks and streaming flag stable across those unrelated updates.const toolActions = useMemo(() => ({onLoadToolInput: actions.onLoadToolInput,+ onRetryImageDelivery: actions.onRetryImageDelivery,onOpenPayload: actions.onOpenPayload,isSessionStreaming: actions.isSessionStreaming,- }), [actions.onLoadToolInput, actions.onOpenPayload, actions.isSessionStreaming]);+ }), [actions.onRetryImageDelivery, actions.onLoadToolInput, actions.onOpenPayload, actions.isSessionStreaming]);const startedAtIso = isStreaming && item.startedAtMs !== undefined? new Date(item.startedAtMs).toISOString(): undefined;@@ -7145,12 +7150,16 @@ function ToolResultPreview({layout,tool,onOpen,+ onRetryImageDelivery,}: {layout: MessageContentLayout;tool: NormalizedRemoteMessage;onOpen?: (payload: MessagePayload) => void;+ onRetryImageDelivery?: (imageId: string) => Promise<void>;}) {const styles = useThemedStyles(makeStyles);+ const imageId = readFailedImageDelivery(tool.secondaryBody);+ if (imageId) return <GeneratedImageRetry imageId={imageId} onRetry={onRetryImageDelivery} />;const payload = buildToolResultPayload({ ...tool, secondaryBody: readToolProcessText(tool.secondaryBody) });if (!payload) return null;const preview = summarizeMessagePayloadPreview(payload, { maxPreviewChars: TOOL_RESULT_PREVIEW_MAX_CHARS });@@ -9519,6 +9528,15 @@ const makeStyles = (colors: ThemeColors) => StyleSheet.create({fontSize: typeScale.footnote,lineHeight: lineHeight.caption,},+ imageDeliveryHint: {+ color: colors.textSecondary, fontSize: typeScale.footnote,+ lineHeight: lineHeight.caption, fontWeight: fontWeight.regular,+ },+ imageDeliveryRetry: { minHeight: 44, justifyContent: 'center', alignSelf: 'flex-start', paddingHorizontal: spacing.sm },+ imageDeliveryRetryText: {+ color: colors.textPrimary, fontSize: typeScale.body,+ lineHeight: lineHeight.body, fontWeight: fontWeight.medium,+ },toolInputPreview: {backgroundColor: colors.chatCodeSurface,borderColor: colors.chatCodeBorder,@@ -9906,3 +9924,17 @@ function RichAnswerMedia({ node, body }: { node: RichNode; body: Parameters<typeonOpen={body.onOpenPayload ? () => body.onOpenPayload!(buildMediaPayload(media, label)) : undefined} /> : null}</View>;}++function GeneratedImageRetry({ imageId, onRetry }: { imageId: string; onRetry?: (id: string) => Promise<void> }) {+ const { t } = useTranslation();+ const styles = useThemedStyles(makeStyles);+ const [pending, setPending] = useState(false);+ const [failed, setFailed] = useState(false);+ return <View>+ <Text style={styles.imageDeliveryHint}>{t(failed ? 'chat:imageDelivery.retryFailed' : 'chat:imageDelivery.failed')}</Text>+ {onRetry && <Pressable accessibilityRole="button" disabled={pending} style={styles.imageDeliveryRetry} onPress={async () => {+ setPending(true); setFailed(false);+ try { await onRetry(imageId); } catch { setFailed(true); } finally { setPending(false); }+ }}><Text style={styles.imageDeliveryRetryText}>{t(pending ? 'chat:imageDelivery.retrying' : 'chat:imageDelivery.retry')}</Text></Pressable>}+ </View>;+}diff --git a/docs/dev-rules/media-storage-and-protocols.md b/docs/dev-rules/media-storage-and-protocols.mdindex 9d007f6923..dfc2d32d60 100644--- a/docs/dev-rules/media-storage-and-protocols.md+++ b/docs/dev-rules/media-storage-and-protocols.md@@ -234,6 +234,36 @@[xAI](https://docs.x.ai/developers/model-capabilities/images/generation)。回归覆盖 `imageParameters.test.ts`、`invocationService.test.ts` 和各图像通道测试。+## Codex 原生生成图交付(#6412)++- `imageGeneration` 完成事件保留 native thread / turn / item 标识、`savedPath` 与 `result`;+ 裸 Base64 是图片数据,路径不能覆盖同时返回的字节。翻译层不读文件、不解码图片。+- 远程 Agent 的源 Host 在事件进入可确认的传输日志前读取源文件或验证原生字节,按真实+ MIME 与 20 MiB 上限校验;控制端声明支持持久交付回执时才入 `cindy-media` 建立恢复所有权。+ 旧控制端没有回执能力时只准备传输字节,不留下永久固定的源副本。跨设备发送不带源文件路径的 data URL;控制端给+ native 图片标注远端来源,不做工作区路径替换,不读本机同名文件。SSH 只走已有远端文件服务。+- 图片字节只存在媒体总仓。账号私有 `cindy-media/generated-images-v1` 记录小型交付日志,+ 不保存 Base64;native 标识生成稳定交付 ID,任务 scope 和源 Host scope 隔离。待交付副本+ 复用 `integration-cache` 引用但设 `isCache: false`,不可按可再生缓存清掉已付费产物。+- 任务 Host 先保存 blob、持久工具结果及 `session-attachment` 引用,再确认源副本可释放;+ 事件流 ACK 不等于持久交付。成功只表示任务 Host 已保存,不能宣称手机已下载。+- 失败结果分别保留生成状态与交付状态。Desktop / Mobile 的“重试交付”只按交付 ID 重读+ 原产物;不发送 Agent 消息、不重新生图。首次历史读取触发后台恢复,不阻塞历史首屏。+ 重启后复用已有 blob 或源 Host 副本;原产物确已不存在时保留失败,不能假成功。+ 重试更新已有结果后,通过 `broadcastMessageRow` 推送相同消息 ID 的最新持久内容,+ 让 Mobile 即时替换失败状态;不能仅依赖 `maker:event` 的工具结果事件。+- 每个异步边界检查账号;消息发布检查任务删除、清空与结果 tombstone / rewind。+ 清空前的未知远端产物不自动补入;新代次仍可恢复。清理独立枚举源端,只释放清空前代次的产物(删除释放全部)。+ 代次来自任务 Host 的 `cleared_at`,随新远程会话传递,不比较两台设备的墙钟。清理回执+ 先落盘,源端离线时保留,账号下次就绪重试;即使没有本地图片日志,也从任务清空/删除+ 状态重建清理。删除/回退只抑制对应稳定结果 ID,不能阻断后续无关图片恢复。+ 供应商组中转持久保存上游设备/任务/relay 回执,自己入仓且引用落库后再释放成员副本;+ 回执失败跨重启重试,流收尾等待图片准备完成。分享撤销清理同一受邀者的源 Host 引用。+ 原生交付自行提交带任务边界的附件引用,消息写入器不并发启动普通附件挂账。+ 清空若发生在引用写入期间,释放会按同一任务的可见消息条件补偿;其它任务或清空后+ 新消息仍引用同一图片时保留引用。释放日志保留受管地址,重启可继续未完成的引用清理。+ 同一任务并发交付/恢复合并,重复 native 完成事件复用消息 ID 与附件引用。+## 多端与远程- 将已有截图或本地图片保存为持久受管附件时,Agent 使用 Core `media(action: "import_image", path)`:Hostdiff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.mdindex 6eec8ce389..0090f6e242 100644--- a/docs/dev-rules/protocol-compatibility.md+++ b/docs/dev-rules/protocol-compatibility.md@@ -1036,6 +1036,31 @@ handler 无 sender 依赖;不加入共享任务访客白名单,不进入自## 远程 Agent:Agent 在另一台电脑运行+Codex 原生图片恢复(#6412)在既有 `maker:remote-agent:v1` 上追加可选+`caps.imageRecovery: true` 与 `op: images`,不改变已有事件行格式与协议版本:++- `list(sessionId, offset)` 每页最多 64 条,`read(sessionId, imageId, offset)` 每片最多+ 512 KiB,返回总长度和 SHA-256;接收方复核完整字节指纹与真实 MIME。+ `release(sessionId, imageId)` 是持久交付回执,可重复调用。入参不接受任意文件路径;+ Host 从已认证 caller 与任务 ID 派生私有 scope,返回前再次检查撤权。+- 新控制端在 `open` 声明 `acceptsImageDeliveryReceipts: true`,源 Host 才建立持久恢复副本;+ 供应商组逐层透传该声明。旧控制端缺少声明时,源 Host 仍验证/读取图片并以 data URL+ 交付,但不建立无法确认释放的恢复引用。旧源端忽略可选声明,新控制端仍按其 caps 决定恢复能力。+- 协商回执后源 Host 先入仓再发事件。两种路径均以 data URL 单独携带字节,+ 兼容仍优先读取 path 的旧控制端。+ 新控制端接受旧事件;旧源 Host 已丢失字节的 path-only 事件只能呈现交付失败,升级源端+ 后新产物才具备恢复能力。旧端未声明 capability 时不自动请求 `images`。+- `images` 可选携带 `relay`,与 `open` 相同,scope 始终由已认证 caller、relay、任务 ID+ 派生;只有明确声明 `caps.imageRecoveryRelay` 的源端才发中转释放,避免旧端忽略 relay+ 后误确认。旧端未升级时保留中转回执,正常图片事件继续交付。+- `open.imageDeliveryEpoch` / 图片 `deliveryEpoch` 是任务 Host 的清空代次(初始 0),+ 经供应商组透传,源端不使用自己的时钟换算。旧端忽略可选字段;缺少代次的旧产物在清空时+ 保守保留,删除任务仍可全部释放。新代次产物不能被此前离线清理回执删除。无需服务端升级。+- Desktop / Mobile 手动重试走同账号 `maker:images:retry(sessionId, imageId)`,不进入+ 共享任务访客清单,不进入自动重放。旧任务 Host 不认识通道时保留失败状态。+- 失败半径是一个产物:恢复不重启 relay、不关闭其它任务、不重新调用生成模型。+ 源文件、接收端消息、任务引用和释放回执分别验证,不把传输成功视为最终保存成功。+同账号的 A(任务、项目文件与命令所在)可以让 B(打开了「允许远程控制」)用 B 自己的 Agent 程序、登录(含 Claude 订阅)、供应商与网络运行 Agent。新增 invoke channel `maker:remote-agent:v1`(`packages/device-link/src/remoteAgent.ts`),只进同账号 allowlist,不进共享任务清单;被控端diff --git a/packages/device-link/src/__tests__/remoteAgent.test.ts b/packages/device-link/src/__tests__/remoteAgent.test.tsindex 41f701e81b..b59d6f1f29 100644--- a/packages/device-link/src/__tests__/remoteAgent.test.ts+++ b/packages/device-link/src/__tests__/remoteAgent.test.ts@@ -210,3 +210,20 @@ describe('remote agent channel', () => {expect(remoteAgentErrorCode('[REMOTE_AGENT_SOMETHING] x')).toBeNull();});});++// #6412: additive native-image recovery must accept old caps and never accept caller paths.+it('negotiates native image recovery and validates scoped chunk requests', () => {+ const caps = { version: 1, agents: [], maxRuns: 1, uploadChunkBytes: 1024, maxPayloadBytes: 2048 };+ expect(parseRemoteAgentCaps(caps).imageRecovery).toBeUndefined();+ expect(parseRemoteAgentCaps(caps).imageRecoveryRelay).toBeUndefined();+ expect(parseRemoteAgentCaps({ ...caps, imageRecoveryRelay: true }).imageRecoveryRelay).toBe(true);+ expect(parseRemoteAgentRequest({ op: 'images', sessionId: 'task', relay: 'r'.repeat(16), action: 'release', imageId: 'a'.repeat(64) }))+ .toMatchObject({ relay: 'r'.repeat(16), sessionId: 'task' });+ expect(parseRemoteAgentRequest({ op: 'images', sessionId: 'internal-task', action: 'list' })).toEqual({ op: 'images', sessionId: 'internal-task', action: 'list', offset: 0 });+ expect(parseRemoteAgentCaps({ ...caps, imageRecovery: true }).imageRecovery).toBe(true);+ expect(parseRemoteAgentRequest({ op: 'images', sessionId: runId, action: 'read', imageId: 'a'.repeat(64), offset: 512, path: '/private/image.png' }))+ .toEqual({ op: 'images', sessionId: runId, action: 'read', imageId: 'a'.repeat(64), offset: 512 });+ for (const patch of [{ offset: -1 }, { offset: 0.5 }, { imageId: '../image.png' }, { sessionId: '' }, { relay: '../unsafe' }]) {+ expect(() => parseRemoteAgentRequest({ op: 'images', sessionId: runId, action: 'read', imageId: 'a'.repeat(64), offset: 0, ...patch })).toThrow('REMOTE_AGENT_INVALID');+ }+});diff --git a/packages/device-link/src/allowlist.ts b/packages/device-link/src/allowlist.tsindex 1c9276df14..ac3d887ffc 100644--- a/packages/device-link/src/allowlist.ts+++ b/packages/device-link/src/allowlist.ts@@ -208,6 +208,7 @@ const CORE_INVOKE_CHANNELS: readonly string[] = ['maker:input:steer','maker:input:stop','maker:input:resume',+ 'maker:images:retry','maker:input:retry-last-error','maker:input:clear-error','maker:input:cancel-usage-limit-wait',diff --git a/packages/device-link/src/remoteAgent.ts b/packages/device-link/src/remoteAgent.tsindex 41d1df636d..d0852fd673 100644--- a/packages/device-link/src/remoteAgent.ts+++ b/packages/device-link/src/remoteAgent.ts@@ -145,6 +145,10 @@ export const REMOTE_AGENT_MAX_PUSH_CHARS = 3 * 1024 * 1024;export type RemoteAgentRequest =| { op: 'caps' }+ /** Native image recovery is scoped to the caller's task; never accepts file paths. */+ | { op: 'images'; sessionId: string; relay?: string; action: 'list'; offset: number }+ | { op: 'images'; sessionId: string; relay?: string; action: 'read'; imageId: string; offset: number }+ | { op: 'images'; sessionId: string; relay?: string; action: 'release'; imageId: string }| { op: 'upload'; uploadId: string; index: number; data: string }| { op: 'open'; runId: string; agentKind: RemoteAgentKind; payload: RemoteAgentPayload }| { op: 'call'; runId: string; callId: string; method: RemoteAgentMethod; payload: RemoteAgentPayload }@@ -219,6 +223,8 @@ export const REMOTE_AGENT_TEARDOWN_REASONS = ['navigation', 'account-boundary',export type RemoteAgentTeardownReason = (typeof REMOTE_AGENT_TEARDOWN_REASONS)[number];export interface RemoteAgentCaps {+ imageRecovery?: boolean;+ imageRecoveryRelay?: boolean;version: number;agents: Array<{ kind: RemoteAgentKind; available: boolean }>;maxRuns: number;@@ -375,6 +381,18 @@ export function parseRemoteAgentRequest(value: unknown): RemoteAgentRequest {switch (v.op) {case 'caps':return { op: 'caps' };+ case 'images': {+ // Same task-id contract as the open payload, including non-UUID internal tasks.+ const sessionId = v.sessionId;+ if (typeof sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(sessionId)) invalid();+ if (v.relay !== undefined && (typeof v.relay !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(v.relay))) invalid();+ const relay = typeof v.relay === 'string' ? { relay: v.relay } : {};+ const action = oneOf(v.action, ['list', 'read', 'release'] as const);+ if (action === 'list') return { op: 'images', sessionId, ...relay, action, offset: count(v.offset ?? 0, Number.MAX_SAFE_INTEGER) };+ if (typeof v.imageId !== 'string' || !/^[a-f0-9]{64}$/.test(v.imageId)) invalid();+ if (action === 'release') return { op: 'images', sessionId, ...relay, action, imageId: v.imageId as string };+ return { op: 'images', sessionId, ...relay, action, imageId: v.imageId as string, offset: count(v.offset, Number.MAX_SAFE_INTEGER) };+ }case 'upload':return {op: 'upload',@@ -508,6 +526,8 @@ export function parseRemoteAgentCaps(value: unknown): RemoteAgentCaps {uploadChunkBytes: count(v.uploadChunkBytes, REMOTE_AGENT_UPLOAD_CHUNK_BYTES),maxPayloadBytes: count(v.maxPayloadBytes, Number.MAX_SAFE_INTEGER),...(v.virtualWorkspace === true ? { virtualWorkspace: true } : {}),+ ...(v.imageRecovery === true ? { imageRecovery: true } : {}),+ ...(v.imageRecoveryRelay === true ? { imageRecoveryRelay: true } : {}),...(v.guestRelay === true ? { guestRelay: true } : {}),...(v.reshareConsent === true ? { reshareConsent: true } : {}),...(v.reshareBatch === true ? { reshareBatch: true } : {}),diff --git a/packages/maker-core/src/agents/codex/translator.ts b/packages/maker-core/src/agents/codex/translator.tsindex fd1105b446..c6993dbbbd 100644--- a/packages/maker-core/src/agents/codex/translator.ts+++ b/packages/maker-core/src/agents/codex/translator.ts@@ -34,7 +34,7 @@ import {} from '@cindy/maker-shared/internal-citation';import { UsageTokenSpeedMeter } from '../shared/token-speed.js';-import type { AgentEvent, AgentTaskStatus, AgentTaskUpdateEventData } from '../../types/events.js';+import type { AgentEvent, AgentTaskStatus, AgentTaskUpdateEventData, GeneratedImageEventData } from '../../types/events.js';import { normalizeAccountRateLimitSnapshot } from '../../types/account-rate-limits.js';import type { AsyncQueue } from '../shared/async-queue.js';import { stripTerminalControlSequences } from '../shared/terminal-output.js';@@ -498,7 +498,7 @@ export function translateItemNotification(handleImageView(phase, item as unknown as ImageViewItem, queue);return;case 'imageGeneration':- handleImageGeneration(phase, item as unknown as ImageGenerationItem, queue);+ handleImageGeneration(phase, item as unknown as ImageGenerationItem, queue, notification);return;case 'contextCompaction':handleContextCompaction(phase, item as unknown as ContextCompactionItem, queue, ctx);@@ -1006,7 +1006,7 @@ interface ImageViewItem {path: string;}-// v2.rs ThreadItem::ImageGeneration — 模型生成图; result 是 url/data URL, savedPath 落盘后才有。+// result may contain bare Base64 even when savedPath is also present (Codex 0.159.2).interface ImageGenerationItem {type: 'imageGeneration';id: string;@@ -2235,9 +2235,8 @@ function handleImageView(}// ── imageGeneration → image event (kind='generation') ────────────────────────-// 模型生成图。result 优先识别为 url (http/data 协议头) — 否则当 path 兜底 (codex 偶尔直接给本地路径-// 不走 savedPath 字段)。savedPath 优先 path; 同时给 revisedPrompt / status 让 UI 显示生成参数。-// started 阶段 result/savedPath 通常没填, 只发 completed。+// Preserve bytes independently of savedPath: that path may belong to another computer.+// Decode/validate/store in the Host, outside the synchronous translator hot path.function isUrlLike(s: string): boolean {return /^(https?:|data:)/i.test(s);@@ -2247,26 +2246,24 @@ function handleImageGeneration(phase: ItemPhase,item: ImageGenerationItem,queue: AsyncQueue<AgentEvent>,+ identity: { threadId: string; turnId: string },): void {if (phase !== 'completed') return;- const data: {- kind: 'generation';- blockId: string;- path?: string;- url?: string;- revisedPrompt?: string;- status?: string;- } = {+ const data: GeneratedImageEventData = {kind: 'generation',blockId: item.id,+ threadId: identity.threadId,+ turnId: identity.turnId,status: item.status,};if (item.revisedPrompt) data.revisedPrompt = item.revisedPrompt;- if (item.savedPath) {- data.path = item.savedPath;- } else if (item.result) {+ if (item.savedPath) data.path = item.savedPath;+ if (item.result) {if (isUrlLike(item.result)) data.url = item.result;- else data.path = item.result;+ // Keep the historical path-only result shape, but never interpret Base64 as a path.+ else if (/^(?:[A-Za-z]:[\\/]|\.\.?[\\/])/.test(item.result)+ || /\.(?:png|jpe?g|gif|webp)$/i.test(item.result)) data.path ??= item.result;+ else data.data = item.result;}queue.push({ type: 'image', data, source: 'codex' });}diff --git a/packages/maker-core/src/types/events.ts b/packages/maker-core/src/types/events.tsindex 5724a6471e..e7864592df 100644--- a/packages/maker-core/src/types/events.ts+++ b/packages/maker-core/src/types/events.ts@@ -54,6 +54,24 @@ export interface TurnDiffEventData {isComplete?: boolean;}+/** Native generated bytes are Host-only; never persist them in chat content. */+export interface GeneratedImageEventData {+ /** Task host clear boundary, carried as a logical generation (never a source-device clock). */+ deliveryEpoch?: number;+ kind: 'generation';+ blockId: string;+ threadId?: string;+ turnId?: string;+ /** Bare Base64, independent of the optional saved file. */+ data?: string;+ url?: string;+ path?: string;+ /** Set by the receiving transport, not inferred from path syntax. */+ pathOrigin?: 'remote-agent';+ revisedPrompt?: string;+ status?: string;+}+export interface AgentErrorEventData {message: string;/**diff --git a/packages/maker-shared/src/__tests__/toolProcessMedia.test.ts b/packages/maker-shared/src/__tests__/toolProcessMedia.test.tsindex 0ebecc1240..e8e2dee99b 100644--- a/packages/maker-shared/src/__tests__/toolProcessMedia.test.ts+++ b/packages/maker-shared/src/__tests__/toolProcessMedia.test.ts@@ -2,6 +2,7 @@// Unit coverage missing from delivered-media tests; image-only and mixed video are minimal inputs.import { describe, it, expect } from "vitest";import {+ readFailedImageDelivery,collectNativeToolMedia,readToolProcessMedia,readToolProcessText,@@ -79,3 +80,10 @@ it("budgets whole references and exposes the original multiline tool text", () =expect(JSON.parse(readToolProcessText(withToolProcessMedia(json, refs.slice(-1)))!)).toEqual(JSON.parse(json));expect(readToolProcessText(json)).toBe(json);});++it('only offers image delivery retry for a failed Host artifact record', () => {+ const value = { kind: 'generation', native_image_delivery: { id: 'a'.repeat(64), state: 'failed' } };+ expect(readFailedImageDelivery(JSON.stringify(value))).toBe('a'.repeat(64));+ expect(readFailedImageDelivery(JSON.stringify({ ...value, native_image_delivery: { ...value.native_image_delivery, state: 'stored' } }))).toBeNull();+ expect(readFailedImageDelivery(JSON.stringify({ ...value, native_image_delivery: { id: '/tmp/image.png', state: 'failed' } }))).toBeNull();+});diff --git a/packages/maker-shared/src/toolProcessMedia.ts b/packages/maker-shared/src/toolProcessMedia.tsindex 923fb59dc3..2c304945f8 100644--- a/packages/maker-shared/src/toolProcessMedia.ts+++ b/packages/maker-shared/src/toolProcessMedia.ts@@ -138,3 +138,15 @@ export function nativeToolMediaFields(content: unknown): {const processMedia = collectNativeToolMedia(content);return processMedia.length ? { processMedia } : {};}++/** Only the Host-issued delivery record enables retry; arbitrary paths/URLs never do. */+export function readFailedImageDelivery(text: string | undefined): string | null {+ if (!text?.includes('native_image_delivery')) return null;+ try {+ const value = record(JSON.parse(text));+ const delivery = record(value?.native_image_delivery);+ return value?.kind === 'generation' && delivery?.state === 'failed'+ && typeof delivery.id === 'string' && /^[a-f0-9]{64}$/.test(delivery.id)+ ? delivery.id : null;+ } catch { return null; }+}