From f3c4710b0c3183c0f771c1ee0a65b03268facc5c Mon Sep 17 00:00:00 2001 From: zhangyc Date: Thu, 19 Nov 2026 15:02:09 +0800 Subject: [PATCH 1/2] fix(server): read detached Antigravity 1.5 subagent transcripts --- .../provider/acp/AntigravityChildWork.test.ts | 279 ++++++++++++++++++ .../src/provider/acp/AntigravityChildWork.ts | 198 ++++++++++--- 2 files changed, 435 insertions(+), 42 deletions(-) diff --git a/apps/server/src/provider/acp/AntigravityChildWork.test.ts b/apps/server/src/provider/acp/AntigravityChildWork.test.ts index ed0397da32bb7..4b267db2c2b9d 100644 --- a/apps/server/src/provider/acp/AntigravityChildWork.test.ts +++ b/apps/server/src/provider/acp/AntigravityChildWork.test.ts @@ -318,6 +318,285 @@ it.layer(NodeServices.layer)("readAntigravityChildWork", (it) => { }), ); + it.effect("follows a detached 1.5 launch id through the child's inbox to its transcript", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const profile = yield* fs.makeTempDirectoryScoped({ prefix: "t3-agy-detached-" }); + const sibling = "b468c0e1-d2f3-4a5b-6c7d-8e9f0a1b2c3d"; + const writeJson = (segments: ReadonlyArray, value: unknown) => { + const file = path.join(profile, "antigravity-acp", "brain", ...segments); + return fs + .makeDirectory(path.dirname(file), { recursive: true }) + .pipe(Effect.andThen(fs.writeFileString(file, JSON.stringify(value)))); + }; + const writeTranscript = ( + conversationId: string, + lines: ReadonlyArray>, + ) => { + const file = path.join( + profile, + "antigravity-acp", + "brain", + conversationId, + ".system_generated", + "logs", + "transcript.jsonl", + ); + return fs + .makeDirectory(path.dirname(file), { recursive: true }) + .pipe( + Effect.andThen( + fs.writeFileString(file, lines.map((line) => JSON.stringify(line)).join("\n") + "\n"), + ), + ); + }; + + // Matches real agy 1.5.12 records (no legacy step_type=127 database row). + yield* writeJson([ROOT, ".system_generated", "subagents", `${CHILD}.json`], { + conversationId: CHILD, + subagentDescriptor: { typeName: "research", role: LAUNCH.role }, + state: "SUBAGENT_STATE_ALIVE", + }); + yield* writeJson([CHILD, ".system_generated", "messages", "launch.json"], { + sender: ROOT, + content: LAUNCH.prompt, + sourceMetadata: { + tool: { + conversationId: ROOT, + stepIndex: 2, + toolCall: { + id: "call_11340266277043349041", + name: "invoke_subagent", + argumentsJson: JSON.stringify({ + TypeName: "research", + Role: LAUNCH.role, + Prompt: LAUNCH.prompt, + }), + }, + }, + }, + }); + yield* writeJson([CHILD, ".system_generated", "messages", "read.json"], { launch: true }); + yield* writeTranscript(CHILD, [ + { + step_index: 0, + type: "SYSTEM_MESSAGE", + status: "DONE", + content: `\n[Message] sender=${ROOT} content=${LAUNCH.prompt}\n`, + }, + { + step_index: 1, + type: "PLANNER_RESPONSE", + status: "DONE", + tool_calls: [{ name: "read_file", args: { Path: '"/project/README.md"' } }], + }, + { + step_index: 2, + type: "GENERIC", + status: "DONE", + content: "2: MAGIC_TOKEN=probe-38478-ok", + }, + ]); + + // A second detached child without argumentsJson falls back to descriptor role + message content. + yield* writeJson([ROOT, ".system_generated", "subagents", `${sibling}.json`], { + conversationId: sibling, + subagentDescriptor: { typeName: "research", role: "Line Counter" }, + }); + yield* writeJson([sibling, ".system_generated", "messages", "launch.json"], { + sender: ROOT, + content: "Count lines in README.md", + sourceMetadata: { + tool: { + toolCall: { id: "call_22340266277043349042", name: "invoke_subagent" }, + }, + }, + }); + // A follow-up send_message must not be treated as a launch. + yield* writeJson([sibling, ".system_generated", "messages", "followup.json"], { + sender: ROOT, + content: "Also check LICENSE", + sourceMetadata: { + tool: { + toolCall: { id: "call_followup", name: "send_message" }, + }, + }, + }); + + const [first, ...firstRest] = yield* read(profile, "call_11340266277043349041", { + title: LAUNCH.role, + prompt: LAUNCH.prompt, + }); + expect(firstRest).toEqual([]); + expect(first).toMatchObject({ + conversationId: CHILD, + role: LAUNCH.role, + prompt: LAUNCH.prompt, + truncated: false, + }); + expect(first?.steps?.map((step) => step.text ?? step.toolCalls[0]?.name)).toEqual([ + "read_file", + "2: MAGIC_TOKEN=probe-38478-ok", + ]); + expect(first?.steps?.[0]?.toolCalls[0]?.input).toBe('{"Path":"/project/README.md"}'); + + // Missing transcript still returns the proven child with steps: null. + const [second] = yield* read(profile, "call_22340266277043349042", { + title: "Line Counter", + prompt: "Count lines in README.md", + }); + expect(second).toEqual({ + conversationId: sibling, + role: "Line Counter", + prompt: "Count lines in README.md", + steps: null, + truncated: false, + }); + + // Unknown id and send_message id return nothing. + expect(yield* read(profile, "call_unknown")).toEqual([]); + expect(yield* read(profile, "call_followup")).toEqual([]); + + // Another child claiming the same toolCall id makes ownership ambiguous. + yield* writeJson([sibling, ".system_generated", "messages", "dup.json"], { + sender: ROOT, + content: LAUNCH.prompt, + sourceMetadata: { + tool: { + toolCall: { id: "call_11340266277043349041", name: "invoke_subagent" }, + }, + }, + }); + expect(yield* read(profile, "call_11340266277043349041")).toEqual([]); + }), + ); + + it.effect( + "refuses detached 1.5 child records that are linked, mismatched, or out of bounds", + () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const makeDetached = () => + Effect.gen(function* () { + const profile = yield* fs.makeTempDirectoryScoped({ prefix: "t3-agy-detached-guard-" }); + const brain = path.join(profile, "antigravity-acp", "brain"); + const subagentPath = path.join( + brain, + ROOT, + ".system_generated", + "subagents", + `${CHILD}.json`, + ); + const messagePath = path.join( + brain, + CHILD, + ".system_generated", + "messages", + "launch.json", + ); + const transcriptPath = path.join( + brain, + CHILD, + ".system_generated", + "logs", + "transcript.jsonl", + ); + for (const file of [subagentPath, messagePath, transcriptPath]) { + yield* fs.makeDirectory(path.dirname(file), { recursive: true }); + } + yield* fs.writeFileString( + subagentPath, + JSON.stringify({ conversationId: CHILD, subagentDescriptor: { role: LAUNCH.role } }), + ); + yield* fs.writeFileString( + messagePath, + JSON.stringify({ + sender: ROOT, + content: LAUNCH.prompt, + sourceMetadata: { + tool: { + conversationId: ROOT, + toolCall: { id: "call_safe", name: "invoke_subagent" }, + }, + }, + }), + ); + yield* fs.writeFileString(transcriptPath, JSON.stringify(transcriptLines[3]) + "\n"); + return { profile, brain, subagentPath, messagePath, transcriptPath }; + }); + + // Linked subagent metadata file is refused. + const linkedMeta = yield* makeDetached(); + const outside = yield* fs.makeTempDirectoryScoped({ prefix: "t3-agy-outside-" }); + const outsideFile = path.join(outside, "meta.json"); + yield* fs.writeFileString(outsideFile, JSON.stringify({ conversationId: CHILD })); + yield* fs.remove(linkedMeta.subagentPath); + yield* fs.symlink(outsideFile, linkedMeta.subagentPath); + expect(yield* read(linkedMeta.profile, "call_safe")).toEqual([]); + + // Linked transcript file keeps the proven launch but refuses the transcript. + const linkedTranscript = yield* makeDetached(); + const secret = path.join(outside, "transcript.jsonl"); + yield* fs.writeFileString(secret, JSON.stringify(transcriptLines[3]) + "\n"); + yield* fs.remove(linkedTranscript.transcriptPath); + yield* fs.symlink(secret, linkedTranscript.transcriptPath); + const [withLinkedTranscript] = yield* read(linkedTranscript.profile, "call_safe"); + expect(withLinkedTranscript?.role).toBe(LAUNCH.role); + expect(withLinkedTranscript?.steps).toBeNull(); + + // Mismatched conversationId inside the subagent file is refused. + const mismatched = yield* makeDetached(); + yield* fs.writeFileString( + mismatched.subagentPath, + JSON.stringify({ conversationId: "00000000-0000-4000-8000-000000000000" }), + ); + expect(yield* read(mismatched.profile, "call_safe")).toEqual([]); + + // Launch message belonging to another root session is refused. + const wrongRoot = yield* makeDetached(); + yield* fs.writeFileString( + wrongRoot.messagePath, + JSON.stringify({ + sender: ROOT, + content: LAUNCH.prompt, + sourceMetadata: { + tool: { + conversationId: "00000000-0000-4000-8000-000000000000", + toolCall: { id: "call_safe", name: "invoke_subagent" }, + }, + }, + }), + ); + expect(yield* read(wrongRoot.profile, "call_safe")).toEqual([]); + + // Unreadable sibling inbox prevents proving uniqueness. + const corruptSibling = yield* makeDetached(); + const otherChild = "b468c0e1-d2f3-4a5b-6c7d-8e9f0a1b2c3d"; + yield* fs.writeFileString( + path.join( + corruptSibling.brain, + ROOT, + ".system_generated", + "subagents", + `${otherChild}.json`, + ), + "{}", + ); + const corruptMsg = path.join( + corruptSibling.brain, + otherChild, + ".system_generated", + "messages", + "bad.json", + ); + yield* fs.makeDirectory(path.dirname(corruptMsg), { recursive: true }); + yield* fs.writeFileString(corruptMsg, "{not-json"); + expect(yield* read(corruptSibling.profile, "call_safe")).toEqual([]); + }), + ); + it.effect("shares one transcript budget across the batch", () => Effect.gen(function* () { const filler = JSON.stringify({ diff --git a/apps/server/src/provider/acp/AntigravityChildWork.ts b/apps/server/src/provider/acp/AntigravityChildWork.ts index 17d3ba3de18f2..554e419421f6c 100644 --- a/apps/server/src/provider/acp/AntigravityChildWork.ts +++ b/apps/server/src/provider/acp/AntigravityChildWork.ts @@ -125,7 +125,10 @@ const text = (bytes: Uint8Array | undefined, field: number) => { interface InvokeRecord { readonly toolCallId: string | undefined; readonly launches: ReadonlyArray; - readonly children: ReadonlyArray<{ readonly conversationId: string; readonly logUri: string }>; + readonly children: ReadonlyArray<{ + readonly conversationId: string; + readonly logUri?: string | undefined; + }>; } const NATIVE_ID = /^[A-Za-z0-9-]{1,64}$/; @@ -386,13 +389,15 @@ async function readChildTranscript( ) )?.path; if (expected === undefined) return undefined; - let named: string; - try { - named = NodeURL.fileURLToPath(child.logUri); - } catch { - return undefined; + if (child.logUri !== undefined) { + let named: string; + try { + named = NodeURL.fileURLToPath(child.logUri); + } catch { + return undefined; + } + if ((await NodeFSP.realpath(named).catch(() => undefined)) !== expected) return undefined; } - if ((await NodeFSP.realpath(named).catch(() => undefined)) !== expected) return undefined; const handle = await NodeFSP.open( expected, NodeFS.constants.O_RDONLY | (NodeFS.constants.O_NOFOLLOW ?? 0), @@ -435,23 +440,27 @@ export const readAntigravityChildWork = Effect.fn("readAntigravityChildWork")(fu return yield* Effect.tryPromise({ try: async (): Promise> => { const profileRoot = await antigravityProfileRoot(input.profileDirectory); - const databasePath = - profileRoot === undefined - ? undefined - : ( - await antigravityManagedPath( - profileRoot, - ["antigravity-acp", "conversations", `${input.rootSessionId}.db`], - "file", - ) - )?.path; - if (profileRoot === undefined || databasePath === undefined) return []; - const database = new NodeSqlite.DatabaseSync(databasePath, { readOnly: true }); - let record: InvokeRecord | undefined; - try { - record = findInvokeRecord(database, input); - } finally { - database.close(); + if (profileRoot === undefined) return []; + let record = await findDetachedInvokeRecord( + profileRoot, + input.rootSessionId, + input.nativeTaskId, + ); + if (record === undefined) { + const databasePath = ( + await antigravityManagedPath( + profileRoot, + ["antigravity-acp", "conversations", `${input.rootSessionId}.db`], + "file", + ) + )?.path; + if (databasePath === undefined) return []; + const database = new NodeSqlite.DatabaseSync(databasePath, { readOnly: true }); + try { + record = findInvokeRecord(database, input); + } finally { + database.close(); + } } if (record === undefined) return []; const { launches, children } = record; @@ -486,11 +495,19 @@ const decodeChildMessage = Schema.decodeUnknownOption( Schema.fromJsonString( Schema.Struct({ sender: Schema.String, + content: Schema.optional(Schema.String), sourceMetadata: Schema.optional( Schema.Struct({ tool: Schema.optional( Schema.Struct({ - toolCall: Schema.optional(Schema.Struct({ id: Schema.String, name: Schema.String })), + conversationId: Schema.optional(Schema.String), + toolCall: Schema.optional( + Schema.Struct({ + id: Schema.String, + name: Schema.String, + argumentsJson: Schema.optional(Schema.String), + }), + ), }), ), }), @@ -499,6 +516,19 @@ const decodeChildMessage = Schema.decodeUnknownOption( ), ); +const decodeDetachedSubagent = Schema.decodeUnknownOption( + Schema.fromJsonString( + Schema.Struct({ + conversationId: Schema.optional(Schema.String), + subagentDescriptor: Schema.optional( + Schema.Struct({ + role: Schema.optional(Schema.String), + }), + ), + }), + ), +); + /** A conversation's inbox. Throws past a bound or on a file it cannot read, so nothing is proven. */ async function readInbox(profileRoot: string, conversationId: string) { const directory = ["antigravity-acp", "brain", conversationId, ".system_generated", "messages"]; @@ -518,6 +548,102 @@ async function readInbox(profileRoot: string, conversationId: string) { ); } +type ChildMessage = Awaited>[number]; + +async function listDetachedChildIds( + profileRoot: string, + rootSessionId: string, +): Promise | undefined> { + const children = await antigravityManagedPath( + profileRoot, + ["antigravity-acp", "brain", rootSessionId, ".system_generated", "subagents"], + "directory", + ); + if (children === undefined) return undefined; + const entries = await NodeFSP.readdir(children.path).catch(() => undefined); + if (entries === undefined) return undefined; + const childIds = entries.flatMap((name) => + name.endsWith(".json") && NATIVE_ID.test(name.slice(0, -5)) ? [name.slice(0, -5)] : [], + ); + return childIds.length > MAX_DETACHED_CHILDREN ? undefined : childIds; +} + +function detachedLaunchCall(message: ChildMessage, rootSessionId: string) { + const tool = message.sourceMetadata?.tool; + const call = tool?.toolCall; + return message.sender === rootSessionId && + (tool?.conversationId === undefined || tool.conversationId === rootSessionId) && + call?.name === "invoke_subagent" + ? call + : undefined; +} + +async function readDetachedSubagent(profileRoot: string, rootSessionId: string, childId: string) { + const file = await antigravityManagedPath( + profileRoot, + [ + "antigravity-acp", + "brain", + rootSessionId, + ".system_generated", + "subagents", + `${childId}.json`, + ], + "file", + ); + if (file === undefined || file.info.size > MAX_STEP_BYTES) return undefined; + const contents = await NodeFSP.readFile(file.path, "utf8").catch(() => undefined); + if (contents === undefined) return undefined; + const record = Option.getOrUndefined(decodeDetachedSubagent(contents)); + return record !== undefined && + (record.conversationId === undefined || record.conversationId === childId) + ? record + : undefined; +} + +/** + * agy 1.5 records detached children under `subagents/` instead of a SQLite `INVOKE_SUBAGENT` step; + * the child's own inbox carries the parent's launching `invoke_subagent` tool call id. + */ +async function findDetachedInvokeRecord( + profileRoot: string, + rootSessionId: string, + nativeTaskId: string, +): Promise { + const childIds = await listDetachedChildIds(profileRoot, rootSessionId); + if (childIds === undefined || childIds.length === 0) return undefined; + const matches: Array = []; + for (const childId of childIds) { + const messages = await readInbox(profileRoot, childId).catch(() => undefined); + // An unreadable or oversized sibling inbox could also claim this id, so uniqueness is unproven. + if (messages === undefined) return undefined; + const launchMessage = messages.find( + (message) => detachedLaunchCall(message, rootSessionId)?.id === nativeTaskId, + ); + if (launchMessage === undefined) continue; + const subagent = await readDetachedSubagent(profileRoot, rootSessionId, childId); + if (subagent === undefined) return undefined; + const argumentsJson = launchMessage.sourceMetadata?.tool?.toolCall?.argumentsJson; + const parsedArgs = + argumentsJson === undefined + ? undefined + : Option.getOrUndefined(decodeArgument(argumentsJson)); + const [fromArgs] = antigravitySubagentLaunches(parsedArgs) ?? []; + matches.push({ + toolCallId: nativeTaskId, + launches: [ + fromArgs ?? { + role: subagent.subagentDescriptor?.role ?? "", + prompt: launchMessage.content ?? "", + }, + ], + children: [{ conversationId: childId }], + }); + } + const [match] = matches; + return matches.length === 1 ? match : undefined; +} + /** * agy 1.5 children outlive their `invoke_subagent` call and the agent reports no end for them: * a child is done, or waits for guidance, once its message is in the parent's inbox. Returns the @@ -532,19 +658,11 @@ export const readAntigravityChildrenAtWork = Effect.fn("readAntigravityChildrenA if (!NATIVE_ID.test(input.rootSessionId)) return []; const read = async (): Promise> => { const profileRoot = await antigravityProfileRoot(input.profileDirectory); - const children = + const childIds = profileRoot === undefined ? undefined - : await antigravityManagedPath( - profileRoot, - ["antigravity-acp", "brain", input.rootSessionId, ".system_generated", "subagents"], - "directory", - ); - if (profileRoot === undefined || children === undefined) return []; - const childIds = (await NodeFSP.readdir(children.path)).flatMap((name) => - name.endsWith(".json") && NATIVE_ID.test(name.slice(0, -5)) ? [name.slice(0, -5)] : [], - ); - if (childIds.length > MAX_DETACHED_CHILDREN) return []; + : await listDetachedChildIds(profileRoot, input.rootSessionId); + if (profileRoot === undefined || childIds === undefined) return []; const reported = new Set( (await readInbox(profileRoot, input.rootSessionId)).map((message) => message.sender), ); @@ -552,12 +670,8 @@ export const readAntigravityChildrenAtWork = Effect.fn("readAntigravityChildrenA for (const childId of childIds) { if (reported.has(childId)) continue; for (const message of await readInbox(profileRoot, childId)) { - const launch = message.sourceMetadata?.tool?.toolCall; - if ( - message.sender === input.rootSessionId && - launch?.name === "invoke_subagent" && - input.toolCallIds.includes(launch.id) - ) { + const launch = detachedLaunchCall(message, input.rootSessionId); + if (launch !== undefined && input.toolCallIds.includes(launch.id)) { atWork.push(launch.id); } } From e4e8b460c27885f99837e44c29263ff243e42eb6 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 19 Nov 2026 07:32:27 +0000 Subject: [PATCH 2/2] test(server): drop detached Antigravity guard cases the shared path helper already covers Co-Authored-By: Claude Opus 5.5 --- .../provider/acp/AntigravityChildWork.test.ts | 125 ------------------ 1 file changed, 125 deletions(-) diff --git a/apps/server/src/provider/acp/AntigravityChildWork.test.ts b/apps/server/src/provider/acp/AntigravityChildWork.test.ts index 4b267db2c2b9d..e1bfe3aa504e8 100644 --- a/apps/server/src/provider/acp/AntigravityChildWork.test.ts +++ b/apps/server/src/provider/acp/AntigravityChildWork.test.ts @@ -472,131 +472,6 @@ it.layer(NodeServices.layer)("readAntigravityChildWork", (it) => { }), ); - it.effect( - "refuses detached 1.5 child records that are linked, mismatched, or out of bounds", - () => - Effect.gen(function* () { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const makeDetached = () => - Effect.gen(function* () { - const profile = yield* fs.makeTempDirectoryScoped({ prefix: "t3-agy-detached-guard-" }); - const brain = path.join(profile, "antigravity-acp", "brain"); - const subagentPath = path.join( - brain, - ROOT, - ".system_generated", - "subagents", - `${CHILD}.json`, - ); - const messagePath = path.join( - brain, - CHILD, - ".system_generated", - "messages", - "launch.json", - ); - const transcriptPath = path.join( - brain, - CHILD, - ".system_generated", - "logs", - "transcript.jsonl", - ); - for (const file of [subagentPath, messagePath, transcriptPath]) { - yield* fs.makeDirectory(path.dirname(file), { recursive: true }); - } - yield* fs.writeFileString( - subagentPath, - JSON.stringify({ conversationId: CHILD, subagentDescriptor: { role: LAUNCH.role } }), - ); - yield* fs.writeFileString( - messagePath, - JSON.stringify({ - sender: ROOT, - content: LAUNCH.prompt, - sourceMetadata: { - tool: { - conversationId: ROOT, - toolCall: { id: "call_safe", name: "invoke_subagent" }, - }, - }, - }), - ); - yield* fs.writeFileString(transcriptPath, JSON.stringify(transcriptLines[3]) + "\n"); - return { profile, brain, subagentPath, messagePath, transcriptPath }; - }); - - // Linked subagent metadata file is refused. - const linkedMeta = yield* makeDetached(); - const outside = yield* fs.makeTempDirectoryScoped({ prefix: "t3-agy-outside-" }); - const outsideFile = path.join(outside, "meta.json"); - yield* fs.writeFileString(outsideFile, JSON.stringify({ conversationId: CHILD })); - yield* fs.remove(linkedMeta.subagentPath); - yield* fs.symlink(outsideFile, linkedMeta.subagentPath); - expect(yield* read(linkedMeta.profile, "call_safe")).toEqual([]); - - // Linked transcript file keeps the proven launch but refuses the transcript. - const linkedTranscript = yield* makeDetached(); - const secret = path.join(outside, "transcript.jsonl"); - yield* fs.writeFileString(secret, JSON.stringify(transcriptLines[3]) + "\n"); - yield* fs.remove(linkedTranscript.transcriptPath); - yield* fs.symlink(secret, linkedTranscript.transcriptPath); - const [withLinkedTranscript] = yield* read(linkedTranscript.profile, "call_safe"); - expect(withLinkedTranscript?.role).toBe(LAUNCH.role); - expect(withLinkedTranscript?.steps).toBeNull(); - - // Mismatched conversationId inside the subagent file is refused. - const mismatched = yield* makeDetached(); - yield* fs.writeFileString( - mismatched.subagentPath, - JSON.stringify({ conversationId: "00000000-0000-4000-8000-000000000000" }), - ); - expect(yield* read(mismatched.profile, "call_safe")).toEqual([]); - - // Launch message belonging to another root session is refused. - const wrongRoot = yield* makeDetached(); - yield* fs.writeFileString( - wrongRoot.messagePath, - JSON.stringify({ - sender: ROOT, - content: LAUNCH.prompt, - sourceMetadata: { - tool: { - conversationId: "00000000-0000-4000-8000-000000000000", - toolCall: { id: "call_safe", name: "invoke_subagent" }, - }, - }, - }), - ); - expect(yield* read(wrongRoot.profile, "call_safe")).toEqual([]); - - // Unreadable sibling inbox prevents proving uniqueness. - const corruptSibling = yield* makeDetached(); - const otherChild = "b468c0e1-d2f3-4a5b-6c7d-8e9f0a1b2c3d"; - yield* fs.writeFileString( - path.join( - corruptSibling.brain, - ROOT, - ".system_generated", - "subagents", - `${otherChild}.json`, - ), - "{}", - ); - const corruptMsg = path.join( - corruptSibling.brain, - otherChild, - ".system_generated", - "messages", - "bad.json", - ); - yield* fs.makeDirectory(path.dirname(corruptMsg), { recursive: true }); - yield* fs.writeFileString(corruptMsg, "{not-json"); - expect(yield* read(corruptSibling.profile, "call_safe")).toEqual([]); - }), - ); - it.effect("shares one transcript budget across the batch", () => Effect.gen(function* () { const filler = JSON.stringify({