@teammy/cli 0.0.10 → 0.1.1

package/dist/main.js

@@ -1,6 +1,6 @@
 // apps/client/main.ts
-import { parseArgs as parseArgs4 } from "node:util";
-import { resolve as resolve9 } 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()
@@ -148,7 +150,8 @@ var MemberUpdateSchema = z3.object({
 var ProjectCreateSchema = z3.object({
   operationId: z3.uuid(),
   projectName: z3.string().trim().min(1).max(120),
-  description: z3.string().max(2e3).default("")
+  description: z3.string().max(2e3).default(""),
+  workspacePath: z3.string().trim().min(1).optional()
 }).strict();
 var ProjectSummarySchema = z3.object({
   projectId: NameSchema,
@@ -189,113 +192,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 +385,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 +424,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 +446,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 +460,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 +504,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 +524,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 +564,18 @@ var HubClient = class {
 };
 
 // apps/client/sessions/command.ts
-import { createHash as createHash7 } from "node:crypto";
-import { realpath as realpath4 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname5, join as join7, resolve as resolve4 } from "node:path";
-import { parseArgs } from "node:util";
+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 join17, 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";
@@ -539,7 +592,7 @@ function transaction(db, action) {
     throw error;
   }
 }
-function openDatabase(path, migrations, busyTimeoutMs = 5e3) {
+function openDatabase(path, migrations, busyTimeoutMs = 5e3, journalMode = "WAL") {
   if (!Number.isSafeInteger(busyTimeoutMs) || busyTimeoutMs < 0)
     throw new Error("Invalid SQLite busy timeout.");
   mkdirSync(dirname(path), { recursive: true, mode: 448 });
@@ -547,7 +600,7 @@ function openDatabase(path, migrations, busyTimeoutMs = 5e3) {
   try {
     chmodSync(path, 384);
     db.exec(
-      `PRAGMA busy_timeout = ${busyTimeoutMs}; PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL;`
+      `PRAGMA busy_timeout = ${busyTimeoutMs}; PRAGMA foreign_keys = ON; PRAGMA journal_mode = ${journalMode}; PRAGMA synchronous = FULL;`
     );
     transaction(db, () => {
       const version = Number(db.prepare("PRAGMA user_version").get().user_version);
@@ -583,8 +636,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 +651,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 +665,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 +685,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 +703,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 +720,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,33 +950,191 @@ 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 join7, relative as relative2, isAbsolute, sep as sep2 } from "node:path";
+import { z as z12 } 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 join5, resolve } from "node:path";
 
 // apps/client/files/local-fs.ts
-import { createHash as createHash2, randomUUID } 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 { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { lstat, mkdir, open as open2, readdir, realpath, rename, rmdir, unlink } from "node:fs/promises";
+import { dirname as dirname3, join as join4, relative, sep } from "node:path";
 import { setImmediate } from "node:timers/promises";
+
+// packages/workspace/local-config.ts
+import { constants } from "node:fs";
+import { open, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { z as z10 } from "zod";
+import ignore from "ignore";
+function ignored(path) {
+  return path.split("/").some(
+    (part) => part === ".git" || part === ".DS_Store" || /^\.teammy(?:[-.]|$)/i.test(part) || /(?:~|\.(?:swp|swx|tmp|part))$/i.test(part)
+  );
+}
 function missing(error) {
   return error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR"].includes(String(error.code));
 }
+var LOCAL_CONFIG_NAME = ".teammy-local.json";
+var LocalConfigSchema = z10.object({
+  files: z10.object({ ignore: z10.array(z10.string().max(1024)).max(256).default([]) }).strict().default({ ignore: [] })
+}).strict();
+async function ensureLocalConfig(root) {
+  try {
+    await writeFile(
+      join3(root, LOCAL_CONFIG_NAME),
+      JSON.stringify({ files: { ignore: [] } }, null, 2) + "\n",
+      { flag: "wx", mode: 384 }
+    );
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+  }
+}
+async function loadLocalRules(root) {
+  let rules = [];
+  try {
+    const file = await open(
+      join3(root, LOCAL_CONFIG_NAME),
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+    try {
+      const before = await file.stat();
+      if (!before.isFile() || before.size > 65536)
+        throw new Error("Expected a regular configuration file no larger than 64 KiB.");
+      const buffer = Buffer.alloc(65537);
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+      if (bytesRead > 65536 || bytesRead !== before.size)
+        throw new Error("Configuration exceeds the read limit or changed while reading.");
+      const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytesRead));
+      const after = await file.stat();
+      if (before.size !== after.size || before.mtimeMs !== after.mtimeMs)
+        throw new Error("Configuration is being saved; retry on the next check.");
+      rules = LocalConfigSchema.parse(JSON.parse(text)).files.ignore;
+    } finally {
+      await file.close();
+    }
+  } catch (error) {
+    if (!missing(error))
+      throw new Error(
+        `${LOCAL_CONFIG_NAME}: invalid or unreadable configuration; uploads paused.`,
+        { cause: error }
+      );
+  }
+  const matcher = ignore().add(rules);
+  return {
+    fingerprint: JSON.stringify(rules),
+    excludes: (path, directory = false) => ignored(path) || matcher.ignores(path + (directory && !path.endsWith("/") ? "/" : ""))
+  };
+}
+
+// apps/client/files/local-fs.ts
+function missing2(error) {
+  return error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR"].includes(String(error.code));
+}
 function signature(stat2) {
   return [stat2.dev, stat2.ino, stat2.size, stat2.mtimeNs, stat2.ctimeNs].join(":");
 }
-function ignored(path) {
-  return path.split("/").some(
-    (part) => part === ".git" || part === ".DS_Store" || /^\.teammy(?:[-.]|$)/i.test(part) || /(?:~|\.(?:swp|swx|tmp|part))$/i.test(part)
-  );
-}
 async function safePath(root, path, createParents = false) {
   FilePathSchema.parse(path);
   const rootStat = await lstat(root);
@@ -907,7 +1143,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 = join4(parent, part);
     if (createParents)
       await mkdir(parent).catch((error) => {
         if (error.code !== "EEXIST") throw error;
@@ -917,7 +1153,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 join4(root, ...parts);
 }
 async function metadata(root, path) {
   try {
@@ -927,7 +1163,7 @@ async function metadata(root, path) {
       throw new Error(`Unsupported filesystem entry: ${path}`);
     return { signature: signature(stat2), directory: stat2.isDirectory() };
   } catch (error) {
-    if (missing(error)) return null;
+    if (missing2(error)) return null;
     throw error;
   }
 }
@@ -977,12 +1213,12 @@ async function readStable(root, path) {
   const inside = relative(await realpath(root), resolvedBefore);
   if (inside.startsWith(`..${sep}`) || inside === "..")
     throw new Error(`File escapes sync root: ${path}`);
-  const file = await open(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  const file = await open2(target, constants2.O_RDONLY | (constants2.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;
@@ -1007,7 +1243,7 @@ async function readStable(root, path) {
 }
 async function syncDirectory(directory) {
   if (process.platform === "win32") return;
-  const handle = await open(directory, "r");
+  const handle = await open2(directory, "r");
   try {
     await handle.sync();
   } finally {
@@ -1016,8 +1252,8 @@ 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 file = await open(temporary, "wx", 384);
+  const temporary = join4(dirname3(target), `.teammy-${randomUUID2()}.tmp`);
+  const file = await open2(temporary, "wx", 384);
   try {
     try {
       await file.writeFile(bytes);
@@ -1033,15 +1269,15 @@ 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) => {
-      if (!missing(error)) throw error;
+      if (!missing2(error)) throw error;
     });
   }
 }
@@ -1052,16 +1288,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 +1305,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 join5(await realpath2(dirname4(path)), basename(path));
 }
 async function directoryIdentity(root) {
   const stat2 = await lstat2(root, { bigint: true });
@@ -1086,18 +1322,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(join5(p, ".git"));
       repo = true;
       break;
     } catch (e) {
-      if (!missing(e)) throw e;
+      if (!missing2(e)) throw e;
     }
-    if (p === dirname3(p)) break;
+    if (p === dirname4(p)) break;
   }
   if (repo) {
     let tracked;
@@ -1142,7 +1378,7 @@ async function prepareWorkspace(state, root, input, reconnect = false) {
     await lstat2(root);
     present = true;
   } catch (e) {
-    if (!missing(e)) throw e;
+    if (!missing2(e)) throw e;
   }
   if (present) {
     if (reconnect && state.binding(root)) {
@@ -1179,8 +1415,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 join6 } 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 +1432,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 = join6(directory, "logs");
+    mkdirSync4(logs, { recursive: true, mode: 448 });
+    this.path = join6(logs, "client.jsonl");
   }
   limit;
   path;
@@ -1215,10 +1451,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 +1473,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 +1491,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 z11 } from "zod";
+var CredentialSchema = z11.string().regex(/^tmy_[a-f0-9]{64}$/);
+var EnrollmentSchema = z11.object({
+  operationId: z11.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 = z11.object({
+  checkIntervalSeconds: z11.number().min(1).max(86400),
+  fileSettleSeconds: z11.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 = z11.object({
+  checkedAt: z11.string(),
+  published: z11.boolean(),
+  appliedFiles: z11.number().int().nonnegative(),
+  pendingFiles: z11.number().int().nonnegative(),
+  sessionSources: z11.number().int().nonnegative(),
+  errors: z11.array(z11.string().max(1e3)).max(20)
 }).strict();
-var DeviceStatusSchema = z8.object({
-  clientVersion: z8.string().max(64),
+var DeviceStatusSchema = z11.object({
+  clientVersion: z11.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: z11.array(z11.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
+  configError: z11.string().max(2e3).nullable(),
+  reportError: z11.string().max(2e3).nullable(),
   lastSync: SyncSummarySchema.nullable()
 }).strict();
-var WebDevicesSchema = z8.object({
-  devices: z8.array(
-    z8.object({
+var WebDevicesSchema = z11.object({
+  devices: z11.array(
+    z11.object({
       memberId: NameSchema,
-      bound: z8.boolean(),
-      lastSeenAt: z8.string().nullable(),
+      bound: z11.boolean(),
+      lastSeenAt: z11.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 +1558,7 @@ var ClientProjectState = class {
       return request2;
     }
     const request = {
-      operationId: randomUUID2(),
+      operationId: randomUUID3(),
       memberId,
       projectId,
       deviceId,
@@ -1495,6 +1731,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 (
@@ -1554,12 +1804,12 @@ 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 s.*, p.revision,p.hash,p.selected_path,p.pending_json,p.pending_signature,p.pending_path,p.attempts,p.retry_at
+      `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=? ${path === void 0 ? "" : "AND s.path=?"} ORDER BY s.checked_at, s.path LIMIT ?`
-    ).all(this.root, ...path === void 0 ? [] : [path], limit).map((row) => ({
+      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),
@@ -1569,6 +1819,8 @@ var SessionState = class {
       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,
@@ -1607,21 +1859,28 @@ var SessionState = class {
   }
   stage(path, request, signature2) {
     this.state.db.prepare(
-      `UPDATE session_publications SET pending_json=?,pending_signature=?,pending_path=?,attempts=0,retry_at=0
+      `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, this.root, request.sessionKey);
+    ).run(
+      JSON.stringify(request),
+      signature2,
+      path,
+      parserVersions[this.get(path).agent],
+      this.root,
+      request.sessionKey
+    );
   }
-  acknowledge(path, revision, hash2, signature2) {
+  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);
+    this.observed(path, signature2, parserVersion);
   }
-  observed(path, signature2) {
+  observed(path, signature2, parserVersion = parserVersions[this.get(path).agent]) {
     this.state.db.prepare(
-      "UPDATE session_sources SET signature=?,verified_at=?,last_error=NULL,adopt_existing=0 WHERE root=? AND path=?"
-    ).run(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(
@@ -1643,10 +1902,12 @@ var SessionState = class {
     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(
@@ -1667,33 +1928,75 @@ var SessionState = class {
 
 // apps/client/state.ts
 var LocalBindingSchema = BindingSchema.extend({
-  root: z9.string(),
-  serverUrl: z9.string(),
-  token: z9.string()
+  root: z12.string(),
+  serverUrl: z12.string(),
+  token: z12.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,
-      sessionSourcesMigration
-    ]);
+  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(join7(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(join7(directory, "client.sqlite3"), clientMigrations);
+        } finally {
+          exclusive?.close();
+        }
+        if (!options.maintenance) access2 = stateAccess(directory);
+      } else {
+        db = new DatabaseSync3(join7(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()) {
@@ -1709,7 +2012,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
     );
@@ -1754,11 +2057,11 @@ async function stateLocation(root, directory) {
 // apps/client/sessions/setup.ts
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import { access, mkdir as mkdir4, readFile, writeFile } from "node:fs/promises";
-import { constants as constants2 } from "node:fs";
+import { access, mkdir as mkdir5, readFile as readFile2, writeFile as writeFile2, realpath as realpath4 } from "node:fs/promises";
+import { constants as constants3 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname4, join as join5, resolve as resolve3 } from "node:path";
-import { createHash as createHash5 } from "node:crypto";
+import { dirname as dirname6, join as join11, resolve as resolve4 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
 
 // apps/client/sessions/normalize.ts
 function object(value) {
@@ -1792,6 +2095,9 @@ var JsonlNormalizer = class {
   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;
@@ -1839,8 +2145,11 @@ var JsonlNormalizer = class {
         this.add(payload.role, payload.content, payload.id, line);
       }
     } else if (this.agent === "cursor") {
-      const message2 = object(row.message);
       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") {
@@ -1849,6 +2158,14 @@ var JsonlNormalizer = class {
         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);
         this.add(message2.role, message2.content, row.id, line);
@@ -1876,9 +2193,25 @@ var JsonlNormalizer = class {
     }
   }
   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 messages = this.candidates.filter((m) => m.visible || !visibleGroups.has(m.group)).map((m) => {
+    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);
@@ -1895,10 +2228,167 @@ var JsonlNormalizer = class {
   }
 };
 
+// apps/client/sessions/registration.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "node:fs";
+import { join as join8 } from "node:path";
+var registrationPath = (directory, root) => join8(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;
+}
+function saveRegistration(directory, value) {
+  writePrivateJson(registrationPath(directory, value.root), value);
+}
+function registrations(directory, onError) {
+  const path = join8(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(join8(path, name2), "utf8"));
+      const registration = readRegistration(directory, value.root);
+      if (!registration) throw new Error("Missing Hook registration.");
+      return [registration];
+    } catch (error) {
+      onError(join8(path, name2), error);
+      return [];
+    }
+  });
+}
+
+// apps/client/root-lock.ts
+import { createHash as createHash5 } from "node:crypto";
+import { join as join9 } from "node:path";
+function acquireRootLock(root, stateDirectory) {
+  let lock;
+  try {
+    lock = openDatabase(
+      join9(stateDirectory, "locks", `${createHash5("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/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 join10, 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("~/") ? join10(home, path.slice(2)) : path
+  );
+}
+async function piDiscoveryDirectories(agentDirectory, project, home, env) {
+  let configured;
+  for (const path of [join10(agentDirectory, "settings.json"), join10(project, ".pi/settings.json")]) {
+    try {
+      const settings = JSON.parse(await readFile(path, "utf8"));
+      if (typeof settings?.sessionDir === "string" && settings.sessionDir)
+        configured = settings.sessionDir;
+    } catch (error) {
+      if (!missing2(error)) throw new Error(`Unable to read Pi session directory setting: ${path}`);
+    }
+  }
+  configured = env.PI_CODING_AGENT_SESSION_DIR || configured;
+  return [
+    .../* @__PURE__ */ new Set([
+      join10(agentDirectory, "sessions"),
+      ...configured ? [piPath(configured, home, project)] : []
+    ])
+  ];
+}
+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(join10(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 = join10(agentDirectory, "extensions", `teammy-${rootKey(directory)}.js`);
+  await mkdir4(dirname5(path), { recursive: true });
+  let original = null;
+  try {
+    original = await readStable(dirname5(path), basename2(path));
+  } catch (error) {
+    if (!missing2(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 (missing2(error)) return false;
+    throw error;
+  }
+}
+
 // apps/client/sessions/setup.ts
 var exec2 = promisify2(execFile2);
 var quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
-async function exists(path, mode = constants2.F_OK) {
+async function exists(path, mode = constants3.F_OK) {
   try {
     await access(path, mode);
     return true;
@@ -1907,176 +2397,399 @@ async function exists(path, mode = constants2.F_OK) {
   }
 }
 async function setupSessions(state, root, directory, options = {}) {
-  const home = options.home ?? homedir(), env = options.env ?? process.env;
-  const project = dirname4(root), sessions = new SessionState(state, root);
-  const defaults = [
-    {
-      agent: "claude-code",
-      executables: ["claude"],
-      storage: env.CLAUDE_CONFIG_DIR ?? join5(home, ".claude"),
-      directories: ["projects"],
-      config: ".claude/settings.local.json",
-      events: ["SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"]
-    },
-    {
-      agent: "codex",
-      executables: ["codex"],
-      storage: env.CODEX_HOME ?? join5(home, ".codex"),
-      directories: ["sessions"],
-      config: ".codex/hooks.json",
-      events: ["SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"]
-    },
-    {
-      agent: "cursor",
-      executables: ["agent", "cursor-agent"],
-      storage: env.CURSOR_CONFIG_DIR ?? join5(home, ".cursor"),
-      directories: ["chats", "projects"],
-      config: ".cursor/hooks.json",
-      events: ["sessionStart", "postToolUse", "stop", "sessionEnd"]
-    },
-    {
-      agent: "pi",
-      executables: ["pi"],
-      storage: env.PI_CODING_AGENT_DIR ?? join5(home, ".pi", "agent"),
-      directories: ["sessions"]
-    }
-  ];
-  const issues = [], configured = [];
-  let gitRoot = project;
+  await realpath4(root);
+  if (!state.binding(root)) throw new Error("Connect this root before installing hooks.");
+  const lock = acquireRootLock("hooks", join11(directory, "runtime"));
   try {
-    gitRoot = (await exec2("git", ["-C", project, "rev-parse", "--show-toplevel"])).stdout.trim();
-  } catch {
-  }
-  for (const adapter of defaults) {
-    const installed = options.agents ? options.agents.includes(adapter.agent) : await exists(adapter.storage) || (await Promise.all(
-      (env.PATH ?? "").split(":").flatMap(
-        (dir) => adapter.executables.map((name2) => exists(join5(dir, name2), constants2.X_OK))
-      )
-    )).some(Boolean);
-    if (!installed) continue;
-    for (const sub of adapter.directories)
-      sessions.discover(adapter.agent, resolve3(adapter.storage, sub), project);
-    if (adapter.agent === "cursor")
-      sessions.discover("cursor", join5(home, ".cursor", "projects"), project);
-    configured.push(adapter.agent);
-    if (!adapter.config) continue;
-    const configRoot = adapter.agent === "cursor" ? gitRoot : project;
-    const path = join5(configRoot, adapter.config);
-    try {
-      await mkdir4(dirname4(path), { recursive: true });
-      let original = null;
-      try {
-        original = await readStable(configRoot, adapter.config);
-      } catch (error) {
-        if (!missing(error)) throw error;
-      }
-      const config = original ? JSON.parse(original.bytes.toString("utf8")) : {};
-      if (!config || typeof config !== "object" || Array.isArray(config))
-        throw new Error("Hook configuration must be a JSON object.");
-      if (config.hooks !== void 0 && (!config.hooks || typeof config.hooks !== "object" || Array.isArray(config.hooks)))
-        throw new Error("Invalid existing hooks object.");
-      const hooks = object(config.hooks);
-      const marker = `teammy-session-${rootKey(root)}`;
-      const command = [
-        process.execPath,
-        options.entry ?? resolve3(process.argv[1]),
-        "session",
-        "hook",
-        "--agent",
-        adapter.agent,
-        "--root",
-        root,
-        "--state-dir",
-        directory,
-        "--project-dir",
-        project
-      ].map(quote).join(" ") + ` # ${marker}`;
-      for (const event of adapter.events) {
-        const entries = hooks[event] ?? [];
-        if (!Array.isArray(entries)) throw new Error(`Invalid ${event} hooks.`);
-        const retained = entries.flatMap((entry) => {
-          const value = object(entry);
-          if (adapter.agent === "cursor")
-            return typeof value.command === "string" && value.command.includes(marker) ? [] : [entry];
-          if (!Array.isArray(value.hooks)) return [entry];
-          const nested = value.hooks.filter(
-            (hook) => !(typeof object(hook).command === "string" && String(object(hook).command).includes(marker))
-          );
-          return nested.length ? [{ ...value, hooks: nested }] : [];
-        });
-        hooks[event] = [
-          ...retained,
-          adapter.agent === "cursor" ? { command, timeout: 3 } : { hooks: [{ type: "command", command, timeout: 3 }] }
-        ];
+    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 ?? join11(home, ".claude"),
+        directories: ["projects"],
+        config: ".claude/settings.local.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "codex",
+        executables: ["codex"],
+        storage: env.CODEX_HOME ?? join11(home, ".codex"),
+        directories: ["sessions"],
+        config: ".codex/hooks.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "claude-code",
+        instance: "tclaude",
+        executables: ["tclaude"],
+        storage: join11(home, ".tclaude"),
+        directories: ["projects"],
+        config: ".claude/settings.local.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "codex",
+        instance: "tcodex",
+        executables: ["tcodex"],
+        storage: join11(home, ".tcodex"),
+        directories: ["sessions"],
+        config: ".codex/hooks.json",
+        events: ["Stop", "SessionEnd"]
+      },
+      {
+        agent: "cursor",
+        executables: ["agent", "cursor-agent"],
+        storage: env.CURSOR_CONFIG_DIR ?? join11(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 ?? join11(home, ".pi", "agent"), home, project),
+        directories: []
       }
-      config.hooks = hooks;
-      if (adapter.agent === "cursor") config.version ??= 1;
-      const bytes = Buffer.from(JSON.stringify(config, null, 2) + "\n");
-      if (original?.bytes.equals(bytes)) continue;
-      if (original) {
-        const backupDir = join5(directory, "hook-backups", rootKey(root));
-        await mkdir4(backupDir, { recursive: true, mode: 448 });
-        const hash2 = createHash5("sha256").update(original.bytes).digest("hex");
-        await writeFile(join5(backupDir, `${adapter.agent}-${hash2}.json`), original.bytes, {
-          mode: 384
-        });
+    ];
+    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(join11(dir, name2), constants3.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(join11(home, ".cursor", "projects")))
+        sessions.discover("cursor", join11(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."}`
+            );
+          }
+        }
       }
-      await replaceFile(configRoot, adapter.config, bytes, original?.signature ?? null);
+      if (!adapter.config) continue;
+      const configRoot = adapter.agent === "cursor" ? gitRoot : project;
+      const path = join11(configRoot, adapter.config);
+      if (written.has(path)) continue;
+      written.add(path);
       try {
-        const relativePath = path.slice(gitRoot.length + 1);
-        const tracked = (await exec2("git", ["-C", gitRoot, "ls-files", "--", relativePath])).stdout;
-        if (!tracked) {
-          const exclude = (await exec2("git", [
-            "-C",
-            gitRoot,
-            "rev-parse",
-            "--path-format=absolute",
-            "--git-path",
-            "info/exclude"
-          ])).stdout.trim();
-          const old = await readFile(exclude, "utf8").catch((e) => {
-            if (missing(e)) return "";
-            throw e;
+        await mkdir5(dirname6(path), { recursive: true });
+        let original = null;
+        try {
+          original = await readStable(configRoot, adapter.config);
+        } catch (error) {
+          if (!missing2(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 = join11(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 = join11(directory, "hook-backups", rootKey(root));
+          await mkdir5(backupDir, { recursive: true, mode: 448 });
+          const hash2 = createHash6("sha256").update(original.bytes).digest("hex");
+          await writeFile2(join11(backupDir, `${adapter.agent}-${hash2}.json`), original.bytes, {
+            mode: 384
           });
-          const rule = "/" + relativePath.replace(/[\\*?[\]#! ]/g, "\\$&");
-          if (!old.split(/\r?\n/).includes(rule)) {
-            await mkdir4(dirname4(exclude), { recursive: true });
-            await writeFile(exclude, old + (old && !old.endsWith("\n") ? "\n" : "") + rule + "\n");
+        }
+        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 (missing2(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 writeFile2(
+                exclude,
+                old + (old && !old.endsWith("\n") ? "\n" : "") + owned.exclude.line + "\n"
+              );
+            }
           }
+        } catch {
         }
-      } catch {
+      } catch (error) {
+        issues.push(`${path}: ${error instanceof Error ? error.message : "Hook setup failed."}`);
       }
-    } 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", join11(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(join11(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: join11(project, ".claude/settings.local.json"), agent: "claude-code", created: false },
+      { path: join11(project, ".codex/hooks.json"), agent: "codex", created: false },
+      { path: join11(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", join11(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 writeFile2(config.exclude.path, text.replace(config.exclude.line + "\n", ""));
+          }
+          removed++;
+        } catch (error) {
+          if (!missing2(error))
+            issues.push(
+              `${config.path}: ${error instanceof Error ? error.message : "Hook removal failed."}`
+            );
+        }
+      }
+    }
+    return { removed, issues };
+  } finally {
+    lock.close();
   }
-  return { configured, issues };
 }
 
+// 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 join13 } from "node:path";
+
 // apps/client/sessions/hooks.ts
-import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
-import { mkdir as mkdir5, open as open2, opendir, rename as rename2, unlink as unlink2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join6 } from "node:path";
-import { z as z10 } from "zod";
-var HintSchema = z10.object({
+import { createHash as createHash7, randomUUID as randomUUID5 } from "node:crypto";
+import { mkdir as mkdir6, open as open3, opendir, rename as rename2, unlink as unlink2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join12 } from "node:path";
+import { z as z13 } from "zod";
+var HintSchema = z13.object({
   agent: AgentSchema,
-  path: z10.string().min(1).max(4096).refine(isAbsolute3).optional(),
-  nativeId: z10.string().min(1).max(512).optional(),
-  projectDir: z10.string().min(1).max(4096).refine(isAbsolute3)
+  path: z13.string().min(1).max(4096).refine(isAbsolute3).optional(),
+  nativeId: z13.string().min(1).max(512).optional(),
+  projectDir: z13.string().min(1).max(4096).refine(isAbsolute3)
 });
 function inbox(directory, root) {
-  return join6(directory, "session-hints", createHash6("sha256").update(root).digest("hex"));
+  return join12(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 mkdir5(targetDir, { recursive: true, mode: 448 });
-  const target = join6(
+  await mkdir6(targetDir, { recursive: true, mode: 448 });
+  const target = join12(
     targetDir,
-    `${createHash6("sha256").update(JSON.stringify(hint)).digest("hex")}.json`
+    `${createHash7("sha256").update(JSON.stringify(hint)).digest("hex")}.json`
   );
-  const temporary = `${target}.${randomUUID4()}.tmp`;
-  const handle = await open2(temporary, "wx", 384);
+  const temporary = `${target}.${randomUUID5()}.tmp`;
+  const handle = await open3(temporary, "wx", 384);
   try {
     await handle.writeFile(JSON.stringify(hint));
   } finally {
@@ -2097,9 +2810,9 @@ async function consumeHints(directory, root, sessions, refresh) {
   for await (const entry of dir) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
     if (count++ >= 50) break;
-    const path = join6(inbox(directory, root), entry.name);
+    const path = join12(inbox(directory, root), entry.name);
     try {
-      const handle = await open2(path, "r");
+      const handle = await open3(path, "r");
       let body;
       try {
         if ((await handle.stat()).size > 16384) throw new Error("Oversized hook hint.");
@@ -2137,353 +2850,104 @@ async function hookPayload() {
   }
 }
 
-// apps/client/sessions/command.ts
-var help = `Usage: teammy session COMMAND [options]
-
-  setup       Configure project hooks and native discovery (also done by connect)
-  track       --agent AGENT --file PATH [--project-dir DIR] [--adopt-existing]
-  untrack     --file PATH (does not delete server history)
-  discover    --agent AGENT [--directory DIR] [--project-dir DIR]
-  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]
-  read        --owner MEMBER --key KEY [--revision N]
-  search      --query TEXT [--after N] [--limit N]
-
-Shared options: --root DIR (./workspaces), --state-dir DIR (~/.teammy/client).
-AGENT: claude-code, codex, cursor, pi, dsh. Project defaults to the shared root's parent.
-track/discover only register local sources. Run teammy sync to collect and publish.
-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) {
-  const command = args[0];
-  if (!command || ["--help", "-h", "help"].includes(command)) {
-    process.stdout.write(help);
-    return 0;
-  }
-  const { values } = parseArgs({
-    args: args.slice(1),
-    options: {
-      root: { type: "string", default: resolve4("workspaces") },
-      "state-dir": { type: "string", default: join7(homedir2(), ".teammy", "client") },
-      agent: { type: "string" },
-      file: { type: "string" },
-      directory: { type: "string" },
-      "project-dir": { type: "string" },
-      "adopt-existing": { type: "boolean" },
-      owner: { type: "string" },
-      key: { type: "string" },
-      revision: { type: "string" },
-      query: { type: "string" },
-      after: { type: "string", default: "0" },
-      limit: { type: "string", default: "50" },
-      help: { type: "boolean", short: "h" }
-    }
-  });
-  if (values.help) {
-    process.stdout.write(help);
-    return 0;
-  }
-  const root = await realpath4(resolve4(values.root));
-  const directory = await stateLocation(root, values["state-dir"]);
-  const projectDir = await realpath4(resolve4(values["project-dir"] ?? dirname5(root)));
-  if (command === "hook") {
-    const payload = values.file ? {} : await hookPayload();
-    const file = values.file ?? payload.transcript_path ?? payload.session_file ?? payload.sessionFile;
-    const nativeId = payload.session_id ?? payload.conversation_id;
-    if (typeof file === "string" && file || typeof nativeId === "string")
-      await recordHint(directory, root, {
-        agent: AgentSchema.parse(values.agent),
-        ...typeof file === "string" && file ? { path: resolve4(file) } : {},
-        ...typeof nativeId === "string" ? { nativeId } : {},
-        projectDir
-      });
-    return 0;
-  }
-  const state = new ClientState(directory);
+// apps/client/sessions/hook-entry.ts
+async function runHook(args) {
   try {
-    const binding = state.binding(root);
-    if (!binding) throw new Error("Connect this root first.");
-    const sessions = new SessionState(state, root);
-    const client = new HubClient(binding.serverUrl, 1e4, binding);
-    let output;
-    if (command === "setup") output = await setupSessions(state, root, directory);
-    else if (command === "track" || command === "untrack") {
-      if (!values.file) throw new Error("--file is required.");
-      const path = resolve4(values.file);
-      if (command === "track")
-        sessions.track(
-          AgentSchema.parse(values.agent),
-          path,
-          projectDir,
-          Boolean(values["adopt-existing"])
-        );
-      else sessions.untrack(path);
-      output = sessions.status();
-    } 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(resolve4(values.directory)));
-      } else {
-        const agent = AgentSchema.parse(values.agent);
-        const defaults = {
-          "claude-code": join7(
-            process.env.CLAUDE_CONFIG_DIR ?? join7(homedir2(), ".claude"),
-            "projects"
-          ),
-          codex: join7(process.env.CODEX_HOME ?? join7(homedir2(), ".codex"), "sessions"),
-          cursor: join7(
-            process.env.CURSOR_CONFIG_DIR ?? join7(homedir2(), ".cursor"),
-            "chats",
-            createHash7("md5").update(projectDir).digest("hex")
-          ),
-          pi: join7(process.env.PI_CODING_AGENT_DIR ?? join7(homedir2(), ".pi", "agent"), "sessions"),
-          dsh: void 0
-        };
-        const path = values.directory ?? defaults[agent];
-        if (!path) throw new Error("DSH requires its configured persistence --directory.");
-        sessions.discover(agent, await realpath4(resolve4(path)), projectDir);
+    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" }
       }
-      output = sessions.directories();
-    } else if (command === "sources")
-      output = {
-        sources: sessions.status(),
-        discovery: sessions.directories(),
-        hooks: sessions.hooks()
-      };
-    else {
-      const after = Number(values.after);
-      const limit = Number(values.limit);
-      if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100)
-        throw new Error("Invalid pagination options.");
-      if (command === "list") output = await client.sessions(after, limit);
-      else if (command === "search") {
-        if (!values.query) throw new Error("--query is required.");
-        output = await client.searchSessions(values.query, after, limit);
-      } else if (command === "read") {
-        if (!values.owner || !values.key) throw new Error("--owner and --key are required.");
-        const revision = values.revision === void 0 ? void 0 : Number(values.revision);
-        if (revision !== void 0 && (!Number.isSafeInteger(revision) || revision < 1))
-          throw new Error("Invalid revision.");
-        const session = await client.session(values.owner, values.key, revision);
-        const snapshot = SessionSnapshotSchema.parse(
-          JSON.parse(Buffer.from(await client.downloadBlob(session.blob.sha256)).toString("utf8"))
-        );
-        output = { session, snapshot };
-      } else throw new Error("Unknown session command. Use teammy session --help.");
-    }
-    process.stdout.write(`${JSON.stringify(output, null, 2)}
-`);
-    return 0;
-  } finally {
-    state.close();
-  }
-}
-
-// apps/client/sync-command.ts
-import { parseArgs as parseArgs3 } 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 join12, resolve as resolve6 } from "node:path";
-import { homedir as homedir4 } from "node:os";
-import { createInterface as createInterface2 } from "node:readline/promises";
-
-// apps/client/connection.ts
-import { readFile as readFile2, mkdir as mkdir6 } from "node:fs/promises";
-import { createInterface } from "node:readline/promises";
-
-// apps/client/root-lock.ts
-import { createHash as createHash8 } from "node:crypto";
-import { join as join8 } from "node:path";
-function acquireRootLock(root, stateDirectory) {
-  let lock;
-  try {
-    lock = openDatabase(
-      join8(stateDirectory, "locks", `${createHash8("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 constants3 } from "node:fs";
-import { open as open3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-import { z as z11 } from "zod";
-import ignore from "ignore";
-var LOCAL_CONFIG_NAME = ".teammy-local.json";
-var LocalConfigSchema = z11.object({
-  files: z11.object({ ignore: z11.array(z11.string().max(1024)).max(256).default([]) }).strict().default({ ignore: [] })
-}).strict();
-async function ensureLocalConfig(root) {
-  try {
-    await writeFile2(
-      join9(root, LOCAL_CONFIG_NAME),
-      JSON.stringify({ files: { ignore: [] } }, null, 2) + "\n",
-      { flag: "wx", mode: 384 }
-    );
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
-  }
-}
-async function loadLocalRules(root) {
-  let rules = [];
-  try {
-    const file = await open3(
-      join9(root, LOCAL_CONFIG_NAME),
-      constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
+    });
+    const directory = await realpath5(
+      resolve5(values["state-dir"] ?? join13(homedir2(), ".teammy", "client"))
     );
-    try {
-      const before = await file.stat();
-      if (!before.isFile() || before.size > 65536)
-        throw new Error("Expected a regular configuration file no larger than 64 KiB.");
-      const buffer = Buffer.alloc(65537);
-      const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
-      if (bytesRead > 65536 || bytesRead !== before.size)
-        throw new Error("Configuration exceeds the read limit or changed while reading.");
-      const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytesRead));
-      const after = await file.stat();
-      if (before.size !== after.size || before.mtimeMs !== after.mtimeMs)
-        throw new Error("Configuration is being saved; retry on the next check.");
-      rules = LocalConfigSchema.parse(JSON.parse(text)).files.ignore;
-    } finally {
-      await file.close();
-    }
-  } catch (error) {
-    if (!missing(error))
-      throw new Error(
-        `${LOCAL_CONFIG_NAME}: invalid or unreadable configuration; uploads paused.`,
-        { cause: error }
-      );
-  }
-  const matcher = ignore().add(rules);
-  return {
-    fingerprint: JSON.stringify(rules),
-    excludes: (path, directory = false) => ignored(path) || matcher.ignores(path + (directory && !path.endsWith("/") ? "/" : ""))
-  };
-}
-
-// apps/client/connection.ts
-async function connectProject(state, root, directory, options) {
-  const lock = acquireRootLock(root, directory);
-  try {
-    state.assertRootAvailable(root);
-    const transport = new HubClient(options.url);
-    const existing = state.binding(root);
-    const project = new ClientProjectState(state, root);
-    if (existing && existing.serverUrl !== transport.url)
-      throw new Error("This root is connected to another server.");
-    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("multi-project"))
-      throw new Error(
-        "This client requires a multi-project server. Update the server before connecting."
+    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"]
+        )
       );
-    let member = options.member;
-    if (existing && !options.reconnect && !options.tokenFile) {
-      if (member && member !== existing.memberId)
-        throw new Error("This root belongs to a different member.");
-      const client2 = new HubClient(existing.serverUrl, 1e4, existing);
-      await client2.members();
-    } else if (options.tokenFile) {
-      const token = CredentialSchema.parse((await readFile2(options.tokenFile, "utf8")).trim());
-      const deviceId = state.deviceFor(root);
-      const client2 = new HubClient(options.url, 1e4, { token, deviceId });
-      const binding2 = await client2.bind(deviceId, options.project ?? existing?.workspaceId);
-      if (options.project && binding2.workspaceId !== options.project)
-        throw new Error("Token belongs to a different project.");
-      state.saveBinding(root, client2.url, token, binding2);
-    } else {
-      member ??= existing?.memberId;
-      if (!member && process.stdin.isTTY) {
-        const rl = createInterface({ input: process.stdin, output: process.stderr });
+      const matches = [];
+      for (const item of candidates2) {
         try {
-          member = (await rl.question("Member ID: ")).trim();
-        } finally {
-          rl.close();
+          const project = await realpath5(item.projectDir);
+          const rel = relative4(project, cwd);
+          if (!isAbsolute4(rel) && rel !== ".." && !rel.startsWith(".." + sep4)) matches.push(item);
+        } catch {
         }
       }
-      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();
+      matches.sort((a, b) => b.projectDir.length - a.projectDir.length);
+      selectedRoot = matches[0]?.root;
+      if (!selectedRoot) return;
     }
-    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 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 own = await metadata(root, binding.memberId);
-    if (own && !own.directory) throw new Error("Member path is not a directory.");
-    if (!own) await mkdir6(await safePath(root, binding.memberId));
-    await ensureLocalConfig(root);
-    const { token: _, ...visible } = binding;
-    return { ...visible, configRevision: project.cached()?.config.configRevision ?? null };
-  } finally {
-    lock.close();
+    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 join16, 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 join10 } from "node:path";
-import { z as z12 } from "zod";
-var RequestSchema = z12.object({
-  method: z12.enum(["ping", "wake", "status", "once"]),
-  root: z12.string().max(4096).optional()
+import { join as join14 } from "node:path";
+import { z as z14 } from "zod";
+var RequestSchema = z14.object({
+  method: z14.enum(["ping", "wake", "status", "once"]),
+  root: z14.string().max(4096).optional()
 }).strict();
 function socketPath(directory) {
-  return join10(
+  return join14(
     "/tmp",
     `teammy-${process.getuid?.() ?? "user"}-${rootKey(directory)}`,
     "control.sock"
   );
 }
 async function prepareSocketDirectory(directory) {
-  const path = join10(socketPath(directory), "..");
+  const path = join14(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((resolve10, reject) => {
+  return new Promise((resolve16, reject) => {
     const socket = createConnection(socketPath(directory));
     socket.setEncoding("utf8");
     let body = "";
@@ -2493,11 +2957,15 @@ async function daemonRequest(directory, input, timeout = 15e3) {
       done = true;
       socket.destroy();
       if (error) reject(error);
-      else resolve10(result2);
+      else resolve16(result2);
     };
     socket.setTimeout(
       timeout,
-      () => finish(new Error("Background service did not respond. Run teammy status."))
+      () => finish(
+        Object.assign(new Error("Background service did not respond. Run teammy repair."), {
+          code: "ETIMEDOUT"
+        })
+      )
     );
     socket.on("error", (e) => finish(e));
     socket.on("end", () => {
@@ -2521,10 +2989,28 @@ async function daemonRequest(directory, input, timeout = 15e3) {
     });
   });
 }
+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)
     ))
@@ -2537,8 +3023,8 @@ async function runningDaemon(directory) {
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname6, join as join11, resolve as resolve5 } from "node:path";
-import { mkdir as mkdir8, readFile as readFile3, writeFile as writeFile3, rename as rename3 } from "node:fs/promises";
+import { dirname as dirname8, join as join15, resolve as resolve6 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile3, writeFile as writeFile3, 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 });
@@ -2555,7 +3041,7 @@ function serviceDefinition(directory, executable, entry, platform = process.plat
   if (platform === "darwin")
     return {
       id,
-      path: join11(userHome, "Library", "LaunchAgents", id + ".plist"),
+      path: join15(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>
@@ -2564,7 +3050,7 @@ function serviceDefinition(directory, executable, entry, platform = process.plat
   if (platform === "linux")
     return {
       id: id + ".service",
-      path: join11(userHome, ".config", "systemd", "user", id + ".service"),
+      path: join15(userHome, ".config", "systemd", "user", id + ".service"),
       content: `[Unit]
 Description=Teammy background synchronization
 [Service]
@@ -2610,17 +3096,19 @@ async function bootstrapLaunchAgent(path) {
   }
 }
 async function ensureDaemon(directory, version) {
-  const definition = serviceDefinition(directory, process.execPath, resolve5(process.argv[1]));
+  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 alive = await runningDaemon(directory);
-  if (alive && old === definition.content && alive.version === version) return;
+  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(dirname6(definition.path), { recursive: true });
+  await mkdir8(dirname8(definition.path), { recursive: true });
   if (old !== definition.content) {
     const temp = definition.path + `.${process.pid}.tmp`;
     await writeFile3(temp, definition.content, { mode: 384 });
@@ -2634,33 +3122,528 @@ async function ensureDaemon(directory, version) {
       loaded = true;
     } catch {
     }
-    if (loaded && (old !== definition.content || alive?.version !== version)) {
-      await exec3("launchctl", ["bootout", target]);
-      loaded = false;
+    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(join15(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(join16(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", join16(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 = join16(directory, "backups");
+        await mkdir9(backups, { recursive: true, mode: 448 });
+        backup = join16(backups, `before-schema-${before}.sqlite3`);
+        if (!existsSync4(backup)) {
+          const temp = backup + ".tmp";
+          await rm2(temp, { force: true });
+          const db = new DatabaseSync5(join16(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(join16(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(join16(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(join16(directory, "backups"))) {
+          if (/^before-schema-\d+\.sqlite3$/.test(file) && join16(directory, "backups", file) !== backup)
+            await rm2(join16(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]
+  read        --owner MEMBER --key KEY [--revision N]
+  search      --query TEXT [--after N] [--limit N]
+
+Shared options: --root DIR (./workspaces), --state-dir DIR (~/.teammy/client).
+AGENT: claude-code, codex, cursor, pi, dsh. Project defaults to the shared root's parent.
+track/discover only register local sources. Run teammy sync to collect and publish.
+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, version) {
+  const command = args[0];
+  if (!command || ["--help", "-h", "help"].includes(command)) {
+    process.stdout.write(help);
+    return 0;
+  }
+  if (command === "hook") {
+    await runHook(args.slice(1));
+    return 0;
+  }
+  const { values } = parseArgs2({
+    args: args.slice(1),
+    options: {
+      root: { type: "string", default: resolve8("workspaces") },
+      "state-dir": { type: "string", default: join17(homedir4(), ".teammy", "client") },
+      agent: { type: "string" },
+      file: { type: "string" },
+      directory: { type: "string" },
+      "project-dir": { type: "string" },
+      "adopt-existing": { type: "boolean" },
+      owner: { type: "string" },
+      key: { type: "string" },
+      revision: { type: "string" },
+      query: { type: "string" },
+      after: { type: "string", default: "0" },
+      limit: { type: "string", default: "50" },
+      help: { type: "boolean", short: "h" },
+      all: { type: "boolean" }
+    }
+  });
+  if (values.help) {
+    process.stdout.write(help);
+    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);
+    if (!binding) throw new Error("Connect this root first.");
+    const sessions = new SessionState(state, root);
+    const client = new HubClient(binding.serverUrl, 1e4, binding);
+    let output;
+    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 = resolve8(values.file);
+      if (command === "track")
+        sessions.track(
+          AgentSchema.parse(values.agent),
+          path,
+          projectDir,
+          Boolean(values["adopt-existing"])
+        );
+      else sessions.untrack(path);
+      output = sessions.status();
+    } else if (command === "discover" || command === "undiscover") {
+      if (command === "undiscover") {
+        if (!values.directory) throw new Error("--directory is required.");
+        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": join17(
+            process.env.CLAUDE_CONFIG_DIR ?? join17(homedir4(), ".claude"),
+            "projects"
+          ),
+          codex: join17(process.env.CODEX_HOME ?? join17(homedir4(), ".codex"), "sessions"),
+          cursor: join17(
+            process.env.CURSOR_CONFIG_DIR ?? join17(homedir4(), ".cursor"),
+            "chats",
+            createHash8("md5").update(projectDir).digest("hex")
+          ),
+          pi: join17(process.env.PI_CODING_AGENT_DIR ?? join17(homedir4(), ".pi", "agent"), "sessions"),
+          dsh: void 0
+        };
+        const path = values.directory ?? defaults[agent];
+        if (!path) throw new Error("DSH requires its configured persistence --directory.");
+        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(),
+        hooks: sessions.hooks()
+      };
+    else {
+      const after = Number(values.after);
+      const limit = Number(values.limit);
+      if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+        throw new Error("Invalid pagination options.");
+      if (command === "list") output = await client.sessions(after, limit);
+      else if (command === "search") {
+        if (!values.query) throw new Error("--query is required.");
+        output = await client.searchSessions(values.query, after, limit);
+      } else if (command === "read") {
+        if (!values.owner || !values.key) throw new Error("--owner and --key are required.");
+        const revision = values.revision === void 0 ? void 0 : Number(values.revision);
+        if (revision !== void 0 && (!Number.isSafeInteger(revision) || revision < 1))
+          throw new Error("Invalid revision.");
+        const session = await client.session(values.owner, values.key, revision);
+        const snapshot = SessionSnapshotSchema.parse(
+          JSON.parse(Buffer.from(await client.downloadBlob(session.blob.sha256)).toString("utf8"))
+        );
+        output = { session, snapshot };
+      } else throw new Error("Unknown session command. Use teammy session --help.");
+    }
+    process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+    return 0;
+  } finally {
+    state.close();
+  }
+}
+
+// apps/client/sync-command.ts
+import { parseArgs as parseArgs4 } from "node:util";
+import { setTimeout as setTimeout4 } from "node:timers/promises";
+
+// apps/client/client-command.ts
+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 as readFile5, mkdir as mkdir10 } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
+async function connectProject(state, root, directory, options) {
+  const lock = acquireRootLock(root, directory);
+  try {
+    state.assertRootAvailable(root);
+    const transport = new HubClient(options.url);
+    const existing = state.binding(root);
+    const project = new ClientProjectState(state, root);
+    if (existing && existing.serverUrl !== transport.url)
+      throw new Error("This root is connected to another server.");
+    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."
+      );
+    let member = options.member;
+    if (existing && !options.reconnect && !options.tokenFile) {
+      if (member && member !== existing.memberId)
+        throw new Error("This root belongs to a different member.");
+      const client2 = new HubClient(existing.serverUrl, 1e4, existing);
+      await client2.members();
+    } else if (options.tokenFile) {
+      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);
+      if (options.project && binding2.workspaceId !== options.project)
+        throw new Error("Token belongs to a different project.");
+      state.saveBinding(root, client2.url, token, binding2);
+    } else {
+      member ??= existing?.memberId;
+      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;
+      }
     }
-    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 ? "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
@@ -2680,15 +3663,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: resolve6("workspaces") },
-  "state-dir": { type: "string", default: join12(homedir4(), ".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,
@@ -2708,54 +3770,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.");
@@ -2786,7 +3810,7 @@ async function runClientCommand(command, args, version) {
       tokenFile: values["token-file"],
       reconnect: values.reconnect
     });
-    const collection = await setupSessions(state, root, directory);
+    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"]);
@@ -2795,7 +3819,7 @@ async function runClientCommand(command, args, version) {
     if (values.json) json({ ...connected, collection, syncEnabled: !values["no-start"] });
     else result(values["no-start"] ? "\u9879\u76EE\u5DF2\u8FDE\u63A5" : "\u5DF2\u8FDE\u63A5\uFF0C\u540E\u53F0\u540C\u6B65\u5DF2\u542F\u52A8", root);
     if (collection.issues.length && !values.json)
-      result("\u90E8\u5206\u4F1A\u8BDD Hook \u672A\u914D\u7F6E", "\u540E\u53F0\u53D1\u73B0\u4ECD\u53EF\u7528\uFF0C\u8BE6\u60C5\u89C1 teammy logs");
+      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));
@@ -2806,16 +3830,16 @@ 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 mkdir10 } from "node:fs/promises";
-import { join as join14, 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 createHash9, randomUUID as randomUUID5 } from "node:crypto";
-import { link, mkdir as mkdir9, open as open4, readFile as readFile4, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname7, join as join13, resolve as resolve7 } from "node:path";
+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 createHash9("sha256").update(content).digest("hex");
 }
@@ -2833,14 +3857,14 @@ var BlobIntegrityError = class extends Error {
 var LocalBlobStore = class {
   root;
   constructor(root) {
-    this.root = resolve7(root);
+    this.root = resolve11(root);
   }
   async put(content) {
     const bytes = Buffer.from(content);
     const sha256 = hash(bytes);
     const target = this.pathFor(sha256);
-    await mkdir9(dirname7(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 {
@@ -2856,7 +3880,7 @@ var LocalBlobStore = class {
         await this.get(sha256);
       }
       if (process.platform !== "win32") {
-        let directory = dirname7(target);
+        let directory = dirname10(target);
         for (; ; ) {
           const handle = await open4(directory, "r");
           try {
@@ -2864,8 +3888,8 @@ var LocalBlobStore = class {
           } finally {
             await handle.close();
           }
-          if (directory === dirname7(this.root)) break;
-          directory = dirname7(directory);
+          if (directory === dirname10(this.root)) break;
+          directory = dirname10(directory);
         }
       }
     } finally {
@@ -2877,7 +3901,7 @@ var LocalBlobStore = class {
     const target = this.pathFor(sha256);
     let content;
     try {
-      content = await readFile4(target);
+      content = await readFile6(target);
     } catch (error) {
       if (hasCode(error, "ENOENT")) return void 0;
       throw error;
@@ -2887,7 +3911,7 @@ var LocalBlobStore = class {
   }
   pathFor(sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error("Invalid SHA-256 content identifier.");
-    return join13(this.root, "sha256", sha256.slice(0, 2), sha256);
+    return join19(this.root, "sha256", sha256.slice(0, 2), sha256);
   }
 };
 
@@ -2905,15 +3929,18 @@ 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);
-      for (const hash2 of missing2) {
+      const { missing: missing3 } = hashes.length ? await this.transport.missingBlobs(hashes) : { missing: [] };
+      for (const hash2 of missing3) {
         if (!hashes.includes(hash2)) throw new Error("Server requested unrelated content.");
         const content = await this.blobs.get(hash2);
         if (!content) throw new Error("A queued content snapshot is missing from local storage.");
@@ -2921,9 +3948,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,
@@ -2947,17 +3977,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(join14(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 : join14(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();
@@ -2987,14 +4017,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)
@@ -3022,6 +4054,7 @@ var FileSynchronizer = class _FileSynchronizer {
     };
     try {
       try {
+        if (!this.capable) await this.checkCapabilities();
         if (this.projectScope) {
           try {
             this.sharedConfig = await this.client.sharedFilesConfig();
@@ -3081,11 +4114,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)}`);
       }
@@ -3129,7 +4161,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;
@@ -3156,10 +4188,12 @@ var FileSynchronizer = class _FileSynchronizer {
       }
     }
     const ownerPath = this.projectScope ? this.root : await safePath(this.root, this.owner);
-    await mkdir10(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;
@@ -3169,7 +4203,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) => {
@@ -3193,6 +4227,7 @@ var FileSynchronizer = class _FileSynchronizer {
       }
     }
     issues.push(...scan.issues);
+    return scan.complete;
   }
   async refreshDirty(issues) {
     const blocked = /* @__PURE__ */ new Set();
@@ -3233,73 +4268,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());
   }
@@ -3342,7 +4384,7 @@ var FileSynchronizer = class _FileSynchronizer {
     }
     const job = this.index.job(owner);
     const ownerRoot = this.projectScope ? this.root : await safePath(this.root, owner);
-    await mkdir10(ownerRoot).catch((error) => {
+    await mkdir12(ownerRoot).catch((error) => {
       if (error.code !== "EEXIST") throw error;
     });
     const ownerStat = await lstat4(ownerRoot);
@@ -3397,8 +4439,9 @@ function message(error) {
 }
 
 // apps/client/sessions/synchronizer.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
-import { join as join17 } 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 createHash10 } from "node:crypto";
@@ -3408,15 +4451,15 @@ function sessionKey(agent, nativeId) {
 
 // apps/client/sessions/source.ts
 import { createReadStream, realpathSync } from "node:fs";
-import { stat, realpath as realpath5, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname9, relative as relative4, isAbsolute as isAbsolute4, sep as sep5, join as join15 } from "node:path";
+import { 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 createHash11 } from "node:crypto";
-import { basename as basename2, dirname as dirname8, resolve as resolve8 } from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { 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);
@@ -3454,33 +4497,30 @@ function fields(bytes) {
   return result2;
 }
 function readCursor(path, projectDir, checkCwd) {
-  const db = new DatabaseSync2(path, { readOnly: true });
+  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(dirname8(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 (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(dirname8(dirname8(path)));
-    const md5 = (cwd2) => createHash11("md5").update(resolve8(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 {
@@ -3496,9 +4536,8 @@ function readCursor(path, projectDir, checkCwd) {
     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) {
@@ -3541,11 +4580,11 @@ function readCursor(path, projectDir, checkCwd) {
 
 // apps/client/sessions/source.ts
 function within(project, cwd) {
-  const rel = relative4(project, cwd);
-  return rel !== ".." && !rel.startsWith(`..${sep5}`) && !isAbsolute4(rel);
+  const rel = relative5(project, cwd);
+  return rel !== ".." && !rel.startsWith(`..${sep6}`) && !isAbsolute5(rel);
 }
 var cursorEncoded = (cwd) => cwd.replace(/^[/\\]+/, "").replace(/[/\\]/g, "-");
-var cursorDatabase = (path) => basename3(path) === "store.db";
+var cursorDatabase = (path) => basename4(path) === "store.db";
 async function sourceSignature(path, agent) {
   const paths = agent === "cursor" && cursorDatabase(path) ? [path, `${path}-wal`] : [path];
   const signatures = [];
@@ -3569,12 +4608,12 @@ async function sourceSignature(path, agent) {
   return JSON.stringify(signatures);
 }
 async function cursorScope(path, project) {
-  let container = dirname9(path);
-  while (basename3(container) !== "agent-transcripts" && dirname9(container) !== container)
-    container = dirname9(container);
-  if (basename3(container) !== "agent-transcripts")
+  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 = basename3(dirname9(container));
+  const encoded = basename4(dirname12(container));
   const matches = [];
   const visit = async (directory) => {
     const prefix = cursorEncoded(directory);
@@ -3584,7 +4623,7 @@ async function cursorScope(path, project) {
     }
     if (!encoded.startsWith(prefix + "-")) return;
     for (const entry of await readdir2(directory, { withFileTypes: true })) {
-      if (entry.isDirectory() && !entry.isSymbolicLink()) await visit(join15(directory, entry.name));
+      if (entry.isDirectory() && !entry.isSymbolicLink()) await visit(join21(directory, entry.name));
     }
   };
   await visit(project);
@@ -3594,7 +4633,7 @@ async function cursorScope(path, project) {
 }
 async function readSource(agent, path, projectDir) {
   const signature2 = await sourceSignature(path, agent);
-  const project = await realpath5(projectDir);
+  const project = await realpath8(projectDir);
   if (agent === "cursor" && cursorDatabase(path)) {
     const snapshot2 = readCursor(path, projectDir, (cwd) => {
       if (!within(project, realpathSync(cwd)))
@@ -3602,7 +4641,7 @@ async function readSource(agent, path, projectDir) {
     });
     return { snapshot: snapshot2, incomplete: false, skipped: 0, signature: signature2 };
   }
-  const cursor = agent === "cursor" ? { nativeId: basename3(path, ".jsonl"), cwd: await cursorScope(path, projectDir) } : void 0;
+  const 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)
@@ -3633,7 +4672,7 @@ async function readSource(agent, path, projectDir) {
       }
       const cwd = row.cwd ?? (row.type === "session_meta" ? object(row.payload).cwd : void 0);
       if (typeof cwd === "string" && !checkedCwds.has(cwd)) {
-        const actual = await realpath5(cwd).catch((error) => {
+        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;
@@ -3654,21 +4693,54 @@ async function readSource(agent, path, projectDir) {
   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 snapshot = normalizer.finish();
-  if (!within(project, await realpath5(snapshot.cwd)))
+  if (!within(project, await realpath8(snapshot.cwd)))
     throw new Error("Session cwd is outside the registered project.");
   return { snapshot, incomplete: lastBad, skipped, signature: signature2 };
 }
 
 // apps/client/sessions/discovery.ts
 import { opendir as opendir2 } from "node:fs/promises";
-import { join as join16 } 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 = join16(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") : entry.name.endsWith(".jsonl") || agent === "dsh" && entry.name.endsWith(".jsonl.zstd")))
         yield path;
@@ -3682,10 +4754,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)) {
@@ -3701,7 +4775,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) {
@@ -3714,13 +4788,14 @@ 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;
           try {
-            const result2 = await readSource(config.agent, path, config.projectDir);
+            const result2 = await sessionWorkQueue.run(
+              () => readSource(config.agent, path, config.projectDir)
+            );
             if (!result2.snapshot.messages.length) continue;
-            reads--;
             this.state.track(config.agent, path, config.projectDir);
           } catch (error) {
             const message2 = error instanceof Error ? error.message : "Discovery failed.";
@@ -3730,8 +4805,8 @@ var SessionDiscovery = class {
               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) {
         if (error.code !== "ENOENT")
@@ -3743,6 +4818,7 @@ var SessionDiscovery = class {
         scan.nextAt = Date.now() + 3e5;
       }
     }
+    this.pending = [...this.scans.values()].some((scan) => scan.nextAt <= Date.now());
     return issues;
   }
   async refresh() {
@@ -3758,10 +4834,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(join17(directory, "blobs"));
+    this.blobs = new LocalBlobStore(join23(directory, "blobs"));
     this.index = new SessionState(state, root);
     this.discovery = new SessionDiscovery(this.index);
   }
@@ -3772,8 +4849,16 @@ var SessionSynchronizer = class {
   blobs;
   discovery;
   capable = false;
+  passAt;
+  signal;
   async cycle() {
-    const report = { published: 0, checked: 0, issues: [], warnings: [] };
+    const report = {
+      published: 0,
+      checked: 0,
+      pending: false,
+      issues: [],
+      warnings: []
+    };
     report.issues.push(
       ...await consumeHints(
         this.directory,
@@ -3783,7 +4868,10 @@ var SessionSynchronizer = class {
       )
     );
     report.warnings.push(...await this.discovery.cycle());
-    const sources = this.index.sources(void 0, 200);
+    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(
@@ -3792,60 +4880,86 @@ 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 scheduled of sources) {
-      let source = this.index.get(scheduled.path);
-      if (reads <= 0 || uploads <= 0 || report.checked >= 200) break;
-      report.checked++;
-      this.index.checked(source.path, source.lastError);
-      try {
-        if (source.pending) {
-          if (source.pendingPath !== source.path) continue;
-          if (source.retryAt > Date.now()) {
-            if (source.lastError)
-              report.issues.push(`${source.path}: ${source.lastError} (retry deferred)`);
-            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.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;
         }
-        if (observed.skipped)
+        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}: skipped ${observed.skipped} unreadable record(s); retained complete dialogue.`
+            `${source.path}: kept the previous snapshot because the damaged copy contains fewer messages.`
           );
-        if (observed.skipped && source.hash) {
-          const previous = await this.blobs.get(source.hash);
-          if (previous && JSON.parse(Buffer.from(previous).toString("utf8")).messages.length > observed.snapshot.messages.length) {
-            this.index.observed(source.path, observed.signature);
-            report.warnings.push(
-              `${source.path}: kept the previous snapshot because the damaged copy contains fewer messages.`
-            );
-            continue;
-          }
+          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 10 MiB snapshot limit.");
-        const blob = await this.blobs.put(bytes);
+      }
+      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 && !this.index.publication(key)) {
           try {
@@ -3864,38 +4978,37 @@ var SessionSynchronizer = class {
         this.index.baseline(source.path, key, revision);
         source = this.index.get(source.path);
         revision = source.revision;
-        if (source.pending) continue;
+        if (source.pending) return;
         if (source.agent === "cursor" && source.selectedPath && cursorDatabase(source.selectedPath) && !cursorDatabase(source.path)) {
           this.index.observed(source.path, observed.signature);
-          continue;
+          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;
     try {
-      const { missing: missing2 } = await this.client.missingBlobs([request.blob.sha256]);
-      if (missing2.some((hash2) => hash2 !== request.blob.sha256))
+      const { missing: missing3 } = await this.client.missingBlobs([request.blob.sha256]);
+      if (missing3.some((hash2) => hash2 !== request.blob.sha256))
         throw new Error("Server requested unrelated session content.");
-      if (missing2.length) {
+      if (missing3.length) {
         const bytes = await this.blobs.get(request.blob.sha256);
         if (!bytes) throw new Error("Queued session snapshot is missing.");
         const ref = await this.client.uploadBlob(request.blob.sha256, bytes);
@@ -3909,9 +5022,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,
@@ -4027,7 +5142,13 @@ var SyncJob = class {
       pendingPublication: false,
       issues: []
     };
-    let sessions = { published: 0, checked: 0, issues: [], warnings: [] };
+    let sessions = {
+      published: 0,
+      checked: 0,
+      pending: false,
+      issues: [],
+      warnings: []
+    };
     try {
       await verifyWorkspace(this.state, this.root);
       if (!this.controlStarted) {
@@ -4089,11 +5210,20 @@ var SyncJob = class {
         );
     }
     this.lastIssue = issueKey;
-    this.nextAt = now + (report.issues.length || this.control.enabled && (this.control.status.configError || this.control.status.reportError) ? Math.min(9e5, Math.max(this.intervalMs, 1e4) * 2 ** Math.min(this.issueCount - 1, 5)) : pendingDownloads ? 250 : this.intervalMs);
+    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
@@ -4139,7 +5269,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,
@@ -4179,16 +5309,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);
@@ -4249,10 +5392,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();
@@ -4317,7 +5510,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();
@@ -4355,8 +5556,8 @@ async function runDaemon(directory, version) {
   let timer;
   let resolveStop = () => {
   };
-  const stopped = new Promise((resolve10) => {
-    resolveStop = resolve10;
+  const stopped = new Promise((resolve16) => {
+    resolveStop = resolve16;
   });
   const stop = () => {
     closing = true;
@@ -4367,14 +5568,15 @@ async function runDaemon(directory, version) {
     await unlink4(socketPath(directory)).catch((e) => {
       if (e.code !== "ENOENT") throw e;
     });
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve16, reject) => {
       server.once("error", reject);
       server.listen(socketPath(directory), () => {
         server.off("error", reject);
-        resolve10();
+        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}`);
@@ -4394,9 +5596,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((resolve10) => server.close(() => resolve10()));
+    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();
@@ -4413,10 +5617,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.
@@ -4448,12 +5654,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 = resolve9(values["state-dir"]);
+    const directory = resolve15(values["state-dir"]);
     try {
       await runDaemon(directory, version);
       return 0;
@@ -4462,9 +5668,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(
@@ -4497,7 +5711,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" },