@hellcoder/companion 0.107.1-preview.20260708075901.9f18d7b → 0.108.0

package/server/dashboard-summarizer.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DashboardStore } from "./dashboard-store.js";
+import { _resetForTest } from "./settings-manager.js";
+import { clearClaudeSessionHistoryCacheForTests } from "./claude-session-history.js";
+
+// The summarizer runs prompts through the headless Claude CLI (same login as
+// normal sessions). Tests either inject a fake runner or toggle the mocked CLI
+// availability below — no network and no real CLI involved.
+const cliMock = { available: true };
+vi.mock("./claude-cli-runner.js", () => ({
+  isClaudeCliAvailable: () => cliMock.available,
+  runClaudePrompt: vi.fn().mockResolvedValue(null),
+}));
+
+import {
+  _resetDashboardRunStateForTest,
+  buildTranscriptExcerpt,
+  DashboardCliUnavailableError,
+  parseSummaryResponse,
+  runDashboardUpdate,
+} from "./dashboard-summarizer.js";
+
+// Covers the three layers of the summarizer:
+// 1. buildTranscriptExcerpt — bounded, tail-biased excerpt building
+// 2. parseSummaryResponse — tolerant parsing of the model's JSON answer
+// 3. runDashboardUpdate — end-to-end over fake transcripts with an injected
+//    prompt runner, including the incremental "only changed sessions" skip.
+
+const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+
+/** Writes a minimal Claude Code transcript that discovery + history parsing accept. */
+function writeTranscript(projectsRoot: string, sessionId: string, cwd: string): string {
+  const projectDir = join(projectsRoot, "-root-projects-demo");
+  mkdirSync(projectDir, { recursive: true });
+  const file = join(projectDir, `${sessionId}.jsonl`);
+  const lines = [
+    { sessionId, cwd, gitBranch: "main", slug: "demo-task", type: "summary" },
+    {
+      sessionId,
+      type: "user",
+      timestamp: "2026-07-18T10:00:00Z",
+      message: { role: "user", content: "Please fix the login bug" },
+    },
+    {
+      sessionId,
+      type: "assistant",
+      timestamp: "2026-07-18T10:01:00Z",
+      message: {
+        role: "assistant",
+        id: "msg_1",
+        content: [{ type: "text", text: "Fixed the redirect loop and added a test." }],
+      },
+    },
+  ];
+  writeFileSync(file, lines.map((l) => JSON.stringify(l)).join("\n"), "utf-8");
+  return file;
+}
+
+describe("buildTranscriptExcerpt", () => {
+  it("formats roles and keeps message order", () => {
+    const excerpt = buildTranscriptExcerpt([
+      { role: "user", content: "do X" },
+      { role: "assistant", content: "did X" },
+    ]);
+    expect(excerpt).toBe("USER: do X\n\nASSISTANT: did X");
+  });
+
+  it("keeps the tail when the total budget is exceeded", () => {
+    const big = "x".repeat(1_400);
+    const messages = Array.from({ length: 40 }, (_, i) => ({
+      role: "user" as const,
+      content: `${i}:${big}`,
+    }));
+    const excerpt = buildTranscriptExcerpt(messages);
+    // The last message must survive; the first must be dropped.
+    expect(excerpt).toContain("39:");
+    expect(excerpt).not.toContain("USER: 0:");
+    expect(excerpt.length).toBeLessThanOrEqual(25_000);
+  });
+
+  it("truncates oversized individual messages", () => {
+    const excerpt = buildTranscriptExcerpt([{ role: "user", content: "y".repeat(5_000) }]);
+    expect(excerpt).toContain("[... truncated]");
+    expect(excerpt.length).toBeLessThan(2_000);
+  });
+});
+
+describe("parseSummaryResponse", () => {
+  it("parses a clean JSON object", () => {
+    const parsed = parseSummaryResponse(
+      '{"summary":"Done.","status":"completed","openItems":[],"archivable":true}',
+    );
+    expect(parsed).toEqual({ summary: "Done.", status: "completed", openItems: [], archivable: true });
+  });
+
+  it("extracts JSON wrapped in prose or markdown fences", () => {
+    const parsed = parseSummaryResponse(
+      'Here you go:\n```json\n{"summary":"WIP","status":"in_progress","openItems":["write tests"],"archivable":false}\n```',
+    );
+    expect(parsed?.status).toBe("in_progress");
+    expect(parsed?.openItems).toEqual(["write tests"]);
+  });
+
+  it("falls back to in_progress for unknown status values and caps openItems", () => {
+    const parsed = parseSummaryResponse(
+      `{"summary":"s","status":"weird","openItems":["1","2","3","4","5","6","7"],"archivable":"yes"}`,
+    );
+    expect(parsed?.status).toBe("in_progress");
+    expect(parsed?.openItems).toHaveLength(5);
+    // Non-boolean archivable must not be treated as true.
+    expect(parsed?.archivable).toBe(false);
+  });
+
+  it("returns null for garbage or missing summary", () => {
+    expect(parseSummaryResponse("no json here")).toBeNull();
+    expect(parseSummaryResponse('{"status":"completed"}')).toBeNull();
+  });
+});
+
+describe("runDashboardUpdate", () => {
+  let projectsRoot: string;
+  let storeDir: string;
+  let store: DashboardStore;
+
+  beforeEach(() => {
+    projectsRoot = mkdtempSync(join(tmpdir(), "dashboard-projects-"));
+    storeDir = mkdtempSync(join(tmpdir(), "dashboard-store-"));
+    store = new DashboardStore(storeDir);
+    cliMock.available = true;
+    _resetForTest(join(mkdtempSync(join(tmpdir(), "dashboard-settings-")), "settings.json"));
+    _resetDashboardRunStateForTest();
+    clearClaudeSessionHistoryCacheForTests();
+  });
+
+  afterEach(() => {
+    _resetForTest();
+    rmSync(projectsRoot, { recursive: true, force: true });
+    rmSync(storeDir, { recursive: true, force: true });
+  });
+
+  it("throws when sessions need summarizing but the Claude CLI is missing", async () => {
+    writeTranscript(projectsRoot, SESSION_ID, "/root/projects/demo");
+    cliMock.available = false;
+    await expect(
+      runDashboardUpdate({ trigger: "manual", store, projectsRoot }),
+    ).rejects.toBeInstanceOf(DashboardCliUnavailableError);
+  });
+
+  it("succeeds without the CLI when there is nothing to summarize", async () => {
+    cliMock.available = false;
+    const meta = await runDashboardUpdate({ trigger: "manual", store, projectsRoot });
+    expect(meta.lastRunStatus).toBe("success");
+    expect(meta.sessionsProcessed).toBe(0);
+  });
+
+  it("summarizes changed sessions via the runner and persists summary + run meta", async () => {
+    writeTranscript(projectsRoot, SESSION_ID, "/root/projects/demo");
+
+    const runner = vi.fn().mockResolvedValue(JSON.stringify({
+      summary: "Login bug fixed; regression test added.",
+      status: "completed",
+      openItems: [],
+      archivable: true,
+    }));
+
+    const meta = await runDashboardUpdate({ trigger: "manual", store, projectsRoot, runner });
+
+    expect(meta.lastRunStatus).toBe("success");
+    expect(meta.sessionsProcessed).toBe(1);
+    expect(meta.sessionsFailed).toBe(0);
+    expect(store.loadRunMeta()).toEqual(meta);
+
+    const summary = store.loadSummary(SESSION_ID);
+    expect(summary?.status).toBe("completed");
+    expect(summary?.archivable).toBe(true);
+    expect(summary?.cwd).toBe("/root/projects/demo");
+    expect(summary?.model).toBe("claude-haiku-4-5");
+
+    // The runner receives the transcript excerpt and the configured dashboard model.
+    const [prompt, model] = runner.mock.calls[0];
+    expect(prompt).toContain("USER: Please fix the login bug");
+    expect(model).toBe("claude-haiku-4-5");
+  });
+
+  it("skips sessions whose transcript is unchanged since the last run", async () => {
+    const file = writeTranscript(projectsRoot, SESSION_ID, "/root/projects/demo");
+    // Pin the mtime so both runs observe the same lastActivityAt.
+    utimesSync(file, new Date(1_700_000_000_000), new Date(1_700_000_000_000));
+
+    const runner = vi.fn().mockResolvedValue(JSON.stringify({
+      summary: "s", status: "in_progress", openItems: [], archivable: false,
+    }));
+
+    await runDashboardUpdate({ trigger: "manual", store, projectsRoot, runner });
+    expect(runner).toHaveBeenCalledTimes(1);
+
+    const second = await runDashboardUpdate({ trigger: "manual", store, projectsRoot, runner });
+    // No new activity → no additional runner call, session counted as skipped.
+    expect(runner).toHaveBeenCalledTimes(1);
+    expect(second.sessionsProcessed).toBe(0);
+    expect(second.sessionsSkipped).toBe(1);
+  });
+
+  it("records a failed run when the runner yields nothing", async () => {
+    writeTranscript(projectsRoot, SESSION_ID, "/root/projects/demo");
+    const runner = vi.fn().mockResolvedValue(null);
+
+    const meta = await runDashboardUpdate({ trigger: "scheduled", store, projectsRoot, runner });
+    expect(meta.lastRunStatus).toBe("error");
+    expect(meta.sessionsFailed).toBe(1);
+    expect(store.loadSummary(SESSION_ID)).toBeNull();
+  });
+});

