@teammy/cli 0.0.9 → 0.1.0

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 { parseArgs as parseArgs6 } from "node:util";
+import { resolve as resolve15 } from "node:path";
 
 // packages/protocol/project.ts
 import { z as z3 } from "zod";
@@ -19,7 +19,9 @@ var MembersSchema = z.object({ members: z.array(NameSchema) });
 
 // packages/protocol/files.ts
 import { z as z2 } from "zod";
-var MAX_BLOB_BYTES = 10 * 1024 * 1024;
+var MAX_BLOB_BYTES = 128 * 1024 * 1024;
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+var BLOB_TRANSFER_TIMEOUT_MS = 3e5;
 var MAX_BATCH_FILES = 200;
 var HashSchema = z2.string().regex(/^[a-f0-9]{64}$/);
 var RevisionSchema = z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
@@ -33,25 +35,29 @@ var BlobRefSchema = z2.object({
   sha256: HashSchema,
   size: z2.number().int().min(0).max(MAX_BLOB_BYTES)
 });
+var FileBlobRefSchema = BlobRefSchema.extend({
+  size: z2.number().int().min(0).max(MAX_FILE_BYTES)
+});
 var FileChangeSchema = z2.discriminatedUnion("kind", [
-  BlobRefSchema.extend({ kind: z2.literal("upsert"), path: FilePathSchema }).strict(),
+  FileBlobRefSchema.extend({ kind: z2.literal("upsert"), path: FilePathSchema }).strict(),
   z2.object({ kind: z2.literal("delete"), path: FilePathSchema }).strict()
 ]);
 var FileCommitSchema = z2.object({
   operationId: z2.uuid(),
   parentRevision: RevisionSchema,
-  changes: z2.array(FileChangeSchema).min(1).max(MAX_BATCH_FILES)
+  changes: z2.array(FileChangeSchema)
 }).strict().refine(
   (batch) => new Set(batch.changes.map((change) => change.path)).size === batch.changes.length,
-  "Duplicate paths in a batch."
+  "Duplicate paths in a publication."
 );
 var CommitResultSchema = z2.object({ operationId: z2.uuid(), revision: RevisionSchema });
