agent-mockingbird 0.0.1

package/apps/server/src/backend/opencode/systemPrompt.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import type { AgentMockingbirdConfig } from "../config/schema";
+
+const tempDirs: string[] = [];
+const originalConfigPath = process.env.AGENT_MOCKINGBIRD_CONFIG_PATH;
+
+afterEach(() => {
+  process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = originalConfigPath;
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("systemPrompt helpers", () => {
+  test("includes config, memory, cron, and workspace bootstrap guidance", async () => {
+    const root = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-system-prompt-"));
+    tempDirs.push(root);
+    const workspaceDir = path.join(root, "workspace");
+    mkdirSync(workspaceDir, { recursive: true });
+    writeFileSync(path.join(workspaceDir, "AGENTS.md"), "# Workspace Guide\n\nUse the workspace guide.\n");
+    const exampleConfig = JSON.parse(
+      readFileSync(path.resolve(import.meta.dir, "../../../../../agent-mockingbird.config.example.json"), "utf8"),
+    ) as AgentMockingbirdConfig;
+    exampleConfig.workspace = {
+      pinnedDirectory: workspaceDir,
+    };
+    exampleConfig.runtime.opencode.directory = workspaceDir;
+    exampleConfig.runtime.memory.workspaceDir = workspaceDir;
+    exampleConfig.runtime.memory.enabled = true;
+    exampleConfig.runtime.memory.toolMode = "hybrid";
+    exampleConfig.runtime.opencode.bootstrap.enabled = true;
+    exampleConfig.runtime.opencode.bootstrap.includeAgentPrompt = false;
+    writeFileSync(
+      path.join(root, "config.json"),
+      JSON.stringify(exampleConfig),
+    );
+    process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = path.join(root, "config.json");
+
+    const { buildAgentMockingbirdSystemPrompt } = await import("./systemPrompt");
+    const prompt = buildAgentMockingbirdSystemPrompt() ?? "";
+
+    expect(prompt).toContain("Config policy:");
+    expect(prompt).toContain("Memory policy:");
+    expect(prompt).toContain("Cron policy:");
+    expect(prompt).toContain("# Project Context");
+    expect(prompt).toContain("Use the workspace guide.");
+  });
+
+  test("builds a compaction prompt with OpenClaw-style headings and local guidance", async () => {
+    const root = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-compaction-context-"));
+    tempDirs.push(root);
+    const workspaceDir = path.join(root, "workspace");
+    mkdirSync(workspaceDir, { recursive: true });
+    writeFileSync(path.join(workspaceDir, "AGENTS.md"), "# Workspace Guide\n\nUse the workspace guide.\n");
+    const exampleConfig = JSON.parse(
+      readFileSync(path.resolve(import.meta.dir, "../../../../../agent-mockingbird.config.example.json"), "utf8"),
+    ) as AgentMockingbirdConfig;
+    exampleConfig.workspace = {
+      pinnedDirectory: workspaceDir,
+    };
+    exampleConfig.runtime.opencode.directory = workspaceDir;
+    exampleConfig.runtime.memory.workspaceDir = workspaceDir;
+    exampleConfig.runtime.memory.enabled = true;
+    exampleConfig.runtime.memory.toolMode = "hybrid";
+    exampleConfig.runtime.opencode.bootstrap.enabled = true;
+    exampleConfig.runtime.opencode.bootstrap.includeAgentPrompt = false;
+    writeFileSync(path.join(root, "config.json"), JSON.stringify(exampleConfig));
+    process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = path.join(root, "config.json");
+
+    const { buildAgentMockingbirdCompactionPrompt } = await import("./systemPrompt");
+    const prompt = buildAgentMockingbirdCompactionPrompt();
+
+    expect(prompt).toContain("Compaction rules:");
+    expect(prompt).toContain("## Decisions");
+    expect(prompt).toContain("## Pending user asks");
+    expect(prompt).toContain("## Exact identifiers");
+    expect(prompt).toContain("Agent Mockingbird continuation notes:");
+    expect(prompt).toContain("Memory follow-through:");
+    expect(prompt).toContain("Workspace bootstrap context:");
+    expect(prompt).toContain("# Project Context");
+  });
+
+  test("adds session-aware compaction prompt context from the mirrored transcript", async () => {
+    const root = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-compaction-session-"));
+    tempDirs.push(root);
+    const workspaceDir = path.join(root, "workspace");
+    mkdirSync(workspaceDir, { recursive: true });
+    writeFileSync(path.join(workspaceDir, "AGENTS.md"), "# Workspace Guide\n\nUse the workspace guide.\n");
+    const exampleConfig = JSON.parse(
+      readFileSync(path.resolve(import.meta.dir, "../../../../../agent-mockingbird.config.example.json"), "utf8"),
+    ) as AgentMockingbirdConfig;
+    exampleConfig.workspace = {
+      pinnedDirectory: workspaceDir,
+    };
+    exampleConfig.runtime.opencode.directory = workspaceDir;
+    exampleConfig.runtime.memory.workspaceDir = workspaceDir;
+    writeFileSync(path.join(root, "config.json"), JSON.stringify(exampleConfig));
+    process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = path.join(root, "config.json");
+
+    const { appendChatExchange, createSession, resetDatabaseToDefaults, setRuntimeSessionBinding } = await import(
+      "../db/repository"
+    );
+    resetDatabaseToDefaults();
+    const session = createSession({ title: "Compaction Test" });
+    setRuntimeSessionBinding("opencode", session.id, "sess-ctx");
+    appendChatExchange({
+      sessionId: session.id,
+      userContent: "Please update apps/server/src/backend/opencode/systemPrompt.ts and keep port 3001 and https://example.test/docs in mind.",
+      assistantContent: "I am investigating the compaction hook and runtime routes now.",
+      source: "runtime",
+      usage: {
+        requestCountDelta: 1,
+        inputTokensDelta: 10,
+        outputTokensDelta: 10,
+        estimatedCostUsdDelta: 0,
+      },
+    });
+    appendChatExchange({
+      sessionId: session.id,
+      userContent: "Do not lose the unresolved follow-up about /api/mockingbird/runtime/compaction-context on 2026-03-15.",
+      assistantContent: "I will preserve that exact endpoint and date in the continuation notes.",
+      source: "runtime",
+      usage: {
+        requestCountDelta: 1,
+        inputTokensDelta: 10,
+        outputTokensDelta: 10,
+        estimatedCostUsdDelta: 0,
+      },
+    });
+
+    const { buildAgentMockingbirdCompactionPrompt } = await import("./systemPrompt");
+    const prompt = buildAgentMockingbirdCompactionPrompt("sess-ctx");
+
+    expect(prompt).toContain("Session-specific context to preserve:");
+    expect(prompt).toContain("Transcript continuity requirements:");
+    expect(prompt).toContain("Latest user ask to carry forward:");
+    expect(prompt).toContain("/api/mockingbird/runtime/compaction-context");
+    expect(prompt).toContain("2026-03-15");
+    expect(prompt).toContain("Recent turns to preserve verbatim when useful:");
+    expect(prompt).toContain("apps/server/src/backend/opencode/systemPrompt.ts");
+  });
+});

package/apps/server/src/backend/opencode/systemPrompt.ts

@@ -0,0 +1,284 @@
+import { buildWorkspaceBootstrapPromptContext } from "../agents/bootstrapContext";
+import { getConfigSnapshot } from "../config/service";
+import {
+  getLocalSessionIdByRuntimeBinding,
+  listMessagesForSession,
+} from "../db/repository";
+import { env } from "../env";
+
+const OPENCODE_RUNTIME_ID = "opencode";
+const OPENCODE_COMPACTION_HEADINGS = [
+  "## Decisions",
+  "## Open TODOs",
+  "## Constraints/Rules",
+  "## Pending user asks",
+  "## Exact identifiers",
+] as const;
+const MAX_COMPACTION_RECENT_MESSAGES = 6;
+const MAX_COMPACTION_RECENT_MESSAGE_CHARS = 220;
+const MAX_COMPACTION_IDENTIFIERS = 10;
+const MAX_COMPACTION_PATHS = 8;
+
+function trimCompactionLine(value: string) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  if (compact.length <= MAX_COMPACTION_RECENT_MESSAGE_CHARS) return compact;
+  return `${compact.slice(0, MAX_COMPACTION_RECENT_MESSAGE_CHARS - 3).trimEnd()}...`;
+}
+
+function collectRecentTranscriptLines(externalSessionId?: string) {
+  const sessionId = externalSessionId?.trim()
+    ? getLocalSessionIdByRuntimeBinding(OPENCODE_RUNTIME_ID, externalSessionId)
+    : null;
+  if (!sessionId) return [];
+  const messages = listMessagesForSession(sessionId);
+  return messages
+    .slice(-MAX_COMPACTION_RECENT_MESSAGES)
+    .map(message => {
+      const content = trimCompactionLine(message.content);
+      if (!content) return null;
+      const role = message.role === "user" ? "User" : "Assistant";
+      return `- ${role}: ${content}`;
+    })
+    .filter((line): line is string => Boolean(line));
+}
+
+function collectLatestUserAsk(externalSessionId?: string) {
+  const sessionId = externalSessionId?.trim()
+    ? getLocalSessionIdByRuntimeBinding(OPENCODE_RUNTIME_ID, externalSessionId)
+    : null;
+  if (!sessionId) return null;
+  const messages = listMessagesForSession(sessionId);
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "user") continue;
+    const content = trimCompactionLine(message.content);
+    if (content) return content;
+  }
+  return null;
+}
+
+function collectOpaqueIdentifiers(externalSessionId?: string) {
+  const sessionId = externalSessionId?.trim()
+    ? getLocalSessionIdByRuntimeBinding(OPENCODE_RUNTIME_ID, externalSessionId)
+    : null;
+  if (!sessionId) return [];
+  const messages = listMessagesForSession(sessionId);
+  const haystack = messages.slice(-10).map(message => message.content).join("\n");
+  const matches =
+    haystack.match(
+      /([A-Fa-f0-9]{8,}|https?:\/\/\S+|\/[\w./-]{2,}|[A-Za-z]:\\[\w\\./-]+|\b\d{4}-\d{2}-\d{2}\b|\b\d{6,}\b|localhost:\d{2,5}|\b\d{2,5}\b)/g,
+    ) ?? [];
+  return [...new Set(matches.map(match => match.replace(/[),.;]+$/g, "").trim()).filter(Boolean))].slice(
+    0,
+    MAX_COMPACTION_IDENTIFIERS,
+  );
+}
+
+function collectMentionedPaths(externalSessionId?: string) {
+  const sessionId = externalSessionId?.trim()
+    ? getLocalSessionIdByRuntimeBinding(OPENCODE_RUNTIME_ID, externalSessionId)
+    : null;
+  if (!sessionId) return [];
+  const messages = listMessagesForSession(sessionId);
+  const haystack = messages.slice(-12).map(message => message.content).join("\n");
+  const matches =
+    haystack.match(
+      /\b(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\b|\b[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|json|md|sql|mjs|cjs|css|html)\b/g,
+    ) ?? [];
+  return [...new Set(matches.map(match => match.replace(/[),.;]+$/g, "").trim()).filter(Boolean))].slice(
+    0,
+    MAX_COMPACTION_PATHS,
+  );
+}
+
+function buildSessionAwareCompactionContext(externalSessionId?: string) {
+  const latestAsk = collectLatestUserAsk(externalSessionId);
+  const identifiers = collectOpaqueIdentifiers(externalSessionId);
+  const paths = collectMentionedPaths(externalSessionId);
+  const recentTranscript = collectRecentTranscriptLines(externalSessionId);
+  const sections: string[] = [];
+
+  if (latestAsk || identifiers.length > 0 || paths.length > 0) {
+    const lines = [
+      "Transcript continuity requirements:",
+      "- Preserve the latest unresolved user ask and any unfinished work, approvals, or blockers.",
+      "- Preserve exact literal identifiers when they matter for continuation: file paths, URLs, ports, dates, hashes, IDs.",
+    ];
+    if (latestAsk) {
+      lines.push(`- Latest user ask to carry forward: ${latestAsk}`);
+    }
+    if (identifiers.length > 0) {
+      lines.push(`- Exact identifiers seen recently: ${identifiers.join(", ")}`);
+    }
+    if (paths.length > 0) {
+      lines.push(`- Files and paths explicitly mentioned: ${paths.join(", ")}`);
+    }
+    sections.push(lines.join("\n"));
+  }
+
+  if (recentTranscript.length > 0) {
+    sections.push(
+      [
+        "Recent turns to preserve verbatim when useful:",
+        ...recentTranscript,
+      ].join("\n"),
+    );
+  }
+
+  return sections;
+}
+
+function currentMemoryConfig() {
+  return getConfigSnapshot().config.runtime.memory;
+}
+
+function buildCompactionRequirementLines() {
+  return [
+    "Compaction rules:",
+    "- Write the summary body in the primary language used in the conversation.",
+    "- Keep the exact section headings shown below unchanged.",
+    "- Do not translate or alter code, file paths, identifiers, error messages, URLs, ports, dates, hashes, or filenames.",
+    "- Preserve active tasks, current status, blockers, approvals, unresolved questions, and promised follow-ups.",
+    "- Preserve the latest unresolved user ask even if it appeared very recently.",
+    "- Prefer recent context over older history when choosing what to keep.",
+    "",
+    "Produce the summary with these exact headings, in this exact order:",
+    ...OPENCODE_COMPACTION_HEADINGS,
+  ];
+}
+
+function buildConfigPolicyLines() {
+  return [
+    "Config policy:",
+    "- Use config_manager for runtime configuration changes.",
+    "- Use agent_type_manager for dedicated agent type CRUD operations.",
+    "- Prefer patch_config with expectedHash from get_config to avoid conflicts.",
+    "- Safe config writes enforce policy checks and may reject protected paths.",
+    "- Keep runSmokeTest enabled unless explicitly instructed otherwise.",
+  ];
+}
+
+function buildInteractionPolicyLines() {
+  return [
+    "Interaction policy:",
+    "- If the user asks for an interactive multiple-choice question, use the question UI/tool instead of plain text.",
+    "- Keep option labels short and descriptions concise.",
+  ];
+}
+
+function buildMemoryPolicyLines() {
+  return [
+    "Memory policy:",
+    "- Use memory_search when a request likely depends on prior durable context.",
+    "- Prefer one search call first; then use memory_get only for the top 1-2 cited records before relying on details.",
+    "- For people/relationships, use concrete terms (for example: daughter, spouse, partner, child, parent, names) instead of only generic words.",
+    "- For broad domains (for example: portfolio), run one adjacent-term refinement (for example: metals, silver, bonds, allocation) if the first search misses.",
+    "- Skip memory tool calls for clearly self-contained tasks.",
+    "- If the first memory_search misses, do one refined query with entity/relationship terms before concluding no memory exists.",
+    "- Use memory_remember when new context could be useful later.",
+    "- Prefer supersedes when replacing older memory records.",
+  ];
+}
+
+function buildCronPolicyLines() {
+  return [
+    "Cron policy:",
+    "- Use cron_manager for recurring automation and background checks.",
+    "- Prefer deterministic jobs when possible; only invoke the model when useful.",
+    "- Review existing jobs before creating new ones to avoid duplicates.",
+  ];
+}
+
+export function buildAgentMockingbirdSystemPrompt() {
+  const memoryConfig = currentMemoryConfig();
+  const config = getConfigSnapshot().config;
+  const workspaceContext = buildWorkspaceBootstrapPromptContext({
+    config,
+  });
+  const lines: string[] = [];
+
+  lines.push(...buildConfigPolicyLines());
+
+  lines.push("");
+  lines.push(...buildInteractionPolicyLines());
+
+  if (memoryConfig.enabled && memoryConfig.toolMode !== "inject_only") {
+    lines.push("", ...buildMemoryPolicyLines());
+  }
+
+  if (env.AGENT_MOCKINGBIRD_CRON_ENABLED) {
+    lines.push("", ...buildCronPolicyLines());
+  }
+
+  if (workspaceContext.section) {
+    lines.push("", workspaceContext.section);
+  }
+
+  return lines.length ? lines.join("\n") : undefined;
+}
+
+export function buildAgentMockingbirdCompactionContext(externalSessionId?: string) {
+  const memoryConfig = currentMemoryConfig();
+  const workspaceContext = buildWorkspaceBootstrapPromptContext({
+    config: getConfigSnapshot().config,
+  });
+  const sections: string[] = [];
+
+  sections.push(
+    [
+      "Agent Mockingbird continuation notes:",
+      "- Mention any config changes made through config_manager or agent_type_manager and whether they were applied successfully.",
+      "- Mention any pending approvals or interactive questions that still block progress.",
+      "- Mention any cron jobs or automation changes that were created, updated, or investigated if they affect next steps.",
+    ].join("\n"),
+  );
+
+  if (memoryConfig.enabled && memoryConfig.toolMode !== "inject_only") {
+    sections.push(
+      [
+        "Memory follow-through:",
+        "- Include any retrieved memory records that materially changed the approach.",
+        "- Include any new facts that should probably be persisted with memory_remember if they were not saved yet.",
+      ].join("\n"),
+    );
+  }
+
+  sections.push(...buildSessionAwareCompactionContext(externalSessionId));
+
+  if (workspaceContext.section) {
+    sections.push(
+      [
+        "Workspace bootstrap context:",
+        workspaceContext.section,
+      ].join("\n"),
+    );
+  }
+
+  return sections;
+}
+
+export function buildAgentMockingbirdCompactionPrompt(externalSessionId?: string) {
+  const contextSections = buildAgentMockingbirdCompactionContext(externalSessionId);
+  const lines: string[] = [];
+
+  lines.push(
+    "You are generating a compact factual continuation summary for an Agent Mockingbird coding session.",
+  );
+  lines.push(
+    "The next agent will use your summary to resume work without losing important technical context.",
+  );
+  lines.push("");
+  lines.push(...buildCompactionRequirementLines());
+
+  if (contextSections.length > 0) {
+    lines.push("");
+    lines.push("Session-specific context to preserve:");
+    lines.push("");
+    lines.push(...contextSections);
+  }
+
+  lines.push("");
+  lines.push("Return only the summary, using the exact headings above.");
+
+  return lines.join("\n");
+}