package/server/dashboard-summarizer.ts

@@ -0,0 +1,290 @@
+import { DEFAULT_DASHBOARD_MODEL, getSettings } from "./settings-manager.js";
+import { isClaudeCliAvailable, runClaudePrompt } from "./claude-cli-runner.js";
+import { discoverClaudeSessions, type DiscoveredClaudeSession } from "./claude-session-discovery.js";
+import { getClaudeSessionHistoryPage } from "./claude-session-history.js";
+import { DashboardStore, getDashboardStore } from "./dashboard-store.js";
+import {
+  DASHBOARD_SESSION_STATUSES,
+  type DashboardRunMeta,
+  type DashboardRunProgress,
+  type DashboardRunTrigger,
+  type DashboardSessionStatus,
+  type DashboardSessionSummary,
+} from "./dashboard-types.js";
+
+// Bounded transcript excerpt so a huge session can't blow the token budget:
+// keep only the tail of the conversation, and truncate individual messages.
+const EXCERPT_MESSAGE_LIMIT = 40;
+const EXCERPT_MAX_MESSAGE_CHARS = 1_500;
+const EXCERPT_MAX_TOTAL_CHARS = 24_000;
+const DISCOVERY_LIMIT = 500;
+// Generous: each summarization pays Claude CLI startup cost on top of the model call.
+const PER_SESSION_TIMEOUT_MS = 120_000;
+
+interface ExcerptMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
+/**
+ * Builds a compact, tail-biased plain-text excerpt of a transcript.
+ * Exported for tests.
+ */
+export function buildTranscriptExcerpt(messages: ExcerptMessage[]): string {
+  const lines: string[] = [];
+  let total = 0;
+  // Walk backwards from the end so the most recent context always survives.
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    const text = msg.content.trim();
+    if (!text) continue;
+    const clipped = text.length > EXCERPT_MAX_MESSAGE_CHARS
+      ? `${text.slice(0, EXCERPT_MAX_MESSAGE_CHARS)}\n[... truncated]`
+      : text;
+    const line = `${msg.role === "user" ? "USER" : "ASSISTANT"}: ${clipped}`;
+    if (total + line.length > EXCERPT_MAX_TOTAL_CHARS) break;
+    total += line.length;
+    lines.push(line);
+  }
+  return lines.reverse().join("\n\n");
+}
+
+export interface ParsedSessionSummary {
+  summary: string;
+  status: DashboardSessionStatus;
+  openItems: string[];
+  archivable: boolean;
+}
+
+/**
+ * Tolerant parser for the model's JSON answer. Model-agnostic on purpose —
+ * works whether or not the configured model supports structured outputs.
+ * Exported for tests.
+ */
+export function parseSummaryResponse(raw: string): ParsedSessionSummary | null {
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end <= start) return null;
+
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw.slice(start, end + 1)) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+
+  const summary = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
+  if (!summary) return null;
+
+  const status = DASHBOARD_SESSION_STATUSES.includes(parsed.status as DashboardSessionStatus)
+    ? (parsed.status as DashboardSessionStatus)
+    : "in_progress";
+
+  const openItems = Array.isArray(parsed.openItems)
+    ? parsed.openItems.filter((item): item is string => typeof item === "string" && !!item.trim()).slice(0, 5)
+    : [];
+
+  return {
+    summary: summary.slice(0, 1_000),
+    status,
+    openItems,
+    archivable: parsed.archivable === true,
+  };
+}
+
+function buildPrompt(session: DiscoveredClaudeSession, excerpt: string): string {
+  return [
+    "You are generating a project-dashboard entry for a Claude Code (coding agent) session transcript.",
+    "Do not use any tools — analyze only the excerpt below and answer directly.",
+    "Answer with ONLY a JSON object — no prose, no markdown fences — with exactly these fields:",
+    `{"summary": "...", "status": "...", "openItems": ["..."], "archivable": true|false}`,
+    "",
+    '- "summary": 2-3 sentences on what the session is about and where it stands right now.',
+    '- "status": one of "completed" (task finished and verified/accepted), "in_progress" (work underway or clearly more to do), "awaiting_user" (agent asked a question or needs a decision/approval), "stalled" (errors, dead ends, or abandoned mid-task).',
+    '- "openItems": up to 5 short outstanding work items; empty array if nothing is left.',
+    '- "archivable": true only when the session is finished or clearly abandoned and keeping it active adds nothing.',
+    "",
+    `Project directory: ${session.cwd}`,
+    session.gitBranch ? `Git branch: ${session.gitBranch}` : "",
+    "",
+    "Transcript excerpt (tail of the session):",
+    excerpt,
+  ].filter(Boolean).join("\n");
+}
+
+/**
+ * One prompt → one plain-text answer. The default runner goes through the
+ * headless Claude CLI (`claude --print`), so summarization authenticates with
+ * the same Claude Code login that normal sessions use — no API key required.
+ */
+export type SummarizerRunner = (prompt: string, model: string) => Promise<string | null>;
+
+const defaultRunner: SummarizerRunner = (prompt, model) =>
+  runClaudePrompt({ prompt, model, timeoutMs: PER_SESSION_TIMEOUT_MS });
+
+// ─── Run state (module singleton) ───────────────────────────────────────────
+
+let progress: DashboardRunProgress = { state: "idle", total: 0, processed: 0, failed: 0 };
+
+export function getDashboardRunProgress(): DashboardRunProgress {
+  return { ...progress };
+}
+
+export function isDashboardRunActive(): boolean {
+  return progress.state === "running";
+}
+
+function sessionLabel(session: DiscoveredClaudeSession): string {
+  if (session.slug) return session.slug;
+  const parts = session.cwd.split("/").filter(Boolean);
+  return parts[parts.length - 1] || session.cwd;
+}
+
+export interface RunDashboardUpdateOptions {
+  trigger: DashboardRunTrigger;
+  store?: DashboardStore;
+  projectsRoot?: string;
+  /** Override the prompt runner (tests). Defaults to the headless Claude CLI. */
+  runner?: SummarizerRunner;
+}
+
+export class DashboardRunActiveError extends Error {
+  constructor() {
+    super("A dashboard update is already running");
+  }
+}
+
+export class DashboardCliUnavailableError extends Error {
+  constructor() {
+    super("Claude Code CLI not found — the dashboard summarizer uses your Claude Code login");
+  }
+}
+
+/**
+ * Runs one summarizer pass: summarize every discovered Claude session whose
+ * transcript changed since its stored summary. Sequential on purpose — this
+ * is a background job and we'd rather be slow than hit rate limits.
+ */
+export async function runDashboardUpdate(
+  options: RunDashboardUpdateOptions,
+): Promise<DashboardRunMeta> {
+  if (isDashboardRunActive()) throw new DashboardRunActiveError();
+
+  const settings = getSettings();
+  const model = settings.dashboardModel?.trim() || DEFAULT_DASHBOARD_MODEL;
+  const maxSessions = settings.dashboardMaxSessionsPerRun;
+  const store = options.store || getDashboardStore();
+  const startedAt = Date.now();
+
+  const discovered = discoverClaudeSessions({
+    limit: DISCOVERY_LIMIT,
+    projectsRoot: options.projectsRoot,
+  });
+
+  // Incremental: only sessions with activity since their last stored summary.
+  const stale = discovered.filter((session) => {
+    const existing = store.loadSummary(session.sessionId);
+    return !existing || session.lastActivityAt > existing.transcriptMtimeMs;
+  });
+  const queue = stale.slice(0, maxSessions);
+  const skipped = discovered.length - queue.length;
+
+  // Only the default (CLI-backed) runner needs the binary; an injected runner
+  // (tests) doesn't, and an empty queue never invokes the runner at all.
+  if (queue.length > 0 && !options.runner && !isClaudeCliAvailable()) {
+    throw new DashboardCliUnavailableError();
+  }
+  const runner = options.runner || defaultRunner;
+
+  progress = {
+    state: "running",
+    trigger: options.trigger,
+    total: queue.length,
+    processed: 0,
+    failed: 0,
+    startedAt,
+  };
+
+  let failed = 0;
+  try {
+    for (const session of queue) {
+      progress = { ...progress, currentSession: sessionLabel(session) };
+      const ok = await summarizeOne(session, store, runner, model, options.projectsRoot);
+      if (!ok) failed++;
+      progress = {
+        ...progress,
+        processed: progress.processed + 1,
+        failed,
+      };
+    }
+
+    const meta: DashboardRunMeta = {
+      lastRunAt: startedAt,
+      lastRunCompletedAt: Date.now(),
+      lastRunStatus: failed === 0 ? "success" : failed === queue.length && queue.length > 0 ? "error" : "partial",
+      lastRunError: failed > 0 ? `${failed} of ${queue.length} sessions failed to summarize` : undefined,
+      trigger: options.trigger,
+      model,
+      sessionsProcessed: queue.length - failed,
+      sessionsSkipped: skipped,
+      sessionsFailed: failed,
+    };
+    // Only a fully failed run keeps the previous meta's "last successful" story;
+    // we still persist it so the UI can surface the failure.
+    store.saveRunMeta(meta);
+    return meta;
+  } finally {
+    progress = { state: "idle", total: 0, processed: 0, failed: 0 };
+  }
+}
+
+async function summarizeOne(
+  session: DiscoveredClaudeSession,
+  store: DashboardStore,
+  runner: SummarizerRunner,
+  model: string,
+  projectsRoot?: string,
+): Promise<boolean> {
+  const history = getClaudeSessionHistoryPage({
+    sessionId: session.sessionId,
+    limit: EXCERPT_MESSAGE_LIMIT,
+    projectsRoot,
+  });
+  if (!history || history.messages.length === 0) return false;
+
+  const excerpt = buildTranscriptExcerpt(
+    history.messages.map((m) => ({ role: m.role, content: m.content })),
+  );
+  if (!excerpt) return false;
+
+  const raw = await runner(buildPrompt(session, excerpt), model);
+  if (!raw) return false;
+
+  const parsed = parseSummaryResponse(raw);
+  if (!parsed) {
+    console.warn(`[dashboard] Unparseable summarizer response for session ${session.sessionId}`);
+    return false;
+  }
+
+  const summary: DashboardSessionSummary = {
+    sessionId: session.sessionId,
+    cwd: session.cwd,
+    gitBranch: session.gitBranch,
+    slug: session.slug,
+    summary: parsed.summary,
+    status: parsed.status,
+    openItems: parsed.openItems,
+    archivable: parsed.archivable,
+    transcriptMtimeMs: session.lastActivityAt,
+    lastActivityAt: session.lastActivityAt,
+    summarizedAt: Date.now(),
+    model,
+  };
+  store.saveSummary(summary);
+  return true;
+}
+
+/** Test hook — reset the module-level run state. */
+export function _resetDashboardRunStateForTest(): void {
+  progress = { state: "idle", total: 0, processed: 0, failed: 0 };
+}

