piu-piu-cli 0.1.0

package/dist/daemon.mjs

@@ -0,0 +1,1975 @@
+// ../../apps/daemon/src/config.ts
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+var home = process.env.PIU_PIU_HOME ?? join(homedir(), ".piu-piu");
+var env = (name) => process.env[`PIU_PIU_${name}`] ?? process.env[`MAZE_OFFICE_${name}`];
+var officeDist = [process.env.PIU_PIU_OFFICE, join(import.meta.dirname, "office"), resolve(import.meta.dirname, "../../office/dist")].find(
+  (p) => Boolean(p && existsSync(join(p, "index.html")))
+);
+var config = {
+  host: env("HOST") ?? "127.0.0.1",
+  port: Number(env("PORT") ?? 7777),
+  home,
+  officeDist,
+  rosterPath: join(home, "agents.yaml"),
+  dataDir: home,
+  projectsDir: join(homedir(), ".claude", "projects"),
+  // Transcripts untouched for longer than this are not replayed at startup.
+  replayWindowMs: 24 * 60 * 60 * 1e3,
+  // How much of the end of a transcript to replay to rebuild a session's state.
+  replayBytes: 512 * 1024,
+  // A session with no activity for this long is considered closed.
+  staleMs: 30 * 60 * 1e3,
+  // "Working" with no activity for this long means the session stalled or was
+  // killed without telling us; show it as idle.
+  stalledMs: 10 * 60 * 1e3,
+  maxEvents: 2e3
+};
+var ROSTER_TEMPLATE = `# piu-piu roster. Sessions whose folder is inside an agent's cwd sit at that agent's desk;
+# anything else gets a "freelancer" desk named after its folder.
+# Agents can also be created in the office (Team > New agent); those are saved in agents.json.
+# Rooms with desks: dev-floor | server-room | library | studio-b
+#
+# agents:
+#   - id: budget
+#     name: L\xE9a
+#     role: dev            # dev | lead | devops | web | design | docs | qa | product
+#     room: dev-floor
+#     cwd: ~/code/budget
+#
+# Seat specialists (Claude Code agents) in a room of your choice:
+# specialists:
+#   my-docs-agent: library
+agents: []
+`;
+function prepareHome() {
+  const fresh = !existsSync(join(home, "office.db"));
+  mkdirSync(home, { recursive: true, mode: 448 });
+  const legacy = resolve(import.meta.dirname, "../../../data");
+  if (fresh && existsSync(join(legacy, "office.db"))) {
+    for (const f of ["office.db", "office.db-wal", "office.db-shm", "agents.json", "channel-token"]) {
+      if (existsSync(join(legacy, f))) copyFileSync(join(legacy, f), join(home, f));
+    }
+    const legacyRoster = resolve(legacy, "../agents.yaml");
+    if (existsSync(legacyRoster) && !existsSync(config.rosterPath)) copyFileSync(legacyRoster, config.rosterPath);
+    console.log(`[piu-piu] moved your data from ${legacy} to ${home}`);
+  }
+  if (!existsSync(config.rosterPath)) writeFileSync(config.rosterPath, ROSTER_TEMPLATE);
+}
+function channelToken() {
+  const path = join(config.dataDir, "channel-token");
+  try {
+    return readFileSync(path, "utf8").trim();
+  } catch {
+    mkdirSync(config.dataDir, { recursive: true });
+    const token = randomBytes(24).toString("hex");
+    writeFileSync(path, token, { mode: 384 });
+    return token;
+  }
+}
+function expandHome(p) {
+  if (p === "~") return homedir();
+  return p.startsWith("~/") ? join(homedir(), p.slice(2)) : p;
+}
+
+// ../../apps/daemon/src/roster.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, join as join2 } from "node:path";
+import { parse, parseDocument } from "yaml";
+var appAgentsPath = () => join2(config.dataDir, "agents.json");
+function loadAppAgents() {
+  try {
+    return JSON.parse(readFileSync2(appAgentsPath(), "utf8")).map((a) => ({ ...a, managed: true, exact: true }));
+  } catch {
+    return [];
+  }
+}
+function saveAppAgents(agents) {
+  writeFileSync2(appAgentsPath(), JSON.stringify(agents.map(({ managed: _m, ...a }) => a), null, 2) + "\n");
+}
+function renameYamlAgent(id, name, path = config.rosterPath) {
+  const doc = parseDocument(readFileSync2(path, "utf8"));
+  const list = doc.get("agents");
+  const item = list?.items?.find((it) => it.get("id") === id);
+  if (!item) return false;
+  item.set("name", name);
+  writeFileSync2(path, doc.toString());
+  return true;
+}
+function appAgents() {
+  return loadAppAgents();
+}
+function loadRoster(path = config.rosterPath) {
+  const doc = parse(readFileSync2(path, "utf8"));
+  const fromYaml = (doc.agents ?? []).map((a) => ({ ...a, cwd: expandHome(a.cwd) }));
+  const ids = new Set(fromYaml.map((a) => a.id));
+  return [...fromYaml, ...loadAppAgents().filter((a) => !ids.has(a.id))];
+}
+function specialistRooms(path = config.rosterPath) {
+  try {
+    return parse(readFileSync2(path, "utf8")).specialists ?? {};
+  } catch {
+    return {};
+  }
+}
+function assignDesk(roster, cwd) {
+  let best;
+  for (const agent of roster) {
+    const inside = cwd === agent.cwd || !agent.exact && cwd.startsWith(agent.cwd + "/");
+    if (inside && (!best || agent.cwd.length > best.cwd.length || agent.cwd.length === best.cwd.length && agent.exact)) best = agent;
+  }
+  if (best) return { agentId: best.id, agentName: best.name, role: best.role, room: best.room };
+  const project = basename(cwd) || "home";
+  return { agentId: `freelancer:${project}`, agentName: project, role: "freelancer", room: "dev-floor" };
+}
+
+// ../../apps/daemon/src/observe/specialists.ts
+import { EventEmitter } from "node:events";
+import { readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename2, join as join3 } from "node:path";
+import chokidar from "chokidar";
+import { parse as parse2 } from "yaml";
+var BUILTINS = [
+  { type: "Explore", name: "Explore", room: "library", description: "Read-only search across a codebase: finds files, code and conventions." },
+  { type: "Plan", name: "Plan", room: "library", description: "Software architect: designs implementation plans." },
+  { type: "general-purpose", name: "General purpose", room: "dev-floor", description: "Researches questions and runs multi-step tasks." },
+  { type: "claude-code-guide", name: "Claude Code guide", room: "library", description: "Answers questions about Claude Code, the Agent SDK and the API." },
+  { type: "statusline-setup", name: "Status line setup", room: "dev-floor", description: "Configures Claude Code's status line." },
+  { type: "fork", name: "Fork", room: "dev-floor", description: "A copy of the calling agent, working on a side task with its context." }
+];
+var ROOM_RULES = [
+  [/doc|wiki|librar|writer|explore|plan|guide|research/i, "library"],
+  [/devops|infra|deploy|\bops\b|k8s|kube|cloud|sre|security/i, "server-room"],
+  [/seo|content|design|film|motion|video|image|market|brand|copy/i, "studio-b"]
+];
+function homeRoom(type, description, overrides) {
+  if (overrides[type]) return overrides[type];
+  for (const text of [type, description.slice(0, 160)]) for (const [re, room] of ROOM_RULES) if (re.test(text)) return room;
+  return "dev-floor";
+}
+var titleCase = (s) => s.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+function frontmatter(path) {
+  let block;
+  try {
+    block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(readFileSync3(path, "utf8"))?.[1];
+  } catch {
+    return void 0;
+  }
+  if (block === void 0) return void 0;
+  try {
+    const doc = parse2(block);
+    if (doc && typeof doc === "object") return doc;
+  } catch {
+  }
+  const out = {};
+  for (const line of block.split(/\r?\n/)) {
+    const m = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+    if (m) out[m[1]] = m[2].replace(/^(["'])(.*)\1$/, "$2");
+  }
+  return out;
+}
+function readAgentsDir(dir, source, prefix = "") {
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  return files.flatMap((f) => {
+    const fm = frontmatter(join3(dir, f));
+    if (!fm) return [];
+    const name = typeof fm.name === "string" ? fm.name : basename2(f, ".md");
+    const description = typeof fm.description === "string" ? fm.description.split(/<example>|\n/)[0].trim() : "";
+    return [{
+      type: prefix + name,
+      name: titleCase(name),
+      description,
+      model: typeof fm.model === "string" ? fm.model : void 0,
+      color: typeof fm.color === "string" ? fm.color : void 0,
+      source
+    }];
+  });
+}
+function pluginAgentDirs() {
+  try {
+    const installed = JSON.parse(readFileSync3(join3(homedir2(), ".claude", "plugins", "installed_plugins.json"), "utf8"));
+    let enabled = {};
+    try {
+      enabled = JSON.parse(readFileSync3(join3(homedir2(), ".claude", "settings.json"), "utf8")).enabledPlugins ?? {};
+    } catch {
+    }
+    return Object.entries(installed.plugins ?? {}).flatMap(
+      ([key, installs]) => enabled[key] === false ? [] : installs.map((i) => ({ dir: join3(i.installPath, "agents"), prefix: `${key.split("@")[0]}:` }))
+    );
+  } catch {
+    return [];
+  }
+}
+var Specialists = class extends EventEmitter {
+  constructor(overrides) {
+    super();
+    this.overrides = overrides;
+    this.reload();
+    const dirs = [join3(homedir2(), ".claude", "agents"), join3(homedir2(), ".claude", "plugins", "installed_plugins.json")];
+    chokidar.watch(dirs, { ignoreInitial: true, depth: 0 }).on("all", () => this.refresh());
+  }
+  list = [];
+  lastUsed = /* @__PURE__ */ new Map();
+  folders = /* @__PURE__ */ new Set();
+  timer;
+  get all() {
+    return this.list;
+  }
+  // A folder sessions run in: its .claude/agents may define project specialists.
+  addFolder(cwd) {
+    if (this.folders.has(cwd)) return;
+    this.folders.add(cwd);
+    this.refresh();
+  }
+  // Someone called this type: remember it, and learn types we haven't seen defined.
+  used(type, at) {
+    if ((this.lastUsed.get(type) ?? 0) >= at) return;
+    this.lastUsed.set(type, at);
+    const known = this.list.find((s) => s.type === type);
+    if (known) {
+      known.lastUsed = at;
+      this.schedule();
+    } else this.refresh();
+  }
+  refresh() {
+    this.schedule(() => this.reload());
+  }
+  schedule(work) {
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      work?.();
+      this.emit("changed", this.list);
+    }, 400);
+  }
+  reload() {
+    const found = /* @__PURE__ */ new Map();
+    const add = (items) => items.forEach((s) => !found.has(s.type) && found.set(s.type, s));
+    for (const cwd of this.folders) add(readAgentsDir(join3(cwd, ".claude", "agents"), "project"));
+    add(readAgentsDir(join3(homedir2(), ".claude", "agents"), "user"));
+    for (const { dir, prefix } of pluginAgentDirs()) add(readAgentsDir(dir, "plugin", prefix));
+    add(BUILTINS.map(({ room: _r, ...b }) => ({ ...b, source: "builtin" })));
+    for (const type of this.lastUsed.keys()) if (!found.has(type)) found.set(type, { type, name: titleCase(type), description: "", source: "builtin" });
+    const overrides = this.overrides();
+    const builtinRoom = (type) => BUILTINS.find((b) => b.type === type)?.room;
+    this.list = [...found.values()].map((s) => ({
+      ...s,
+      room: overrides[s.type] ?? (s.source === "builtin" ? builtinRoom(s.type) : void 0) ?? homeRoom(s.type, s.description, overrides),
+      lastUsed: this.lastUsed.get(s.type)
+    }));
+  }
+};
+
+// ../../apps/daemon/src/observe/subagents.ts
+import { EventEmitter as EventEmitter3 } from "node:events";
+import { open, readFile, stat } from "node:fs/promises";
+import { basename as basename4, dirname, relative, sep } from "node:path";
+import chokidar2 from "chokidar";
+
+// ../../apps/daemon/src/state.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { basename as basename3, resolve as resolve2 } from "node:path";
+var DEDUPE_WINDOW_MS = 1e4;
+var Office = class extends EventEmitter2 {
+  constructor(roster, store2) {
+    super();
+    this.roster = roster;
+    this.store = store2;
+    for (const s of store2.loadSessions(Date.now() - config.staleMs)) this.sessions.set(s.sessionId, s);
+    setInterval(() => this.sweep(), 3e4).unref();
+  }
+  sessions = /* @__PURE__ */ new Map();
+  // Claude Code process id -> the session it is currently running (changes on /clear).
+  sessionByPid = /* @__PURE__ */ new Map();
+  // session id -> its transcript file, filled in by the transcript watcher
+  transcriptPaths = /* @__PURE__ */ new Map();
+  recent = /* @__PURE__ */ new Map();
+  // Create the session if needed and merge the patch. Returns undefined when the
+  // session is unknown and no cwd is available to place it in the office.
+  update(sessionId, cwd, patch, opts = {}) {
+    if (cwd) cwd = resolve2(cwd);
+    let s = this.sessions.get(sessionId);
+    if (!s) {
+      if (!cwd) return void 0;
+      const now = patch.lastActivity ?? Date.now();
+      s = {
+        sessionId,
+        cwd,
+        project: basename3(cwd),
+        ...assignDesk(this.roster, cwd),
+        source: "terminal",
+        status: "idle",
+        contextTokens: 0,
+        costUSD: 0,
+        activeSubagents: 0,
+        startedAt: now,
+        lastActivity: now
+      };
+      this.sessions.set(sessionId, s);
+    }
+    Object.assign(s, patch);
+    if (!opts.silent) this.publish(s);
+    return s;
+  }
+  // The roster changed (an agent was added or removed): re-seat every session.
+  setRoster(roster) {
+    this.roster = roster;
+    for (const s of this.sessions.values()) {
+      const desk = assignDesk(roster, s.cwd);
+      if (desk.agentId !== s.agentId || desk.agentName !== s.agentName) {
+        Object.assign(s, desk);
+        this.publish(s);
+      }
+    }
+  }
+  publish(s) {
+    this.store.saveSession(s);
+    this.emit("session", s);
+  }
+  // Transcripts and hooks both report tool calls; the first one to arrive wins.
+  event(e, dedupeKey) {
+    if (dedupeKey) {
+      const key = `${e.sessionId}:${e.kind}:${dedupeKey}`;
+      const seen = this.recent.get(key);
+      if (seen && e.ts - seen < DEDUPE_WINDOW_MS) return;
+      this.recent.set(key, e.ts);
+    }
+    this.store.addEvent(e);
+    this.emit("event", e);
+  }
+  snapshot() {
+    return {
+      roster: this.roster,
+      sessions: [...this.sessions.values()].filter((s) => s.status !== "ended"),
+      events: this.store.recentEvents(200)
+    };
+  }
+  sweep() {
+    const now = Date.now();
+    for (const s of this.sessions.values()) {
+      if (s.status !== "ended" && now - s.lastActivity > config.staleMs) {
+        s.status = "ended";
+        s.currentTool = void 0;
+        this.publish(s);
+      } else if (s.status === "working" && now - s.lastActivity > config.stalledMs) {
+        s.status = "idle";
+        s.currentTool = void 0;
+        s.currentToolDetail = void 0;
+        this.publish(s);
+      }
+    }
+    for (const [key, ts] of this.recent) if (now - ts > DEDUPE_WINDOW_MS) this.recent.delete(key);
+    this.store.prune();
+  }
+};
+function describeTool(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const i = input;
+  const raw = i.description ?? i.command ?? i.file_path ?? i.pattern ?? i.url ?? i.query ?? i.prompt;
+  if (typeof raw !== "string") return void 0;
+  const text = raw.replace(/\s+/g, " ").trim();
+  return text.length > 120 ? text.slice(0, 117) + "\u2026" : text;
+}
+
+// ../../apps/daemon/src/observe/subagents.ts
+var INACTIVE_MS = 10 * 60 * 1e3;
+var RECENT_MS = 24 * 60 * 60 * 1e3;
+var HISTORY_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_RUNS = 1e3;
+var HANDBACK_TOOLS = /* @__PURE__ */ new Set(["SubagentHandback"]);
+var Subagents = class extends EventEmitter3 {
+  constructor(office2) {
+    super();
+    this.office = office2;
+    const root = config.projectsDir;
+    const watcher = chokidar2.watch(root, {
+      depth: 3,
+      ignoreInitial: false,
+      ignored: (path, stats) => {
+        const parts = relative(root, path).split(sep);
+        if (!parts[0]) return false;
+        if (parts[0] === "memory" || parts[1] === "memory") return true;
+        if (parts.length <= 2) return Boolean(stats?.isFile());
+        if (parts.length === 3) return parts[2] !== "subagents";
+        return !/^agent-[\w-]+\.(jsonl|meta\.json)$/.test(parts[3]);
+      }
+    });
+    const onFile = (path) => this.schedule(path);
+    watcher.on("add", onFile).on("change", onFile);
+    watcher.on("ready", () => {
+      this.ready = true;
+      console.log("[subagents] watching specialist runs");
+    });
+    setInterval(() => this.sweep(), 3e4).unref();
+  }
+  runs = /* @__PURE__ */ new Map();
+  paths = /* @__PURE__ */ new Map();
+  // run id -> transcript
+  tails = /* @__PURE__ */ new Map();
+  queue = /* @__PURE__ */ new Map();
+  ready = false;
+  // SubagentStop time per run: transcript lines written up to then can't reopen it
+  stoppedAt = /* @__PURE__ */ new Map();
+  // Live runs and those that ended in the last day, newest first.
+  recent() {
+    const since = Date.now() - RECENT_MS;
+    return [...this.runs.values()].filter((r) => r.status === "working" || r.lastActivity > since).sort((a, b) => b.lastActivity - a.lastActivity).slice(0, 200);
+  }
+  history(type, limit = 50) {
+    return [...this.runs.values()].filter((r) => r.type === type).sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
+  }
+  // SubagentStart / SubagentStop hooks: instant signals, also for background runs.
+  hook(event, p) {
+    if (!p.agent_id || !p.session_id) return;
+    const now = Date.now();
+    let run2 = this.runs.get(p.agent_id);
+    if (event === "SubagentStart") {
+      if (!run2) {
+        run2 = { id: p.agent_id, type: p.agent_type || "general-purpose", parentSessionId: p.session_id, status: "working", startedAt: now, lastActivity: now };
+        this.runs.set(run2.id, run2);
+        this.announce(run2, true);
+      }
+      return;
+    }
+    if (event === "SubagentStop") {
+      this.stoppedAt.set(p.agent_id, now);
+      if (run2 && run2.status === "working") this.finish(run2, now);
+    }
+  }
+  schedule(path) {
+    const id = /agent-([\w-]+)\.(?:jsonl|meta\.json)$/.exec(basename4(path))?.[1];
+    if (!id) return;
+    const prev = this.queue.get(id) ?? Promise.resolve();
+    const next = prev.then(() => this.read(id, path)).catch((err) => console.error(`[subagents] ${path}:`, err.message));
+    this.queue.set(id, next);
+  }
+  async read(id, path) {
+    const dir = dirname(path);
+    const parentSessionId = basename4(dirname(dir));
+    const transcript = `${dir}/agent-${id}.jsonl`;
+    let run2 = this.runs.get(id);
+    if (!run2) {
+      const meta = await readMeta(`${dir}/agent-${id}.meta.json`);
+      const info = await stat(transcript).catch(() => stat(path));
+      const startedAt = info.birthtimeMs || info.mtimeMs;
+      if (Date.now() - info.mtimeMs > HISTORY_MS) return;
+      run2 = {
+        id,
+        type: meta.agentType || "general-purpose",
+        parentSessionId,
+        description: meta.description,
+        background: meta.requestShape === "background" || void 0,
+        status: Date.now() - info.mtimeMs > INACTIVE_MS ? "done" : "working",
+        startedAt,
+        lastActivity: info.mtimeMs,
+        endedAt: Date.now() - info.mtimeMs > INACTIVE_MS ? info.mtimeMs : void 0
+      };
+      this.runs.set(id, run2);
+      this.paths.set(id, transcript);
+      this.emit("used", run2.type, run2.startedAt);
+      if (run2.status === "done" && Date.now() - info.mtimeMs > RECENT_MS) {
+        this.trim();
+        return;
+      }
+    } else if (path.endsWith(".meta.json")) {
+      const meta = await readMeta(path);
+      const changed = meta.agentType && meta.agentType !== run2.type || meta.description && !run2.description;
+      if (meta.agentType) run2.type = meta.agentType;
+      run2.description ??= meta.description;
+      run2.background ??= meta.requestShape === "background" || void 0;
+      this.paths.set(id, transcript);
+      if (changed) this.publish(run2);
+      return;
+    }
+    this.paths.set(id, transcript);
+    if (path.endsWith(".jsonl")) await this.tail(run2, transcript);
+    else if (!this.tails.has(id)) await this.tail(run2, transcript).catch(() => void 0);
+  }
+  async tail(run2, path) {
+    const { size } = await stat(path);
+    let t = this.tails.get(run2.id);
+    const first = !t;
+    if (!t) {
+      t = { offset: Math.max(0, size - 256 * 1024), partial: "" };
+      this.tails.set(run2.id, t);
+    }
+    if (size < t.offset) Object.assign(t, { offset: 0, partial: "" });
+    if (size === t.offset) {
+      if (first) this.announce(run2, false);
+      return;
+    }
+    const fh = await open(path, "r");
+    const cutStart = first && t.offset > 0;
+    try {
+      const buf = Buffer.alloc(size - t.offset);
+      await fh.read(buf, 0, buf.length, t.offset);
+      t.offset = size;
+      const lines = (t.partial + buf.toString("utf8")).split("\n");
+      t.partial = lines.pop() ?? "";
+      lines.forEach((line, i) => {
+        if (!line || i === 0 && cutStart) return;
+        try {
+          this.line(run2, JSON.parse(line));
+        } catch {
+        }
+      });
+    } finally {
+      await fh.close();
+    }
+    if (first) {
+      if (run2.status === "working" && Date.now() - run2.lastActivity > INACTIVE_MS) {
+        run2.status = "done";
+        run2.endedAt = run2.lastActivity;
+        run2.currentTool = void 0;
+        run2.currentToolDetail = void 0;
+      }
+      this.announce(run2, this.ready && run2.status === "working");
+    } else this.publish(run2);
+  }
+  // One line of the run's own transcript.
+  line(run2, o) {
+    const ts = o.timestamp ? Date.parse(o.timestamp) : Date.now();
+    run2.lastActivity = Math.max(run2.lastActivity, ts);
+    const m = o.message ?? {};
+    const stopped = this.stoppedAt.get(run2.id);
+    if (stopped !== void 0 && ts <= stopped + 2e3) {
+      if (o.type === "assistant") {
+        for (const b of Array.isArray(m.content) ? m.content : []) if (b.type === "text" && b.text?.trim()) run2.lastText = b.text.trim().slice(0, 280);
+      }
+      return;
+    }
+    if (o.type === "assistant") {
+      let usedTool = false;
+      let handedBack = false;
+      for (const b of Array.isArray(m.content) ? m.content : []) {
+        if (b.type === "tool_use" && HANDBACK_TOOLS.has(b.name)) {
+          handedBack = true;
+          if (typeof b.input?.message === "string") run2.lastText = b.input.message.trim().slice(0, 280);
+        } else if (b.type === "tool_use") {
+          usedTool = true;
+          run2.currentTool = b.name;
+          run2.currentToolDetail = describeTool(b.input);
+        } else if (b.type === "text" && b.text?.trim()) {
+          const text = b.text.trim();
+          run2.lastText = text.length > 280 ? text.slice(0, 277) + "\u2026" : text;
+        }
+      }
+      if (handedBack || !usedTool && (m.stop_reason === "end_turn" || m.stop_reason === "stop_sequence")) {
+        run2.status = "done";
+        run2.endedAt = ts;
+        run2.currentTool = void 0;
+        run2.currentToolDetail = void 0;
+      } else {
+        run2.status = "working";
+        run2.endedAt = void 0;
+      }
+    } else if (o.type === "user") {
+      const result = Array.isArray(m.content) && m.content.some((b) => b.type === "tool_result");
+      if (result) {
+        run2.currentTool = void 0;
+        run2.currentToolDetail = void 0;
+      }
+      if (Date.now() - ts < INACTIVE_MS && !(result && run2.status === "done")) {
+        run2.status = "working";
+        run2.endedAt = void 0;
+      }
+    }
+  }
+  // First sight of a run: tell the office (and the parent's activity feed if it is live news).
+  announce(run2, live) {
+    this.publish(run2);
+    if (live) this.office.event({ ts: run2.startedAt, sessionId: run2.parentSessionId, kind: "subagent_start", tool: run2.type, detail: run2.description }, run2.id);
+  }
+  finish(run2, at) {
+    run2.status = "done";
+    run2.endedAt = at;
+    run2.currentTool = void 0;
+    run2.currentToolDetail = void 0;
+    this.publish(run2);
+  }
+  wasWorking = /* @__PURE__ */ new Map();
+  publish(run2) {
+    const parent = this.office.sessions.get(run2.parentSessionId);
+    if (parent) {
+      run2.parentAgentId = parent.agentId;
+      run2.parentName = parent.agentName;
+    }
+    const was = this.wasWorking.get(run2.id);
+    this.wasWorking.set(run2.id, run2.status === "working");
+    if (was && run2.status === "done" && this.ready) this.office.event({ ts: run2.endedAt ?? Date.now(), sessionId: run2.parentSessionId, kind: "subagent_stop", tool: run2.type, detail: run2.description }, run2.id);
+    if (was !== (run2.status === "working")) this.countFor(run2.parentSessionId);
+    this.emit("run", run2);
+  }
+  // The parent session's helper count is the number of its runs still working.
+  countFor(sessionId) {
+    const s = this.office.sessions.get(sessionId);
+    if (!s) return;
+    let n = 0;
+    for (const r of this.runs.values()) if (r.parentSessionId === sessionId && r.status === "working") n++;
+    if (s.activeSubagents !== n) this.office.update(sessionId, void 0, { activeSubagents: n });
+  }
+  sweep() {
+    const now = Date.now();
+    for (const r of this.runs.values()) if (r.status === "working" && now - r.lastActivity > INACTIVE_MS) this.finish(r, r.lastActivity);
+    this.trim();
+  }
+  trim() {
+    if (this.runs.size <= MAX_RUNS) return;
+    const oldest = [...this.runs.values()].filter((r) => r.status === "done").sort((a, b) => a.lastActivity - b.lastActivity);
+    for (const r of oldest.slice(0, this.runs.size - MAX_RUNS)) {
+      this.runs.delete(r.id);
+      this.paths.delete(r.id);
+      this.tails.delete(r.id);
+      this.wasWorking.delete(r.id);
+      this.stoppedAt.delete(r.id);
+    }
+  }
+};
+async function readMeta(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+// ../../apps/daemon/src/runtime/agents.ts
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { EventEmitter as EventEmitter4 } from "node:events";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// ../../apps/daemon/src/runtime/peer.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+async function peerAncestry(remotePort, depth = 4) {
+  try {
+    const { stdout } = await run("lsof", ["-n", "-P", `-iTCP@127.0.0.1:${remotePort}`, "-sTCP:ESTABLISHED", "-Fp"]);
+    const pids = [...stdout.matchAll(/^p(\d+)$/gm)].map((m) => Number(m[1])).filter((p) => p !== process.pid);
+    if (pids.length !== 1) return void 0;
+    const chain = [pids[0]];
+    for (let i = 0; i < depth; i++) {
+      const { stdout: ppid } = await run("ps", ["-o", "ppid=", "-p", String(chain[chain.length - 1])]);
+      const p = Number(ppid.trim());
+      if (!p || p === 1) break;
+      chain.push(p);
+    }
+    return chain;
+  } catch {
+    return void 0;
+  }
+}
+
+// ../../apps/daemon/src/runtime/agents.ts
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sameSecret(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+var READ_ONLY_TOOLS = ["Read", "Glob", "Grep", "LS", "TodoWrite", "Task", "Agent", "ToolSearch"];
+var PROMPT_SETTLED = /* @__PURE__ */ new Set(["PostToolUse", "PostToolUseFailure", "Stop", "UserPromptSubmit", "SessionEnd"]);
+var IDLE_CLOSE_MS = 20 * 60 * 1e3;
+function inputStream() {
+  const items = [];
+  let wake;
+  let closed = false;
+  return {
+    push(text) {
+      items.push({ type: "user", message: { role: "user", content: text }, parent_tool_use_id: null });
+      wake?.();
+      wake = void 0;
+    },
+    close() {
+      closed = true;
+      wake?.();
+    },
+    async *messages() {
+      while (!closed) {
+        if (items.length) yield items.shift();
+        else await new Promise((r) => wake = r);
+      }
+    }
+  };
+}
+var AgentRuntime = class extends EventEmitter4 {
+  // a taken-over session runs in its own folder
+  constructor(office2, store2, terminals2) {
+    super();
+    this.office = office2;
+    this.store = store2;
+    this.terminals = terminals2;
+  }
+  live = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  channels = /* @__PURE__ */ new Map();
+  // by Claude Code pid
+  modes = /* @__PURE__ */ new Map();
+  commandCache = /* @__PURE__ */ new Map();
+  terminalOnly = /* @__PURE__ */ new Set(["exit", "quit", "statusline", "terminal-setup", "vim", "ide", "keybindings", "login", "logout", "doctor", "resume", "theme", "config", "install-github-app", "upgrade", "migrate-installer"]);
+  cwdOverride = /* @__PURE__ */ new Map();
+  // Hand an agent's conversation to the real Claude Code in a terminal. Office
+  // chat pauses for that agent until the terminal exits; then the next chat
+  // message takes the session back over.
+  // how: continue the agent's conversation, pick one in Claude Code's own
+  // /resume picker, or start a new one.
+  openTerminal(agentId, cols, rows, how = "continue") {
+    if (this.terminals.has(agentId)) return;
+    const a = this.agent(agentId);
+    if (this.isBusy(agentId)) throw new Error(`${a.name} is working in chat mode; stop that task first.`);
+    this.closeLive(agentId);
+    const closed = this.closedTerminalSession(agentId);
+    const cwd = (how === "continue" ? closed?.cwd : void 0) ?? this.cwdOverride.get(agentId) ?? a.cwd;
+    let resume;
+    if (how === "pick") resume = true;
+    else if (how === "continue") {
+      resume = closed?.sessionId ?? this.store.agentSession(agentId);
+      if (resume) this.store.setAgentSession(agentId, resume);
+    }
+    this.terminals.start(agentId, { cwd, resume, mode: this.mode(agentId) }, cols, rows);
+    this.say(
+      agentId,
+      "status",
+      how === "pick" ? "Opened Claude Code's resume picker in the terminal." : how === "new" ? "Started a new conversation in the terminal." : "Opened in the terminal: the real Claude Code is running this conversation."
+    );
+  }
+  get approvals() {
+    return [...this.pending.values()].map((p) => p.approval);
+  }
+  get running() {
+    return [...this.live].filter(([, l]) => l.busy > 0).map(([id]) => id);
+  }
+  isBusy(agentId) {
+    return (this.live.get(agentId)?.busy ?? 0) > 0;
+  }
+  // End an agent's live process (e.g. to switch to another conversation).
+  closeLive(agentId) {
+    const l = this.live.get(agentId);
+    if (!l) return;
+    this.live.delete(agentId);
+    clearTimeout(l.idleTimer);
+    l.close();
+    l.query.close();
+  }
+  history(agentId, limit = 200) {
+    return this.store.chatHistory(agentId, limit);
+  }
+  // Roster agents come from agents.yaml. Freelancers (sessions in folders the
+  // roster doesn't cover) work in the folder their latest session used, and ask
+  // before every edit since that folder can be as broad as the home directory.
+  agent(agentId) {
+    const a = this.office.roster.find((r) => r.id === agentId);
+    if (a) return a;
+    if (agentId.startsWith("freelancer:")) {
+      const latest = [...this.office.sessions.values()].filter((s) => s.agentId === agentId).sort((x, y) => y.lastActivity - x.lastActivity)[0];
+      if (latest) return { id: agentId, name: latest.agentName, role: "freelancer", room: "dev-floor", cwd: latest.cwd, permissionMode: "default" };
+    }
+    throw new Error(`No agent "${agentId}" in agents.yaml`);
+  }
+  say(agentId, role, text) {
+    this.emit("chat", this.store.addChat({ agentId, ts: Date.now(), role, text }));
+  }
+  // Messages sent while the agent is busy are queued and sent when it finishes.
+  send(agentId, text) {
+    this.agent(agentId);
+    if (this.terminals.has(agentId) && !this.channelFor(agentId)) {
+      throw new Error(`${this.agent(agentId).name} is running in the terminal: type there, or close the terminal to chat.`);
+    }
+    this.say(agentId, "you", text);
+    const channel = this.channelFor(agentId);
+    console.log(`[runtime] message for ${agentId} -> ${channel ? "terminal session (channel)" : "office agent"}`);
+    if (channel) {
+      channel.send(JSON.stringify({ type: "message", chatId: agentId, text }));
+      return;
+    }
+    const closed = this.closedTerminalSession(agentId);
+    if (closed && !this.isBusy(agentId)) {
+      this.closeLive(agentId);
+      this.store.setAgentSession(agentId, closed.sessionId);
+      this.cwdOverride.set(agentId, closed.cwd);
+      this.say(agentId, "status", "The terminal is closed, so the office has taken over this session.");
+    }
+    const l = this.live.get(agentId) ?? this.start(agentId);
+    clearTimeout(l.idleTimer);
+    l.busy++;
+    if (l.busy === 1) this.emit("running", agentId, true);
+    this.markSession(agentId, { status: "working" });
+    l.push(text);
+  }
+  async stop(agentId) {
+    const l = this.live.get(agentId);
+    if (!l || l.busy === 0) return;
+    l.stopping = true;
+    for (const [id, p] of this.pending) if (p.approval.agentId === agentId) this.resolve(id, { behavior: "deny", message: "Stopped by the user." });
+    await l.query.interrupt();
+  }
+  // Continue an earlier conversation from its folder: the next message resumes it.
+  resume(agentId, session) {
+    const a = this.agent(agentId);
+    if (this.isBusy(agentId)) throw new Error(`${a.name} is busy; stop the current task first.`);
+    this.closeLive(agentId);
+    this.store.setAgentSession(agentId, session.sessionId);
+    this.cwdOverride.set(agentId, a.cwd);
+    this.office.transcriptPaths.set(session.sessionId, session.path);
+    this.office.update(session.sessionId, a.cwd, { source: "sdk", status: "idle", title: session.title, lastActivity: Date.now() });
+    this.say(agentId, "status", `Resumed \u201C${session.title}\u201D. Your next message continues it.`);
+  }
+  // Forget in-memory state for an agent id (removed, or about to be reused).
+  forget(agentId) {
+    this.closeLive(agentId);
+    this.modes.delete(agentId);
+    this.cwdOverride.delete(agentId);
+    this.commandCache.delete(agentId);
+    this.store.forgetAgent(agentId);
+  }
+  mode(agentId) {
+    return this.modes.get(agentId) ?? this.store.agentMode(agentId) ?? this.agent(agentId).permissionMode ?? "acceptEdits";
+  }
+  // Like Shift+Tab in the terminal; applies to the running task too.
+  async setMode(agentId, mode) {
+    const before = this.mode(agentId);
+    this.modes.set(agentId, mode);
+    this.store.setAgentMode(agentId, mode);
+    const l = this.live.get(agentId);
+    if (!l) return;
+    if (mode === "bypassPermissions") {
+      for (const [id, p] of this.pending) if (p.approval.agentId === agentId && p.approval.kind === "tool" && !p.relayedFromPid) this.resolve(id, { behavior: "allow" });
+      if (before !== "bypassPermissions") this.say(agentId, "status", "Allow all is on: nothing will ask for permission.");
+      return;
+    }
+    await l.query.setPermissionMode(mode);
+  }
+  // The slash commands this agent's sessions support (built-ins, skills,
+  // custom commands), minus the ones that only make sense in a terminal.
+  // Loading them starts Claude Code without sending any message.
+  async commands(agentId) {
+    const cached = this.commandCache.get(agentId);
+    if (cached && Date.now() - cached.at < 10 * 60 * 1e3) return cached.list;
+    const a = this.agent(agentId);
+    let release;
+    const hold = new Promise((r) => release = r);
+    const q = query({
+      prompt: (async function* () {
+        await hold;
+      })(),
+      options: { cwd: this.cwdOverride.get(agentId) ?? a.cwd, settingSources: ["user", "project", "local"] }
+    });
+    try {
+      const list = (await q.supportedCommands()).filter((c) => !this.terminalOnly.has(c.name) && !c.name.startsWith("_")).map((c) => ({ name: c.name, description: c.description, argumentHint: c.argumentHint || void 0 })).sort((x, y) => x.name.localeCompare(y.name));
+      this.commandCache.set(agentId, { at: Date.now(), list });
+      return list;
+    } finally {
+      release();
+      q.close();
+    }
+  }
+  // Forget the conversation; the next message starts a fresh session.
+  reset(agentId) {
+    this.closeLive(agentId);
+    this.store.setAgentSession(agentId, void 0);
+    this.say(agentId, "status", "Started a new conversation.");
+  }
+  // The agent's most recent terminal session, if its terminal has exited and it's
+  // newer than the office's own conversation with that agent.
+  closedTerminalSession(agentId) {
+    const officeSession = this.office.sessions.get(this.store.agentSession(agentId) ?? "");
+    const candidates = [...this.office.sessions.values()].filter((s) => s.agentId === agentId && s.source === "terminal" && !s.background && this.office.transcriptPaths.has(s.sessionId)).sort((x, y) => y.lastActivity - x.lastActivity);
+    const latest = candidates[0];
+    if (!latest || officeSession && officeSession.lastActivity >= latest.lastActivity) return void 0;
+    const pid = [...this.office.sessionByPid].find(([, id]) => id === latest.sessionId)?.[0];
+    if (pid && isAlive(pid)) return void 0;
+    return latest;
+  }
+  // --- channels: terminal sessions linked to the office ---------------------
+  // remotePort identifies the connecting process, so a channel can only speak
+  // for the Claude Code session that actually started it.
+  attachChannel(socket, remotePort) {
+    let pid;
+    socket.on("message", async (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (msg.type === "hello" && Number.isInteger(msg.pid)) {
+        if (pid !== void 0) return;
+        const chain = await peerAncestry(remotePort, 1);
+        if (typeof msg.token !== "string" || !sameSecret(msg.token, channelToken()) || !chain || chain[1] !== msg.pid) {
+          console.warn(`[channel] refused a channel claiming pid ${msg.pid} (peer chain ${chain?.join(" <- ") ?? "unknown"})`);
+          socket.close(4003, "not verified");
+          return;
+        }
+        pid = msg.pid;
+        this.channels.set(pid, socket);
+        this.markChannel(pid, true);
+        return;
+      }
+      if (!pid) return;
+      const session = this.sessionForPid(pid);
+      if (msg.type === "reply" && typeof msg.text === "string") {
+        if (session) this.say(session.agentId, "agent", msg.text);
+      } else if (msg.type === "permission" && session && /^[a-km-z]{5}$/.test(msg.requestId)) {
+        this.relayPermission(pid, socket, session.agentId, msg);
+      }
+    });
+    socket.on("close", () => {
+      if (pid === void 0 || this.channels.get(pid) !== socket) return;
+      this.channels.delete(pid);
+      this.markChannel(pid, false);
+      for (const [id, p] of this.pending) if (p.relayedFromPid === pid) this.drop(id);
+    });
+  }
+  // Called for every hook event: links a pid to its (possibly new) session, and
+  // clears relayed prompts that were settled in the terminal.
+  hookEvent(pid, eventName) {
+    if (this.channels.has(pid)) this.markChannel(pid, true);
+    if (PROMPT_SETTLED.has(eventName)) {
+      for (const [id, p] of this.pending) if (p.relayedFromPid === pid) this.drop(id);
+    }
+  }
+  routesToChannel(agentId) {
+    return Boolean(this.channelFor(agentId));
+  }
+  // What the daemon knows about linked terminal sessions (for /api/channels).
+  channelInfo() {
+    return [...this.channels.keys()].map((pid) => {
+      const s = this.sessionForPid(pid);
+      return { pid, sessionId: this.office.sessionByPid.get(pid), agentId: s?.agentId, status: s?.status, channel: s?.channel };
+    });
+  }
+  sessionForPid(pid) {
+    const id = this.office.sessionByPid.get(pid);
+    return id ? this.office.sessions.get(id) : void 0;
+  }
+  markChannel(pid, connected) {
+    const s = this.sessionForPid(pid);
+    if (s && Boolean(s.channel) !== connected) this.office.update(s.sessionId, s.cwd, { channel: connected });
+  }
+  channelFor(agentId) {
+    let best;
+    for (const [pid, ws] of this.channels) {
+      const s = this.sessionForPid(pid);
+      if (s && s.agentId === agentId && s.status !== "ended" && (!best || s.lastActivity > best.at)) best = { ws, at: s.lastActivity };
+    }
+    return best?.ws;
+  }
+  relayPermission(pid, socket, agentId, msg) {
+    const approval = {
+      id: randomUUID(),
+      agentId,
+      ts: Date.now(),
+      kind: "tool",
+      tool: msg.tool,
+      detail: msg.preview || msg.description
+    };
+    const verdict = (behavior) => socket.send(JSON.stringify({ type: "verdict", requestId: msg.requestId, behavior }));
+    this.pending.set(approval.id, { approval, input: {}, relayedFromPid: pid, resolve: (r) => verdict(r.behavior === "allow" ? "allow" : "deny") });
+    this.emit("approval", approval);
+  }
+  drop(approvalId) {
+    if (this.pending.delete(approvalId)) this.emit("approvalResolved", approvalId);
+  }
+  resolve(approvalId, decision) {
+    const p = this.pending.get(approvalId);
+    if (!p) return false;
+    this.pending.delete(approvalId);
+    const { approval } = p;
+    if (decision.behavior === "allow") {
+      const updatedInput = approval.kind === "question" ? { ...p.input, answers: decision.answers ?? {} } : p.input;
+      p.resolve({ behavior: "allow", updatedInput });
+      this.say(approval.agentId, "status", approval.kind === "question" ? "You answered." : `You allowed ${approval.tool}.`);
+    } else {
+      p.resolve({ behavior: "deny", message: decision.message || "The user declined this." });
+      this.say(approval.agentId, "status", `You declined ${approval.tool}${decision.message ? `: ${decision.message}` : "."}`);
+    }
+    this.emit("approvalResolved", approvalId);
+    this.markSession(approval.agentId, { status: "working" });
+    return true;
+  }
+  markSession(agentId, patch) {
+    const sessionId = this.live.get(agentId)?.sessionId;
+    if (sessionId) this.office.update(sessionId, this.agent(agentId).cwd, { ...patch, source: "sdk", lastActivity: Date.now() });
+  }
+  start(agentId) {
+    const a = this.agent(agentId);
+    const resume = this.store.agentSession(agentId);
+    const instructions = [
+      `You are ${a.name}, the ${a.role} agent at Mazestudio, working in ${a.cwd}.`,
+      "You are being messaged from the piu-piu office dashboard, not a terminal: keep replies short and plain, and say what you did.",
+      a.skills?.length ? `Use these skills when relevant: ${a.skills.join(", ")}.` : "",
+      a.instructions ?? ""
+    ].filter(Boolean).join("\n");
+    const input = inputStream();
+    const q = query({
+      prompt: input.messages(),
+      options: {
+        cwd: this.cwdOverride.get(agentId) ?? a.cwd,
+        resume,
+        systemPrompt: { type: "preset", preset: "claude_code", append: instructions },
+        settingSources: ["user", "project", "local"],
+        permissionMode: this.mode(agentId),
+        // only processes started in "Allow all" may bypass permissions in the CLI;
+        // switching to it later is honoured by ask()
+        allowDangerouslySkipPermissions: this.mode(agentId) === "bypassPermissions",
+        allowedTools: READ_ONLY_TOOLS,
+        canUseTool: (toolName, toolInput, { signal }) => this.ask(agentId, toolName, toolInput, signal)
+      }
+    });
+    const l = { query: q, push: input.push, close: input.close, busy: 0 };
+    this.live.set(agentId, l);
+    void this.consume(agentId, l, Boolean(resume));
+    return l;
+  }
+  async consume(agentId, l, resumed) {
+    try {
+      for await (const msg of l.query) this.handle(agentId, l, msg);
+    } catch (err) {
+      if (!l.stopping && this.live.get(agentId) === l) this.say(agentId, "error", `Something went wrong: ${err.message}`);
+      if (resumed && /session|resume/i.test(err.message)) this.store.setAgentSession(agentId, void 0);
+    } finally {
+      if (this.live.get(agentId) === l) this.live.delete(agentId);
+      clearTimeout(l.idleTimer);
+      if (l.busy > 0) {
+        l.busy = 0;
+        this.emit("running", agentId, false);
+        this.markSession(agentId, { status: "idle", currentTool: void 0, currentToolDetail: void 0 });
+      }
+    }
+  }
+  // A turn finished (done, failed or stopped).
+  turnEnded(agentId, l) {
+    l.busy = Math.max(0, l.busy - 1);
+    if (l.stopping) {
+      this.say(agentId, "status", "Stopped.");
+      l.stopping = false;
+      l.busy = 0;
+    }
+    if (l.busy > 0) return;
+    this.emit("running", agentId, false);
+    this.markSession(agentId, { status: "idle", currentTool: void 0, currentToolDetail: void 0 });
+    l.idleTimer = setTimeout(() => this.live.get(agentId) === l && this.closeLive(agentId), IDLE_CLOSE_MS);
+  }
+  handle(agentId, l, msg) {
+    switch (msg.type) {
+      case "system":
+        if (msg.subtype === "init") {
+          l.sessionId = msg.session_id;
+          for (const c of msg.terminal_slash_commands ?? []) this.terminalOnly.add(c.replace(/^\//, ""));
+          this.store.setAgentSession(agentId, msg.session_id);
+          this.markSession(agentId, { status: "working" });
+        }
+        return;
+      case "assistant":
+        if (msg.parent_tool_use_id) return;
+        for (const block of msg.message.content) {
+          if (block.type === "text" && block.text.trim()) this.say(agentId, "agent", block.text.trim());
+          else if (block.type === "tool_use") {
+            const detail = describeTool(block.input);
+            this.say(agentId, "tool", `${block.name}${detail ? `: ${detail}` : ""}`);
+          }
+        }
+        return;
+      case "result":
+        if (msg.subtype === "success") {
+          if (msg.num_turns > 0) this.say(agentId, "status", `Done in ${msg.num_turns} turns, $${msg.total_cost_usd.toFixed(2)}.`);
+        } else if (!l.stopping) this.say(agentId, "error", `Stopped: ${msg.subtype.replace(/_/g, " ")}${"errors" in msg && msg.errors.length ? ` (${msg.errors.join("; ")})` : ""}`);
+        this.turnEnded(agentId, l);
+        return;
+    }
+  }
+  // Called by the SDK whenever a tool needs permission or Claude asks a question.
+  // The promise stays pending until you decide in the office.
+  ask(agentId, toolName, input, signal) {
+    const isQuestion = toolName === "AskUserQuestion";
+    if (!isQuestion && this.mode(agentId) === "bypassPermissions") return Promise.resolve({ behavior: "allow", updatedInput: input });
+    const approval = {
+      id: randomUUID(),
+      agentId,
+      ts: Date.now(),
+      kind: isQuestion ? "question" : "tool",
+      tool: toolName,
+      detail: isQuestion ? void 0 : String(input.plan ?? input.command ?? input.url ?? input.query ?? input.file_path ?? describeTool(input) ?? ""),
+      questions: isQuestion ? input.questions : void 0
+    };
+    return new Promise((resolve4) => {
+      this.pending.set(approval.id, { approval, input, resolve: resolve4 });
+      signal.addEventListener("abort", () => {
+        if (this.pending.delete(approval.id)) {
+          this.emit("approvalResolved", approval.id);
+          resolve4({ behavior: "deny", message: "Cancelled." });
+        }
+      });
+      this.emit("approval", approval);
+      this.markSession(agentId, { status: "waiting" });
+    });
+  }
+};
+
+// ../../apps/daemon/src/runtime/terminals.ts
+import { accessSync, chmodSync, constants, existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, join as join4 } from "node:path";
+import { EventEmitter as EventEmitter5 } from "node:events";
+import * as pty from "node-pty";
+var SCROLLBACK_BYTES = 2 * 1024 * 1024;
+var helperChecked = false;
+function ensureSpawnHelper() {
+  if (helperChecked) return;
+  helperChecked = true;
+  try {
+    const prebuilds = join4(dirname2(createRequire(import.meta.url).resolve("node-pty/package.json")), "prebuilds");
+    for (const arch of existsSync2(prebuilds) ? readdirSync2(prebuilds) : []) {
+      const helper = join4(prebuilds, arch, "spawn-helper");
+      if (!existsSync2(helper)) continue;
+      try {
+        accessSync(helper, constants.X_OK);
+      } catch {
+        chmodSync(helper, 493);
+      }
+    }
+  } catch (err) {
+    console.warn("[terminals] could not check node-pty:", err.message);
+  }
+}
+function claudeBinary() {
+  for (const p of [join4(homedir3(), ".local", "bin", "claude"), "/opt/homebrew/bin/claude", "/usr/local/bin/claude"]) if (existsSync2(p)) return p;
+  return "claude";
+}
+var Terminals = class extends EventEmitter5 {
+  terms = /* @__PURE__ */ new Map();
+  get running() {
+    return [...this.terms.keys()];
+  }
+  has(agentId) {
+    return this.terms.has(agentId);
+  }
+  pid(agentId) {
+    return this.terms.get(agentId)?.proc.pid;
+  }
+  start(agentId, opts, cols = 100, rows = 30) {
+    if (this.terms.has(agentId)) return;
+    const args = [];
+    if (opts.resume === true) args.push("--resume");
+    else if (opts.resume) args.push("--resume", opts.resume);
+    if (opts.mode === "bypassPermissions") args.push("--dangerously-skip-permissions");
+    else if (opts.mode === "plan" || opts.mode === "acceptEdits") args.push("--permission-mode", opts.mode);
+    ensureSpawnHelper();
+    const proc = pty.spawn(claudeBinary(), args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: opts.cwd,
+      env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor", FORCE_COLOR: "1" }
+    });
+    const term = { proc, buffer: "", clients: /* @__PURE__ */ new Set(), cols, rows };
+    this.terms.set(agentId, term);
+    proc.onData((data) => {
+      term.buffer += data;
+      if (term.buffer.length > SCROLLBACK_BYTES) term.buffer = term.buffer.slice(-SCROLLBACK_BYTES);
+      const frame = JSON.stringify({ type: "data", data });
+      for (const c of term.clients) if (c.readyState === c.OPEN) c.send(frame);
+    });
+    proc.onExit(({ exitCode }) => {
+      if (this.terms.get(agentId) !== term) return;
+      this.terms.delete(agentId);
+      const frame = JSON.stringify({ type: "exit", code: exitCode });
+      for (const c of term.clients) if (c.readyState === c.OPEN) c.send(frame);
+      this.emit("changed", this.running);
+    });
+    this.emit("changed", this.running);
+  }
+  // A browser view attaches: replay the scrollback, then stream. Keystrokes
+  // and resizes come back over the same socket.
+  attach(agentId, socket) {
+    const term = this.terms.get(agentId);
+    if (!term) return false;
+    term.clients.add(socket);
+    socket.send(JSON.stringify({ type: "data", data: term.buffer }));
+    socket.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (msg.type === "input" && typeof msg.data === "string") term.proc.write(msg.data);
+      else if (msg.type === "resize" && Number.isInteger(msg.cols) && Number.isInteger(msg.rows) && msg.cols > 10 && msg.rows > 3) {
+        term.cols = msg.cols;
+        term.rows = msg.rows;
+        term.proc.resize(msg.cols, msg.rows);
+      }
+    });
+    socket.on("close", () => term.clients.delete(socket));
+    return true;
+  }
+  stop(agentId) {
+    this.terms.get(agentId)?.proc.kill();
+  }
+  stopAll() {
+    for (const t of this.terms.values()) t.proc.kill();
+  }
+};
+
+// ../../apps/daemon/src/server.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+import fastifyStatic from "@fastify/static";
+import fastifyWebsocket from "@fastify/websocket";
+import Fastify from "fastify";
+
+// ../../apps/daemon/src/observe/skills.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+function isSkill(name, cwd) {
+  if (!name || name.includes("/")) return false;
+  if (name.includes(":")) return true;
+  return existsSync3(join5(homedir4(), ".claude", "skills", name)) || Boolean(cwd && existsSync3(join5(cwd, ".claude", "skills", name)));
+}
+function skillOf(input) {
+  const skill = input?.skill;
+  return typeof skill === "string" && skill ? skill : void 0;
+}
+
+// ../../apps/daemon/src/observe/hooks.ts
+function handleHook(office2, eventName, p) {
+  const sessionId = p.session_id;
+  if (!sessionId) return;
+  const ts = Date.now();
+  const update = (patch) => office2.update(sessionId, p.cwd, { lastActivity: ts, ...patch });
+  const emit = (kind, extra = {}, key) => office2.event({ ts, sessionId, kind, ...extra }, key);
+  switch (eventName) {
+    case "SessionStart":
+      if (update({ status: "idle" })) emit("session_start");
+      return;
+    case "UserPromptSubmit":
+      if (update({ status: "working" })) emit("prompt", { detail: p.prompt?.slice(0, 200) });
+      return;
+    case "PreToolUse": {
+      const detail = describeTool(p.tool_input);
+      const skill = p.tool_name === "Skill" ? skillOf(p.tool_input) : void 0;
+      const waiting = office2.sessions.get(sessionId)?.status === "waiting";
+      if (update({ ...waiting ? {} : { status: "working" }, currentTool: p.tool_name, currentToolDetail: detail, ...skill ? { activeSkill: skill } : {} })) emit("tool_start", { tool: p.tool_name, detail }, p.tool_use_id);
+      return;
+    }
+    case "PostToolUse":
+      if (update({ status: "working", currentTool: void 0, currentToolDetail: void 0 })) emit("tool_end", {}, p.tool_use_id);
+      return;
+    case "Notification":
+      if (update({ status: "waiting" })) emit("waiting", { detail: p.message });
+      return;
+    case "Stop":
+      if (update({ status: "idle", currentTool: void 0, currentToolDetail: void 0, activeSkill: void 0 })) emit("stop");
+      return;
+    case "SessionEnd": {
+      const chat = office2.sessions.get(sessionId)?.source === "sdk";
+      if (update({ status: chat ? "idle" : "ended", currentTool: void 0, currentToolDetail: void 0 })) emit(chat ? "stop" : "session_end");
+      return;
+    }
+  }
+}
+
+// ../../apps/daemon/src/folders.ts
+import { open as open2, readdir, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join6, resolve as resolve3 } from "node:path";
+var projectDir = (cwd) => join6(config.projectsDir, resolve3(cwd).replace(/[^a-zA-Z0-9]/g, "-"));
+async function suggestFolders(query2, known) {
+  const home2 = homedir5();
+  const out = new Set(known);
+  const roots = [join6(home2, "workspace"), join6(home2, "Documents", "DEV"), join6(home2, "projects"), join6(home2, "code")];
+  async function walk(dir, depth) {
+    if (depth < 0) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name.startsWith(".") || e.name === "node_modules") continue;
+      const p = join6(dir, e.name);
+      out.add(p);
+      await walk(p, depth - 1);
+    }
+  }
+  for (const r of roots) await walk(r, 2);
+  const typed = query2.trim();
+  if (typed.startsWith("/") || typed.startsWith("~")) {
+    const abs = expandHome(typed);
+    const parent = abs.endsWith("/") ? abs : abs.slice(0, abs.lastIndexOf("/") + 1);
+    try {
+      for (const e of await readdir(parent, { withFileTypes: true })) if (e.isDirectory() && !e.name.startsWith(".")) out.add(join6(parent, e.name));
+    } catch {
+    }
+  }
+  out.add(home2);
+  const q = typed.replace(/^~/, home2).toLowerCase();
+  const list = [...out].filter((p) => !q || p.toLowerCase().includes(q.replace(/^~/, home2)));
+  return list.sort((a, b) => a.length - b.length || a.localeCompare(b)).slice(0, 40);
+}
+async function isFolder(path) {
+  try {
+    return (await stat2(expandHome(path))).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function slice(path, start, length) {
+  const fh = await open2(path, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    const { bytesRead } = await fh.read(buf, 0, length, start);
+    return buf.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    await fh.close();
+  }
+}
+function lastField(text, key) {
+  const all = [...text.matchAll(new RegExp(`"${key}":"((?:[^"\\\\]|\\\\.)*)"`, "g"))];
+  if (!all.length) return void 0;
+  try {
+    return JSON.parse(`"${all[all.length - 1][1]}"`) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function titleOf(path, size) {
+  const tail = await slice(path, Math.max(0, size - 1024 * 1024), Math.min(size, 1024 * 1024));
+  const head = size > 1024 * 1024 ? await slice(path, 0, 256 * 1024) : "";
+  for (const key of ["customTitle", "agentName", "aiTitle"]) {
+    const t = lastField(tail, key) ?? lastField(head, key);
+    if (t) return t;
+  }
+  const headText = head || await slice(path, 0, Math.min(size, 256 * 1024));
+  for (const line of headText.split("\n")) {
+    try {
+      const o = JSON.parse(line);
+      if (o.type !== "user" || o.isMeta) continue;
+      const c = o.message?.content;
+      const text = typeof c === "string" ? c : Array.isArray(c) ? c.find((b) => b.type === "text")?.text : void 0;
+      if (text && !text.trim().startsWith("<")) return text.trim().slice(0, 90);
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function pastSessions(cwd, limit = 25) {
+  const dir = projectDir(expandHome(cwd));
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const stats = await Promise.all(files.map(async (f) => ({ f, s: await stat2(join6(dir, f)) })));
+  const newest = [];
+  for (const entry of stats.sort((a, b) => b.s.mtimeMs - a.s.mtimeMs).slice(0, 400)) {
+    if (newest.length >= limit) break;
+    const entrypoint = /"entrypoint":"([^"]+)"/.exec(await slice(join6(dir, entry.f), 0, Math.min(entry.s.size, 1024 * 1024)))?.[1];
+    if (!entrypoint || entrypoint === "cli" || entrypoint === "sdk-ts") newest.push(entry);
+  }
+  return Promise.all(
+    newest.map(async ({ f, s }) => {
+      const path = join6(dir, f);
+      return {
+        sessionId: f.replace(/\.jsonl$/, ""),
+        title: await titleOf(path, s.size) ?? "Untitled conversation",
+        lastActivity: s.mtimeMs,
+        sizeKB: Math.round(s.size / 1024),
+        path
+      };
+    })
+  );
+}
+
+// ../../apps/daemon/src/observe/mirror.ts
+import { open as open3, stat as stat3 } from "node:fs/promises";
+var OFFICE_REPLY_TOOL = /^mcp__(piu-piu|maze-office)__reply$/;
+function commandText(text) {
+  const name = /<command-name>([\s\S]*?)<\/command-name>/.exec(text)?.[1]?.trim();
+  if (!name) return void 0;
+  const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(text)?.[1]?.trim();
+  return `${name.startsWith("/") ? name : `/${name}`}${args ? ` ${args}` : ""}`;
+}
+function commandOutput(text) {
+  const out = [...text.matchAll(/<local-command-(?:stdout|stderr)>([\s\S]*?)<\/local-command-(?:stdout|stderr)>/g)].map((m) => m[1].trim()).filter(Boolean);
+  return out.length ? out.join("\n") : void 0;
+}
+function cleanUserText(text) {
+  const t = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+  if (!t || t.startsWith("<")) return void 0;
+  return t;
+}
+function mirrorMessages(o, offset, sidechain = false) {
+  if (!o || Boolean(o.isSidechain) !== sidechain || o.isMeta || !o.sessionId) return [];
+  const ts = o.timestamp ? Date.parse(o.timestamp) : Date.now();
+  const base = { sessionId: o.sessionId, ts };
+  const content = o.message?.content;
+  const out = [];
+  if (o.type === "system" && o.subtype === "local_command" && typeof o.content === "string") {
+    const text = commandOutput(o.content);
+    return text ? [{ ...base, id: -(offset + 1), role: "agent", text }] : [];
+  }
+  if (o.type === "user") {
+    if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) return [];
+    const raw = typeof content === "string" ? content : Array.isArray(content) ? content.filter((b) => b.type === "text").map((b) => b.text).join("\n") : "";
+    const command = commandText(raw);
+    if (command) return [{ ...base, id: -(offset + 1), role: "you", text: command }];
+    const printed = commandOutput(raw);
+    if (printed) return [{ ...base, id: -(offset + 1), role: "agent", text: printed }];
+    const texts = typeof content === "string" ? [content] : Array.isArray(content) ? content.filter((b) => b.type === "text").map((b) => b.text) : [];
+    const text = texts.map(cleanUserText).filter(Boolean).join("\n\n");
+    if (text) out.push({ ...base, id: -(offset + 1), role: "you", text });
+  } else if (o.type === "assistant" && Array.isArray(content)) {
+    content.forEach((b, i) => {
+      const id = -(offset + 1) - i / 100;
+      if (b.type === "text" && b.text?.trim()) out.push({ ...base, id, role: "agent", text: b.text.trim() });
+      else if (b.type === "tool_use" && b.name === "SubagentHandback" && typeof b.input?.message === "string") out.push({ ...base, id, role: "agent", text: b.input.message.trim() });
+      else if (b.type === "tool_use" && !OFFICE_REPLY_TOOL.test(b.name)) {
+        const detail = describeTool(b.input);
+        out.push({ ...base, id, role: "tool", text: `${b.name}${detail ? `: ${detail}` : ""}` });
+      }
+    });
+  }
+  return out;
+}
+async function readMirror(path, limit = 300, before, sidechain = false) {
+  const size = before !== void 0 ? Math.max(0, Math.min(before, (await stat3(path)).size)) : (await stat3(path)).size;
+  if (size === 0) return [];
+  let tail = 4 * 1024 * 1024;
+  for (; ; ) {
+    const messages = await readTail(path, size, tail, sidechain);
+    if (messages.length >= limit || tail >= size || tail >= 128 * 1024 * 1024) return messages.slice(-limit);
+    tail *= 4;
+  }
+}
+async function readTail(path, size, tailBytes, sidechain) {
+  const start = Math.max(0, size - tailBytes);
+  const fh = await open3(path, "r");
+  try {
+    const buf = Buffer.alloc(size - start);
+    await fh.read(buf, 0, buf.length, start);
+    const text = buf.toString("utf8");
+    const out = [];
+    let offset = start;
+    const lines = text.split("\n");
+    lines.forEach((line, i) => {
+      const lineOffset = offset;
+      offset += Buffer.byteLength(line) + 1;
+      if (!line || i === 0 && start > 0) return;
+      try {
+        out.push(...mirrorMessages(JSON.parse(line), lineOffset, sidechain));
+      } catch {
+      }
+    });
+    return out;
+  } finally {
+    await fh.close();
+  }
+}
+
+// ../../apps/daemon/src/server.ts
+function trustedOrigin(origin) {
+  if (!origin) return true;
+  try {
+    const u = new URL(origin);
+    return ["127.0.0.1", "localhost"].includes(u.hostname) && [String(config.port), "5173"].includes(u.port);
+  } catch {
+    return false;
+  }
+}
+async function startServer(office2, runtime2, store2, terminals2, specialists2, subagents2) {
+  const app2 = Fastify({ logger: false, bodyLimit: 5 * 1024 * 1024 });
+  await app2.register(fastifyWebsocket);
+  const roots = [config.officeDist, join7(import.meta.dirname, "../public"), join7(import.meta.dirname, "public")].filter((p) => Boolean(p && existsSync4(p)));
+  if (!config.officeDist) console.warn("[server] the office is not built: run pnpm build");
+  await app2.register(fastifyStatic, { root: roots });
+  app2.post("/hooks/:event", async (req, reply) => {
+    try {
+      const body = req.body ?? {};
+      handleHook(office2, req.params.event, body);
+      if (req.params.event === "SubagentStart" || req.params.event === "SubagentStop") subagents2.hook(req.params.event, body);
+      const pid = Number(req.headers["x-claude-pid"]) || void 0;
+      if (pid && body.session_id) {
+        if (office2.sessionByPid.get(pid) !== body.session_id) {
+          const chain = await peerAncestry(req.socket.remotePort ?? 0, 3);
+          if (chain?.includes(pid)) office2.sessionByPid.set(pid, body.session_id);
+          else console.warn(`[hooks] ignored a session link for pid ${pid} from an unrelated process`);
+        }
+        if (office2.sessionByPid.get(pid) === body.session_id) runtime2.hookEvent(pid, req.params.event);
+      }
+    } catch (err) {
+      console.error("[hooks]", err);
+    }
+    return reply.code(204).send();
+  });
+  app2.addHook("onRequest", async (req, reply) => {
+    if (req.url.startsWith("/api/") || req.url.startsWith("/ws") || req.url.startsWith("/channel") || req.url.startsWith("/terminal")) {
+      if (!trustedOrigin(req.headers.origin)) return reply.code(403).send({ error: "Forbidden origin" });
+    }
+  });
+  const snapshot = () => ({
+    ...office2.snapshot(),
+    approvals: runtime2.approvals,
+    running: runtime2.running,
+    terminals: terminals2.running,
+    specialists: specialists2.all,
+    subagents: subagents2.recent()
+  });
+  app2.get("/api/state", async () => snapshot());
+  app2.get("/api/sessions/:id/transcript", async (req, reply) => {
+    const path = office2.transcriptPaths.get(req.params.id);
+    if (!path) return reply.code(404).send({ error: "No transcript for that session yet." });
+    const before = req.query.before !== void 0 ? Number(req.query.before) : void 0;
+    return (await readMirror(path, 300, before)).map(({ sessionId: _s, ...m }) => m);
+  });
+  app2.get("/api/subagents/:id/transcript", async (req, reply) => {
+    const path = subagents2.paths.get(req.params.id);
+    if (!path) return reply.code(404).send({ error: "No transcript for that run." });
+    const before = req.query.before !== void 0 ? Number(req.query.before) : void 0;
+    try {
+      return (await readMirror(path, 300, before, true)).map(({ sessionId: _s, ...m }) => ({ ...m, agentId: `run:${req.params.id}` }));
+    } catch {
+      return reply.code(404).send({ error: "That run left no transcript." });
+    }
+  });
+  app2.get("/api/specialists/:type/runs", async (req) => subagents2.history(req.params.type));
+  app2.get("/api/agents/:id/chat", async (req) => runtime2.history(req.params.id, 2e3));
+  app2.get("/api/channels", async (req) => ({
+    channels: runtime2.channelInfo(),
+    links: Object.fromEntries(office2.sessionByPid),
+    routesTo: req.query.agent ? runtime2.routesToChannel(req.query.agent) : void 0
+  }));
+  app2.post("/api/agents/:id/messages", async (req, reply) => {
+    const text = req.body?.text?.trim();
+    if (!text) return reply.code(400).send({ error: "Write a message first." });
+    try {
+      runtime2.send(req.params.id, text);
+    } catch (err) {
+      return reply.code(404).send({ error: err.message });
+    }
+    return reply.code(202).send({ ok: true });
+  });
+  const roomsWithDesks = ["dev-floor", "server-room", "library", "studio-b"];
+  const clients = /* @__PURE__ */ new Set();
+  const reloadRoster = () => {
+    office2.setRoster(loadRoster());
+    for (const send of clients) send({ type: "roster", roster: office2.roster });
+  };
+  app2.post("/api/agents", async (req, reply) => {
+    const name = req.body?.name?.trim();
+    const cwd = req.body?.cwd?.trim();
+    const room = req.body?.room ?? "dev-floor";
+    if (!name) return reply.code(400).send({ error: "Give the agent a name." });
+    if (!cwd || !await isFolder(cwd)) return reply.code(400).send({ error: "Pick a folder that exists on this Mac." });
+    if (!roomsWithDesks.includes(room)) return reply.code(400).send({ error: "Pick a room with desks." });
+    const base = name.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "agent";
+    let id = base;
+    for (let i = 2; office2.roster.some((a) => a.id === id); i++) id = `${base}-${i}`;
+    const agent = { id, name, role: req.body?.role?.trim() || "dev", room, cwd: expandHome(cwd) };
+    runtime2.forget(agent.id);
+    saveAppAgents([...appAgents(), agent]);
+    if (req.body?.adopt?.startsWith("freelancer:")) store2.moveAgent(req.body.adopt, agent.id);
+    reloadRoster();
+    return reply.code(201).send(agent);
+  });
+  app2.patch("/api/agents/:id", async (req, reply) => {
+    const name = req.body?.name?.trim();
+    if (!name) return reply.code(400).send({ error: "The name can\u2019t be empty." });
+    const mine = appAgents();
+    if (mine.some((a) => a.id === req.params.id)) saveAppAgents(mine.map((a) => a.id === req.params.id ? { ...a, name } : a));
+    else if (!renameYamlAgent(req.params.id, name)) return reply.code(404).send({ error: "Unknown agent." });
+    reloadRoster();
+    return { ok: true, name };
+  });
+  app2.delete("/api/agents/:id", async (req, reply) => {
+    const mine = appAgents();
+    if (!mine.some((a) => a.id === req.params.id)) return reply.code(404).send({ error: "Only agents created in the office can be removed here." });
+    saveAppAgents(mine.filter((a) => a.id !== req.params.id));
+    runtime2.forget(req.params.id);
+    reloadRoster();
+    return { ok: true };
+  });
+  app2.get("/api/folders", async (req) => {
+    const known = [.../* @__PURE__ */ new Set([...office2.roster.map((a) => a.cwd), ...[...office2.sessions.values()].map((s) => s.cwd)])];
+    return suggestFolders(req.query.q ?? "", known);
+  });
+  app2.get("/api/folders/sessions", async (req, reply) => {
+    if (!req.query.cwd) return reply.code(400).send({ error: "cwd is required" });
+    return (await pastSessions(req.query.cwd)).map(({ path: _p, ...s }) => s);
+  });
+  app2.post("/api/agents/:id/resume", async (req, reply) => {
+    const agent = office2.roster.find((a) => a.id === req.params.id);
+    if (!agent) return reply.code(404).send({ error: "Unknown agent." });
+    const session = (await pastSessions(agent.cwd, 200)).find((s) => s.sessionId === req.body?.sessionId);
+    if (!session) return reply.code(404).send({ error: "That conversation isn't in this agent's folder." });
+    try {
+      runtime2.resume(agent.id, session);
+    } catch (err) {
+      return reply.code(409).send({ error: err.message });
+    }
+    return { ok: true };
+  });
+  app2.get("/api/agents/:id/commands", async (req, reply) => {
+    try {
+      return { commands: await runtime2.commands(req.params.id), mode: runtime2.mode(req.params.id) };
+    } catch (err) {
+      return reply.code(404).send({ error: err.message });
+    }
+  });
+  app2.post("/api/agents/:id/mode", async (req, reply) => {
+    const mode = req.body?.mode;
+    if (mode !== "default" && mode !== "acceptEdits" && mode !== "plan" && mode !== "bypassPermissions") return reply.code(400).send({ error: "mode must be default, acceptEdits, plan or bypassPermissions" });
+    await runtime2.setMode(req.params.id, mode);
+    return { mode };
+  });
+  app2.post("/api/agents/:id/stop", async (req) => {
+    await runtime2.stop(req.params.id);
+    return { ok: true };
+  });
+  app2.post("/api/agents/:id/reset", async (req) => {
+    runtime2.reset(req.params.id);
+    return { ok: true };
+  });
+  app2.post("/api/approvals/:id", async (req, reply) => {
+    const body = req.body;
+    if (!body || body.behavior !== "allow" && body.behavior !== "deny") return reply.code(400).send({ error: "behavior must be allow or deny" });
+    return runtime2.resolve(req.params.id, body) ? { ok: true } : reply.code(404).send({ error: "That request is no longer waiting." });
+  });
+  app2.get("/ws", { websocket: true }, (socket) => {
+    const send = (msg) => socket.readyState === socket.OPEN && socket.send(JSON.stringify(msg));
+    send({ type: "snapshot", ...snapshot() });
+    clients.add(send);
+    const onSession = (session) => send({ type: "session", session });
+    const onEvent = (event) => send({ type: "event", event });
+    const onChat = (message) => send({ type: "chat", message });
+    const onApproval = (approval) => send({ type: "approval", approval });
+    const onResolved = (id) => send({ type: "approval_resolved", id });
+    const onRunning = (agentId, running) => send({ type: "running", agentId, running });
+    const onTranscript = ({ sessionId, ...m }) => send({ type: "transcript", sessionId, message: { ...m, agentId: office2.sessions.get(sessionId)?.agentId ?? "" } });
+    office2.on("session", onSession).on("event", onEvent).on("transcript", onTranscript);
+    runtime2.on("chat", onChat).on("approval", onApproval).on("approvalResolved", onResolved).on("running", onRunning);
+    socket.on("close", () => {
+      clients.delete(send);
+      office2.off("session", onSession).off("event", onEvent).off("transcript", onTranscript);
+      runtime2.off("chat", onChat).off("approval", onApproval).off("approvalResolved", onResolved).off("running", onRunning);
+    });
+  });
+  app2.post("/api/agents/:id/terminal", async (req, reply) => {
+    const how = req.body?.how === "pick" || req.body?.how === "new" ? req.body.how : "continue";
+    try {
+      runtime2.openTerminal(req.params.id, req.body?.cols, req.body?.rows, how);
+    } catch (err) {
+      return reply.code(409).send({ error: err.message });
+    }
+    return { ok: true };
+  });
+  app2.delete("/api/agents/:id/terminal", async (req) => {
+    terminals2.stop(req.params.id);
+    return { ok: true };
+  });
+  app2.get("/terminal/:id", { websocket: true }, (socket, req) => {
+    if (!terminals2.attach(req.params.id, socket)) {
+      socket.send(JSON.stringify({ type: "exit", code: null }));
+      socket.close();
+    }
+  });
+  terminals2.on("changed", (ids) => {
+    for (const send of clients) send({ type: "terminals", ids });
+  });
+  specialists2.on("changed", (list) => {
+    for (const send of clients) send({ type: "specialists", list });
+  });
+  subagents2.on("run", (run2) => {
+    for (const send of clients) send({ type: "subagent", run: run2 });
+  });
+  app2.get("/channel", { websocket: true }, (socket, req) => runtime2.attachChannel(socket, req.socket.remotePort ?? 0));
+  await app2.listen({ host: config.host, port: config.port });
+  console.log(`[server] http://${config.host}:${config.port}`);
+  return app2;
+}
+
+// ../../apps/daemon/src/store.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join8 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var Store = class {
+  db;
+  constructor(dir = config.dataDir) {
+    mkdirSync2(dir, { recursive: true });
+    this.db = new DatabaseSync(join8(dir, "office.db"));
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, last_activity INTEGER, json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS events (id INTEGER PRIMARY KEY AUTOINCREMENT, ts INTEGER, session_id TEXT, json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS chat (id INTEGER PRIMARY KEY AUTOINCREMENT, agent_id TEXT NOT NULL, ts INTEGER NOT NULL, role TEXT NOT NULL, text TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS chat_agent ON chat (agent_id, id);
+      CREATE TABLE IF NOT EXISTS agent_sessions (agent_id TEXT PRIMARY KEY, session_id TEXT NOT NULL, updated INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS agent_modes (agent_id TEXT PRIMARY KEY, mode TEXT NOT NULL);
+    `);
+  }
+  saveSession(s) {
+    this.db.prepare("INSERT INTO sessions (id, last_activity, json) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET last_activity = excluded.last_activity, json = excluded.json").run(s.sessionId, s.lastActivity, JSON.stringify(s));
+  }
+  loadSessions(since) {
+    const rows = this.db.prepare("SELECT json FROM sessions WHERE last_activity >= ?").all(since);
+    return rows.map((r) => JSON.parse(r.json));
+  }
+  addEvent(e) {
+    this.db.prepare("INSERT INTO events (ts, session_id, json) VALUES (?, ?, ?)").run(e.ts, e.sessionId, JSON.stringify(e));
+  }
+  recentEvents(limit) {
+    const rows = this.db.prepare("SELECT json FROM events ORDER BY id DESC LIMIT ?").all(limit);
+    return rows.map((r) => JSON.parse(r.json)).reverse();
+  }
+  addChat(m) {
+    const r = this.db.prepare("INSERT INTO chat (agent_id, ts, role, text) VALUES (?, ?, ?, ?)").run(m.agentId, m.ts, m.role, m.text);
+    return { ...m, id: Number(r.lastInsertRowid) };
+  }
+  chatHistory(agentId, limit = 200) {
+    const rows = this.db.prepare("SELECT id, agent_id AS agentId, ts, role, text FROM chat WHERE agent_id = ? ORDER BY id DESC LIMIT ?").all(agentId, limit);
+    return rows.reverse();
+  }
+  // Each agent's mode (Ask first / Auto-edit / Plan / Allow all) survives restarts.
+  agentMode(agentId) {
+    return this.db.prepare("SELECT mode FROM agent_modes WHERE agent_id = ?").get(agentId)?.mode;
+  }
+  setAgentMode(agentId, mode) {
+    this.db.prepare("INSERT INTO agent_modes (agent_id, mode) VALUES (?, ?) ON CONFLICT(agent_id) DO UPDATE SET mode = excluded.mode").run(agentId, mode);
+  }
+  // An agent was removed (or an id is being reused): drop its saved mode and
+  // conversation link, so a later agent with the same id starts clean rather
+  // than inheriting, say, Allow all.
+  forgetAgent(agentId) {
+    this.db.prepare("DELETE FROM agent_modes WHERE agent_id = ?").run(agentId);
+    this.db.prepare("DELETE FROM agent_sessions WHERE agent_id = ?").run(agentId);
+  }
+  // A freelancer became a named agent: their office chat and conversation follow.
+  moveAgent(from, to) {
+    this.db.prepare("UPDATE chat SET agent_id = ? WHERE agent_id = ?").run(to, from);
+    this.db.prepare("UPDATE OR REPLACE agent_sessions SET agent_id = ? WHERE agent_id = ?").run(to, from);
+    this.db.prepare("UPDATE OR REPLACE agent_modes SET agent_id = ? WHERE agent_id = ?").run(to, from);
+  }
+  // The SDK session each roster agent continues when you message them.
+  agentSession(agentId) {
+    const row = this.db.prepare("SELECT session_id FROM agent_sessions WHERE agent_id = ?").get(agentId);
+    return row?.session_id;
+  }
+  setAgentSession(agentId, sessionId) {
+    if (sessionId) this.db.prepare("INSERT INTO agent_sessions (agent_id, session_id, updated) VALUES (?, ?, ?) ON CONFLICT(agent_id) DO UPDATE SET session_id = excluded.session_id, updated = excluded.updated").run(agentId, sessionId, Date.now());
+    else this.db.prepare("DELETE FROM agent_sessions WHERE agent_id = ?").run(agentId);
+  }
+  prune() {
+    this.db.prepare("DELETE FROM events WHERE id <= (SELECT MAX(id) FROM events) - ?").run(config.maxEvents);
+    this.db.prepare("DELETE FROM sessions WHERE last_activity < ?").run(Date.now() - 7 * 24 * 60 * 60 * 1e3);
+  }
+};
+
+// ../../apps/daemon/src/observe/transcripts.ts
+import { open as open4, stat as stat4 } from "node:fs/promises";
+import { basename as basename5 } from "node:path";
+import chokidar3 from "chokidar";
+function watchTranscripts(office2) {
+  const cursors = /* @__PURE__ */ new Map();
+  const queue = /* @__PURE__ */ new Map();
+  const schedule = (path) => {
+    const prev = queue.get(path) ?? Promise.resolve();
+    const next = prev.then(() => readNew(path)).catch((err) => console.error(`[transcripts] ${path}:`, err.message));
+    queue.set(path, next);
+  };
+  async function readNew(path) {
+    const { size, mtimeMs } = await stat4(path);
+    let cur = cursors.get(path);
+    if (!cur) {
+      cur = { offset: 0, partial: "", pending: {}, replaying: true };
+      cursors.set(path, cur);
+      if (Date.now() - mtimeMs > config.replayWindowMs) {
+        cur.offset = size;
+        cur.replaying = false;
+        return;
+      }
+      cur.offset = Math.max(0, size - config.replayBytes);
+    }
+    if (size < cur.offset) Object.assign(cur, { offset: 0, partial: "" });
+    if (size === cur.offset) return;
+    const fh = await open4(path, "r");
+    try {
+      const buf = Buffer.alloc(size - cur.offset);
+      await fh.read(buf, 0, buf.length, cur.offset);
+      const startedMidFile = cur.replaying && cur.offset > 0 && !cur.partial;
+      let lineOffset = cur.offset - Buffer.byteLength(cur.partial);
+      cur.offset = size;
+      const lines = (cur.partial + buf.toString("utf8")).split("\n");
+      cur.partial = lines.pop() ?? "";
+      lines.forEach((line, i) => {
+        const at = lineOffset;
+        lineOffset += Buffer.byteLength(line) + 1;
+        if (!line || i === 0 && startedMidFile) return;
+        handleLine(cur, line, at, path);
+      });
+    } finally {
+      await fh.close();
+    }
+    if (cur.replaying) {
+      cur.replaying = false;
+      const s = cur.sessionId && office2.sessions.get(cur.sessionId);
+      if (s) {
+        if (Date.now() - s.lastActivity > config.staleMs) s.status = "ended";
+        office2.publish(s);
+      }
+    }
+  }
+  function handleLine(cur, line, offset, path) {
+    let o;
+    try {
+      o = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (o.isSidechain) return;
+    cur.sessionId ??= o.sessionId;
+    if (cur.sessionId) office2.transcriptPaths.set(cur.sessionId, path);
+    if (typeof o.entrypoint === "string" && o.entrypoint !== "cli" && !cur.pending.background && !office2.sessions.get(cur.sessionId)?.background) {
+      const known = office2.sessions.get(cur.sessionId);
+      if (known) office2.update(cur.sessionId, cur.cwd, { background: true }, { silent: cur.replaying });
+      else cur.pending.background = true;
+    }
+    if (typeof o.gitBranch === "string" && o.gitBranch && cur.sessionId) {
+      const known = office2.sessions.get(cur.sessionId);
+      if (known && known.gitBranch !== o.gitBranch) office2.update(cur.sessionId, cur.cwd, { gitBranch: o.gitBranch }, { silent: cur.replaying });
+      else if (!known) cur.pending.gitBranch = o.gitBranch;
+    }
+    if (!cur.replaying) for (const m of mirrorMessages(o, offset)) office2.emit("transcript", m);
+    if (typeof o.cwd === "string") cur.cwd = o.cwd;
+    if (!cur.sessionId) return;
+    const ts = o.timestamp ? Date.parse(o.timestamp) : Date.now();
+    const silent = cur.replaying;
+    const apply = (patch) => {
+      const merged = { ...cur.pending, ...patch };
+      const s = office2.update(cur.sessionId, cur.cwd, merged, { silent });
+      cur.pending = s ? {} : merged;
+    };
+    const emit = (kind, extra = {}, key) => {
+      if (!silent && office2.sessions.has(cur.sessionId)) office2.event({ ts, sessionId: cur.sessionId, kind, ...extra }, key);
+    };
+    switch (o.type) {
+      case "custom-title":
+        if (o.customTitle) {
+          cur.named = true;
+          apply({ title: o.customTitle });
+        }
+        return;
+      case "ai-title":
+        if (!cur.named) apply({ title: o.aiTitle });
+        return;
+      case "cost-state":
+        apply({ costUSD: o.totalCostUSD ?? 0 });
+        return;
+      case "system":
+        if (o.subtype === "turn_duration") apply({ status: "idle", currentTool: void 0, currentToolDetail: void 0, activeSkill: void 0, lastActivity: ts });
+        return;
+      case "assistant":
+        return handleAssistant(cur, o, ts, apply, emit);
+      case "user":
+        return handleUser(cur, o, ts, apply, emit);
+    }
+  }
+  function handleAssistant(cur, o, ts, apply, emit) {
+    const m = o.message ?? {};
+    const u = m.usage;
+    const waiting = office2.sessions.get(cur.sessionId)?.status === "waiting";
+    const patch = { lastActivity: ts, ...waiting ? {} : { status: "working" } };
+    if (m.model) patch.model = m.model;
+    if (u) patch.contextTokens = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+    for (const block of Array.isArray(m.content) ? m.content : []) {
+      if (block.type === "tool_use") {
+        const detail = describeTool(block.input);
+        patch.currentTool = block.name;
+        patch.currentToolDetail = detail;
+        if (block.name === "Skill" && skillOf(block.input)) patch.activeSkill = skillOf(block.input);
+        emit("tool_start", { tool: block.name, detail }, block.id);
+      } else if (block.type === "text" && block.text?.trim()) {
+        const text = block.text.trim();
+        patch.lastText = text.length > 280 ? text.slice(0, 277) + "\u2026" : text;
+        emit("text", { detail: patch.lastText });
+      }
+    }
+    if (m.stop_reason === "end_turn" || m.stop_reason === "stop_sequence") {
+      patch.status = "idle";
+      patch.currentTool = void 0;
+      patch.currentToolDetail = void 0;
+      patch.activeSkill = void 0;
+    }
+    apply(patch);
+  }
+  function handleUser(cur, o, ts, apply, emit) {
+    if (o.isMeta) return;
+    const content = o.message?.content;
+    if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
+      for (const b of content) {
+        if (b.type !== "tool_result") continue;
+        emit("tool_end", { detail: b.is_error ? "error" : void 0 }, b.tool_use_id);
+      }
+      apply({ lastActivity: ts, status: "working", currentTool: void 0, currentToolDetail: void 0 });
+      return;
+    }
+    const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((b) => b.type === "text")?.text : void 0;
+    const command = text && /<command-name>\/?([^<\s]+)<\/command-name>/.exec(text)?.[1];
+    if (command && isSkill(command, cur.cwd)) {
+      apply({ lastActivity: ts, status: "working", activeSkill: command });
+      return;
+    }
+    if (!text || text.startsWith("<")) return;
+    apply({ lastActivity: ts, status: "working" });
+    emit("prompt", { detail: text.length > 200 ? text.slice(0, 197) + "\u2026" : text });
+  }
+  const watcher = chokidar3.watch(config.projectsDir, {
+    depth: 1,
+    ignoreInitial: false,
+    ignored: (path, stats) => Boolean(stats?.isFile() && !path.endsWith(".jsonl")) || basename5(path) === "memory"
+  });
+  watcher.on("add", schedule).on("change", schedule);
+  watcher.on("ready", () => console.log(`[transcripts] watching ${config.projectsDir}`));
+  return () => watcher.close();
+}
+
+// ../../apps/daemon/src/index.ts
+prepareHome();
+channelToken();
+console.log(`[piu-piu] data in ${config.home}`);
+var store = new Store();
+var office = new Office(loadRoster(), store);
+var terminals = new Terminals();
+var runtime = new AgentRuntime(office, store, terminals);
+var stopWatching = watchTranscripts(office);
+var specialists = new Specialists(specialistRooms);
+var subagents = new Subagents(office);
+subagents.on("used", (type, at) => specialists.used(type, at));
+for (const a of office.roster) specialists.addFolder(a.cwd);
+office.on("session", (s) => specialists.addFolder(s.cwd));
+var app = await startServer(office, runtime, store, terminals, specialists, subagents);
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, async () => {
+    terminals.stopAll();
+    await stopWatching();
+    await app.close();
+    process.exit(0);
+  });
+}