@teammy/cli 0.0.9 → 0.0.10

package/dist/main.js

@@ -1,6 +1,6 @@
 // apps/client/main.ts
 import { parseArgs as parseArgs4 } from "node:util";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 
 // packages/protocol/project.ts
 import { z as z3 } from "zod";
@@ -518,10 +518,10 @@ var HubClient = class {
 };
 
 // apps/client/sessions/command.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { realpath as realpath4 } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname as dirname4, join as join6, resolve as resolve3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname5, join as join7, resolve as resolve4 } from "node:path";
 import { parseArgs } from "node:util";
 
 // packages/state/sqlite.ts
@@ -1513,6 +1513,28 @@ var sessionClientMigration = String.raw`
     root TEXT NOT NULL, path TEXT NOT NULL, signature TEXT NOT NULL, PRIMARY KEY(root, path)
   );
 `;
+var sessionSourcesMigration = String.raw`
+  CREATE TABLE session_hook_receipts (root TEXT NOT NULL, agent TEXT NOT NULL, received_at INTEGER NOT NULL, PRIMARY KEY(root,agent));
+  CREATE TABLE session_publications (
+    root TEXT NOT NULL REFERENCES connections(root), session_key TEXT NOT NULL,
+    revision INTEGER NOT NULL DEFAULT 0, hash TEXT, selected_path TEXT,
+    pending_json TEXT, pending_signature TEXT, pending_path TEXT,
+    attempts INTEGER NOT NULL DEFAULT 0, retry_at INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY(root,session_key)
+  );
+  INSERT INTO session_publications(root,session_key,revision,hash,selected_path,pending_json,pending_signature,pending_path,attempts,retry_at)
+    SELECT root,session_key,revision,hash,path,pending_json,pending_signature,path,attempts,retry_at FROM session_sources WHERE session_key IS NOT NULL;
+  ALTER TABLE session_sources RENAME TO session_sources_old;
+  DROP INDEX session_source_scheduling;
+  CREATE TABLE session_sources (
+    root TEXT NOT NULL REFERENCES connections(root), path TEXT NOT NULL, agent TEXT NOT NULL, project_dir TEXT NOT NULL,
+    session_key TEXT, signature TEXT, checked_at INTEGER NOT NULL DEFAULT 0, verified_at INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT, adopt_existing INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(root,path)
+  );
+  INSERT INTO session_sources SELECT root,path,agent,project_dir,session_key,signature,checked_at,verified_at,last_error,adopt_existing FROM session_sources_old;
+  DROP TABLE session_sources_old;
+  CREATE INDEX session_source_scheduling ON session_sources(root,checked_at,path);
+`;
 var SessionState = class {
   constructor(state, root) {
     this.state = state;
@@ -1534,23 +1556,27 @@ var SessionState = class {
   }
   sources(path, limit = 2147483647) {
     return this.state.db.prepare(
-      `SELECT * FROM session_sources WHERE root=? ${path === void 0 ? "" : "AND path=?"} ORDER BY checked_at, path LIMIT ?`
+      `SELECT s.*, p.revision,p.hash,p.selected_path,p.pending_json,p.pending_signature,p.pending_path,p.attempts,p.retry_at
+      FROM session_sources s LEFT JOIN session_publications p USING(root,session_key)
+      WHERE s.root=? ${path === void 0 ? "" : "AND s.path=?"} ORDER BY s.checked_at, s.path LIMIT ?`
     ).all(this.root, ...path === void 0 ? [] : [path], limit).map((row) => ({
       path: String(row.path),
       agent: row.agent,
       projectDir: String(row.project_dir),
       key: row.session_key,
-      revision: Number(row.revision),
-      hash: row.hash,
+      revision: Number(row.revision ?? 0),
+      hash: row.hash ?? null,
       signature: row.signature,
       checkedAt: Number(row.checked_at),
       verifiedAt: Number(row.verified_at),
       lastError: row.last_error,
       adoptExisting: Boolean(row.adopt_existing),
       pending: row.pending_json ? SessionCommitSchema.parse(JSON.parse(String(row.pending_json))) : null,
-      pendingSignature: row.pending_signature,
-      attempts: Number(row.attempts),
-      retryAt: Number(row.retry_at)
+      pendingSignature: row.pending_signature ?? null,
+      pendingPath: row.pending_path ?? null,
+      selectedPath: row.selected_path ?? null,
+      attempts: Number(row.attempts ?? 0),
+      retryAt: Number(row.retry_at ?? 0)
     }));
   }
   status() {
@@ -1560,32 +1586,61 @@ var SessionState = class {
     }));
   }
   untrack(path) {
-    this.state.db.prepare("DELETE FROM session_sources WHERE root=? AND path=?").run(this.root, path);
+    transaction(this.state.db, () => {
+      const source = this.get(path);
+      this.state.db.prepare("DELETE FROM session_sources WHERE root=? AND path=?").run(this.root, path);
+      if (!source?.key) return;
+      if (!this.state.db.prepare("SELECT 1 FROM session_sources WHERE root=? AND session_key=?").get(this.root, source.key)) {
+        this.state.db.prepare("DELETE FROM session_publications WHERE root=? AND session_key=?").run(this.root, source.key);
+      } else {
+        this.state.db.prepare(
+          "UPDATE session_publications SET selected_path=NULL WHERE root=? AND session_key=? AND selected_path=?"
+        ).run(this.root, source.key, path);
+        this.state.db.prepare(
+          "UPDATE session_publications SET pending_json=NULL,pending_signature=NULL,pending_path=NULL,attempts=0,retry_at=0 WHERE root=? AND session_key=? AND pending_path=?"
+        ).run(this.root, source.key, path);
+      }
+    });
   }
   checked(path, error = null) {
-    this.state.db.prepare("UPDATE session_sources SET checked_at=?, last_error=? WHERE root=? AND path=?").run(Date.now(), error, this.root, path);
+    this.state.db.prepare("UPDATE session_sources SET checked_at=?,last_error=? WHERE root=? AND path=?").run(Date.now(), error, this.root, path);
   }
   stage(path, request, signature2) {
     this.state.db.prepare(
-      "UPDATE session_sources SET session_key=?, pending_json=?, pending_signature=?, attempts=0, retry_at=0 WHERE root=? AND path=? AND pending_json IS NULL"
-    ).run(request.sessionKey, JSON.stringify(request), signature2, this.root, path);
+      `UPDATE session_publications SET pending_json=?,pending_signature=?,pending_path=?,attempts=0,retry_at=0
+      WHERE root=? AND session_key=? AND pending_json IS NULL`
+    ).run(JSON.stringify(request), signature2, path, this.root, request.sessionKey);
   }
   acknowledge(path, revision, hash2, signature2) {
+    const source = this.get(path);
+    this.state.db.prepare(
+      `UPDATE session_publications SET revision=?,hash=?,selected_path=?,pending_json=NULL,pending_signature=NULL,pending_path=NULL,attempts=0,retry_at=0 WHERE root=? AND session_key=?`
+    ).run(revision, hash2, path, this.root, source.key);
+    this.observed(path, signature2);
+  }
+  observed(path, signature2) {
     this.state.db.prepare(
-      `UPDATE session_sources SET revision=?, hash=?, signature=?, verified_at=?, pending_json=NULL, pending_signature=NULL, attempts=0, retry_at=0, last_error=NULL, adopt_existing=0 WHERE root=? AND path=?`
-    ).run(revision, hash2, signature2, Date.now(), this.root, path);
+      "UPDATE session_sources SET signature=?,verified_at=?,last_error=NULL,adopt_existing=0 WHERE root=? AND path=?"
+    ).run(signature2, Date.now(), this.root, path);
   }
   baseline(path, key, revision) {
-    this.state.db.prepare("UPDATE session_sources SET session_key=?, revision=? WHERE root=? AND path=?").run(key, revision, this.root, path);
+    this.state.db.prepare(
+      "INSERT OR IGNORE INTO session_publications(root,session_key,revision) VALUES (?,?,?)"
+    ).run(this.root, key, revision);
+    this.state.db.prepare("UPDATE session_sources SET session_key=? WHERE root=? AND path=?").run(key, this.root, path);
+  }
+  publication(key) {
+    return this.state.db.prepare("SELECT 1 FROM session_publications WHERE root=? AND session_key=?").get(this.root, key);
   }
   retry() {
-    this.state.db.prepare("UPDATE session_sources SET retry_at=0 WHERE root=?").run(this.root);
+    this.state.db.prepare("UPDATE session_publications SET retry_at=0 WHERE root=?").run(this.root);
   }
   postpone(source, error, blocked) {
     const at = blocked ? Number.MAX_SAFE_INTEGER : Date.now() + Math.min(9e5, 6e4 * 2 ** Math.min(source.attempts, 4));
     this.state.db.prepare(
-      "UPDATE session_sources SET retry_at=?, attempts=attempts+1, last_error=? WHERE root=? AND path=?"
-    ).run(at, error, this.root, source.path);
+      "UPDATE session_publications SET retry_at=?,attempts=attempts+1 WHERE root=? AND session_key=?"
+    ).run(at, this.root, source.key);
+    this.checked(source.path, error);
   }
   discover(agent, directory, projectDir) {
     this.state.db.prepare(
@@ -1593,6 +1648,14 @@ var SessionState = class {
     ).run(this.root, directory, agent, projectDir);
     this.state.db.prepare("DELETE FROM session_discovery_cache WHERE root=?").run(this.root);
   }
+  receivedHook(agent) {
+    this.state.db.prepare(
+      "INSERT INTO session_hook_receipts VALUES (?,?,?) ON CONFLICT(root,agent) DO UPDATE SET received_at=excluded.received_at"
+    ).run(this.root, agent, Date.now());
+  }
+  hooks() {
+    return this.state.db.prepare("SELECT agent,received_at FROM session_hook_receipts WHERE root=? ORDER BY agent").all(this.root);
+  }
   directories() {
     return this.state.db.prepare("SELECT * FROM session_discovery WHERE root=? ORDER BY directory").all(this.root).map((row) => ({
       directory: String(row.directory),
@@ -1624,7 +1687,8 @@ var ClientState = class extends FilePublicationState {
       projectClientMigration,
       controlClientMigration,
       runtimeMigration,
-      projectFilesClientMigration
+      projectFilesClientMigration,
+      sessionSourcesMigration
     ]);
     super(db);
   }
@@ -1687,11 +1751,14 @@ async function stateLocation(root, directory) {
   return canonical;
 }
 
-// apps/client/sessions/hooks.ts
-import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
-import { mkdir as mkdir4, open as open2, opendir, rename as rename2, unlink as unlink2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join5 } from "node:path";
-import { z as z10 } from "zod";
+// apps/client/sessions/setup.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { access, mkdir as mkdir4, readFile, writeFile } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname4, join as join5, resolve as resolve3 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
 
 // apps/client/sessions/normalize.ts
 function object(value) {
@@ -1702,91 +1769,104 @@ function textContent(value) {
   if (!Array.isArray(value)) return "";
   return value.flatMap((block) => {
     const part = object(block);
-    return ["text", "input_text", "output_text"].includes(String(part.type)) && typeof part.text === "string" ? [part.text] : [];
+    return ["text", "Text", "input_text", "output_text"].includes(String(part.type)) && typeof part.text === "string" ? [part.text] : [];
   }).join("\n");
 }
-function parseJsonl(text) {
-  const lines = text.split("\n");
-  const rows = [];
-  for (let index = 0; index < lines.length; index++) {
-    const line = lines[index];
-    if (!line.trim()) continue;
-    if (Buffer.byteLength(line) > 8 * 1024 * 1024) throw new Error("Session record exceeds 8 MiB.");
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      if (index === lines.length - 1 && !text.endsWith("\n")) return { rows, incomplete: true };
-      throw new Error(`Invalid session JSON at line ${index + 1}.`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      throw new Error(`Invalid session record at line ${index + 1}.`);
-    rows.push({ line: index + 1, value: object(parsed) });
+function parseRecord(line) {
+  try {
+    const value = JSON.parse(line);
+    if (value && typeof value === "object" && !Array.isArray(value)) return object(value);
+  } catch {
   }
-  return { rows, incomplete: false };
+  return void 0;
 }
-function normalizeJsonl(agent, text) {
-  const { rows, incomplete } = parseJsonl(text);
-  let nativeId;
-  let cwd;
-  const messages = [];
-  const ids = /* @__PURE__ */ new Map();
-  const add = (role, content, id, line) => {
+var JsonlNormalizer = class {
+  constructor(agent, cursor) {
+    this.agent = agent;
+    if (agent === "cursor" && cursor) {
+      this.nativeId = cursor.nativeId;
+      this.cwd = cursor.cwd;
+    }
+  }
+  agent;
+  nativeId;
+  cwd;
+  turn = "legacy";
+  candidates = [];
+  add(role, content, id, line, visible = false) {
     if (role !== "user" && role !== "assistant") return;
-    const text2 = textContent(content);
-    if (!text2.trim()) return;
-    const base = typeof id === "string" && id ? id : `line:${line}`;
-    const count = (ids.get(base) ?? 0) + 1;
-    ids.set(base, count);
-    messages.push({ id: `${base}#${count}`, role, text: text2, source: `line:${line}` });
-  };
-  for (const { line, value: row } of rows) {
-    if (agent === "claude-code") {
-      if (row.isSidechain === true) continue;
+    const text = textContent(content);
+    if (text.trim())
+      this.candidates.push({ role, text, id, line, group: `${this.turn}:${role}`, visible });
+  }
+  consume(row, line) {
+    if (this.agent === "claude-code") {
+      if (row.isSidechain === true) return;
       if (row.sessionId) {
-        if (nativeId && nativeId !== row.sessionId)
+        if (this.nativeId && this.nativeId !== row.sessionId)
           throw new Error("Mixed Claude session identities.");
-        nativeId = row.sessionId;
+        this.nativeId = row.sessionId;
       }
-      if (row.cwd && !cwd) cwd = row.cwd;
-      if (row.type === "user" || row.type === "assistant") {
+      if (row.cwd && !this.cwd) this.cwd = row.cwd;
+      if ((row.type === "user" || row.type === "assistant") && row.isMeta !== true) {
         const message2 = object(row.message);
-        add(message2.role ?? row.type, message2.content, row.uuid, line);
+        this.add(message2.role ?? row.type, message2.content, row.uuid, line);
       }
-    } else if (agent === "codex") {
+    } else if (this.agent === "codex") {
       const payload = object(row.payload);
       if (row.type === "session_meta") {
-        if (nativeId && nativeId !== payload.id) throw new Error("Mixed Codex session identities.");
-        nativeId = payload.id;
-        cwd = payload.cwd;
+        if (this.nativeId && this.nativeId !== payload.id)
+          throw new Error("Mixed Codex session identities.");
+        this.nativeId = payload.id;
+        this.cwd = payload.cwd;
       }
-      if (row.type === "response_item" && payload.type === "message" && payload.channel !== "analysis")
-        add(payload.role, payload.content, payload.id, line);
-    } else if (agent === "pi") {
+      if (typeof payload.turn_id === "string") this.turn = payload.turn_id;
+      if (row.type === "event_msg" && payload.type === "item_completed") {
+        const item = object(payload.item);
+        if (item.type === "UserMessage" || item.type === "AgentMessage")
+          this.add(
+            item.type === "UserMessage" ? "user" : "assistant",
+            item.content,
+            item.id,
+            line,
+            true
+          );
+      }
+      if (row.type === "response_item" && payload.type === "message" && payload.channel !== "analysis") {
+        const kinds = object(payload.internal_chat_message_metadata_passthrough).content_item_kinds;
+        if (payload.role === "user" && Array.isArray(kinds) && !kinds.some((k) => String(k).startsWith("user.")))
+          return;
+        this.add(payload.role, payload.content, payload.id, line);
+      }
+    } else if (this.agent === "cursor") {
+      const message2 = object(row.message);
+      if (row.isSidechain === true) return;
+      this.add(row.role ?? message2.role, message2.content ?? row.content, row.id ?? row.uuid, line);
+    } else if (this.agent === "pi") {
       if (row.type === "session") {
         if (row.version !== 3) throw new Error("Unsupported Pi session version (expected 3).");
-        if (nativeId) throw new Error("Multiple Pi session headers.");
-        nativeId = row.id;
-        cwd = row.cwd;
+        if (this.nativeId) throw new Error("Multiple Pi session headers.");
+        this.nativeId = row.id;
+        this.cwd = row.cwd;
       }
       if (row.type === "message") {
         const message2 = object(row.message);
-        add(message2.role, message2.content, row.id, line);
+        this.add(message2.role, message2.content, row.id, line);
       }
     } else {
       if (row.type === "session") {
         if (row.version !== 0) throw new Error("Unsupported DSH session version (expected 0).");
-        if (nativeId) throw new Error("Multiple DSH session headers.");
+        if (this.nativeId) throw new Error("Multiple DSH session headers.");
         if (Number(row.delegationDepth ?? 0) > 0)
           throw new Error("DSH delegated sessions are not collected.");
-        nativeId = row.id;
-        cwd = row.cwd;
+        this.nativeId = row.id;
+        this.cwd = row.cwd;
       }
       if (row.type === "user/message" || row.type === "assistant/message") {
         const data = object(row.data);
         const message2 = row.type === "assistant/message" ? object(data.message) : data;
-        if (object(message2.source).kind === "plugin") continue;
-        add(
+        if (object(message2.source).kind === "plugin") return;
+        this.add(
           row.type === "user/message" ? "user" : "assistant",
           message2.content,
           `seq:${row.seq}`,
@@ -1795,35 +1875,205 @@ function normalizeJsonl(agent, text) {
       }
     }
   }
-  return {
-    snapshot: SessionSnapshotSchema.parse({
+  finish() {
+    const visibleGroups = new Set(this.candidates.filter((m) => m.visible).map((m) => m.group));
+    const ids = /* @__PURE__ */ new Map();
+    const messages = this.candidates.filter((m) => m.visible || !visibleGroups.has(m.group)).map((m) => {
+      const base = typeof m.id === "string" && m.id ? m.id : `line:${m.line}`;
+      const count = (ids.get(base) ?? 0) + 1;
+      ids.set(base, count);
+      return { id: `${base}#${count}`, role: m.role, text: m.text, source: `line:${m.line}` };
+    });
+    return SessionSnapshotSchema.parse({
       formatVersion: 1,
       adapterVersion: 1,
-      agent,
-      nativeId,
-      cwd,
+      agent: this.agent,
+      nativeId: this.nativeId,
+      cwd: this.cwd,
       messages
-    }),
-    incomplete
-  };
+    });
+  }
+};
+
+// apps/client/sessions/setup.ts
+var exec2 = promisify2(execFile2);
+var quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
+async function exists(path, mode = constants2.F_OK) {
+  try {
+    await access(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function setupSessions(state, root, directory, options = {}) {
+  const home = options.home ?? homedir(), env = options.env ?? process.env;
+  const project = dirname4(root), sessions = new SessionState(state, root);
+  const defaults = [
+    {
+      agent: "claude-code",
+      executables: ["claude"],
+      storage: env.CLAUDE_CONFIG_DIR ?? join5(home, ".claude"),
+      directories: ["projects"],
+      config: ".claude/settings.local.json",
+      events: ["SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"]
+    },
+    {
+      agent: "codex",
+      executables: ["codex"],
+      storage: env.CODEX_HOME ?? join5(home, ".codex"),
+      directories: ["sessions"],
+      config: ".codex/hooks.json",
+      events: ["SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"]
+    },
+    {
+      agent: "cursor",
+      executables: ["agent", "cursor-agent"],
+      storage: env.CURSOR_CONFIG_DIR ?? join5(home, ".cursor"),
+      directories: ["chats", "projects"],
+      config: ".cursor/hooks.json",
+      events: ["sessionStart", "postToolUse", "stop", "sessionEnd"]
+    },
+    {
+      agent: "pi",
+      executables: ["pi"],
+      storage: env.PI_CODING_AGENT_DIR ?? join5(home, ".pi", "agent"),
+      directories: ["sessions"]
+    }
+  ];
+  const issues = [], configured = [];
+  let gitRoot = project;
+  try {
+    gitRoot = (await exec2("git", ["-C", project, "rev-parse", "--show-toplevel"])).stdout.trim();
+  } catch {
+  }
+  for (const adapter of defaults) {
+    const installed = options.agents ? options.agents.includes(adapter.agent) : await exists(adapter.storage) || (await Promise.all(
+      (env.PATH ?? "").split(":").flatMap(
+        (dir) => adapter.executables.map((name2) => exists(join5(dir, name2), constants2.X_OK))
+      )
+    )).some(Boolean);
+    if (!installed) continue;
+    for (const sub of adapter.directories)
+      sessions.discover(adapter.agent, resolve3(adapter.storage, sub), project);
+    if (adapter.agent === "cursor")
+      sessions.discover("cursor", join5(home, ".cursor", "projects"), project);
+    configured.push(adapter.agent);
+    if (!adapter.config) continue;
+    const configRoot = adapter.agent === "cursor" ? gitRoot : project;
+    const path = join5(configRoot, adapter.config);
+    try {
+      await mkdir4(dirname4(path), { recursive: true });
+      let original = null;
+      try {
+        original = await readStable(configRoot, adapter.config);
+      } catch (error) {
+        if (!missing(error)) throw error;
+      }
+      const config = original ? JSON.parse(original.bytes.toString("utf8")) : {};
+      if (!config || typeof config !== "object" || Array.isArray(config))
+        throw new Error("Hook configuration must be a JSON object.");
+      if (config.hooks !== void 0 && (!config.hooks || typeof config.hooks !== "object" || Array.isArray(config.hooks)))
+        throw new Error("Invalid existing hooks object.");
+      const hooks = object(config.hooks);
+      const marker = `teammy-session-${rootKey(root)}`;
+      const command = [
+        process.execPath,
+        options.entry ?? resolve3(process.argv[1]),
+        "session",
+        "hook",
+        "--agent",
+        adapter.agent,
+        "--root",
+        root,
+        "--state-dir",
+        directory,
+        "--project-dir",
+        project
+      ].map(quote).join(" ") + ` # ${marker}`;
+      for (const event of adapter.events) {
+        const entries = hooks[event] ?? [];
+        if (!Array.isArray(entries)) throw new Error(`Invalid ${event} hooks.`);
+        const retained = entries.flatMap((entry) => {
+          const value = object(entry);
+          if (adapter.agent === "cursor")
+            return typeof value.command === "string" && value.command.includes(marker) ? [] : [entry];
+          if (!Array.isArray(value.hooks)) return [entry];
+          const nested = value.hooks.filter(
+            (hook) => !(typeof object(hook).command === "string" && String(object(hook).command).includes(marker))
+          );
+          return nested.length ? [{ ...value, hooks: nested }] : [];
+        });
+        hooks[event] = [
+          ...retained,
+          adapter.agent === "cursor" ? { command, timeout: 3 } : { hooks: [{ type: "command", command, timeout: 3 }] }
+        ];
+      }
+      config.hooks = hooks;
+      if (adapter.agent === "cursor") config.version ??= 1;
+      const bytes = Buffer.from(JSON.stringify(config, null, 2) + "\n");
+      if (original?.bytes.equals(bytes)) continue;
+      if (original) {
+        const backupDir = join5(directory, "hook-backups", rootKey(root));
+        await mkdir4(backupDir, { recursive: true, mode: 448 });
+        const hash2 = createHash5("sha256").update(original.bytes).digest("hex");
+        await writeFile(join5(backupDir, `${adapter.agent}-${hash2}.json`), original.bytes, {
+          mode: 384
+        });
+      }
+      await replaceFile(configRoot, adapter.config, bytes, original?.signature ?? null);
+      try {
+        const relativePath = path.slice(gitRoot.length + 1);
+        const tracked = (await exec2("git", ["-C", gitRoot, "ls-files", "--", relativePath])).stdout;
+        if (!tracked) {
+          const exclude = (await exec2("git", [
+            "-C",
+            gitRoot,
+            "rev-parse",
+            "--path-format=absolute",
+            "--git-path",
+            "info/exclude"
+          ])).stdout.trim();
+          const old = await readFile(exclude, "utf8").catch((e) => {
+            if (missing(e)) return "";
+            throw e;
+          });
+          const rule = "/" + relativePath.replace(/[\\*?[\]#! ]/g, "\\$&");
+          if (!old.split(/\r?\n/).includes(rule)) {
+            await mkdir4(dirname4(exclude), { recursive: true });
+            await writeFile(exclude, old + (old && !old.endsWith("\n") ? "\n" : "") + rule + "\n");
+          }
+        }
+      } catch {
+      }
+    } catch (error) {
+      issues.push(`${path}: ${error instanceof Error ? error.message : "Hook setup failed."}`);
+    }
+  }
+  return { configured, issues };
 }
 
 // apps/client/sessions/hooks.ts
+import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
+import { mkdir as mkdir5, open as open2, opendir, rename as rename2, unlink as unlink2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join6 } from "node:path";
+import { z as z10 } from "zod";
 var HintSchema = z10.object({
   agent: AgentSchema,
-  path: z10.string().min(1).max(4096).refine(isAbsolute3),
+  path: z10.string().min(1).max(4096).refine(isAbsolute3).optional(),
+  nativeId: z10.string().min(1).max(512).optional(),
   projectDir: z10.string().min(1).max(4096).refine(isAbsolute3)
 });
 function inbox(directory, root) {
-  return join5(directory, "session-hints", createHash5("sha256").update(root).digest("hex"));
+  return join6(directory, "session-hints", createHash6("sha256").update(root).digest("hex"));
 }
 async function recordHint(directory, root, input) {
   const hint = HintSchema.parse(input);
   const targetDir = inbox(directory, root);
-  await mkdir4(targetDir, { recursive: true, mode: 448 });
-  const target = join5(
+  await mkdir5(targetDir, { recursive: true, mode: 448 });
+  const target = join6(
     targetDir,
-    `${createHash5("sha256").update(JSON.stringify(hint)).digest("hex")}.json`
+    `${createHash6("sha256").update(JSON.stringify(hint)).digest("hex")}.json`
   );
   const temporary = `${target}.${randomUUID4()}.tmp`;
   const handle = await open2(temporary, "wx", 384);
@@ -1834,7 +2084,7 @@ async function recordHint(directory, root, input) {
   }
   await rename2(temporary, target);
 }
-async function consumeHints(directory, root, sessions) {
+async function consumeHints(directory, root, sessions, refresh) {
   const issues = [];
   let dir;
   try {
@@ -1847,7 +2097,7 @@ async function consumeHints(directory, root, sessions) {
   for await (const entry of dir) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
     if (count++ >= 50) break;
-    const path = join5(inbox(directory, root), entry.name);
+    const path = join6(inbox(directory, root), entry.name);
     try {
       const handle = await open2(path, "r");
       let body;
@@ -1858,7 +2108,9 @@ async function consumeHints(directory, root, sessions) {
         await handle.close();
       }
       const hint = HintSchema.parse(JSON.parse(body));
-      sessions.track(hint.agent, hint.path, hint.projectDir);
+      sessions.receivedHook(hint.agent);
+      if (hint.path) sessions.track(hint.agent, hint.path, hint.projectDir);
+      if (hint.nativeId) await refresh?.();
       await unlink2(path);
     } catch (error) {
       issues.push(
@@ -1876,7 +2128,7 @@ async function hookPayload() {
     for await (const part of process.stdin) {
       const bytes = Buffer.from(part);
       size += bytes.length;
-      if (size > 16384) throw new Error("Hook payload too large.");
+      if (size > 4 * 1024 * 1024) throw new Error("Hook payload too large.");
       parts.push(bytes);
     }
     return object(JSON.parse(Buffer.concat(parts).toString("utf8")));
@@ -1888,6 +2140,7 @@ async function hookPayload() {
 // apps/client/sessions/command.ts
 var help = `Usage: teammy session COMMAND [options]
 
+  setup       Configure project hooks and native discovery (also done by connect)
   track       --agent AGENT --file PATH [--project-dir DIR] [--adopt-existing]
   untrack     --file PATH (does not delete server history)
   discover    --agent AGENT [--directory DIR] [--project-dir DIR]
@@ -1913,8 +2166,8 @@ async function runSessionCommand(args) {
   const { values } = parseArgs({
     args: args.slice(1),
     options: {
-      root: { type: "string", default: resolve3("workspaces") },
-      "state-dir": { type: "string", default: join6(homedir(), ".teammy", "client") },
+      root: { type: "string", default: resolve4("workspaces") },
+      "state-dir": { type: "string", default: join7(homedir2(), ".teammy", "client") },
       agent: { type: "string" },
       file: { type: "string" },
       directory: { type: "string" },
@@ -1933,16 +2186,18 @@ async function runSessionCommand(args) {
     process.stdout.write(help);
     return 0;
   }
-  const root = await realpath4(resolve3(values.root));
+  const root = await realpath4(resolve4(values.root));
   const directory = await stateLocation(root, values["state-dir"]);
-  const projectDir = await realpath4(resolve3(values["project-dir"] ?? dirname4(root)));
+  const projectDir = await realpath4(resolve4(values["project-dir"] ?? dirname5(root)));
   if (command === "hook") {
     const payload = values.file ? {} : await hookPayload();
     const file = values.file ?? payload.transcript_path ?? payload.session_file ?? payload.sessionFile;
-    if (typeof file === "string" && file)
+    const nativeId = payload.session_id ?? payload.conversation_id;
+    if (typeof file === "string" && file || typeof nativeId === "string")
       await recordHint(directory, root, {
         agent: AgentSchema.parse(values.agent),
-        path: resolve3(file),
+        ...typeof file === "string" && file ? { path: resolve4(file) } : {},
+        ...typeof nativeId === "string" ? { nativeId } : {},
         projectDir
       });
     return 0;
@@ -1954,9 +2209,10 @@ async function runSessionCommand(args) {
     const sessions = new SessionState(state, root);
     const client = new HubClient(binding.serverUrl, 1e4, binding);
     let output;
-    if (command === "track" || command === "untrack") {
+    if (command === "setup") output = await setupSessions(state, root, directory);
+    else if (command === "track" || command === "untrack") {
       if (!values.file) throw new Error("--file is required.");
-      const path = resolve3(values.file);
+      const path = resolve4(values.file);
       if (command === "track")
         sessions.track(
           AgentSchema.parse(values.agent),
@@ -1969,27 +2225,34 @@ async function runSessionCommand(args) {
     } else if (command === "discover" || command === "undiscover") {
       if (command === "undiscover") {
         if (!values.directory) throw new Error("--directory is required.");
-        state.db.prepare("DELETE FROM session_discovery WHERE root=? AND directory=?").run(root, await realpath4(resolve3(values.directory)));
+        state.db.prepare("DELETE FROM session_discovery WHERE root=? AND directory=?").run(root, await realpath4(resolve4(values.directory)));
       } else {
         const agent = AgentSchema.parse(values.agent);
         const defaults = {
-          "claude-code": join6(homedir(), ".claude", "projects"),
-          codex: join6(process.env.CODEX_HOME ?? join6(homedir(), ".codex"), "sessions"),
-          cursor: join6(
-            process.env.CURSOR_CONFIG_DIR ?? join6(homedir(), ".cursor"),
+          "claude-code": join7(
+            process.env.CLAUDE_CONFIG_DIR ?? join7(homedir2(), ".claude"),
+            "projects"
+          ),
+          codex: join7(process.env.CODEX_HOME ?? join7(homedir2(), ".codex"), "sessions"),
+          cursor: join7(
+            process.env.CURSOR_CONFIG_DIR ?? join7(homedir2(), ".cursor"),
             "chats",
-            createHash6("md5").update(projectDir).digest("hex")
+            createHash7("md5").update(projectDir).digest("hex")
           ),
-          pi: join6(process.env.PI_CODING_AGENT_DIR ?? join6(homedir(), ".pi", "agent"), "sessions"),
+          pi: join7(process.env.PI_CODING_AGENT_DIR ?? join7(homedir2(), ".pi", "agent"), "sessions"),
           dsh: void 0
         };
         const path = values.directory ?? defaults[agent];
         if (!path) throw new Error("DSH requires its configured persistence --directory.");
-        sessions.discover(agent, await realpath4(resolve3(path)), projectDir);
+        sessions.discover(agent, await realpath4(resolve4(path)), projectDir);
       }
       output = sessions.directories();
     } else if (command === "sources")
-      output = { sources: sessions.status(), discovery: sessions.directories() };
+      output = {
+        sources: sessions.status(),
+        discovery: sessions.directories(),
+        hooks: sessions.hooks()
+      };
     else {
       const after = Number(values.after);
       const limit = Number(values.limit);
@@ -2025,22 +2288,22 @@ import { setTimeout as setTimeout4 } from "node:timers/promises";
 
 // apps/client/client-command.ts
 import { parseArgs as parseArgs2 } from "node:util";
-import { join as join11, resolve as resolve5 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { join as join12, resolve as resolve6 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // apps/client/connection.ts
-import { readFile, mkdir as mkdir5 } from "node:fs/promises";
+import { readFile as readFile2, mkdir as mkdir6 } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 
 // apps/client/root-lock.ts
-import { createHash as createHash7 } from "node:crypto";
-import { join as join7 } from "node:path";
+import { createHash as createHash8 } from "node:crypto";
+import { join as join8 } from "node:path";
 function acquireRootLock(root, stateDirectory) {
   let lock;
   try {
     lock = openDatabase(
-      join7(stateDirectory, "locks", `${createHash7("sha256").update(root).digest("hex")}.sqlite3`),
+      join8(stateDirectory, "locks", `${createHash8("sha256").update(root).digest("hex")}.sqlite3`),
       [],
       0
     );
@@ -2055,9 +2318,9 @@ function acquireRootLock(root, stateDirectory) {
 }
 
 // apps/client/local-config.ts
-import { constants as constants2 } from "node:fs";
-import { open as open3, writeFile } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { constants as constants3 } from "node:fs";
+import { open as open3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 import { z as z11 } from "zod";
 import ignore from "ignore";
 var LOCAL_CONFIG_NAME = ".teammy-local.json";
@@ -2066,8 +2329,8 @@ var LocalConfigSchema = z11.object({
 }).strict();
 async function ensureLocalConfig(root) {
   try {
-    await writeFile(
-      join8(root, LOCAL_CONFIG_NAME),
+    await writeFile2(
+      join9(root, LOCAL_CONFIG_NAME),
       JSON.stringify({ files: { ignore: [] } }, null, 2) + "\n",
       { flag: "wx", mode: 384 }
     );
@@ -2079,8 +2342,8 @@ async function loadLocalRules(root) {
   let rules = [];
   try {
     const file = await open3(
-      join8(root, LOCAL_CONFIG_NAME),
-      constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK
+      join9(root, LOCAL_CONFIG_NAME),
+      constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
     );
     try {
       const before = await file.stat();
@@ -2136,7 +2399,7 @@ async function connectProject(state, root, directory, options) {
       const client2 = new HubClient(existing.serverUrl, 1e4, existing);
       await client2.members();
     } else if (options.tokenFile) {
-      const token = CredentialSchema.parse((await readFile(options.tokenFile, "utf8")).trim());
+      const token = CredentialSchema.parse((await readFile2(options.tokenFile, "utf8")).trim());
       const deviceId = state.deviceFor(root);
       const client2 = new HubClient(options.url, 1e4, { token, deviceId });
       const binding2 = await client2.bind(deviceId, options.project ?? existing?.workspaceId);
@@ -2185,7 +2448,7 @@ async function connectProject(state, root, directory, options) {
     }
     const own = await metadata(root, binding.memberId);
     if (own && !own.directory) throw new Error("Member path is not a directory.");
-    if (!own) await mkdir5(await safePath(root, binding.memberId));
+    if (!own) await mkdir6(await safePath(root, binding.memberId));
     await ensureLocalConfig(root);
     const { token: _, ...visible } = binding;
     return { ...visible, configRevision: project.cached()?.config.configRevision ?? null };
@@ -2196,23 +2459,23 @@ async function connectProject(state, root, directory, options) {
 
 // apps/client/runtime/ipc.ts
 import { createConnection } from "node:net";
-import { mkdir as mkdir6, lstat as lstat3, chmod } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { mkdir as mkdir7, lstat as lstat3, chmod } from "node:fs/promises";
+import { join as join10 } from "node:path";
 import { z as z12 } from "zod";
 var RequestSchema = z12.object({
   method: z12.enum(["ping", "wake", "status", "once"]),
   root: z12.string().max(4096).optional()
 }).strict();
 function socketPath(directory) {
-  return join9(
+  return join10(
     "/tmp",
     `teammy-${process.getuid?.() ?? "user"}-${rootKey(directory)}`,
     "control.sock"
   );
 }
 async function prepareSocketDirectory(directory) {
-  const path = join9(socketPath(directory), "..");
-  await mkdir6(path, { recursive: true, mode: 448 });
+  const path = join10(socketPath(directory), "..");
+  await mkdir7(path, { recursive: true, mode: 448 });
   const stat2 = await lstat3(path);
   if (!stat2.isDirectory() || stat2.isSymbolicLink() || stat2.uid !== process.getuid?.())
     throw new Error("Unsafe daemon socket directory.");
@@ -2220,7 +2483,7 @@ async function prepareSocketDirectory(directory) {
 }
 async function daemonRequest(directory, input, timeout = 15e3) {
   RequestSchema.parse(input);
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const socket = createConnection(socketPath(directory));
     socket.setEncoding("utf8");
     let body = "";
@@ -2230,7 +2493,7 @@ async function daemonRequest(directory, input, timeout = 15e3) {
       done = true;
       socket.destroy();
       if (error) reject(error);
-      else resolve9(result2);
+      else resolve10(result2);
     };
     socket.setTimeout(
       timeout,
@@ -2271,20 +2534,20 @@ async function runningDaemon(directory) {
 }
 
 // apps/client/runtime/service.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname5, join as join10, resolve as resolve4 } from "node:path";
-import { mkdir as mkdir7, readFile as readFile2, writeFile as writeFile2, rename as rename3 } from "node:fs/promises";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname6, join as join11, resolve as resolve5 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile3, writeFile as writeFile3, rename as rename3 } from "node:fs/promises";
 import { setTimeout as setTimeout3 } from "node:timers/promises";
-var execute = promisify2(execFile2);
-var exec2 = (file, args, options = {}) => execute(file, args, { timeout: 45e3, ...options });
+var execute = promisify3(execFile3);
+var exec3 = (file, args, options = {}) => execute(file, args, { timeout: 45e3, ...options });
 var xml = (s) => s.replace(
   /[<>&"']/g,
   (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;", "'": "&apos;" })[c]
 );
 var unit = (s) => '"' + s.replace(/%/g, "%%").replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, () => "$$") + '"';
-function serviceDefinition(directory, executable, entry, platform = process.platform, userHome = homedir2()) {
+function serviceDefinition(directory, executable, entry, platform = process.platform, userHome = homedir3()) {
   for (const value of [directory, executable, entry])
     if (/[\r\n\0]/.test(value)) throw new Error("Invalid service path.");
   const id = `com.teammy.client.${rootKey(directory)}`;
@@ -2292,7 +2555,7 @@ function serviceDefinition(directory, executable, entry, platform = process.plat
   if (platform === "darwin")
     return {
       id,
-      path: join10(userHome, "Library", "LaunchAgents", id + ".plist"),
+      path: join11(userHome, "Library", "LaunchAgents", id + ".plist"),
       content: `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict><key>Label</key><string>${id}</string><key>ProgramArguments</key><array>${args.map((a) => `<string>${xml(a)}</string>`).join("")}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ThrottleInterval</key><integer>30</integer><key>WorkingDirectory</key><string>${xml(userHome)}</string></dict></plist>
@@ -2301,7 +2564,7 @@ function serviceDefinition(directory, executable, entry, platform = process.plat
   if (platform === "linux")
     return {
       id: id + ".service",
-      path: join10(userHome, ".config", "systemd", "user", id + ".service"),
+      path: join11(userHome, ".config", "systemd", "user", id + ".service"),
       content: `[Unit]
 Description=Teammy background synchronization
 [Service]
@@ -2323,10 +2586,10 @@ WantedBy=default.target
 async function checkServiceSupport() {
   try {
     if (process.platform === "darwin")
-      await exec2("launchctl", ["print", `gui/${process.getuid()}`], {
+      await exec3("launchctl", ["print", `gui/${process.getuid()}`], {
         maxBuffer: 4 * 1024 * 1024
       });
-    else if (process.platform === "linux") await exec2("systemctl", ["--user", "show-environment"]);
+    else if (process.platform === "linux") await exec3("systemctl", ["--user", "show-environment"]);
     else throw new Error("unsupported");
   } catch {
     throw new Error(
@@ -2338,7 +2601,7 @@ async function bootstrapLaunchAgent(path) {
   const deadline = Date.now() + 1e4;
   for (; ; ) {
     try {
-      await exec2("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
+      await exec3("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
       return;
     } catch (error) {
       if (error.code !== 5 || Date.now() >= deadline) throw error;
@@ -2347,40 +2610,40 @@ async function bootstrapLaunchAgent(path) {
   }
 }
 async function ensureDaemon(directory, version) {
-  const definition = serviceDefinition(directory, process.execPath, resolve4(process.argv[1]));
+  const definition = serviceDefinition(directory, process.execPath, resolve5(process.argv[1]));
   let old = "";
   try {
-    old = await readFile2(definition.path, "utf8");
+    old = await readFile3(definition.path, "utf8");
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
   const alive = await runningDaemon(directory);
   if (alive && old === definition.content && alive.version === version) return;
   await checkServiceSupport();
-  await mkdir7(dirname5(definition.path), { recursive: true });
+  await mkdir8(dirname6(definition.path), { recursive: true });
   if (old !== definition.content) {
     const temp = definition.path + `.${process.pid}.tmp`;
-    await writeFile2(temp, definition.content, { mode: 384 });
+    await writeFile3(temp, definition.content, { mode: 384 });
     await rename3(temp, definition.path);
   }
   if (process.platform === "darwin") {
     const domain = `gui/${process.getuid()}`, target = `${domain}/${definition.id}`;
     let loaded = false;
     try {
-      await exec2("launchctl", ["print", target]);
+      await exec3("launchctl", ["print", target]);
       loaded = true;
     } catch {
     }
     if (loaded && (old !== definition.content || alive?.version !== version)) {
-      await exec2("launchctl", ["bootout", target]);
+      await exec3("launchctl", ["bootout", target]);
       loaded = false;
     }
     if (!loaded) await bootstrapLaunchAgent(definition.path);
-    await exec2("launchctl", ["kickstart", target]);
+    await exec3("launchctl", ["kickstart", target]);
   } else {
-    await exec2("systemctl", ["--user", "daemon-reload"]);
-    await exec2("systemctl", ["--user", "enable", definition.id]);
-    await exec2("systemctl", [
+    await exec3("systemctl", ["--user", "daemon-reload"]);
+    await exec3("systemctl", ["--user", "enable", definition.id]);
+    await exec3("systemctl", [
       "--user",
       old !== definition.content || alive?.version !== version ? "restart" : "start",
       definition.id
@@ -2419,8 +2682,8 @@ function json(value) {
 
 // apps/client/client-command.ts
 var locationOptions = {
-  root: { type: "string", default: resolve5("workspaces") },
-  "state-dir": { type: "string", default: join11(homedir3(), ".teammy", "client") },
+  root: { type: "string", default: resolve6("workspaces") },
+  "state-dir": { type: "string", default: join12(homedir4(), ".teammy", "client") },
   json: { type: "boolean" },
   help: { type: "boolean", short: "h" }
 };
@@ -2523,12 +2786,16 @@ async function runClientCommand(command, args, version) {
       tokenFile: values["token-file"],
       reconnect: values.reconnect
     });
+    const collection = await setupSessions(state, root, directory);
+    for (const issue of collection.issues) log.write("sessions.setup.failed", root, issue);
     completePreparation(state, root);
     runtime.enable(root, !values["no-start"]);
     log.write("workspace.connected", root);
     if (!values["no-start"]) await wakeDaemon(directory, version);
-    if (values.json) json({ ...connected, syncEnabled: !values["no-start"] });
+    if (values.json) json({ ...connected, collection, syncEnabled: !values["no-start"] });
     else result(values["no-start"] ? "\u9879\u76EE\u5DF2\u8FDE\u63A5" : "\u5DF2\u8FDE\u63A5\uFF0C\u540E\u53F0\u540C\u6B65\u5DF2\u542F\u52A8", root);
+    if (collection.issues.length && !values.json)
+      result("\u90E8\u5206\u4F1A\u8BDD Hook \u672A\u914D\u7F6E", "\u540E\u53F0\u53D1\u73B0\u4ECD\u53EF\u7528\uFF0C\u8BE6\u60C5\u89C1 teammy logs");
     return 0;
   } catch (e) {
     log.write(`${command}.failed`, root, diagnostic(e));
@@ -2541,16 +2808,16 @@ async function runClientCommand(command, args, version) {
 // apps/client/files/synchronizer.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { watch } from "node:fs";
-import { lstat as lstat4, mkdir as mkdir9 } from "node:fs/promises";
-import { join as join13, sep as sep4 } from "node:path";
+import { lstat as lstat4, mkdir as mkdir10 } from "node:fs/promises";
+import { join as join14, sep as sep4 } from "node:path";
 import { performance } from "node:perf_hooks";
 
 // packages/storage/local-blob-store.ts
-import { createHash as createHash8, randomUUID as randomUUID5 } from "node:crypto";
-import { link, mkdir as mkdir8, open as open4, readFile as readFile3, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname6, join as join12, resolve as resolve6 } from "node:path";
+import { createHash as createHash9, randomUUID as randomUUID5 } from "node:crypto";
+import { link, mkdir as mkdir9, open as open4, readFile as readFile4, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname7, join as join13, resolve as resolve7 } from "node:path";
 function hash(content) {
-  return createHash8("sha256").update(content).digest("hex");
+  return createHash9("sha256").update(content).digest("hex");
 }
 function hasCode(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
@@ -2566,13 +2833,13 @@ var BlobIntegrityError = class extends Error {
 var LocalBlobStore = class {
   root;
   constructor(root) {
-    this.root = resolve6(root);
+    this.root = resolve7(root);
   }
   async put(content) {
     const bytes = Buffer.from(content);
     const sha256 = hash(bytes);
     const target = this.pathFor(sha256);
-    await mkdir8(dirname6(target), { recursive: true, mode: 448 });
+    await mkdir9(dirname7(target), { recursive: true, mode: 448 });
     const temporary = `${target}.${randomUUID5()}.tmp`;
     const file = await open4(temporary, "wx", 384);
     try {
@@ -2589,7 +2856,7 @@ var LocalBlobStore = class {
         await this.get(sha256);
       }
       if (process.platform !== "win32") {
-        let directory = dirname6(target);
+        let directory = dirname7(target);
         for (; ; ) {
           const handle = await open4(directory, "r");
           try {
@@ -2597,8 +2864,8 @@ var LocalBlobStore = class {
           } finally {
             await handle.close();
           }
-          if (directory === dirname6(this.root)) break;
-          directory = dirname6(directory);
+          if (directory === dirname7(this.root)) break;
+          directory = dirname7(directory);
         }
       }
     } finally {
@@ -2610,7 +2877,7 @@ var LocalBlobStore = class {
     const target = this.pathFor(sha256);
     let content;
     try {
-      content = await readFile3(target);
+      content = await readFile4(target);
     } catch (error) {
       if (hasCode(error, "ENOENT")) return void 0;
       throw error;
@@ -2620,7 +2887,7 @@ var LocalBlobStore = class {
   }
   pathFor(sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error("Invalid SHA-256 content identifier.");
-    return join12(this.root, "sha256", sha256.slice(0, 2), sha256);
+    return join13(this.root, "sha256", sha256.slice(0, 2), sha256);
   }
 };
 
@@ -2680,7 +2947,7 @@ var FileSynchronizer = class _FileSynchronizer {
     if (!binding) throw new Error("Connect this root before synchronizing.");
     this.binding = binding;
     this.client = new HubClient(binding.serverUrl, 3e4, binding, this.abort.signal);
-    this.blobs = new LocalBlobStore(join13(stateDirectory, "blobs"));
+    this.blobs = new LocalBlobStore(join14(stateDirectory, "blobs"));
     this.projectScope = options.scope === "project";
     this.owner = this.projectScope ? PROJECT_FILE_OWNER : binding.memberId;
     this.publication = new FilePublicationState(state.db, options.scope);
@@ -2690,7 +2957,7 @@ var FileSynchronizer = class _FileSynchronizer {
       commitFiles: (batch) => this.projectScope ? this.client.commitSharedFiles(batch, this.sharedConfig.revision) : this.client.commitFiles(batch)
     });
     this.index = new SyncState(state, root, options.scope);
-    this.ownRoot = this.projectScope ? root : join13(root, binding.memberId);
+    this.ownRoot = this.projectScope ? root : join14(root, binding.memberId);
     this.common = this.projectScope ? void 0 : new _FileSynchronizer(state, root, stateDirectory, { ...options, scope: "project" });
     const started = performance.now();
     const epoch = Date.now();
@@ -2889,7 +3156,7 @@ var FileSynchronizer = class _FileSynchronizer {
       }
     }
     const ownerPath = this.projectScope ? this.root : await safePath(this.root, this.owner);
-    await mkdir9(ownerPath).catch((error) => {
+    await mkdir10(ownerPath).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
     this.publication.initializePublication(this.root, manifest.revision, manifest.files);
@@ -3075,7 +3342,7 @@ var FileSynchronizer = class _FileSynchronizer {
     }
     const job = this.index.job(owner);
     const ownerRoot = this.projectScope ? this.root : await safePath(this.root, owner);
-    await mkdir9(ownerRoot).catch((error) => {
+    await mkdir10(ownerRoot).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
     const ownerStat = await lstat4(ownerRoot);
@@ -3131,22 +3398,24 @@ function message(error) {
 
 // apps/client/sessions/synchronizer.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 
 // packages/protocol/session-key.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function sessionKey(agent, nativeId) {
-  return createHash9("sha256").update(JSON.stringify([agent, nativeId])).digest("hex");
+  return createHash10("sha256").update(JSON.stringify([agent, nativeId])).digest("hex");
 }
 
 // apps/client/sessions/source.ts
-import { open as open5, stat, realpath as realpath5 } from "node:fs/promises";
-import { relative as relative4, isAbsolute as isAbsolute4, sep as sep5 } from "node:path";
+import { createReadStream, realpathSync } from "node:fs";
+import { stat, realpath as realpath5, readdir as readdir2 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname9, relative as relative4, isAbsolute as isAbsolute4, sep as sep5, join as join15 } from "node:path";
+import { createInterface as createInterface3 } from "node:readline";
 import * as zlib from "node:zlib";
 
 // apps/client/sessions/cursor.ts
-import { createHash as createHash10 } from "node:crypto";
-import { basename as basename2, dirname as dirname7, resolve as resolve7 } from "node:path";
+import { createHash as createHash11 } from "node:crypto";
+import { basename as basename2, dirname as dirname8, resolve as resolve8 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { fileURLToPath } from "node:url";
 function fields(bytes) {
@@ -3184,7 +3453,7 @@ function fields(bytes) {
   }
   return result2;
 }
-function readCursor(path, projectDir) {
+function readCursor(path, projectDir, checkCwd) {
   const db = new DatabaseSync2(path, { readOnly: true });
   try {
     db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=100; BEGIN");
@@ -3195,7 +3464,7 @@ function readCursor(path, projectDir) {
     if (typeof hex !== "string" || !/^(?:[a-fA-F0-9]{2})+$/.test(hex))
       throw new Error("Invalid Cursor metadata.");
     const meta = object(JSON.parse(Buffer.from(hex, "hex").toString("utf8")));
-    if (typeof meta.agentId !== "string" || meta.agentId !== basename2(dirname7(path)) || meta.subagentInfo != null)
+    if (typeof meta.agentId !== "string" || meta.agentId !== basename2(dirname8(path)) || meta.subagentInfo != null)
       throw new Error("Invalid or delegated Cursor session identity.");
     let budget = 64 * 1024 * 1024;
     const blob = (id) => {
@@ -3205,13 +3474,13 @@ function readCursor(path, projectDir) {
         throw new Error("Cursor history missing or exceeds 64 MiB.");
       const bytes = Buffer.from(value);
       budget -= bytes.length;
-      if (createHash10("sha256").update(bytes).digest("hex") !== id)
+      if (createHash11("sha256").update(bytes).digest("hex") !== id)
         throw new Error("Cursor blob failed integrity verification.");
       return bytes;
     };
     const root = fields(blob(String(meta.latestRootBlobId)));
-    const bucket = basename2(dirname7(dirname7(path)));
-    const md5 = (cwd2) => createHash10("md5").update(resolve7(cwd2)).digest("hex");
+    const bucket = basename2(dirname8(dirname8(path)));
+    const md5 = (cwd2) => createHash11("md5").update(resolve8(cwd2)).digest("hex");
     let cwd = md5(projectDir) === bucket ? projectDir : void 0;
     for (const uri of root.get(9) ?? []) {
       try {
@@ -3224,6 +3493,7 @@ function readCursor(path, projectDir) {
       }
     }
     if (!cwd) throw new Error("Cursor workspace cannot be verified against its storage bucket.");
+    checkCwd?.(cwd);
     const refs = [];
     for (const archive of root.get(13) ?? root.get(11) ?? [])
       refs.push(...fields(blob(archive.toString("hex"))).get(1) ?? []);
@@ -3246,7 +3516,7 @@ function readCursor(path, projectDir) {
         if (start >= 0 && end > start) text = text.slice(start + 12, end).trim();
       }
       if (!text.trim()) continue;
-      const id = createHash10("sha256").update(JSON.stringify([message2.role, cursor.requestId ?? "", text])).digest("hex");
+      const id = createHash11("sha256").update(JSON.stringify([message2.role, cursor.requestId ?? "", text])).digest("hex");
       const count = (counts.get(id) ?? 0) + 1;
       counts.set(id, count);
       messages.push({
@@ -3270,9 +3540,14 @@ function readCursor(path, projectDir) {
 }
 
 // apps/client/sessions/source.ts
-var MAX_SOURCE_BYTES = 64 * 1024 * 1024;
+function within(project, cwd) {
+  const rel = relative4(project, cwd);
+  return rel !== ".." && !rel.startsWith(`..${sep5}`) && !isAbsolute4(rel);
+}
+var cursorEncoded = (cwd) => cwd.replace(/^[/\\]+/, "").replace(/[/\\]/g, "-");
+var cursorDatabase = (path) => basename3(path) === "store.db";
 async function sourceSignature(path, agent) {
-  const paths = agent === "cursor" ? [path, `${path}-wal`] : [path];
+  const paths = agent === "cursor" && cursorDatabase(path) ? [path, `${path}-wal`] : [path];
   const signatures = [];
   for (const file of paths) {
     try {
@@ -3293,60 +3568,109 @@ async function sourceSignature(path, agent) {
   }
   return JSON.stringify(signatures);
 }
+async function cursorScope(path, project) {
+  let container = dirname9(path);
+  while (basename3(container) !== "agent-transcripts" && dirname9(container) !== container)
+    container = dirname9(container);
+  if (basename3(container) !== "agent-transcripts")
+    throw new Error("Cursor transcript workspace cannot be verified.");
+  const encoded = basename3(dirname9(container));
+  const matches = [];
+  const visit = async (directory) => {
+    const prefix = cursorEncoded(directory);
+    if (encoded === prefix) {
+      matches.push(directory);
+      return;
+    }
+    if (!encoded.startsWith(prefix + "-")) return;
+    for (const entry of await readdir2(directory, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.isSymbolicLink()) await visit(join15(directory, entry.name));
+    }
+  };
+  await visit(project);
+  if (matches.length !== 1)
+    throw new Error("Session cwd is outside the registered project or ambiguous.");
+  return matches[0];
+}
 async function readSource(agent, path, projectDir) {
   const signature2 = await sourceSignature(path, agent);
-  let result2;
-  if (agent === "cursor") result2 = { snapshot: readCursor(path, projectDir), incomplete: false };
-  else {
-    const handle = await open5(path, "r");
-    let bytes;
-    try {
-      const size = (await handle.stat()).size;
-      if (size > MAX_SOURCE_BYTES) throw new Error("Session source exceeds 64 MiB.");
-      bytes = Buffer.alloc(size + 1);
-      let offset = 0;
-      while (offset < bytes.length) {
-        const read = await handle.read(bytes, offset, bytes.length - offset, offset);
-        if (!read.bytesRead) break;
-        offset += read.bytesRead;
-      }
-      bytes = bytes.subarray(0, offset);
-      if (offset > size) throw new Error("Session source changed while reading; retry next cycle.");
-    } finally {
-      await handle.close();
+  const project = await realpath5(projectDir);
+  if (agent === "cursor" && cursorDatabase(path)) {
+    const snapshot2 = readCursor(path, projectDir, (cwd) => {
+      if (!within(project, realpathSync(cwd)))
+        throw new Error("Session cwd is outside the registered project.");
+    });
+    return { snapshot: snapshot2, incomplete: false, skipped: 0, signature: signature2 };
+  }
+  const cursor = agent === "cursor" ? { nativeId: basename3(path, ".jsonl"), cwd: await cursorScope(path, projectDir) } : void 0;
+  const normalizer = new JsonlNormalizer(agent, cursor);
+  const stream = createReadStream(path, {
+    end: Math.max(0, Number(JSON.parse(signature2)[0][2]) - 1)
+  });
+  let input = stream;
+  if (agent === "dsh" && path.endsWith(".zstd")) {
+    const decompress = zlib.createZstdDecompress;
+    if (!decompress) {
+      stream.destroy();
+      throw new Error("Compressed DSH sessions require Node.js with zstd support (22.15+ or 24+).");
     }
-    if (agent === "dsh" && path.endsWith(".zstd")) {
-      const decompress = zlib.zstdDecompressSync;
-      if (!decompress)
-        throw new Error(
-          "Compressed DSH sessions require Node.js with zstd support (22.15+ or 24+)."
-        );
-      bytes = decompress(bytes, { maxOutputLength: MAX_SOURCE_BYTES });
+    const decoder = decompress();
+    stream.on("error", (e) => decoder.destroy(e));
+    input = stream.pipe(decoder);
+  }
+  const lines = createInterface3({ input, crlfDelay: Infinity });
+  const checkedCwds = /* @__PURE__ */ new Set();
+  let line = 0, skipped = 0, lastBad = false;
+  try {
+    for await (const text of lines) {
+      line++;
+      if (!text.trim()) continue;
+      const row = parseRecord(text);
+      lastBad = !row;
+      if (!row) {
+        skipped++;
+        continue;
+      }
+      const cwd = row.cwd ?? (row.type === "session_meta" ? object(row.payload).cwd : void 0);
+      if (typeof cwd === "string" && !checkedCwds.has(cwd)) {
+        const actual = await realpath5(cwd).catch((error) => {
+          if (error.code === "ENOENT" && !within(project, cwd))
+            throw new Error("Session cwd is outside the registered project.");
+          throw error;
+        });
+        if (!within(project, actual))
+          throw new Error("Session cwd is outside the registered project.");
+        checkedCwds.add(cwd);
+      }
+      normalizer.consume(row, line);
     }
-    result2 = normalizeJsonl(agent, new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } finally {
+    lines.close();
+    stream.destroy();
+    if (input !== stream) input.destroy();
   }
-  if (signature2 !== await sourceSignature(path, agent))
+  const before = JSON.parse(signature2)[0];
+  const after = JSON.parse(await sourceSignature(path, agent))[0];
+  if (before[0] !== after[0] || before[1] !== after[1] || Number(after[2]) < Number(before[2]) || before[2] === after[2] && before.join() !== after.join())
     throw new Error("Session source changed while reading; retry next cycle.");
-  const cwd = await realpath5(result2.snapshot.cwd);
-  const project = await realpath5(projectDir);
-  const rel = relative4(project, cwd);
-  if (rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute4(rel))
+  const snapshot = normalizer.finish();
+  if (!within(project, await realpath5(snapshot.cwd)))
     throw new Error("Session cwd is outside the registered project.");
-  return { ...result2, signature: signature2 };
+  return { snapshot, incomplete: lastBad, skipped, signature: signature2 };
 }
 
 // apps/client/sessions/discovery.ts
 import { opendir as opendir2 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 async function* candidates(directory, agent) {
   const queue = [directory];
   while (queue.length) {
     const current = queue.shift();
     const dir = await opendir2(current);
     for await (const entry of dir) {
-      const path = join14(current, entry.name);
+      const path = join16(current, entry.name);
       if (entry.isDirectory()) queue.push(path);
-      if (entry.isFile() && (agent === "cursor" ? entry.name === "store.db" : entry.name.endsWith(".jsonl") || agent === "dsh" && entry.name.endsWith(".jsonl.zstd")))
+      if (entry.isFile() && (agent === "cursor" ? entry.name === "store.db" || entry.name.endsWith(".jsonl") : entry.name.endsWith(".jsonl") || agent === "dsh" && entry.name.endsWith(".jsonl.zstd")))
         yield path;
       else yield null;
     }
@@ -3393,25 +3717,27 @@ var SessionDiscovery = class {
             "SELECT 1 FROM session_discovery_cache WHERE root=? AND path=? AND signature=?"
           ).get(this.state.root, path, signature2))
             continue;
-          reads--;
           try {
             const result2 = await readSource(config.agent, path, config.projectDir);
-            if (result2.incomplete) continue;
+            if (!result2.snapshot.messages.length) continue;
+            reads--;
             this.state.track(config.agent, path, config.projectDir);
           } catch (error) {
             const message2 = error instanceof Error ? error.message : "Discovery failed.";
             if (!message2.includes("outside the registered project"))
               issues.push(`${path}: ${message2}`);
-            if (!message2.includes("outside the registered project")) continue;
+            if (error.code === "ENOENT" || /locked|busy|changed while reading/i.test(message2))
+              continue;
           }
           db.prepare(
             "INSERT INTO session_discovery_cache VALUES (?,?,?) ON CONFLICT(root,path) DO UPDATE SET signature=excluded.signature"
           ).run(this.state.root, path, signature2);
         }
       } catch (error) {
-        issues.push(
-          `${config.directory}: ${error instanceof Error ? error.message : "Discovery failed."}`
-        );
+        if (error.code !== "ENOENT")
+          issues.push(
+            `${config.directory}: ${error instanceof Error ? error.message : "Discovery failed."}`
+          );
         await scan.iterator.return(void 0);
         scan.iterator = candidates(config.directory, config.agent);
         scan.nextAt = Date.now() + 3e5;
@@ -3419,6 +3745,9 @@ var SessionDiscovery = class {
     }
     return issues;
   }
+  async refresh() {
+    for (const scan of this.scans.values()) scan.nextAt = 0;
+  }
   async close() {
     for (const scan of this.scans.values()) await scan.iterator.return(void 0);
   }
@@ -3432,7 +3761,7 @@ var SessionSynchronizer = class {
     const binding = state.binding(root);
     if (!binding) throw new Error("Connect this root before collecting sessions.");
     this.client = new HubClient(binding.serverUrl, 1e4, binding, signal);
-    this.blobs = new LocalBlobStore(join15(directory, "blobs"));
+    this.blobs = new LocalBlobStore(join17(directory, "blobs"));
     this.index = new SessionState(state, root);
     this.discovery = new SessionDiscovery(this.index);
   }
@@ -3444,9 +3773,16 @@ var SessionSynchronizer = class {
   discovery;
   capable = false;
   async cycle() {
-    const report = { published: 0, checked: 0, issues: [] };
-    report.issues.push(...await consumeHints(this.directory, this.root, this.index));
-    report.issues.push(...await this.discovery.cycle());
+    const report = { published: 0, checked: 0, issues: [], warnings: [] };
+    report.issues.push(
+      ...await consumeHints(
+        this.directory,
+        this.root,
+        this.index,
+        () => this.discovery.refresh()
+      )
+    );
+    report.warnings.push(...await this.discovery.cycle());
     const sources = this.index.sources(void 0, 200);
     if (sources.length && !this.capable) {
       const info = await this.client.serverInfo();
@@ -3458,12 +3794,14 @@ var SessionSynchronizer = class {
     }
     let reads = 5;
     let uploads = 5;
-    for (const source of sources) {
+    for (const scheduled of sources) {
+      let source = this.index.get(scheduled.path);
       if (reads <= 0 || uploads <= 0 || report.checked >= 200) break;
       report.checked++;
       this.index.checked(source.path, source.lastError);
       try {
         if (source.pending) {
+          if (source.pendingPath !== source.path) continue;
           if (source.retryAt > Date.now()) {
             if (source.lastError)
               report.issues.push(`${source.path}: ${source.lastError} (retry deferred)`);
@@ -3481,12 +3819,24 @@ var SessionSynchronizer = class {
         }
         reads--;
         const observed = await readSource(source.agent, source.path, source.projectDir);
-        if (observed.incomplete)
-          throw new Error("Final session record is incomplete; waiting for the next save.");
         if (!observed.snapshot.messages.length) {
           this.index.checked(source.path);
           continue;
         }
+        if (observed.skipped)
+          report.warnings.push(
+            `${source.path}: skipped ${observed.skipped} unreadable record(s); retained complete dialogue.`
+          );
+        if (observed.skipped && source.hash) {
+          const previous = await this.blobs.get(source.hash);
+          if (previous && JSON.parse(Buffer.from(previous).toString("utf8")).messages.length > observed.snapshot.messages.length) {
+            this.index.observed(source.path, observed.signature);
+            report.warnings.push(
+              `${source.path}: kept the previous snapshot because the damaged copy contains fewer messages.`
+            );
+            continue;
+          }
+        }
         const key = sessionKey(source.agent, observed.snapshot.nativeId);
         if (source.key && source.key !== key)
           throw new Error(
@@ -3497,7 +3847,7 @@ var SessionSynchronizer = class {
           throw new Error("Normalized session exceeds the 10 MiB snapshot limit.");
         const blob = await this.blobs.put(bytes);
         let revision = source.revision;
-        if (!source.key) {
+        if (!source.key && !this.index.publication(key)) {
           try {
             const owner = this.index.state.binding(this.root).memberId;
             const current = await this.client.session(owner, key);
@@ -3510,7 +3860,14 @@ var SessionSynchronizer = class {
             if (!(error instanceof HubRequestError && error.code === "SESSION_NOT_FOUND"))
               throw error;
           }
-          this.index.baseline(source.path, key, revision);
+        }
+        this.index.baseline(source.path, key, revision);
+        source = this.index.get(source.path);
+        revision = source.revision;
+        if (source.pending) continue;
+        if (source.agent === "cursor" && source.selectedPath && cursorDatabase(source.selectedPath) && !cursorDatabase(source.path)) {
+          this.index.observed(source.path, observed.signature);
+          continue;
         }
         if (blob.sha256 === source.hash) {
           this.index.acknowledge(source.path, revision, blob.sha256, observed.signature);
@@ -3670,7 +4027,7 @@ var SyncJob = class {
       pendingPublication: false,
       issues: []
     };
-    let sessions = { published: 0, checked: 0, issues: [] };
+    let sessions = { published: 0, checked: 0, issues: [], warnings: [] };
     try {
       await verifyWorkspace(this.state, this.root);
       if (!this.controlStarted) {
@@ -3680,6 +4037,8 @@ var SyncJob = class {
       }
       if (this.files) report = await this.files.cycle();
       sessions = await this.sessions.cycle();
+      for (const warning of sessions.warnings)
+        this.log.write("sessions.partial", this.root, warning);
     } catch (e) {
       report.issues.push(diagnostic(e));
     }
@@ -3730,7 +4089,7 @@ var SyncJob = class {
         );
     }
     this.lastIssue = issueKey;
-    this.nextAt = now + (issue ? Math.min(9e5, Math.max(this.intervalMs, 1e4) * 2 ** Math.min(this.issueCount - 1, 5)) : pendingDownloads ? 250 : this.intervalMs);
+    this.nextAt = now + (report.issues.length || this.control.enabled && (this.control.status.configError || this.control.status.reportError) ? Math.min(9e5, Math.max(this.intervalMs, 1e4) * 2 ** Math.min(this.issueCount - 1, 5)) : pendingDownloads ? 250 : this.intervalMs);
     this.runtime.save(this.root, {
       state: this.stopped ? "stopped" : issue ? "waiting" : "idle",
       checkedAt,
@@ -3996,8 +4355,8 @@ async function runDaemon(directory, version) {
   let timer;
   let resolveStop = () => {
   };
-  const stopped = new Promise((resolve9) => {
-    resolveStop = resolve9;
+  const stopped = new Promise((resolve10) => {
+    resolveStop = resolve10;
   });
   const stop = () => {
     closing = true;
@@ -4008,11 +4367,11 @@ async function runDaemon(directory, version) {
     await unlink4(socketPath(directory)).catch((e) => {
       if (e.code !== "ENOENT") throw e;
     });
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       server.once("error", reject);
       server.listen(socketPath(directory), () => {
         server.off("error", reject);
-        resolve9();
+        resolve10();
       });
     });
     await chmod2(socketPath(directory), 384);
@@ -4035,7 +4394,7 @@ async function runDaemon(directory, version) {
     await Promise.all([...jobs.values(), ...temporaryJobs].map((job) => job.close()));
     await Promise.allSettled(oneShots.values());
     for (const socket of sockets) socket.destroy();
-    await new Promise((resolve9) => server.close(() => resolve9()));
+    await new Promise((resolve10) => server.close(() => resolve10()));
     await unlink4(socketPath(directory)).catch(() => {
     });
     log.write("daemon.stopped");
@@ -4094,7 +4453,7 @@ async function runCli(args, version) {
       options: { "state-dir": { type: "string" } }
     });
     if (!values["state-dir"]) throw new Error("Missing daemon state directory.");
-    const directory = resolve8(values["state-dir"]);
+    const directory = resolve9(values["state-dir"]);
     try {
       await runDaemon(directory, version);
       return 0;