package/server/dashboard-types.ts

@@ -0,0 +1,70 @@
+// ─── Project Dashboard types ────────────────────────────────────────────────
+// The dashboard never reads live session data. A nightly (or manually
+// triggered) summarizer job writes per-session summaries + a run-meta record
+// to ~/.companion/dashboard/, and the dashboard UI reads only that store.
+
+/** Where a session stands, as classified by the summarizer LLM. */
+export type DashboardSessionStatus =
+  | "completed"
+  | "in_progress"
+  | "awaiting_user"
+  | "stalled";
+
+export const DASHBOARD_SESSION_STATUSES: DashboardSessionStatus[] = [
+  "completed",
+  "in_progress",
+  "awaiting_user",
+  "stalled",
+];
+
+export interface DashboardSessionSummary {
+  /** Claude CLI session id — the transcript's .jsonl basename. */
+  sessionId: string;
+  cwd: string;
+  gitBranch?: string;
+  /** Session slug from the transcript metadata, if present. */
+  slug?: string;
+  /** 2-3 sentence "where it stands" summary. */
+  summary: string;
+  status: DashboardSessionStatus;
+  /** Outstanding work items, empty when the task is done. */
+  openItems: string[];
+  /** Summarizer's hint that this session is finished/abandoned and safe to archive. */
+  archivable: boolean;
+  /** Transcript mtime observed when this summary was generated (incremental-skip key). */
+  transcriptMtimeMs: number;
+  /** Last activity timestamp of the session (= transcript mtime). */
+  lastActivityAt: number;
+  summarizedAt: number;
+  /** Model that produced this summary. */
+  model: string;
+}
+
+export type DashboardRunTrigger = "manual" | "scheduled";
+
+export type DashboardRunStatus = "success" | "partial" | "error";
+
+export interface DashboardRunMeta {
+  /** Start of the last completed run (successful or not). */
+  lastRunAt: number;
+  lastRunCompletedAt: number;
+  lastRunStatus: DashboardRunStatus;
+  lastRunError?: string;
+  trigger: DashboardRunTrigger;
+  model: string;
+  sessionsProcessed: number;
+  sessionsSkipped: number;
+  sessionsFailed: number;
+}
+
+/** Live progress of an in-flight summarizer run (not persisted). */
+export interface DashboardRunProgress {
+  state: "idle" | "running";
+  trigger?: DashboardRunTrigger;
+  total: number;
+  processed: number;
+  failed: number;
+  /** Short label (project dir name or slug) of the session being summarized. */
+  currentSession?: string;
+  startedAt?: number;
+}

