create-interview-cockpit 0.3.0 → 0.5.0

package/template/client/src/store.ts

@@ -1,7 +1,60 @@
 import { create } from "zustand";
 import type { Topic, Question, CodeSnippet, WorkspaceMeta } from "./types";
+import type { AiSettings } from "./api";
 import * as api from "./api";
 
+const DEFAULT_AI_SETTINGS: AiSettings = {
+  systemPrompt: "",
+  responseProfiles: {
+    concise: { maxOutputTokens: 1000, maxSteps: 3 },
+    moderate: { maxOutputTokens: 1000, maxSteps: 5 },
+    normal: { maxOutputTokens: 3000, maxSteps: 5 },
+  },
+  vizGuide: "",
+  alwaysSendPrefsDefault: false,
+  thinkingBudget: 0,
+  promptGroups: {
+    length: {
+      label: "Response Length",
+      description:
+        "Appended to the user message when the selected length changes.",
+      default: "normal",
+      options: {
+        concise:
+          "Keep the response concise. Aim for roughly 300 characters of text when possible. These limits do not apply to mermaid diagrams. You can generate as many as you want to explain the solution effectively. Prioritize diagrams over text.",
+        moderate:
+          "Keep the response moderately detailed. Aim for roughly 550 characters of text when possible.",
+        normal:
+          "Use a fuller answer with enough context to explain the idea clearly.",
+      },
+    },
+    style: {
+      label: "Response Style",
+      description:
+        "Appended to the user message when the selected style changes.",
+      default: "prose",
+      options: {
+        prose:
+          "Use natural prose with short paragraphs. Avoid bullet lists and numbered lists unless I explicitly ask for them.",
+        bullets: "Use bullet points and short lists as the main format.",
+        structured:
+          "Use structured sections with headings and numbered steps when helpful.",
+      },
+    },
+    audience: {
+      label: "Response Audience",
+      description:
+        "Appended to the user message when the selected audience changes.",
+      default: "normal",
+      options: {
+        normal: "",
+        beginner:
+          "When using technical terms or abbreviations, immediately expand their meaning in square brackets right after the term — e.g. 'TCP [Transmission Control Protocol — a connection-oriented transport protocol]' or 'idempotent [an operation that produces the same result no matter how many times it is applied]'. Do this throughout your response so I never need to look anything up.",
+      },
+    },
+  },
+};
+
 interface Store {
   topics: Topic[];
   questionsByTopic: Record<string, Question[]>;
@@ -13,6 +66,7 @@ interface Store {
   showCodePanel: boolean;
   showSidebar: boolean;
   viewingFile: string | null;
+  viewingDoc: { fileId: string; quote: string; fileName: string } | null;
 
   // ── Workspaces ───────────────────────────────────────────────
   workspaces: WorkspaceMeta[];
@@ -85,26 +139,107 @@ interface Store {
     files: FileList | File[],
   ) => Promise<void>;
   removeTopicFile: (topicId: string, fileId: string) => Promise<void>;
+  linkFileToTopic: (
+    topicId: string,
+    fileId: string,
+    originalName: string,
+  ) => Promise<void>;
   uploadQuestionFiles: (
     questionId: string,
     files: FileList | File[],
   ) => Promise<void>;
   removeQuestionFile: (questionId: string, fileId: string) => Promise<void>;
+  linkFileToQuestion: (
+    questionId: string,
+    fileId: string,
+    originalName: string,
+  ) => Promise<void>;
+  saveCodeSnippetToQuestion: (
+    questionId: string,
+    code: string,
+    language: string,
+    label: string,
+    origin: "user" | "ai" | "sandbox",
+  ) => Promise<import("./types").ContextFile>;
   clearMessages: (questionId: string) => Promise<void>;
+
+  // ── Workspace Context Files ──────────────────────────────────
+  workspaceFiles: import("./types").ContextFile[];
+  fetchWorkspaceFiles: () => Promise<void>;
+  uploadWorkspaceFiles: (files: FileList | File[]) => Promise<void>;
+  removeWorkspaceFile: (fileId: string) => Promise<void>;
+
   updateQuestionSystemContext: (
     questionId: string,
     systemContext: string,
   ) => Promise<void>;
   openFileViewer: (path: string) => void;
   closeFileViewer: () => void;
+  openDocViewer: (fileId: string, quote: string, fileName: string) => void;
+  closeDocViewer: () => void;
+  /** Inline code blocks written by the AI, keyed by `inline:<id>` */
+  inlineCodeSnippets: Record<
+    string,
+    { content: string; language: string; label: string }
+  >;
+  registerInlineCode: (
+    id: string,
+    entry: { content: string; language: string; label: string },
+  ) => void;
   codeSnippets: CodeSnippet[];
   addSnippet: (snippet: CodeSnippet) => void;
   removeSnippet: (id: string) => void;
   clearSnippets: () => void;
+
+  // ── AI Settings ──────────────────────────────────────────────
+  aiSettings: AiSettings;
+  fetchAiSettings: () => Promise<void>;
+  saveAiSettings: (patch: Partial<AiSettings>) => Promise<void>;
+  /** The currently active preference suffix (LENGTH/STYLE/AUDIENCE/etc) built by ChatView. */
+  livePreferenceSuffix: string;
+  setLivePreferenceSuffix: (suffix: string) => void;
+  showSettings: boolean;
+  openSettings: () => void;
+  closeSettings: () => void;
+
+  // ── Code Runner ──────────────────────────────────────────────
+  showCodeRunner: boolean;
+  /** Code pre-filled into the runner when opened */
+  runnerInitialCode: string;
+  /** Language hint — 'typescript' or 'javascript' */
+  runnerInitialLanguage: string;
+  /** When set, opens the runner in sandbox mode with these values pre-filled */
+  runnerInitialSandbox: {
+    serverCode: string;
+    serverLang: string;
+    clientCode: string;
+    clientLang: string;
+    fileId?: string;
+  } | null;
+  openCodeRunner: (code?: string, language?: string) => void;
+  openSandbox: (
+    serverCode: string,
+    serverLang: string,
+    clientCode: string,
+    clientLang: string,
+    fileId?: string,
+  ) => void;
+  overwriteContextFileContent: (
+    questionId: string,
+    fileId: string,
+    content: string,
+  ) => Promise<void>;
+  renameContextFile: (
+    questionId: string,
+    fileId: string,
+    label: string,
+  ) => Promise<void>;
+  closeCodeRunner: () => void;
 }
 
 export const useStore = create<Store>((set, get) => ({
   topics: [],
+  workspaceFiles: [],
   questionsByTopic: {},
   selectedTopicId: null,
   selectedQuestionId: null,
@@ -114,7 +249,16 @@ export const useStore = create<Store>((set, get) => ({
   showCodePanel: false,
   showSidebar: true,
   viewingFile: null,
+  viewingDoc: null,
+  inlineCodeSnippets: {},
   codeSnippets: [],
+  aiSettings: DEFAULT_AI_SETTINGS,
+  livePreferenceSuffix: "",
+  showSettings: false,
+  showCodeRunner: false,
+  runnerInitialCode: "",
+  runnerInitialLanguage: "typescript",
+  runnerInitialSandbox: null,
 
   // ── Workspaces ───────────────────────────────────────────────
   workspaces: [],
@@ -154,6 +298,8 @@ export const useStore = create<Store>((set, get) => ({
     });
     const topics = await api.fetchTopics();
     set({ topics });
+    const workspaceFiles = await api.fetchWorkspaceFiles();
+    set({ workspaceFiles });
   },
 
   deleteWorkspace: async (id) => {
@@ -445,6 +591,17 @@ export const useStore = create<Store>((set, get) => ({
     }));
   },
 
+  linkFileToTopic: async (topicId, fileId, originalName) => {
+    const cf = await api.linkFileToTopic(topicId, fileId, originalName);
+    set((s) => ({
+      topics: s.topics.map((t) =>
+        t.id === topicId
+          ? { ...t, contextFiles: [...(t.contextFiles || []), cf] }
+          : t,
+      ),
+    }));
+  },
+
   uploadQuestionFiles: async (questionId, files) => {
     const uploaded = await api.uploadQuestionFiles(questionId, files);
     set((s) => ({
@@ -476,6 +633,45 @@ export const useStore = create<Store>((set, get) => ({
     }));
   },
 
+  linkFileToQuestion: async (questionId, fileId, originalName) => {
+    const cf = await api.linkFileToQuestion(questionId, fileId, originalName);
+    set((s) => ({
+      currentQuestion:
+        s.currentQuestion?.id === questionId
+          ? {
+              ...s.currentQuestion,
+              contextFiles: [...(s.currentQuestion.contextFiles || []), cf],
+            }
+          : s.currentQuestion,
+    }));
+  },
+
+  saveCodeSnippetToQuestion: async (
+    questionId,
+    code,
+    language,
+    label,
+    origin,
+  ) => {
+    const cf = await api.saveCodeSnippet(
+      questionId,
+      code,
+      language,
+      label,
+      origin,
+    );
+    set((s) => ({
+      currentQuestion:
+        s.currentQuestion?.id === questionId
+          ? {
+              ...s.currentQuestion,
+              contextFiles: [...(s.currentQuestion.contextFiles || []), cf],
+            }
+          : s.currentQuestion,
+    }));
+    return cf;
+  },
+
   clearMessages: async (questionId) => {
     await api.updateQuestion(questionId, { messages: [] });
     set((s) => ({
@@ -486,6 +682,23 @@ export const useStore = create<Store>((set, get) => ({
     }));
   },
 
+  fetchWorkspaceFiles: async () => {
+    const files = await api.fetchWorkspaceFiles();
+    set({ workspaceFiles: files });
+  },
+
+  uploadWorkspaceFiles: async (files) => {
+    const uploaded = await api.uploadWorkspaceFiles(files);
+    set((s) => ({ workspaceFiles: [...s.workspaceFiles, ...uploaded] }));
+  },
+
+  removeWorkspaceFile: async (fileId) => {
+    await api.deleteWorkspaceFile(fileId);
+    set((s) => ({
+      workspaceFiles: s.workspaceFiles.filter((f) => f.id !== fileId),
+    }));
+  },
+
   updateQuestionSystemContext: async (questionId, systemContext) => {
     const updated = await api.updateQuestion(questionId, { systemContext });
     set((s) => ({
@@ -507,4 +720,66 @@ export const useStore = create<Store>((set, get) => ({
 
   openFileViewer: (path) => set({ viewingFile: path }),
   closeFileViewer: () => set({ viewingFile: null }),
+  registerInlineCode: (id, entry) =>
+    set((s) => ({
+      inlineCodeSnippets: { ...s.inlineCodeSnippets, [id]: entry },
+    })),
+  openDocViewer: (fileId, quote, fileName) =>
+    set({ viewingDoc: { fileId, quote, fileName } }),
+  closeDocViewer: () => set({ viewingDoc: null }),
+  openCodeRunner: (code = "", language = "typescript") =>
+    set({
+      showCodeRunner: true,
+      runnerInitialCode: code,
+      runnerInitialLanguage: language,
+      runnerInitialSandbox: null,
+    }),
+  openSandbox: (serverCode, serverLang, clientCode, clientLang, fileId?) =>
+    set({
+      showCodeRunner: true,
+      runnerInitialCode: "",
+      runnerInitialLanguage: "typescript",
+      runnerInitialSandbox: {
+        serverCode,
+        serverLang,
+        clientCode,
+        clientLang,
+        fileId,
+      },
+    }),
+
+  overwriteContextFileContent: async (questionId, fileId, content) => {
+    await api.overwriteContextFileContent(questionId, fileId, content);
+  },
+
+  renameContextFile: async (questionId, fileId, label) => {
+    const cf = await api.renameContextFile(questionId, fileId, label);
+    set((s) => ({
+      currentQuestion:
+        s.currentQuestion?.id === questionId
+          ? {
+              ...s.currentQuestion,
+              contextFiles: (s.currentQuestion.contextFiles || []).map((f) =>
+                f.id === fileId ? { ...f, label: cf.label, name: cf.name } : f,
+              ),
+            }
+          : s.currentQuestion,
+    }));
+  },
+  closeCodeRunner: () => set({ showCodeRunner: false }),
+
+  fetchAiSettings: async () => {
+    const settings = await api.fetchAiSettings();
+    set({ aiSettings: settings });
+  },
+
+  saveAiSettings: async (patch) => {
+    const updated = await api.saveAiSettings(patch);
+    set({ aiSettings: updated });
+  },
+
+  setLivePreferenceSuffix: (suffix) => set({ livePreferenceSuffix: suffix }),
+
+  openSettings: () => set({ showSettings: true }),
+  closeSettings: () => set({ showSettings: false }),
 }));

package/template/client/src/types.ts

@@ -4,6 +4,14 @@ export interface ContextFile {
   originalName: string;
   driveFileId?: string;
   createdAt: string;
+  /** Distinguishes how this file was added. 'upload' = user-uploaded doc,
+   *  'user' = code saved from Code Runner, 'ai' = AI-generated code block,
+   *  'sandbox' = paired server+client sandbox saved as JSON. */
+  origin?: "user" | "ai" | "upload" | "sandbox";
+  /** Language hint for code snippets (e.g. 'typescript', 'javascript'). */
+  language?: string;
+  /** Short display label for code snippets. */
+  label?: string;
 }
 
 export interface WorkspaceMeta {
@@ -36,6 +44,7 @@ export interface Message {
   id: string;
   role: "user" | "assistant";
   content: string;
+  parts?: { type: string; [key: string]: any }[];
   createdAt?: string;
 }
 

package/template/cockpit.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.2.0"
+  "version": "0.4.0"
 }

package/template/data/ai-settings.json

@@ -0,0 +1,49 @@
+{
+  "systemPrompt": "You are a senior engineering interview coach.\n\nHighest priority: follow the user's explicit response preferences and current conversation context. If they conflict with your default teaching behavior, the user's preference wins.\nExplain clearly, accurately, and practically.\nOnly include Mermaid diagrams, code blocks, or tables when the user explicitly asks for them or when they materially improve the answer.\nIf you show code, use a fenced code block with the correct language.\n\nMermaid syntax rules (follow strictly):\n- Wrap node labels in quotes when they contain special characters: A[\"Microservice A (Producer)\"]\n- Edge labels use |text| syntax: A -->|sends message| B\n- Never put parentheses or brackets inside [] without quoting the label\n- Use simple node IDs (letters/numbers) and put descriptive text in the label\n\nYou can produce animated diagrams using ```viz blocks for flows, step-through walkthroughs, or any explanation that benefits from animation. Call getVizGuide() first to get the full spec reference before writing a viz block.",
+  "responseProfiles": {
+    "concise": {
+      "maxOutputTokens": 1000,
+      "maxSteps": 3
+    },
+    "moderate": {
+      "maxOutputTokens": 1000,
+      "maxSteps": 5
+    },
+    "normal": {
+      "maxOutputTokens": 3000,
+      "maxSteps": 5
+    }
+  },
+  "vizGuide": "Animated viz diagrams — full spec reference\n\nThe content of a ```viz block is a YAML (preferred) or JSON object:\n\n  view: { width: 900, height: 360 }   # required — scene canvas size\n  nodes:                               # required — list of nodes\n    - id: client                       # required, kebab-case\n      label: Client                    # display text\n      x: 80                            # required — absolute X centre in view\n      y: 180                           # required — absolute Y centre in view\n      shape: rect                      # rect (default) | circle | cylinder | diamond | hexagon | ellipse | cloud | document | note\n      width: 120                       # optional, default 120\n      height: 40                       # optional, default 40\n      fill: '#0e7490'                  # optional hex colour\n      stroke: '#164e63'                # optional\n  edges:                               # optional\n    - from: client\n      to: lb\n      label: HTTP Request             # optional\n      animate: flow                   # optional — adds marching-ants stroke animation\n      style: straight                 # straight (default) | curved | orthogonal\n  autoSignals:                         # optional — self-animating signal dots, no code needed\n    - id: req-flow                     # unique key\n      chain: [client, lb, server]      # ordered node ids — dot travels this path\n      loop: true                       # restart after reaching the end\n      durationPerHop: 700              # ms per hop, default 800\n      loopDelay: 0                     # ms pause before restart\n      color: '#7dd3fc'                 # optional dot colour\n  steps:                               # optional — replaces autoSignals; adds step-through UI\n    - label: Client sends a request    # shown in step indicator\n      highlight: [client, lb]          # node ids to highlight on this step\n      signals:                         # one-shot signals that play on this step\n        - id: s1\n          chain: [client, lb]\n          durationPerHop: 800\n      autoAdvance: false               # true = auto-proceeds after signals complete\n\nRules:\n- x/y are ABSOLUTE coordinates within the view. Plan layout so nodes don't overlap (typical node is 120×40).\n- Use autoSignals (loop: true) for animated overview diagrams. Use steps for walkthroughs where you explain each phase.\n- Do NOT mix autoSignals and steps in the same spec.\n- Keep node ids simple, lowercase, no spaces (use hyphens).\n- Prefer YAML — it is more readable. Only use JSON if the structure is trivial.\n\nMinimal animated example (autoSignal loop):\n```viz\nview: { width: 860, height: 260 }\nnodes:\n  - { id: client, label: Client, x: 80, y: 130, width: 120, height: 40, fill: '#0e7490' }\n  - { id: lb, label: Load Balancer, x: 430, y: 130, width: 160, height: 40, fill: '#7c3aed' }\n  - { id: srv, label: Server, x: 770, y: 130, width: 120, height: 40, fill: '#065f46' }\nedges:\n  - { from: client, to: lb }\n  - { from: lb, to: srv }\nautoSignals:\n  - { id: flow, chain: [client, lb, srv], loop: true, durationPerHop: 700 }\n```\n\nMinimal step-through example:\n```viz\nview: { width: 860, height: 260 }\nnodes:\n  - { id: client, label: Client, x: 80, y: 130, width: 120, height: 40, fill: '#0e7490' }\n  - { id: cache, label: Cache, x: 430, y: 130, width: 120, height: 40, fill: '#7c3aed' }\n  - { id: db, label: Database, x: 770, y: 130, width: 120, height: 40, fill: '#065f46' }\nedges:\n  - { from: client, to: cache }\n  - { from: cache, to: db }\nsteps:\n  - label: Client queries the cache\n    highlight: [client, cache]\n    signals: [{ id: s1, chain: [client, cache], durationPerHop: 800 }]\n  - label: Cache miss — forward to DB\n    highlight: [cache, db]\n    signals: [{ id: s2, chain: [cache, db], durationPerHop: 800 }]\n  - label: DB responds, cache is populated\n    highlight: [db, cache, client]\n    signals:\n      - { id: s3a, chain: [db, cache], durationPerHop: 600 }\n      - { id: s3b, chain: [cache, client], durationPerHop: 600 }\n```",
+  "promptGroups": {
+    "length": {
+      "label": "Response Length",
+      "description": "Appended to the user message when the selected length changes.",
+      "default": "normal",
+      "options": {
+        "concise": "Keep the response very concise",
+        "moderate": "Keep the response moderately detailed.",
+        "normal": "Use a fuller answer with enough context to explain the idea clearly."
+      }
+    },
+    "style": {
+      "label": "Response Style",
+      "description": "Appended to the user message when the selected style changes.",
+      "default": "structured",
+      "options": {
+        "prose": "Use natural prose with short paragraphs.",
+        "bullets": "Use bullet points and short lists as the main format.",
+        "structured": "Use structured sections with headings and numbered steps when helpful."
+      }
+    },
+    "audience": {
+      "label": "Response Audience",
+      "description": "Appended to the user message when the selected audience changes.",
+      "default": "normal",
+      "options": {
+        "normal": "",
+        "beginner": "When using technical terms or abbreviations, immediately expand their meaning in square brackets."
+      }
+    }
+  }
+}

package/template/server/src/google-drive.ts

@@ -313,6 +313,14 @@ export async function syncWorkspace(
   const questions = pending.filter((p) => !p.isContextFile);
   const contextFiles = pending.filter((p) => p.isContextFile);
 
+  // Collect parent-title links to re-apply after all questions are saved
+  // (IDs are regenerated on import, so we must link by title within a topic)
+  const parentLinks: Array<{
+    questionId: string;
+    topicId: string;
+    parentTitle: string;
+  }> = [];
+
   await Promise.all(
     questions.map(async ({ topicId, filename, buffer }) => {
       try {
@@ -320,6 +328,9 @@ export async function syncWorkspace(
         let systemContext = "";
         let messages: storage.Question["messages"] = [];
         let codeContextFiles: string[] = [];
+        let codeAnnotations: storage.Question["codeAnnotations"] = {};
+        let parentTitle: string | null = null;
+        const restoredContextFiles: storage.ContextFile[] = [];
 
         if (filename.endsWith(".json")) {
           // Our own exported JSON — restore fields directly, no text extraction
@@ -329,6 +340,42 @@ export async function syncWorkspace(
             systemContext = parsed.systemContext || "";
             messages = parsed.messages || [];
             codeContextFiles = parsed.codeContextFiles || [];
+            codeAnnotations = parsed.codeAnnotations || {};
+            parentTitle = parsed.parentTitle || null;
+
+            // Restore code snippet context files (user/ai origin)
+            if (
+              Array.isArray(parsed.codeSnippets) &&
+              parsed.codeSnippets.length > 0
+            ) {
+              const ctxDir =
+                storage.getContextFilesDirForWorkspace(workspaceId);
+              await Promise.all(
+                parsed.codeSnippets.map(
+                  async (cs: storage.ContextFile & { content?: string }) => {
+                    if (
+                      cs.content &&
+                      (cs.origin === "user" ||
+                        cs.origin === "ai" ||
+                        cs.origin === "sandbox")
+                    ) {
+                      try {
+                        await fs.mkdir(ctxDir, { recursive: true });
+                        await fs.writeFile(
+                          path.join(ctxDir, cs.id),
+                          Buffer.from(cs.content, "utf-8"),
+                        );
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        const { content: _content, ...cfMeta } = cs;
+                        restoredContextFiles.push(cfMeta);
+                      } catch {
+                        /* skip bad blobs */
+                      }
+                    }
+                  },
+                ),
+              );
+            }
           } catch {
             // Malformed JSON — fall through to raw text
             systemContext = buffer.toString("utf-8");
@@ -344,18 +391,47 @@ export async function syncWorkspace(
           title,
           systemContext,
           codeContextFiles,
-          contextFiles: [],
+          contextFiles: restoredContextFiles,
           messages,
+          codeAnnotations,
           createdAt: new Date().toISOString(),
         };
         await storage.saveQuestion(q);
         result.filesImported++;
+        if (parentTitle) {
+          parentLinks.push({ questionId: q.id, topicId, parentTitle });
+        }
       } catch (err: any) {
         result.errors.push(`${filename}: ${err?.message ?? "failed"}`);
       }
     }),
   );
 
+  // ── Phase 4b: re-link parent–child relationships by title ───────────────────
+  // IDs are regenerated on import, so we match parent by title within the same topic.
+  if (parentLinks.length > 0) {
+    // Group by topicId to avoid redundant getQuestionsByTopic calls
+    const byTopic = new Map<string, typeof parentLinks>();
+    for (const link of parentLinks) {
+      const arr = byTopic.get(link.topicId) ?? [];
+      arr.push(link);
+      byTopic.set(link.topicId, arr);
+    }
+    for (const [topicId, links] of byTopic) {
+      const allInTopic = await storage.getQuestionsByTopic(topicId);
+      for (const { questionId, parentTitle } of links) {
+        const parent = allInTopic.find(
+          (q) => q.title === parentTitle && q.id !== questionId,
+        );
+        const child = allInTopic.find((q) => q.id === questionId);
+        if (parent && child) {
+          child.parentQuestionId = parent.id;
+          await storage.saveQuestion(child);
+        }
+      }
+    }
+  }
+
   // ── Phase 5: save context file blobs in parallel, then update topics.json once ─
   if (contextFiles.length > 0) {
     // Write binary files in parallel
@@ -645,13 +721,45 @@ export async function exportWorkspace(
             try {
               const safeName =
                 q.title.replace(/[/\\:*?"<>|]/g, "-").trim() || q.id;
+              // Look up parent title so the relationship can be restored on import
+              const parentTitle = q.parentQuestionId
+                ? questions.find((p) => p.id === q.parentQuestionId)?.title
+                : undefined;
+
+              // Read code snippet blobs so they survive drive sync
+              const ctxDir =
+                storage.getContextFilesDirForWorkspace(workspaceId);
+              const contextFilesWithContent: Array<
+                storage.ContextFile & { content?: string }
+              > = [];
+              for (const cf of q.contextFiles || []) {
+                if (
+                  cf.origin === "user" ||
+                  cf.origin === "ai" ||
+                  cf.origin === "sandbox"
+                ) {
+                  try {
+                    const content = await fs.readFile(
+                      path.join(ctxDir, cf.id),
+                      "utf-8",
+                    );
+                    contextFilesWithContent.push({ ...cf, content });
+                  } catch {
+                    contextFilesWithContent.push(cf);
+                  }
+                }
+              }
+
               // Export full question as JSON so nothing is lost on sync-back
               const payload = JSON.stringify(
                 {
                   title: q.title,
+                  parentTitle: parentTitle ?? null,
                   systemContext: q.systemContext || "",
                   messages: q.messages,
                   codeContextFiles: q.codeContextFiles,
+                  codeAnnotations: q.codeAnnotations ?? {},
+                  codeSnippets: contextFilesWithContent,
                 },
                 null,
                 2,