feat(storage): move desktop SQLite ownership into a storage utility process

Main no longer opens desktop business SQLite. A single utility-process
storage owner holds the Assistant, Knowledge, attachment, document-result,
remote-binding and native model-ledger databases and runs whole domain
transactions; Main and Runtime callers use explicit async domain operations.

- Remove the Main readWithFallback path and the supervision worker's
  separate business write connection; manifests are scanned read-only and
  committed by the sole writer.
- Remote events are ACKed only after commit; process loss reports
  unconfirmed writes instead of replaying them.
- Use native utilityProcess messaging with one in-flight bound (32) and
  ordered waiting instead of capacity rejection and retries.
- Start the storage process before the window so startup overlaps.
- Keep short tool output in memory and store full output once in owned
  storage; paging, branching, restart and deletion reuse that copy.
- Put required runtime launch files under goodbuddy-prefixed owned temp
  directories and reclaim confirmed stale ones; stop writing duplicate
  parsed.md.
- Add lint guards for SQLite ownership and architecture, concurrency
  acceptance fixtures, and maintenance/architecture documentation.

Validation: typecheck and lint pass. Alternating baseline (edf019aa) vs
candidate runs show no regression on single-session, C01, C02, C04 and a
5-minute C06; Main p99 drops from ~21 ms to ~16.7 ms under concurrency.
Fresh portable copy (1.75M events) upgrade content unchanged; real-model
output paging passes with 4 external requests. Full npm test runs had
1-9 different timing-sensitive failures per run that pass when rerun.
Not covered: C03 review publication, C07 source body, app-level C05.

src/shared/assistant-contracts.ts

@@ -344,6 +344,14 @@ export type ConversationQueueItem = z.infer<
   typeof conversationQueueItemSchema
 >
 
+export const toolOutputReferenceSchema = z.object({
+  handle: z.string().min(1),
+  nextCursor: z.number().int().nonnegative(),
+  totalBytes: z.number().int().nonnegative()
+}).strict()
+
+export type ToolOutputReference = z.infer<typeof toolOutputReferenceSchema>
+
 export const conversationToolActivitySchema = z
   .object({
     callId: z.string().optional(),
@@ -360,6 +368,7 @@ export const conversationToolActivitySchema = z
     summary: z.string(),
     input: z.string().optional(),
     output: z.string().optional(),
+    outputReferences: z.array(toolOutputReferenceSchema).optional(),
     error: z.string().optional()
   })
   .strict()
@@ -436,6 +445,7 @@ const conversationSubagentActivityBaseSchema = z.object({
   reason: z.string().trim().min(1).max(240).optional(),
   progress: conversationMessageBlocksSchema.optional(),
   output: z.string().optional(),
+  outputReference: toolOutputReferenceSchema.optional(),
   error: z.string().trim().min(1).max(1_000).optional()
 })
 

src/shared/contracts.ts

@@ -1321,6 +1321,7 @@ export type AgentEvent =
       summary: string
       input?: string
       output?: string
