[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_228":-5,"_231":232,"_233":234},"routes/shell",{"_41":42,"_227":-5,"_228":-5,"_229":230},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":42,"_43":32,"_44":32,"_45":32,"_46":32,"_47":32,"_48":32,"_49":50,"_51":50,"_52":32,"_53":-7,"_54":-7,"_55":56,"_57":58,"_59":60,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","apps/server/src/chat/service.ts","oid","6c679c42861a23a90f4fdd039681dd2cb96f1ee5","size",69559,"commit","2182c95de44a8f63fd86af1c5874ae0ca298f807","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","/**\n * Chat.\n *\n * One transcript per room, shared by everyone in it, and one turn at a time.\n * Messages that address the agent are queued rather than refused while it is\n * working: the plan belongs to the agent for the length of a turn, but the\n * Chat does not, and silencing somebody because a colleague prompted\n * first is a poor way to run a room with two people in it.\n *\n * Messages that do not address it are ordinary conversation. They are carried\n * into the next turn as context rather than starting one, so people can decide\n * something between themselves and the agent turns up already knowing.\n *\n * Every message reaching the model is prefixed with its author's handle. The\n * agent is planning with a group, and \"Alice prefers X, but Bob raised Y\" is\n * the kind of thing it has to be able to say back.\n */\n\nimport { createHash } from \"node:crypto\";\n\nimport { ulid } from \"@chopin/dialect\";\n\nimport { PLANNER_TOOL_NAMES } from \"../harness/tool-names\";\nimport type { PlannerSession } from \"../harness/session\";\nimport { verifiedCheckout } from \"../harness/atomic/checkout\";\nimport { rememberCheckout } from \"../harness/atomic/workspace\";\nimport { plannerInstructions } from \"../agent/planner\";\nimport type { ActiveOwnerBinding } from \"../agent/active-owner\";\nimport type { DocumentRoom, ResearchWorkspaceRequest } from \"../agent/tools\";\nimport * as Service from \"../plan/service\";\nimport { instruction } from \"@chopin/protocol/address\";\n\nimport { annotatedText, compose, referenceCatalog, remember } from \"./address\";\nimport { createNotices } from \"./notices\";\nimport { createJobQueue, finishJob, jobReason, type JobTurn, safeProjection } from \"./job-queue\";\nimport { translateJob } from \"./job-translate\";\nimport { argsText, outputText } from \"./activity\";\nimport { watchJobAbort } from \"./job-fence\";\nimport { JOB_TOOLS } from \"../agent/job-scope\";\nimport type { JobOutcome } from \"../conversation-plan/jobs\";\nexport type { Announcer, NoticeInput } from \"./notices\";\nimport { broadcast, fail, reply, tell } from \"../wire\";\nimport { MAX_MESSAGE_BYTES } from \"./limits\";\n\nimport type { Server } from \"bun\";\nimport type { TextStreamPart, ToolSet } from \"ai\";\nimport type { Chat as Wire, ConversationPlan, Request } from \"@chopin/protocol\";\nimport type { Config } from \"../config\";\nimport type { HostedAuth } from \"../auth/routes\";\nimport type { HostedRepository } from \"../agent/repository\";\nimport type { JobService } from \"../jobs/service\";\nimport type { Plan } from \"../plan/service\";\nimport type { Said } from \"./address\";\nimport type { ReferenceService } from \"./references\";\nimport type { Socket, SocketData } from \"../wire\";\n\n/** Beyond this the queue is a backlog nobody is going to read. */\nconst MAX_QUEUE = 20;\nconst MAX_PENDING_SENDS = 20;\nconst MAX_SESSION_REFERENCES = 50;\nconst REQUEST_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\nconst FINGERPRINT = /^sha256:[0-9a-f]{64}$/;\n\ntype Delivery = {\n\tdestination: Wire.Destination;\n\trequestFingerprint: string;\n\tcanonicalFingerprint: string;\n};\n\ntype MemberEntry = Wire.Entry & { delivery?: Delivery };\n\n/** How long the agent's cursor stays where it finished, after a turn ends. */\nconst LINGER_MS = 5_000;\n\n/**\n * A queued message, with what the queue needs and clients do not.\n *\n * `spent` is asked, just before the turn would run, whether somebody else has\n * already done the work. It is a function rather than a flag because the answer\n * is only knowable at that moment — and `JSON.stringify` drops it, so the wire\n * shape stays exactly `Wire.Waiting`.\n */\nexport type Waiting = Wire.Waiting & {\n\tdelivery?: Delivery;\n\tspent?: () => boolean;\n\t/** True when this came from the composer rather than another instruction. */\n\tmessage?: boolean;\n\t/** The comment thread this turn was started to act on, if one was. */\n\tthread?: string;\n\t/** Login session whose Copilot entitlement owns this queued turn. */\n\tsessionId?: string;\n\t/** Verified member identity, retained only for a queued composer message. */\n\tuserId?: string;\n\t/** A queued background turn, resolved only after its scope is cleaned up. */\n\tjob?: JobTurn;\n\tposted?: boolean;\n\t/** MCP caller whose instruction this is; it never claims ownership without their login. */\n\tinvokedBy?: string;\n};\n\nexport type ActiveMemberRequest = {\n\tentryId: string;\n\tuserId: string;\n\thandle: string;\n\ttext: string;\n\tclaimantSessionId: string | undefined;\n\tturnId: string;\n\tlifecycle: number;\n};\n\ntype MemberRequest = Pick;\n\n/** What a turn other than a message needs to say about itself. */\nexport type Instruction = {\n\tspent?: () => boolean;\n\tthread?: string;\n};\n\nexport type Chat = {\n\tjob?: ConversationPlan.Job;\n\tjobOutput?: string;\n\tjobFailures?: number;\n\tjobFailureCode?: \"source-shape\";\n\tjobCalls?: Map;\n\tjobToolNames?: ReadonlySet;\n\t/** The job shifted from the queue while its handoff save is pending. */\n\thandoffJob?: JobTurn;\n\tentries: Wire.Entry[];\n\twaiting: Waiting[];\n\t/** Serializes complete member send acceptance, including asynchronous resolution and persistence. */\n\tsending: Promise;\n\t/** Work admitted to the send FIFO, including the operation currently resolving. */\n\tpendingSends: number;\n\t/** Per-turn owner for revocation and credential rotation fencing. */\n\topeningOwner?: { sessionId: string; generation: number; revision: number };\n\t/** Current session. Disposable per turn, except a full Planner session kept while it owns workflow runs. */\n\tagent?: PlannerSession;\n\t/** The Planner session kept past its turn, with its owner binding, until its workflow runs finish. */\n\tretained?: Retained;\n\t/** Live and paused workflow runs of the retained session. */\n\truns?: Wire.Runs;\n\tturnController?: AbortController;\n\t/** Fences a turn invalidated while opening or streaming. */\n\tlifecycle: number;\n\trunning?: Promise;\n\tclosed: boolean;\n\tbusy: boolean;\n\t/** The transient lifecycle of the running Planner turn. */\n\tturn?: Wire.Turn;\n\t/** Private provenance for the member message driving only the current turn. */\n\tactiveRequest?: ActiveMemberRequest;\n\t/**\n\t * The comment thread the running turn is acting on.\n\t *\n\t * Read by `edit_plan`, so the prose a turn writes can be recorded as what\n\t * that decision produced even when the agent forgets to say so itself.\n\t */\n\tacting?: string;\n\t/** The entry the agent is currently writing into. */\n\twriting?: string;\n\t/** The dedicated entry collecting tool calls for this turn. */\n\ttooling?: string;\n\t/** Pending removal of the agent's cursor, cancelled if it edits again. */\n\tlingering?: ReturnType;\n\t/** When each running tool call started, for its duration. */\n\ttimings: Map;\n\t/** Settles a host tool's row when its own execution ends, ahead of the harness's step-end result. */\n\ttoolFinished?: (id: string, output: unknown, success: boolean) => void;\n\t/** Shows a tool's partial output as it arrives, ahead of the harness's step-end part. */\n\ttoolProgress?: (id: string, output: unknown) => void;\n\t/** Text part ids are adapter-local; transcript ids are unique across turns. */\n\tmessageIds?: Map;\n\t/** Owner identity for the running turn only. */\n\towner?: { sessionId: string; generation: number; revision: number };\n\t/** User-facing reason an in-flight turn was interrupted. */\n\tinterruption?: string;\n\t/** Backscroll entries already represented by an opening session's bootstrap. */\n\tbootstrapEntries?: Set;\n\t/** References available to `read_reference` in the active SDK session. */\n\treferenceCache: Map;\n\t/**\n\t * What the room has said since the agent last ran.\n\t *\n\t * Deliberately not persisted: a conversation the agent never saw has no\n\t * claim on surviving a restart, and replaying it later would be stranger\n\t * than losing it.\n\t */\n\tbackscroll: Said[];\n};\n\nexport function create(): Chat {\n\treturn {\n\t\tentries: [],\n\t\twaiting: [],\n\t\tsending: Promise.resolve(),\n\t\tpendingSends: 0,\n\t\tbusy: false,\n\t\tlifecycle: 0,\n\t\tclosed: false,\n\t\ttimings: new Map(),\n\t\treferenceCache: new Map(),\n\t\tbackscroll: [],\n\t};\n}\n\n/**\n * Come back with what was said before, and the workflow runs shown then.\n *\n * An entry that was still streaming when the process went away never finished,\n * so the flag is cleared: it is as complete as it is ever going to be, and\n * leaving it set would show a spinner nothing will ever stop. Runs still live\n * then have no session now, so they come back stopped.\n */\nexport function restore(entries: Wire.Entry[], runs?: Wire.Run[]): Chat {\n\tlet restoredRuns = restoreRuns(runs);\n\treturn {\n\t\t...(restoredRuns ? { runs: restoredRuns } : {}),\n\t\tentries: entries.map(entry => {\n\t\t\tlet { streaming: _streaming, ...rest } = entry;\n\t\t\treturn rest.tools?.some(tool => tool.status === \"running\")\n\t\t\t\t? {\n\t\t\t\t\t...rest,\n\t\t\t\t\ttools: rest.tools.map(tool =>\n\t\t\t\t\t\ttool.status === \"running\" ? { ...tool, status: \"failed\" as const } : tool\n\t\t\t\t\t),\n\t\t\t\t}\n\t\t\t\t: rest;\n\t\t}),\n\t\twaiting: [],\n\t\tsending: Promise.resolve(),\n\t\tpendingSends: 0,\n\t\tbusy: false,\n\t\tlifecycle: 0,\n\t\tclosed: false,\n\t\ttimings: new Map(),\n\t\treferenceCache: new Map(),\n\t\tbackscroll: [],\n\t};\n}\n\nfunction now(): number {\n\treturn Math.floor(Date.now() / 1000);\n}\n\nfunction begin(handle: string, entryOffset: number): Wire.Turn {\n\tlet startedAt = Date.now();\n\treturn {\n\t\tid: ulid(),\n\t\thandle,\n\t\tstarted: Math.floor(startedAt / 1000),\n\t\tentryOffset,\n\t\tstartedAt,\n\t\tresponded: false,\n\t};\n}\n\nfunction digest(value: string): string {\n\treturn `sha256:${createHash(\"sha256\").update(value).digest(\"hex\")}`;\n}\n\nfunction requestFingerprint(msg: Request, principalId: string): string {\n\tlet references = Array.isArray(msg.references)\n\t\t? msg.references.map(value => {\n\t\t\tif (!value || typeof value !== \"object\" || Array.isArray(value)) return value;\n\t\t\tlet item = value as unknown as Record;\n\t\t\treturn Object.keys(item).sort().map(key => [key, item[key]]);\n\t\t})\n\t\t: msg.references ?? [];\n\treturn digest(JSON.stringify([principalId, msg.to, msg.text, references]));\n}\n\nfunction canonicalFingerprint(\n\tdestination: Wire.Destination,\n\ttext: string,\n\treferences: Wire.Reference[] = [],\n): string {\n\tlet targets = references.map(reference =>\n\t\treference.kind === \"document\"\n\t\t\t? [\n\t\t\t\treference.kind,\n\t\t\t\treference.id,\n\t\t\t\treference.start,\n\t\t\t\treference.end,\n\t\t\t\treference.label,\n\t\t\t\treference.href,\n\t\t\t\treference.repositoryId,\n\t\t\t\treference.observedRevision,\n\t\t\t\treference.channelId,\n\t\t\t\treference.observedSourceHash,\n\t\t\t]\n\t\t\t: [\n\t\t\t\treference.kind,\n\t\t\t\treference.id,\n\t\t\t\treference.start,\n\t\t\t\treference.end,\n\t\t\t\treference.label,\n\t\t\t\treference.href,\n\t\t\t\treference.repositoryId,\n\t\t\t\treference.observedRevision,\n\t\t\t\treference.parentChannelId,\n\t\t\t\treference.workspaceId,\n\t\t\t]\n\t);\n\treturn digest(JSON.stringify([destination, text, targets]));\n}\n\nfunction delivery(\n\tdestination: Wire.Destination,\n\trequest: string,\n\ttext: string,\n\treferences: Wire.Reference[] = [],\n): Delivery {\n\treturn {\n\t\tdestination,\n\t\trequestFingerprint: request,\n\t\tcanonicalFingerprint: canonicalFingerprint(destination, text, references),\n\t};\n}\n\nfunction publicEntry(value: Wire.Entry): Wire.Entry {\n\tlet { delivery, ...entry } = value as MemberEntry;\n\treturn delivery?.destination === \"planner\" ? { ...entry, to: \"planner\" } : entry;\n}\n\nexport function validateDelivery(entry: Wire.Entry): void {\n\tlet saved = (entry as MemberEntry).delivery;\n\tif (saved === undefined) return;\n\tlet keys = saved && typeof saved === \"object\" && !Array.isArray(saved)\n\t\t? Object.keys(saved).sort()\n\t\t: [];\n\tif (\n\t\tentry.author.kind !== \"member\" || !REQUEST_ID.test(entry.id)\n\t\t|| keys.length !== 3\n\t\t|| keys[0] !== \"canonicalFingerprint\"\n\t\t|| keys[1] !== \"destination\"\n\t\t|| keys[2] !== \"requestFingerprint\"\n\t\t|| (saved.destination !== \"room\" && saved.destination !== \"planner\")\n\t\t|| typeof saved.requestFingerprint !== \"string\" || !FINGERPRINT.test(saved.requestFingerprint)\n\t\t|| typeof saved.canonicalFingerprint !== \"string\"\n\t\t|| !FINGERPRINT.test(saved.canonicalFingerprint)\n\t\t|| saved.canonicalFingerprint\n\t\t\t!== canonicalFingerprint(saved.destination, entry.text, entry.references)\n\t) throw new Error(\"hosted channel has invalid chat delivery metadata\");\n}\n\nfunction replay(\n\tchat: Chat,\n\tws: Socket,\n\tmsg: Request,\n\trequestId: string,\n\tfingerprint: string,\n): boolean {\n\tlet entries = chat.entries.filter(entry => entry.id === requestId);\n\tlet waiting = chat.waiting.filter(item => item.id === requestId);\n\tif (entries.length === 0 && waiting.length === 0) return false;\n\tif (entries.length + waiting.length !== 1) {\n\t\tfail(ws, msg.rid, \"chat request id conflicts with existing state\");\n\t\treturn true;\n\t}\n\tlet entry = entries[0];\n\tlet queued = waiting[0];\n\tlet saved = entry ? (entry as MemberEntry).delivery : queued?.delivery;\n\ttry {\n\t\tif (entry) validateDelivery(entry);\n\t\telse if (\n\t\t\t!queued || !saved || !REQUEST_ID.test(queued.id)\n\t\t\t|| saved.canonicalFingerprint\n\t\t\t\t!== canonicalFingerprint(saved.destination, queued.text, queued.references)\n\t\t) throw new Error(\"invalid queued delivery metadata\");\n\t} catch {\n\t\tfail(ws, msg.rid, \"chat request id conflicts with existing state\");\n\t\treturn true;\n\t}\n\tif (!saved || saved.destination !== msg.to || saved.requestFingerprint !== fingerprint) {\n\t\tfail(ws, msg.rid, \"chat request id was reused with different content\");\n\t\treturn true;\n\t}\n\treply(ws, msg.rid, {\n\t\tkind: \"chat:send\",\n\t\tts: 0,\n\t\tid: (entry ?? queued)!.id,\n\t\tqueued: waiting.length === 1,\n\t});\n\treturn true;\n}\n\nfunction state(chat: Chat, server: Server, room: string): void {\n\tbroadcast(server, room, {\n\t\tkind: \"chat:state\",\n\t\tts: 0,\n\t\tbusy: chat.busy,\n\t\t...(chat.turn ? { turn: chat.turn } : {}),\n\t\t...(chat.runs ? { runs: chat.runs } : {}),\n\t});\n}\n\n/** Only visible Planner prose ends the working projection. */\nfunction responded(chat: Chat, server: Server, room: string, text: string): void {\n\tif (!chat.turn || chat.turn.responded || !text.trim()) return;\n\tchat.turn.responded = true;\n\tstate(chat, server, room);\n}\n\n/**\n * The queue as clients see it.\n *\n * Internal queue metadata decides how and under whose authority a turn runs.\n * None of it belongs in the wire projection.\n */\nfunction visible(chat: Chat): Wire.Waiting[] {\n\treturn chat.waiting.map(({ handle, id, text, references }) => ({\n\t\thandle,\n\t\tid,\n\t\ttext,\n\t\t...(references?.length ? { references } : {}),\n\t}));\n}\n\nfunction queued(chat: Chat, server: Server, room: string): void {\n\tbroadcast(server, room, { kind: \"chat:queue\", ts: 0, waiting: visible(chat) });\n}\n\nfunction say(\n\tchat: Chat,\n\tserver: Server,\n\troom: string,\n\tentry: Wire.Entry,\n): Wire.Entry {\n\tchat.entries.push(entry);\n\tannounce(server, room, entry);\n\treturn entry;\n}\n\nfunction announce(server: Server, room: string, entry: Wire.Entry): void {\n\tbroadcast(server, room, { kind: \"chat:message\", ts: 0, entry: publicEntry(entry) });\n}\n\n/** Everything said so far, for somebody who has just arrived. */\nexport function greet(chat: Chat, ws: Socket): void {\n\ttell(ws, {\n\t\tkind: \"chat:history\",\n\t\tts: 0,\n\t\tentries: chat.entries.map(publicEntry),\n\t\tbusy: chat.busy,\n\t\t...(chat.turn ? { turn: chat.turn } : {}),\n\t\t...(chat.runs ? { runs: chat.runs } : {}),\n\t\tqueued: visible(chat),\n\t});\n}\n\nexport type Room = {\n\tinvestigations?: import(\"../agent/experiment-tools\").InvestigationTools;\n\tchat: Chat;\n\tplan: Plan;\n\tserver: Server;\n\troom: string;\n\tconfig: Config;\n\tauth: HostedAuth;\n\t/**\n\t * Login session that may claim Planner ownership for this room's turns.\n\t * Absent for an MCP caller without a live browser login: their instruction\n\t * runs only under an owner the channel already has.\n\t */\n\tclaimantSessionId: string | undefined;\n\trepository: HostedRepository;\n\tactiveOwner?: () => Promise;\n\tpersist: (chat?: () => Pick) => Promise;\n\tcommitRoomMessage?: (entry: Wire.Entry) => Promise;\n\troomMessagePublished?: () => void;\n\topenPlannerSession?: typeof import(\"../harness/session\")[\"openPlannerSession\"];\n\tinvokedBy?: string;\n\townerAvailable?: () => Promise;\n\tjobs?: JobService;\n\treferences?: ReferenceService;\n\tcreateResearch?: (request: {\n\t\tentryId: string;\n\t\tuserId: string;\n\t\thandle: string;\n\t\ttext: string;\n\t\tquestion: string;\n\t}) => Promise;\n\t/** Keeps the room loaded while a retained Planner still owns workflow runs; returns the release. */\n\thold?: () => () => void;\n};\n\ntype Retained = {\n\tsession: PlannerSession;\n\tbinding: ActiveOwnerBinding;\n\trelease: () => Promise;\n};\n\n/**\n * Take a message.\n *\n * A room message appears immediately. A planner message queued behind another\n * turn stays visibly queued until that turn actually begins, then moves into\n * the transcript exactly once. The destination, rather than its prose, decides\n * which lifecycle it takes.\n */\nexport function send(context: Room, ws: Socket, msg: Request): Promise {\n\tif (context.chat.pendingSends >= MAX_PENDING_SENDS) {\n\t\tfail(ws, msg.rid, \"too many chat messages are waiting to be processed\");\n\t\treturn Promise.resolve();\n\t}\n\tcontext.chat.pendingSends++;\n\tlet process = () => processSend(context, ws, msg);\n\tlet accepted = context.chat.sending.then(process, process);\n\tlet completed = accepted.finally(() => context.chat.pendingSends--);\n\tcontext.chat.sending = completed.then(() => {}, () => {});\n\treturn completed;\n}\n\n/**\n * Accept an MCP instruction without waiting for its Planner turn.\n *\n * The caller is attributed on the posted message, and the turn runs under the\n * channel's Planner owner. A checkout matters only to the atomic harness, which\n * verifies it before anything is posted and remembers it for the channel.\n */\nexport async function invoke(\n\tcontext: Room,\n\tuser: { id: string; login: string },\n\ttext: string,\n\tcheckout?: string,\n): Promise<\n\t| \"planner-unavailable\"\n\t| \"planner-owner-unavailable\"\n\t| \"planner-queue-full\"\n\t| \"checkout-unverified\"\n\t| undefined\n> {\n\tlet { chat, server, room } = context;\n\tif (chat.pendingSends >= MAX_PENDING_SENDS) return \"planner-queue-full\";\n\tchat.pendingSends++;\n\tlet post = async () => {\n\t\tif (!context.config.agent || chat.closed) return \"planner-unavailable\" as const;\n\t\tlet verified: string | undefined;\n\t\tif (checkout !== undefined && context.config.harness === \"atomic\") {\n\t\t\tverified = await verifiedCheckout(context.repository, checkout);\n\t\t\tif (!verified) return \"checkout-unverified\" as const;\n\t\t}\n\t\ttry {\n\t\t\tawait resolveOwner(context.auth, context.repository, room, context.claimantSessionId);\n\t\t} catch {\n\t\t\treturn \"planner-owner-unavailable\" as const;\n\t\t}\n\t\tif (chat.closed) return \"planner-unavailable\" as const;\n\t\tif (chat.busy && chat.waiting.length >= MAX_QUEUE) return \"planner-queue-full\" as const;\n\t\tlet entry: Wire.Entry = {\n\t\t\tid: ulid(),\n\t\t\tauthor: { kind: \"member\", handle: user.login },\n\t\t\ttext,\n\t\t\tts: now(),\n\t\t};\n\t\tchat.entries.push(entry);\n\t\ttry {\n\t\t\tawait context.persist();\n\t\t} catch (error) {\n\t\t\tchat.entries = chat.entries.filter(value => value !== entry);\n\t\t\tthrow error;\n\t\t}\n\t\tif (chat.closed) return \"planner-unavailable\" as const;\n\t\tif (verified) rememberCheckout(room, verified);\n\t\tannounce(server, room, entry);\n\t\tif (chat.busy) {\n\t\t\tchat.waiting.push({\n\t\t\t\tid: entry.id,\n\t\t\t\thandle: user.login,\n\t\t\t\ttext,\n\t\t\t\tmessage: true,\n\t\t\t\tposted: true,\n\t\t\t\tsessionId: context.claimantSessionId,\n\t\t\t\tuserId: user.id,\n\t\t\t\tinvokedBy: user.id,\n\t\t\t});\n\t\t\tqueued(chat, server, room);\n\t\t} else {\n\t\t\tstartRun(\n\t\t\t\t{ ...context, invokedBy: user.id },\n\t\t\t\tuser.login,\n\t\t\t\ttext,\n\t\t\t\tundefined,\n\t\t\t\tcontext.claimantSessionId,\n\t\t\t\tfalse,\n\t\t\t\t{ entryId: entry.id, userId: user.id },\n\t\t\t);\n\t\t}\n\t\treturn undefined;\n\t};\n\tlet accepted = chat.sending.then(post, post);\n\tlet completed = accepted.finally(() => chat.pendingSends--);\n\tchat.sending = completed.then(() => {}, () => {});\n\treturn completed;\n}\n\nasync function processSend(context: Room, ws: Socket, msg: Request): Promise {\n\tlet { chat, room, server } = context;\n\tlet suppliedRequestId = (msg as Request & { requestId?: unknown }).requestId;\n\tif (\n\t\tsuppliedRequestId !== undefined && (\n\t\t\ttypeof suppliedRequestId !== \"string\" || !REQUEST_ID.test(suppliedRequestId)\n\t\t)\n\t) {\n\t\treturn fail(ws, msg.rid, \"chat request id must be a UUIDv4\");\n\t}\n\t// Pre-deploy browser tabs did not send request IDs. They keep legacy at-most-once behavior.\n\tlet requestId = suppliedRequestId ?? crypto.randomUUID();\n\tlet handle = ws.data.handle;\n\tlet destination = msg.to;\n\tif (destination !== \"room\" && destination !== \"planner\") {\n\t\treturn fail(ws, msg.rid, \"invalid message destination\");\n\t}\n\tif (typeof msg.text !== \"string\") return fail(ws, msg.rid, \"invalid message text\");\n\tif (Buffer.byteLength(msg.text) > MAX_MESSAGE_BYTES) {\n\t\treturn fail(ws, msg.rid, \"chat message exceeds the 64 KiB limit\");\n\t}\n\tlet request = requestFingerprint(msg, ws.data.principalId);\n\tif (replay(chat, ws, msg, requestId, request)) return;\n\tif (chat.closed) return fail(ws, msg.rid, \"chat is closed\");\n\tlet projected: { text: string; references?: Wire.Reference[] };\n\ttry {\n\t\tif (context.references) {\n\t\t\tprojected = await context.references.resolve({\n\t\t\t\tchannelId: room,\n\t\t\t\trepositoryId: context.repository.id,\n\t\t\t\ttext: msg.text,\n\t\t\t\tdestination,\n\t\t\t\trequests: msg.references,\n\t\t\t});\n\t\t} else {\n\t\t\tif (\n\t\t\t\tmsg.references !== undefined && (!Array.isArray(msg.references) || msg.references.length)\n\t\t\t) {\n\t\t\t\treturn fail(ws, msg.rid, \"chat references are unavailable\");\n\t\t\t}\n\t\t\tlet text = msg.text.trim();\n\t\t\tprojected = { text: destination === \"planner\" ? instruction(text) : text };\n\t\t}\n\t} catch {\n\t\treturn fail(ws, msg.rid, \"invalid or unavailable chat reference\");\n\t}\n\tlet text = projected.text;\n\tlet references = projected.references;\n\tif (!text) return fail(ws, msg.rid, \"message text is empty\");\n\tif (chat.closed) return fail(ws, msg.rid, \"chat is closed\");\n\tlet savedDelivery = delivery(destination, request, text, references);\n\n\tif (destination === \"room\") {\n\t\tlet entry: MemberEntry = {\n\t\t\tid: requestId,\n\t\t\tauthor: { kind: \"member\", handle },\n\t\t\ttext,\n\t\t\tts: now(),\n\t\t\t...(references?.length ? { references } : {}),\n\t\t\tdelivery: savedDelivery,\n\t\t};\n\t\tif (!context.commitRoomMessage) chat.entries.push(entry);\n\t\ttry {\n\t\t\tif (context.commitRoomMessage) await context.commitRoomMessage(entry);\n\t\t\telse await context.persist();\n\t\t} catch {\n\t\t\tif (!context.commitRoomMessage) {\n\t\t\t\tchat.entries = chat.entries.filter(value => value.id !== entry.id);\n\t\t\t}\n\t\t\treturn fail(ws, msg.rid, \"could not save message\");\n\t\t}\n\t\treply(ws, msg.rid, { kind: \"chat:send\", ts: 0, id: entry.id, queued: false });\n\t\tannounce(server, room, entry);\n\t\tcontext.roomMessagePublished?.();\n\t\tchat.backscroll = remember(chat.backscroll, {\n\t\t\tentryId: entry.id,\n\t\t\thandle,\n\t\t\ttext,\n\t\t\t...(references?.length ? { references } : {}),\n\t\t});\n\t\treturn;\n\t}\n\tif (!context.config.agent) {\n\t\tlet entries: MemberEntry[] = [{\n\t\t\tid: requestId,\n\t\t\tauthor: { kind: \"member\", handle },\n\t\t\ttext,\n\t\t\tts: now(),\n\t\t\t...(references?.length ? { references } : {}),\n\t\t\tdelivery: savedDelivery,\n\t\t}, {\n\t\t\tid: ulid(),\n\t\t\tauthor: { kind: \"system\" },\n\t\t\ttext: \"The agent is not running, so the plan has not been revised.\",\n\t\t\tts: now(),\n\t\t}];\n\t\tchat.entries.push(...entries);\n\t\ttry {\n\t\t\tawait context.persist();\n\t\t} catch {\n\t\t\tlet ids = new Set(entries.map(entry => entry.id));\n\t\t\tchat.entries = chat.entries.filter(entry => !ids.has(entry.id));\n\t\t\treturn fail(ws, msg.rid, \"could not save message\");\n\t\t}\n\t\treply(ws, msg.rid, { kind: \"chat:send\", ts: 0, id: entries[0]!.id, queued: false });\n\t\tfor (let entry of entries) announce(server, room, entry);\n\t\treturn;\n\t}\n\n\tif (chat.busy) {\n\t\tif (chat.waiting.length >= MAX_QUEUE) {\n\t\t\tsay(chat, server, room, {\n\t\t\t\tid: ulid(),\n\t\t\t\tauthor: { kind: \"system\" },\n\t\t\t\ttext: \"The queue is full. Wait for the current turn to finish.\",\n\t\t\t\tts: now(),\n\t\t\t});\n\t\t\treturn fail(ws, msg.rid, \"the Planner queue is full\");\n\t\t}\n\t\tlet waiting: Waiting = {\n\t\t\tid: requestId,\n\t\t\thandle,\n\t\t\ttext,\n\t\t\t...(references?.length ? { references } : {}),\n\t\t\tdelivery: savedDelivery,\n\t\t\tmessage: true,\n\t\t\tsessionId: context.claimantSessionId,\n\t\t\tuserId: ws.data.principalId,\n\t\t};\n\t\tchat.waiting.push(waiting);\n\t\treply(ws, msg.rid, { kind: \"chat:send\", ts: 0, id: waiting.id, queued: true });\n\t\treturn queued(chat, server, room);\n\t}\n\n\tlet entry: MemberEntry = {\n\t\tid: requestId,\n\t\tauthor: { kind: \"member\", handle },\n\t\ttext,\n\t\tts: now(),\n\t\t...(references?.length ? { references } : {}),\n\t\tdelivery: savedDelivery,\n\t};\n\tchat.busy = true;\n\tchat.turn = begin(handle, chat.entries.length + 1);\n\tstate(chat, server, room);\n\tchat.entries.push(entry);\n\ttry {\n\t\tawait context.persist();\n\t} catch {\n\t\tchat.entries = chat.entries.filter(value => value.id !== entry.id);\n\t\tchat.busy = false;\n\t\tchat.turn = undefined;\n\t\tstate(chat, server, room);\n\t\treturn fail(ws, msg.rid, \"could not save message\");\n\t}\n\treply(ws, msg.rid, { kind: \"chat:send\", ts: 0, id: entry.id, queued: false });\n\tif (chat.closed) return;\n\tannounce(server, room, entry);\n\tstartRun(\n\t\tcontext,\n\t\thandle,\n\t\ttext,\n\t\tundefined,\n\t\tcontext.claimantSessionId,\n\t\ttrue,\n\t\t{ entryId: entry.id, userId: ws.data.principalId },\n\t\treferences,\n\t);\n}\n\n/** Say something in the transcript without asking the agent for anything. */\nexport let { notice, noticeOnce, noticeExclusive, refreshNoticeExclusive } = createNotices({\n\tnow,\n\tannounce,\n});\n\nfunction instructionNotice(context: Room, text: string): void | Promise {\n\tlet { chat, room, server } = context;\n\tlet entry: Wire.Entry = { id: ulid(), author: { kind: \"system\" }, text, ts: now() };\n\tchat.entries.push(entry);\n\treturn context.persist().then(() => announce(server, room, entry));\n}\n\n/**\n * Start a turn from something other than a message.\n *\n * Accepting a comment is an instruction in a way prose is not — the `@chopin` rule\n * exists to separate conversation from instruction, and a button press is\n * already the latter. What it is not is a thing anybody said, so the transcript\n * gets a system entry explaining why the agent started moving; an agent that\n * begins editing for no visible reason is worse than a noisy log.\n */\nexport function instruct(\n\tcontext: Room,\n\thandle: string,\n\ttext: string,\n\tsaid: string,\n\tabout: Instruction = {},\n): void | Promise {\n\tlet { chat, config, room, server } = context;\n\tlet proceed = (): void | Promise => {\n\t\tif (chat.closed) return;\n\t\t// `AGENT=off` runs the room without one. The decision that got here is\n\t\t// still a decision and is already recorded; only the turn is impossible,\n\t\t// and saying so beats a session failing to open.\n\t\tif (!config.agent) {\n\t\t\tlet entry: Wire.Entry = {\n\t\t\t\tid: ulid(),\n\t\t\t\tauthor: { kind: \"system\" },\n\t\t\t\ttext: \"The agent is not running, so the plan has not been revised.\",\n\t\t\t\tts: now(),\n\t\t\t};\n\t\t\tchat.entries.push(entry);\n\t\t\treturn context.persist().then(() => announce(server, room, entry));\n\t\t}\n\n\t\tif (chat.busy) {\n\t\t\tif (chat.waiting.length >= MAX_QUEUE) {\n\t\t\t\treturn void say(chat, server, room, {\n\t\t\t\t\tid: ulid(),\n\t\t\t\t\tauthor: { kind: \"system\" },\n\t\t\t\t\ttext: \"The queue is full. Wait for the current turn to finish.\",\n\t\t\t\t\tts: now(),\n\t\t\t\t});\n\t\t\t}\n\t\t\tchat.waiting.push({\n\t\t\t\tid: ulid(),\n\t\t\t\thandle,\n\t\t\t\ttext,\n\t\t\t\t...about,\n\t\t\t\tsessionId: context.claimantSessionId,\n\t\t\t});\n\t\t\treturn queued(chat, server, room);\n\t\t}\n\n\t\tstartRun(context, handle, text, about.thread, context.claimantSessionId);\n\t};\n\tlet announced = instructionNotice(context, said);\n\treturn announced instanceof Promise ? announced.then(proceed) : proceed();\n}\n\nlet jobState = safeProjection(state);\nlet jobQueued = safeProjection(queued);\nlet { job, cancelQueuedJobs, stopAfterPersistenceFailure } = createJobQueue({\n\tqueued: jobQueued,\n\tstate: jobState,\n\tstartRun,\n\tMAX_QUEUE,\n});\nexport { cancelQueuedJobs, job };\n\n/** Withdraw a queued message. Only whoever wrote it may. */\nexport function unqueue(context: Room, ws: Socket, msg: Request): void {\n\tlet { chat, room, server } = context;\n\tlet found = chat.waiting.find(item => item.id === msg.id);\n\tif (!found || found.job || found.handle !== ws.data.handle) return;\n\tchat.waiting = chat.waiting.filter(item => item.id !== msg.id);\n\tqueued(chat, server, room);\n}\n\n/**\n * Stop the running turn and pause the Planner's workflow runs, so both hold\n * until someone resumes them. Anyone may, and the transcript says who did.\n */\ntype RunsSnapshot = ReturnType>;\ntype StoppingRuns = {\n\tpause: Promise;\n\ttargets: Set;\n\tpausedTargets: Set;\n\treset: boolean;\n\tsettled: boolean;\n\tpaused: boolean;\n\tunwatch?: () => void;\n};\n\nconst stoppingRuns = new WeakMap();\n\nfunction observeStoppingRuns(stopping: StoppingRuns, runs: RunsSnapshot): void {\n\tif (!runs) return;\n\tfor (let id of runs.paused) if (stopping.targets.has(id)) stopping.pausedTargets.add(id);\n\tstopping.reset = runs.active.some(id =>\n\t\t!stopping.targets.has(id) || stopping.pausedTargets.has(id)\n\t);\n}\n\nfunction clearStoppingRuns(session: PlannerSession, stopping: StoppingRuns): void {\n\tif (stoppingRuns.get(session) !== stopping) return;\n\tstoppingRuns.delete(session);\n\tstopping.unwatch?.();\n}\n\nexport async function abort(context: Room, ws: Socket): Promise {\n\tlet { chat, room, server } = context;\n\tlet turn = chat.busy && !chat.turnController?.signal.aborted\n\t\t? chat.turnController\n\t\t: undefined;\n\tlet session = chat.retained?.session ?? chat.agent;\n\tlet runs = session?.runs?.();\n\tlet live = (runs?.active.length ?? 0) > 0;\n\tlet notice = (paused: boolean) =>\n\t\tsay(chat, server, room, {\n\t\t\tid: ulid(),\n\t\t\tauthor: { kind: \"system\" },\n\t\t\ttext: paused\n\t\t\t\t? `@${ws.data.handle} stopped the Planner and paused its workflows.`\n\t\t\t\t: `@${ws.data.handle} stopped the turn.`,\n\t\t\tts: now(),\n\t\t});\n\tlet stopping = session && stoppingRuns.get(session);\n\tif (stopping) observeStoppingRuns(stopping, runs);\n\tif (session && stopping?.settled && stopping.paused && stopping.reset) {\n\t\tclearStoppingRuns(session, stopping);\n\t\tstopping = undefined;\n\t}\n\tif (stopping) {\n\t\tif (turn) {\n\t\t\tturn.abort();\n\t\t\tnotice(false);\n\t\t}\n\t\tawait stopping.pause;\n\t\treturn;\n\t}\n\tif (!turn && !live) return;\n\tif (live && session?.pauseRuns) {\n\t\tlet pauseRuns = session.pauseRuns;\n\t\tlet stopping: StoppingRuns = {\n\t\t\tpause: Promise.resolve(),\n\t\t\ttargets: new Set(runs?.active ?? []),\n\t\t\tpausedTargets: new Set(),\n\t\t\treset: false,\n\t\t\tsettled: false,\n\t\t\tpaused: false,\n\t\t};\n\t\tstopping.pause = Promise.resolve().then(async () => {\n\t\t\ttry {\n\t\t\t\tawait pauseRuns.call(session);\n\t\t\t\tstopping.paused = true;\n\t\t\t} catch (err) {\n\t\t\t\tconsole.error(\"[chat] pausing workflow runs failed:\", err);\n\t\t\t}\n\t\t\tnotice(stopping.paused);\n\t\t});\n\t\tstoppingRuns.set(session, stopping);\n\t\tstopping.unwatch = session.watchRuns?.(next => {\n\t\t\tobserveStoppingRuns(stopping, next);\n\t\t\tif (stopping.settled && stopping.paused && stopping.reset) {\n\t\t\t\tclearStoppingRuns(session, stopping);\n\t\t\t}\n\t\t});\n\t\tturn?.abort();\n\t\ttry {\n\t\t\tawait stopping.pause;\n\t\t} finally {\n\t\t\tstopping.settled = true;\n\t\t\tobserveStoppingRuns(stopping, session.runs?.());\n\t\t\tif (!stopping.paused || stopping.reset) clearStoppingRuns(session, stopping);\n\t\t}\n\t\treturn;\n\t}\n\tturn?.abort();\n\tnotice(false);\n}\n\n/** Resume the workflow runs the Planner paused. Anyone may, and the transcript says who did. */\nexport async function resume(context: Room, ws: Socket): Promise {\n\tlet { chat, room, server } = context;\n\tlet session = chat.retained?.session;\n\tif (!session?.resumeRuns || !session.runs?.()?.paused.length) return;\n\tlet text = `@${ws.data.handle} resumed the Planner's workflows.`;\n\ttry {\n\t\tawait session.resumeRuns();\n\t} catch (err) {\n\t\tconsole.error(\"[chat] resuming workflow runs failed:\", err);\n\t\ttext = \"The Planner's workflows could not be resumed.\";\n\t}\n\tsay(chat, server, room, { id: ulid(), author: { kind: \"system\" }, text, ts: now() });\n}\n\n/** Pause or resume one workflow run of the retained Planner. Anyone may, and the transcript says who did. */\nexport async function controlRun(\n\tcontext: Room,\n\tws: Socket,\n\tframe: { kind: \"chat:pause-run\" | \"chat:resume-run\"; runId?: unknown },\n): Promise {\n\tlet { chat, room, server } = context;\n\tlet session = chat.retained?.session;\n\tlet run = typeof frame.runId === \"string\"\n\t\t? chat.runs?.find(candidate => candidate.id === frame.runId)\n\t\t: undefined;\n\tlet runs = session?.runs?.();\n\tif (!session || !run) return;\n\tlet pausing = frame.kind === \"chat:pause-run\";\n\tif (pausing ? !runs?.active.includes(run.id) : !runs?.paused.includes(run.id)) return;\n\tlet control = pausing ? session.pauseRun : session.resumeRun;\n\tif (!control) return;\n\tlet text = `@${ws.data.handle} ${pausing ? \"paused\" : \"resumed\"} ${run.name}.`;\n\ttry {\n\t\tawait control(run.id);\n\t} catch (err) {\n\t\tconsole.error(`[chat] ${pausing ? \"pausing\" : \"resuming\"} workflow run failed:`, err);\n\t\ttext = `${run.name} could not be ${pausing ? \"paused\" : \"resumed\"}.`;\n\t}\n\tsay(chat, server, room, { id: ulid(), author: { kind: \"system\" }, text, ts: now() });\n}\n\nconst ENDED_RUN: Partial> = {\n\tfinished: \"finished\",\n\tblocked: \"ended blocked\",\n\tfailed: \"failed\",\n\tstopped: \"was stopped\",\n};\n\n/**\n * The run cards Chat shows after the retained session reports `incoming`. Ended\n * cards stay until a new run starts in the document. With no report, the session\n * was let go, so a card still marked live becomes stopped.\n */\nexport function mergeRuns(\n\tprevious: Wire.Run[],\n\tincoming: Wire.Run[] | undefined,\n\tat: number,\n): Wire.Run[] {\n\tif (!incoming) return previous.map(run => ENDED_RUN[run.status] ? run : stopped(run, at));\n\tlet known = new Set(previous.map(run => run.id));\n\tif (incoming.some(run => !known.has(run.id))) return incoming;\n\tlet reported = new Set(incoming.map(run => run.id));\n\treturn [...previous.filter(run => ENDED_RUN[run.status] && !reported.has(run.id)), ...incoming];\n}\n\nfunction stopped(run: Wire.Run, at: number): Wire.Run {\n\treturn { ...run, status: \"stopped\", ended: run.ended ?? at, waiting: 0 };\n}\n\n/** Run cards restored with the document; no session survives a reload of the room, so live ones were stopped. */\nexport function restoreRuns(runs: Wire.Run[] | undefined): Wire.Run[] | undefined {\n\treturn runs?.length ? mergeRuns(runs, undefined, now()) : undefined;\n}\n\nconst publishing = new WeakMap>();\nconst owners = new WeakMap>();\nconst unsaved = new WeakMap();\nconst gone = new WeakSet();\n\ntype Runs = { active: string[]; paused: string[]; cards?: Wire.Run[] };\n\n/**\n * Show the session's runs, keeping ended ones as summary cards until the next\n * run starts, store them with the document so a reload keeps them, and say once\n * in the transcript when one ends. A card belongs to the session that reported\n * it: a report or release only changes its own session's cards.\n */\nfunction publishRuns(\n\tcontext: Room,\n\tsession: PlannerSession,\n\truns: Runs | undefined,\n\treleasing = false,\n): Promise {\n\tlet known = owners.get(context.chat) ?? new Map();\n\towners.set(context.chat, known);\n\tfor (let run of runs?.cards ?? []) known.set(run.id, session);\n\tlet turn = (publishing.get(context.chat) ?? Promise.resolve()).then(() =>\n\t\tpublishReport(context, session, runs, releasing)\n\t);\n\tpublishing.set(context.chat, turn);\n\treturn turn;\n}\n\nasync function publishReport(\n\tcontext: Room,\n\tsession: PlannerSession,\n\truns: Runs | undefined,\n\treleasing: boolean,\n): Promise {\n\tlet { chat, room, server } = context;\n\tlet at = now();\n\tlet known = owners.get(chat)!;\n\tlet prior = chat.runs ?? [];\n\tlet before = new Map(prior.map(run => [run.id, run.status]));\n\tlet theirs = (run: Wire.Run) => {\n\t\tlet holder = known.get(run.id);\n\t\treturn holder !== undefined && holder !== session && !gone.has(holder);\n\t};\n\tlet others = prior.filter(theirs);\n\tlet mine = prior.filter(run => !theirs(run)).map(run =>\n\t\tknown.get(run.id) === session || ENDED_RUN[run.status] ? run : stopped(run, at)\n\t);\n\tlet own = mergeRuns(mine, runs?.cards, at);\n\tif (releasing) own = mergeRuns(own, undefined, at);\n\tlet fresh = (runs?.cards ?? []).some(run => !before.has(run.id));\n\tlet cards = [...others.filter(run => fresh ? !ENDED_RUN[run.status] : true), ...own];\n\tlet position = (run: Wire.Run) => {\n\t\tlet index = prior.findIndex(value => value.id === run.id);\n\t\treturn index < 0 ? prior.length : index;\n\t};\n\tcards.sort((a, b) => position(a) - position(b));\n\t// A new run replaces ended cards, including ones this report has just stopped; those still\n\t// get their one finish message.\n\tlet shown = new Set(cards.map(run => run.id));\n\tlet replaced = mine.filter(run => !shown.has(run.id));\n\tlet finished: Wire.Entry[] = [];\n\tfor (let run of [...cards, ...replaced]) {\n\t\tlet ended = ENDED_RUN[run.status];\n\t\tlet previous = before.get(run.id);\n\t\tif (!ended || (previous && ENDED_RUN[previous])) continue;\n\t\tlet minutes = Math.max(1, Math.round(((run.ended ?? run.updated) - run.started) / 60));\n\t\tfinished.push({\n\t\t\tid: ulid(),\n\t\t\tauthor: { kind: \"system\" },\n\t\t\ttext: `${run.name} ${ended} after ${minutes} min.`,\n\t\t\tts: now(),\n\t\t});\n\t}\n\tlet next = cards.length ? cards : undefined;\n\ttry {\n\t\tawait context.persist(() => ({ entries: [...chat.entries, ...finished], runs: next }));\n\t} catch (err) {\n\t\tconsole.error(\"[chat] storing workflow runs failed:\", err);\n\t\tif (releasing) unsaved.delete(session);\n\t\telse if (runs) unsaved.set(session, runs);\n\t\treturn;\n\t}\n\tunsaved.delete(session);\n\tchat.entries.push(...finished);\n\tchat.runs = next;\n\tfor (let entry of finished) announce(server, room, entry);\n\tstate(chat, server, room);\n}\n\n/**\n * Keep a Planner session that still owns workflow runs instead of destroying\n * it with its turn: the runs belong to the session, and the next turn reuses\n * it so the Planner can still see and steer them. It is let go once every run\n * has finished, when its owner binding ends, or when the chat closes.\n */\nfunction retain(\n\tcontext: Room,\n\topened: { session: PlannerSession; binding: ActiveOwnerBinding },\n): boolean {\n\tlet { chat } = context;\n\tlet runs = opened.session.runs?.();\n\tif (chat.retained && chat.retained.session !== opened.session) return false;\n\tif (!runs || opened.binding.signal.aborted) return false;\n\tif (!runs.active.length && !runs.paused.length) {\n\t\tvoid publishRuns(context, opened.session, runs);\n\t\treturn false;\n\t}\n\tlet report = (next: typeof runs) => publishRuns(context, opened.session, next);\n\tif (!chat.retained) {\n\t\tlet unhold = context.hold?.();\n\t\tlet stopWatching = opened.session.watchRuns?.(next => {\n\t\t\tif (chat.retained?.session !== opened.session) return;\n\t\t\tvoid report(next);\n\t\t\tif (next.active.length || next.paused.length) return;\n\t\t\tlet releaseWhenIdle = async () => {\n\t\t\t\tif (chat.busy) await chat.running;\n\t\t\t\tif (chat.busy || chat.retained?.session !== opened.session) return;\n\t\t\t\tlet current = opened.session.runs?.();\n\t\t\t\tif (!current || current.active.length || current.paused.length) return;\n\t\t\t\tawait chat.retained.release();\n\t\t\t};\n\t\t\tvoid releaseWhenIdle().catch(err =>\n\t\t\t\tconsole.error(\"[chat] releasing completed workflow session failed:\", err)\n\t\t\t);\n\t\t});\n\t\tlet released: Promise | undefined;\n\t\tlet retained: Retained = {\n\t\t\t...opened,\n\t\t\trelease: () =>\n\t\t\t\treleased ??= (async () => {\n\t\t\t\t\tif (chat.retained === retained) chat.retained = undefined;\n\t\t\t\t\tstopWatching?.();\n\t\t\t\t\topened.binding.signal.removeEventListener(\"abort\", ended);\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait opened.session.destroy();\n\t\t\t\t\t} finally {\n\t\t\t\t\t\topened.binding.release();\n\t\t\t\t\t\tunhold?.();\n\t\t\t\t\t\tif (chat.agent === opened.session) {\n\t\t\t\t\t\t\tchat.agent = undefined;\n\t\t\t\t\t\t\tif (!chat.busy) chat.owner = undefined;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tawait publishing.get(chat);\n\t\t\t\t\t\tawait publishRuns(context, opened.session, unsaved.get(opened.session), true);\n\t\t\t\t\t\tgone.add(opened.session);\n\t\t\t\t\t}\n\t\t\t\t})(),\n\t\t};\n\t\tlet ended = () => void retained.release();\n\t\topened.binding.signal.addEventListener(\"abort\", ended, { once: true });\n\t\tchat.retained = retained;\n\t}\n\tvoid report(runs);\n\treturn true;\n}\n\nfunction currentMemberRequest(chat: Chat): ActiveMemberRequest | undefined {\n\tlet active = chat.activeRequest;\n\tif (\n\t\t!active || chat.closed || !chat.busy || chat.lifecycle !== active.lifecycle\n\t\t|| chat.turn?.id !== active.turnId || !active.userId\n\t) return undefined;\n\tlet entry = chat.entries.find(value => value.id === active.entryId);\n\tif (\n\t\tentry?.author.kind !== \"member\" || entry.author.handle !== active.handle\n\t\t|| entry.text !== active.text\n\t) return undefined;\n\treturn active;\n}\n\nexport function documentRoom(context: Room): DocumentRoom {\n\tlet { chat, plan, room, server } = context;\n\treturn {\n\t\tinvestigations: context.investigations,\n\t\tid: room,\n\t\tplan,\n\t\tserver,\n\t\tpublish: mutation => Service.publish(plan, server, room, mutation, { agent: true }),\n\t\tpersist: context.persist,\n\t\texclusive: action => Service.exclusive(plan, action),\n\t\tanchors: () => Service.anchors(plan, server, room),\n\t\tchanges: found => Service.changes(plan, server, room, found),\n\t\tjobs: context.jobs,\n\t\tcurrentMemberRequest: () => currentMemberRequest(chat),\n\t\treadReference: async (id, repositoryId) => {\n\t\t\tlet reference = chat.referenceCache.get(id);\n\t\t\tif (!reference) throw new Error(\"reference is not available in this Planner session\");\n\t\t\tif (!context.references) throw new Error(\"chat references are unavailable\");\n\t\t\treturn context.references.read({\n\t\t\t\tchannelId: room,\n\t\t\t\trepositoryId,\n\t\t\t\treference,\n\t\t\t});\n\t\t},\n\t\tcreateResearch: async _question => {\n\t\t\tlet active = currentMemberRequest(chat);\n\t\t\tif (!active) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t\"research workspaces require the explicit member message driving the current turn\",\n\t\t\t\t);\n\t\t\t}\n\t\t\tlet createResearch = context.createResearch;\n\t\t\tif (!createResearch) throw new Error(\"research workspaces are unavailable\");\n\t\t\treturn createResearch({\n\t\t\t\tentryId: active.entryId,\n\t\t\t\tuserId: active.userId,\n\t\t\t\thandle: active.handle,\n\t\t\t\ttext: active.text,\n\t\t\t\tquestion: active.text,\n\t\t\t});\n\t\t},\n\t};\n}\n\nexport function retainReferences(chat: Chat, references: Wire.Reference[]): void {\n\tfor (let reference of references) {\n\t\tchat.referenceCache.delete(reference.id);\n\t\tchat.referenceCache.set(reference.id, reference);\n\t\twhile (chat.referenceCache.size > MAX_SESSION_REFERENCES) {\n\t\t\tlet oldest = chat.referenceCache.keys().next().value;\n\t\t\tif (typeof oldest !== \"string\") break;\n\t\t\tchat.referenceCache.delete(oldest);\n\t\t}\n\t}\n}\n\nexport function sessionBootstrap(\n\tchat: Chat,\n\tcursor: number,\n\tsummary: string,\n\tcurrentEntryId?: string,\n\tcurrentReferences: Wire.Reference[] = [],\n): string | undefined {\n\tlet start = Number.isSafeInteger(cursor) && cursor >= 0 && cursor <= chat.entries.length\n\t\t? cursor\n\t\t: 0;\n\tlet candidates = chat.entries.slice(start)\n\t\t.filter(entry => entry.id !== currentEntryId)\n\t\t.slice(-100);\n\tlet allReferenceIds = new Set(\n\t\tcandidates.flatMap(entry => entry.references?.map(reference => reference.id) ?? []),\n\t);\n\tlet line = (entry: Wire.Entry, readable: Set) => {\n\t\tlet speaker = entry.author.kind === \"member\"\n\t\t\t? `@${entry.author.handle}`\n\t\t\t: entry.author.kind === \"agent\"\n\t\t\t? \"Planner\"\n\t\t\t: \"System\";\n\t\treturn `${speaker}: ${annotatedText(entry.text, entry.references, readable)}`;\n\t};\n\tlet selected: Wire.Entry[] = [];\n\tlet used = 0;\n\tlet partial = false;\n\tfor (let entry of candidates.toReversed()) {\n\t\tlet rendered = line(entry, allReferenceIds);\n\t\tlet separator = selected.length > 0 ? 1 : 0;\n\t\tif (used + separator + rendered.length > 50_000) {\n\t\t\tif (selected.length === 0) {\n\t\t\t\tselected.unshift(entry);\n\t\t\t\tpartial = true;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tselected.unshift(entry);\n\t\tused += separator + rendered.length;\n\t}\n\tlet selectedIds = new Set(selected.map(entry => entry.id));\n\tlet remainingBackscroll = chat.backscroll.filter(said =>\n\t\t!said.entryId || !selectedIds.has(said.entryId)\n\t);\n\tchat.referenceCache.clear();\n\tretainReferences(chat, selected.flatMap(entry => entry.references ?? []));\n\tretainReferences(chat, [\n\t\t...remainingBackscroll.flatMap(said => said.references ?? []),\n\t\t...currentReferences,\n\t]);\n\tlet readable = new Set(chat.referenceCache.keys());\n\tlet lines = selected.map(entry => line(entry, readable));\n\tif (partial && lines[0]) lines[0] = lines[0].slice(-50_000);\n\tchat.bootstrapEntries = new Set(selected.map(entry => entry.id));\n\tlet transcript = lines.join(\"\\n\");\n\tif (!transcript && !summary) return undefined;\n\tlet durableIds = new Set(\n\t\tselected.flatMap(entry => entry.references?.map(reference => reference.id) ?? []),\n\t);\n\tlet catalog = referenceCatalog(\n\t\t[...chat.referenceCache.values()].filter(reference => durableIds.has(reference.id)),\n\t);\n\treturn [\n\t\t\"A fresh Planner session starts for each turn.\",\n\t\tsummary ? `Earlier durable summary:\\n${summary}` : \"\",\n\t\ttranscript ? `Durable conversation context follows:\\n${transcript}` : \"\",\n\t\tcatalog ?? \"\",\n\t].filter(Boolean).join(\"\\n\\n\");\n}\n\nexport function consumeBootstrapBackscroll(chat: Chat): void {\n\tlet entries = chat.bootstrapEntries;\n\tchat.bootstrapEntries = undefined;\n\tif (!entries?.size) return;\n\tchat.backscroll = chat.backscroll.filter(said => !said.entryId || !entries.has(said.entryId));\n}\n\nasync function repositorySession(\n\tcontext: Room,\n\tclaimantSessionId: string | undefined,\n\tcurrentEntryId?: string,\n\tcurrentReferences: Wire.Reference[] = [],\n): Promise<{ session: PlannerSession; binding: ActiveOwnerBinding }> {\n\tlet retained = context.chat.retained;\n\t// A background job keeps its isolated session: it never borrows or ends the retained Planner.\n\tif (retained && !context.chat.job) {\n\t\tif (!retained.binding.signal.aborted && await retained.binding.revalidate()) {\n\t\t\tcontext.chat.agent = retained.session;\n\t\t\treturn { session: retained.session, binding: retained.binding };\n\t\t}\n\t\tawait retained.release();\n\t}\n\tlet { ownership, owner, repository } = await resolveOwner(\n\t\tcontext.auth,\n\t\tcontext.repository,\n\t\tcontext.room,\n\t\tclaimantSessionId,\n\t);\n\tif (context.ownerAvailable) void context.ownerAvailable().catch(() => {});\n\tlet { chat, auth } = context;\n\tlet lifecycle = chat.lifecycle;\n\tlet ownerSessionId = ownership.ownerSessionId!;\n\tlet openingOwner = {\n\t\tsessionId: ownerSessionId,\n\t\tgeneration: ownership.generation,\n\t\trevision: owner.access.revision,\n\t};\n\tchat.openingOwner = openingOwner;\n\tlet binding: ActiveOwnerBinding | undefined;\n\tlet opened: PlannerSession | undefined;\n\ttry {\n\t\tbinding = await context.activeOwner?.();\n\t\tif (\n\t\t\t!binding || binding.ownerSessionId !== ownerSessionId\n\t\t\t|| binding.ownerGeneration !== ownership.generation\n\t\t\t|| binding.credentialRevision !== owner.access.revision\n\t\t\t|| binding.repository.id !== repository.id\n\t\t\t|| chat.lifecycle !== lifecycle || chat.openingOwner !== openingOwner\n\t\t) throw new Error(\"The Planner owner changed while opening. Try again.\");\n\t\tawait auth.storage.channels.updateAgentContext({\n\t\t\tchannelId: context.room,\n\t\t\townerSessionId,\n\t\t\tgeneration: ownership.generation,\n\t\t\tsummary: ownership.summary,\n\t\t\ttranscriptCursor: ownership.transcriptCursor,\n\t\t\tstatus: \"ready\",\n\t\t\tnow: new Date(),\n\t\t});\n\t\tchat.referenceCache.clear();\n\t\tlet bootstrap = sessionBootstrap(\n\t\t\tchat,\n\t\t\townership.transcriptCursor,\n\t\t\townership.summary,\n\t\t\tcurrentEntryId,\n\t\t\tcurrentReferences,\n\t\t);\n\t\tlet open = context.openPlannerSession\n\t\t\t?? (await import(\"../harness/session\")).openPlannerSession;\n\t\tlet result = await open(binding, {\n\t\t\troom: documentRoom(context),\n\t\t\trepository,\n\t\t\tinstructions: workspace =>\n\t\t\t\tplannerInstructions(\n\t\t\t\t\t`${repository.owner}/${repository.name}`,\n\t\t\t\t\tbootstrap,\n\t\t\t\t\tworkspace,\n\t\t\t\t),\n\t\t\tmodel: context.config.model,\n\t\t\tharness: context.config.harness,\n\t\t});\n\t\tif (!result.ok) throw new Error(`Planner session unavailable (${result.error.kind})`);\n\t\topened = result.value;\n\t\tif (\n\t\t\tchat.lifecycle !== lifecycle || chat.openingOwner !== openingOwner\n\t\t\t|| binding.signal.aborted || !await binding.revalidate()\n\t\t) throw new Error(\"The Planner session changed while opening. Try again.\");\n\t\tchat.agent = opened;\n\t\tchat.owner = openingOwner;\n\t\tif (!chat.job) consumeBootstrapBackscroll(chat);\n\t\telse chat.bootstrapEntries = undefined;\n\t\treturn { session: opened, binding };\n\t} catch (err) {\n\t\tawait opened?.destroy();\n\t\tbinding?.release();\n\t\tchat.bootstrapEntries = undefined;\n\t\tawait auth.storage.channels.updateAgentContext({\n\t\t\tchannelId: context.room,\n\t\t\townerSessionId,\n\t\t\tgeneration: ownership.generation,\n\t\t\tsummary: ownership.summary,\n\t\t\ttranscriptCursor: ownership.transcriptCursor,\n\t\t\tstatus: \"unavailable\",\n\t\t\tnow: new Date(),\n\t\t}).catch(() => {});\n\t\tthrow err;\n\t} finally {\n\t\tif (chat.openingOwner === openingOwner) chat.openingOwner = undefined;\n\t}\n}\n\n/**\n * The channel's Planner owner, claimed for the claimant when it has none.\n * Without a claimant only an owner the channel already has will do.\n */\nexport async function resolveOwner(\n\tauth: HostedAuth,\n\trepository: HostedRepository,\n\tchannelId: string,\n\tclaimantSessionId: string | undefined,\n) {\n\tlet ownership = claimantSessionId\n\t\t? await auth.storage.channels.claimAgentOwner(channelId, claimantSessionId, new Date())\n\t\t: (await auth.storage.channels.readAgent(channelId, new Date()))?.agent;\n\tlet ownerSessionId = ownership?.ownerSessionId;\n\tif (!ownership || !ownerSessionId) {\n\t\tthrow new Error(\"This channel's Copilot owner is unavailable.\");\n\t}\n\tlet owner = await auth.sessions.resolve(ownerSessionId);\n\tif (!owner) {\n\t\tthrow new Error(\"The Copilot owner must sign in again or reset this channel's agent.\");\n\t}\n\tlet checked = await auth.sessions.use(\n\t\towner,\n\t\ttoken => auth.github.repositoryAccess(token, repository.owner, repository.name),\n\t);\n\towner = checked.authenticated;\n\tlet current = checked.value;\n\tif (\n\t\t!current\n\t\t|| current.id !== repository.id\n\t\t|| (!current.permissions.push && !current.permissions.admin)\n\t) throw new Error(\"The Copilot owner no longer has repository write access.\");\n\treturn { ownership, owner, repository };\n}\n\n/**\n * Finish anything left mid-sentence.\n *\n * A message is normally completed by `assistant.message`, which arrives at the\n * end of a stream. An aborted or failed turn never sends one, so without this\n * the entry keeps its streaming flag and every client goes on drawing a caret\n * after a message that will never be added to.\n */\nfunction settle(chat: Chat, server: Server, room: string, stopped: boolean): void {\n\tfor (let entry of chat.entries) {\n\t\tlet running = entry.tools?.filter(tool => tool.status === \"running\");\n\t\tif (!entry.streaming && !running?.length) continue;\n\t\tfor (let activity of running ?? []) {\n\t\t\tlet started = chat.timings.get(activity.id) ?? activity.startedAt;\n\t\t\tlet finished: Wire.Activity = {\n\t\t\t\t...activity,\n\t\t\t\tstatus: \"failed\",\n\t\t\t\tresult: stopped ? \"Turn stopped.\" : \"Turn ended without a result.\",\n\t\t\t\t...(started ? { took: Date.now() - started } : {}),\n\t\t\t};\n\t\t\tObject.assign(activity, finished);\n\t\t\tbroadcast(server, room, { kind: \"chat:tool\", ts: 0, entry: entry.id, activity: finished });\n\t\t}\n\t\tdelete entry.streaming;\n\t\tannounce(server, room, entry);\n\t}\n\tchat.timings.clear();\n}\n\n/** Run one turn, then drain whatever queued up behind it. */\nasync function run(\n\tcontext: Room,\n\thandle: string,\n\ttext: string,\n\tthread: string | undefined,\n\tclaimantSessionId: string | undefined,\n\treserved = false,\n\tmember?: MemberRequest,\n\treferences: Wire.Reference[] = [],\n\tjobTurn?: JobTurn,\n): Promise {\n\tlet { chat, plan, room, server } = context;\n\tif (chat.closed) {\n\t\tif (jobTurn) finishJob(jobTurn, { status: \"failed\", reason: \"The document closed.\" });\n\t\treturn;\n\t}\n\n\tif (!reserved) {\n\t\tchat.busy = true;\n\t\tchat.turn = begin(handle, chat.entries.length);\n\t\tchat.acting = thread;\n\t\t(jobTurn ? jobState : state)(chat, server, room);\n\t} else chat.acting = thread;\n\n\tchat.activeRequest = member && chat.turn\n\t\t? {\n\t\t\tentryId: member.entryId,\n\t\t\tuserId: member.userId,\n\t\t\thandle,\n\t\t\ttext,\n\t\t\tclaimantSessionId,\n\t\t\tturnId: chat.turn.id,\n\t\t\tlifecycle: chat.lifecycle,\n\t\t}\n\t\t: undefined;\n\tchat.messageIds = new Map();\n\tif (jobTurn) {\n\t\tchat.job = jobTurn.job;\n\t\tchat.jobOutput = undefined;\n\t\tchat.jobFailures = 0;\n\t\tchat.jobFailureCode = undefined;\n\t\tchat.jobCalls = new Map();\n\t}\n\tlet sendStarted = false;\n\tlet outcome: JobOutcome | undefined;\n\tlet persistenceError: unknown;\n\tlet releaseJobAbort: (() => void) | undefined;\n\n\tlet opened: { session: PlannerSession; binding: ActiveOwnerBinding } | undefined;\n\tlet turnController = new AbortController();\n\tchat.turnController = turnController;\n\tlet held = jobTurn ? chat.retained : undefined;\n\tlet heldOwner = chat.owner;\n\tlet heldReferences = held ? new Map(chat.referenceCache) : undefined;\n\ttry {\n\t\topened = await repositorySession(context, claimantSessionId, member?.entryId, references);\n\t\tif (chat.agent !== opened.session || turnController.signal.aborted) {\n\t\t\tthrow new Error(\"The Planner session changed before the turn started. Try again.\");\n\t\t}\n\t\tchat.jobToolNames = jobTurn\n\t\t\t? new Set(opened.session.activeTools ?? PLANNER_TOOL_NAMES)\n\t\t\t: undefined;\n\t\tlet prompt: string;\n\t\tif (jobTurn) {\n\t\t\tprompt = jobTurn.prompt;\n\t\t} else {\n\t\t\t// Drained rather than copied: what the agent has been told once should\n\t\t\t// not arrive again on the next turn.\n\t\t\tlet backscroll = chat.backscroll;\n\t\t\tchat.backscroll = [];\n\t\t\tlet promptReferences = [\n\t\t\t\t...backscroll.flatMap(said => said.references ?? []),\n\t\t\t\t...references,\n\t\t\t];\n\t\t\tretainReferences(chat, promptReferences);\n\t\t\tlet available = promptReferences.filter(reference => chat.referenceCache.has(reference.id));\n\t\t\tprompt = compose(backscroll, handle, text, references, available, !!context.invokedBy);\n\t\t}\n\t\tsendStarted = true;\n\t\tif (!jobTurn) {\n\t\t\tchat.toolFinished = (id, output, success) => {\n\t\t\t\tif (!turnController.signal.aborted) finished(context, id, output, success);\n\t\t\t};\n\t\t\tchat.toolProgress = (id, output) => progressed(context, id, output);\n\t\t}\n\t\tlet signal = AbortSignal.any([opened.binding.signal, turnController.signal]);\n\t\tif (jobTurn) releaseJobAbort = watchJobAbort(chat, jobTurn, signal);\n\t\tlet result = await opened.session.stream(prompt, signal);\n\t\tfor await (let part of result.fullStream) {\n\t\t\tif (turnController.signal.aborted) break;\n\t\t\ttranslate(context, part);\n\t\t}\n\t\tif (jobTurn && chat.closed) throw new Error(\"The document closed.\");\n\t\tif (chat.interruption) throw new Error(chat.interruption);\n\t\tif (jobTurn && turnController.signal.aborted) throw new Error(\"The Planner turn was stopped.\");\n\t\tif (jobTurn) {\n\t\t\toutcome = chat.jobOutput === undefined\n\t\t\t\t? {\n\t\t\t\t\tstatus: \"failed\",\n\t\t\t\t\treason: chat.jobFailureCode\n\t\t\t\t\t\t?? `The Planner ended without calling ${JOB_TOOLS[jobTurn.job.kind]}.`,\n\t\t\t\t}\n\t\t\t\t: { status: \"done\", output: chat.jobOutput };\n\t\t}\n\t} catch (err) {\n\t\tconsole.error(\"[chat] turn failed:\", err);\n\t\tif (jobTurn) {\n\t\t\toutcome = chat.closed\n\t\t\t\t? { status: \"failed\", reason: \"The document closed.\" }\n\t\t\t\t: {\n\t\t\t\t\tstatus: sendStarted || chat.interruption ? \"failed\" : \"skipped\",\n\t\t\t\t\treason: jobReason(err),\n\t\t\t\t};\n\t\t} else if (!chat.closed && (!turnController.signal.aborted || chat.interruption)) {\n\t\t\tsay(chat, server, room, {\n\t\t\t\tid: ulid(),\n\t\t\t\tauthor: { kind: \"system\" },\n\t\t\t\ttext: err instanceof Error ? err.message : \"The agent could not be reached.\",\n\t\t\t\tts: now(),\n\t\t\t});\n\t\t}\n\t\tchat.interruption = undefined;\n\t} finally {\n\t\treleaseJobAbort?.();\n\t\tchat.activeRequest = undefined;\n\t\tchat.turnController = undefined;\n\t\tchat.toolFinished = undefined;\n\t\tchat.toolProgress = undefined;\n\t\tlet kept = false;\n\t\ttry {\n\t\t\tif (opened && !chat.closed && !jobTurn) kept = retain(context, opened);\n\t\t\tif (!kept) {\n\t\t\t\tif (!jobTurn && chat.retained?.session === opened?.session) await chat.retained?.release();\n\t\t\t\telse await opened?.session.destroy();\n\t\t\t}\n\t\t} catch (err) {\n\t\t\tconsole.error(\"[chat] could not close a finished turn:\", err);\n\t\t\tif (jobTurn) persistenceError = err;\n\t\t\telse {\n\t\t\t\t// Fence late tool work, then keep transcript persistence and queue cleanup reachable.\n\t\t\t\tlet stopped = turnController.signal.aborted;\n\t\t\t\tturnController.abort();\n\t\t\t\tif (!stopped && !chat.closed) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tsay(chat, server, room, {\n\t\t\t\t\t\t\tid: ulid(),\n\t\t\t\t\t\t\tauthor: { kind: \"system\" },\n\t\t\t\t\t\t\ttext: \"The Planner session could not close cleanly. Try again.\",\n\t\t\t\t\t\t\tts: now(),\n\t\t\t\t\t\t});\n\t\t\t\t\t} catch (noticeError) {\n\t\t\t\t\t\tconsole.error(\"[chat] could not announce a failed turn:\", noticeError);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} finally {\n\t\t\tif (!kept) {\n\t\t\t\topened?.binding.release();\n\t\t\t\tif (chat.agent === opened?.session) chat.agent = undefined;\n\t\t\t\tchat.owner = undefined;\n\t\t\t\t// The job's own session briefly stood in for the retained one; hand it back,\n\t\t\t\t// with the references the retained Planner can read.\n\t\t\t\tif (held && chat.retained === held) {\n\t\t\t\t\tchat.agent = held.session;\n\t\t\t\t\tchat.owner = heldOwner;\n\t\t\t\t\tif (heldReferences) chat.referenceCache = heldReferences;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tchat.messageIds = undefined;\n\t\tchat.writing = undefined;\n\t\tchat.tooling = undefined;\n\t\tsettle(chat, server, room, turnController.signal.aborted);\n\t\tif (jobTurn) {\n\t\t\tchat.job = undefined;\n\t\t\tchat.jobOutput = undefined;\n\t\t\tchat.jobFailures = undefined;\n\t\t\tchat.jobFailureCode = undefined;\n\t\t\tchat.jobCalls = undefined;\n\t\t}\n\t\tchat.jobToolNames = undefined;\n\t\ttry {\n\t\t\tif (!chat.closed) await context.persist();\n\t\t} catch (err) {\n\t\t\tpersistenceError = err;\n\t\t\tconsole.error(\"[chat] could not save a finished turn:\", err);\n\t\t}\n\t\tif (jobTurn) {\n\t\t\tif (chat.closed) outcome = { status: \"failed\", reason: \"The document closed.\" };\n\t\t\telse if (persistenceError) {\n\t\t\t\toutcome = { status: \"failed\", reason: jobReason(persistenceError) };\n\t\t\t} else if (chat.interruption) {\n\t\t\t\toutcome = { status: \"failed\", reason: jobReason(chat.interruption) };\n\t\t\t}\n\t\t}\n\n\t\t/*\n\t\t * The agent's cursor outlives the turn by a moment.\n\t\t *\n\t\t * Somebody who looks over just as it finishes should still see where it\n\t\t * got to, and a caret that vanished on the same tick as the last token\n\t\t * would deny them that. Restarted rather than stacked: a queued turn\n\t\t * starting inside the linger must cancel this, or it would take down a\n\t\t * cursor the next turn had just placed.\n\t\t */\n\t\tclearTimeout(chat.lingering);\n\t\tif (!chat.closed) {\n\t\t\tchat.lingering = setTimeout(() => {\n\t\t\t\tchat.lingering = undefined;\n\t\t\t\tService.release(plan, server, room);\n\t\t\t}, LINGER_MS);\n\t\t}\n\t}\n\n\tif (persistenceError) {\n\t\tstopAfterPersistenceFailure(chat, server, room);\n\t}\n\tif (jobTurn) {\n\t\tfinishJob(jobTurn, outcome ?? { status: \"failed\", reason: \"The Planner turn ended.\" });\n\t}\n\n\tif (chat.closed) return;\n\tlet next = pending(chat);\n\twhile (next) {\n\t\tif (next.job) chat.handoffJob = next.job;\n\t\ttry {\n\t\t\tawait context.persist();\n\t\t} catch (err) {\n\t\t\tif (chat.handoffJob === next.job) chat.handoffJob = undefined;\n\t\t\tconsole.error(\"[chat] could not save a queued turn:\", err);\n\t\t\tif (next.job) finishJob(next.job, { status: \"failed\", reason: jobReason(err) });\n\t\t\tstopAfterPersistenceFailure(chat, server, room);\n\t\t\treturn;\n\t\t}\n\t\tif (chat.handoffJob === next.job) chat.handoffJob = undefined;\n\t\tif (chat.closed) {\n\t\t\tif (next.job) finishJob(next.job, { status: \"failed\", reason: \"The document closed.\" });\n\t\t\treturn;\n\t\t}\n\t\tif (next.job?.settled) {\n\t\t\tnext = pending(chat);\n\t\t\tcontinue;\n\t\t}\n\t\t(next.job ? jobQueued : queued)(chat, server, room);\n\t\tlet nextId = next.id;\n\t\tlet entry = next.message ? chat.entries.find(item => item.id === nextId) : undefined;\n\t\tif (entry && !next.posted) announce(server, room, entry);\n\t\tawait run(\n\t\t\t{ ...context, invokedBy: next.invokedBy },\n\t\t\tnext.handle,\n\t\t\tnext.text,\n\t\t\tnext.thread,\n\t\t\tnext.invokedBy ? next.sessionId : next.sessionId ?? context.claimantSessionId,\n\t\t\tfalse,\n\t\t\tnext.message && next.userId ? { entryId: next.id, userId: next.userId } : undefined,\n\t\t\tnext.references,\n\t\t\tnext.job,\n\t\t);\n\t\treturn;\n\t}\n\tchat.busy = false;\n\tchat.turn = undefined;\n\tchat.acting = undefined;\n\t(jobTurn ? jobState : state)(chat, server, room);\n}\n\nfunction startRun(\n\tcontext: Room,\n\thandle: string,\n\ttext: string,\n\tthread: string | undefined,\n\tclaimantSessionId: string | undefined,\n\treserved = false,\n\tmember?: MemberRequest,\n\treferences?: Wire.Reference[],\n\tjobTurn?: JobTurn,\n): void {\n\tif (context.chat.closed) {\n\t\tif (jobTurn) finishJob(jobTurn, { status: \"failed\", reason: \"The document closed.\" });\n\t\treturn;\n\t}\n\tlet running = run(\n\t\tcontext,\n\t\thandle,\n\t\ttext,\n\t\tthread,\n\t\tclaimantSessionId,\n\t\treserved,\n\t\tmember,\n\t\treferences ?? [],\n\t\tjobTurn,\n\t);\n\tcontext.chat.running = running;\n\tvoid running.finally(() => {\n\t\tif (context.chat.running === running) context.chat.running = undefined;\n\t}).catch(() => {});\n}\n\n/**\n * The next queued turn worth running.\n *\n * A turn whose work is already done is dropped rather than run: four accepted\n * comments should not cost four passes over the plan when the agent dealt with\n * all of them in the first. Only something that queued behind a turn can be\n * spent, which is why the question is asked here and not when it was accepted.\n */\nexport function pending(chat: Chat): Waiting | undefined {\n\tlet next = chat.waiting.shift();\n\twhile (next?.spent?.()) next = chat.waiting.shift();\n\tif (next?.message && !next.posted) {\n\t\tlet entry: MemberEntry = {\n\t\t\tid: next.id,\n\t\t\tauthor: { kind: \"member\", handle: next.handle },\n\t\t\ttext: next.text,\n\t\t\tts: now(),\n\t\t\t...(next.references?.length ? { references: next.references } : {}),\n\t\t\t...(next.delivery ? { delivery: next.delivery } : {}),\n\t\t};\n\t\tchat.entries.push(entry);\n\t}\n\treturn next;\n}\n\n/** Project one AI SDK stream part into the shared Conversation. */\nexport function translate(context: Room, part: TextStreamPart): void {\n\tlet { chat, room, server } = context;\n\tif (chat.job || chat.jobToolNames) return translateJob(context, part);\n\tlet ids = chat.messageIds ??= new Map();\n\tswitch (part.type) {\n\t\tcase \"finish\":\n\t\t\tchat.tooling = undefined;\n\t\t\treturn;\n\t\tcase \"text-start\": {\n\t\t\tlet id = ulid();\n\t\t\tids.set(part.id, id);\n\t\t\tchat.writing = id;\n\t\t\tchat.tooling = undefined;\n\t\t\treturn;\n\t\t}\n\t\tcase \"text-delta\": {\n\t\t\tlet id = ids.get(part.id);\n\t\t\tif (!id) {\n\t\t\t\tid = ulid();\n\t\t\t\tids.set(part.id, id);\n\t\t\t}\n\t\t\tlet entry = chat.entries.find(item => item.id === id);\n\t\t\tif (!entry) {\n\t\t\t\tchat.writing = id;\n\t\t\t\tchat.tooling = undefined;\n\t\t\t\tsay(chat, server, room, {\n\t\t\t\t\tid,\n\t\t\t\t\tauthor: { kind: \"agent\" },\n\t\t\t\t\ttext: part.text,\n\t\t\t\t\tts: now(),\n\t\t\t\t\tstreaming: true,\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tentry.text += part.text;\n\t\t\t\tbroadcast(server, room, { kind: \"chat:delta\", ts: 0, id, text: part.text });\n\t\t\t}\n\t\t\tresponded(chat, server, room, part.text);\n\t\t\treturn;\n\t\t}\n\t\tcase \"text-end\": {\n\t\t\tlet id = ids.get(part.id);\n\t\t\tlet entry = chat.entries.find(item => item.id === id);\n\t\t\tif (entry) {\n\t\t\t\tdelete entry.streaming;\n\t\t\t\tannounce(server, room, entry);\n\t\t\t}\n\t\t\tif (chat.writing === id) chat.writing = undefined;\n\t\t\treturn;\n\t\t}\n\t\tcase \"tool-input-start\": {\n\t\t\tif (!permitted(context, part.toolName)) return;\n\t\t\tbegun(chat, part.id);\n\t\t\tpublish(context, {\n\t\t\t\tid: part.id,\n\t\t\t\tname: part.toolName,\n\t\t\t\tstatus: \"running\",\n\t\t\t\tstartedAt: chat.timings.get(part.id),\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\t\tcase \"tool-call\": {\n\t\t\tif (!permitted(context, part.toolName)) return;\n\t\t\tbegun(chat, part.toolCallId);\n\t\t\tpublish(context, {\n\t\t\t\tid: part.toolCallId,\n\t\t\t\tname: part.toolName,\n\t\t\t\tstatus: \"running\",\n\t\t\t\targs: argsText(part.input),\n\t\t\t\tstartedAt: chat.timings.get(part.toolCallId),\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\t\tcase \"tool-result\":\n\t\tcase \"tool-error\":\n\t\tcase \"tool-output-denied\": {\n\t\t\tlet preliminary = part.type === \"tool-result\" && part.preliminary === true;\n\t\t\tlet success = part.type === \"tool-result\";\n\t\t\tlet output = part.type === \"tool-result\"\n\t\t\t\t? part.output\n\t\t\t\t: part.type === \"tool-error\"\n\t\t\t\t? part.error\n\t\t\t\t: \"Refused.\";\n\t\t\tconclude(\n\t\t\t\tcontext,\n\t\t\t\tpart.toolCallId,\n\t\t\t\toutput,\n\t\t\t\tpreliminary ? \"running\" : success ? \"done\" : \"failed\",\n\t\t\t\tsuccess,\n\t\t\t\tpart.type === \"tool-output-denied\",\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t\tcase \"tool-approval-request\":\n\t\t\tchat.interruption = \"Planner tool approval was denied.\";\n\t\t\tchat.turnController?.abort();\n\t\t\treturn;\n\t\tcase \"error\":\n\t\t\tchat.tooling = undefined;\n\t\t\tsay(chat, server, room, {\n\t\t\t\tid: ulid(),\n\t\t\t\tauthor: { kind: \"system\" },\n\t\t\t\ttext: part.error instanceof Error ? part.error.message : String(part.error),\n\t\t\t\tts: now(),\n\t\t\t});\n\t\t\treturn;\n\t}\n}\n\n/**\n * Publish a tool's outcome once.\n *\n * The harness holds a host tool's result until its model step ends, so the\n * tool's own execution reports first and the buffered part finds the row\n * already settled with the real duration.\n */\nfunction conclude(\n\tcontext: Room,\n\tid: string,\n\toutput: unknown,\n\tstatus: Wire.ToolStatus,\n\tsuccess: boolean,\n\trefused = false,\n): void {\n\tlet { chat } = context;\n\tlet name = named(chat, id);\n\tlet existing = tool(chat, id);\n\tif (existing && existing.status !== \"running\") return;\n\tlet started = chat.timings.get(id);\n\tif (status !== \"running\") chat.timings.delete(id);\n\tlet detail = name === \"read_reference\"\n\t\t? success\n\t\t\t? \"Reference content was returned privately to the Planner.\"\n\t\t\t: \"The reference could not be read.\"\n\t\t: outputText(output);\n\tpublish(context, {\n\t\tid,\n\t\tname,\n\t\tstatus,\n\t\t...(refused ? { refused: true as const } : {}),\n\t\t...(started && status !== \"running\" ? { took: Date.now() - started } : {}),\n\t\t...(detail ? { result: detail } : {}),\n\t});\n}\n\n/** Whether the session offers this tool; one it does not offer ends the turn. */\nfunction permitted(context: Room, name: string): boolean {\n\tlet { chat } = context;\n\tif ((chat.agent?.activeTools ?? PLANNER_TOOL_NAMES).includes(name)) return true;\n\tconsole.error(`[chat] boundary failure: inactive tool ${name}`);\n\tchat.interruption = `Planner tool boundary failure: ${name}`;\n\tchat.turnController?.abort();\n\treturn false;\n}\n\nfunction begun(chat: Chat, id: string): void {\n\tif (!chat.timings.has(id)) chat.timings.set(id, Date.now());\n}\n\nfunction publish(context: Room, activity: Wire.Activity): void {\n\tlet { room, server } = context;\n\tbroadcast(server, room, {\n\t\tkind: \"chat:tool\",\n\t\tts: 0,\n\t\tentry: attach(context, activity),\n\t\tactivity,\n\t});\n}\n\n/** A host tool's own execution ended; settle its open row now rather than at step end. */\nexport function finished(context: Room, id: string, output: unknown, success: boolean): void {\n\tif (tool(context.chat, id)?.status !== \"running\") return;\n\tconclude(context, id, output, success ? \"done\" : \"failed\", success);\n}\n\n/** A tool still running reported partial output; show it now. */\nexport function progressed(context: Room, id: string, output: unknown): void {\n\tif (tool(context.chat, id)?.status !== \"running\") return;\n\tconclude(context, id, output, \"running\", true);\n}\n\nfunction tool(chat: Chat, id: string): Wire.Activity | undefined {\n\treturn chat.entries.flatMap(entry => entry.tools ?? []).find(item => item.id === id);\n}\n\n/** What a running tool call was called, from where it was filed. */\nfunction named(chat: Chat, id: string): string {\n\tfor (let entry of chat.entries) {\n\t\tlet found = entry.tools?.find(activity => activity.id === id);\n\t\tif (found) return found.name;\n\t}\n\treturn \"tool\";\n}\n\n/**\n * File a tool call under the message that made it, and say which that was.\n *\n * A tool call that arrives before the agent has said anything — which is most\n * of them, since reading precedes writing — has no message to attach to yet.\n * It gets an entry of its own so the work is visible while it happens rather\n * than appearing retrospectively once the agent finishes talking.\n */\nfunction attach(context: Room, activity: Wire.Activity): string {\n\tlet { chat, room, server } = context;\n\t// Completion can arrive after idle; find its original activity by call id.\n\tlet entry = chat.entries.find(item => item.tools?.some(tool => tool.id === activity.id))\n\t\t?? chat.entries.find(item => item.id === chat.tooling)\n\t\t?? chat.entries.find(item => item.id === chat.writing);\n\tif (entry && !entry.tools?.some(tool => tool.id === activity.id)) chat.tooling = entry.id;\n\n\tif (!entry) {\n\t\tentry = { id: ulid(), author: { kind: \"agent\" }, text: \"\", ts: now(), tools: [] };\n\t\tchat.tooling = entry.id;\n\t\tsay(chat, server, room, entry);\n\t}\n\n\tentry.tools ??= [];\n\tlet existing = entry.tools.findIndex(item => item.id === activity.id);\n\tif (existing >= 0) entry.tools[existing] = { ...entry.tools[existing], ...activity };\n\telse entry.tools.push(activity);\n\treturn entry.id;\n}\n\nexport async function resetAgent(\n\tchat: Chat,\n\tsessionId?: string,\n\trevision?: number,\n\treason?: string,\n): Promise {\n\tlet binding = chat.owner ?? chat.openingOwner;\n\tif (\n\t\t!binding\n\t\t|| (sessionId && binding.sessionId !== sessionId)\n\t\t|| (revision !== undefined && binding.revision !== revision)\n\t) return;\n\tchat.lifecycle++;\n\tchat.activeRequest = undefined;\n\tif (reason && chat.turnController) chat.interruption = reason;\n\tif (chat.job) {\n\t\tchat.job = undefined;\n\t\tchat.jobOutput = undefined;\n\t}\n\tchat.turnController?.abort();\n\tchat.referenceCache.clear();\n\tchat.bootstrapEntries = undefined;\n\tchat.openingOwner = undefined;\n}\n\n/** Let go of the session. The conversation is resumable by id. */\nexport async function close(chat: Chat): Promise {\n\tchat.closed = true;\n\tchat.job = undefined;\n\tchat.jobOutput = undefined;\n\tchat.lifecycle++;\n\tchat.activeRequest = undefined;\n\tfor (let waiting of chat.waiting) {\n\t\tif (waiting.job) finishJob(waiting.job, { status: \"failed\", reason: \"The document closed.\" });\n\t}\n\tif (chat.handoffJob) {\n\t\tfinishJob(chat.handoffJob, { status: \"failed\", reason: \"The document closed.\" });\n\t\tchat.handoffJob = undefined;\n\t}\n\tchat.waiting = [];\n\tchat.turnController?.abort();\n\tchat.referenceCache.clear();\n\tchat.bootstrapEntries = undefined;\n\tchat.openingOwner = undefined;\n\tclearTimeout(chat.lingering);\n\tchat.lingering = undefined;\n\tawait Promise.all([chat.sending, chat.running]);\n\tawait chat.retained?.release();\n}\n","editable",false,"branch","documentNavigation","repo","githubnext/chopin","repoId","7d1a8ac3-35b0-4dea-85d4-06a980f3bada","ownerId","org:89615882","site","nexthub","private","admin","settings","maintainer","triage","starred","stars",0,"watchers","watching","pinned","notify","views",[183,184,185,186,187,188,189,190,191,192,193,194,195],"navigation",{"_55":56,"_139":140,"_141":142,"_143":144,"_145":146,"_147":148,"_149":150},"sources",[],"viewer","meta",{"_131":132,"_133":134,"_135":136,"_43":32,"_137":14,"_138":32,"_49":50,"_51":50},"branches",[74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,14,127,128,129,130],"tags",[70,71,72,73],"cloneUrl","https://git.nexthub.sh/githubnext/chopin.git","color-controls-slice-1","color-controls-slice-2","color-controls-slice-3","color-controls-slice-4","Krzysztof-Cieslak-patch-1","Krzysztof-Cieslak-patch-2","Maggie/app-preview-toolkit","Maggie/ci-playwright-install-timeout","Maggie/collaborative-visual-decision","Maggie/design-audit","Maggie/generic-visual-decision-runtime","Maggie/impeccable-chopin-metadata","Maggie/jev-chat-product","Maggie/jev-composed-assessment","Maggie/native-document-layouts","Maggie/openui-composition-product","Maggie/openui-composition-trial","Maggie/planner-visual-authoring","Maggie/planner-visual-requests","Maggie/visual-selection-eval","artifacts/pr-419-live-preview-20261009","automation/pr-maintenance-state","automation/use-effect/callout-disabled-picker-8cf9e49ba5c09471","automation/use-effect/collaboration-options-ref-4e3a5a08a879a5ae","automation/use-effect/room-workspace-effective-access-a57d40866c71bed0","chore/bun-1.4.2","color-controls","color-controls-plan","comments","design-pr-assets","design/archived-decisions-badge","design/channel-route-remount","design/chat-decision-entry","design/conversation-analysis-markers","design/decision-evidence","design/settled-line-icon","dev/integration","diagram-step-controls","feat/liveapp-frontend-pilot","feat/local-experiments","feat/local-launcher-tracer","fix/autolink-mdx-crash","github-pills/2-pills","github-pills/3-hover-card","maggie/app-preview-toolkit","maggie/ci-playwright-install-timeout","maggie/collaborative-visual-decision","maggie/design-audit","maggie/generic-visual-decision-runtime","maggie/impeccable-chopin-metadata","maggie/jev-composed-assessment","maggie/native-document-layouts","maggie/openui-composition-product","maggie/openui-composition-trial","maggie/planner-visual-authoring","maggie/planner-visual-requests","maggie/visual-selection-eval","plain-text-fence-chrome","tokens/09-copy","wireframes/2-renderer","wireframes/3-planner","description","Let's compose rich plans together","owner","githubnext","section","","head","empty","pins",[165,166,167],"documents",{"_160":161,"_162":163},"code",{"_156":157,"_158":159},"automations",{"_153":154,"_155":-5},"delivery",{"_151":50,"_152":-5},"tag","04zvKQ8QOrDUF8TO1Ovz0Zy8_TT","releases","applications","workflows",3,"deployments","commits",1000,"changes",13,"counts",{"_164":163},"total",11,"issue",{"_168":158,"_170":181,"_15":158,"_172":182,"_53":174,"_175":32,"_176":174,"_177":159},{"_168":178,"_170":179,"_15":178,"_172":180,"_53":174,"_175":32,"_176":174,"_177":50},{"_168":169,"_170":171,"_15":169,"_172":173,"_53":174,"_175":32,"_176":174,"_177":163},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_168":158,"_170":181,"_15":158,"_172":226,"_53":174,"_175":32,"_176":174},{"_168":178,"_170":179,"_15":178,"_172":225,"_53":174,"_175":32,"_176":174},{"_168":169,"_170":171,"_15":169,"_172":224,"_53":174,"_175":32,"_176":174},{"_168":221,"_170":222,"_15":221,"_172":223,"_53":32,"_175":32,"_176":174},{"_168":218,"_170":219,"_15":218,"_172":220,"_53":32,"_175":32,"_176":174},{"_168":153,"_170":216,"_15":145,"_172":217,"_53":32,"_175":32,"_176":174},{"_168":155,"_170":213,"_15":214,"_172":215,"_53":32,"_175":32,"_176":174},{"_168":151,"_170":211,"_15":151,"_172":212,"_53":32,"_175":32,"_176":174},{"_168":207,"_170":208,"_15":209,"_172":210,"_53":32,"_175":32,"_176":174},{"_168":141,"_170":205,"_15":141,"_172":206,"_53":32,"_175":32,"_176":32},{"_168":202,"_170":203,"_15":202,"_172":204,"_53":32,"_175":32,"_176":32},{"_168":199,"_170":200,"_15":199,"_172":201,"_53":32,"_175":32,"_176":32},{"_168":196,"_170":197,"_15":196,"_172":198,"_53":32,"_175":32,"_176":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794436443529,"sidebar","expanded"]