[{"_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","2e417e7dfb37dcdcdeecc0569e5ecefecf247518","path","packages/editor/src/threads.ts","oid","e920020746ad5d40f602f2eacaebf6d7a8d1ef8e","size",17585,"commit","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","/**\n * Which comment threads the plan holds, and where they point.\n *\n * Two sources feed this and they arrive separately on purpose. What a thread\n * says comes over `comment:*`; where it points comes over `plan:anchors`, with\n * every other relationship in the plan, because a passage moves whenever the\n * document does. Joining them by id here is what keeps the server from having\n * to send the same fact twice on two schedules.\n *\n * An external store rather than React state because resolution has to re-run\n * on every editor update, and that update arrives from a Lexical listener which\n * knows nothing about rendering.\n */\n\nimport { useCallback, useSyncExternalStore } from \"react\";\nimport { useLexicalComposerContext } from \"@lexical/react/LexicalComposerContext\";\nimport { useEffect } from \"react\";\n\nimport { resolve } from \"./anchors\";\nimport { clear as unpaint, holds, paint, pin, unpin } from \"./marks\";\nimport { $blockPoints, $recover, locate } from \"./passage\";\nimport { blockElement, scrollToKey } from \"./scroll\";\n\nimport type { Binding } from \"@lexical/yjs\";\nimport type { LexicalEditor } from \"lexical\";\nimport type { Comment, Plan } from \"@chopin/protocol\";\nimport type { Marked as Selected, Points } from \"./passage\";\nimport type { Transport } from \"./transport\";\n\n/** A thread being written but not yet sent. It has no id until the server gives it one. */\nexport type Draft = Selected;\n\nexport type ThreadView = {\n\tthread: Comment.Thread;\n\t/**\n\t * Where it points, once the anchors snapshot has caught up.\n\t *\n\t * The phrase it marks while it is live; the prose its acceptance produced\n\t * once the agent has said what that was, which may be several blocks.\n\t */\n\tplaces: Points[];\n\t/** Block used for a gutter button when the exact phrase no longer resolves. */\n\ttargetKey?: string;\n\t/** An open thread with no surviving subject block. */\n\torphaned: boolean;\n\t/** Nowhere left to point: the prose is gone and nothing replaced it. */\n\tdrifted: boolean;\n\t/**\n\t * The agent has said what an accepted thread produced.\n\t *\n\t * Derived from the result anchor rather than tracked: `pending` already\n\t * means \"nobody has reviewed this since the last change\", which is exactly\n\t * the question the card is asking.\n\t */\n\tapplied: boolean;\n\t/** The prose it marks, as it currently reads. Frozen once resolved. */\n\tquote: string;\n\t/** Position in the document, for ordering the pane. Undefined if unresolved. */\n\tat?: number;\n};\n\nexport type ThreadState = {\n\tthreads: ThreadView[];\n\tdraft?: Draft;\n\t/** Who is writing a reply, by thread. */\n\twriting: { [thread: string]: string[] };\n\tfocused?: string;\n\t/** Why the last attempt to mark a passage was refused. */\n\terror?: string;\n};\n\nconst EMPTY: ThreadState = { threads: [], writing: {} };\n\nexport class ThreadStore {\n\t#state: ThreadState = EMPTY;\n\t#listeners = new Set<() => void>();\n\n\t#threads = new Map();\n\t#anchors = new Map();\n\t#writing = new Map>();\n\t#draft: Draft | undefined;\n\t#focused: string | undefined;\n\t#error: string | undefined;\n\t/**\n\t * Which card the reader last asked to be taken to, and how far along it.\n\t *\n\t * Never cleared. Whether it is still live is the pin's answer, not this\n\t * one's, and a second copy of that rule is a second thing to get wrong.\n\t */\n\t#walk: { thread: string; index: number } | undefined;\n\n\t#binding: Binding | undefined;\n\t#editor: LexicalEditor | undefined;\n\t#wire: Transport | undefined;\n\n\tsubscribe = (listener: () => void): () => void => {\n\t\tthis.#listeners.add(listener);\n\t\treturn () => this.#listeners.delete(listener);\n\t};\n\n\tsnapshot = (): ThreadState => this.#state;\n\n\tattach(editor: LexicalEditor | undefined): void {\n\t\tthis.#editor = editor;\n\t\tif (!editor) unpaint();\n\t}\n\n\tbind(binding: Binding | undefined): void {\n\t\tthis.#binding = binding;\n\t}\n\n\t/**\n\t * Take the room's socket, and listen on it.\n\t *\n\t * Returns the disposer rather than owning the lifetime: the host knows when\n\t * the connection goes away, and a store that unsubscribed itself would have\n\t * to guess.\n\t */\n\tlisten(wire: Transport | undefined): () => void {\n\t\tthis.#wire = wire;\n\t\tif (!wire) {\n\t\t\tthis.#threads.clear();\n\t\t\tthis.refresh();\n\t\t\treturn () => {};\n\t\t}\n\n\t\tlet off = [\n\t\t\twire.on(\"comment:sync\", frame => this.sync(frame.threads)),\n\t\t\twire.on(\"comment:opened\", frame => this.opened(frame.thread)),\n\t\t\twire.on(\"comment:said\", frame => this.said(frame.id, frame.note)),\n\t\t\twire.on(\"comment:resolved\", frame => this.resolved(frame)),\n\t\t\twire.on(\"comment:typing\", frame => this.typing(frame)),\n\t\t];\n\n\t\treturn () => {\n\t\t\tfor (let stop of off) stop();\n\t\t\tthis.#wire = undefined;\n\t\t};\n\t}\n\n\t// -- acting ----------------------------------------------------------------\n\n\t/** Send the drafted comment. The thread arrives back as `comment:opened`. */\n\tstart(text: string): void {\n\t\tlet draft = this.#draft;\n\t\tif (!draft || !this.#wire) return;\n\n\t\tvoid this.#wire\n\t\t\t.ask(\"comment:start\", { ...draft, text })\n\t\t\t.then(frame => {\n\t\t\t\tif (frame.ok) return this.opened(frame.thread);\n\t\t\t\t// The plan moved under the selection, or there are too many\n\t\t\t\t// open threads. Either way the draft is no longer sendable.\n\t\t\t\tthis.#draft = undefined;\n\t\t\t\tthis.#error = frame.message;\n\t\t\t\tthis.refresh();\n\t\t\t})\n\t\t\t.catch(() => {});\n\t}\n\n\treply(id: string, text: string): void {\n\t\tvoid this.#wire\n\t\t\t?.ask(\"comment:reply\", { id, text })\n\t\t\t.then(frame => {\n\t\t\t\tif (frame.ok) this.said(id, frame.note);\n\t\t\t})\n\t\t\t.catch(() => {});\n\t}\n\n\taccept(id: string): void {\n\t\tvoid this.#wire?.ask(\"comment:accept\", { id }).catch(() => {});\n\t}\n\n\tdismiss(id: string): void {\n\t\tvoid this.#wire?.ask(\"comment:dismiss\", { id }).catch(() => {});\n\t}\n\n\t/**\n\t * Ask the agent to have another go at an accepted thread.\n\t *\n\t * An ordinary chat message, because that is what it is: the decision was\n\t * already made and recorded, and what is missing is a turn. Inventing a\n\t * frame for \"run that again\" would be a second way to start one.\n\t */\n\tretry(id: string): void {\n\t\tlet view = this.#state.threads.find(entry => entry.thread.id === id);\n\t\tif (!view || !this.#wire) return;\n\t\tthis.#wire.send(\"chat:send\", {\n\t\t\ttext: `@ai apply the accepted comment on \"${view.quote}\" — it has not been actioned yet.`,\n\t\t\tto: \"planner\",\n\t\t});\n\t}\n\n\tannounce(id: string, writing: boolean): void {\n\t\tthis.#wire?.send(\"comment:typing\", { id, writing });\n\t}\n\n\t// -- what threads say ------------------------------------------------------\n\n\t/** Replace everything, from `comment:sync`. */\n\tsync(threads: Comment.Thread[]): void {\n\t\tthis.#threads = new Map(threads.map(thread => [thread.id, thread]));\n\t\tthis.refresh();\n\t}\n\n\topened(thread: Comment.Thread): void {\n\t\tthis.#threads.set(thread.id, thread);\n\t\t// The card that was being drafted is now a real thread.\n\t\tthis.#draft = undefined;\n\t\tthis.refresh();\n\t}\n\n\tsaid(id: string, note: Comment.Note): void {\n\t\tlet thread = this.#threads.get(id);\n\t\tif (!thread) return;\n\t\t// A note the sender already added, arriving as a broadcast, must not\n\t\t// appear twice.\n\t\tif (thread.notes.some(existing => existing.id === note.id)) return;\n\t\tthis.#threads.set(id, { ...thread, notes: [...thread.notes, note] });\n\t\tthis.refresh();\n\t}\n\n\tresolved(event: Comment.Resolved): void {\n\t\tlet thread = this.#threads.get(event.id);\n\t\tif (!thread) return;\n\t\tthis.#threads.set(event.id, {\n\t\t\t...thread,\n\t\t\tstatus: event.status,\n\t\t\tresolver: event.resolver,\n\t\t\tat: event.at,\n\t\t\tquote: event.quote,\n\t\t});\n\t\tthis.#writing.delete(event.id);\n\t\tthis.refresh();\n\t}\n\n\ttyping(event: Comment.Typing.Output): void {\n\t\tlet entry = this.#writing.get(event.id);\n\t\tif (event.writing) {\n\t\t\tif (!entry) this.#writing.set(event.id, entry = new Map());\n\t\t\tentry.set(event.client, event.handle);\n\t\t} else {\n\t\t\tentry?.delete(event.client);\n\t\t}\n\t\tthis.refresh();\n\t}\n\n\t// -- where they point ------------------------------------------------------\n\n\t/** Take a new snapshot from the server. */\n\tanchors(threads: Plan.ThreadAnchors[]): void {\n\t\tthis.#anchors = new Map(threads.map(entry => [entry.thread, entry]));\n\t\tthis.refresh();\n\t}\n\n\t// -- drafting --------------------------------------------------------------\n\n\t/**\n\t * Start a comment on what is selected.\n\t *\n\t * The passage is captured now, not held as a live selection: clicking into\n\t * the composer destroys the selection that summoned it, and a draft that\n\t * forgot what it was about the moment you started typing would be useless.\n\t */\n\tdraft(value: Draft | undefined): void {\n\t\tthis.#draft = value;\n\t\tthis.#error = undefined;\n\t\tthis.refresh();\n\t}\n\n\tfocus(id: string | undefined): void {\n\t\tif (this.#focused === id) return;\n\t\tthis.#focused = id;\n\t\tthis.refresh();\n\t}\n\n\t/**\n\t * Take the reader to the prose a thread points at.\n\t *\n\t * A decision can have produced several blocks, so clicking again walks to\n\t * the next one and round. The step is part of the pin rather than a fact\n\t * about the card: a pin that has lapsed means the reader has moved on, and\n\t * starting a minute later at the third place would be a jump with nothing\n\t * on screen to explain it.\n\t *\n\t * Marked as well as scrolled. Arriving is not the same as being shown\n\t * which block was meant, and the hover that lit it is over by the time the\n\t * click has landed.\n\t */\n\treveal(id: string): void {\n\t\tlet editor = this.#editor;\n\t\tlet places = this.#state.threads.find(view => view.thread.id === id)?.places ?? [];\n\t\tif (!editor || places.length === 0) return;\n\n\t\tlet walk = this.#walk;\n\t\tlet index = holds(\"comments\") && walk !== undefined && walk.thread === id\n\t\t\t? (walk.index + 1) % places.length\n\t\t\t: 0;\n\n\t\tlet place = places[index];\n\t\tif (!place) return;\n\n\t\tthis.#walk = { thread: id, index };\n\t\tpin(editor, \"comments\", [place]);\n\t\tscrollToKey(editor, place.anchorKey);\n\t}\n\n\t/** Stop pointing at anything. The pane is going away. */\n\trelease(): void {\n\t\tunpin(this.#editor, \"comments\");\n\t\tthis.focus(undefined);\n\t}\n\n\t/**\n\t * Re-resolve and repaint.\n\t *\n\t * Called on every editor update as well as on new data, because a passage\n\t * is expressed against the document and any edit can move it.\n\t *\n\t * Guarded as a whole, on top of the per-thread guard inside. This runs as a\n\t * Lexical update listener, and Lexical runs those in one loop with no\n\t * isolation: the first to throw skips every listener after it, including\n\t * the one that syncs the document. A comment failing to paint must not cost\n\t * the room its collaboration.\n\t */\n\trefresh = (): void => {\n\t\ttry {\n\t\t\tthis.#rebuild();\n\t\t} catch (err) {\n\t\t\tconsole.error(\"[plan] could not refresh the comment sidecar:\", err);\n\t\t}\n\t};\n\n\t#rebuild(): void {\n\t\tlet editor = this.#editor;\n\t\tlet binding = this.#binding;\n\n\t\tlet views: ThreadView[] = [];\n\t\tlet marks: Points[] = [];\n\n\t\t// Dismissed threads are not shown at all — the transcript is where they\n\t\t// left their trace — so they are dropped once here rather than in each\n\t\t// branch below, where one copy of the rule could outlive the other.\n\t\tlet live = [...this.#threads.values()].filter(thread => thread.status !== \"dismissed\");\n\n\t\tlet build = () => {\n\t\t\tfor (let thread of live) {\n\t\t\t\t/*\n\t\t\t\t * One thread at a time, and the whole of it.\n\t\t\t\t *\n\t\t\t\t * A thread whose relationship cannot be read is a highlight\n\t\t\t\t * nobody gets, not a sidecar nobody gets — and certainly not a\n\t\t\t\t * document nobody gets. The card still renders with its quote\n\t\t\t\t * and its notes, which is the durable part of a comment; the\n\t\t\t\t * anchor was only ever a convenience for finding it again.\n\t\t\t\t *\n\t\t\t\t * The guard covers reading the snapshot as well as resolving\n\t\t\t\t * it, because a malformed entry is as likely as an unresolvable\n\t\t\t\t * one and would otherwise cost every other card too.\n\t\t\t\t */\n\t\t\t\ttry {\n\t\t\t\t\tlet anchors = this.#anchors.get(thread.id);\n\t\t\t\t\t// Nothing resolves before the editor exists; the card still\n\t\t\t\t\t// renders, with the quote and no highlight.\n\t\t\t\t\tlet placement = editor && binding && anchors\n\t\t\t\t\t\t? this.#places(binding, anchors)\n\t\t\t\t\t\t: { places: [] };\n\t\t\t\t\tlet { places } = placement;\n\t\t\t\t\tlet targetKey = thread.status === \"open\" ? placement.targetKey : undefined;\n\t\t\t\t\tlet first = places[0];\n\n\t\t\t\t\tviews.push({\n\t\t\t\t\t\tthread,\n\t\t\t\t\t\tplaces,\n\t\t\t\t\t\t// Only when there is nowhere left to point. A thread\n\t\t\t\t\t\t// whose subject was rewritten but whose result resolves\n\t\t\t\t\t\t// has not lost its place; it has moved to the prose it\n\t\t\t\t\t\t// produced, which is the whole point of accepting it.\n\t\t\t\t\t\tdrifted: !!editor && !!anchors && places.length === 0,\n\t\t\t\t\t\t...(targetKey ? { targetKey } : {}),\n\t\t\t\t\t\torphaned: thread.status === \"open\" && !!editor && !!anchors\n\t\t\t\t\t\t\t&& places.length === 0 && !targetKey,\n\t\t\t\t\t\tapplied: !!anchors && !anchors.result.pending,\n\t\t\t\t\t\tquote: thread.quote ?? anchors?.subject.quote ?? \"\",\n\t\t\t\t\t\t...(first && editor ? { at: order(editor, first.anchorKey) } : {}),\n\t\t\t\t\t});\n\n\t\t\t\t\t// Open comments remain visible in the prose. Accepted comments\n\t\t\t\t\t// have their inline Decision instead, so their anchors must not\n\t\t\t\t\t// leave behind comment chrome after resolution.\n\t\t\t\t\tif (thread.status === \"open\") marks.push(...places);\n\t\t\t\t} catch (err) {\n\t\t\t\t\tconsole.error(`[plan] could not place comment ${thread.id}:`, err);\n\t\t\t\t\t// Unplaceable, but still worth reading.\n\t\t\t\t\tviews.push({\n\t\t\t\t\t\tthread,\n\t\t\t\t\t\tplaces: [],\n\t\t\t\t\t\tdrifted: true,\n\t\t\t\t\t\torphaned: false,\n\t\t\t\t\t\tapplied: false,\n\t\t\t\t\t\tquote: thread.quote ?? \"\",\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tif (editor && binding) editor.getEditorState().read(build);\n\t\telse build();\n\n\t\tviews.sort((a, b) => (a.at ?? Infinity) - (b.at ?? Infinity));\n\t\tif (editor) paint(editor, \"comments\", marks);\n\n\t\tlet writing: { [thread: string]: string[] } = {};\n\t\tfor (let [id, entry] of this.#writing) {\n\t\t\tif (entry.size > 0) writing[id] = [...new Set(entry.values())];\n\t\t}\n\n\t\tlet next: ThreadState = {\n\t\t\tthreads: views,\n\t\t\twriting,\n\t\t\t...(this.#draft ? { draft: this.#draft } : {}),\n\t\t\t...(this.#focused ? { focused: this.#focused } : {}),\n\t\t\t...(this.#error ? { error: this.#error } : {}),\n\t\t};\n\n\t\t// Every keystroke in the plan produces an update and almost none of\n\t\t// them move a thread. Comparing before publishing is what keeps the\n\t\t// pane from re-rendering on every character typed in the prose.\n\t\tif (JSON.stringify(next) === JSON.stringify(this.#state)) return;\n\t\tthis.#state = next;\n\t\tfor (let listener of this.#listeners) listener();\n\t}\n\n\t/** Positions first; reading is what covers the gap before the next rebase. */\n\t/**\n\t * Where a thread points, now.\n\t *\n\t * The result first, when the agent has said what the decision produced.\n\t * The prose a thread was about is usually the prose it asked to have\n\t * rewritten, so after the turn the subject is gone by design — treating\n\t * that as the thread having lost its place gets it exactly backwards. What\n\t * was discussed is kept as a frozen quote; what it produced is where the\n\t * decision now lives.\n\t *\n\t * Block-wide, because after a rewrite there is no phrase to point at,\n\t * only a passage of new prose.\n\t */\n\t#places(\n\t\tbinding: Binding,\n\t\tanchors: Plan.ThreadAnchors,\n\t): { places: Points[]; targetKey?: string } {\n\t\tlet { result, subject } = anchors;\n\n\t\t// Pending means nobody has checked this since the plan moved, so it is\n\t\t// not somewhere worth sending a reader.\n\t\tif (result.anchors.length > 0 && !result.pending) {\n\t\t\tlet produced = result.anchors\n\t\t\t\t.map(anchor => resolve(binding, anchor))\n\t\t\t\t.flatMap(key => (key ? [$blockPoints(key)] : []))\n\t\t\t\t.filter((points): points is Points => !!points);\n\t\t\tif (produced.length > 0) return { places: produced };\n\t\t}\n\n\t\tlet targetKey = subject.blocks\n\t\t\t.map(block => resolve(binding, block))\n\t\t\t.find((key): key is string => !!key);\n\t\tlet found = locate(binding, subject) ?? this.#recover(binding, subject);\n\t\treturn {\n\t\t\tplaces: found ? [found] : [],\n\t\t\t...(targetKey ? { targetKey } : {}),\n\t\t};\n\t}\n\n\t/** The phrase, read out of the prose, when its positions cannot be resolved. */\n\t#recover(binding: Binding, subject: Plan.Passage): Points | undefined {\n\t\tlet keys = subject.blocks\n\t\t\t.map(block => resolve(binding, block))\n\t\t\t.filter((key): key is string => !!key);\n\t\tif (keys.length !== subject.blocks.length) return undefined;\n\n\t\treturn $recover(subject, keys);\n\t}\n}\n\n/**\n * Where a node sits among the document's blocks, for ordering the pane.\n *\n * Guarded on its own rather than left to the caller's: this reaches for the\n * DOM, and an editor without one throws rather than returning nothing. Sort\n * order is cosmetic, and losing it must not cost the thread its place.\n */\nfunction order(editor: LexicalEditor, key: string): number | undefined {\n\ttry {\n\t\tlet block = blockElement(editor, key);\n\t\tif (!block) return undefined;\n\n\t\tlet root = editor.getRootElement();\n\t\tif (!root) return undefined;\n\n\t\tlet index = [...root.children].indexOf(block);\n\t\treturn index === -1 ? undefined : index;\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\n/** Mounted inside the editor, so resolution re-runs as the document changes. */\nexport function ThreadObserver({ store }: { store: ThreadStore }) {\n\tlet [editor] = useLexicalComposerContext();\n\n\tuseEffect(() => {\n\t\tstore.attach(editor);\n\t\tstore.refresh();\n\t\tlet off = editor.registerUpdateListener(store.refresh);\n\t\treturn () => {\n\t\t\toff();\n\t\t\tstore.attach(undefined);\n\t\t};\n\t}, [editor, store]);\n\n\treturn null;\n}\n\nexport function useThreads(store: ThreadStore): ThreadState {\n\tlet subscribe = useCallback((listener: () => void) => store.subscribe(listener), [store]);\n\treturn useSyncExternalStore(subscribe, store.snapshot, store.snapshot);\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",1794442924257,"sidebar","expanded"]