package/apps/server/src/backend/paths.ts

@@ -0,0 +1,57 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+import { env } from "./env";
+
+function sourceRoot() {
+  return path.resolve(import.meta.dir, "../../../../");
+}
+
+export function getBinaryDir(): string {
+  return process.cwd();
+}
+
+function getProjectRoot(): string {
+  return process.cwd();
+}
+
+export function resolveDataPath(...segments: string[]): string {
+  return path.resolve(getProjectRoot(), "data", ...segments);
+}
+
+function resolveAgentMockingbirdDataDir(): string {
+  const configuredPath = env.AGENT_MOCKINGBIRD_CONFIG_PATH?.trim();
+  if (!configuredPath) {
+    return resolveDataPath();
+  }
+  return path.dirname(path.resolve(configuredPath));
+}
+
+function workspaceFingerprint(workspaceDir: string): string {
+  return createHash("sha256").update(path.resolve(workspaceDir)).digest("hex").slice(0, 16);
+}
+
+export function resolveManagedOpencodeConfigDir(workspaceDir: string): string {
+  const explicitConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (explicitConfigDir) {
+    return path.resolve(explicitConfigDir);
+  }
+  return path.join(resolveAgentMockingbirdDataDir(), "opencode-config", workspaceFingerprint(workspaceDir));
+}
+
+export function resolveAppDistDir(): string | null {
+  const candidates = [
+    path.resolve(process.cwd(), "dist", "app"),
+    path.resolve(process.cwd(), "vendor", "opencode", "packages", "app", "dist"),
+    path.resolve(sourceRoot(), "dist", "app"),
+    path.resolve(sourceRoot(), "vendor", "opencode", "packages", "app", "dist"),
+    path.resolve(path.dirname(process.execPath), "app"),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  return null;
+}

package/apps/server/src/backend/prompts/service.ts

@@ -0,0 +1,100 @@
+import {
+  type QuestionInfo,
+  type QuestionRequest,
+  type PermissionRequest,
+} from "@opencode-ai/sdk/v2/client";
+
+import { getConfigSnapshot } from "../config/service";
+import { getLocalSessionIdByRuntimeBinding } from "../db/repository";
+import { createOpencodeV2ClientFromConnection, unwrapSdkData } from "../opencode/client";
+
+const OPENCODE_RUNTIME_ID = "opencode";
+
+interface PendingPermissionPrompt {
+  id: string;
+  sessionId: string;
+  permission: string;
+  patterns: string[];
+  metadata: Record<string, unknown>;
+  always: string[];
+}
+
+interface PendingQuestionPrompt {
+  id: string;
+  sessionId: string;
+  questions: QuestionInfo[];
+}
+
+interface PendingPromptsSnapshot {
+  pendingPermissions: PendingPermissionPrompt[];
+  pendingQuestions: PendingQuestionPrompt[];
+}
+
+function createPromptClient() {
+  const config = getConfigSnapshot().config.runtime.opencode;
+  return {
+    client: createOpencodeV2ClientFromConnection({
+      baseUrl: config.baseUrl,
+      directory: config.directory,
+    }),
+    timeoutMs: config.timeoutMs,
+  };
+}
+
+function toLocalSessionId(externalSessionId: string) {
+  return getLocalSessionIdByRuntimeBinding(OPENCODE_RUNTIME_ID, externalSessionId);
+}
+
+function normalizePendingPermission(input: PermissionRequest): PendingPermissionPrompt | null {
+  const localSessionId = toLocalSessionId(input.sessionID);
+  if (!localSessionId) return null;
+  return {
+    id: input.id,
+    sessionId: localSessionId,
+    permission: input.permission,
+    patterns: Array.isArray(input.patterns) ? input.patterns : [],
+    metadata:
+      input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata)
+        ? input.metadata
+        : {},
+    always: Array.isArray(input.always) ? input.always : [],
+  };
+}
+
+function normalizePendingQuestion(input: QuestionRequest): PendingQuestionPrompt | null {
+  const localSessionId = toLocalSessionId(input.sessionID);
+  if (!localSessionId) return null;
+  return {
+    id: input.id,
+    sessionId: localSessionId,
+    questions: Array.isArray(input.questions) ? input.questions : [],
+  };
+}
+
+export async function listPendingPrompts(): Promise<PendingPromptsSnapshot> {
+  const { client, timeoutMs } = createPromptClient();
+  const options = {
+    responseStyle: "data" as const,
+    throwOnError: true as const,
+    signal: AbortSignal.timeout(timeoutMs),
+  };
+
+  const [permissionListRaw, questionListRaw] = await Promise.all([
+    client.permission.list(undefined, options),
+    client.question.list(undefined, options),
+  ]);
+
+  const permissions = (unwrapSdkData<PermissionRequest[]>(permissionListRaw) ?? [])
+    .map(normalizePendingPermission)
+    .filter((item): item is PendingPermissionPrompt => Boolean(item))
+    .sort((left, right) => left.id.localeCompare(right.id));
+  const questions = (unwrapSdkData<QuestionRequest[]>(questionListRaw) ?? [])
+    .map(normalizePendingQuestion)
+    .filter((item): item is PendingQuestionPrompt => Boolean(item))
+    .sort((left, right) => left.id.localeCompare(right.id));
+
+  return {
+    pendingPermissions: permissions,
+    pendingQuestions: questions,
+  };
+}