+      outputReferences?: import('./assistant-contracts').ToolOutputReference[]
       error?: string
     }
   | {
@@ -2335,6 +2336,7 @@ export type DesktopApi = {
     cancelParsing: (operationId: string) => Promise<void>
     sendOriginal: (conversationId: string, id: string) => Promise<ContextAttachment[]>
     openOriginal: (id: string) => Promise<void>
+    readOutput: (input: { conversationId: string; handle: string; cursor?: number; limitBytes?: number }) => Promise<import('./conversation-output').ConversationOutputPage>
     addResultImages: (conversationId: string, resultId: string, imageIds: string[]) => Promise<ContextAttachment[]>
     onDraftChanged: (listener: (conversationId: string, attachments: ContextAttachment[]) => void) => () => void
     getDraft: (conversationId: string) => Promise<ContextAttachment[]>
@@ -2434,6 +2436,11 @@ export type DesktopApi = {
       files: File[],
       graphStrategy?: 'rules' | 'model' | 'hybrid'
     ) => Promise<void>
+    importPaths?: (
+      libraryId: string,
+      paths: string[],
+      graphStrategy?: 'rules' | 'model' | 'hybrid'
+    ) => Promise<void>
     importUrl: (
       libraryId: string,
       url: string,

src/shared/conversation-output.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod'
+import type { ConversationMessage } from './assistant-contracts'
+
+export const conversationOutputReadSchema = z.object({
+  conversationId: z.string().uuid(),
+  handle: z.string().regex(/^(?:process|rg|subagent):[0-9a-f-]{36}$/iu),
+  cursor: z.number().int().nonnegative().default(0),
+  limitBytes: z.number().int().min(1).max(32768).default(32768)
+}).strict()
+
+export type ConversationOutputPage = {
+  content: string
+  cursor: number
+  nextCursor: number
+  totalBytes: number
+  eof: boolean
+}
+
+export function conversationMessageResourceIds(message: ConversationMessage): string[] {
+  const ids = new Set(message.attachments?.map(attachment => attachment.resourceId ?? attachment.id))
+  for (const handle of conversationMessageOutputHandles(message)) ids.add(handle.slice(handle.lastIndexOf(':') + 1))
+  return [...ids]
+}
+
+export function conversationMessageOutputHandles(message: ConversationMessage): string[] {
+  const handles = new Set<string>()
+  const add = (handle: string): void => {
+    if (/^(?:process|rg|subagent):[0-9a-f-]{36}$/iu.test(handle)) handles.add(handle)
+  }
+  for (const tool of message.tools ?? []) for (const reference of tool.outputReferences ?? []) add(reference.handle)
+  for (const block of message.blocks ?? []) {
+    if (block.type === 'tool') for (const reference of block.tool.outputReferences ?? []) add(reference.handle)
+  }
+  for (const subagent of message.subagents ?? []) {
+    if (subagent.outputReference) add(subagent.outputReference.handle)
+    for (const block of subagent.progress ?? []) {
+      if (block.type === 'tool') for (const reference of block.tool.outputReferences ?? []) add(reference.handle)
+    }
+  }
+  return [...handles]
+}

src/shared/ipc-channels.ts

@@ -182,6 +182,7 @@ export const ipcChannels = {
   contextCancelParsing: 'context:cancel-parsing',
   contextSendOriginal: 'context:send-original',
   contextOpenOriginal: 'context:open-original',
+  contextReadOutput: 'context:read-output',
   contextCancelImport: 'context:cancel-import',
   contextPendingParsing: 'context:pending-parsing',
   contextRetryParsing: 'context:retry-parsing',

src/shared/storage-data-size.ts

@@ -0,0 +1,27 @@
+/** Counts DTO memory without stringifying or copying its string/binary bodies. */
+export function storageDataBytes(value: unknown, limit = 32 * 1024 * 1024): number {
+  let bytes = 0
+  const seen = new Set<object>()
+  const visit = (item: unknown): void => {
+    bytes += 16
+    if (typeof item === 'string') bytes += item.length * 2
+    else if (typeof item === 'function' || typeof item === 'symbol') throw new TypeError('Storage requires data, not callbacks or symbols')
+    else if (item && typeof item === 'object') {
+      if (seen.has(item)) return
+      seen.add(item)
+      if (item instanceof Uint8Array) bytes += item.byteLength
+      else if (item instanceof Date) bytes += 8
+      else if (item instanceof Map) for (const [key, entry] of item) { visit(key); visit(entry) }
+      else if (item instanceof Set || Array.isArray(item)) for (const entry of item) visit(entry)
+      else {
+        if (Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null) {
+          throw new TypeError('Storage requires plain data, not live objects')
+        }
+        for (const key of Object.keys(item)) { visit(key); visit((item as Record<string, unknown>)[key]) }
+      }
+    }
+    if (bytes > limit) throw Object.assign(new RangeError('Storage payload capacity exceeded; use a bounded domain batch or page'), { code: 'STORAGE_CAPACITY' })
+  }
+  visit(value)
+  return bytes
+}