careermate 0.0.4 → 0.0.6

package/packages/core/src/summary.ts

@@ -40,11 +40,39 @@ export interface HomeSummary {
   in_progress: { application: ApplicationRecord; job: JobRecord | null; status_label: string }[];
   recent_cover_letters: CoverLetterRecord[];
   interview_todo: { job: JobRecord; status_label: string }[];
+  deadlines: { job: JobRecord; status: ApplicationStatus; status_label: string; days_left: number }[];
+  followups: { job: JobRecord; days_since: number }[];
   recent_activity: ActivityRecord[];
 }
 
 const ACTIVE: ApplicationStatus[] = ['draft', 'planned', 'applied', 'document_passed', 'interview'];
 
+// Deadline nudge applies only while the posting still needs action (not yet applied).
+const DEADLINE_ACTIONABLE: ApplicationStatus[] = ['draft', 'planned'];
+// Surface a deadline once it's within this many days (overdue items are always shown).
+const DEADLINE_SOON_DAYS = 14;
+// Suggest a follow-up when an application has sat in 'applied' this many days with no response.
+const FOLLOWUP_STALE_DAYS = 10;
+const DAY_MS = 86400000;
+
+/** Whole days from `now`'s local midnight to a `YYYY-MM-DD` date (future > 0, today = 0, past < 0); null if unparseable. */
+function daysUntilDate(dateStr: string | null | undefined, now: Date): number | null {
+  if (!dateStr) return null;
+  const d = new Date(`${dateStr}T00:00:00`);
+  if (isNaN(d.getTime())) return null;
+  const today = new Date(now);
+  today.setHours(0, 0, 0, 0);
+  return Math.round((d.getTime() - today.getTime()) / DAY_MS);
+}
+
+/** Whole days elapsed since an ISO timestamp up to `now`; null if unparseable. */
+function daysSinceTimestamp(iso: string | null | undefined, now: Date): number | null {
+  if (!iso) return null;
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return null;
+  return Math.floor((now.getTime() - d.getTime()) / DAY_MS);
+}
+
 export function jobWithMeta(job: JobRecord): JobWithMeta {
   const app = applicationRepo.getByJob(job.id);
   const fit = fitRepo.getByJob(job.id);
@@ -52,11 +80,12 @@ export function jobWithMeta(job: JobRecord): JobWithMeta {
   return { ...job, status, status_label: APPLICATION_STATUS_LABELS[status], fit_score: fit?.score ?? null };
 }
 
-export function getHomeSummary(): HomeSummary {
+export function getHomeSummary(now: Date = new Date()): HomeSummary {
   const onboarding = getOnboardingStatus();
   const jobs = jobRepo.list();
   const applications = applicationRepo.list();
   const coverLetters = coverLetterRepo.list();
+  const statusByJob = new Map(applications.map((a) => [a.job_id, a]));
 
   const status_breakdown = (Object.keys(APPLICATION_STATUS_LABELS) as ApplicationStatus[]).map((status) => ({
     status,
@@ -75,6 +104,33 @@ export function getHomeSummary(): HomeSummary {
     })
     .filter((x): x is { job: JobRecord; status_label: string } => x !== null);
 
+  // Deadline nudges: postings still awaiting action (draft/planned) whose deadline
+  // is overdue or within DEADLINE_SOON_DAYS. Most urgent (overdue) first.
+  const deadlines = jobs
+    .map((job) => {
+      const status = statusByJob.get(job.id)?.status ?? 'draft';
+      if (!DEADLINE_ACTIONABLE.includes(status)) return null;
+      const days_left = daysUntilDate(job.deadline, now);
+      if (days_left == null || days_left > DEADLINE_SOON_DAYS) return null;
+      return { job, status, status_label: APPLICATION_STATUS_LABELS[status], days_left };
+    })
+    .filter((x): x is { job: JobRecord; status: ApplicationStatus; status_label: string; days_left: number } => x !== null)
+    .sort((a, b) => a.days_left - b.days_left)
+    .slice(0, 5);
+
+  // Follow-up nudges: applications sitting in 'applied' with no response for a while.
+  const followups = applications
+    .filter((a) => a.status === 'applied')
+    .map((a) => {
+      const days_since = daysSinceTimestamp(a.applied_at, now);
+      if (days_since == null || days_since < FOLLOWUP_STALE_DAYS) return null;
+      const job = jobRepo.get(a.job_id);
+      return job ? { job, days_since } : null;
+    })
+    .filter((x): x is { job: JobRecord; days_since: number } => x !== null)
+    .sort((a, b) => b.days_since - a.days_since)
+    .slice(0, 5);
+
   return {
     onboarding,
     counts: {
@@ -95,6 +151,8 @@ export function getHomeSummary(): HomeSummary {
     }),
     recent_cover_letters: coverLetters.slice(0, 5),
     interview_todo,
+    deadlines,
+    followups,
     recent_activity: activityRepo.recent(10),
   };
 }

package/packages/core/src/verify/lint.ts

@@ -198,6 +198,10 @@ export function lintArtifact(
   const strict = !!opts.strict;
 
   const blocking: LintReport['blocking'] = [];
+  // Save-gate currently fires for cover letters only. The other `kind`s
+  // ('resume' | 'fit' | 'interview') are accepted and linted (signals/provenance
+  // still computed) but not yet hard-gated — that's the deferred B-2 scope, not a
+  // dead branch. See docs/career-os EOP B-2.
   if (corpusAvailable && kind === 'cover_letter') {
     // Always block suspected fabrication (numbers tracing to nothing).
     if (provenance.fabricated.length > 0) {

package/packages/db/src/index.ts

@@ -20,5 +20,6 @@ export {
   applicationRepo,
   interviewRepo,
   activityRepo,
+  timelineRepo,
   getEntityCounts,
 } from './repositories.ts';

package/packages/db/src/schema.ts

@@ -283,6 +283,23 @@ export const MIGRATIONS: string[] = [
   COMMIT;
   PRAGMA foreign_keys=ON;
   `,
+
+  // v3 — per-job timeline entries. Document/cover-letter refs live in payload
+  // snapshots instead of FKs so deleting a document does not erase the history.
+  `
+  CREATE TABLE IF NOT EXISTS application_timeline_events (
+    id TEXT PRIMARY KEY,
+    job_id TEXT NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+    type TEXT NOT NULL,
+    title TEXT NOT NULL,
+    summary TEXT,
+    payload TEXT NOT NULL DEFAULT '{}',
+    occurred_at TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_timeline_job ON application_timeline_events(job_id, occurred_at ASC);
+  `,
 ];
 
 export function migrate(db: DatabaseSync): { from: number; to: number } {

package/packages/exporters/src/index.ts

@@ -284,23 +284,34 @@ export function interviewPrepToMarkdown(
     ? joinBlocks(['## 1분 자기소개', prep.self_introduction.trim()])
     : '';
 
-  const questionsBlock = prep.questions?.length
-    ? joinBlocks([
-        '## 예상 질문',
-        ...prep.questions.map((q, idx) =>
-          joinBlocks([
-            `### Q${idx + 1}. ${q.question}`,
-            q.intent?.trim() ? kv('의도', q.intent) : '',
-            q.answer_outline?.trim()
-              ? joinBlocks(['**답변 가이드**', q.answer_outline.trim()])
-              : '',
-            q.followups?.length
-              ? joinBlocks(['**예상 꼬리 질문**', bulletList(q.followups)])
-              : '',
-          ]),
-        ),
-      ])
-    : '';
+  const renderQuestion = (q: InterviewPrepRecord['questions'][number], idx: number, level: string) =>
+    joinBlocks([
+      `${level} Q${idx + 1}. ${q.question}`,
+      q.intent?.trim() ? kv('의도', q.intent) : '',
+      q.answer_outline?.trim()
+        ? joinBlocks(['**답변 가이드**', q.answer_outline.trim()])
+        : '',
+      q.followups?.length
+        ? joinBlocks(['**예상 꼬리 질문**', bulletList(q.followups)])
+        : '',
+    ]);
+
+  let questionsBlock = '';
+  if (prep.questions?.length) {
+    const technical = prep.questions.filter((q) => (q.category ?? 'technical') === 'technical');
+    const behavioral = prep.questions.filter((q) => q.category === 'behavioral');
+    // Split into 기술 / 인성·컬처핏 sub-sections only when both tracks are present;
+    // a single-track sheet stays flat (backward-compatible output).
+    questionsBlock = behavioral.length
+      ? joinBlocks([
+          '## 예상 질문',
+          technical.length
+            ? joinBlocks(['### 기술 면접', ...technical.map((q, i) => renderQuestion(q, i, '####'))])
+            : '',
+          joinBlocks(['### 인성·컬처핏 면접', ...behavioral.map((q, i) => renderQuestion(q, i, '####'))]),
+        ])
+      : joinBlocks(['## 예상 질문', ...prep.questions.map((q, i) => renderQuestion(q, i, '###'))]);
+  }
 
   const starBlock = prep.star_guides?.length
     ? joinBlocks([

package/packages/knowledge/src/index.ts

@@ -58,12 +58,13 @@ export const VERIFIER_IDS = [
 ] as const;
 export type VerifierId = (typeof VERIFIER_IDS)[number];
 
-/** 5 per-feature execution procedures — docs/career-os/eop/<feature>.md. */
+/** Per-feature execution procedures — docs/career-os/eop/<feature>.md. */
 export const EOP_FEATURES = [
   'fit-analysis',
   'job-analysis',
   'profile-extraction',
   'cover-letter',
+  'career-description',
   'interview-prep',
 ] as const;
 export type EopFeature = (typeof EOP_FEATURES)[number];
@@ -95,7 +96,7 @@ export function getEop(feature: EopFeature): string {
 
 /** A goal → which EOP, expert playbooks, and verifiers to apply, in order. */
 export interface CareerRoute {
-  eop?: EopFeature;
+  eop?: EopFeature | EopFeature[];
   expertSequence: ExpertDomain[];
   verifierSequence: VerifierId[];
   loop?: 'draft_verify_revise';
@@ -109,7 +110,7 @@ export const CAREER_ROUTES: Record<string, CareerRoute> = {
     verifierSequence: ['truthfulness', 'consistency'],
   },
   analyze_job: {
-    eop: 'job-analysis',
+    eop: ['job-analysis', 'fit-analysis'],
     expertSequence: ['fit-matching', 'company-research'],
     verifierSequence: ['truthfulness', 'consistency', 'responsiveness-on-target'],
     loop: 'draft_verify_revise',
@@ -120,12 +121,47 @@ export const CAREER_ROUTES: Record<string, CareerRoute> = {
     verifierSequence: ['human-voice', 'truthfulness', 'ats-compat', 'consistency'],
     loop: 'draft_verify_revise',
   },
+  write_career_description: {
+    eop: 'career-description',
+    expertSequence: ['resume', 'ats'],
+    verifierSequence: ['truthfulness', 'consistency', 'ats-compat'],
+    loop: 'draft_verify_revise',
+  },
   prepare_interview: {
     eop: 'interview-prep',
-    expertSequence: ['interview-behavioral', 'interview-technical', 'company-research'],
+    expertSequence: ['recruiter-screen', 'interview-behavioral', 'interview-technical', 'company-research'],
     verifierSequence: ['truthfulness', 'consistency'],
     loop: 'draft_verify_revise',
   },
+  // R7 A2: manage_application_status had no route → rejection-triage / offer-evaluation /
+  // salary-negotiation were orphaned (served only on-demand via get_playbook). Route the
+  // decision-stage playbooks so they are pushed when the user manages application outcomes.
+  // R7 A4: A2 routed the decision-stage playbooks, but the EOP-free lifecycle domains
+  // onboarding-first-90-days and networking-referrals were still on-demand-only. Anchor them
+  // here (the only EOP-free lifecycle route). NOTE: networking's strongest lever is *before*
+  // applied (pre-referral, networking-referrals §2) — this route is the surfacing point, not
+  // the recommended timing, so surface networking early when the user is pre-application.
+  // linkedin-profile/portfolio stay on-demand pending a dedicated personal-brand workflow id
+  // (FIXES.md / STATUS §7.9 follow-up — onboarding EOP is résumé-import-only, so brand-
+  // creation playbooks would blur its stage meaning). Additive wiring (A1/A2 precedent).
+  manage_application_status: {
+    expertSequence: [
+      'rejection-triage-iteration',
+      'offer-evaluation-decision',
+      'salary-negotiation',
+      'onboarding-first-90-days',
+      'networking-referrals',
+    ],
+    verifierSequence: ['truthfulness', 'consistency'],
+  },
+  // R7 후속: linkedin-profile·portfolio는 onboarding(이력서 임포트)과 단계 의미가
+  // 달라(개인 브랜드 자산 *생성*) 전용 워크플로우로 분리(consensus 권고). networking은
+  // manage_application_status에 이미 정박. 저장은 add_resume(kind=portfolio); linkedin
+  // 전용 저장/검증은 Phase B.
+  build_personal_brand: {
+    expertSequence: ['linkedin-profile', 'portfolio'],
+    verifierSequence: ['truthfulness', 'human-voice', 'consistency'],
+  },
 };
 
 export function getRoute(id: string): CareerRoute | undefined {
@@ -142,12 +178,15 @@ export function renderRouteGuide(id: string): string | undefined {
   const route = CAREER_ROUTES[id];
   if (!route) return undefined;
   const lines: string[] = [];
-  if (route.eop) {
+  const eops = route.eop ? (Array.isArray(route.eop) ? route.eop : [route.eop]) : [];
+  if (eops.length) {
     lines.push('---', '');
     lines.push('## 전문가 실행 절차 (EOP) — 즉답하지 말고 이 절차를 따르세요');
     lines.push('');
-    lines.push(getEop(route.eop));
-    lines.push('');
+    for (const e of eops) {
+      lines.push(getEop(e));
+      lines.push('');
+    }
   }
   lines.push('## 이 작업에 적용할 전문가 플레이북');
   lines.push('작성 직전, 아래 도메인의 깊은 지식을 받아 적용하세요:');

package/packages/mcp-tools/src/bridge.ts

@@ -3,12 +3,13 @@
  *
  * `open_dashboard` / `open_application` need the running web server's URL. The
  * web server publishes it to a runtime file (see @careermate/db runtime). If the
- * server isn't running we start it (detached) and wait for it to register.
+ * server isn't running we start it in the background and wait for it to register.
  */
-import { spawn, type SpawnOptions } from 'node:child_process';
+import { spawn, spawnSync, type SpawnOptions } from 'node:child_process';
+import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { readRuntimeInfo, isProcessAlive } from '@careermate/db';
+import { getDataDir, readRuntimeInfo, isProcessAlive, type RuntimeInfo } from '@careermate/db';
 import { BUNDLED } from '@careermate/shared';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -19,9 +20,103 @@ export function projectRoot(): string {
   return REPO_ROOT;
 }
 
-function liveServer() {
+const HEALTH_TIMEOUT_MS = 800;
+let pendingStart: Promise<{ url: string } | null> | null = null;
+
+function dashboardLogPath(): string {
+  return path.join(getDataDir(), 'server.log');
+}
+
+function launchdPlistPath(): string {
+  return path.join(getDataDir(), 'dashboard.launchd.plist');
+}
+
+function launchdLabel(): string {
+  let hash = 5381;
+  for (const ch of getDataDir()) hash = ((hash * 33) ^ ch.charCodeAt(0)) >>> 0;
+  return `life.careermate.dashboard.${hash.toString(16)}`;
+}
+
+function xmlEscape(value: string): string {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+function plistString(key: string, value: string): string {
+  return `  <key>${xmlEscape(key)}</key>\n  <string>${xmlEscape(value)}</string>`;
+}
+
+function renderLaunchdPlist(bin: string, args: string[], cwd: string, log: string): string {
+  const env: Record<string, string> = {
+    CAREERMATE_DATA_DIR: getDataDir(),
+    CAREERMATE_NO_OPEN: '1',
+  };
+  if (process.env.CAREERMATE_PORT) env.CAREERMATE_PORT = process.env.CAREERMATE_PORT;
+  if (process.env.PATH) env.PATH = process.env.PATH;
+
+  const programArgs = [bin, ...args].map((arg) => `    <string>${xmlEscape(arg)}</string>`).join('\n');
+  const envEntries = Object.entries(env).map(([key, value]) => `${plistString(key, value)}`).join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(launchdLabel())}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(cwd)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(log)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(log)}</string>
+</dict>
+</plist>
+`;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function pingDashboard(url: string, timeoutMs = HEALTH_TIMEOUT_MS): Promise<boolean> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const healthUrl = new URL('/api/health', url);
+    const res = await fetch(healthUrl, {
+      signal: controller.signal,
+      headers: { accept: 'application/json' },
+    });
+    if (!res.ok) return false;
+    const body = (await res.json().catch(() => null)) as { ok?: unknown } | null;
+    return body?.ok === true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function liveServer(): Promise<RuntimeInfo | null> {
   const info = readRuntimeInfo();
-  if (info && isProcessAlive(info.pid)) return info;
+  if (info && isProcessAlive(info.pid) && await pingDashboard(info.url)) return info;
   return null;
 }
 
@@ -33,36 +128,122 @@ function liveServer() {
  * guards the synchronous spawn() call, not the later event — so attach the
  * listener here. stdio defaults to 'ignore'; callers may override via opts.
  */
-function spawnDetached(cmd: string, args: string[], opts: SpawnOptions = {}): void {
+function spawnDetached(cmd: string, args: string[], opts: SpawnOptions = {}): number | null {
   try {
     const child = spawn(cmd, args, { stdio: 'ignore', detached: true, ...opts });
     child.on('error', () => {
       /* binary missing / spawn failed — best-effort, never crash */
     });
     child.unref();
+    return child.pid ?? null;
   } catch {
     /* best-effort */
+    return null;
   }
 }
 
-/** Start the dashboard server detached and wait until it publishes its address. */
+function spawnViaLaunchd(bin: string, args: string[], cwd: string, log: string): boolean {
+  if (process.platform !== 'darwin' || process.env.CAREERMATE_LAUNCHER === 'detached') return false;
+  if (typeof process.getuid !== 'function') return false;
+
+  const domain = `gui/${process.getuid()}`;
+  const label = launchdLabel();
+  const plist = launchdPlistPath();
+  try {
+    fs.writeFileSync(plist, renderLaunchdPlist(bin, args, cwd, log), 'utf8');
+    // Remove a stale loaded job for the same data dir. If it is not loaded,
+    // launchctl exits non-zero; that is fine and should not block bootstrap.
+    spawnSync('launchctl', ['bootout', `${domain}/${label}`], { stdio: 'ignore' });
+    const res = spawnSync('launchctl', ['bootstrap', domain, plist], {
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    if (res.status === 0) return true;
+    fs.appendFileSync(log, `[${new Date().toISOString()}] launchctl bootstrap failed: ${res.stderr || res.stdout || res.status}\n`);
+  } catch (e) {
+    try {
+      fs.appendFileSync(log, `[${new Date().toISOString()}] launchctl launch failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    } catch {
+      /* ignore */
+    }
+  }
+  return false;
+}
+
+function spawnDashboardDetached(bin: string, args: string[], cwd: string, logFd: number | null): void {
+  spawnDetached(bin, args, {
+    cwd,
+    env: { ...process.env, CAREERMATE_NO_OPEN: '1' },
+    stdio: logFd === null ? 'ignore' : ['ignore', logFd, logFd],
+  });
+}
+
+/** Start the dashboard server in the background and wait until it publishes its address. */
 export async function ensureServer(timeoutMs = 12000): Promise<{ url: string } | null> {
-  const existing = liveServer();
+  const existing = await liveServer();
   if (existing) return { url: existing.url };
+  if (pendingStart) return pendingStart;
 
+  pendingStart = startServerBackground(timeoutMs);
+  try {
+    return await pendingStart;
+  } finally {
+    pendingStart = null;
+  }
+}
+
+async function startServerBackground(timeoutMs: number): Promise<{ url: string } | null> {
   // prod(번들): dist/web.mjs를 플레인 node로 실행. dev: tsx로 소스 실행.
   const [bin, args, cwd] = BUNDLED
     ? [process.execPath, ['--experimental-sqlite', path.join(__dirname, 'web.mjs')], __dirname]
-    : [process.execPath, ['--no-warnings', '--experimental-sqlite', '--import', 'tsx', 'apps/web/src/index.ts'], REPO_ROOT];
+    : [
+      process.execPath,
+      ['--no-warnings', '--experimental-sqlite', '--import', 'tsx', path.join(REPO_ROOT, 'apps/web/src/index.ts')],
+      REPO_ROOT,
+    ];
   // Spawn failures (sync or async) just leave the server down; the poll loop
   // below then times out and returns null — no crash.
-  spawnDetached(bin as string, args as string[], { cwd: cwd as string, env: { ...process.env, CAREERMATE_NO_OPEN: '1' } });
+  const log = dashboardLogPath();
+  let logFd: number | null = null;
+  try {
+    logFd = fs.openSync(log, 'a');
+    fs.writeSync(logFd, `\n[${new Date().toISOString()}] CareerMate dashboard background launch\n`);
+  } catch {
+    logFd = null;
+  }
+  let launchedViaLaunchd = false;
+  try {
+    launchedViaLaunchd = spawnViaLaunchd(bin as string, args as string[], cwd as string, log);
+    if (!launchedViaLaunchd) spawnDashboardDetached(bin as string, args as string[], cwd as string, logFd);
+  } finally {
+    if (logFd !== null) {
+      try { fs.closeSync(logFd); } catch { /* ignore */ }
+    }
+  }
 
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
-    const info = liveServer();
+    const info = await liveServer();
     if (info) return { url: info.url };
-    await new Promise((r) => setTimeout(r, 300));
+    await delay(300);
+  }
+
+  // If launchd accepted the job but the server never became healthy, give the
+  // simpler detached path one chance. This protects dev/source installs where
+  // launchd has a thinner environment than the invoking AI client.
+  if (launchedViaLaunchd) {
+    try {
+      fs.appendFileSync(log, `[${new Date().toISOString()}] launchd did not produce a healthy server; falling back to detached spawn\n`);
+    } catch {
+      /* ignore */
+    }
+    spawnDashboardDetached(bin as string, args as string[], cwd as string, null);
+    const fallbackStart = Date.now();
+    while (Date.now() - fallbackStart < Math.min(timeoutMs, 8000)) {
+      const info = await liveServer();
+      if (info) return { url: info.url };
+      await delay(300);
+    }
   }
   return null;
 }
@@ -98,7 +279,7 @@ export function openInFileManager(dir: string): void {
 
 /** Resolve the dashboard URL, starting the server if needed. */
 export async function resolveDashboardUrl(hash = ''): Promise<{ url: string; running: boolean }> {
-  const live = liveServer();
+  const live = await liveServer();
   if (live) return { url: live.url + hash, running: true };
   const started = await ensureServer();
   if (started) return { url: started.url + hash, running: true };