-var FileEntrySchema = BlobRefSchema.extend({
+var FileEntrySchema = FileBlobRefSchema.extend({
   path: FilePathSchema,
   revision: RevisionSchema
 });
 var ManifestSchema = z2.object({
   revision: RevisionSchema,
+  complete: z2.boolean().default(false),
   files: z2.array(FileEntrySchema),
   nextCursor: z2.string().nullable()
 });
@@ -105,12 +111,8 @@ var ProjectConfigSchema = z3.object({
 }).strict();
 var SetupSchema = z3.object({
   operationId: z3.uuid(),
-  projectName: z3.string().trim().min(1).max(120),
-  description: z3.string().max(2e3).default(""),
   publicServerUrl: ServerUrlSchema,
-  adminId: NameSchema,
-  members: z3.array(NameSchema).max(100).default([]),
-  sync: SyncPolicySchema.default(DEFAULT_POLICY)
+  adminId: NameSchema
 }).strict();
 var SetupStatusSchema = z3.object({
   initialized: z3.boolean()
@@ -189,113 +191,136 @@ var UserUpdateSchema = z3.object({
 }).strict();
 
 // packages/protocol/sessions.ts
+import { z as z5 } from "zod";
+
+// packages/protocol/session-analysis.ts
 import { z as z4 } from "zod";
-var AgentSchema = z4.enum(["claude-code", "codex", "cursor", "pi", "dsh"]);
-var SessionSnapshotSchema = z4.object({
-  formatVersion: z4.literal(1),
-  adapterVersion: z4.literal(1),
+var SessionAnalysisKindSchema = z4.enum(["overview", "handoff"]);
+var SessionOverviewOutputSchema = z4.object({ title: z4.string().trim().min(1), summary: z4.string().trim().min(1) }).strict();
+var SessionHandoffOutputSchema = z4.object({ markdown: z4.string().trim().min(1) }).strict();
+var SessionOverviewSchema = SessionOverviewOutputSchema.extend({
+  sourceRevision: RevisionSchema,
+  sourceHash: HashSchema,
+  generatedAt: z4.string(),
+  stale: z4.boolean()
+});
+var SessionAnalysisStateSchema = z4.object({
+  kind: SessionAnalysisKindSchema,
+  status: z4.enum(["absent", "queued", "running", "succeeded", "failed"]),
+  available: z4.boolean(),
+  currentRevision: RevisionSchema,
+  sourceRevision: RevisionSchema.nullable(),
+  stale: z4.boolean(),
+  result: z4.union([SessionOverviewOutputSchema, SessionHandoffOutputSchema]).nullable(),
+  generatedAt: z4.string().nullable(),
+  error: z4.string().nullable()
+});
+
+// packages/protocol/sessions.ts
+var AgentSchema = z5.enum(["claude-code", "codex", "cursor", "pi", "dsh"]);
+var SessionSnapshotSchema = z5.object({
+  formatVersion: z5.literal(1),
+  adapterVersion: z5.literal(1),
   agent: AgentSchema,
-  nativeId: z4.string().min(1).max(512),
-  cwd: z4.string().min(1).max(4096),
-  messages: z4.array(
-    z4.object({
-      id: z4.string().min(1).max(1024),
-      role: z4.enum(["user", "assistant"]),
-      text: z4.string().min(1).max(2 * 1024 * 1024),
-      source: z4.string().min(1).max(1024)
+  nativeId: z5.string().min(1).max(512),
+  cwd: z5.string().min(1).max(4096),
+  messages: z5.array(
+    z5.object({
+      id: z5.string().min(1).max(1024),
+      role: z5.enum(["user", "assistant"]),
+      text: z5.string().min(1),
+      source: z5.string().min(1).max(1024)
     }).strict()
-  ).max(5e4)
+  )
 }).strict().refine(
   (s) => new Set(s.messages.map((m) => m.id)).size === s.messages.length,
   "Duplicate message IDs."
 );
-var SessionCommitSchema = z4.object({
-  operationId: z4.uuid(),
+var SessionCommitSchema = z5.object({
+  operationId: z5.uuid(),
   sessionKey: HashSchema,
   parentRevision: RevisionSchema,
   blob: BlobRefSchema
 }).strict();
-var SessionInfoSchema = z4.object({
+var SessionInfoSchema = z5.object({
   owner: NameSchema,
   sessionKey: HashSchema,
   agent: AgentSchema,
-  nativeId: z4.string(),
-  cwd: z4.string(),
-  title: z4.string(),
+  nativeId: z5.string(),
+  cwd: z5.string(),
+  title: z5.string(),
   revision: RevisionSchema,
-  updatedAt: z4.string(),
-  messageCount: z4.number().int().nonnegative(),
-  blob: BlobRefSchema
+  updatedAt: z5.string(),
+  messageCount: z5.number().int().nonnegative(),
+  blob: BlobRefSchema,
+  overview: SessionOverviewSchema.optional()
 });
-var SessionListSchema = z4.object({
-  sessions: z4.array(SessionInfoSchema),
+var SessionListSchema = z5.object({
+  sessions: z5.array(SessionInfoSchema),
   nextCursor: RevisionSchema.nullable()
 });
-var SessionStatsSchema = z4.object({
-  totalSessions: z4.number().int().nonnegative(),
-  totalMessages: z4.number().int().nonnegative(),
-  memberCount: z4.number().int().nonnegative(),
-  updatedAt: z4.string().nullable()
+var SessionStatsSchema = z5.object({
+  totalSessions: z5.number().int().nonnegative(),
+  totalMessages: z5.number().int().nonnegative(),
+  memberCount: z5.number().int().nonnegative(),
+  updatedAt: z5.string().nullable()
 });
-var SessionScopeSchema = z4.object({
+var SessionScopeSchema = z5.object({
   owner: NameSchema.optional(),
   sessionKey: HashSchema.optional()
 }).strict().refine((v) => !v.sessionKey || !!v.owner, "A session scope requires an owner.");
-var SessionSearchSchema = z4.object({
-  matches: z4.array(
-    z4.object({
+var SessionSearchSchema = z5.object({
+  matches: z5.array(
+    z5.object({
       owner: NameSchema,
       sessionKey: HashSchema,
       revision: RevisionSchema,
-      messageId: z4.string(),
-      role: z4.enum(["user", "assistant"]),
-      snippet: z4.string(),
-      title: z4.string()
+      messageId: z5.string(),
+      role: z5.enum(["user", "assistant"]),
+      snippet: z5.string(),
+      title: z5.string()
     })
   ),
   nextCursor: RevisionSchema.nullable()
 });
 
 // packages/transport/hub-client.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import { createHash } from "node:crypto";
 
 // packages/protocol/index.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var PROTOCOL_VERSION = 1;
-var HealthSchema = z5.object({ status: z5.literal("ok") });
-var ServerInfoSchema = z5.object({
-  name: z5.literal("teammy"),
-  version: z5.string().min(1),
-  protocolVersion: z5.literal(PROTOCOL_VERSION),
-  capabilities: z5.array(z5.string())
+var HealthSchema = z6.object({ status: z6.literal("ok") });
+var ServerInfoSchema = z6.object({
+  name: z6.literal("teammy"),
+  version: z6.string().min(1),
+  protocolVersion: z6.literal(PROTOCOL_VERSION),
+  capabilities: z6.array(z6.string())
 });
-var ErrorResponseSchema = z5.object({
-  error: z5.object({
-    code: z5.string(),
-    message: z5.string(),
-    requestId: z5.string()
+var ErrorResponseSchema = z6.object({
+  error: z6.object({
+    code: z6.string(),
+    message: z6.string(),
+    requestId: z6.string()
   })
 });
 
 // packages/protocol/shared-files.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var PROJECT_FILE_OWNER = "_project";
-var FileOwnerSchema = z6.union([NameSchema, z6.literal(PROJECT_FILE_OWNER)]);
-var SharedPathSchema = z6.string().max(255).refine((path) => {
+var FileOwnerSchema = z7.union([NameSchema, z7.literal(PROJECT_FILE_OWNER)]);
+var SharedPathSchema = z7.string().max(255).refine((path) => {
   const directory = path.endsWith("/");
   const name2 = directory ? path.slice(0, -1) : path;
   return FilePathSchema.safeParse(name2).success && !name2.includes("/") && !name2.startsWith(".") && !/^_?teammy/i.test(name2) && (directory ? name2.startsWith("_") : name2.includes("."));
 }, "Use a root file (README.md) or an underscore-prefixed directory (_template/).");
-var SharedFilesConfigSchema = z6.object({
+var SharedFilesConfigSchema = z7.object({
   maintainer: NameSchema.nullable(),
-  paths: z6.array(SharedPathSchema).max(30).refine((paths) => new Set(paths.map((p) => p.toLowerCase())).size === paths.length),
+  paths: z7.array(SharedPathSchema).max(30).refine((paths) => new Set(paths.map((p) => p.toLowerCase())).size === paths.length),
   revision: RevisionSchema
 }).strict();
 var SharedFilesUpdateSchema = SharedFilesConfigSchema.omit({ revision: true }).extend({ expectedRevision: RevisionSchema }).strict();
-var SharedFileCommitSchema = FileCommitSchema.safeExtend({
-  configRevision: RevisionSchema
-});
 function privateWorkspacePath(path) {
   return path.split("/").some((part) => /^\.teammy(?:[-.]|$)/i.test(part));
 }
@@ -359,15 +384,23 @@ var HubClient = class {
   }
   uploadBlob(hash2, content) {
     if (content.byteLength > MAX_BLOB_BYTES)
-      throw new Error("Content exceeds the file size limit.");
-    return this.request("PUT", `api/v1/blobs/${HashSchema.parse(hash2)}`, BlobRefSchema, content);
+      throw new Error("Content exceeds the binary object size limit.");
+    return this.request(
+      "PUT",
+      `api/v1/blobs/${HashSchema.parse(hash2)}`,
+      BlobRefSchema,
+      content,
+      BLOB_TRANSFER_TIMEOUT_MS
+    );
   }
   async downloadBlob(hash2) {
     const { response, signal } = await this.fetchResponse(
       "GET",
-      `api/v1/blobs/${HashSchema.parse(hash2)}`
+      `api/v1/blobs/${HashSchema.parse(hash2)}`,
+      void 0,
+      BLOB_TRANSFER_TIMEOUT_MS
     );
-    if (!response.ok) return this.decode(response, signal, z7.never());
+    if (!response.ok) return this.decode(response, signal, z8.never());
     const reader = response.body?.getReader();
     if (!reader) throw new Error("Server returned no content body.");
     const parts = [];
@@ -390,7 +423,7 @@ var HubClient = class {
     return bytes;
   }
   commitFiles(batch) {
-    return this.request("POST", "api/v1/files/commits", CommitResultSchema, batch);
+    return this.publishFiles(batch);
   }
   fileManifest(owner, revision, after = "", limit = 200) {
     const query = new URLSearchParams({ after, limit: String(limit) });
@@ -412,7 +445,7 @@ var HubClient = class {
     return this.request(
       "PUT",
       "api/v1/devices/self/status",
-      z7.object({ ok: z7.literal(true) }),
+      z8.object({ ok: z8.literal(true) }),
       status
     );
   }
@@ -426,17 +459,27 @@ var HubClient = class {
     return this.request("GET", "api/v1/project/shared-files", SharedFilesConfigSchema);
   }
   commitSharedFiles(batch, configRevision) {
-    return this.request("POST", "api/v1/files/_project/commits", CommitResultSchema, {
-      ...batch,
-      configRevision
-    });
+    return this.publishFiles({ ...batch, configRevision });
+  }
+  async publishFiles(publication) {
+    const bytes = Buffer.from(JSON.stringify(publication));
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    if ((await this.missingBlobs([sha256])).missing.length) await this.uploadBlob(sha256, bytes);
+    return this.request(
+      "POST",
+      "api/v1/files/publications",
+      CommitResultSchema,
+      { manifest: { sha256, size: bytes.byteLength } },
+      BLOB_TRANSFER_TIMEOUT_MS
+    );
   }
   commitSession(commit) {
     return this.request(
       "POST",
       "api/v1/sessions/commits",
       CommitResultSchema,
-      SessionCommitSchema.parse(commit)
+      SessionCommitSchema.parse(commit),
+      BLOB_TRANSFER_TIMEOUT_MS
     );
   }
   sessions(after = 0, limit = 50) {
@@ -460,14 +503,14 @@ var HubClient = class {
       SessionSearchSchema
     );
   }
-  async request(method, path, schema, requestBody) {
-    const { response, signal } = await this.fetchResponse(method, path, requestBody);
+  async request(method, path, schema, requestBody, timeoutMs = this.timeoutMs) {
+    const { response, signal } = await this.fetchResponse(method, path, requestBody, timeoutMs);
     return this.decode(response, signal, schema);
   }
-  async fetchResponse(method, path, requestBody) {
+  async fetchResponse(method, path, requestBody, timeoutMs = this.timeoutMs) {
     if (this.credentials?.workspaceId && path.startsWith("api/v1/") && !["api/v1/bind", "api/v1/server"].includes(path))
       path = `api/v1/projects/${encodeURIComponent(this.credentials.workspaceId)}/${path.slice("api/v1/".length)}`;
-    const timeout = AbortSignal.timeout(this.timeoutMs);
+    const timeout = AbortSignal.timeout(timeoutMs);
     const signal = this.abortSignal ? AbortSignal.any([timeout, this.abortSignal]) : timeout;
     const binary = requestBody instanceof Uint8Array;
     const response = await fetch(new URL(path, this.baseUrl), {
@@ -480,7 +523,9 @@ var HubClient = class {
           "x-teammy-device": this.credentials.deviceId
         } : {}
       },
-      ...requestBody === void 0 ? {} : { body: binary ? Uint8Array.from(requestBody).buffer : JSON.stringify(requestBody) },
+      ...requestBody === void 0 ? {} : {
+        body: binary ? requestBody : JSON.stringify(requestBody)
+      },
       signal,
       redirect: "error"
     });
@@ -518,11 +563,18 @@ var HubClient = class {
 };
 
 // apps/client/sessions/command.ts
-import { createHash as createHash6 } 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 { parseArgs } from "node:util";
+import { createHash as createHash8 } from "node:crypto";
+import { realpath as realpath6 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname9, join as join16, resolve as resolve8 } from "node:path";
+import { parseArgs as parseArgs2 } from "node:util";
+
+// packages/protocol/file-publication.ts
+import { z as z9 } from "zod";
+var FilePublicationSchema = FileCommitSchema.safeExtend({
+  configRevision: RevisionSchema.optional()
+}).strict();
+var PublishFilesSchema = z9.object({ manifest: BlobRefSchema }).strict();
 
 // packages/state/sqlite.ts
 import { chmodSync, mkdirSync } from "node:fs";
@@ -583,8 +635,14 @@ var FilePublicationState = class {
   }
   publication(root) {
     this.db.prepare(`INSERT OR IGNORE INTO ${this.tables.publications}(root) VALUES (?)`).run(root);
-    const row = this.db.prepare(`SELECT revision, initialized FROM ${this.tables.publications} WHERE root=?`).get(root);
-    return { revision: Number(row.revision), initialized: Boolean(row.initialized) };
+    const row = this.db.prepare(
+      `SELECT revision, initialized, complete FROM ${this.tables.publications} WHERE root=?`
+    ).get(root);
+    return {
+      revision: Number(row.revision),
+      initialized: Boolean(row.initialized),
+      complete: Boolean(row.complete)
+    };
   }
   initializePublication(root, revision, files, options = {}) {
     transaction(this.db, () => {
@@ -592,8 +650,8 @@ var FilePublicationState = class {
       if (this.pending(root))
         throw new Error("Cannot replace a baseline with a publication pending.");
       this.db.prepare(
-        `INSERT INTO ${this.tables.publications} VALUES (?, ?, 1) ON CONFLICT(root) DO UPDATE SET revision=excluded.revision, initialized=1`
-      ).run(root, revision);
+        `INSERT INTO ${this.tables.publications}(root,revision,initialized,complete) VALUES (?, ?, 1, ?) ON CONFLICT(root) DO UPDATE SET revision=excluded.revision, initialized=1,complete=excluded.complete`
+      ).run(root, revision, Number(options.complete ?? false));
       this.db.prepare(`DELETE FROM ${this.tables.owner_files} WHERE root=?`).run(root);
       for (const file of files)
         this.db.prepare(`INSERT INTO ${this.tables.owner_files} VALUES (?, ?, ?, ?)`).run(root, file.path, file.sha256, file.size);
@@ -606,17 +664,18 @@ var FilePublicationState = class {
   }
   pending(root) {
     const row = this.db.prepare(
-      `SELECT request_json, attempts, retry_at, last_error FROM ${this.tables.outbox} WHERE root=?`
+      `SELECT request_json, attempts, retry_at, last_error, next_index FROM ${this.tables.outbox} WHERE root=?`
     ).get(root);
     return row ? {
-      batch: FileCommitSchema.parse(JSON.parse(String(row.request_json))),
+      batch: FilePublicationSchema.parse(JSON.parse(String(row.request_json))),
+      nextIndex: Number(row.next_index),
       attempts: Number(row.attempts),
       retryAt: Number(row.retry_at),
       lastError: row.last_error === null ? null : String(row.last_error)
     } : void 0;
   }
   enqueue(root, batch) {
-    const fixed = FileCommitSchema.parse(batch);
+    const fixed = FilePublicationSchema.parse(batch);
     transaction(this.db, () => {
       const publication = this.publication(root);
       if (!publication.initialized || publication.revision !== fixed.parentRevision)
@@ -625,6 +684,11 @@ var FilePublicationState = class {
       this.db.prepare(`INSERT INTO ${this.tables.outbox}(root, request_json) VALUES (?, ?)`).run(root, JSON.stringify(fixed));
     });
   }
+  uploaded(root, operationId, nextIndex) {
+    this.db.prepare(
+      `UPDATE ${this.tables.outbox} SET next_index=? WHERE root=? AND json_extract(request_json,'$.operationId')=?`
+    ).run(nextIndex, root, operationId);
+  }
   acknowledge(root, result2) {
     transaction(this.db, () => {
       const pending = this.pending(root);
@@ -638,7 +702,7 @@ var FilePublicationState = class {
             `INSERT INTO ${this.tables.owner_files} VALUES (?, ?, ?, ?) ON CONFLICT(root, path) DO UPDATE SET hash=excluded.hash, size=excluded.size`
           ).run(root, change.path, change.sha256, change.size);
       }
-      this.db.prepare(`UPDATE ${this.tables.publications} SET revision=? WHERE root=?`).run(result2.revision, root);
+      this.db.prepare(`UPDATE ${this.tables.publications} SET revision=?,complete=1 WHERE root=?`).run(result2.revision, root);
       this.db.prepare(`DELETE FROM ${this.tables.outbox} WHERE root=?`).run(root);
     });
   }
@@ -655,6 +719,19 @@ var FilePublicationState = class {
   }
 };
 
+// apps/client/files/atomic-schema.ts
+var atomicFilesClientMigration = ["", "project_"].map(
+  (prefix) => `
+  ALTER TABLE ${prefix}publications ADD COLUMN complete INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE ${prefix}outbox ADD COLUMN next_index INTEGER NOT NULL DEFAULT 0;
+  -- Old outboxes contain a partial batch, not a complete publication. Reconcile
+  -- against the server (including a possibly lost acknowledgement) before rebuilding.
+  DELETE FROM ${prefix}outbox;
+  UPDATE ${prefix}publications SET initialized=0;
+  UPDATE ${prefix}file_index SET dirty=1,event_pending=1,generation=generation+1;
+`
+).join("\n");
+
 // apps/client/files/state.ts
 var syncMigration = String.raw`
   CREATE TABLE file_index (
@@ -872,21 +949,116 @@ var RuntimeState = class {
 };
 
 // apps/client/state.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { join as join4, relative as relative2, isAbsolute, sep as sep2 } from "node:path";
-import { z as z9 } from "zod";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { join as join6, relative as relative2, isAbsolute, sep as sep2 } from "node:path";
+import { z as z11 } from "zod";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+
+// apps/client/runtime/state-access.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// apps/client/runtime/metadata.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+import { randomUUID } from "node:crypto";
+function writePrivateJson(path, value) {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  const temp = path + `.${randomUUID()}.tmp`;
+  writeFileSync(temp, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+  renameSync(temp, path);
+}
+function maintenancePath(directory) {
+  return join(directory, "runtime", "maintenance.json");
+}
+function readMaintenance(directory) {
+  const path = maintenancePath(directory);
+  if (!existsSync(path)) return null;
+  const value = JSON.parse(readFileSync(path, "utf8"));
+  if (value.format !== 1 || !["repair", "upgrade", "paused", "uninstalled"].includes(value.reason))
+    throw new Error("Unsupported maintenance record. Inspect teammy logs --all.");
+  return value;
+}
+function writeMaintenance(directory, record) {
+  writePrivateJson(maintenancePath(directory), {
+    ...record,
+    format: 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// apps/client/runtime/state-access.ts
+function stateAccess(directory, exclusive = false) {
+  const path = join2(directory, "runtime", "access.sqlite3");
+  mkdirSync3(join2(directory, "runtime"), { recursive: true, mode: 448 });
+  const db = new DatabaseSync2(path);
+  try {
+    chmodSync2(path, 384);
+    db.exec("PRAGMA busy_timeout=0");
+    if (!db.prepare("SELECT 1 FROM sqlite_master WHERE name='access'").get()) {
+      db.exec(
+        "PRAGMA journal_mode=DELETE; CREATE TABLE IF NOT EXISTS access(id INTEGER PRIMARY KEY); INSERT OR IGNORE INTO access VALUES(1)"
+      );
+    }
+    db.exec(exclusive ? "BEGIN EXCLUSIVE" : "BEGIN");
+    db.prepare("SELECT id FROM access").get();
+    if (!exclusive) {
+      const record = readMaintenance(directory);
+      if (record && ["repair", "upgrade"].includes(record.reason))
+        throw new Error("Client maintenance is pending. Run teammy repair.");
+    }
+    return db;
+  } catch (error) {
+    db.close();
+    if (error instanceof Error && /locked|busy/.test(error.message))
+      throw new Error(
+        "Client state is in use. Finish the local foreground command, then run teammy repair."
+      );
+    throw error;
+  }
+}
+function legacyStateLocks(directory) {
+  const locks = [];
+  try {
+    const path = join2(directory, "locks");
+    if (existsSync2(path))
+      for (const file of readdirSync(path)) {
+        if (!/^[a-f0-9]{64}\.sqlite3$/.test(file)) continue;
+        const db = new DatabaseSync2(join2(path, file));
+        locks.push(db);
+        db.exec("PRAGMA busy_timeout=0; BEGIN IMMEDIATE");
+      }
+    return { close: () => locks.forEach((db) => db.close()) };
+  } catch {
+    locks.forEach((db) => db.close());
+    throw new Error(
+      "An older sync process is still using this client. Stop its foreground command before repair."
+    );
+  }
+}
+function stateVersion(directory) {
+  const path = join2(directory, "client.sqlite3");
+  if (!existsSync2(path)) return 0;
+  const db = new DatabaseSync2(path, { readOnly: true });
+  try {
+    return Number(db.prepare("PRAGMA user_version").get().user_version);
+  } finally {
+    db.close();
+  }
+}
 
 // apps/client/workspace.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { lstat as lstat2, mkdir as mkdir2, realpath as realpath2, rmdir as rmdir2 } from "node:fs/promises";
-import { basename, dirname as dirname3, join as join2, resolve } from "node:path";
+import { basename, dirname as dirname4, join as join4, resolve } from "node:path";
 
 // apps/client/files/local-fs.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readdir, realpath, rename, rmdir, unlink } from "node:fs/promises";
-import { dirname as dirname2, join, relative, sep } from "node:path";
+import { dirname as dirname3, join as join3, relative, sep } from "node:path";
 import { setImmediate } from "node:timers/promises";
 function missing(error) {
   return error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR"].includes(String(error.code));
@@ -907,7 +1079,7 @@ async function safePath(root, path, createParents = false) {
   const parts = path.split("/");
   let parent = root;
   for (const part of parts.slice(0, -1)) {
-    parent = join(parent, part);
+    parent = join3(parent, part);
     if (createParents)
       await mkdir(parent).catch((error) => {
         if (error.code !== "EEXIST") throw error;
@@ -917,7 +1089,7 @@ async function safePath(root, path, createParents = false) {
     if (!stat2.isDirectory())
       throw Object.assign(new Error(`Parent is not a directory: ${path}`), { code: "ENOTDIR" });
   }
-  return join(root, ...parts);
+  return join3(root, ...parts);
 }
 async function metadata(root, path) {
   try {
@@ -980,9 +1152,9 @@ async function readStable(root, path) {
   const file = await open(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
   try {
     const before = await file.stat({ bigint: true });
-    if (!before.isFile() || before.size > BigInt(MAX_BLOB_BYTES))
+    if (!before.isFile() || before.size > BigInt(MAX_FILE_BYTES))
       throw new Error(
-        `Only regular files up to ${MAX_BLOB_BYTES} bytes can be synchronized: ${path}`
+        `Only regular files up to ${MAX_FILE_BYTES} bytes can be synchronized: ${path}`
       );
     const buffer = Buffer.alloc(Number(before.size) + 1);
     let count = 0;
@@ -1016,7 +1188,7 @@ async function syncDirectory(directory) {
 }
 async function replaceFile(root, path, bytes, expected) {
   const target = await safePath(root, path, true);
-  const temporary = join(dirname2(target), `.teammy-${randomUUID()}.tmp`);
+  const temporary = join3(dirname3(target), `.teammy-${randomUUID2()}.tmp`);
   const file = await open(temporary, "wx", 384);
   try {
     try {
@@ -1033,11 +1205,11 @@ async function replaceFile(root, path, bytes, expected) {
       throw new Error(`Local file changed before replacement: ${path}`);
     await safePath(root, path);
     await rename(temporary, target);
-    let directory = dirname2(target);
+    let directory = dirname3(target);
     for (; ; ) {
       await syncDirectory(directory);
-      if (directory === dirname2(root)) break;
-      directory = dirname2(directory);
+      if (directory === dirname3(root)) break;
+      directory = dirname3(directory);
     }
   } finally {
     await unlink(temporary).catch((error) => {
@@ -1052,16 +1224,16 @@ async function removeFile(root, path, expected) {
     throw new Error(`Local file changed before deletion: ${path}`);
   const target = await safePath(root, path);
   await unlink(target);
-  await syncDirectory(dirname2(target));
-  let parent = dirname2(target);
+  await syncDirectory(dirname3(target));
+  let parent = dirname3(target);
   while (parent !== root) {
     try {
       await rmdir(parent);
-      await syncDirectory(dirname2(parent));
+      await syncDirectory(dirname3(parent));
     } catch {
       break;
     }
-    parent = dirname2(parent);
+    parent = dirname3(parent);
   }
 }
 
@@ -1069,7 +1241,7 @@ async function removeFile(root, path, expected) {
 var exec = promisify(execFile);
 async function workspacePath(input) {
   const path = resolve(input);
-  return join2(await realpath2(dirname3(path)), basename(path));
+  return join4(await realpath2(dirname4(path)), basename(path));
 }
 async function directoryIdentity(root) {
   const stat2 = await lstat2(root, { bigint: true });
@@ -1086,18 +1258,18 @@ async function verifyWorkspace(state, root) {
     );
 }
 async function ignorePlan(root) {
-  const parent = dirname3(root), name2 = basename(root);
+  const parent = dirname4(root), name2 = basename(root);
   if (/[\r\n]/.test(name2)) throw new Error("Workspace name cannot contain a newline.");
   let repo = false;
-  for (let p = parent; ; p = dirname3(p)) {
+  for (let p = parent; ; p = dirname4(p)) {
     try {
-      await lstat2(join2(p, ".git"));
+      await lstat2(join4(p, ".git"));
       repo = true;
       break;
     } catch (e) {
       if (!missing(e)) throw e;
     }
-    if (p === dirname3(p)) break;
+    if (p === dirname4(p)) break;
   }
   if (repo) {
     let tracked;
@@ -1179,8 +1351,8 @@ function completePreparation(state, root) {
 }
 
 // apps/client/runtime/log.ts
-import { appendFileSync, mkdirSync as mkdirSync2, renameSync, statSync, unlinkSync, readFileSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync4, renameSync as renameSync2, statSync, unlinkSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join5 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 function rootKey(root) {
   return createHash3("sha256").update(root).digest("hex").slice(0, 16);
@@ -1196,9 +1368,9 @@ function diagnostic(error) {
 var ClientLog = class {
   constructor(directory, limit = 1024 * 1024) {
     this.limit = limit;
-    const logs = join3(directory, "logs");
-    mkdirSync2(logs, { recursive: true, mode: 448 });
-    this.path = join3(logs, "client.jsonl");
+    const logs = join5(directory, "logs");
+    mkdirSync4(logs, { recursive: true, mode: 448 });
+    this.path = join5(logs, "client.jsonl");
   }
   limit;
   path;
@@ -1215,10 +1387,10 @@ var ClientLog = class {
         } catch {
         }
         try {
-          renameSync(this.path + ".1", this.path + ".2");
+          renameSync2(this.path + ".1", this.path + ".2");
         } catch {
         }
-        renameSync(this.path, this.path + ".1");
+        renameSync2(this.path, this.path + ".1");
       }
       appendFileSync(
         this.path,
@@ -1237,7 +1409,7 @@ var ClientLog = class {
     const lines = [];
     for (const suffix of [".2", ".1", ""])
       try {
-        for (const line of readFileSync(this.path + suffix, "utf8").split("\n")) {
+        for (const line of readFileSync2(this.path + suffix, "utf8").split("\n")) {
           if (!line) continue;
           try {
             const item = JSON.parse(line);
@@ -1255,50 +1427,50 @@ var ClientLog = class {
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 
 // packages/protocol/devices.ts
-import { z as z8 } from "zod";
-var CredentialSchema = z8.string().regex(/^tmy_[a-f0-9]{64}$/);
-var EnrollmentSchema = z8.object({
-  operationId: z8.uuid(),
+import { z as z10 } from "zod";
+var CredentialSchema = z10.string().regex(/^tmy_[a-f0-9]{64}$/);
+var EnrollmentSchema = z10.object({
+  operationId: z10.uuid(),
   projectId: NameSchema,
   memberId: NameSchema,
   deviceId: DeviceIdSchema,
   credential: CredentialSchema
 }).strict();
-var EffectivePolicySchema = z8.object({
-  checkIntervalSeconds: z8.number().min(1).max(86400),
-  fileSettleSeconds: z8.number().min(0).max(86400)
+var EffectivePolicySchema = z10.object({
+  checkIntervalSeconds: z10.number().min(1).max(86400),
+  fileSettleSeconds: z10.number().min(0).max(86400)
 }).strict();
-var SyncSummarySchema = z8.object({
-  checkedAt: z8.string(),
-  published: z8.boolean(),
-  appliedFiles: z8.number().int().nonnegative(),
-  pendingFiles: z8.number().int().nonnegative(),
-  sessionSources: z8.number().int().nonnegative(),
-  errors: z8.array(z8.string().max(1e3)).max(20)
+var SyncSummarySchema = z10.object({
+  checkedAt: z10.string(),
+  published: z10.boolean(),
+  appliedFiles: z10.number().int().nonnegative(),
+  pendingFiles: z10.number().int().nonnegative(),
+  sessionSources: z10.number().int().nonnegative(),
+  errors: z10.array(z10.string().max(1e3)).max(20)
 }).strict();
-var DeviceStatusSchema = z8.object({
-  clientVersion: z8.string().max(64),
+var DeviceStatusSchema = z10.object({
+  clientVersion: z10.string().max(64),
   receivedRevision: RevisionSchema.nullable(),
   appliedRevision: RevisionSchema.nullable(),
   effectivePolicy: EffectivePolicySchema,
-  overrides: z8.array(z8.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
-  configError: z8.string().max(2e3).nullable(),
-  reportError: z8.string().max(2e3).nullable(),
+  overrides: z10.array(z10.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
+  configError: z10.string().max(2e3).nullable(),
+  reportError: z10.string().max(2e3).nullable(),
   lastSync: SyncSummarySchema.nullable()
 }).strict();
-var WebDevicesSchema = z8.object({
-  devices: z8.array(
-    z8.object({
+var WebDevicesSchema = z10.object({
+  devices: z10.array(
+    z10.object({
       memberId: NameSchema,
-      bound: z8.boolean(),
-      lastSeenAt: z8.string().nullable(),
+      bound: z10.boolean(),
+      lastSeenAt: z10.string().nullable(),
       status: DeviceStatusSchema.nullable()
     })
   )
 });
 
 // apps/client/project-state.ts
-import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
 var projectClientMigration = String.raw`
  CREATE TABLE client_enrollments(root TEXT PRIMARY KEY REFERENCES connections(root),server_url TEXT NOT NULL,request_json TEXT NOT NULL);
  CREATE TABLE client_project_config(root TEXT PRIMARY KEY REFERENCES connections(root),config_json TEXT NOT NULL,descriptor_hash TEXT NOT NULL);
@@ -1322,7 +1494,7 @@ var ClientProjectState = class {
       return request2;
     }
     const request = {
-      operationId: randomUUID2(),
+      operationId: randomUUID3(),
       memberId,
       projectId,
       deviceId,
@@ -1495,6 +1667,20 @@ function readControlStatus(state, root) {
   return row ? DeviceStatusSchema.parse(JSON.parse(String(row.status_json))) : null;
 }
 
+// apps/client/sessions/versions.ts
+var parserVersions = {
+  "claude-code": 1,
+  codex: 1,
+  cursor: 1,
+  pi: 2,
+  dsh: 1
+};
+var sessionParserMigration = `
+ALTER TABLE session_sources ADD COLUMN parser_version INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE session_publications ADD COLUMN pending_parser_version INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE session_discovery_cache ADD COLUMN parser_version INTEGER NOT NULL DEFAULT 0;
+`;
+
 // apps/client/sessions/state.ts
 var sessionClientMigration = String.raw`
   CREATE TABLE session_sources (
@@ -1513,6 +1699,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;
@@ -1532,25 +1740,31 @@ var SessionState = class {
   get(path) {
     return this.sources(path)[0];
   }
-  sources(path, limit = 2147483647) {
+  sources(path, limit = 2147483647, before = Number.MAX_SAFE_INTEGER) {
     return this.state.db.prepare(
-      `SELECT * FROM session_sources WHERE root=? ${path === void 0 ? "" : "AND path=?"} ORDER BY checked_at, path LIMIT ?`
-    ).all(this.root, ...path === void 0 ? [] : [path], limit).map((row) => ({
+      `SELECT s.*, p.revision,p.hash,p.selected_path,p.pending_json,p.pending_signature,p.pending_path,p.pending_parser_version,p.attempts,p.retry_at
+      FROM session_sources s LEFT JOIN session_publications p USING(root,session_key)
+      WHERE s.root=? AND s.checked_at<? ${path === void 0 ? "" : "AND s.path=?"} ORDER BY s.checked_at, s.path LIMIT ?`
+    ).all(this.root, before, ...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),
+      parserVersion: Number(row.parser_version),
+      pendingParserVersion: Number(row.pending_parser_version ?? 0),
       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,38 +1774,84 @@ 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=?,pending_parser_version=?,attempts=0,retry_at=0
+      WHERE root=? AND session_key=? AND pending_json IS NULL`
+    ).run(
+      JSON.stringify(request),
+      signature2,
+      path,
+      parserVersions[this.get(path).agent],
+      this.root,
+      request.sessionKey
+    );
+  }
+  acknowledge(path, revision, hash2, signature2, parserVersion) {
+    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, parserVersion);
   }
-  acknowledge(path, revision, hash2, signature2) {
+  observed(path, signature2, parserVersion = parserVersions[this.get(path).agent]) {
     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=?,parser_version=?,last_error=NULL,adopt_existing=0 WHERE root=? AND path=?"
+    ).run(signature2, Date.now(), parserVersion, 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) {
+    const prior = this.directories().find((item) => item.directory === directory);
+    if (prior?.agent === agent && prior.projectDir === projectDir) return;
     this.state.db.prepare(
       "INSERT INTO session_discovery VALUES (?,?,?,?) ON CONFLICT(root,directory) DO UPDATE SET agent=excluded.agent,project_dir=excluded.project_dir"
     ).run(this.root, directory, agent, projectDir);
-    this.state.db.prepare("DELETE FROM session_discovery_cache WHERE root=?").run(this.root);
+    this.state.db.prepare("DELETE FROM session_discovery_cache WHERE root=? AND substr(path,1,?)=?").run(this.root, directory.length + 1, directory + "/");
+  }
+  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) => ({
@@ -1604,32 +1864,75 @@ var SessionState = class {
 
 // apps/client/state.ts
 var LocalBindingSchema = BindingSchema.extend({
-  root: z9.string(),
-  serverUrl: z9.string(),
-  token: z9.string()
+  root: z11.string(),
+  serverUrl: z11.string(),
+  token: z11.string()
 });
-var ClientState = class extends FilePublicationState {
-  constructor(directory) {
-    const db = openDatabase(join4(directory, "client.sqlite3"), [
-      String.raw`
+var clientMigrations = [
+  String.raw`
       CREATE TABLE connections (root TEXT PRIMARY KEY, device_id TEXT NOT NULL, binding_json TEXT);
     `,
-      String.raw`
+  String.raw`
         CREATE TABLE publications (root TEXT PRIMARY KEY REFERENCES connections(root), revision INTEGER NOT NULL DEFAULT 0, initialized INTEGER NOT NULL DEFAULT 0);
         CREATE TABLE owner_files (root TEXT NOT NULL REFERENCES connections(root), path TEXT NOT NULL, hash TEXT NOT NULL, size INTEGER NOT NULL, PRIMARY KEY(root, path));
         CREATE TABLE outbox (root TEXT PRIMARY KEY REFERENCES connections(root), request_json TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0, retry_at INTEGER NOT NULL DEFAULT 0, last_error TEXT);
       `,
-      syncMigration,
-      sessionClientMigration,
-      projectClientMigration,
-      controlClientMigration,
-      runtimeMigration,
-      projectFilesClientMigration
-    ]);
+  syncMigration,
+  sessionClientMigration,
+  projectClientMigration,
+  controlClientMigration,
+  runtimeMigration,
+  projectFilesClientMigration,
+  sessionSourcesMigration,
+  atomicFilesClientMigration,
+  sessionParserMigration
+];
+var clientSchemaVersion = clientMigrations.length;
+var ClientState = class extends FilePublicationState {
+  access;
+  constructor(directory, options = {}) {
+    let access2;
+    let db;
+    try {
+      if (!options.maintenance) access2 = stateAccess(directory);
+      const version = stateVersion(directory);
+      if (version > clientSchemaVersion)
+        throw new Error(
+          "Database was created by a newer Teammy version. Local stop and logs remain available."
+        );
+      if (version > 0 && version < clientSchemaVersion)
+        throw new Error("Client state needs an upgrade. Run teammy repair.");
+      if (options.readOnly) {
+        if (!version) throw new Error("No client state is available.");
+        db = new DatabaseSync3(join6(directory, "client.sqlite3"), { readOnly: true });
+      } else if (!version) {
+        access2?.close();
+        access2 = void 0;
+        const exclusive = options.maintenance ? void 0 : stateAccess(directory, true);
+        try {
+          db = openDatabase(join6(directory, "client.sqlite3"), clientMigrations);
+        } finally {
+          exclusive?.close();
+        }
+        if (!options.maintenance) access2 = stateAccess(directory);
+      } else {
+        db = new DatabaseSync3(join6(directory, "client.sqlite3"));
+        db.exec("PRAGMA busy_timeout=5000; PRAGMA foreign_keys=ON; PRAGMA synchronous=FULL;");
+      }
+    } catch (error) {
+      db?.close();
+      access2?.close();
+      throw error;
+    }
     super(db);
+    this.access = access2;
   }
   close() {
-    this.db.close();
+    try {
+      this.db.close();
+    } finally {
+      this.access?.close();
+    }
   }
   assertRootAvailable(root) {
     for (const row of this.db.prepare("SELECT root FROM connections").all()) {
@@ -1645,7 +1948,7 @@ var ClientState = class extends FilePublicationState {
   }
   deviceFor(root) {
     this.assertRootAvailable(root);
-    this.db.prepare("INSERT OR IGNORE INTO connections (root, device_id) VALUES (?, ?)").run(root, randomUUID3());
+    this.db.prepare("INSERT OR IGNORE INTO connections (root, device_id) VALUES (?, ?)").run(root, randomUUID4());
     return String(
       this.db.prepare("SELECT device_id FROM connections WHERE root=?").get(root).device_id
     );
@@ -1687,11 +1990,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 mkdir5, readFile as readFile2, writeFile, realpath as realpath4 } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname6, join as join10, resolve as resolve4 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
 
 // apps/client/sessions/normalize.ts
 function object(value) {
@@ -1702,91 +2008,118 @@ 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";
+  piParents = /* @__PURE__ */ new Map();
+  piLeaf = null;
+  piTree = false;
+  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 (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);
       }
-      if (row.type === "response_item" && payload.type === "message" && payload.channel !== "analysis")
-        add(payload.role, payload.content, payload.id, line);
-    } else if (agent === "pi") {
+    } else if (this.agent === "cursor") {
+      if (row.isSidechain === true) return;
+      const sessionId = row.sessionId ?? row.session_id;
+      if (typeof sessionId === "string" && this.nativeId && sessionId !== this.nativeId)
+        throw new Error("Mixed Cursor session identities.");
+      const message2 = object(row.message);
+      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 !== "session" && typeof row.id === "string") {
+        this.piTree ||= Object.hasOwn(row, "parentId");
+        this.piParents.set(
+          row.id,
+          typeof row.parentId === "string" ? row.parentId : row.parentId === null ? null : this.piLeaf
+        );
+        this.piLeaf = row.id;
       }
       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,103 +2128,1221 @@ function normalizeJsonl(agent, text) {
       }
     }
   }
-  return {
-    snapshot: SessionSnapshotSchema.parse({
+  finish() {
+    let piBranch;
+    if (this.agent === "pi" && this.piTree) {
+      piBranch = /* @__PURE__ */ new Set();
+      let id = this.piLeaf;
+      while (id && !piBranch.has(id)) {
+        piBranch.add(id);
+        id = this.piParents.get(id) ?? null;
+      }
+    }
+    const visibleGroups = new Set(this.candidates.filter((m) => m.visible).map((m) => m.group));
+    const ids = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    const messages = this.candidates.filter((m) => !piBranch || typeof m.id === "string" && piBranch.has(m.id)).filter((m) => m.visible || !visibleGroups.has(m.group)).filter((m) => {
+      if (typeof m.id !== "string" || !m.id) return true;
+      const identity = JSON.stringify([m.id, m.role, m.text]);
+      if (seen.has(identity)) return false;
+      seen.add(identity);
+      return true;
+    }).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/hooks.ts
-var HintSchema = z10.object({
-  agent: AgentSchema,
-  path: z10.string().min(1).max(4096).refine(isAbsolute3),
-  projectDir: z10.string().min(1).max(4096).refine(isAbsolute3)
-});
-function inbox(directory, root) {
-  return join5(directory, "session-hints", createHash5("sha256").update(root).digest("hex"));
+// apps/client/sessions/registration.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+var registrationPath = (directory, root) => join7(directory, "hook-registrations", rootKey(root) + ".json");
+function readRegistration(directory, root) {
+  const path = registrationPath(directory, root);
+  if (!existsSync3(path)) return null;
+  const value = JSON.parse(readFileSync3(path, "utf8"));
+  if (value.format !== 1 || value.root !== root || !Array.isArray(value.configs))
+    throw new Error("Invalid Hook registration.");
+  return value;
 }
-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(
-    targetDir,
-    `${createHash5("sha256").update(JSON.stringify(hint)).digest("hex")}.json`
-  );
-  const temporary = `${target}.${randomUUID4()}.tmp`;
-  const handle = await open2(temporary, "wx", 384);
-  try {
-    await handle.writeFile(JSON.stringify(hint));
-  } finally {
-    await handle.close();
-  }
-  await rename2(temporary, target);
+function saveRegistration(directory, value) {
+  writePrivateJson(registrationPath(directory, value.root), value);
 }
-async function consumeHints(directory, root, sessions) {
-  const issues = [];
-  let dir;
+function registrations(directory, onError) {
+  const path = join7(directory, "hook-registrations");
+  if (!existsSync3(path)) return [];
+  return readdirSync2(path).filter((name2) => /^[a-f0-9]{16}\.json$/.test(name2)).flatMap((name2) => {
+    try {
+      const value = JSON.parse(readFileSync3(join7(path, name2), "utf8"));
+      const registration = readRegistration(directory, value.root);
+      if (!registration) throw new Error("Missing Hook registration.");
+      return [registration];
+    } catch (error) {
+      onError(join7(path, name2), error);
+      return [];
+    }
+  });
+}
+
+// apps/client/root-lock.ts
+import { createHash as createHash5 } from "node:crypto";
+import { join as join8 } from "node:path";
+function acquireRootLock(root, stateDirectory) {
+  let lock;
   try {
-    dir = await opendir(inbox(directory, root));
+    lock = openDatabase(
+      join8(stateDirectory, "locks", `${createHash5("sha256").update(root).digest("hex")}.sqlite3`),
+      [],
+      0
+    );
+    lock.exec("PRAGMA busy_timeout=0; BEGIN IMMEDIATE");
+    return lock;
   } catch (error) {
-    if (error.code === "ENOENT") return issues;
+    lock?.close();
+    if (error instanceof Error && /locked|busy/.test(error.message))
+      throw new Error("Another sync or connect process is using this root.");
     throw error;
   }
-  let count = 0;
-  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);
+}
+
+// apps/client/sessions/setup.ts
+import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
+
+// apps/client/sessions/pi-extension.ts
+import { mkdir as mkdir4, readFile } from "node:fs/promises";
+import { dirname as dirname5, basename as basename2, join as join9, resolve as resolve3 } from "node:path";
+var marker = (directory) => `// Teammy Pi collection ${rootKey(directory)}`;
+function piPath(path, home, cwd) {
+  return resolve3(
+    cwd,
+    path === "~" ? home : path.startsWith("~/") ? join9(home, path.slice(2)) : path
+  );
+}
+async function piDiscoveryDirectories(agentDirectory, project, home, env) {
+  let configured;
+  for (const path of [join9(agentDirectory, "settings.json"), join9(project, ".pi/settings.json")]) {
     try {
-      const handle = await open2(path, "r");
-      let body;
-      try {
-        if ((await handle.stat()).size > 16384) throw new Error("Oversized hook hint.");
-        body = await handle.readFile("utf8");
-      } finally {
-        await handle.close();
-      }
-      const hint = HintSchema.parse(JSON.parse(body));
-      sessions.track(hint.agent, hint.path, hint.projectDir);
-      await unlink2(path);
+      const settings = JSON.parse(await readFile(path, "utf8"));
+      if (typeof settings?.sessionDir === "string" && settings.sessionDir)
+        configured = settings.sessionDir;
     } catch (error) {
-      issues.push(
-        `hook hint ${entry.name}: ${error instanceof Error ? error.message : "invalid hint"}`
-      );
+      if (!missing(error)) throw new Error(`Unable to read Pi session directory setting: ${path}`);
     }
   }
-  return issues;
+  configured = env.PI_CODING_AGENT_SESSION_DIR || configured;
+  return [
+    .../* @__PURE__ */ new Set([
+      join9(agentDirectory, "sessions"),
+      ...configured ? [piPath(configured, home, project)] : []
+    ])
+  ];
 }
-async function hookPayload() {
-  let size = 0;
-  const parts = [];
-  const timeout = setTimeout(() => process.stdin.destroy(new Error("Hook input timeout.")), 500);
+function piExtensionSource(directory, path, entry) {
+  return `${marker(directory)}
+import { spawn } from 'node:child_process';
+
+export default function teammyCollection(pi) {
+  const collect = async (_event, ctx) => {
+    try {
+      const manager = ctx.sessionManager;
+      const file = manager.getSessionFile();
+      if (!file || manager.isPersisted?.() === false) return;
+      const payload = JSON.stringify({
+        cwd: manager.getCwd?.() ?? ctx.cwd,
+        session_id: manager.getSessionId(),
+        transcript_path: file,
+      });
+      const child = spawn(${JSON.stringify(process.execPath)}, [
+        ${JSON.stringify(join9(dirname5(entry), "session-hook.js"))},
+        '--agent', 'pi', '--state-dir', ${JSON.stringify(directory)},
+        '--integration-file', ${JSON.stringify(path)},
+      ], { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true, shell: false });
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => { try { child.kill('SIGKILL'); } catch {} finish(); }, 2000);
+        const finish = () => { clearTimeout(timer); resolve(); };
+        child.once('error', finish);
+        child.once('close', finish);
+        child.stdin.on('error', () => {});
+        child.stdin.end(payload);
+      });
+    } catch { /* Collection never affects the host session. */ }
+  };
+  // agent_end is supported by older Pi releases too. It follows message
+  // persistence; retries or queued turns simply produce another hint later.
+  for (const event of ['session_start', 'agent_end', 'session_shutdown']) {
+    try { pi.on(event, collect); } catch {}
+  }
+}
+`;
+}
+async function installPiExtension(directory, registry, agentDirectory, entry) {
+  const path = join9(agentDirectory, "extensions", `teammy-${rootKey(directory)}.js`);
+  await mkdir4(dirname5(path), { recursive: true });
+  let original = null;
   try {
-    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.");
-      parts.push(bytes);
-    }
-    return object(JSON.parse(Buffer.concat(parts).toString("utf8")));
-  } finally {
-    clearTimeout(timeout);
+    original = await readStable(dirname5(path), basename2(path));
+  } catch (error) {
+    if (!missing(error)) throw error;
+  }
+  if (original && !original.bytes.toString("utf8").startsWith(marker(directory) + "\n"))
+    throw new Error(`Pi extension is not owned by Teammy: ${path}`);
+  if (!registry.configs.some((config) => config.path === path && config.kind === "pi-extension"))
+    registry.configs.push({ path, agent: "pi", kind: "pi-extension", created: !original });
+  saveRegistration(directory, registry);
+  const bytes = Buffer.from(piExtensionSource(directory, path, entry));
+  if (!original?.bytes.equals(bytes))
+    await replaceFile(dirname5(path), basename2(path), bytes, original?.signature ?? null);
+}
+async function removePiExtension(directory, path) {
+  const issues = [];
+  const remaining = registrations(directory, (file) => issues.push(file));
+  if (issues.length || remaining.some((r) => r.enabled && r.configs.some((c) => c.path === path)))
+    return false;
+  try {
+    const original = await readStable(dirname5(path), basename2(path));
+    if (!original.bytes.toString("utf8").startsWith(marker(directory) + "\n"))
+      throw new Error(`Pi extension is not owned by Teammy: ${path}`);
+    await removeFile(dirname5(path), basename2(path), original.signature);
+    return true;
+  } catch (error) {
+    if (missing(error)) return false;
+    throw error;
   }
 }
 
-// apps/client/sessions/command.ts
-var help = `Usage: teammy session COMMAND [options]
-
-  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]
-  undiscover  --directory DIR (also untrack any previously discovered sources to stop them)
+// 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 = {}) {
+  await realpath4(root);
+  if (!state.binding(root)) throw new Error("Connect this root before installing hooks.");
+  const lock = acquireRootLock("hooks", join10(directory, "runtime"));
+  try {
+    const prior = readRegistration(directory, root);
+    if (prior && !prior.enabled && !options.enable)
+      return { configured: [], issues: [] };
+    const registry = prior ?? {
+      format: 1,
+      root,
+      projectDir: dirname6(root),
+      enabled: true,
+      configs: []
+    };
+    registry.enabled = true;
+    saveRegistration(directory, registry);
+    const home = options.home ?? homedir(), env = options.env ?? process.env;
+    const project = dirname6(root), sessions = new SessionState(state, root);
+    const defaults = [
+      {
+        agent: "claude-code",
+        executables: ["claude"],
+        storage: env.CLAUDE_CONFIG_DIR ?? join10(home, ".claude"),
+        directories: ["projects"],
+        config: ".claude/settings.local.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "codex",
+        executables: ["codex"],
+        storage: env.CODEX_HOME ?? join10(home, ".codex"),
+        directories: ["sessions"],
+        config: ".codex/hooks.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "claude-code",
+        instance: "tclaude",
+        executables: ["tclaude"],
+        storage: join10(home, ".tclaude"),
+        directories: ["projects"],
+        config: ".claude/settings.local.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "codex",
+        instance: "tcodex",
+        executables: ["tcodex"],
+        storage: join10(home, ".tcodex"),
+        directories: ["sessions"],
+        config: ".codex/hooks.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "cursor",
+        executables: ["agent", "cursor-agent"],
+        storage: env.CURSOR_CONFIG_DIR ?? join10(home, ".cursor"),
+        directories: ["chats", "projects"],
+        config: ".cursor/hooks.json",
+        events: ["sessionStart", "postToolUse", "stop", "sessionEnd"]
+      },
+      {
+        agent: "pi",
+        executables: ["pi"],
+        storage: piPath(env.PI_CODING_AGENT_DIR ?? join10(home, ".pi", "agent"), home, project),
+        directories: []
+      }
+    ];
+    const issues = [], configured = [];
+    let gitRoot = project;
+    try {
+      gitRoot = (await exec2("git", ["-C", project, "rev-parse", "--show-toplevel"])).stdout.trim();
+    } catch {
+    }
+    const written = /* @__PURE__ */ new Set();
+    for (const adapter of defaults) {
+      const installed = options.agents ? options.agents.includes(adapter.instance ?? adapter.agent) : await exists(adapter.storage) || (await Promise.all(
+        (env.PATH ?? "").split(":").flatMap(
+          (dir) => adapter.executables.map((name2) => exists(join10(dir, name2), constants2.X_OK))
+        )
+      )).some(Boolean);
+      const piProfiles = adapter.agent === "pi" ? registry.configs.filter((config) => config.kind === "pi-extension").map((config) => dirname6(dirname6(config.path))) : [];
+      if (!installed && !piProfiles.length) continue;
+      for (const sub of adapter.directories) {
+        const source = resolve4(adapter.storage, sub);
+        if (!registry.excludedDiscovery?.includes(source))
+          sessions.discover(adapter.agent, source, project);
+      }
+      if (adapter.agent === "cursor" && !registry.excludedDiscovery?.includes(join10(home, ".cursor", "projects")))
+        sessions.discover("cursor", join10(home, ".cursor", "projects"), project);
+      if (!configured.includes(adapter.agent)) configured.push(adapter.agent);
+      if (adapter.agent === "pi") {
+        for (const profile of /* @__PURE__ */ new Set([...piProfiles, ...installed ? [adapter.storage] : []])) {
+          try {
+            if (profile !== adapter.storage && !await exists(profile))
+              throw new Error(`Registered Pi profile is missing: ${profile}`);
+            await installPiExtension(
+              directory,
+              registry,
+              profile,
+              options.entry ?? resolve4(process.argv[1])
+            );
+            for (const source of await piDiscoveryDirectories(profile, project, home, env)) {
+              if (!registry.excludedDiscovery?.includes(source))
+                sessions.discover("pi", source, project);
+            }
+          } catch (error) {
+            issues.push(
+              `Pi: ${error instanceof Error ? error.message : "Extension setup failed."}`
+            );
+          }
+        }
+      }
+      if (!adapter.config) continue;
+      const configRoot = adapter.agent === "cursor" ? gitRoot : project;
+      const path = join10(configRoot, adapter.config);
+      if (written.has(path)) continue;
+      written.add(path);
+      try {
+        await mkdir5(dirname6(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 marker2 = hookMarker(directory, root);
+        const cliEntry = options.entry ?? resolve4(process.argv[1]);
+        const hookEntry = join10(dirname6(cliEntry), "session-hook.js");
+        const invocation = [
+          process.execPath,
+          hookEntry,
+          "--agent",
+          adapter.agent,
+          "--root",
+          root,
+          "--state-dir",
+          directory,
+          "--project-dir",
+          project
+        ].map(quote).join(" ");
+        const command = `( ${invocation} ) >/dev/null 2>&1 || : # ${marker2}`;
+        removeOwned(hooks, adapter.agent, directory, root);
+        for (const event of adapter.events) {
+          const entries = hooks[event] ?? [];
+          if (!Array.isArray(entries)) throw new Error(`Invalid ${event} hooks.`);
+          hooks[event] = [
+            ...entries,
+            adapter.agent === "cursor" ? { command, timeout: 3 } : { hooks: [{ type: "command", command, timeout: 3 }] }
+          ];
+        }
+        let owned = registry.configs.find((item) => item.path === path);
+        if (!owned) {
+          owned = { path, agent: adapter.agent, created: !original };
+          registry.configs.push(owned);
+        }
+        saveRegistration(directory, registry);
+        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 = join10(directory, "hook-backups", rootKey(root));
+          await mkdir5(backupDir, { recursive: true, mode: 448 });
+          const hash2 = createHash6("sha256").update(original.bytes).digest("hex");
+          await writeFile(join10(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 readFile2(exclude, "utf8").catch((e) => {
+              if (missing(e)) return "";
+              throw e;
+            });
+            const rule = "/" + relativePath.replace(/[\\*?[\]#! ]/g, "\\$&");
+            if (!old.split(/\r?\n/).includes(rule)) {
+              await mkdir5(dirname6(exclude), { recursive: true });
+              owned.exclude = {
+                path: exclude,
+                line: "# teammy-hook-" + rootKey(directory) + "-" + rootKey(root) + "\n" + rule
+              };
+              saveRegistration(directory, registry);
+              await writeFile(
+                exclude,
+                old + (old && !old.endsWith("\n") ? "\n" : "") + owned.exclude.line + "\n"
+              );
+            }
+          }
+        } catch {
+        }
+      } catch (error) {
+        issues.push(`${path}: ${error instanceof Error ? error.message : "Hook setup failed."}`);
+      }
+    }
+    return { configured, issues };
+  } finally {
+    lock.close();
+  }
+}
+function hookMarker(directory, root) {
+  return `teammy-session-${rootKey(directory)}-${rootKey(root)}`;
+}
+function setDiscoveryPreference(directory, root, source, enabled) {
+  const lock = acquireRootLock("hooks", join10(directory, "runtime"));
+  try {
+    const registry = readRegistration(directory, root);
+    if (!registry) return;
+    const excluded = new Set(registry.excludedDiscovery ?? []);
+    if (enabled) excluded.delete(source);
+    else excluded.add(source);
+    registry.excludedDiscovery = [...excluded];
+    saveRegistration(directory, registry);
+  } finally {
+    lock.close();
+  }
+}
+function owns(command, directory, root) {
+  if (typeof command !== "string") return false;
+  if (command.trimEnd().endsWith("# " + hookMarker(directory, root))) return true;
+  return command.trimEnd().endsWith("# teammy-session-" + rootKey(root)) && command.includes(quote("--state-dir") + " " + quote(directory));
+}
+function removeOwned(hooks, agent, directory, root) {
+  let changed = false;
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const retained = entries.flatMap((entry) => {
+      const value = object(entry);
+      if (agent === "cursor") return owns(value.command, directory, root) ? [] : [entry];
+      if (!Array.isArray(value.hooks)) return [entry];
+      const nested = value.hooks.filter((hook) => !owns(object(hook).command, directory, root));
+      if (nested.length === value.hooks.length) return [entry];
+      return nested.length ? [{ ...value, hooks: nested }] : [];
+    });
+    if (JSON.stringify(retained) === JSON.stringify(entries)) continue;
+    changed = true;
+    if (retained.length) hooks[event] = retained;
+    else delete hooks[event];
+  }
+  return changed;
+}
+async function legacyRegistrations(directory, explicitRoot) {
+  const roots = new Set(explicitRoot ? [explicitRoot] : []);
+  let db;
+  try {
+    db = new DatabaseSync4(join10(directory, "client.sqlite3"), { readOnly: true });
+    for (const row of db.prepare("SELECT root FROM connections WHERE binding_json IS NOT NULL").all())
+      if (!explicitRoot || row.root === explicitRoot) roots.add(String(row.root));
+  } catch {
+  } finally {
+    db?.close();
+  }
+  for (const root of roots) {
+    try {
+      if (readRegistration(directory, root)) continue;
+    } catch {
+      continue;
+    }
+    const project = dirname6(root);
+    let gitRoot = project;
+    try {
+      gitRoot = (await exec2("git", ["-C", project, "rev-parse", "--show-toplevel"])).stdout.trim();
+    } catch {
+    }
+    const configs = [
+      { path: join10(project, ".claude/settings.local.json"), agent: "claude-code", created: false },
+      { path: join10(project, ".codex/hooks.json"), agent: "codex", created: false },
+      { path: join10(gitRoot, ".cursor/hooks.json"), agent: "cursor", created: false }
+    ];
+    saveRegistration(directory, { format: 1, root, projectDir: project, enabled: true, configs });
+  }
+}
+async function teardownSessions(directory, root) {
+  const lock = acquireRootLock("hooks", join10(directory, "runtime"));
+  const issues = [];
+  let removed = 0;
+  try {
+    await legacyRegistrations(directory, root);
+    const selected = registrations(directory, (path, error) => {
+      issues.push(
+        `${path}: ${error instanceof Error ? error.message : "Invalid Hook registration."}`
+      );
+    }).filter((item) => !root || item.root === root);
+    for (const registration of selected) {
+      registration.enabled = false;
+      try {
+        saveRegistration(directory, registration);
+      } catch (error) {
+        issues.push(
+          `${registration.root}: ${error instanceof Error ? error.message : "Hook removal failed."}`
+        );
+        continue;
+      }
+      for (const config of registration.configs) {
+        try {
+          if (config.kind === "pi-extension") {
+            if (await removePiExtension(directory, config.path)) removed++;
+            continue;
+          }
+          const original = await readStable(
+            dirname6(config.path),
+            config.path.split(/[\\/]/).at(-1)
+          );
+          const value = JSON.parse(original.bytes.toString("utf8"));
+          if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("Invalid hook configuration.");
+          if (value.hooks !== void 0 && (!value.hooks || typeof value.hooks !== "object" || Array.isArray(value.hooks)))
+            throw new Error("Invalid hooks object.");
+          const hooks = object(value.hooks);
+          if (!removeOwned(hooks, config.agent, directory, registration.root)) continue;
+          if (Object.keys(hooks).length) value.hooks = hooks;
+          else delete value.hooks;
+          const empty = !Object.keys(value).length || config.agent === "cursor" && Object.keys(value).length === 1 && value.version === 1;
+          if (empty && config.created)
+            await removeFile(
+              dirname6(config.path),
+              config.path.split(/[\\/]/).at(-1),
+              original.signature
+            );
+          else if (!original.bytes.equals(Buffer.from(JSON.stringify(value, null, 2) + "\n")))
+            await replaceFile(
+              dirname6(config.path),
+              config.path.split(/[\\/]/).at(-1),
+              Buffer.from(JSON.stringify(value, null, 2) + "\n"),
+              original.signature
+            );
+          if (config.exclude && !await exists(config.path)) {
+            const text = await readFile2(config.exclude.path, "utf8");
+            await writeFile(config.exclude.path, text.replace(config.exclude.line + "\n", ""));
+          }
+          removed++;
+        } catch (error) {
+          if (!missing(error))
+            issues.push(
+              `${config.path}: ${error instanceof Error ? error.message : "Hook removal failed."}`
+            );
+        }
+      }
+    }
+    return { removed, issues };
+  } finally {
+    lock.close();
+  }
+}
+
+// apps/client/sessions/hook-entry.ts
+import { parseArgs } from "node:util";
+import { realpath as realpath5 } from "node:fs/promises";
+import { dirname as dirname7, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve5, sep as sep4 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join12 } from "node:path";
+
+// apps/client/sessions/hooks.ts
+import { createHash as createHash7, randomUUID as randomUUID5 } from "node:crypto";
+import { mkdir as mkdir6, open as open2, opendir, rename as rename2, unlink as unlink2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join11 } from "node:path";
+import { z as z12 } from "zod";
+var HintSchema = z12.object({
+  agent: AgentSchema,
+  path: z12.string().min(1).max(4096).refine(isAbsolute3).optional(),
+  nativeId: z12.string().min(1).max(512).optional(),
+  projectDir: z12.string().min(1).max(4096).refine(isAbsolute3)
+});
+function inbox(directory, root) {
+  return join11(directory, "session-hints", createHash7("sha256").update(root).digest("hex"));
+}
+async function recordHint(directory, root, input) {
+  const hint = HintSchema.parse(input);
+  const targetDir = inbox(directory, root);
+  await mkdir6(targetDir, { recursive: true, mode: 448 });
+  const target = join11(
+    targetDir,
+    `${createHash7("sha256").update(JSON.stringify(hint)).digest("hex")}.json`
+  );
+  const temporary = `${target}.${randomUUID5()}.tmp`;
+  const handle = await open2(temporary, "wx", 384);
+  try {
+    await handle.writeFile(JSON.stringify(hint));
+  } finally {
+    await handle.close();
+  }
+  await rename2(temporary, target);
+}
+async function consumeHints(directory, root, sessions, refresh) {
+  const issues = [];
+  let dir;
+  try {
+    dir = await opendir(inbox(directory, root));
+  } catch (error) {
+    if (error.code === "ENOENT") return issues;
+    throw error;
+  }
+  let count = 0;
+  for await (const entry of dir) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    if (count++ >= 50) break;
+    const path = join11(inbox(directory, root), entry.name);
+    try {
+      const handle = await open2(path, "r");
+      let body;
+      try {
+        if ((await handle.stat()).size > 16384) throw new Error("Oversized hook hint.");
+        body = await handle.readFile("utf8");
+      } finally {
+        await handle.close();
+      }
+      const hint = HintSchema.parse(JSON.parse(body));
+      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(
+        `hook hint ${entry.name}: ${error instanceof Error ? error.message : "invalid hint"}`
+      );
+    }
+  }
+  return issues;
+}
+async function hookPayload() {
+  let size = 0;
+  const parts = [];
+  const timeout = setTimeout(() => process.stdin.destroy(new Error("Hook input timeout.")), 500);
+  try {
+    for await (const part of process.stdin) {
+      const bytes = Buffer.from(part);
+      size += bytes.length;
+      if (size > 4 * 1024 * 1024) throw new Error("Hook payload too large.");
+      parts.push(bytes);
+    }
+    return object(JSON.parse(Buffer.concat(parts).toString("utf8")));
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// apps/client/sessions/hook-entry.ts
+async function runHook(args) {
+  try {
+    const { values } = parseArgs({
+      args,
+      options: {
+        agent: { type: "string" },
+        root: { type: "string" },
+        "state-dir": { type: "string" },
+        "project-dir": { type: "string" },
+        file: { type: "string" },
+        "integration-file": { type: "string" }
+      }
+    });
+    const directory = await realpath5(
+      resolve5(values["state-dir"] ?? join12(homedir2(), ".teammy", "client"))
+    );
+    const payload = values.file ? {} : await hookPayload();
+    let selectedRoot = values.root;
+    if (values["integration-file"]) {
+      if (values.agent !== "pi" || typeof payload.cwd !== "string") return;
+      const cwd = await realpath5(payload.cwd);
+      const candidates2 = registrations(directory, () => {
+      }).filter(
+        (item) => item.enabled && item.configs.some(
+          (config) => config.kind === "pi-extension" && config.path === values["integration-file"]
+        )
+      );
+      const matches = [];
+      for (const item of candidates2) {
+        try {
+          const project = await realpath5(item.projectDir);
+          const rel = relative4(project, cwd);
+          if (!isAbsolute4(rel) && rel !== ".." && !rel.startsWith(".." + sep4)) matches.push(item);
+        } catch {
+        }
+      }
+      matches.sort((a, b) => b.projectDir.length - a.projectDir.length);
+      selectedRoot = matches[0]?.root;
+      if (!selectedRoot) return;
+    }
+    const root = await realpath5(resolve5(selectedRoot ?? "workspaces"));
+    const registration = readRegistration(directory, root);
+    if (!registration?.enabled) return;
+    const projectDir = await realpath5(registration.projectDir);
+    if (projectDir !== await realpath5(values["project-dir"] ?? dirname7(root))) return;
+    if (typeof payload.cwd === "string") {
+      const rel = relative4(projectDir, await realpath5(payload.cwd));
+      if (isAbsolute4(rel) || rel === ".." || rel.startsWith(".." + sep4)) return;
+    }
+    const file = values.file ?? payload.transcript_path ?? payload.session_file ?? payload.sessionFile;
+    const nativeId = payload.session_id ?? payload.conversation_id;
+    if (typeof file === "string" && file || typeof nativeId === "string")
+      await recordHint(directory, root, {
+        agent: values.agent,
+        ...typeof file === "string" && file ? { path: resolve5(projectDir, file) } : {},
+        ...typeof nativeId === "string" ? { nativeId } : {},
+        projectDir
+      });
+  } catch {
+  }
+}
+
+// apps/client/runtime/maintenance.ts
+import { mkdir as mkdir9, rename as rename4, rm as rm2, readFile as readFile4 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join15, resolve as resolve7 } from "node:path";
+import { DatabaseSync as DatabaseSync5 } from "node:sqlite";
+import { setTimeout as delay } from "node:timers/promises";
+
+// apps/client/runtime/ipc.ts
+import { createConnection } from "node:net";
+import { mkdir as mkdir7, lstat as lstat3, chmod } from "node:fs/promises";
+import { join as join13 } from "node:path";
+import { z as z13 } from "zod";
+var RequestSchema = z13.object({
+  method: z13.enum(["ping", "wake", "status", "once"]),
+  root: z13.string().max(4096).optional()
+}).strict();
+function socketPath(directory) {
+  return join13(
+    "/tmp",
+    `teammy-${process.getuid?.() ?? "user"}-${rootKey(directory)}`,
+    "control.sock"
+  );
+}
+async function prepareSocketDirectory(directory) {
+  const path = join13(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.");
+  await chmod(path, 448);
+}
+var CONTROL_PROTOCOL = 1;
+async function daemonRequest(directory, input, timeout = 15e3) {
+  RequestSchema.parse(input);
+  return new Promise((resolve16, reject) => {
+    const socket = createConnection(socketPath(directory));
+    socket.setEncoding("utf8");
+    let body = "";
+    let done = false;
+    const finish = (error, result2) => {
+      if (done) return;
+      done = true;
+      socket.destroy();
+      if (error) reject(error);
+      else resolve16(result2);
+    };
+    socket.setTimeout(
+      timeout,
+      () => finish(
+        Object.assign(new Error("Background service did not respond. Run teammy repair."), {
+          code: "ETIMEDOUT"
+        })
+      )
+    );
+    socket.on("error", (e) => finish(e));
+    socket.on("end", () => {
+      if (!done)
+        finish(
+          Object.assign(new Error("Background service disconnected."), { code: "ECONNRESET" })
+        );
+    });
+    socket.on("connect", () => socket.write(JSON.stringify(input) + "\n"));
+    socket.on("data", (chunk) => {
+      body += chunk.toString();
+      if (body.length > 256 * 1024) return finish(new Error("Oversized daemon response."));
+      if (!body.includes("\n")) return;
+      try {
+        const response = JSON.parse(body.split("\n")[0]);
+        if (response.ok) finish(void 0, response.result);
+        else finish(new Error(response.error ?? "Background operation failed."));
+      } catch (e) {
+        finish(e);
+      }
+    });
+  });
+}
+async function probeDaemon(directory) {
+  try {
+    const info = await daemonRequest(directory, { method: "ping" }, 1e3);
+    if (!info || !Number.isSafeInteger(info.pid) || info.pid <= 0 || typeof info.version !== "string" || info.protocol !== void 0 && info.protocol !== CONTROL_PROTOCOL)
+      return { state: "incompatible", error: "Unsupported background control protocol." };
+    return { state: "ready", info };
+  } catch (error) {
+    if (["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE"].includes(
+      String(error.code)
+    ))
+      return { state: "absent" };
+    return {
+      state: error.code === "ETIMEDOUT" ? "unresponsive" : "incompatible",
+      error: error instanceof Error ? error.message : "Invalid background response."
+    };
+  }
+}
+async function runningDaemon(directory) {
+  try {
+    return await daemonRequest(directory, { method: "ping" }, 1e3);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Background service is stopping.") return null;
+    if (["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE"].includes(
+      String(error.code)
+    ))
+      return null;
+    throw error;
+  }
+}
+
+// apps/client/runtime/service.ts
+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 dirname8, join as join14, resolve as resolve6 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile3, writeFile as writeFile2, rename as rename3, rm } from "node:fs/promises";
+import { setTimeout as setTimeout3 } from "node:timers/promises";
+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 = 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)}`;
+  const args = [executable, entry, "_daemon", "--state-dir", directory];
+  if (platform === "darwin")
+    return {
+      id,
+      path: join14(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>
+`
+    };
+  if (platform === "linux")
+    return {
+      id: id + ".service",
+      path: join14(userHome, ".config", "systemd", "user", id + ".service"),
+      content: `[Unit]
+Description=Teammy background synchronization
+[Service]
+Type=simple
+ExecStart=${args.map(unit).join(" ")}
+Restart=always
+RestartSec=30
+UMask=0077
+StandardOutput=null
+StandardError=journal
+[Install]
+WantedBy=default.target
+`
+    };
+  throw new Error(
+    "Automatic background sync currently supports macOS and Linux. Use --no-start with sync --foreground on other systems."
+  );
+}
+async function checkServiceSupport() {
+  try {
+    if (process.platform === "darwin")
+      await exec3("launchctl", ["print", `gui/${process.getuid()}`], {
+        maxBuffer: 4 * 1024 * 1024
+      });
+    else if (process.platform === "linux") await exec3("systemctl", ["--user", "show-environment"]);
+    else throw new Error("unsupported");
+  } catch {
+    throw new Error(
+      "A login-session service manager is required (macOS launchd or Linux systemd --user). Use --no-start and sync --foreground where unavailable."
+    );
+  }
+}
+async function bootstrapLaunchAgent(path) {
+  const deadline = Date.now() + 1e4;
+  for (; ; ) {
+    try {
+      await exec3("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
+      return;
+    } catch (error) {
+      if (error.code !== 5 || Date.now() >= deadline) throw error;
+      await setTimeout3(250);
+    }
+  }
+}
+async function ensureDaemon(directory, version) {
+  const definition = serviceDefinition(directory, process.execPath, resolve6(process.argv[1]));
+  let old = "";
+  try {
+    old = await readFile3(definition.path, "utf8");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  const probe = await probeDaemon(directory);
+  const alive = probe.state === "ready" ? probe.info : null;
+  if (alive && old === definition.content && alive.version === version && alive.protocol === CONTROL_PROTOCOL)
+    return;
+  await checkServiceSupport();
+  await mkdir8(dirname8(definition.path), { recursive: true });
+  if (old !== definition.content) {
+    const temp = definition.path + `.${process.pid}.tmp`;
+    await writeFile2(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 exec3("launchctl", ["print", target]);
+      loaded = true;
+    } catch {
+    }
+    if (loaded && (old !== definition.content || alive?.version !== version || alive?.protocol !== CONTROL_PROTOCOL)) {
+      await exec3("launchctl", ["bootout", target]);
+      loaded = false;
+    }
+    if (!loaded) await bootstrapLaunchAgent(definition.path);
+    await exec3("launchctl", ["kickstart", target]);
+  } else {
+    await exec3("systemctl", ["--user", "daemon-reload"]);
+    await exec3("systemctl", ["--user", "enable", definition.id]);
+    await exec3("systemctl", [
+      "--user",
+      old !== definition.content || alive?.version !== version || alive?.protocol !== CONTROL_PROTOCOL ? "restart" : "start",
+      definition.id
+    ]);
+  }
+  const deadline = Date.now() + 15e3;
+  while (Date.now() < deadline) {
+    const current = await probeDaemon(directory);
+    if (current.state === "ready" && current.info.version === version && current.info.protocol === CONTROL_PROTOCOL)
+      return;
+    await setTimeout3(150);
+  }
+  throw new Error(
+    "Background service did not start. Run teammy logs and check the user service manager."
+  );
+}
+async function wakeDaemon(directory, version) {
+  await ensureDaemon(directory, version);
+  await daemonRequest(directory, { method: "wake" });
+}
+async function stopDaemon(directory, remove = false) {
+  const definition = serviceDefinition(directory, process.execPath, resolve6(process.argv[1]));
+  let loaded = false;
+  let pid;
+  try {
+    const saved = JSON.parse(await readFile3(join14(directory, "runtime", "daemon.json"), "utf8"));
+    if (saved.directory === directory && Number.isSafeInteger(saved.pid) && saved.pid > 0)
+      pid = saved.pid;
+  } catch {
+  }
+  const target = process.platform === "darwin" ? `gui/${process.getuid()}/${definition.id}` : definition.id;
+  try {
+    const output = process.platform === "darwin" ? (await exec3("launchctl", ["print", target])).stdout : (await exec3("systemctl", ["--user", "show", target, "--property=LoadState,MainPID"])).stdout;
+    loaded = process.platform === "darwin" || !output.includes("LoadState=not-found");
+    const match = output.match(process.platform === "darwin" ? /\bpid = (\d+)/ : /MainPID=(\d+)/);
+    if (match && Number(match[1]) > 0) pid = Number(match[1]);
+  } catch {
+  }
+  if (loaded) {
+    try {
+      if (process.platform === "darwin")
+        await exec3("launchctl", ["bootout", target], { timeout: 3e4 });
+      else await exec3("systemctl", ["--user", "stop", target], { timeout: 3e4 });
+    } catch {
+      if (process.platform === "darwin") {
+        await exec3("launchctl", ["kill", "SIGKILL", target]);
+        await exec3("launchctl", ["bootout", target], { timeout: 5e3 });
+      } else {
+        await exec3("systemctl", ["--user", "kill", "--signal=SIGKILL", "--kill-whom=all", target]);
+        await exec3("systemctl", ["--user", "stop", target], { timeout: 5e3 });
+      }
+    }
+    if (process.platform === "linux") await exec3("systemctl", ["--user", "disable", target]);
+  }
+  const probe = await probeDaemon(directory);
+  if (probe.state === "ready") pid = probe.info.pid;
+  if (pid) {
+    let command = "";
+    try {
+      command = (await exec3("ps", ["-p", String(pid), "-o", "uid=", "-o", "command="])).stdout;
+    } catch {
+    }
+    if (command.trim()) {
+      const owned = Number(command.trim().split(/\s+/)[0]) === process.getuid?.() && command.includes("_daemon") && command.includes(directory);
+      if (!owned) {
+        if (probe.state !== "absent")
+          throw new Error(
+            "Cannot verify background process ownership; no unrelated process was stopped."
+          );
+        command = "";
+      }
+      if (owned) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch (e) {
+          if (e.code !== "ESRCH") throw e;
+        }
+        const deadline2 = Date.now() + 3e4;
+        while (Date.now() < deadline2) {
+          try {
+            process.kill(pid, 0);
+          } catch {
+            break;
+          }
+          await setTimeout3(100);
+        }
+        let current = "";
+        try {
+          current = (await exec3("ps", ["-p", String(pid), "-o", "uid=", "-o", "command="])).stdout;
+        } catch {
+        }
+        if (current === command && current.trim()) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch (e) {
+            if (e.code !== "ESRCH") throw e;
+          }
+        }
+      }
+    }
+  }
+  const deadline = Date.now() + 5e3;
+  for (; ; ) {
+    try {
+      const lock = acquireRootLock("daemon:" + directory, directory);
+      lock.close();
+      break;
+    } catch (error) {
+      if (Date.now() >= deadline) throw error;
+      await setTimeout3(100);
+    }
+  }
+  const remaining = await probeDaemon(directory);
+  if (remaining.state !== "absent")
+    throw new Error("Background service has not stopped. Inspect the user service manager.");
+  await rm(socketPath(directory), { force: true });
+  if (remove || process.platform === "darwin") await rm(definition.path, { force: true });
+}
+
+// apps/client/runtime/maintenance.ts
+var services = { stop: stopDaemon, start: ensureDaemon };
+async function prepareClient(directory, version, options = {}, control = services) {
+  const record = options.stop || options.uninstall ? null : readMaintenance(directory);
+  if (options.daemonStartup && record)
+    throw new Error("Client is paused for maintenance. Run teammy repair.");
+  const schema = options.stop || options.uninstall ? void 0 : stateVersion(directory);
+  const installation = {
+    version,
+    executable: process.execPath,
+    entry: resolve7(process.argv[1]),
+    protocol: CONTROL_PROTOCOL,
+    schema: clientSchemaVersion
+  };
+  let installed;
+  try {
+    installed = JSON.parse(await readFile4(join15(directory, "runtime/installation.json"), "utf8"));
+  } catch {
+  }
+  const probe = options.daemonStartup ? { state: "absent" } : await probeDaemon(directory);
+  const changed = probe.state === "ready" && (probe.info.version !== version || probe.info.protocol !== CONTROL_PROTOCOL || probe.info.executable !== process.execPath || probe.info.entry !== resolve7(process.argv[1]));
+  const required = options.force || options.stop || options.uninstall || schema !== clientSchemaVersion || JSON.stringify(installed) !== JSON.stringify(installation) || changed || probe.state === "unresponsive" || probe.state === "incompatible" || Boolean(record && (options.resume || ["repair", "upgrade"].includes(record.reason)));
+  if (!required) return { maintained: false, enabled: 0, stopped: 0, issues: [] };
+  const mutex = acquireRootLock("maintenance", join15(directory, "runtime"));
+  const log = new ClientLog(directory);
+  let access2;
+  let legacy;
+  let state;
+  let enabled = 0, stopped = 0;
+  let restart = false;
+  const issues = [];
+  const pauseReason = options.resume ? void 0 : record?.reason === "paused" || record?.reason === "uninstalled" ? record.reason : record?.pauseReason;
+  try {
+    const reason = options.uninstall ? "uninstalled" : options.stop ? "paused" : options.force ? "repair" : "upgrade";
+    writeMaintenance(directory, {
+      reason,
+      phase: "stopping",
+      version,
+      ...pauseReason ? { pauseReason } : {}
+    });
+    log.write("maintenance.started", void 0, `version=${version} reason=${reason}`);
+    if (!options.daemonStartup) await control.stop(directory, Boolean(options.uninstall));
+    if (options.stop || options.uninstall) {
+      if (options.uninstall) issues.push(...(await teardownSessions(directory)).issues);
+      writeMaintenance(directory, { reason, phase: "paused", version });
+      log.write("maintenance.paused");
+    } else {
+      const deadline = Date.now() + 5e3;
+      while (!access2) {
+        try {
+          access2 = stateAccess(directory, true);
+        } catch (error) {
+          if (!(error instanceof Error) || !error.message.includes("Client state is in use") || Date.now() >= deadline)
+            throw error;
+          await delay(100);
+        }
+      }
+      legacy = legacyStateLocks(directory);
+      const before = stateVersion(directory);
+      if (before > clientSchemaVersion)
+        throw new Error(
+          "Database was created by a newer Teammy version. Install a compatible client; teammy repair --stop and logs remain available."
+        );
+      let backup;
+      if (before > 0 && before < clientSchemaVersion) {
+        const backups = join15(directory, "backups");
+        await mkdir9(backups, { recursive: true, mode: 448 });
+        backup = join15(backups, `before-schema-${before}.sqlite3`);
+        if (!existsSync4(backup)) {
+          const temp = backup + ".tmp";
+          await rm2(temp, { force: true });
+          const db = new DatabaseSync5(join15(directory, "client.sqlite3"));
+          try {
+            db.prepare("VACUUM INTO ?").run(temp);
+          } finally {
+            db.close();
+          }
+          const { chmod: chmod3 } = await import("node:fs/promises");
+          await chmod3(temp, 384);
+          await rename4(temp, backup);
+        }
+        log.write("maintenance.backup", void 0, backup);
+      }
+      writeMaintenance(directory, {
+        reason,
+        phase: "migrating",
+        version,
+        ...pauseReason ? { pauseReason } : {},
+        ...backup ? { backup } : {}
+      });
+      openDatabase(join15(directory, "client.sqlite3"), clientMigrations).close();
+      state = new ClientState(directory, { maintenance: true });
+      const runtime = new RuntimeState(state);
+      if (options.intent) {
+        if (options.intent.enabled) await verifyWorkspace(state, options.intent.root);
+        runtime.enable(options.intent.root, options.intent.enabled);
+      }
+      writeMaintenance(directory, {
+        reason,
+        phase: "configuring",
+        version,
+        ...pauseReason ? { pauseReason } : {},
+        ...backup ? { backup } : {}
+      });
+      for (const { root } of state.db.prepare("SELECT root FROM connections WHERE binding_json IS NOT NULL").all()) {
+        if (runtime.enabled(String(root))) enabled++;
+        else stopped++;
+        try {
+          issues.push(...(await setupSessions(state, String(root), directory)).issues);
+        } catch (error) {
+          issues.push(`${root}: ${diagnostic(error)}`);
+        }
+      }
+      writePrivateJson(join15(directory, "runtime/installation.json"), installation);
+      if (pauseReason)
+        writeMaintenance(directory, { reason: pauseReason, phase: "paused", version });
+      else await rm2(maintenancePath(directory), { force: true });
+      restart = !options.daemonStartup && !pauseReason && enabled > 0;
+      if (backup) {
+        const { readdir: readdir3 } = await import("node:fs/promises");
+        for (const file of await readdir3(join15(directory, "backups"))) {
+          if (/^before-schema-\d+\.sqlite3$/.test(file) && join15(directory, "backups", file) !== backup)
+            await rm2(join15(directory, "backups", file));
+        }
+      }
+      log.write(
+        "maintenance.completed",
+        void 0,
+        `version=${version} enabled=${enabled} issues=${issues.length}`
+      );
+    }
+    for (const issue of issues) log.write("sessions.setup.failed", void 0, issue);
+  } catch (error) {
+    log.write("maintenance.failed", void 0, diagnostic(error));
+    throw error;
+  } finally {
+    state?.close();
+    legacy?.close();
+    access2?.close();
+    mutex.close();
+  }
+  if (restart) await control.start(directory, version);
+  return { maintained: true, enabled, stopped, issues };
+}
+
+// apps/client/sessions/command.ts
+var help = `Usage: teammy session COMMAND [options]
+
+Collect Agent conversations into the conversation library (\u5BF9\u8BDD\u5E93), then browse or search them.
+
+  teardown    Remove project hooks; --all removes all registered hooks (keeps discovery)
+  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]
+  undiscover  --directory DIR (also untrack any previously discovered sources to stop them)
   sources     Show registered sources, discovery directories and collection errors
   hook        --agent AGENT [--file PATH] [--project-dir DIR]; accepts JSON on stdin
   list        [--after N] [--limit N]
@@ -1904,17 +3355,21 @@ track/discover only register local sources. Run teammy sync to collect and publi
 Discover uses native default locations except DSH, which requires --directory.
 Hook only records a local hint, emits no stdout, and always exits successfully.
 `;
-async function runSessionCommand(args) {
+async function runSessionCommand(args, version) {
   const command = args[0];
   if (!command || ["--help", "-h", "help"].includes(command)) {
     process.stdout.write(help);
     return 0;
   }
-  const { values } = parseArgs({
+  if (command === "hook") {
+    await runHook(args.slice(1));
+    return 0;
+  }
+  const { values } = parseArgs2({
     args: args.slice(1),
     options: {
-      root: { type: "string", default: resolve3("workspaces") },
-      "state-dir": { type: "string", default: join6(homedir(), ".teammy", "client") },
+      root: { type: "string", default: resolve8("workspaces") },
+      "state-dir": { type: "string", default: join16(homedir4(), ".teammy", "client") },
       agent: { type: "string" },
       file: { type: "string" },
       directory: { type: "string" },
@@ -1926,27 +3381,25 @@ async function runSessionCommand(args) {
       query: { type: "string" },
       after: { type: "string", default: "0" },
       limit: { type: "string", default: "50" },
-      help: { type: "boolean", short: "h" }
+      help: { type: "boolean", short: "h" },
+      all: { type: "boolean" }
     }
   });
   if (values.help) {
     process.stdout.write(help);
     return 0;
   }
-  const root = await realpath4(resolve3(values.root));
-  const directory = await stateLocation(root, values["state-dir"]);
-  const projectDir = await realpath4(resolve3(values["project-dir"] ?? dirname4(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)
-      await recordHint(directory, root, {
-        agent: AgentSchema.parse(values.agent),
-        path: resolve3(file),
-        projectDir
-      });
-    return 0;
+  if (command === "teardown") {
+    const directory2 = await realpath6(resolve8(values["state-dir"]));
+    const root2 = values.all ? void 0 : await realpath6(resolve8(values.root)).catch(() => resolve8(values.root));
+    const report = await teardownSessions(directory2, root2);
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    return report.issues.length ? 1 : 0;
   }
+  const root = await realpath6(resolve8(values.root));
+  const directory = await stateLocation(root, values["state-dir"]);
+  const projectDir = await realpath6(resolve8(values["project-dir"] ?? dirname9(root)));
+  await prepareClient(directory, version);
   const state = new ClientState(directory);
   try {
     const binding = state.binding(root);
@@ -1954,9 +3407,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, { enable: true });
+    else if (command === "track" || command === "untrack") {
       if (!values.file) throw new Error("--file is required.");
-      const path = resolve3(values.file);
+      const path = resolve8(values.file);
       if (command === "track")
         sessions.track(
           AgentSchema.parse(values.agent),
@@ -1969,27 +3423,38 @@ 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)));
+        const source = await realpath6(resolve8(values.directory));
+        setDiscoveryPreference(directory, root, source, false);
+        state.db.prepare("DELETE FROM session_discovery WHERE root=? AND directory=?").run(root, source);
       } 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": join16(
+            process.env.CLAUDE_CONFIG_DIR ?? join16(homedir4(), ".claude"),
+            "projects"
+          ),
+          codex: join16(process.env.CODEX_HOME ?? join16(homedir4(), ".codex"), "sessions"),
+          cursor: join16(
+            process.env.CURSOR_CONFIG_DIR ?? join16(homedir4(), ".cursor"),
             "chats",
-            createHash6("md5").update(projectDir).digest("hex")
+            createHash8("md5").update(projectDir).digest("hex")
           ),
-          pi: join6(process.env.PI_CODING_AGENT_DIR ?? join6(homedir(), ".pi", "agent"), "sessions"),
+          pi: join16(process.env.PI_CODING_AGENT_DIR ?? join16(homedir4(), ".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);
+        const source = await realpath6(resolve8(path));
+        setDiscoveryPreference(directory, root, source, true);
+        sessions.discover(agent, source, 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);
@@ -2020,54 +3485,33 @@ async function runSessionCommand(args) {
 }
 
 // apps/client/sync-command.ts
-import { parseArgs as parseArgs3 } from "node:util";
+import { parseArgs as parseArgs4 } from "node:util";
 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 { parseArgs as parseArgs3 } from "node:util";
+import { join as join18, resolve as resolve10 } from "node:path";
+import { homedir as homedir5 } 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 readFile5, mkdir as mkdir10 } 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";
-function acquireRootLock(root, stateDirectory) {
-  let lock;
-  try {
-    lock = openDatabase(
-      join7(stateDirectory, "locks", `${createHash7("sha256").update(root).digest("hex")}.sqlite3`),
-      [],
-      0
-    );
-    lock.exec("PRAGMA busy_timeout=0; BEGIN IMMEDIATE");
-    return lock;
-  } catch (error) {
-    lock?.close();
-    if (error instanceof Error && /locked|busy/.test(error.message))
-      throw new Error("Another sync or connect process is using this root.");
-    throw error;
-  }
-}
-
 // 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 { z as z11 } from "zod";
+import { constants as constants3 } from "node:fs";
+import { open as open3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join17 } from "node:path";
+import { z as z14 } from "zod";
 import ignore from "ignore";
 var LOCAL_CONFIG_NAME = ".teammy-local.json";
-var LocalConfigSchema = z11.object({
-  files: z11.object({ ignore: z11.array(z11.string().max(1024)).max(256).default([]) }).strict().default({ ignore: [] })
+var LocalConfigSchema = z14.object({
+  files: z14.object({ ignore: z14.array(z14.string().max(1024)).max(256).default([]) }).strict().default({ ignore: [] })
 }).strict();
 async function ensureLocalConfig(root) {
   try {
-    await writeFile(
-      join8(root, LOCAL_CONFIG_NAME),
+    await writeFile3(
+      join17(root, LOCAL_CONFIG_NAME),
       JSON.stringify({ files: { ignore: [] } }, null, 2) + "\n",
       { flag: "wx", mode: 384 }
     );
@@ -2079,8 +3523,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
+      join17(root, LOCAL_CONFIG_NAME),
+      constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
     );
     try {
       const before = await file.stat();
@@ -2125,6 +3569,10 @@ async function connectProject(state, root, directory, options) {
     if (existing && options.project && options.project !== existing.workspaceId)
       throw new Error("This root belongs to a different project. Use a different local root.");
     const info = await transport.serverInfo();
+    if (!info.capabilities.includes("atomic-file-publications"))
+      throw new Error(
+        "Update the server before connecting: complete directory publications are required."
+      );
     if (!info.capabilities.includes("multi-project"))
       throw new Error(
         "This client requires a multi-project server. Update the server before connecting."
@@ -2136,7 +3584,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 readFile5(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);
@@ -2148,256 +3596,50 @@ async function connectProject(state, root, directory, options) {
       if (!member && process.stdin.isTTY) {
         const rl = createInterface({ input: process.stdin, output: process.stderr });
         try {
-          member = (await rl.question("Member ID: ")).trim();
-        } finally {
-          rl.close();
-        }
-      }
-      if (!member) throw new Error("--member is required when input is not interactive.");
-      NameSchema.parse(member);
-      if (existing && existing.memberId !== member)
-        throw new Error("This root belongs to a different member.");
-      const projectId = options.project ?? existing?.workspaceId;
-      if (!projectId)
-        throw new Error(
-          "--project is required for a new connection; copy the command from the project settings."
-        );
-      NameSchema.parse(projectId);
-      const request = project.enrollment(
-        transport.url,
-        member,
-        projectId,
-        Boolean(options.reconnect)
-      );
-      const binding2 = await transport.enroll(request);
-      state.saveBinding(root, transport.url, request.credential, binding2);
-      project.completeEnrollment();
-    }
-    const binding = state.binding(root);
-    const client = new HubClient(binding.serverUrl, 1e4, binding);
-    if (info.capabilities.includes("project-config")) {
-      try {
-        await applyProjectFile(project, await client.projectConfig());
-      } catch (error) {
-        if (!(options.tokenFile && error instanceof Error && "code" in error && ["SETUP_REQUIRED", "PROJECT_NOT_FOUND"].includes(String(error.code))))
-          throw error;
-      }
-    }
-    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));
-    await ensureLocalConfig(root);
-    const { token: _, ...visible } = binding;
-    return { ...visible, configRevision: project.cached()?.config.configRevision ?? null };
-  } finally {
-    lock.close();
-  }
-}
-
-// 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 { 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(
-    "/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 stat2 = await lstat3(path);
-  if (!stat2.isDirectory() || stat2.isSymbolicLink() || stat2.uid !== process.getuid?.())
-    throw new Error("Unsafe daemon socket directory.");
-  await chmod(path, 448);
-}
-async function daemonRequest(directory, input, timeout = 15e3) {
-  RequestSchema.parse(input);
-  return new Promise((resolve9, reject) => {
-    const socket = createConnection(socketPath(directory));
-    socket.setEncoding("utf8");
-    let body = "";
-    let done = false;
-    const finish = (error, result2) => {
-      if (done) return;
-      done = true;
-      socket.destroy();
-      if (error) reject(error);
-      else resolve9(result2);
-    };
-    socket.setTimeout(
-      timeout,
-      () => finish(new Error("Background service did not respond. Run teammy status."))
-    );
-    socket.on("error", (e) => finish(e));
-    socket.on("end", () => {
-      if (!done)
-        finish(
-          Object.assign(new Error("Background service disconnected."), { code: "ECONNRESET" })
-        );
-    });
-    socket.on("connect", () => socket.write(JSON.stringify(input) + "\n"));
-    socket.on("data", (chunk) => {
-      body += chunk.toString();
-      if (body.length > 256 * 1024) return finish(new Error("Oversized daemon response."));
-      if (!body.includes("\n")) return;
-      try {
-        const response = JSON.parse(body.split("\n")[0]);
-        if (response.ok) finish(void 0, response.result);
-        else finish(new Error(response.error ?? "Background operation failed."));
-      } catch (e) {
-        finish(e);
-      }
-    });
-  });
-}
-async function runningDaemon(directory) {
-  try {
-    return await daemonRequest(directory, { method: "ping" }, 1e3);
-  } catch (error) {
-    if (["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE"].includes(
-      String(error.code)
-    ))
-      return null;
-    throw error;
-  }
-}
-
-// 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 { setTimeout as setTimeout3 } from "node:timers/promises";
-var execute = promisify2(execFile2);
-var exec2 = (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()) {
-  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)}`;
-  const args = [executable, entry, "_daemon", "--state-dir", directory];
-  if (platform === "darwin")
-    return {
-      id,
-      path: join10(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>
-`
-    };
-  if (platform === "linux")
-    return {
-      id: id + ".service",
-      path: join10(userHome, ".config", "systemd", "user", id + ".service"),
-      content: `[Unit]
-Description=Teammy background synchronization
-[Service]
-Type=simple
-ExecStart=${args.map(unit).join(" ")}
-Restart=always
-RestartSec=30
-UMask=0077
-StandardOutput=null
-StandardError=journal
-[Install]
-WantedBy=default.target
-`
-    };
-  throw new Error(
-    "Automatic background sync currently supports macOS and Linux. Use --no-start with sync --foreground on other systems."
-  );
-}
-async function checkServiceSupport() {
-  try {
-    if (process.platform === "darwin")
-      await exec2("launchctl", ["print", `gui/${process.getuid()}`], {
-        maxBuffer: 4 * 1024 * 1024
-      });
-    else if (process.platform === "linux") await exec2("systemctl", ["--user", "show-environment"]);
-    else throw new Error("unsupported");
-  } catch {
-    throw new Error(
-      "A login-session service manager is required (macOS launchd or Linux systemd --user). Use --no-start and sync --foreground where unavailable."
-    );
-  }
-}
-async function bootstrapLaunchAgent(path) {
-  const deadline = Date.now() + 1e4;
-  for (; ; ) {
-    try {
-      await exec2("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
-      return;
-    } catch (error) {
-      if (error.code !== 5 || Date.now() >= deadline) throw error;
-      await setTimeout3(250);
-    }
-  }
-}
-async function ensureDaemon(directory, version) {
-  const definition = serviceDefinition(directory, process.execPath, resolve4(process.argv[1]));
-  let old = "";
-  try {
-    old = await readFile2(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 });
-  if (old !== definition.content) {
-    const temp = definition.path + `.${process.pid}.tmp`;
-    await writeFile2(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]);
-      loaded = true;
-    } catch {
+          member = (await rl.question("Member ID: ")).trim();
+        } finally {
+          rl.close();
+        }
+      }
+      if (!member) throw new Error("--member is required when input is not interactive.");
+      NameSchema.parse(member);
+      if (existing && existing.memberId !== member)
+        throw new Error("This root belongs to a different member.");
+      const projectId = options.project ?? existing?.workspaceId;
+      if (!projectId)
+        throw new Error(
+          "--project is required for a new connection; copy the command from the project settings."
+        );
+      NameSchema.parse(projectId);
+      const request = project.enrollment(
+        transport.url,
+        member,
+        projectId,
+        Boolean(options.reconnect)
+      );
+      const binding2 = await transport.enroll(request);
+      state.saveBinding(root, transport.url, request.credential, binding2);
+      project.completeEnrollment();
     }
-    if (loaded && (old !== definition.content || alive?.version !== version)) {
-      await exec2("launchctl", ["bootout", target]);
-      loaded = false;
+    const binding = state.binding(root);
+    const client = new HubClient(binding.serverUrl, 1e4, binding);
+    if (info.capabilities.includes("project-config")) {
+      try {
+        await applyProjectFile(project, await client.projectConfig());
+      } catch (error) {
+        if (!(options.tokenFile && error instanceof Error && "code" in error && ["SETUP_REQUIRED", "PROJECT_NOT_FOUND"].includes(String(error.code))))
+          throw error;
+      }
     }
-    if (!loaded) await bootstrapLaunchAgent(definition.path);
-    await exec2("launchctl", ["kickstart", target]);
-  } else {
-    await exec2("systemctl", ["--user", "daemon-reload"]);
-    await exec2("systemctl", ["--user", "enable", definition.id]);
-    await exec2("systemctl", [
-      "--user",
-      old !== definition.content || alive?.version !== version ? "restart" : "start",
-      definition.id
-    ]);
-  }
-  const deadline = Date.now() + 15e3;
-  while (Date.now() < deadline) {
-    if ((await runningDaemon(directory))?.version === version) return;
-    await setTimeout3(150);
+    const own = await metadata(root, binding.memberId);
+    if (own && !own.directory) throw new Error("Member path is not a directory.");
+    if (!own) await mkdir10(await safePath(root, binding.memberId));
+    await ensureLocalConfig(root);
+    const { token: _, ...visible } = binding;
+    return { ...visible, configRevision: project.cached()?.config.configRevision ?? null };
+  } finally {
+    lock.close();
   }
-  throw new Error(
-    "Background service did not start. Run teammy logs and check the user service manager."
-  );
-}
-async function wakeDaemon(directory, version) {
-  await ensureDaemon(directory, version);
-  await daemonRequest(directory, { method: "wake" });
 }
 
 // apps/client/output.ts
@@ -2417,15 +3659,94 @@ function json(value) {
   process.stdout.write(JSON.stringify(value, null, 2) + "\n");
 }
 
+// apps/client/runtime/diagnostics.ts
+import { resolve as resolve9 } from "node:path";
+import { realpath as realpath7 } from "node:fs/promises";
+async function runDiagnostics(command, options, version) {
+  const directory = await realpath7(options.directory).catch(() => resolve9(options.directory));
+  const root = await realpath7(options.root).catch(() => resolve9(options.root));
+  const log = new ClientLog(directory);
+  if (command === "logs") {
+    const entries = log.tail(options.all ? void 0 : root);
+    if (options.json) json(entries);
+    else if (!entries.length) result("\u6CA1\u6709\u8BCA\u65AD\u8BB0\u5F55");
+    else
+      for (const entry of entries)
+        process.stdout.write(
+          `${entry.at}  ${entry.event}${entry.detail ? "  " + entry.detail : ""}
+`
+        );
+    return 0;
+  }
+  const probe = await probeDaemon(directory);
+  let state;
+  let issue = probe.state === "unresponsive" || probe.state === "incompatible" ? probe.error : null;
+  let current = null;
+  let binding = null;
+  let control = null;
+  let maintenance = null;
+  try {
+    maintenance = readMaintenance(directory);
+  } catch (e) {
+    issue ??= diagnostic(e);
+  }
+  try {
+    state = new ClientState(directory, { readOnly: true });
+    const stored = state.binding(root);
+    if (stored) {
+      const { token: _, ...safe } = stored;
+      binding = safe;
+      const runtime = new RuntimeState(state);
+      current = { enabled: runtime.enabled(root), running: false, status: runtime.status(root) };
+      control = readControlStatus(state, root);
+      if (probe.state === "ready") {
+        try {
+          current = await daemonRequest(directory, { method: "status", root }, 1e3);
+        } catch (e) {
+          issue ??= diagnostic(e);
+        }
+      }
+    }
+  } catch (e) {
+    issue ??= diagnostic(e);
+  } finally {
+    state?.close();
+  }
+  if (options.json)
+    json({
+      ...current,
+      binding,
+      control,
+      daemon: probe.state === "ready" ? probe.info : null,
+      daemonState: probe.state,
+      installedVersion: version,
+      maintenance,
+      issue,
+      logPath: log.path
+    });
+  else {
+    const title = maintenance ? "\u540E\u53F0\u540C\u6B65\u5DF2\u6682\u505C" : issue ? "\u540C\u6B65\u9700\u8981\u5904\u7406" : !binding ? "\u5F53\u524D\u76EE\u5F55\u5C1A\u672A\u8FDE\u63A5" : !current?.enabled ? "\u540C\u6B65\u5DF2\u505C\u6B62" : !current.running ? "\u540E\u53F0\u540C\u6B65\u672A\u8FD0\u884C" : current.status?.issue ? "\u540C\u6B65\u7B49\u5F85\u5904\u7406" : "\u540C\u6B65\u5DF2\u5F00\u542F";
+    result(
+      title,
+      `\u5B89\u88C5 ${version} \xB7 \u8FD0\u884C ${probe.state === "ready" ? probe.info.version : "\u672A\u5C31\u7EEA"}`
+    );
+    if (issue || current?.status?.issue) result("\u5F85\u5904\u7406", issue ?? current.status.issue);
+    if (current?.status?.lastSuccessAt)
+      process.stdout.write(`  \u6700\u8FD1\u6210\u529F\uFF1A${current.status.lastSuccessAt}
+`);
+  }
+  return issue ? 1 : 0;
+}
+
 // 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: resolve10("workspaces") },
+  "state-dir": { type: "string", default: join18(homedir5(), ".teammy", "client") },
   json: { type: "boolean" },
   help: { type: "boolean", short: "h" }
 };
 async function runClientCommand(command, args, version) {
-  const { values } = parseArgs2({
+  const { values } = parseArgs3({
     args,
     options: {
       ...locationOptions,
@@ -2445,54 +3766,16 @@ async function runClientCommand(command, args, version) {
     );
     return 0;
   }
+  if (command === "logs" || command === "status")
+    return runDiagnostics(
+      command,
+      { root: values.root, directory: values["state-dir"], json: values.json, all: values.all },
+      version
+    );
   const root = await workspacePath(values.root), directory = await stateLocation(root, values["state-dir"]);
+  await prepareClient(directory, version, { resume: !values["no-start"] });
   const state = new ClientState(directory), log = new ClientLog(directory), runtime = new RuntimeState(state);
   try {
-    if (command === "logs") {
-      const entries = log.tail(values.all ? void 0 : root);
-      if (values.json) json(entries);
-      else if (!entries.length) result("\u6CA1\u6709\u8BCA\u65AD\u8BB0\u5F55");
-      else
-        for (const item of entries)
-          process.stdout.write(
-            `${item.at}  ${item.event}${item.detail ? "  " + item.detail : ""}
-`
-          );
-      return 0;
-    }
-    if (command === "status") {
-      const binding = state.binding(root);
-      if (!binding) throw new Error("This workspace is not connected. Run teammy connect first.");
-      const daemon = await runningDaemon(directory);
-      const current = daemon ? await daemonRequest(directory, { method: "status", root }) : { enabled: runtime.enabled(root), running: false, status: runtime.status(root) };
-      const { token: _, ...publicBinding } = binding;
-      if (values.json)
-        json({
-          ...current,
-          binding: publicBinding,
-          control: readControlStatus(state, root),
-          daemon,
-          logPath: log.path
-        });
-      else {
-        const status = current.status;
-        const title = !current.enabled ? "\u540C\u6B65\u5DF2\u505C\u6B62" : !current.running ? "\u540E\u53F0\u540C\u6B65\u672A\u8FD0\u884C" : status?.issue ? "\u540C\u6B65\u7B49\u5F85\u5904\u7406" : status?.pendingDownloads || !status?.lastSuccessAt ? "\u9996\u6B21\u540C\u6B65\u4E2D" : "\u540C\u6B65\u5DF2\u5F00\u542F";
-        result(
-          title,
-          new ClientProjectState(state, root).cached()?.config.projectName ?? binding.workspaceId
-        );
-        if (status?.issue) result("\u5F85\u5904\u7406", status.issue);
-        else if (status?.lastSuccessAt)
-          process.stdout.write(`  \u6700\u8FD1\u6210\u529F\uFF1A${status.lastSuccessAt}
-`);
-        if (status?.pendingFiles || status?.pendingDownloads)
-          process.stdout.write(
-            `  \u5F85\u4E0A\u4F20 ${status.pendingFiles} \xB7 \u5F85\u4E0B\u8F7D ${status.pendingDownloads}
-`
-          );
-      }
-      return 0;
-    }
     const existing = state.binding(root);
     const url = values.url ?? (values.reconnect ? existing?.serverUrl : void 0);
     if (!url) throw new Error("--url is required.");
@@ -2523,12 +3806,16 @@ async function runClientCommand(command, args, version) {
       tokenFile: values["token-file"],
       reconnect: values.reconnect
     });
+    const collection = await setupSessions(state, root, directory, { enable: true });
+    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\u5BF9\u8BDD\u91C7\u96C6 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));
@@ -2539,18 +3826,18 @@ async function runClientCommand(command, args, version) {
 }
 
 // apps/client/files/synchronizer.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } 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 mkdir12 } from "node:fs/promises";
+import { join as join20, sep as sep5 } 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 randomUUID6 } from "node:crypto";
+import { link, mkdir as mkdir11, open as open4, readFile as readFile6, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname10, join as join19, resolve as resolve11 } 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,14 +3853,14 @@ var BlobIntegrityError = class extends Error {
 var LocalBlobStore = class {
   root;
   constructor(root) {
-    this.root = resolve6(root);
+    this.root = resolve11(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 });
-    const temporary = `${target}.${randomUUID5()}.tmp`;
+    await mkdir11(dirname10(target), { recursive: true, mode: 448 });
+    const temporary = `${target}.${randomUUID6()}.tmp`;
     const file = await open4(temporary, "wx", 384);
     try {
       try {
@@ -2589,7 +3876,7 @@ var LocalBlobStore = class {
         await this.get(sha256);
       }
       if (process.platform !== "win32") {
-        let directory = dirname6(target);
+        let directory = dirname10(target);
         for (; ; ) {
           const handle = await open4(directory, "r");
           try {
@@ -2597,8 +3884,8 @@ var LocalBlobStore = class {
           } finally {
             await handle.close();
           }
-          if (directory === dirname6(this.root)) break;
-          directory = dirname6(directory);
+          if (directory === dirname10(this.root)) break;
+          directory = dirname10(directory);
         }
       }
     } finally {
@@ -2610,7 +3897,7 @@ var LocalBlobStore = class {
     const target = this.pathFor(sha256);
     let content;
     try {
-      content = await readFile3(target);
+      content = await readFile6(target);
     } catch (error) {
       if (hasCode(error, "ENOENT")) return void 0;
       throw error;
@@ -2620,7 +3907,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 join19(this.root, "sha256", sha256.slice(0, 2), sha256);
   }
 };
 
@@ -2638,14 +3925,17 @@ var PublicationQueue = class {
     const pending = this.state.pending(root);
     if (!pending || pending.retryAt > now) return false;
     try {
+      let end = pending.nextIndex, bytes = 0;
+      while (end < pending.batch.changes.length && end - pending.nextIndex < MAX_BATCH_FILES && bytes < 20 * 1024 * 1024) {
+        const change = pending.batch.changes[end++];
+        if (change.kind === "upsert") bytes += change.size;
+      }
       const hashes = [
         ...new Set(
-          pending.batch.changes.flatMap(
-            (change) => change.kind === "upsert" ? [change.sha256] : []
-          )
+          pending.batch.changes.slice(pending.nextIndex, end).flatMap((change) => change.kind === "upsert" ? [change.sha256] : [])
         )
       ];
-      const { missing: missing2 } = await this.transport.missingBlobs(hashes);
+      const { missing: missing2 } = hashes.length ? await this.transport.missingBlobs(hashes) : { missing: [] };
       for (const hash2 of missing2) {
         if (!hashes.includes(hash2)) throw new Error("Server requested unrelated content.");
         const content = await this.blobs.get(hash2);
@@ -2654,9 +3944,12 @@ var PublicationQueue = class {
         if (result2.sha256 !== hash2 || result2.size !== content.byteLength)
           throw new Error("Server acknowledged different content.");
       }
+      this.state.uploaded(root, pending.batch.operationId, end);
+      if (end < pending.batch.changes.length) return false;
       this.state.acknowledge(root, await this.transport.commitFiles(pending.batch));
       return true;
     } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") throw error;
       const blocked = error instanceof HubRequestError && error.status >= 400 && error.status < 500 && ![408, 429].includes(error.status);
       this.state.postpone(
         root,
@@ -2680,17 +3973,17 @@ 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(join20(stateDirectory, "blobs"));
     this.projectScope = options.scope === "project";
     this.owner = this.projectScope ? PROJECT_FILE_OWNER : binding.memberId;
     this.publication = new FilePublicationState(state.db, options.scope);
     this.queue = new PublicationQueue(this.publication, this.blobs, {
       missingBlobs: (hashes) => this.client.missingBlobs(hashes),
       uploadBlob: (hash2, bytes) => this.client.uploadBlob(hash2, bytes),
-      commitFiles: (batch) => this.projectScope ? this.client.commitSharedFiles(batch, this.sharedConfig.revision) : this.client.commitFiles(batch)
+      commitFiles: (batch) => this.projectScope ? this.client.commitSharedFiles(batch, batch.configRevision) : 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 : join20(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();
@@ -2720,14 +4013,16 @@ var FileSynchronizer = class _FileSynchronizer {
   watchIssues = [];
   lastScan = -Infinity;
   busy = false;
+  capable = false;
   stopped = false;
   abort = new AbortController();
   async checkCapabilities() {
     const info = await this.client.serverInfo();
-    if (!["identity", "blobs", "file-revisions"].every(
+    if (!["identity", "blobs", "file-revisions", "atomic-file-publications"].every(
       (capability) => info.capabilities.includes(capability)
     ))
-      throw new Error("Server does not support file synchronization.");
+      throw new Error("Upgrade the server to support complete directory publications.");
+    this.capable = true;
   }
   setSettleMs(value) {
     if (!Number.isSafeInteger(value) || value < 0 || value > 864e5)
@@ -2755,6 +4050,7 @@ var FileSynchronizer = class _FileSynchronizer {
     };
     try {
       try {
+        if (!this.capable) await this.checkCapabilities();
         if (this.projectScope) {
           try {
             this.sharedConfig = await this.client.sharedFilesConfig();
@@ -2814,11 +4110,10 @@ var FileSynchronizer = class _FileSynchronizer {
         }
         const blocked = await this.refreshDirty(report.issues);
         await this.audit(report.issues);
-        report.published = await this.queue.flush(this.root, this.clock());
         if (!this.publication.pending(this.root) && !this.stopped) {
           await this.stage(blocked, report.issues, settleMs);
-          report.published = await this.queue.flush(this.root, this.clock()) || report.published;
         }
+        report.published = await this.queue.flush(this.root, this.clock());
       } catch (error) {
         report.issues.push(`publish: ${message(error)}`);
       }
@@ -2862,7 +4157,7 @@ var FileSynchronizer = class _FileSynchronizer {
         throw new Error("Manifest changed version during pagination.");
       revision = page.revision;
       files.push(...page.files);
-      if (page.nextCursor === null) return { revision, files };
+      if (page.nextCursor === null) return { revision, complete: page.complete, files };
       if (page.nextCursor === after || files.length > 1e5)
         throw new Error("Manifest pagination did not make bounded progress.");
       after = page.nextCursor;
@@ -2889,10 +4184,12 @@ var FileSynchronizer = class _FileSynchronizer {
       }
     }
     const ownerPath = this.projectScope ? this.root : await safePath(this.root, this.owner);
-    await mkdir9(ownerPath).catch((error) => {
+    await mkdir12(ownerPath).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
-    this.publication.initializePublication(this.root, manifest.revision, manifest.files);
+    this.publication.initializePublication(this.root, manifest.revision, manifest.files, {
+      complete: manifest.complete
+    });
   }
   listen() {
     if (this.options.watch === false || this.watcher || this.stopped) return;
@@ -2902,7 +4199,7 @@ var FileSynchronizer = class _FileSynchronizer {
           this.lastScan = -Infinity;
           return;
         }
-        const path = filename.toString().split(sep4).join("/");
+        const path = filename.toString().split(sep5).join("/");
         if (!this.excludes(path)) this.index.event(path, this.clock());
       });
       this.watcher.on("error", (error) => {
@@ -2926,6 +4223,7 @@ var FileSynchronizer = class _FileSynchronizer {
       }
     }
     issues.push(...scan.issues);
+    return scan.complete;
   }
   async refreshDirty(issues) {
     const blocked = /* @__PURE__ */ new Set();
@@ -2966,73 +4264,80 @@ var FileSynchronizer = class _FileSynchronizer {
     }
   }
   async stage(blocked, issues, settleMs) {
-    const ready = this.index.index(true).filter(
-      (row) => !this.excludes(row.path) && !blocked.has(row.path) && !row.eventPending && this.clock() - row.observedAt >= settleMs
-    );
-    if (!ready.length) return;
+    const publication = this.publication.publication(this.root);
+    if (publication.complete && !this.index.index(true).some((row) => !this.excludes(row.path)))
+      return;
+    if (!await this.reconcile("", issues)) return;
+    const before = this.index.index().filter((row) => !this.excludes(row.path));
+    const ready = before.filter((row) => row.dirty);
+    if (ready.some(
+      (row) => blocked.has(row.path) || row.eventPending || this.clock() - row.observedAt < settleMs
+    ))
+      return;
     const baseline = this.publication.ownerFiles(this.root);
     const planned = new Map(baseline);
     const changes = [];
     const snapshots = [];
-    let bytes = 0;
     ready.sort((a, b) => Number(a.signature !== null) - Number(b.signature !== null));
     for (const row of ready) {
-      if (this.stopped || changes.length >= MAX_BATCH_FILES || bytes > 20 * 1024 * 1024) break;
+      if (this.stopped) return;
       try {
         if (row.signature === null) {
-          const current = await metadata(this.ownRoot, row.path);
-          if (current && !current.directory) {
-            this.index.event(row.path, this.clock());
-            continue;
-          }
           if (baseline.has(row.path) && row.seenLocal) {
             changes.push({ kind: "delete", path: row.path });
             planned.delete(row.path);
-          } else {
-            this.index.clean(row.path, row.generation, null, this.clock());
-            continue;
           }
           snapshots.push({ path: row.path, generation: row.generation, hash: null });
           continue;
         }
-        const key = row.path.toLowerCase();
-        const collision = [...planned.keys()].some(
-          (path) => path !== row.path && (path.toLowerCase() === key || path.toLowerCase().startsWith(`${key}/`) || key.startsWith(`${path.toLowerCase()}/`))
-        );
-        if (collision) {
-          issues.push(
-            `${row.path}: conflicts with a preserved server path; rename the local file to publish it.`
-          );
-          continue;
-        }
         const local = await readStable(this.ownRoot, row.path);
-        bytes += local.bytes.length;
         if (local.signature !== row.signature || this.index.get(row.path)?.generation !== row.generation) {
           this.index.event(row.path, this.clock());
-          continue;
+          return;
         }
-        if (baseline.get(row.path)?.sha256 === local.sha256) {
-          this.index.clean(row.path, row.generation, local.sha256, this.clock());
-          continue;
+        if (baseline.get(row.path)?.sha256 !== local.sha256) {
+          const ref = await this.blobs.put(local.bytes);
+          changes.push({ kind: "upsert", path: row.path, ...ref });
+          planned.set(row.path, ref);
         }
-        const ref = await this.blobs.put(local.bytes);
-        changes.push({ kind: "upsert", path: row.path, ...ref });
-        planned.set(row.path, ref);
         snapshots.push({ path: row.path, generation: row.generation, hash: local.sha256 });
       } catch (error) {
         this.index.event(row.path, this.clock());
         issues.push(`${row.path}: ${message(error)}`);
+        return;
       }
     }
-    if (!changes.length) return;
-    const rootStat = await lstat4(this.ownRoot);
-    if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
-      throw new Error("Author directory disappeared before publication.");
-    this.publication.enqueue(this.root, {
-      operationId: randomUUID6(),
-      parentRevision: this.publication.publication(this.root).revision,
-      changes
-    });
+    const keys = /* @__PURE__ */ new Set();
+    for (const path of planned.keys()) {
+      const key = path.toLowerCase();
+      if (keys.has(key)) {
+        issues.push(`${path}: conflicts with a preserved server path.`);
+        return;
+      }
+      keys.add(key);
+    }
+    for (const key of keys) {
+      const parts = key.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        if (keys.has(parts.slice(0, i).join("/"))) {
+          issues.push(`${key}: a file conflicts with its parent directory.`);
+          return;
+        }
+      }
+    }
+    if (!await this.reconcile("", issues)) return;
+    const after = this.index.index().filter((row) => !this.excludes(row.path));
+    const generations = new Map(before.map((row) => [row.path, row.generation]));
+    if (after.length !== before.length || after.some((row) => row.eventPending || generations.get(row.path) !== row.generation))
+      return;
+    if (changes.length || !publication.complete) {
+      this.publication.enqueue(this.root, {
+        operationId: randomUUID7(),
+        parentRevision: publication.revision,
+        changes,
+        ...this.projectScope ? { configRevision: this.sharedConfig.revision } : {}
+      });
+    }
     for (const snapshot of snapshots)
       this.index.clean(snapshot.path, snapshot.generation, snapshot.hash, this.clock());
   }
@@ -3075,7 +4380,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 mkdir12(ownerRoot).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
     const ownerStat = await lstat4(ownerRoot);
@@ -3130,24 +4435,27 @@ function message(error) {
 }
 
 // apps/client/sessions/synchronizer.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
-import { join as join15 } from "node:path";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { join as join23 } from "node:path";
+import { performance as performance3 } from "node:perf_hooks";
 
 // 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 realpath8, readdir as readdir2 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname12, relative as relative5, isAbsolute as isAbsolute5, sep as sep6, join as join21 } 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 { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { createHash as createHash11 } from "node:crypto";
+import { basename as basename3, dirname as dirname11, resolve as resolve12 } from "node:path";
+import { DatabaseSync as DatabaseSync6 } from "node:sqlite";
 import { fileURLToPath } from "node:url";
 function fields(bytes) {
   const data = Buffer.from(bytes);
@@ -3184,34 +4492,31 @@ function fields(bytes) {
   }
   return result2;
 }
-function readCursor(path, projectDir) {
-  const db = new DatabaseSync2(path, { readOnly: true });
+function readCursor(path, projectDir, checkCwd) {
+  const db = new DatabaseSync6(path, { readOnly: true });
   try {
     db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=100; BEGIN");
     if (db.prepare("PRAGMA user_version").get()?.user_version !== 1)
       throw new Error("Unsupported Cursor CLI store version (expected 1).");
-    const row = db.prepare("SELECT value FROM meta WHERE key='0' AND length(value)<=2097152").get();
+    const row = db.prepare("SELECT value FROM meta WHERE key='0'").get();
     const hex = row?.value;
     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 !== basename3(dirname11(path)) || meta.subagentInfo != null)
       throw new Error("Invalid or delegated Cursor session identity.");
-    let budget = 64 * 1024 * 1024;
     const blob = (id) => {
       if (!/^[a-f0-9]{64}$/.test(id)) throw new Error("Invalid Cursor blob reference.");
-      const value = db.prepare("SELECT data FROM blobs WHERE id=? AND length(data)<=?").get(id, budget)?.data;
-      if (!(value instanceof Uint8Array))
-        throw new Error("Cursor history missing or exceeds 64 MiB.");
+      const value = db.prepare("SELECT data FROM blobs WHERE id=?").get(id)?.data;
+      if (!(value instanceof Uint8Array)) throw new Error("Cursor history is missing.");
       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 = basename3(dirname11(dirname11(path)));
+    const md5 = (cwd2) => createHash11("md5").update(resolve12(cwd2)).digest("hex");
     let cwd = md5(projectDir) === bucket ? projectDir : void 0;
     for (const uri of root.get(9) ?? []) {
       try {
@@ -3224,11 +4529,11 @@ 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) ?? []);
-    refs.push(...root.get(1) ?? []);
-    if (refs.length > 5e4) throw new Error("Cursor history exceeds 50000 messages.");
+      for (const ref of fields(blob(archive.toString("hex"))).get(1) ?? []) refs.push(ref);
+    for (const ref of root.get(1) ?? []) refs.push(ref);
     const messages = [];
     const counts = /* @__PURE__ */ new Map();
     for (const ref of refs) {
@@ -3246,7 +4551,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 +4575,14 @@ function readCursor(path, projectDir) {
 }
 
 // apps/client/sessions/source.ts
-var MAX_SOURCE_BYTES = 64 * 1024 * 1024;
+function within(project, cwd) {
+  const rel = relative5(project, cwd);
+  return rel !== ".." && !rel.startsWith(`..${sep6}`) && !isAbsolute5(rel);
+}
+var cursorEncoded = (cwd) => cwd.replace(/^[/\\]+/, "").replace(/[/\\]/g, "-");
+var cursorDatabase = (path) => basename4(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 +4603,142 @@ async function sourceSignature(path, agent) {
   }
   return JSON.stringify(signatures);
 }
+async function cursorScope(path, project) {
+  let container = dirname12(path);
+  while (basename4(container) !== "agent-transcripts" && dirname12(container) !== container)
+    container = dirname12(container);
+  if (basename4(container) !== "agent-transcripts")
+    throw new Error("Cursor transcript workspace cannot be verified.");
+  const encoded = basename4(dirname12(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(join21(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 realpath8(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: basename4(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 realpath8(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 realpath8(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 { performance as performance2 } from "node:perf_hooks";
+import { join as join22 } from "node:path";
+
+// apps/client/sessions/work-queue.ts
+var SessionWorkQueue = class {
+  active = 0;
+  waiting = [];
+  async run(action) {
+    if (this.active >= 2) await new Promise((resolve16) => this.waiting.push(resolve16));
+    else this.active++;
+    try {
+      return await action();
+    } finally {
+      const next = this.waiting.shift();
+      if (next) next();
+      else this.active--;
+    }
+  }
+};
+var sessionWorkQueue = new SessionWorkQueue();
+var publications = /* @__PURE__ */ new Map();
+async function serializeSession(identity, action) {
+  const previous = publications.get(identity) ?? Promise.resolve();
+  const pending = previous.catch(() => {
+  }).then(action);
+  publications.set(identity, pending);
+  try {
+    return await pending;
+  } finally {
+    if (publications.get(identity) === pending) publications.delete(identity);
+  }
+}
+
+// apps/client/sessions/discovery.ts
 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 = join22(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;
     }
@@ -3358,10 +4750,12 @@ var SessionDiscovery = class {
   }
   state;
   scans = /* @__PURE__ */ new Map();
+  pending = false;
   async cycle() {
+    this.pending = false;
     const issues = [];
     let entries = 500;
-    let reads = 5;
+    const started = performance2.now();
     const configs = this.state.directories();
     for (const [directory, scan] of this.scans) {
       if (!configs.some((config) => config.directory === directory)) {
@@ -3377,7 +4771,7 @@ var SessionDiscovery = class {
       }
       if (scan.nextAt > Date.now()) continue;
       try {
-        while (entries > 0 && reads > 0) {
+        while (entries > 0 && performance2.now() - started < 1e3) {
           entries--;
           const entry = await scan.iterator.next();
           if (entry.done) {
@@ -3390,35 +4784,42 @@ var SessionDiscovery = class {
           const signature2 = await sourceSignature(path, config.agent);
           const db = this.state.state.db;
           if (db.prepare(
-            "SELECT 1 FROM session_discovery_cache WHERE root=? AND path=? AND signature=?"
-          ).get(this.state.root, path, signature2))
+            "SELECT 1 FROM session_discovery_cache WHERE root=? AND path=? AND signature=? AND parser_version=?"
+          ).get(this.state.root, path, signature2, parserVersions[config.agent]))
             continue;
-          reads--;
           try {
-            const result2 = await readSource(config.agent, path, config.projectDir);
-            if (result2.incomplete) continue;
+            const result2 = await sessionWorkQueue.run(
+              () => readSource(config.agent, path, config.projectDir)
+            );
+            if (!result2.snapshot.messages.length) continue;
             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);
+            "INSERT INTO session_discovery_cache(root,path,signature,parser_version) VALUES (?,?,?,?) ON CONFLICT(root,path) DO UPDATE SET signature=excluded.signature,parser_version=excluded.parser_version"
+          ).run(this.state.root, path, signature2, parserVersions[config.agent]);
         }
       } 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;
       }
     }
+    this.pending = [...this.scans.values()].some((scan) => scan.nextAt <= Date.now());
     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);
   }
@@ -3429,10 +4830,11 @@ var SessionSynchronizer = class {
   constructor(state, root, directory, signal) {
     this.root = root;
     this.directory = directory;
+    this.signal = signal;
     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(join23(directory, "blobs"));
     this.index = new SessionState(state, root);
     this.discovery = new SessionDiscovery(this.index);
   }
@@ -3443,11 +4845,29 @@ var SessionSynchronizer = class {
   blobs;
   discovery;
   capable = false;
+  passAt;
+  signal;
   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 sources = this.index.sources(void 0, 200);
+    const report = {
+      published: 0,
+      checked: 0,
+      pending: false,
+      issues: [],
+      warnings: []
+    };
+    report.issues.push(
+      ...await consumeHints(
+        this.directory,
+        this.root,
+        this.index,
+        () => this.discovery.refresh()
+      )
+    );
+    report.warnings.push(...await this.discovery.cycle());
+    this.passAt ??= Date.now();
+    const candidates2 = this.index.sources(void 0, 201, this.passAt);
+    const sources = candidates2.slice(0, 200);
+    report.pending = candidates2.length > sources.length || this.discovery.pending;
     if (sources.length && !this.capable) {
       const info = await this.client.serverInfo();
       if (!["blobs", "session-revisions"].every(
@@ -3456,48 +4876,88 @@ var SessionSynchronizer = class {
         throw new Error("Server does not support session publication. Upgrade the server first.");
       this.capable = true;
     }
-    let reads = 5;
-    let uploads = 5;
-    for (const source of sources) {
-      if (reads <= 0 || uploads <= 0 || report.checked >= 200) break;
-      report.checked++;
-      this.index.checked(source.path, source.lastError);
-      try {
-        if (source.pending) {
-          if (source.retryAt > Date.now()) {
-            if (source.lastError)
-              report.issues.push(`${source.path}: ${source.lastError} (retry deferred)`);
-            continue;
-          }
-          uploads--;
-          await this.flush(source);
-          report.published++;
-          continue;
-        }
-        const signature2 = await sourceSignature(source.path, source.agent);
-        if (signature2 === source.signature && Date.now() - source.verifiedAt < 864e5) {
-          this.index.checked(source.path);
-          continue;
+    let offset = 0;
+    let handled = 0;
+    const started = performance3.now();
+    await Promise.all(
+      Array.from({ length: 2 }, async () => {
+        for (; ; ) {
+          if (performance3.now() - started >= 1e3) break;
+          const source = sources[offset++];
+          if (!source || this.signal?.aborted) break;
+          await sessionWorkQueue.run(() => this.collect(source.path, report));
+          handled++;
         }
-        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;
+      })
+    );
+    report.pending ||= handled < candidates2.length;
+    if (handled >= candidates2.length) this.passAt = void 0;
+    return report;
+  }
+  lock(key, action) {
+    return serializeSession(JSON.stringify([this.client.url, this.root, key]), action);
+  }
+  async collect(path, report) {
+    if (this.signal?.aborted) return;
+    let source = this.index.get(path);
+    report.checked++;
+    this.index.checked(source.path, source.lastError);
+    try {
+      if (source.pending) {
+        if (source.pendingPath !== source.path) return;
+        if (source.retryAt > Date.now()) {
+          if (source.lastError)
+            report.issues.push(`${source.path}: ${source.lastError} (retry deferred)`);
+          return;
         }
-        const key = sessionKey(source.agent, observed.snapshot.nativeId);
-        if (source.key && source.key !== key)
-          throw new Error(
-            "Native session identity changed at this path; register the new source explicitly."
+        await this.lock(source.key, async () => {
+          const current = this.index.get(source.path);
+          if (!current.pending || current.pendingPath !== current.path || current.retryAt > Date.now())
+            return;
+          await this.flush(current);
+          report.published++;
+        });
+        return;
+      }
+      const signature2 = await sourceSignature(source.path, source.agent);
+      if (source.parserVersion === parserVersions[source.agent] && signature2 === source.signature && Date.now() - source.verifiedAt < 864e5) {
+        this.index.checked(source.path);
+        return;
+      }
+      const observed = await readSource(source.agent, source.path, source.projectDir);
+      if (!observed.snapshot.messages.length) {
+        this.index.checked(source.path);
+        return;
+      }
+      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.`
           );
-        const bytes = Buffer.from(JSON.stringify(observed.snapshot));
-        if (bytes.length > MAX_BLOB_BYTES)
-          throw new Error("Normalized session exceeds the 10 MiB snapshot limit.");
-        const blob = await this.blobs.put(bytes);
+          return;
+        }
+      }
+      const key = sessionKey(source.agent, observed.snapshot.nativeId);
+      if (source.key && source.key !== key)
+        throw new Error(
+          "Native session identity changed at this path; register the new source explicitly."
+        );
+      const bytes = Buffer.from(JSON.stringify(observed.snapshot));
+      if (bytes.length > MAX_BLOB_BYTES)
+        throw new Error(
+          `Normalized session exceeds the ${MAX_BLOB_BYTES / 1024 / 1024} MiB snapshot limit.`
+        );
+      const blob = await this.blobs.put(bytes);
+      await this.lock(key, async () => {
+        source = this.index.get(source.path);
         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,27 +4970,33 @@ 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) return;
+        if (source.agent === "cursor" && source.selectedPath && cursorDatabase(source.selectedPath) && !cursorDatabase(source.path)) {
+          this.index.observed(source.path, observed.signature);
+          return;
         }
         if (blob.sha256 === source.hash) {
           this.index.acknowledge(source.path, revision, blob.sha256, observed.signature);
-          continue;
+          return;
         }
         this.index.stage(
           source.path,
-          { operationId: randomUUID7(), sessionKey: key, parentRevision: revision, blob },
+          { operationId: randomUUID8(), sessionKey: key, parentRevision: revision, blob },
           observed.signature
         );
-        uploads--;
         await this.flush(this.index.get(source.path));
         report.published++;
-      } catch (error) {
-        const message2 = error instanceof Error ? error.message : "Session synchronization failed.";
-        this.index.checked(source.path, message2);
-        report.issues.push(`${source.path}: ${message2}`);
-      }
+      });
+    } catch (error) {
+      if (this.signal?.aborted) return;
+      const message2 = error instanceof Error ? error.message : "Session synchronization failed.";
+      this.index.checked(source.path, message2);
+      report.issues.push(`${source.path}: ${message2}`);
     }
-    return report;
   }
   async flush(source) {
     const request = source.pending;
@@ -3552,9 +5018,11 @@ var SessionSynchronizer = class {
         source.path,
         result2.revision,
         request.blob.sha256,
-        source.pendingSignature
+        source.pendingSignature,
+        source.pendingParserVersion
       );
     } catch (error) {
+      if (this.signal?.aborted) throw error;
       const blocked = error instanceof HubRequestError && error.status >= 400 && error.status < 500 && ![408, 429].includes(error.status);
       this.index.postpone(
         source,
@@ -3670,7 +5138,13 @@ var SyncJob = class {
       pendingPublication: false,
       issues: []
     };
-    let sessions = { published: 0, checked: 0, issues: [] };
+    let sessions = {
+      published: 0,
+      checked: 0,
+      pending: false,
+      issues: [],
+      warnings: []
+    };
     try {
       await verifyWorkspace(this.state, this.root);
       if (!this.controlStarted) {
@@ -3680,6 +5154,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,11 +5206,20 @@ 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);
+    const uploadReady = [this.state, new FilePublicationState(this.state.db, "project")].some(
+      (state) => {
+        const pending = state.pending(this.root);
+        return pending && pending.retryAt <= now;
+      }
+    );
+    this.nextAt = now + (sessions.pending ? 1e3 : 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 : uploadReady ? 1e3 : this.intervalMs);
     this.runtime.save(this.root, {
       state: this.stopped ? "stopped" : issue ? "waiting" : "idle",
       checkedAt,
-      lastSuccessAt: !issue && !pendingDownloads ? checkedAt : prior?.lastSuccessAt ?? null,
+      lastSuccessAt: !issue && !pendingDownloads && !report.pendingPublication ? checkedAt : prior?.lastSuccessAt ?? null,
       pendingFiles,
       pendingDownloads,
       issue: issue || null
@@ -3780,7 +5265,7 @@ Use teammy status or teammy logs for diagnostics.
 `;
 async function runSyncCommand(args, version) {
   const action = ["on", "off"].includes(args[0] ?? "") ? args[0] : void 0;
-  const { values } = parseArgs3({
+  const { values } = parseArgs4({
     args: action ? args.slice(1) : args,
     options: {
       ...locationOptions,
@@ -3820,16 +5305,29 @@ async function runSyncCommand(args, version) {
       "Timing and recovery overrides require --once or --foreground. Manage normal sync timing in the dashboard."
     );
   const root = await workspacePath(values.root), directory = await stateLocation(root, values["state-dir"]);
+  await prepareClient(directory, version, {
+    resume: action === "on",
+    ...action ? { intent: { root, enabled: action === "on" } } : {}
+  });
   const state = new ClientState(directory), runtime = new RuntimeState(state), log = new ClientLog(directory);
   try {
     if (!state.binding(root)) throw new Error("Connect this workspace first.");
     if (action) {
       if (action === "on") await verifyWorkspace(state, root);
       runtime.enable(root, action === "on");
-      if (action === "on") await wakeDaemon(directory, version);
-      else {
-        if (await runningDaemon(directory))
-          await daemonRequest(directory, { method: "wake" }, 45e3);
+      if (action === "on") {
+        const hooks = await setupSessions(state, root, directory);
+        for (const issue of hooks.issues) log.write("sessions.setup.failed", root, issue);
+        await wakeDaemon(directory, version);
+      } else {
+        try {
+          if (await runningDaemon(directory))
+            await daemonRequest(directory, { method: "wake" }, 45e3);
+        } catch (error) {
+          log.write("daemon.recovering", root, diagnostic(error));
+          await stopDaemon(directory);
+          if (runtime.roots().length) await wakeDaemon(directory, version);
+        }
         const status = runtime.status(root);
         if (status) runtime.save(root, { ...status, state: "stopped" });
         log.write("sync.off_requested", root);
@@ -3890,10 +5388,60 @@ async function runSyncCommand(args, version) {
   }
 }
 
+// apps/client/maintenance-command.ts
+import { parseArgs as parseArgs5 } from "node:util";
+import { homedir as homedir6 } from "node:os";
+import { join as join24, resolve as resolve13 } from "node:path";
+import { mkdir as mkdir13, realpath as realpath9 } from "node:fs/promises";
+async function runMaintenanceCommand(command, args, version) {
+  const { values } = parseArgs5({
+    args,
+    options: {
+      "state-dir": { type: "string", default: join24(homedir6(), ".teammy", "client") },
+      stop: { type: "boolean" },
+      json: { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    process.stdout.write(
+      `Usage: teammy ${command}${command === "repair" ? " [--stop]" : ""} [--state-dir DIR] [--json]
+
+${command === "repair" ? "Repair this local client and preserve project on/off settings. --stop pauses the entire background service without opening the business database." : "Stop and unregister this local background service and remove its project hooks. Keeps workspaces, bindings and history; then run npm uninstall -g @teammy/cli."}
+`
+    );
+    return 0;
+  }
+  if (command === "uninstall" && values.stop) throw new Error("--stop is a repair option.");
+  await mkdir13(resolve13(values["state-dir"]), { recursive: true, mode: 448 });
+  const directory = await realpath9(values["state-dir"]);
+  const report = await prepareClient(directory, version, {
+    force: true,
+    resume: true,
+    stop: Boolean(values.stop),
+    uninstall: command === "uninstall"
+  });
+  if (values.json) json(report);
+  else {
+    result(
+      command === "uninstall" ? "\u672C\u673A\u63A5\u5165\u5DF2\u5378\u8F7D" : values.stop ? "\u540E\u53F0\u540C\u6B65\u5DF2\u6682\u505C" : "\u5BA2\u6237\u7AEF\u5DF2\u5C31\u7EEA",
+      version
+    );
+    if (!values.stop && command !== "uninstall")
+      result(`\u5DF2\u6062\u590D ${report.enabled} \u4E2A\u9879\u76EE\uFF1B${report.stopped} \u4E2A\u9879\u76EE\u4FDD\u6301\u505C\u6B62`);
+    if (report.issues.length) result(`${report.issues.length} \u9879\u914D\u7F6E\u9700\u8981\u5904\u7406`, "teammy logs --all");
+    if (command === "uninstall") result("\u5B89\u88C5\u5305\u53EF\u79FB\u9664", "npm uninstall -g @teammy/cli");
+  }
+  return report.issues.length ? 1 : 0;
+}
+
 // apps/client/runtime/daemon.ts
 import { createServer } from "node:net";
 import { chmod as chmod2, unlink as unlink4 } from "node:fs/promises";
+import { join as join25 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 async function runDaemon(directory, version) {
+  await prepareClient(directory, version, { daemonStartup: true });
   const lock = acquireRootLock("daemon:" + directory, directory), state = new ClientState(directory), runtime = new RuntimeState(state), log = new ClientLog(directory);
   const jobs = /* @__PURE__ */ new Map(), retry = /* @__PURE__ */ new Map();
   let closing = false, serial = Promise.resolve();
@@ -3958,7 +5506,15 @@ async function runDaemon(directory, version) {
       void (async () => {
         const input = RequestSchema.parse(JSON.parse(body.split("\n")[0]));
         if (closing) throw new Error("Background service is stopping.");
-        if (input.method === "ping") return { pid: process.pid, version };
+        if (input.method === "ping")
+          return {
+            pid: process.pid,
+            version,
+            protocol: CONTROL_PROTOCOL,
+            executable: process.execPath,
+            entry: resolve14(process.argv[1]),
+            schema: clientSchemaVersion
+          };
         if (input.method === "wake") {
           retry.clear();
           await reconcile();
@@ -3996,8 +5552,8 @@ async function runDaemon(directory, version) {
   let timer;
   let resolveStop = () => {
   };
-  const stopped = new Promise((resolve9) => {
-    resolveStop = resolve9;
+  const stopped = new Promise((resolve16) => {
+    resolveStop = resolve16;
   });
   const stop = () => {
     closing = true;
@@ -4008,14 +5564,15 @@ 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((resolve16, reject) => {
       server.once("error", reject);
       server.listen(socketPath(directory), () => {
         server.off("error", reject);
-        resolve9();
+        resolve16();
       });
     });
     await chmod2(socketPath(directory), 384);
+    writePrivateJson(join25(directory, "runtime", "daemon.json"), { pid: process.pid, directory });
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
     log.write("daemon.started", void 0, `version=${version}`);
@@ -4035,9 +5592,11 @@ 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((resolve16) => server.close(() => resolve16()));
     await unlink4(socketPath(directory)).catch(() => {
     });
+    await unlink4(join25(directory, "runtime", "daemon.json")).catch(() => {
+    });
     log.write("daemon.stopped");
     state.close();
     lock.close();
@@ -4054,10 +5613,12 @@ Usage:
   teammy server-info --url URL      Check server connection and protocol capabilities
   teammy server-info --help         Show connection options
   teammy connect --url URL --project ID [--member ID | --token-file FILE] [--reconnect] [--root DIR] [--state-dir DIR]
+  teammy repair [--stop]            Repair or pause this local background client
+  teammy uninstall                  Remove local service and hooks; keep user data
   teammy status [--root DIR] [--state-dir DIR]
   teammy sync on | off [--root DIR]
   teammy logs [--root DIR]          Show recent diagnostic events
-  teammy session --help              Collect, read and search Agent sessions
+  teammy session --help            Collect, read and search the conversation library (\u5BF9\u8BDD\u5E93)
 
 Root defaults to ./workspaces; local state defaults to ~/.teammy/client.
 connect starts background sync; enabled projects resume after login.
@@ -4089,12 +5650,12 @@ async function runCli(args, version) {
     return 1;
   }
   if (command === "_daemon") {
-    const { values } = parseArgs4({
+    const { values } = parseArgs6({
       args: args.slice(1),
       options: { "state-dir": { type: "string" } }
     });
     if (!values["state-dir"]) throw new Error("Missing daemon state directory.");
-    const directory = resolve8(values["state-dir"]);
+    const directory = resolve15(values["state-dir"]);
     try {
       await runDaemon(directory, version);
       return 0;
@@ -4103,9 +5664,17 @@ async function runCli(args, version) {
       return 1;
     }
   }
+  if (command === "repair" || command === "uninstall") {
+    try {
+      return await runMaintenanceCommand(command, args.slice(1), version);
+    } catch (error) {
+      process.stderr.write(diagnostic(error) + "\n");
+      return 1;
+    }
+  }
   if (command === "session") {
     try {
-      return await runSessionCommand(args.slice(1));
+      return await runSessionCommand(args.slice(1), version);
     } catch (error) {
       if (args[1] === "hook") return 0;
       process.stderr.write(
@@ -4138,7 +5707,7 @@ async function runCli(args, version) {
     return 1;
   }
   try {
-    const { values } = parseArgs4({
+    const { values } = parseArgs6({
       args: args.slice(1),
       options: {
         help: { type: "boolean", short: "h" },