[{"_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",{"_40":41,"_227":-5,"_228":-5,"_229":230},"routes/repo",{"_33":-7,"_34":35,"_36":37,"_38":39,"_40":41,"_42":31,"_43":31,"_44":31,"_45":31,"_46":31,"_47":31,"_48":49,"_50":49,"_51":31,"_52":-7,"_53":-7,"_54":55,"_56":57,"_58":59,"_60":-5,"_61":62,"_63":64,"_65":66,"_67":68},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":14,"_22":23,"_24":-5,"_25":26,"_27":28,"_28":29,"_30":31,"_32":14},"ref","e32db5d484a3d846a2b3d00f28cf42e065d6a55a","path","apps/server/src/comments/service.ts","oid","193fd787d3746bb3dfa5e7ee2b31ffe1b3ae0b69","size",15928,"commit","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","/**\n * Comments, as a room offers them.\n *\n * A thread marks a phrase and collects what people said about it. Accepting one\n * is the room deciding: the thread freezes, a `` goes into the plan,\n * and the agent is asked to revise the prose. Dismissing closes it without the\n * agent.\n *\n * Accepting is two-phase for the same reason answering a questionnaire is — the\n * record and the document both have to change, and nobody may be told it is\n * final until both have. If the document write fails the claim is rolled back\n * and the thread is still open, which every client already knows how to render.\n *\n * Where a thread points is not in these frames. A passage moves whenever the\n * plan does, and `plan:anchors` already carries every such relationship as one\n * authoritative snapshot, so putting it here too would be a second source of\n * truth updated on a different schedule.\n */\n\nimport { limits, ulid } from \"@chopin/dialect\";\n\nimport * as room from \"../plan/room\";\nimport * as Store from \"./store\";\nimport { broadcast, relay, reply, tell } from \"../wire\";\n\nimport * as Chat from \"../chat/service\";\nimport * as Service from \"../plan/service\";\nimport { compose } from \"./prompt\";\n\nimport type { Server } from \"bun\";\n// `Plan` is the room's plan here; the protocol namespace of the same name is\n// aliased so the two cannot be confused at a glance.\nimport type { Comment as Wire, Plan as Wired, Request } from \"@chopin/protocol\";\nimport type { Plan } from \"../plan/service\";\nimport type { Socket, SocketData } from \"../wire\";\n\nexport type { Threads } from \"./store\";\n\nexport const create = Store.create;\n\n/** A comment thread as it is stored beside the plan, so it survives a restart. */\nexport type Record = {\n\tid: string;\n\tstatus: Wire.Status;\n\t/**\n\t * The phrase it marks.\n\t *\n\t * Rebased with the plan and never frozen: an accepted thread keeps its\n\t * prose highlighted, so it has to keep knowing where that prose is.\n\t */\n\tpassage: Wired.Passage;\n\tnotes: Wire.Note[];\n\t/** The prose the agent's revision produced. Absent until it anchors it. */\n\tresult?: Wired.AnchorSet;\n\t/** The marked text as it read when this resolved. Frozen; the passage is not. */\n\tquote?: string;\n\tresolver?: string;\n\t/** Unix seconds. */\n\tat?: number;\n};\n\n/** The thread as clients see it. The passage travels on `plan:anchors`. */\nfunction wire(record: Record): Wire.Thread {\n\treturn {\n\t\tid: record.id,\n\t\tstatus: record.status,\n\t\tnotes: record.notes,\n\t\t...(record.quote !== undefined ? { quote: record.quote } : {}),\n\t\t...(record.resolver ? { resolver: record.resolver } : {}),\n\t\t...(record.at !== undefined ? { at: record.at } : {}),\n\t};\n}\n\n/**\n * What the passage reads as right now.\n *\n * Rebasing is how that question is answered: it resolves the positions and\n * re-cuts the quote from the text they now cover. The rebased passage is kept,\n * because having computed it there is no reason to store the older one. A\n * drifted passage answers with what it last read, which is the best anyone can\n * say about prose that is gone.\n */\nfunction reading(plan: Plan, record: Record): { quote: string; record: Record } {\n\tlet passage = room.rebasePassage(plan.document, record.passage);\n\tlet next: Record = { ...record, passage };\n\tplan.threads.set(record.id, next);\n\treturn { quote: passage.quote, record: next };\n}\n\n// -- relationships ---------------------------------------------------------\n\n/**\n * A thread's relationships, with an entry for one that has never been anchored.\n *\n * An accepted thread with no result is pending: the agent owes a review. An\n * open one is not — there is nothing outstanding until there is a decision.\n */\nexport function anchors(plan: Plan): Wired.ThreadAnchors[] {\n\tlet out: Wired.ThreadAnchors[] = [];\n\n\tfor (let record of plan.threads.values()) {\n\t\t// Dismissed threads are not shown and never reach the agent, so there\n\t\t// is nothing for anyone to point at.\n\t\tif (record.status === \"dismissed\") continue;\n\n\t\tlet accepted = record.status === \"accepted\";\n\t\tout.push({\n\t\t\tthread: record.id,\n\t\t\tsubject: record.passage,\n\t\t\tresult: record.result ?? {\n\t\t\t\tanchors: [],\n\t\t\t\tpending: accepted,\n\t\t\t\t...(accepted ? { reason: \"missing\" as const } : {}),\n\t\t\t},\n\t\t});\n\t}\n\n\treturn out;\n}\n\n/** Bring every thread forward onto the document as it is now. */\nexport function rebase(plan: Plan): void {\n\tfor (let [id, record] of plan.threads) {\n\t\tif (record.status === \"dismissed\") continue;\n\n\t\tlet next: Record = {\n\t\t\t...record,\n\t\t\tpassage: room.rebasePassage(plan.document, record.passage),\n\t\t};\n\n\t\tif (record.result) {\n\t\t\tlet moved = room.rebase(plan.document, record.result.anchors);\n\t\t\tlet lost = moved.some(anchor => anchor.orphaned);\n\t\t\tnext.result = {\n\t\t\t\t...record.result,\n\t\t\t\tanchors: moved,\n\t\t\t\t...(lost ? { pending: true, reason: \"orphaned\" as const } : {}),\n\t\t\t};\n\t\t}\n\n\t\tplan.threads.set(id, next);\n\t}\n}\n\n/**\n * Mark every result as needing review.\n *\n * The passage a decision produced is the thing most likely to have been\n * rewritten, and a link to where it used to be is worse than an admission that\n * nobody has checked.\n */\nexport function invalidate(plan: Plan, reason: Wired.AnchorReason): void {\n\tfor (let [id, record] of plan.threads) {\n\t\tif (record.status !== \"accepted\" || !record.result) continue;\n\t\tplan.threads.set(id, {\n\t\t\t...record,\n\t\t\tresult: { ...record.result, pending: true, reason },\n\t\t});\n\t}\n}\n\n/** Everything the agent still owes a review on. */\nexport function outstanding(plan: Plan): Array<{ thread: string; reason: Wired.AnchorReason }> {\n\tlet out: Array<{ thread: string; reason: Wired.AnchorReason }> = [];\n\n\tfor (let record of plan.threads.values()) {\n\t\tif (record.status !== \"accepted\") continue;\n\t\tif (record.result && !record.result.pending) continue;\n\t\tout.push({ thread: record.id, reason: record.result?.reason ?? \"missing\" });\n\t}\n\n\treturn out;\n}\n\n/** Whether an accepted thread has already been acted on and anchored. */\nexport function applied(plan: Plan, id: string): boolean {\n\tlet record = plan.threads.get(id);\n\treturn !!record?.result && !record.result.pending;\n}\n\n/**\n * Record what a turn wrote as the decision it was asked to act on.\n *\n * The agent is told to say this itself with `anchor_plan`, and when it does\n * that answer is better than this one: it can pick out the two blocks of five\n * that actually came from the decision. But a thread whose result is never\n * anchored points at nothing for good, and the prose it was about is gone by\n * then — rewriting it is what acceptance asked for. So the blocks a turn\n * authored stand in until the agent says otherwise.\n *\n * Not pending: anchors derived from the change itself are as fresh as anchors\n * get. Only applied when nothing trustworthy is already there, so a precise\n * answer from a previous turn is never coarsened by a later guess.\n */\nexport function attribute(plan: Plan, thread: string, blocks: number[]): void {\n\tlet record = plan.threads.get(thread);\n\tif (!record || record.status !== \"accepted\") return;\n\tif (record.result && !record.result.pending) return;\n\tif (blocks.length === 0) return;\n\n\ttry {\n\t\tlet current = room.digests(plan.document);\n\t\tlet anchors: Wired.Anchor[] = [];\n\t\tfor (let index of blocks) {\n\t\t\tlet hash = current[index];\n\t\t\tif (hash) anchors.push(room.anchorAt(plan.document, index, hash));\n\t\t}\n\t\tif (anchors.length === 0) return;\n\n\t\tplan.threads.set(thread, { ...record, result: { anchors, pending: false } });\n\t} catch (err) {\n\t\t// A decision that cannot be pointed at is worse than one pointed at\n\t\t// coarsely, and both are better than a failed edit.\n\t\tconsole.error(`[comments] could not attribute a revision to ${thread}:`, err);\n\t}\n}\n\n/** Record the prose an accepted thread's revision produced. */\nexport function relate(\n\tplan: Plan,\n\tthread: string,\n\tblocks: Array<{ index: number; digest: string }>,\n): string | undefined {\n\tlet record = plan.threads.get(thread);\n\tif (!record) return `no comment thread ${thread}`;\n\tif (record.status !== \"accepted\") return `comment thread ${thread} was not accepted`;\n\n\tlet current = room.digests(plan.document);\n\tlet found: Wired.Anchor[] = [];\n\n\tfor (let block of blocks) {\n\t\tlet hash = current[block.index];\n\t\tif (!hash) return `no block at index ${block.index}`;\n\t\tif (hash !== block.digest) return `block ${block.index} has changed; read the plan again`;\n\t\tfound.push(room.anchorAt(plan.document, block.index, hash));\n\t}\n\n\t// An empty list is a real answer: reviewed, and deliberately related to\n\t// nothing. It is not the same as never having looked.\n\tplan.threads.set(thread, { ...record, result: { anchors: found, pending: false } });\n\treturn undefined;\n}\n\n// -- sockets ---------------------------------------------------------------\n\n/** Every thread worth showing, for somebody who has just arrived. */\nexport function greet(plan: Plan, ws: Socket): void {\n\ttell(ws, {\n\t\tkind: \"comment:sync\",\n\t\tts: 0,\n\t\tthreads: [...plan.threads.values()]\n\t\t\t.filter(record => record.status !== \"dismissed\")\n\t\t\t.map(wire),\n\t});\n}\n\nfunction said(text: string): string | undefined {\n\tlet value = text.trim();\n\tif (!value) return undefined;\n\treturn value.length > limits.MAX_NOTE ? undefined : value;\n}\n\n/** Mark a phrase and say the first thing about it. */\nexport function start(\n\tplan: Plan,\n\tserver: Server,\n\troomId: string,\n\tws: Socket,\n\tmsg: Request,\n): void | Promise {\n\tlet refuse = (reason: \"invalid\" | \"full\", message: string) =>\n\t\treply(ws, msg.rid, { kind: \"comment:start\", ts: 0, ok: false, reason, message });\n\n\tlet full = Store.room(plan.threads);\n\tif (full) return refuse(\"full\", full.message);\n\n\tlet text = said(msg.text);\n\tif (!text) return refuse(\"invalid\", \"A comment needs something in it.\");\n\n\tlet passage: Wired.Passage;\n\ttry {\n\t\tpassage = room.passageAt(plan.document, msg.blocks, msg.quote, msg.offset, msg.length);\n\t} catch (err) {\n\t\treturn refuse(\"invalid\", err instanceof Error ? err.message : \"could not mark that passage\");\n\t}\n\n\tlet record: Record = {\n\t\tid: ulid(),\n\t\tstatus: \"open\",\n\t\tpassage,\n\t\tnotes: [Store.note(ws.data.handle, text)],\n\t};\n\tplan.threads.set(record.id, record);\n\tlet finish = () => {\n\t\treply(ws, msg.rid, { kind: \"comment:start\", ts: 0, ok: true, thread: wire(record) });\n\t\trelay(ws, { kind: \"comment:opened\", ts: 0, thread: wire(record) });\n\t\t// The passage travels separately, and a card with nothing to highlight is\n\t\t// what the room sees until it arrives — so it goes now, not on the next edit.\n\t\tService.anchors(plan, server, roomId);\n\t};\n\treturn Service.persist(plan).then(finish);\n}\n\n/** Add to an open thread. */\nexport function respond(\n\tplan: Plan,\n\tws: Socket,\n\tmsg: Request,\n): void | Promise {\n\tlet text = said(msg.text);\n\tif (!text) {\n\t\treturn reply(ws, msg.rid, {\n\t\t\tkind: \"comment:reply\",\n\t\t\tts: 0,\n\t\t\tid: msg.id,\n\t\t\tok: false,\n\t\t\treason: \"invalid\",\n\t\t\tmessage: \"A comment needs something in it.\",\n\t\t});\n\t}\n\n\tlet outcome = Store.reply(plan.comments, plan.threads, msg.id, ws.data.handle, text);\n\tif (!outcome.ok) {\n\t\treturn reply(ws, msg.rid, { kind: \"comment:reply\", ts: 0, id: msg.id, ...outcome });\n\t}\n\n\tStore.typing(plan.comments, msg.id, ws.data.client, ws.data.handle, false);\n\tlet finish = () => {\n\t\treply(ws, msg.rid, { kind: \"comment:reply\", ts: 0, id: msg.id, ok: true, note: outcome.note });\n\t\trelay(ws, { kind: \"comment:said\", ts: 0, id: msg.id, note: outcome.note });\n\t};\n\treturn Service.persist(plan).then(finish);\n}\n\n/** Somebody is, or has stopped, writing a reply. */\nexport function typing(plan: Plan, ws: Socket, msg: Wire.Typing.Input): void {\n\tStore.typing(plan.comments, msg.id, ws.data.client, ws.data.handle, msg.writing);\n\trelay(ws, {\n\t\tkind: \"comment:typing\",\n\t\tts: 0,\n\t\tid: msg.id,\n\t\twriting: msg.writing,\n\t\tclient: ws.data.client,\n\t\thandle: ws.data.handle,\n\t});\n}\n\n/** Drop a departed member from every thread they were writing in. */\nexport function away(plan: Plan, ws: Socket): void {\n\tStore.away(plan.comments, ws.data.client);\n}\n\ntype Resolution = \"accept\" | \"dismiss\";\n\n/** Both resolutions answer with the same shape; only the kind differs. */\ntype Settled =\n\t| { ok: true; resolver: string; at: number }\n\t| { ok: false; reason: \"missing\" | \"resolving\" | \"invalid\"; message: string }\n\t| { ok: false; reason: \"resolved\"; status: Wire.Status; resolver: string };\n\nfunction answer(ws: Socket, rid: string, kind: Resolution, id: string, body: Settled): void {\n\tif (kind === \"accept\") {\n\t\treturn reply(ws, rid, { kind: \"comment:accept\", ts: 0, id, ...body });\n\t}\n\treply(ws, rid, { kind: \"comment:dismiss\", ts: 0, id, ...body });\n}\n\n/**\n * Close a thread.\n *\n * Accepting has a durable half — the `` node — so it is claimed\n * first, written, and only then committed. Dismissing has none: nothing about\n * the plan changes, so there is nothing to roll back.\n */\nasync function settle(\n\tcontext: Chat.Room,\n\tws: Socket,\n\tmsg: Request,\n\tkind: Resolution,\n): Promise {\n\tlet { plan, room: roomId, server } = context;\n\n\tlet held = plan.threads.get(msg.id);\n\t// Read the passage before claiming: a decision records the prose as it read\n\t// when somebody decided about it, not as it reads after the agent acts.\n\tlet quote = held ? reading(plan, held).quote : \"\";\n\n\tlet claimed = Store.claim(plan.comments, plan.threads, msg.id, kind, ws.data.handle, quote);\n\tif (!claimed.ok) return answer(ws, msg.rid, kind, msg.id, claimed);\n\tlet mutationError: unknown;\n\tlet next: ReturnType;\n\tawait Service.exclusive(plan, async () => {\n\t\tlet mutation: { update: Uint8Array; source: string } | undefined;\n\t\tif (kind === \"accept\") {\n\t\t\ttry {\n\t\t\t\tmutation = room.insertDecision(plan.document, {\n\t\t\t\t\tid: msg.id,\n\t\t\t\t\tquote: quote.slice(0, limits.MAX_QUOTE),\n\t\t\t\t\tby: ws.data.handle,\n\t\t\t\t\tat: new Date(claimed.claim.result.at * 1_000).toISOString(),\n\t\t\t\t\tnotes: claimed.thread.notes.map(note => ({ by: note.handle, text: note.text })),\n\t\t\t\t});\n\t\t\t} catch (err) {\n\t\t\t\tmutationError = err;\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tnext = Store.commit(plan.comments, plan.threads, claimed.claim);\n\t\tif (mutation) await Service.publish(plan, server, roomId, mutation);\n\t\telse await Service.persistExclusive(plan);\n\t});\n\tif (mutationError) {\n\t\tStore.rollback(plan.comments, claimed.claim);\n\t\tconsole.error(\"[comments] could not project a decision:\", mutationError);\n\t\treturn answer(ws, msg.rid, kind, msg.id, {\n\t\t\tok: false,\n\t\t\treason: \"invalid\",\n\t\t\tmessage: mutationError instanceof Error\n\t\t\t\t? mutationError.message\n\t\t\t\t: \"could not record the decision\",\n\t\t});\n\t}\n\n\tlet { at, resolver } = claimed.claim.result;\n\tanswer(ws, msg.rid, kind, msg.id, { ok: true, resolver, at });\n\tbroadcast(server, roomId, {\n\t\tkind: \"comment:resolved\",\n\t\tts: 0,\n\t\tid: msg.id,\n\t\tstatus: claimed.claim.result.status,\n\t\tresolver,\n\t\tat,\n\t\tquote,\n\t});\n\tService.anchors(plan, server, roomId);\n\n\tif (kind === \"accept\" && next) {\n\t\tawait Chat.instruct(\n\t\t\tcontext,\n\t\t\tresolver,\n\t\t\tcompose(next, quote),\n\t\t\t`@${resolver} accepted a comment on \"${excerpt(quote)}\".`,\n\t\t\t{\n\t\t\t\t// Somebody else's turn may get to it first; running this one\n\t\t\t\t// then would only have the agent read the plan and find\n\t\t\t\t// nothing to do.\n\t\t\t\tspent: () => applied(plan, msg.id),\n\t\t\t\t// So the prose the turn writes can be recorded as what this\n\t\t\t\t// decision produced, whether or not the agent says so.\n\t\t\t\tthread: msg.id,\n\t\t\t},\n\t\t);\n\t} else if (kind === \"dismiss\") {\n\t\tawait Chat.notice(context, `@${resolver} dismissed a comment on \"${excerpt(quote)}\".`);\n\t}\n}\n\n/** Enough of the passage to recognise it in a line of transcript. */\nfunction excerpt(quote: string): string {\n\tlet value = quote.replace(/\\s+/g, \" \").trim();\n\treturn value.length > 60 ? `${value.slice(0, 60)}…` : value;\n}\n\nexport function accept(context: Chat.Room, ws: Socket, msg: Request) {\n\treturn settle(context, ws, msg, \"accept\");\n}\n\nexport function dismiss(context: Chat.Room, ws: Socket, msg: Request) {\n\treturn settle(context, ws, msg, \"dismiss\");\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",{"_54":55,"_139":140,"_141":142,"_143":144,"_145":146,"_147":148,"_149":150},"sources",[],"viewer","meta",{"_131":132,"_133":134,"_135":136,"_42":31,"_137":126,"_138":31,"_48":49,"_50":49},"branches",[73,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,127,128,129,130],"tags",[69,70,71,72],"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","main","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":49,"_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,"_52":174,"_175":31,"_176":174,"_177":159},{"_168":178,"_170":179,"_15":178,"_172":180,"_52":174,"_175":31,"_176":174,"_177":49},{"_168":169,"_170":171,"_15":169,"_172":173,"_52":174,"_175":31,"_176":174,"_177":163},"id","issues","name","Issues","filters",{},true,"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_168":158,"_170":181,"_15":158,"_172":226,"_52":174,"_175":31,"_176":174},{"_168":178,"_170":179,"_15":178,"_172":225,"_52":174,"_175":31,"_176":174},{"_168":169,"_170":171,"_15":169,"_172":224,"_52":174,"_175":31,"_176":174},{"_168":221,"_170":222,"_15":221,"_172":223,"_52":31,"_175":31,"_176":174},{"_168":218,"_170":219,"_15":218,"_172":220,"_52":31,"_175":31,"_176":174},{"_168":153,"_170":216,"_15":145,"_172":217,"_52":31,"_175":31,"_176":174},{"_168":155,"_170":213,"_15":214,"_172":215,"_52":31,"_175":31,"_176":174},{"_168":151,"_170":211,"_15":151,"_172":212,"_52":31,"_175":31,"_176":174},{"_168":207,"_170":208,"_15":209,"_172":210,"_52":31,"_175":31,"_176":174},{"_168":141,"_170":205,"_15":141,"_172":206,"_52":31,"_175":31,"_176":31},{"_168":202,"_170":203,"_15":202,"_172":204,"_52":31,"_175":31,"_176":31},{"_168":199,"_170":200,"_15":199,"_172":201,"_52":31,"_175":31,"_176":31},{"_168":196,"_170":197,"_15":196,"_172":198,"_52":31,"_175":31,"_176":31},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794490057051,"sidebar","expanded"]