@shmulikdav/solix 1.4.2 → 1.8.0

package/dist/index.js

@@ -245,6 +245,7 @@ import { fileURLToPath } from "url";
 var SOLIX_HOME = process.env.SOLIX_HOME ?? join2(homedir2(), ".solix");
 var HOOKS_DIR = join2(SOLIX_HOME, "hooks");
 var SOLIX_SKILLS_DIR = join2(SOLIX_HOME, "skills");
+var SOLIX_TOKEN_FILE = join2(SOLIX_HOME, "token");
 var CLAUDE_DIR = join2(homedir2(), ".claude");
 var CLAUDE_SETTINGS = join2(CLAUDE_DIR, "settings.json");
 var CLAUDE_BACKUP = join2(CLAUDE_DIR, "settings.solix.backup.json");
@@ -343,6 +344,46 @@ async function probeWrappers(port) {
     };
   }
 }
+async function probeAgentView(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/system/preflight`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    if (!res.ok) {
+      return {
+        ok: true,
+        label: "Agent View available",
+        detail: "server too old to report"
+      };
+    }
+    const data = await res.json();
+    if (!data.claudeAvailable) {
+      return {
+        ok: false,
+        label: "Agent View available",
+        detail: "claude not on PATH"
+      };
+    }
+    if (data.agentViewAvailable) {
+      return {
+        ok: true,
+        label: "Agent View available",
+        detail: `yes (${data.version ?? "unknown version"})`
+      };
+    }
+    return {
+      ok: true,
+      label: "Agent View available",
+      detail: `no \u2014 need Claude Code 2.1.139+ (have ${data.version ?? "?"})`
+    };
+  } catch {
+    return {
+      ok: true,
+      label: "Agent View available",
+      detail: "unknown \u2014 server unreachable"
+    };
+  }
+}
 async function doctor() {
   const port = Number(process.env.SOLIX_PORT ?? 4242);
   const checks = [];
@@ -425,6 +466,7 @@ async function doctor() {
   });
   checks.push(await probeHealth(port));
   checks.push(await probeWrappers(port));
+  checks.push(await probeAgentView(port));
   console.log("\nSolix Diagnostics\n");
   let allOk = true;
   for (const c of checks) {
@@ -560,6 +602,7 @@ import {
   writeFileSync as writeFileSync2,
   chmodSync
 } from "fs";
+import { randomBytes } from "crypto";
 import { join as join4 } from "path";
 function readSettings() {
   if (!existsSync3(CLAUDE_SETTINGS)) return {};
@@ -613,6 +656,15 @@ function mergeHooks(existing, solix) {
   }
   return merged;
 }
+function ensureToken() {
+  if (existsSync3(SOLIX_TOKEN_FILE)) return;
+  const token = randomBytes(24).toString("hex");
+  writeFileSync2(SOLIX_TOKEN_FILE, token, { mode: 384 });
+  try {
+    chmodSync(SOLIX_TOKEN_FILE, 384);
+  } catch {
+  }
+}
 function installHookScripts() {
   mkdirSync(HOOKS_DIR, { recursive: true });
   const src = packagedHooksDir();
@@ -678,6 +730,7 @@ function install(opts = {}) {
   } else if (opts.force && existsSync3(CLAUDE_SETTINGS)) {
     copyFileSync(CLAUDE_SETTINGS, CLAUDE_BACKUP);
   }
+  ensureToken();
   installHookScripts();
   console.log(`[solix] installed hook scripts in ${HOOKS_DIR}`);
   const advisorsCopied = installAdvisorAgents();
@@ -979,8 +1032,145 @@ async function installSkillCmd(id, projectId) {
   }
 }
 
+// src/schedule.ts
+var PORT6 = process.env.SOLIX_PORT ?? "4242";
+var BASE6 = `http://127.0.0.1:${PORT6}`;
+async function api4(path, init) {
+  const res = await fetch(`${BASE6}${path}`, {
+    ...init,
+    headers: { "content-type": "application/json", ...init?.headers ?? {} }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} on ${path}: ${text}`);
+  }
+  return await res.json();
+}
+function unreachable(err) {
+  console.error(`[solix] could not reach server at ${BASE6}: ${String(err)}`);
+  console.error("[solix] is `solix start` running?");
+  process.exitCode = 1;
+}
+async function listSchedulesCmd() {
+  try {
+    const list = await api4("/api/schedules");
+    if (!list.length) {
+      console.log("No schedules. Add one with `solix schedule add`.");
+      return;
+    }
+    console.log("id        every  state   next run             prompt");
+    for (const s of list) {
+      const next = new Date(s.nextRunAt).toLocaleString();
+      const state = s.enabled ? "on " : "off";
+      console.log(
+        `  ${s.id.padEnd(8)} ${s.cron.padEnd(5)} [${state}] ${next.padEnd(20)} ${s.prompt.slice(0, 40)}`
+      );
+    }
+  } catch (err) {
+    unreachable(err);
+  }
+}
+async function addScheduleCmd(prompt, opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const cadence = opts.every ?? "1h";
+  try {
+    const s = await api4("/api/schedules", {
+      method: "POST",
+      body: JSON.stringify({ cwd, prompt, cadence, name: opts.name })
+    });
+    console.log(
+      `[solix] scheduled ${s.id} \u2014 every ${s.cron} in ${cwd}
+        next run: ${new Date(s.nextRunAt).toLocaleString()}`
+    );
+  } catch (err) {
+    unreachable(err);
+  }
+}
+async function toggle(id, enabled) {
+  try {
+    await api4(`/api/schedules/${encodeURIComponent(id)}/toggle`, {
+      method: "POST",
+      body: JSON.stringify({ enabled })
+    });
+    console.log(`[solix] schedule ${id} \u2192 ${enabled ? "enabled" : "disabled"}`);
+  } catch (err) {
+    unreachable(err);
+  }
+}
+var enableScheduleCmd = (id) => toggle(id, true);
+var disableScheduleCmd = (id) => toggle(id, false);
+async function removeScheduleCmd(id) {
+  try {
+    await api4(`/api/schedules/${encodeURIComponent(id)}`, { method: "DELETE" });
+    console.log(`[solix] removed schedule ${id}`);
+  } catch (err) {
+    unreachable(err);
+  }
+}
+
+// src/goals.ts
+var PORT7 = process.env.SOLIX_PORT ?? "4242";
+var BASE7 = `http://127.0.0.1:${PORT7}`;
+async function api5(path, init) {
+  const res = await fetch(`${BASE7}${path}`, {
+    ...init,
+    headers: { "content-type": "application/json", ...init?.headers ?? {} }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} on ${path}: ${text}`);
+  }
+  return await res.json();
+}
+function unreachable2(err) {
+  console.error(`[solix] could not reach server at ${BASE7}: ${String(err)}`);
+  console.error("[solix] is `solix start` running?");
+  process.exitCode = 1;
+}
+async function listGoalsCmd() {
+  try {
+    const goals = await api5("/api/goals");
+    if (!goals.length) {
+      console.log('No goals. Add one with `solix goal add "<name>"`.');
+      return;
+    }
+    console.log("id        color    name");
+    for (const g of goals) {
+      console.log(`  ${g.id.padEnd(8)} ${g.color.padEnd(8)} ${g.name}`);
+    }
+  } catch (err) {
+    unreachable2(err);
+  }
+}
+async function addGoalCmd(name, opts) {
+  try {
+    const g = await api5("/api/goals", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        description: opts.description,
+        color: opts.color
+      })
+    });
+    console.log(`[solix] created goal ${g.id} \u2014 "${g.name}" (${g.color})`);
+  } catch (err) {
+    unreachable2(err);
+  }
+}
+async function removeGoalCmd(id) {
+  try {
+    await api5(`/api/goals/${encodeURIComponent(id)}`, { method: "DELETE" });
+    console.log(`[solix] removed goal ${id}`);
+  } catch (err) {
+    unreachable2(err);
+  }
+}
+
 // ../server/src/create.ts
 import { serve } from "@hono/node-server";
+import { readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join15 } from "path";
 
 // ../server/src/broadcaster.ts
 var Broadcaster = class {
@@ -1156,6 +1346,14 @@ CREATE TABLE IF NOT EXISTS scheduled_tasks (
   last_run_at INTEGER,
   next_run_at INTEGER NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS goals (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  color TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
 `;
 var _db = null;
 function ensureColumn(db, table, column, ddl) {
@@ -1175,8 +1373,18 @@ function getDb() {
   ensureColumn(db, "sessions", "advisor_role", "advisor_role TEXT");
   ensureColumn(db, "sessions", "worktree_path", "worktree_path TEXT");
   ensureColumn(db, "sessions", "wrapper_socket_path", "wrapper_socket_path TEXT");
+  ensureColumn(db, "sessions", "agent_view_id", "agent_view_id TEXT");
+  ensureColumn(db, "sessions", "agent_view_summary", "agent_view_summary TEXT");
+  ensureColumn(db, "sessions", "pr_url", "pr_url TEXT");
+  ensureColumn(db, "sessions", "pr_check_status", "pr_check_status TEXT");
   ensureColumn(db, "advisors", "texture_pack", "texture_pack TEXT");
   ensureColumn(db, "missions", "error_summary", "error_summary TEXT");
+  ensureColumn(db, "sessions", "cost_usd", "cost_usd REAL DEFAULT 0");
+  ensureColumn(db, "sessions", "budget_usd", "budget_usd REAL");
+  ensureColumn(db, "sessions", "current_goal_id", "current_goal_id TEXT");
+  ensureColumn(db, "missions", "goal_id", "goal_id TEXT");
+  ensureColumn(db, "scheduled_tasks", "cwd", "cwd TEXT");
+  ensureColumn(db, "scheduled_tasks", "name", "name TEXT");
   _db = db;
   return db;
 }
@@ -1262,7 +1470,14 @@ function rowToSession(row) {
     orbitSlot: row.orbit_slot,
     name: row.name ?? void 0,
     worktreePath: row.worktree_path ?? void 0,
-    wrapperSocketPath: row.wrapper_socket_path ?? void 0
+    wrapperSocketPath: row.wrapper_socket_path ?? void 0,
+    agentViewId: row.agent_view_id ?? void 0,
+    agentViewSummary: row.agent_view_summary ?? void 0,
+    prUrl: row.pr_url ?? void 0,
+    prCheckStatus: row.pr_check_status ?? void 0,
+    costUsd: row.cost_usd ?? 0,
+    budgetUsd: row.budget_usd ?? void 0,
+    currentGoalId: row.current_goal_id ?? void 0
   };
 }
 function nextOrbitSlot(db, projectId) {
@@ -1297,9 +1512,11 @@ function upsertSession(db, input) {
     `INSERT INTO sessions (
        id, pid, project_id, parent_session_id, origin, model, status,
        context_usage_pct, orbit_slot, cwd, name, kind, advisor_role,
-       worktree_path, wrapper_socket_path, created_at, updated_at
+       worktree_path, wrapper_socket_path,
+       agent_view_id, agent_view_summary, pr_url, pr_check_status,
+       created_at, updated_at
      )
-     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, NULL, ?, ?, ?, ?, ?, ?)`
+     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     input.id,
     input.pid,
@@ -1314,6 +1531,10 @@ function upsertSession(db, input) {
     input.advisorRole ?? null,
     input.worktreePath ?? null,
     input.wrapperSocketPath ?? null,
+    input.agentViewId ?? null,
+    input.agentViewSummary ?? null,
+    input.prUrl ?? null,
+    input.prCheckStatus ?? null,
     ts2,
     ts2
   );
@@ -1333,9 +1554,40 @@ function upsertSession(db, input) {
     contextUsagePct: 0,
     orbitSlot,
     worktreePath: input.worktreePath,
-    wrapperSocketPath: input.wrapperSocketPath
+    wrapperSocketPath: input.wrapperSocketPath,
+    agentViewId: input.agentViewId,
+    agentViewSummary: input.agentViewSummary,
+    prUrl: input.prUrl,
+    prCheckStatus: input.prCheckStatus,
+    costUsd: 0
   };
 }
+function setAgentViewFields(db, sessionId, fields) {
+  const ts2 = now();
+  const updates = ["updated_at = ?"];
+  const values = [ts2];
+  if (fields.status !== void 0) {
+    updates.push("status = ?");
+    values.push(fields.status);
+  }
+  if (fields.agentViewSummary !== void 0) {
+    updates.push("agent_view_summary = ?");
+    values.push(fields.agentViewSummary);
+  }
+  if (fields.prUrl !== void 0) {
+    updates.push("pr_url = ?");
+    values.push(fields.prUrl);
+  }
+  if (fields.prCheckStatus !== void 0) {
+    updates.push("pr_check_status = ?");
+    values.push(fields.prCheckStatus);
+  }
+  values.push(sessionId);
+  db.prepare(
+    `UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`
+  ).run(...values);
+  return getSession(db, sessionId);
+}
 function setSessionStatus(db, sessionId, status) {
   const ts2 = now();
   if (status === "terminated") {
@@ -1371,6 +1623,27 @@ function setSessionContextUsage(db, sessionId, pct) {
   ).run(clamped, ts2, sessionId);
   return getSession(db, sessionId);
 }
+function setSessionCost(db, sessionId, costUsd) {
+  const ts2 = now();
+  db.prepare(
+    `UPDATE sessions SET cost_usd = ?, updated_at = ? WHERE id = ?`
+  ).run(Math.max(0, costUsd), ts2, sessionId);
+  return getSession(db, sessionId);
+}
+function setSessionBudget(db, sessionId, budgetUsd) {
+  const ts2 = now();
+  db.prepare(
+    `UPDATE sessions SET budget_usd = ?, updated_at = ? WHERE id = ?`
+  ).run(budgetUsd, ts2, sessionId);
+  return getSession(db, sessionId);
+}
+function setSessionGoal(db, sessionId, goalId) {
+  const ts2 = now();
+  db.prepare(
+    `UPDATE sessions SET current_goal_id = ?, updated_at = ? WHERE id = ?`
+  ).run(goalId, ts2, sessionId);
+  return getSession(db, sessionId);
+}
 function getSession(db, sessionId) {
   const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
   return row ? rowToSession(row) : null;
@@ -1419,7 +1692,8 @@ function rowToMission(row) {
       toolCallCount: row.tool_call_count
     },
     filesTouched,
-    errorSummary: row.error_summary ?? void 0
+    errorSummary: row.error_summary ?? void 0,
+    goalId: row.goal_id ?? void 0
   };
 }
 function setMissionError(db, missionId, errorSummary) {
@@ -1435,14 +1709,14 @@ function shortNameFromPrompt(prompt) {
     (w) => w.replace(/[^a-zA-Z0-9-]/g, "").toLowerCase().replace(/^./, (c) => c.toUpperCase())
   ).filter(Boolean).join(" ") || "New Mission";
 }
-function startMission(db, sessionId, prompt) {
+function startMission(db, sessionId, prompt, goalId) {
   const id = nanoid2();
   const ts2 = now();
   const shortName = shortNameFromPrompt(prompt);
   db.prepare(
-    `INSERT INTO missions (id, session_id, prompt, short_name, status, started_at, files_touched_json)
-     VALUES (?, ?, ?, ?, 'active', ?, '[]')`
-  ).run(id, sessionId, prompt, shortName, ts2);
+    `INSERT INTO missions (id, session_id, prompt, short_name, status, started_at, files_touched_json, goal_id)
+     VALUES (?, ?, ?, ?, 'active', ?, '[]', ?)`
+  ).run(id, sessionId, prompt, shortName, ts2, goalId ?? null);
   return {
     id,
     sessionId,
@@ -1451,9 +1725,16 @@ function startMission(db, sessionId, prompt) {
     shortName,
     status: "active",
     metrics: { subagentCount: 0, toolCallCount: 0 },
-    filesTouched: []
+    filesTouched: [],
+    goalId
   };
 }
+function addMissionTokens(db, missionId, tokens) {
+  if (tokens <= 0) return;
+  db.prepare(
+    `UPDATE missions SET total_tokens = COALESCE(total_tokens, 0) + ? WHERE id = ?`
+  ).run(Math.round(tokens), missionId);
+}
 function completeMission(db, missionId, status = "completed") {
   const ts2 = now();
   const row = db.prepare("SELECT * FROM missions WHERE id = ?").get(missionId);
@@ -1895,6 +2176,138 @@ function writeToWrapperSocket(socketPath, text) {
   }
 }
 
+// ../server/src/state/schedules.ts
+import { nanoid as nanoid4 } from "nanoid";
+function rowToSchedule(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    cwd: row.cwd ?? "",
+    name: row.name ?? void 0,
+    prompt: row.prompt,
+    cron: row.cron,
+    enabled: row.enabled !== 0,
+    lastRunAt: row.last_run_at ?? void 0,
+    nextRunAt: row.next_run_at
+  };
+}
+function cadenceToMs(cadence) {
+  const m = cadence.trim().match(/^(\d+)\s*([mhd])$/i);
+  if (!m) return null;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = m[2].toLowerCase();
+  const mult = unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * mult;
+}
+function nextRunFrom(fromMs, cadence) {
+  const ms = cadenceToMs(cadence);
+  return fromMs + (ms ?? 36e5);
+}
+function createSchedule(db, input) {
+  const project = ensureProject(db, input.cwd);
+  const id = nanoid4(8);
+  const ts2 = now();
+  const nextRun = nextRunFrom(ts2, input.cadence);
+  db.prepare(
+    `INSERT INTO scheduled_tasks
+       (id, project_id, cwd, name, prompt, cron, enabled, last_run_at, next_run_at)
+     VALUES (?, ?, ?, ?, ?, ?, 1, NULL, ?)`
+  ).run(id, project.id, input.cwd, input.name ?? null, input.prompt, input.cadence, nextRun);
+  return getSchedule(db, id);
+}
+function getSchedule(db, id) {
+  const row = db.prepare("SELECT * FROM scheduled_tasks WHERE id = ?").get(id);
+  return row ? rowToSchedule(row) : null;
+}
+function listSchedules(db) {
+  const rows = db.prepare("SELECT * FROM scheduled_tasks ORDER BY next_run_at ASC").all();
+  return rows.map(rowToSchedule);
+}
+function listDueSchedules(db, asOf) {
+  const rows = db.prepare(
+    `SELECT * FROM scheduled_tasks WHERE enabled = 1 AND next_run_at <= ?`
+  ).all(asOf);
+  return rows.map(rowToSchedule);
+}
+function setScheduleEnabled(db, id, enabled) {
+  db.prepare("UPDATE scheduled_tasks SET enabled = ? WHERE id = ?").run(
+    enabled ? 1 : 0,
+    id
+  );
+  return getSchedule(db, id);
+}
+function markScheduleRun(db, id) {
+  const sched = getSchedule(db, id);
+  if (!sched) return null;
+  const ts2 = now();
+  const next = nextRunFrom(ts2, sched.cron);
+  db.prepare(
+    "UPDATE scheduled_tasks SET last_run_at = ?, next_run_at = ? WHERE id = ?"
+  ).run(ts2, next, id);
+  return getSchedule(db, id);
+}
+function deleteSchedule(db, id) {
+  const res = db.prepare("DELETE FROM scheduled_tasks WHERE id = ?").run(id);
+  return res.changes > 0;
+}
+
+// ../server/src/state/goals.ts
+import { nanoid as nanoid5 } from "nanoid";
+var PALETTE = [
+  "#38bdf8",
+  // sky
+  "#a78bfa",
+  // violet
+  "#34d399",
+  // emerald
+  "#fbbf24",
+  // amber
+  "#f472b6",
+  // pink
+  "#f87171",
+  // red
+  "#22d3ee",
+  // cyan
+  "#c084fc"
+  // purple
+];
+function rowToGoal(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? void 0,
+    color: row.color,
+    createdAt: row.created_at
+  };
+}
+function nextColor(db) {
+  const count = db.prepare("SELECT COUNT(*) AS n FROM goals").get().n;
+  return PALETTE[count % PALETTE.length];
+}
+function createGoal(db, input) {
+  const id = nanoid5(8);
+  const ts2 = now();
+  const color = input.color ?? nextColor(db);
+  db.prepare(
+    `INSERT INTO goals (id, name, description, color, created_at)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(id, input.name, input.description ?? null, color, ts2);
+  return { id, name: input.name, description: input.description, color, createdAt: ts2 };
+}
+function listGoals(db) {
+  const rows = db.prepare("SELECT * FROM goals ORDER BY created_at ASC").all();
+  return rows.map(rowToGoal);
+}
+function deleteGoal(db, id) {
+  db.prepare(
+    `UPDATE sessions SET current_goal_id = NULL WHERE current_goal_id = ?`
+  ).run(id);
+  db.prepare(`UPDATE missions SET goal_id = NULL WHERE goal_id = ?`).run(id);
+  const res = db.prepare("DELETE FROM goals WHERE id = ?").run(id);
+  return res.changes > 0;
+}
+
 // ../server/src/state/context.ts
 var MISSIONS_FOR_HANDOFF = 3;
 var DEFAULT_ASKS = {
@@ -2101,7 +2514,7 @@ function recordSkillInstall(db, skillId, projectId) {
 }
 
 // ../server/src/state/galaxy.ts
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid6 } from "nanoid";
 function exportManifest(db, opts = {}) {
   const advisors2 = listAdvisors(db);
   const skills2 = listSkills(db);
@@ -2149,7 +2562,7 @@ function importManifest(db, manifest, sourceUrl) {
   db.prepare(
     `INSERT INTO galaxy_imports (id, source_url, manifest_json, imported_at)
      VALUES (?, ?, ?, ?)`
-  ).run(nanoid4(), sourceUrl ?? null, JSON.stringify(manifest), now());
+  ).run(nanoid6(), sourceUrl ?? null, JSON.stringify(manifest), now());
   return {
     advisorsEnabled: enabled,
     advisorsDisabled: disabled,
@@ -2210,7 +2623,7 @@ function snapshotExport(db, manifest) {
       return rowToVersion(existing);
     }
   }
-  const id = nanoid4();
+  const id = nanoid6();
   const ts2 = now();
   const ordinal = (last?.ordinal ?? 0) + 1;
   db.prepare(
@@ -2288,6 +2701,29 @@ function diffManifests(a, b) {
   };
 }
 
+// ../shared/src/pricing.ts
+var MODEL_PRICING = {
+  opus: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  sonnet: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  haiku: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 }
+};
+function pricingFor(model) {
+  const m = (model ?? "").toLowerCase();
+  if (m.includes("opus")) return MODEL_PRICING.opus;
+  if (m.includes("haiku")) return MODEL_PRICING.haiku;
+  return MODEL_PRICING.sonnet;
+}
+function costForUsage(model, usage) {
+  if (!usage) return 0;
+  const p = pricingFor(model);
+  const cost = ((usage.input_tokens ?? 0) * p.input + (usage.output_tokens ?? 0) * p.output + (usage.cache_read_input_tokens ?? 0) * p.cacheRead + (usage.cache_creation_input_tokens ?? 0) * p.cacheWrite) / 1e6;
+  return cost;
+}
+function totalTokens(usage) {
+  if (!usage) return 0;
+  return (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+}
+
 // ../server/src/cloud.ts
 var RegistryClient = class {
   constructor(baseUrl = process.env.SOLIX_REGISTRY_URL ?? "", apiKey = process.env.SOLIX_REGISTRY_KEY) {
@@ -2362,9 +2798,44 @@ var RegistryClient = class {
 };
 
 // ../server/src/http.ts
+function isAgentViewVersion(version) {
+  if (!version) return false;
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (major > 2) return true;
+  if (major < 2) return false;
+  if (minor > 1) return true;
+  if (minor < 1) return false;
+  return patch >= 139;
+}
 function createHttpApp(opts) {
   const app = new Hono();
-  app.use("*", cors());
+  app.use(
+    "*",
+    cors({
+      origin: [
+        "http://127.0.0.1:4242",
+        "http://localhost:4242",
+        "http://127.0.0.1:4243",
+        "http://localhost:4243"
+      ]
+    })
+  );
+  if (opts.token) {
+    const expected = opts.token;
+    const paths = ["/events", "/events/permission"];
+    for (const p of paths) {
+      app.use(p, async (c, next) => {
+        if (c.req.header("x-solix-token") !== expected) {
+          return c.json({ error: "unauthorized" }, 401);
+        }
+        await next();
+      });
+    }
+  }
   const registry = new RegistryClient();
   app.get(
     "/api/health",
@@ -2388,6 +2859,18 @@ function createHttpApp(opts) {
     }
     return c.json({ ok: true });
   });
+  app.post("/events/permission", async (c) => {
+    let body = null;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ decision: "allow" });
+    }
+    if (!body || !body.event) return c.json({ decision: "allow" });
+    const result = await opts.router.requestPermission(body);
+    const decision = result.timedOut ? "timeout" : result.approved ? "allow" : "deny";
+    return c.json({ decision });
+  });
   app.get("/api/projects", (c) => c.json(listProjects(opts.db)));
   app.get("/api/projects/:id/sessions", (c) => {
     const id = c.req.param("id");
@@ -2468,11 +2951,11 @@ function createHttpApp(opts) {
     return c.json({ ...a, agentMd: readAdvisorAgentMd(a) });
   });
   app.post("/api/advisors/:id/enable", (c) => {
-    const a = setAdvisorEnabled(opts.db, c.req.param("id"), true);
+    const a = opts.router.setAdvisorEnabled(c.req.param("id"), true);
     return c.json({ ok: Boolean(a), advisor: a });
   });
   app.post("/api/advisors/:id/disable", (c) => {
-    const a = setAdvisorEnabled(opts.db, c.req.param("id"), false);
+    const a = opts.router.setAdvisorEnabled(c.req.param("id"), false);
     return c.json({ ok: Boolean(a), advisor: a });
   });
   app.post("/api/advisors/:id/pin", (c) => {
@@ -2628,6 +3111,52 @@ function createHttpApp(opts) {
     return c.json({ ok: true });
   });
   app.get("/api/wrappers", (c) => c.json(listWrappers()));
+  app.get("/api/schedules", (c) => c.json(listSchedules(opts.db)));
+  app.post("/api/schedules", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.cwd || !body.prompt || !body.cadence) {
+      return c.json({ error: "cwd, prompt, cadence required" }, 400);
+    }
+    const schedule2 = createSchedule(opts.db, {
+      cwd: body.cwd,
+      prompt: body.prompt,
+      cadence: body.cadence,
+      name: body.name
+    });
+    opts.router.broadcastScheduleUpsert(schedule2);
+    return c.json(schedule2);
+  });
+  app.post("/api/schedules/:id/toggle", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = setScheduleEnabled(opts.db, c.req.param("id"), Boolean(body.enabled));
+    if (!s) return c.json({ error: "not found" }, 404);
+    opts.router.broadcastScheduleUpsert(s);
+    return c.json(s);
+  });
+  app.delete("/api/schedules/:id", (c) => {
+    const id = c.req.param("id");
+    const ok = deleteSchedule(opts.db, id);
+    if (ok) opts.router.broadcastScheduleRemove(id);
+    return c.json({ ok });
+  });
+  app.get("/api/goals", (c) => c.json(listGoals(opts.db)));
+  app.post("/api/goals", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.name) return c.json({ error: "name required" }, 400);
+    const goal2 = createGoal(opts.db, {
+      name: body.name,
+      description: body.description,
+      color: body.color
+    });
+    opts.router.broadcastGoalUpsert(goal2);
+    return c.json(goal2);
+  });
+  app.delete("/api/goals/:id", (c) => {
+    const id = c.req.param("id");
+    const ok = deleteGoal(opts.db, id);
+    if (ok) opts.router.broadcastGoalRemove(id);
+    return c.json({ ok });
+  });
   let preflightCache = null;
   app.get("/api/system/preflight", (c) => {
     if (preflightCache) return c.json(preflightCache);
@@ -2637,15 +3166,17 @@ function createHttpApp(opts) {
         encoding: "utf8"
       });
       if (res.status === 0) {
+        const version = (res.stdout ?? "").trim() || void 0;
         preflightCache = {
           claudeAvailable: true,
-          version: (res.stdout ?? "").trim() || void 0
+          version,
+          agentViewAvailable: isAgentViewVersion(version)
         };
       } else {
-        preflightCache = { claudeAvailable: false };
+        preflightCache = { claudeAvailable: false, agentViewAvailable: false };
       }
     } catch {
-      preflightCache = { claudeAvailable: false };
+      preflightCache = { claudeAvailable: false, agentViewAvailable: false };
     }
     return c.json(preflightCache);
   });
@@ -2767,7 +3298,7 @@ import { spawn, spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
 import { homedir as homedir8 } from "os";
 import { basename as basename3, join as join12 } from "path";
-import { nanoid as nanoid5 } from "nanoid";
+import { nanoid as nanoid7 } from "nanoid";
 function ensureWorktree(opts) {
   const repoRoot = (() => {
     const r = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
@@ -2809,6 +3340,53 @@ function ensureWorktree(opts) {
   return { path, created: true };
 }
 var FAKE_CLAUDE = process.env.SOLIX_FAKE_CLAUDE === "1";
+function buildSpawnEnv() {
+  const scrub = process.env.SOLIX_ENV_SCRUB === "1" || (process.env.SOLIX_SANDBOX_CMD ?? "").trim() !== "";
+  if (!scrub) return void 0;
+  const allow = [
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LC_ALL",
+    "TERM",
+    "TMPDIR",
+    "TZ",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+    "SOLIX_HOME",
+    "SOLIX_HOST",
+    "SOLIX_PORT",
+    "SOLIX_GATE_ENABLED",
+    "SOLIX_GATE_POLICY",
+    "SOLIX_GATE_TIMEOUT"
+  ];
+  const extra = (process.env.SOLIX_ENV_PASSTHROUGH ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  const keep = /* @__PURE__ */ new Set([...allow, ...extra]);
+  const env = {};
+  for (const k of keep) {
+    if (process.env[k] !== void 0) env[k] = process.env[k];
+  }
+  for (const k of Object.keys(process.env)) {
+    if (k.startsWith("ANTHROPIC_") || k.startsWith("CLAUDE_")) {
+      env[k] = process.env[k];
+    }
+  }
+  return env;
+}
+function sandboxWrap(file, args) {
+  const cmd = (process.env.SOLIX_SANDBOX_CMD ?? "").trim();
+  if (!cmd) return { file, args };
+  const parts = cmd.split(/\s+/);
+  const bin = parts[0];
+  return { file: bin, args: [...parts.slice(1), file, ...args] };
+}
 var Launcher = class {
   constructor(db, broadcaster) {
     this.db = db;
@@ -2838,15 +3416,17 @@ var Launcher = class {
       return this.pinSynthetic(advisor.id, advisor.codename, cwd);
     }
     try {
-      const child = spawn(
-        "claude",
-        ["--agent", advisor.id, "--no-tty"],
-        {
-          cwd,
-          stdio: ["pipe", "pipe", "pipe"],
-          detached: false
-        }
-      );
+      const spawnSpec = sandboxWrap("claude", [
+        "--agent",
+        advisor.id,
+        "--no-tty"
+      ]);
+      const child = spawn(spawnSpec.file, spawnSpec.args, {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: false,
+        env: buildSpawnEnv()
+      });
       const pid = child.pid;
       if (!pid) {
         this.broadcaster.broadcast({
@@ -2885,7 +3465,7 @@ var Launcher = class {
   }
   pinSynthetic(advisorId, codename, cwd) {
     const project = ensureProject(this.db, cwd);
-    const sessionId = `advisor-${advisorId}-${nanoid5(6)}`;
+    const sessionId = `advisor-${advisorId}-${nanoid7(6)}`;
     const fakePid = 1e5 + Math.floor(Math.random() * 1e5);
     const session = upsertSession(this.db, {
       id: sessionId,
@@ -2961,6 +3541,14 @@ var Launcher = class {
    */
   launch(opts) {
     if (!opts.initialPrompt.trim()) return { ok: false };
+    if (opts.useAgentView) {
+      return this.dispatchAgentView({
+        cwd: opts.cwd,
+        model: opts.model,
+        initialPrompt: opts.initialPrompt,
+        agentName: opts.agentName
+      });
+    }
     let spawnCwd = opts.cwd;
     let worktreePath;
     if (opts.worktreeBranch?.trim()) {
@@ -2991,7 +3579,9 @@ var Launcher = class {
         cwd: spawnCwd,
         model: opts.model,
         initialPrompt: opts.initialPrompt,
-        worktreePath
+        worktreePath,
+        budgetUsd: opts.budgetUsd,
+        goalId: opts.goalId
       });
     }
     if (!existsSync9(spawnCwd)) {
@@ -3005,14 +3595,74 @@ var Launcher = class {
     const args = ["--print"];
     if (opts.model) args.push("--model", String(opts.model));
     args.push(opts.initialPrompt);
-    const sessionId = `task-${nanoid5(8)}`;
+    const sessionId = `task-${nanoid7(8)}`;
     return this.spawnPrint({
       sessionId,
       cwd: spawnCwd,
       args,
       isFollowUp: false,
-      worktreePath
+      worktreePath,
+      budgetUsd: opts.budgetUsd,
+      goalId: opts.goalId
+    });
+  }
+  /**
+   * Sprint L: dispatch via Anthropic's Agent View daemon. Runs
+   * `claude --bg "<prompt>"` so the session is hosted by the
+   * supervisor and picked up by Solix's filesystem watcher within ~1s.
+   * Returns the short id parsed from claude's output line:
+   *   backgrounded · 7c5dcf5d
+   */
+  dispatchAgentView(opts) {
+    if (FAKE_CLAUDE) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "info",
+        message: "(SOLIX_FAKE_CLAUDE=1) Agent View dispatch skipped"
+      });
+      return { ok: true };
+    }
+    if (!existsSync9(opts.cwd)) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "error",
+        message: `Agent View dispatch failed: cwd does not exist (${opts.cwd})`
+      });
+      return { ok: false };
+    }
+    const args = [];
+    if (opts.agentName) args.push("--agent", opts.agentName);
+    if (opts.model) args.push("--model", String(opts.model));
+    args.push("--bg", opts.initialPrompt);
+    let child;
+    try {
+      const spawnSpec = sandboxWrap("claude", args);
+      child = spawn(spawnSpec.file, spawnSpec.args, {
+        cwd: opts.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+        env: buildSpawnEnv()
+      });
+    } catch (err) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "error",
+        message: `claude --bg spawn failed: ${err.message}`
+      });
+      return { ok: false };
+    }
+    let stdout = "";
+    child.stdout?.setEncoding("utf8").on("data", (c) => stdout += c);
+    child.on("exit", () => {
+      const match = stdout.match(/backgrounded[^a-z0-9]+([a-f0-9]{6,16})/i);
+      const shortId = match?.[1];
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "info",
+        message: shortId ? `Dispatched to Agent View \xB7 ${shortId}` : "Dispatched to Agent View"
+      });
     });
+    return { ok: true };
   }
   sendPromptToInternal(sessionId, text) {
     if (!text.trim()) return false;
@@ -3035,6 +3685,15 @@ var Launcher = class {
       });
       return false;
     }
+    const full = getSession(this.db, sessionId);
+    if (full?.budgetUsd != null && full.costUsd >= full.budgetUsd) {
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "warn",
+        message: `Budget reached for ${full.name ?? sessionId.slice(0, 8)} ($${full.costUsd.toFixed(2)}/$${full.budgetUsd.toFixed(2)}). Raise the cap to continue.`
+      });
+      return false;
+    }
     if (FAKE_CLAUDE) {
       this.broadcaster.broadcast({
         type: "chat_delta",
@@ -3066,13 +3725,29 @@ var Launcher = class {
     }
     return void 0;
   }
+  /** Sprint M — budget cap recorded at launch for a cwd, if any. */
+  budgetForInternalCwd(cwd) {
+    for (const rec of this.internalTasks.values()) {
+      if (rec.cwd === cwd && rec.budgetUsd != null) return rec.budgetUsd;
+    }
+    return void 0;
+  }
+  /** Sprint M — goal recorded at launch for a cwd, if any. */
+  goalForInternalCwd(cwd) {
+    for (const rec of this.internalTasks.values()) {
+      if (rec.cwd === cwd && rec.goalId) return rec.goalId;
+    }
+    return void 0;
+  }
   spawnPrint(opts) {
     let child;
     try {
-      child = spawn("claude", opts.args, {
+      const spawnSpec = sandboxWrap("claude", opts.args);
+      child = spawn(spawnSpec.file, spawnSpec.args, {
         cwd: opts.cwd,
         stdio: ["ignore", "pipe", "pipe"],
-        detached: false
+        detached: false,
+        env: buildSpawnEnv()
       });
     } catch (err) {
       this.broadcaster.broadcast({
@@ -3087,7 +3762,9 @@ var Launcher = class {
     if (!opts.isFollowUp) {
       this.internalTasks.set(opts.sessionId, {
         cwd: opts.cwd,
-        worktreePath: opts.worktreePath
+        worktreePath: opts.worktreePath,
+        budgetUsd: opts.budgetUsd,
+        goalId: opts.goalId
       });
     }
     let stdout = "";
@@ -3133,7 +3810,7 @@ var Launcher = class {
   }
   launchSynthetic(opts) {
     const project = ensureProject(this.db, opts.cwd);
-    const sessionId = `task-${nanoid5(8)}`;
+    const sessionId = `task-${nanoid7(8)}`;
     const fakePid = 2e5 + Math.floor(Math.random() * 1e5);
     upsertSession(this.db, {
       id: sessionId,
@@ -3144,6 +3821,8 @@ var Launcher = class {
       model: opts.model ?? "sonnet",
       worktreePath: opts.worktreePath
     });
+    if (opts.budgetUsd != null) setSessionBudget(this.db, sessionId, opts.budgetUsd);
+    if (opts.goalId) setSessionGoal(this.db, sessionId, opts.goalId);
     const active = setSessionStatus(this.db, sessionId, "active");
     if (active)
       this.broadcaster.broadcast({ type: "session_upsert", session: active });
@@ -3179,12 +3858,12 @@ var Launcher = class {
 };
 
 // ../server/src/router.ts
-import { nanoid as nanoid7 } from "nanoid";
+import { nanoid as nanoid9 } from "nanoid";
 
 // ../server/src/state/toolcalls.ts
-import { nanoid as nanoid6 } from "nanoid";
+import { nanoid as nanoid8 } from "nanoid";
 function recordToolCall(db, input) {
-  const id = nanoid6();
+  const id = nanoid8();
   const ts2 = now();
   const status = input.status ?? "running";
   db.prepare(
@@ -3286,6 +3965,8 @@ var EventRouter = class {
     const sessionId = this.extractSessionId(event);
     const advisorRole = this.launcher?.advisorRoleForPid(event.pid);
     const worktreePath = this.launcher?.worktreePathForInternalCwd(event.cwd);
+    const launchBudget = this.launcher?.budgetForInternalCwd(event.cwd);
+    const launchGoal = this.launcher?.goalForInternalCwd(event.cwd);
     const wrapper = claimWrapperForCwd(event.cwd);
     const session = upsertSession(this.db, {
       id: sessionId,
@@ -3301,7 +3982,14 @@ var EventRouter = class {
       wrapperSocketPath: wrapper?.socketPath
     });
     if (wrapper) bindWrapperToSession(wrapper.wrapperId, session.id);
-    this.broadcaster.broadcast({ type: "session_upsert", session });
+    let enriched = session;
+    if (launchBudget != null) {
+      enriched = setSessionBudget(this.db, session.id, launchBudget) ?? enriched;
+    }
+    if (launchGoal) {
+      enriched = setSessionGoal(this.db, session.id, launchGoal) ?? enriched;
+    }
+    this.broadcaster.broadcast({ type: "session_upsert", session: enriched });
     if (!session.parentSessionId) {
       this.transcripts?.startWatching(sessionId, event.cwd);
     }
@@ -3322,7 +4010,7 @@ var EventRouter = class {
         model: this.extractModel(event)
       });
     }
-    const mission = startMission(this.db, sessionId, prompt);
+    const mission = startMission(this.db, sessionId, prompt, session.currentGoalId);
     const updated = setSessionMission(this.db, sessionId, mission.id);
     const active = updated ? setSessionStatus(this.db, sessionId, "active") : null;
     this.broadcaster.broadcast({ type: "mission_upsert", mission });
@@ -3366,7 +4054,7 @@ var EventRouter = class {
     const parentSessionId = this.extractSessionId(event);
     const parent = getSession(this.db, parentSessionId);
     if (!parent) return;
-    const subId = nanoid7();
+    const subId = nanoid9();
     const sub = upsertSession(this.db, {
       id: subId,
       pid: event.pid,
@@ -3443,7 +4131,7 @@ var EventRouter = class {
     const p = event.payload;
     const message = typeof p.message === "string" ? p.message : "Permission requested";
     const tool = typeof p.tool_name === "string" ? p.tool_name : "unknown";
-    const requestId = nanoid7();
+    const requestId = nanoid9();
     this.permissions.set(requestId, {
       requestId,
       sessionId,
@@ -3471,6 +4159,90 @@ var EventRouter = class {
       message: `Permission requested: ${message}`
     });
   }
+  /**
+   * Synchronous human-in-the-loop gate for the blocking PreToolUse path.
+   * Records the tool call (so the comet/timeline visuals still fire — the gate
+   * hook no longer POSTs to /events), broadcasts a permission_request, and
+   * returns a promise that resolves when a human answers via `permission_response`
+   * (reused unchanged) or when the server-side timeout fires.
+   */
+  requestPermission(event) {
+    const sessionId = this.extractSessionId(event);
+    const p = event.payload;
+    const { tool, args } = this.describeGatedTool(event.event, p);
+    const session = getSession(this.db, sessionId);
+    if (session) {
+      const toolCall = recordToolCall(this.db, {
+        sessionId,
+        missionId: session.currentMissionId,
+        tool,
+        args
+      });
+      if (event.event === "pre_tool_file" && session.currentMissionId && typeof args.file_path === "string" && args.file_path) {
+        addTouchedFile(this.db, session.currentMissionId, args.file_path);
+      }
+      this.broadcaster.broadcast({ type: "tool_call", toolCall });
+    }
+    const requestId = nanoid9();
+    const timeoutMs = Number(process.env.SOLIX_GATE_TIMEOUT_MS ?? 3e5);
+    return new Promise((resolve4) => {
+      const timer = setTimeout(() => {
+        const pending = this.permissions.get(requestId);
+        if (!pending) return;
+        this.permissions.delete(requestId);
+        const s = setSessionStatus(this.db, sessionId, "active");
+        if (s) this.broadcaster.broadcast({ type: "session_upsert", session: s });
+        resolve4({ approved: false, timedOut: true });
+      }, timeoutMs);
+      this.permissions.set(requestId, {
+        requestId,
+        sessionId,
+        tool,
+        args,
+        createdAt: Date.now(),
+        resolve: (approved) => resolve4({ approved, timedOut: false }),
+        timer
+      });
+      const updated = setSessionStatus(
+        this.db,
+        sessionId,
+        "awaiting_permission"
+      );
+      if (updated) {
+        this.broadcaster.broadcast({ type: "session_upsert", session: updated });
+      }
+      this.broadcaster.broadcast({
+        type: "permission_request",
+        sessionId,
+        tool,
+        args,
+        requestId
+      });
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "warn",
+        message: `Approval requested: ${tool}`
+      });
+    });
+  }
+  describeGatedTool(eventName, p) {
+    const toolInput = p.tool_input ?? {};
+    if (eventName === "pre_tool_bash") {
+      const command = typeof p.command === "string" ? p.command : typeof toolInput.command === "string" ? toolInput.command : "";
+      return { tool: "Bash", args: { command } };
+    }
+    if (eventName === "pre_tool_file") {
+      const tool2 = typeof p.tool_name === "string" ? p.tool_name : "File";
+      const filePath = typeof p.file_path === "string" ? p.file_path : typeof toolInput.file_path === "string" ? toolInput.file_path : "";
+      return { tool: tool2, args: { file_path: filePath } };
+    }
+    if (eventName === "pre_tool_task") {
+      const tool2 = typeof p.tool_name === "string" ? p.tool_name : "Task";
+      return { tool: tool2, args: toolInput };
+    }
+    const tool = typeof p.tool_name === "string" ? p.tool_name : "tool";
+    return { tool, args: toolInput };
+  }
   invokeAdvisor(advisorId, targetSessionId, prompt) {
     const advisor = getAdvisor(this.db, advisorId);
     if (!advisor) return { ok: false };
@@ -3523,6 +4295,20 @@ var EventRouter = class {
     }
     return ok;
   }
+  /** Sprint N — enable/disable an advisor and broadcast the change so open
+   * browsers (and the CLI path) update live. Returns the updated advisor. */
+  setAdvisorEnabled(advisorId, enabled) {
+    const advisor = setAdvisorEnabled(this.db, advisorId, enabled);
+    if (advisor) {
+      this.broadcaster.broadcast({ type: "advisor_upsert", advisor });
+      this.broadcaster.broadcast({
+        type: "toast",
+        level: "info",
+        message: `${advisor.codename} ${enabled ? "added to crew" : "disabled"}`
+      });
+    }
+    return advisor;
+  }
   unpinAdvisor(advisorId) {
     if (this.launcher) {
       this.launcher.unpin(advisorId);
@@ -3544,6 +4330,8 @@ var EventRouter = class {
     const pending = this.permissions.get(requestId);
     if (!pending) return false;
     this.permissions.delete(requestId);
+    if (pending.timer) clearTimeout(pending.timer);
+    if (pending.resolve) pending.resolve(approved);
     const status = approved ? "active" : "idle";
     const session = setSessionStatus(this.db, pending.sessionId, status);
     if (session)
@@ -3579,7 +4367,29 @@ var EventRouter = class {
       model: opts.model,
       initialPrompt: opts.initialPrompt,
       worktreeBranch: opts.worktreeBranch,
-      worktreeBaseRef: opts.worktreeBaseRef
+      worktreeBaseRef: opts.worktreeBaseRef,
+      useAgentView: opts.useAgentView,
+      agentName: opts.agentName,
+      budgetUsd: opts.budgetUsd,
+      goalId: opts.goalId
+    });
+  }
+  /** Sprint M — raise (or clear) a session's budget cap. Clears any standing
+   * budget breach by re-broadcasting the current cost against the new cap. */
+  raiseBudget(sessionId, budgetUsd) {
+    const session = setSessionBudget(this.db, sessionId, budgetUsd);
+    if (!session) return;
+    this.broadcaster.broadcast({ type: "session_upsert", session });
+    this.broadcaster.broadcast({
+      type: "cost_update",
+      sessionId,
+      costUsd: session.costUsd,
+      budgetUsd: session.budgetUsd
+    });
+    this.broadcaster.broadcast({
+      type: "toast",
+      level: "info",
+      message: `Budget raised to $${budgetUsd.toFixed(2)} for ${session.name ?? sessionId.slice(0, 8)}`
     });
   }
   sendPromptToSession(sessionId, text) {
@@ -3624,6 +4434,19 @@ var EventRouter = class {
   broadcastSessionUpsert(session) {
     this.broadcaster.broadcast({ type: "session_upsert", session });
   }
+  // Sprint M — broadcast helpers for schedule/goal CRUD driven by HTTP/CLI.
+  broadcastScheduleUpsert(schedule2) {
+    this.broadcaster.broadcast({ type: "schedule_upsert", schedule: schedule2 });
+  }
+  broadcastScheduleRemove(scheduleId) {
+    this.broadcaster.broadcast({ type: "schedule_remove", scheduleId });
+  }
+  broadcastGoalUpsert(goal2) {
+    this.broadcaster.broadcast({ type: "goal_upsert", goal: goal2 });
+  }
+  broadcastGoalRemove(goalId) {
+    this.broadcaster.broadcast({ type: "goal_remove", goalId });
+  }
   broadcastGalaxyImported(manifest) {
     this.broadcaster.broadcast({ type: "galaxy_imported", manifest });
     this.broadcaster.broadcast({
@@ -3679,7 +4502,9 @@ function attachWs(server, ctx) {
       sessions: listActiveSessions(ctx.db),
       missions: listMissions(ctx.db, { limit: 100 }),
       advisors: listAdvisors(ctx.db),
-      skills: listSkills(ctx.db)
+      skills: listSkills(ctx.db),
+      schedules: listSchedules(ctx.db),
+      goals: listGoals(ctx.db)
     };
     ctx.broadcaster.send(ws, snapshot);
     for (const p of ctx.router.pendingPermissions()) {
@@ -3726,9 +4551,18 @@ function handleClientMessage(ctx, _ws, msg) {
         model: msg.model,
         initialPrompt: msg.initialPrompt,
         worktreeBranch: msg.worktreeBranch,
-        worktreeBaseRef: msg.worktreeBaseRef
+        worktreeBaseRef: msg.worktreeBaseRef,
+        useAgentView: msg.useAgentView,
+        agentName: msg.agentName,
+        budgetUsd: msg.budgetUsd,
+        goalId: msg.goalId
       });
       break;
+    case "raise_budget":
+      ctx.router.raiseBudget(msg.sessionId, msg.budgetUsd);
+      break;
+    case "dismiss_budget_alert":
+      break;
     case "invoke_advisor":
       ctx.router.invokeAdvisor(
         msg.advisorId,
@@ -3742,6 +4576,9 @@ function handleClientMessage(ctx, _ws, msg) {
     case "unpin_advisor":
       ctx.router.unpinAdvisor(msg.advisorId);
       break;
+    case "set_advisor_enabled":
+      ctx.router.setAdvisorEnabled(msg.advisorId, msg.enabled);
+      break;
     default:
       break;
   }
@@ -3777,12 +4614,15 @@ var TranscriptWatcherManager = class {
   constructor(db, broadcaster) {
     this.db = db;
     this.broadcaster = broadcaster;
-    void this.db;
   }
   db;
   broadcaster;
   records = /* @__PURE__ */ new Map();
   deferredRetry = /* @__PURE__ */ new Map();
+  // Sprint M: sessions we've already raised a budget alert for, so we don't
+  // re-fire on every subsequent assistant message. Cleared when spend drops
+  // back under the cap (e.g. after the cap is raised).
+  budgetAlerted = /* @__PURE__ */ new Set();
   /**
    * Begin tailing this session's transcript. Idempotent. If the file doesn't
    * exist yet, retries every second for up to 10 s (Claude Code creates the
@@ -3914,6 +4754,39 @@ var TranscriptWatcherManager = class {
         sessionId,
         usagePct: pct
       });
+      const inc = costForUsage(message.model, message.usage);
+      const session = getSession(this.db, sessionId);
+      if (session) {
+        const updated = setSessionCost(this.db, sessionId, session.costUsd + inc);
+        const costUsd = updated?.costUsd ?? session.costUsd + inc;
+        const cap = updated?.budgetUsd ?? session.budgetUsd;
+        this.broadcaster.broadcast({
+          type: "cost_update",
+          sessionId,
+          costUsd,
+          budgetUsd: cap
+        });
+        if (session.currentMissionId) {
+          addMissionTokens(
+            this.db,
+            session.currentMissionId,
+            totalTokens(message.usage)
+          );
+        }
+        if (cap != null && costUsd >= cap) {
+          if (!this.budgetAlerted.has(sessionId)) {
+            this.budgetAlerted.add(sessionId);
+            this.broadcaster.broadcast({
+              type: "budget_alert",
+              sessionId,
+              costUsd,
+              budgetUsd: cap
+            });
+          }
+        } else {
+          this.budgetAlerted.delete(sessionId);
+        }
+      }
     }
     const content = this.flattenAssistantContent(message.content);
     if (!content) return;
@@ -3991,6 +4864,196 @@ ${text.slice(0, 600)}`);
   }
 };
 
+// ../server/src/state/agentview.ts
+import { existsSync as existsSync11, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync6, watch as watch2 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join14 } from "path";
+var ROSTER_PATH = join14(homedir10(), ".claude", "daemon", "roster.json");
+var JOBS_DIR = join14(homedir10(), ".claude", "jobs");
+function mapStatus(state) {
+  switch (state) {
+    case "working":
+      return "active";
+    case "needs_input":
+      return "awaiting_input";
+    case "idle":
+      return "idle";
+    case "completed":
+      return "terminated";
+    case "failed":
+      return "error";
+    case "stopped":
+      return "terminated";
+    default:
+      return "idle";
+  }
+}
+function mapPrStatus(s) {
+  if (!s) return void 0;
+  if (s === "pending" || s === "success" || s === "failure" || s === "neutral")
+    return s;
+  return void 0;
+}
+function readRoster() {
+  if (!existsSync11(ROSTER_PATH)) return [];
+  try {
+    const raw = readFileSync7(ROSTER_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed;
+    if (parsed && Array.isArray(parsed.sessions)) return parsed.sessions;
+    return [];
+  } catch {
+    return [];
+  }
+}
+function readJobIds() {
+  if (!existsSync11(JOBS_DIR)) return [];
+  try {
+    return readdirSync5(JOBS_DIR).filter((entry) => {
+      try {
+        return statSync6(join14(JOBS_DIR, entry)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function readJobState(jobId) {
+  const p = join14(JOBS_DIR, jobId, "state.json");
+  if (!existsSync11(p)) return null;
+  try {
+    return JSON.parse(readFileSync7(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function syncFromDisk({ db, broadcaster }) {
+  const roster = readRoster();
+  const jobIds = readJobIds();
+  const liveIds = /* @__PURE__ */ new Set();
+  for (const e of roster) if (e.id) liveIds.add(e.id);
+  for (const id of jobIds) liveIds.add(id);
+  for (const agentViewId of liveIds) {
+    const state = readJobState(agentViewId);
+    if (!state) continue;
+    const cwd = state.cwd ?? "";
+    if (!cwd) continue;
+    const solixId = `av-${agentViewId}`;
+    const existing = getSession(db, solixId);
+    const status = mapStatus(state.state);
+    const summary = state.summary ?? null;
+    const prUrl = state.pr_url ?? null;
+    const prCheckStatus = mapPrStatus(state.pr_check_status) ?? null;
+    if (!existing) {
+      const project = ensureProject(db, cwd);
+      const session = upsertSession(db, {
+        id: solixId,
+        pid: 0,
+        // we don't know the pid; supervisor owns it
+        projectId: project.id,
+        cwd,
+        origin: "agentview",
+        model: state.model ?? "default",
+        kind: "user",
+        worktreePath: state.worktree_path ?? void 0,
+        agentViewId,
+        agentViewSummary: summary ?? void 0,
+        prUrl: prUrl ?? void 0,
+        prCheckStatus: prCheckStatus ?? void 0
+      });
+      const updated2 = setAgentViewFields(db, solixId, { status });
+      broadcaster.broadcast({
+        type: "session_upsert",
+        session: updated2 ?? session
+      });
+      continue;
+    }
+    const changed = existing.status !== status || (existing.agentViewSummary ?? null) !== summary || (existing.prUrl ?? null) !== prUrl || (existing.prCheckStatus ?? null) !== prCheckStatus;
+    if (!changed) continue;
+    const updated = setAgentViewFields(db, solixId, {
+      status,
+      agentViewSummary: summary,
+      prUrl,
+      prCheckStatus
+    });
+    if (updated) broadcaster.broadcast({ type: "session_upsert", session: updated });
+  }
+  const rows = db.prepare(
+    `SELECT id, agent_view_id FROM sessions
+       WHERE origin = 'agentview' AND status != 'terminated'`
+  ).all();
+  for (const r of rows) {
+    if (r.agent_view_id && !liveIds.has(r.agent_view_id)) {
+      const updated = setAgentViewFields(db, r.id, { status: "terminated" });
+      if (updated)
+        broadcaster.broadcast({ type: "session_upsert", session: updated });
+    }
+  }
+}
+function debounce(fn, ms) {
+  let h = null;
+  return () => {
+    if (h) clearTimeout(h);
+    h = setTimeout(() => {
+      h = null;
+      fn();
+    }, ms);
+  };
+}
+function startAgentViewBridge(opts) {
+  const claudeRoot = join14(homedir10(), ".claude");
+  if (!existsSync11(claudeRoot)) return () => {
+  };
+  const sync = () => {
+    try {
+      syncFromDisk(opts);
+    } catch (err) {
+      console.warn("[agentview] sync failed:", err.message);
+    }
+  };
+  const debounced = debounce(sync, 50);
+  sync();
+  const watchers = [];
+  const daemonDir = join14(homedir10(), ".claude", "daemon");
+  if (existsSync11(daemonDir)) {
+    try {
+      watchers.push(watch2(daemonDir, { persistent: false }, debounced));
+    } catch (err) {
+      console.warn(
+        "[agentview] could not watch daemon dir:",
+        err.message
+      );
+    }
+  }
+  if (existsSync11(JOBS_DIR)) {
+    try {
+      watchers.push(watch2(JOBS_DIR, { recursive: true, persistent: false }, debounced));
+    } catch (err) {
+      console.warn("[agentview] recursive watch unsupported; falling back to poll");
+      const poll = setInterval(sync, 3e3);
+      return () => {
+        clearInterval(poll);
+        for (const w of watchers) {
+          try {
+            w.close();
+          } catch {
+          }
+        }
+      };
+    }
+  }
+  return () => {
+    for (const w of watchers) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+  };
+}
+
 // ../server/src/create.ts
 async function createSolixServer(opts = {}) {
   const port = opts.port ?? 4242;
@@ -4009,7 +5072,17 @@ async function createSolixServer(opts = {}) {
   const launcher = new Launcher(db, broadcaster);
   const transcripts = new TranscriptWatcherManager(db, broadcaster);
   const router = new EventRouter(db, broadcaster, launcher, transcripts);
-  const app = createHttpApp({ db, router });
+  const tokenPath = join15(
+    process.env.SOLIX_HOME ?? join15(homedir11(), ".solix"),
+    "token"
+  );
+  let token = null;
+  try {
+    token = readFileSync8(tokenPath, "utf8").trim() || null;
+  } catch {
+    token = null;
+  }
+  const app = createHttpApp({ db, router, token });
   const server = serve({
     fetch: app.fetch,
     port,
@@ -4020,10 +5093,33 @@ async function createSolixServer(opts = {}) {
     router,
     broadcaster
   });
+  const stopAgentViewBridge = startAgentViewBridge({ db, broadcaster });
+  const scheduleTimer = setInterval(() => {
+    try {
+      const due = listDueSchedules(db, now());
+      for (const s of due) {
+        if (!s.cwd) continue;
+        launcher.launch({ cwd: s.cwd, initialPrompt: s.prompt });
+        const updated = markScheduleRun(db, s.id);
+        if (updated) {
+          broadcaster.broadcast({ type: "schedule_upsert", schedule: updated });
+          broadcaster.broadcast({
+            type: "toast",
+            level: "info",
+            message: `Heartbeat fired: ${s.name ?? s.prompt.slice(0, 32)}`
+          });
+        }
+      }
+    } catch (err) {
+      console.warn("[scheduler] tick failed:", err.message);
+    }
+  }, 3e4);
   return {
     port,
     hostname,
     close: () => new Promise((resolve4) => {
+      clearInterval(scheduleTimer);
+      stopAgentViewBridge();
       transcripts.shutdownAll();
       launcher.shutdownAll();
       server.close(() => resolve4());
@@ -4071,20 +5167,20 @@ async function start(opts = {}) {
 }
 
 // src/uninstall.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 function uninstall() {
   uninstallShim();
-  if (existsSync11(CLAUDE_BACKUP)) {
+  if (existsSync12(CLAUDE_BACKUP)) {
     copyFileSync2(CLAUDE_BACKUP, CLAUDE_SETTINGS);
     console.log(`[solix] restored settings.json from backup`);
     return;
   }
-  if (!existsSync11(CLAUDE_SETTINGS)) {
+  if (!existsSync12(CLAUDE_SETTINGS)) {
     console.log("[solix] nothing to uninstall (no settings.json found)");
     return;
   }
   const cur = JSON.parse(
-    readFileSync7(CLAUDE_SETTINGS, "utf8")
+    readFileSync9(CLAUDE_SETTINGS, "utf8")
   );
   if (cur.hooks) {
     for (const [evt, entries] of Object.entries(cur.hooks)) {
@@ -4100,7 +5196,7 @@ function uninstall() {
 
 // src/index.ts
 var program = new Command();
-program.name("solix").description("Solix \u2014 a solar-system command center for Claude Code agents").version("1.4.2");
+program.name("solix").description("Solix \u2014 a solar-system command center for Claude Code agents").version("1.8.0");
 program.command("start", { isDefault: true }).description("Start the Solix server and open the browser").option("-p, --port <port>", "port to listen on", (v) => parseInt(v, 10), 4242).option("--no-open", "do not open browser automatically").action(async (opts) => {
   await start({ port: opts.port, noOpen: !opts.open });
 });
@@ -4169,6 +5265,36 @@ galaxy.command("publish <slug>").description("Publish the current galaxy to the
 galaxy.command("install <slug>").description("Pull and install a galaxy from the configured registry").action(async (slug) => {
   await installFromRegistryCmd(slug);
 });
+var schedule = program.command("schedule").description('Manage recurring "heartbeat" tasks (Sprint M)');
+schedule.command("list", { isDefault: true }).description("List all scheduled tasks").action(async () => {
+  await listSchedulesCmd();
+});
+schedule.command("add <prompt>").description("Schedule a recurring task").option("--cwd <dir>", "working directory (default: current dir)").option("--every <cadence>", "cadence: 30m, 2h, 1d", "1h").option("--name <name>", "short label for the galaxy node").action(
+  async (prompt, opts) => {
+    await addScheduleCmd(prompt, opts);
+  }
+);
+schedule.command("enable <id>").description("Enable a schedule").action(async (id) => {
+  await enableScheduleCmd(id);
+});
+schedule.command("disable <id>").description("Disable a schedule (keeps it, stops firing)").action(async (id) => {
+  await disableScheduleCmd(id);
+});
+schedule.command("remove <id>").description("Delete a schedule").action(async (id) => {
+  await removeScheduleCmd(id);
+});
+var goal = program.command("goal").description("Manage goals that missions roll up to (Sprint M)");
+goal.command("list", { isDefault: true }).description("List all goals").action(async () => {
+  await listGoalsCmd();
+});
+goal.command("add <name>").description("Create a goal").option("--description <desc>", "optional description").option("--color <hex>", "optional hex color for the constellation").action(
+  async (name, opts) => {
+    await addGoalCmd(name, opts);
+  }
+);
+goal.command("remove <id>").description("Delete a goal (detaches it from sessions/missions)").action(async (id) => {
+  await removeGoalCmd(id);
+});
 program.parseAsync(process.argv).catch((err) => {
   console.error(err);
   process.exit(1);