package/server/index.ts

@@ -34,6 +34,7 @@ import { LinearAgentBridge } from "./linear-agent-bridge.js";
 import { NoVncProxy } from "./novnc-proxy.js";
 
 import { startPeriodicCheck, setServiceMode } from "./update-checker.js";
+import { startDashboardScheduler } from "./dashboard-scheduler.js";
 import {
   startPeriodicCheck as startClaudeCompatPeriodicCheck,
 } from "./claude-compat-checker.js";
@@ -369,6 +370,9 @@ restoreTailscaleFunnel(port).catch((err) => {
 // ── Update checker ──────────────────────────────────────────────────────────
 startPeriodicCheck();
 
+// ── Nightly dashboard summarizer (opt-in via settings) ──────────────────────
+startDashboardScheduler();
+
 // ── Claude CLI compatibility checker — surfaces banner when CLI is 2.1.121+ ─
 startClaudeCompatPeriodicCheck();
 

package/server/linear-connections.test.ts

@@ -60,6 +60,10 @@ beforeEach(() => {
     aiValidationEnabled: false,
     aiValidationAutoApprove: true,
     aiValidationAutoDeny: false,
+    dashboardEnabled: false,
+    dashboardModel: "claude-haiku-4-5",
+    dashboardRunHour: 3,
+    dashboardMaxSessionsPerRun: 30,
     publicUrl: "",
     updateChannel: "stable",
     dockerAutoUpdate: false,
@@ -192,6 +196,10 @@ describe("linear-connections", () => {
       aiValidationEnabled: false,
       aiValidationAutoApprove: true,
       aiValidationAutoDeny: false,
+      dashboardEnabled: false,
+      dashboardModel: "claude-haiku-4-5",
+      dashboardRunHour: 3,
+      dashboardMaxSessionsPerRun: 30,
       publicUrl: "",
       updateChannel: "stable",
       dockerAutoUpdate: false,
@@ -234,6 +242,10 @@ describe("linear-connections", () => {
       aiValidationEnabled: false,
       aiValidationAutoApprove: true,
       aiValidationAutoDeny: false,
+      dashboardEnabled: false,
+      dashboardModel: "claude-haiku-4-5",
+      dashboardRunHour: 3,
+      dashboardMaxSessionsPerRun: 30,
       publicUrl: "",
       updateChannel: "stable",
       dockerAutoUpdate: false,
@@ -295,6 +307,10 @@ describe("linear-connections", () => {
       aiValidationEnabled: false,
       aiValidationAutoApprove: true,
       aiValidationAutoDeny: false,
+      dashboardEnabled: false,
+      dashboardModel: "claude-haiku-4-5",
+      dashboardRunHour: 3,
+      dashboardMaxSessionsPerRun: 30,
       publicUrl: "",
       updateChannel: "stable",
       dockerAutoUpdate: false,