@teammy/server 0.0.7 → 0.0.8

package/dist/main.js

@@ -1,15 +1,92 @@
-// apps/server/ai/worker.ts
-import { setTimeout as delay } from "node:timers/promises";
+// apps/server/ai/snapshots.ts
+import { createHash as createHash4 } from "node:crypto";
 
-// apps/server/store.ts
-import { createHash, randomBytes } from "node:crypto";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+// apps/server/files.ts
+import { createHash as createHash3 } from "node:crypto";
+import { join as join2 } from "node:path";
+
+// packages/storage/local-blob-store.ts
+import { createHash, randomUUID } from "node:crypto";
+import { link, mkdir, open, readFile, unlink } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+function hash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function hasCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+var BlobIntegrityError = class extends Error {
+  constructor(sha256) {
+    super(`Stored content failed integrity verification: ${sha256}`);
+    this.sha256 = sha256;
+    this.name = "BlobIntegrityError";
+  }
+  sha256;
+};
+var LocalBlobStore = class {
+  root;
+  constructor(root) {
+    this.root = resolve(root);
+  }
+  async put(content) {
+    const bytes = Buffer.from(content);
+    const sha256 = hash(bytes);
+    const target = this.pathFor(sha256);
+    await mkdir(dirname(target), { recursive: true, mode: 448 });
+    const temporary = `${target}.${randomUUID()}.tmp`;
+    const file = await open(temporary, "wx", 384);
+    try {
+      try {
+        await file.writeFile(bytes);
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      try {
+        await link(temporary, target);
+      } catch (error) {
+        if (!hasCode(error, "EEXIST")) throw error;
+        await this.get(sha256);
+      }
+      if (process.platform !== "win32") {
+        let directory = dirname(target);
+        for (; ; ) {
+          const handle = await open(directory, "r");
+          try {
+            await handle.sync();
+          } finally {
+            await handle.close();
+          }
+          if (directory === dirname(this.root)) break;
+          directory = dirname(directory);
+        }
+      }
+    } finally {
+      await unlink(temporary);
+    }
+    return { sha256, size: bytes.byteLength };
+  }
+  async get(sha256) {
+    const target = this.pathFor(sha256);
+    let content;
+    try {
+      content = await readFile(target);
+    } catch (error) {
+      if (hasCode(error, "ENOENT")) return void 0;
+      throw error;
+    }
+    if (hash(content) !== sha256) throw new BlobIntegrityError(sha256);
+    return content;
+  }
+  pathFor(sha256) {
+    if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error("Invalid SHA-256 content identifier.");
+    return join(this.root, "sha256", sha256.slice(0, 2), sha256);
+  }
+};
 
 // packages/state/sqlite.ts
 import { chmodSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 function transaction(db, action) {
   db.exec("BEGIN IMMEDIATE");
@@ -25,7 +102,7 @@ function transaction(db, action) {
 function openDatabase(path, migrations2, busyTimeoutMs = 5e3) {
   if (!Number.isSafeInteger(busyTimeoutMs) || busyTimeoutMs < 0)
     throw new Error("Invalid SQLite busy timeout.");
-  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  mkdirSync(dirname2(path), { recursive: true, mode: 448 });
   const db = new DatabaseSync(path);
   try {
     chmodSync(path, 384);
@@ -48,17 +125,71 @@ function openDatabase(path, migrations2, busyTimeoutMs = 5e3) {
   }
 }
 
-// packages/protocol/identity.ts
+// packages/protocol/files.ts
 import { z } from "zod";
-var NameSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
-var DeviceIdSchema = z.uuid();
-var BindRequestSchema = z.object({ deviceId: DeviceIdSchema, projectId: NameSchema.optional() }).strict();
-var BindingSchema = z.object({
-  workspaceId: NameSchema,
-  memberId: NameSchema,
-  deviceId: DeviceIdSchema
+var MAX_BLOB_BYTES = 10 * 1024 * 1024;
+var MAX_BATCH_FILES = 200;
+var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var RevisionSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var FilePathSchema = z.string().min(1).max(1024).refine((path) => {
+  if (path !== path.normalize("NFC") || /[\\\x00-\x1f\x7f:<>"|?*]/.test(path)) return false;
+  return path.split("/").every(
+    (part) => part.length > 0 && part.length <= 255 && part !== "." && part !== ".." && !/[. ]$/.test(part) && !/^\.teammy(?:-|$)/i.test(part) && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part)
+  );
+}, "Path must be a portable, normalized relative file path.");
+var BlobRefSchema = z.object({
+  sha256: HashSchema,
+  size: z.number().int().min(0).max(MAX_BLOB_BYTES)
+});
+var FileChangeSchema = z.discriminatedUnion("kind", [
+  BlobRefSchema.extend({ kind: z.literal("upsert"), path: FilePathSchema }).strict(),
+  z.object({ kind: z.literal("delete"), path: FilePathSchema }).strict()
+]);
+var FileCommitSchema = z.object({
+  operationId: z.uuid(),
+  parentRevision: RevisionSchema,
+  changes: z.array(FileChangeSchema).min(1).max(MAX_BATCH_FILES)
+}).strict().refine(
+  (batch) => new Set(batch.changes.map((change) => change.path)).size === batch.changes.length,
+  "Duplicate paths in a batch."
+);
+var CommitResultSchema = z.object({ operationId: z.uuid(), revision: RevisionSchema });
+var FileEntrySchema = BlobRefSchema.extend({
+  path: FilePathSchema,
+  revision: RevisionSchema
+});
+var ManifestSchema = z.object({
+  revision: RevisionSchema,
+  files: z.array(FileEntrySchema),
+  nextCursor: z.string().nullable()
+});
+var FileRevisionSchema = z.object({
+  revision: RevisionSchema,
+  operationId: z.uuid(),
+  createdAt: z.string(),
+  changes: z.array(FileChangeSchema)
+});
+var ChangesSchema = z.object({
+  headRevision: RevisionSchema,
+  revisions: z.array(FileRevisionSchema)
+});
+var BlobCheckSchema = z.object({ hashes: z.array(HashSchema).max(MAX_BATCH_FILES) }).strict();
+var MissingBlobsSchema = z.object({ missing: z.array(HashSchema) });
+var FileTreeEntrySchema = z.discriminatedUnion("kind", [
+  FileEntrySchema.extend({ kind: z.literal("file") }),
+  z.object({
+    kind: z.literal("directory"),
+    path: FilePathSchema,
+    fileCount: z.number().int().positive()
+  })
+]);
+var FileTreeSchema = z.object({
+  revision: RevisionSchema,
+  path: z.union([z.literal(""), FilePathSchema]),
+  entries: z.array(FileTreeEntrySchema),
+  nextCursor: z.string().nullable()
 });
-var MembersSchema = z.object({ members: z.array(NameSchema) });
+var FileSelectionSchema = z.object({ revision: RevisionSchema, file: FileEntrySchema });
 
 // apps/server/errors.ts
 var HubError = class extends Error {
@@ -72,454 +203,131 @@ var HubError = class extends Error {
   code;
 };
 
-// apps/server/session-schema.ts
-var sessionMigration = String.raw`
-  CREATE TABLE sessions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, session_key TEXT NOT NULL,
-    agent TEXT NOT NULL, native_id TEXT NOT NULL, cwd TEXT NOT NULL, title TEXT NOT NULL,
-    revision INTEGER NOT NULL, updated_at TEXT NOT NULL, message_count INTEGER NOT NULL,
-    hash TEXT NOT NULL, size INTEGER NOT NULL,
-    UNIQUE(workspace_id, owner, session_key)
-  );
-  CREATE INDEX session_listing ON sessions(workspace_id, id);
-  CREATE TABLE session_revisions (
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, session_key TEXT NOT NULL,
-    revision INTEGER NOT NULL, info_json TEXT NOT NULL,
-    PRIMARY KEY(workspace_id, owner, session_key, revision)
-  );
-  CREATE TABLE session_operations (
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, operation_id TEXT NOT NULL,
-    fingerprint TEXT NOT NULL, revision INTEGER NOT NULL,
-    PRIMARY KEY(workspace_id, owner, operation_id)
-  );
-  CREATE TABLE session_messages (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, session_key TEXT NOT NULL,
-    revision INTEGER NOT NULL, message_id TEXT NOT NULL, role TEXT NOT NULL, body TEXT NOT NULL, search_text TEXT NOT NULL
-  );
-  CREATE INDEX session_message_lookup ON session_messages(workspace_id, owner, session_key);
-  CREATE VIRTUAL TABLE session_fts USING fts5(body, tokenize='trigram');
-`;
-var sessionOwnerIndexMigration = `CREATE INDEX session_owner_listing ON sessions(workspace_id,owner,id);`;
-
-// apps/server/control-schema.ts
-var controlMigration = String.raw`
- CREATE TABLE device_status(workspace_id TEXT NOT NULL,member_id TEXT NOT NULL,device_id TEXT NOT NULL,seen_at TEXT NOT NULL,status_json TEXT NOT NULL,PRIMARY KEY(workspace_id,member_id));
-`;
+// packages/protocol/shared-files.ts
+import { z as z3 } from "zod";
 
-// apps/server/device-schema.ts
-var deviceMigration = String.raw`
- CREATE TABLE device_enrollments(workspace_id TEXT NOT NULL, member_id TEXT NOT NULL, operation_id TEXT NOT NULL, fingerprint TEXT NOT NULL, PRIMARY KEY(workspace_id,member_id,operation_id));
-`;
+// packages/protocol/identity.ts
+import { z as z2 } from "zod";
+var NameSchema = z2.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+var DeviceIdSchema = z2.uuid();
+var BindRequestSchema = z2.object({ deviceId: DeviceIdSchema, projectId: NameSchema.optional() }).strict();
+var BindingSchema = z2.object({
+  workspaceId: NameSchema,
+  memberId: NameSchema,
+  deviceId: DeviceIdSchema
+});
+var MembersSchema = z2.object({ members: z2.array(NameSchema) });
 
-// apps/server/project-schema.ts
-var projectMigration = String.raw`
-  ALTER TABLE members ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1;
-  ALTER TABLE members ADD COLUMN role TEXT NOT NULL DEFAULT 'member';
-  ALTER TABLE members ADD COLUMN display_name TEXT NOT NULL DEFAULT '';
-  ALTER TABLE members ADD COLUMN member_revision INTEGER NOT NULL DEFAULT 1;
-  UPDATE members SET enabled=0 WHERE token_hash IS NULL;
-  CREATE TABLE project_settings(id INTEGER PRIMARY KEY CHECK(id=1), config_json TEXT NOT NULL, setup_operation TEXT NOT NULL, setup_fingerprint TEXT NOT NULL);
-  CREATE TABLE web_sessions(token_hash TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, member_id TEXT NOT NULL, expires_at INTEGER NOT NULL);
-`;
-var multiProjectMigration = String.raw`
-  DROP TABLE project_settings;
-  DROP TABLE web_sessions;
-  ALTER TABLE members DROP COLUMN display_name;
-  CREATE TABLE users (
-    id TEXT PRIMARY KEY, display_name TEXT NOT NULL DEFAULT '',
-    site_role TEXT NOT NULL DEFAULT 'member', enabled INTEGER NOT NULL DEFAULT 1,
-    revision INTEGER NOT NULL DEFAULT 1
-  );
-  CREATE TABLE projects (
-    id TEXT PRIMARY KEY, config_json TEXT NOT NULL,
-    operation_id TEXT NOT NULL UNIQUE, fingerprint TEXT NOT NULL
-  );
-  CREATE TABLE site_settings (
-    id INTEGER PRIMARY KEY CHECK(id=1), config_json TEXT NOT NULL,
-    setup_operation TEXT NOT NULL, setup_fingerprint TEXT NOT NULL
-  );
-  CREATE TABLE web_sessions (
-    token_hash TEXT PRIMARY KEY, member_id TEXT NOT NULL REFERENCES users(id), expires_at INTEGER NOT NULL
-  );
-  DROP TABLE ai_profiles;
-  CREATE TABLE ai_profiles (
-    id TEXT PRIMARY KEY, revision INTEGER NOT NULL, config_json TEXT NOT NULL, secret TEXT
+// packages/protocol/shared-files.ts
+var PROJECT_FILE_OWNER = "_project";
+var FileOwnerSchema = z3.union([NameSchema, z3.literal(PROJECT_FILE_OWNER)]);
+var SharedPathSchema = z3.string().max(255).refine((path) => {
+  const directory = path.endsWith("/");
+  const name = directory ? path.slice(0, -1) : path;
+  return FilePathSchema.safeParse(name).success && !name.includes("/") && !name.startsWith(".") && !/^_?teammy/i.test(name) && (directory ? name.startsWith("_") : name.includes("."));
+}, "Use a root file (README.md) or an underscore-prefixed directory (_template/).");
+var SharedFilesConfigSchema = z3.object({
+  maintainer: NameSchema.nullable(),
+  paths: z3.array(SharedPathSchema).max(30).refine((paths2) => new Set(paths2.map((p) => p.toLowerCase())).size === paths2.length),
+  revision: RevisionSchema
+}).strict();
+var SharedFilesUpdateSchema = SharedFilesConfigSchema.omit({ revision: true }).extend({ expectedRevision: RevisionSchema }).strict();
+var SharedFileCommitSchema = FileCommitSchema.safeExtend({
+  configRevision: RevisionSchema
+});
+var DEFAULT_SHARED_PATHS = ["README.md", "_template/"];
+function privateWorkspacePath(path) {
+  return path.split("/").some((part) => /^\.teammy(?:[-.]|$)/i.test(part));
+}
+function sharedPathAllowed(path, paths2) {
+  return !privateWorkspacePath(path) && paths2.some(
+    (entry) => entry.endsWith("/") ? path === entry.slice(0, -1) || path.startsWith(entry) : path === entry
   );
-`;
-var sitePolicyMigration = `
-UPDATE site_settings SET config_json=json_set(config_json,'$.sync',json(COALESCE(
- (SELECT json_extract(config_json,'$.sync') FROM projects ORDER BY rowid LIMIT 1),
- '{"checkIntervalSeconds":60,"fileSettleSeconds":60}'
-)));
-UPDATE projects SET config_json=json_set(config_json,
- '$.sync',json((SELECT json_extract(config_json,'$.sync') FROM site_settings WHERE id=1)),
- '$.configRevision',json_extract(config_json,'$.configRevision')+1)
-WHERE json_extract(config_json,'$.sync') != (SELECT json_extract(config_json,'$.sync') FROM site_settings WHERE id=1);
-`;
-var equalMembershipMigration = `
-ALTER TABLE members DROP COLUMN role;
-ALTER TABLE members ADD COLUMN display_name TEXT NOT NULL DEFAULT '';
-`;
+}
 
-// apps/server/file-schema.ts
-var fileMigration = String.raw`
-  ALTER TABLE members ADD COLUMN file_revision INTEGER NOT NULL DEFAULT 0;
-  CREATE TABLE workspace_blobs (workspace_id TEXT NOT NULL, hash TEXT NOT NULL, size INTEGER NOT NULL, PRIMARY KEY(workspace_id, hash));
-  CREATE TABLE file_operations (
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, operation_id TEXT NOT NULL,
-    fingerprint TEXT NOT NULL, revision INTEGER NOT NULL,
-    PRIMARY KEY(workspace_id, owner, operation_id)
-  );
-  CREATE TABLE file_revisions (
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, revision INTEGER NOT NULL,
-    operation_id TEXT NOT NULL, created_at TEXT NOT NULL, changes_json TEXT NOT NULL,
-    PRIMARY KEY(workspace_id, owner, revision)
-  );
-  CREATE TABLE current_files (
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, path TEXT NOT NULL, path_key TEXT NOT NULL,
-    hash TEXT NOT NULL, size INTEGER NOT NULL, revision INTEGER NOT NULL,
-    PRIMARY KEY(workspace_id, owner, path), UNIQUE(workspace_id, owner, path_key)
-  );
-  CREATE TABLE file_events (
-    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, path TEXT NOT NULL, revision INTEGER NOT NULL,
-    hash TEXT, size INTEGER,
-    PRIMARY KEY(workspace_id, owner, path, revision)
-  );
-`;
-
-// apps/server/ai/task-schema.ts
-var taskBoardMigration = `
-ALTER TABLE ai_jobs ADD COLUMN runtime_json TEXT;
-ALTER TABLE ai_jobs ADD COLUMN origin TEXT NOT NULL DEFAULT 'manual';
-CREATE TABLE task_board_members (
- workspace_id TEXT NOT NULL, owner TEXT NOT NULL, job_id TEXT NOT NULL REFERENCES ai_jobs(id),
- PRIMARY KEY(workspace_id,owner)
-);
-CREATE TABLE task_cards (
- id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, owner TEXT NOT NULL,
- job_id TEXT NOT NULL REFERENCES ai_jobs(id), fields_json TEXT NOT NULL,
- sources_json TEXT NOT NULL, synced_at TEXT NOT NULL, correction_json TEXT,
- active INTEGER NOT NULL DEFAULT 1, needs_review INTEGER NOT NULL DEFAULT 0
-);
-CREATE INDEX task_cards_scope ON task_cards(workspace_id,owner,active);
-`;
-var taskMaintenanceMigration = `
-ALTER TABLE ai_jobs ADD COLUMN task_context_json TEXT;
-ALTER TABLE task_board_members ADD COLUMN applied_job_id TEXT REFERENCES ai_jobs(id);
-UPDATE task_board_members SET applied_job_id=(
- SELECT j.id FROM ai_jobs j
- WHERE j.workspace_id=task_board_members.workspace_id AND j.status='succeeded'
- AND json_extract(j.request_json,'$.workflow')='task-bootstrap'
- AND json_extract(j.snapshot_json,'$.owner')=task_board_members.owner
- ORDER BY j.rowid DESC LIMIT 1
-);
-`;
-
-// apps/server/ai/schema.ts
-var aiConfigMigration = `
-CREATE TABLE ai_profiles (
- workspace_id TEXT NOT NULL, id TEXT NOT NULL, revision INTEGER NOT NULL,
- config_json TEXT NOT NULL, secret TEXT,
- PRIMARY KEY(workspace_id,id)
-);
-`;
-var aiJobsMigration = `
-CREATE TABLE ai_jobs (
- id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, requester TEXT NOT NULL,
- request_json TEXT NOT NULL, profile_json TEXT NOT NULL, snapshot_json TEXT NOT NULL,
- prompt_version TEXT NOT NULL, status TEXT NOT NULL, attempt_count INTEGER NOT NULL DEFAULT 0, recovery_count INTEGER NOT NULL DEFAULT 0,
- created_at TEXT NOT NULL, updated_at TEXT NOT NULL, run_token TEXT, lease_until INTEGER,
- result_json TEXT, error TEXT
-);
-CREATE INDEX ai_jobs_queue ON ai_jobs(status,created_at);
-CREATE INDEX ai_jobs_workspace ON ai_jobs(workspace_id,id);
-CREATE TABLE ai_operations(workspace_id TEXT NOT NULL,requester TEXT NOT NULL,operation_id TEXT NOT NULL,fingerprint TEXT NOT NULL,job_id TEXT NOT NULL REFERENCES ai_jobs(id),PRIMARY KEY(workspace_id,requester,operation_id));
-CREATE TABLE ai_attempts(job_id TEXT NOT NULL REFERENCES ai_jobs(id),number INTEGER NOT NULL,status TEXT NOT NULL,started_at TEXT NOT NULL,ended_at TEXT,error TEXT,usage_json TEXT,PRIMARY KEY(job_id,number));
-CREATE TABLE ai_events(seq INTEGER PRIMARY KEY AUTOINCREMENT,job_id TEXT NOT NULL REFERENCES ai_jobs(id),attempt INTEGER NOT NULL,kind TEXT NOT NULL,message TEXT NOT NULL,created_at TEXT NOT NULL);
-CREATE INDEX ai_events_job ON ai_events(job_id,seq);
-`;
-var aiDefaultsMigration = `
-CREATE TABLE ai_defaults (
- scope TEXT PRIMARY KEY, profile_id TEXT REFERENCES ai_profiles(id), revision INTEGER NOT NULL
-);
-`;
-
-// apps/server/store.ts
-function digest(token) {
-  return createHash("sha256").update(token).digest("hex");
-}
-var migrations = [
-  String.raw`
-  CREATE TABLE members (
-    workspace_id TEXT NOT NULL,
-    member_id TEXT NOT NULL,
-    token_hash TEXT UNIQUE,
-    device_id TEXT,
-    PRIMARY KEY (workspace_id, member_id)
-  );
-`,
-  fileMigration,
-  sessionMigration,
-  projectMigration,
-  deviceMigration,
-  controlMigration,
-  aiConfigMigration,
-  aiJobsMigration,
-  multiProjectMigration,
-  aiDefaultsMigration,
-  sitePolicyMigration,
-  sessionOwnerIndexMigration,
-  equalMembershipMigration,
-  taskBoardMigration,
-  taskMaintenanceMigration
-];
-var HubStore = class {
-  constructor(directory) {
-    this.directory = directory;
-    const path = join(directory, "hub.sqlite3");
-    if (existsSync(path)) {
-      const existing = new DatabaseSync2(path, { readOnly: true });
-      try {
-        const version = Number(existing.prepare("PRAGMA user_version").get().user_version);
-        if (version > 0 && version < 9)
-          throw new Error(
-            "Single-project data is not supported by this release. Start with a new --data-dir; existing data has been preserved."
-          );
-      } finally {
-        existing.close();
-      }
-    }
-    this.db = openDatabase(path, migrations);
-  }
-  directory;
-  db;
-  close() {
-    this.db.close();
-  }
-  issueMember(workspaceId, memberId, reset = false) {
-    NameSchema.parse(workspaceId);
-    NameSchema.parse(memberId);
-    const token = `tmy_${randomBytes(32).toString("hex")}`;
-    transaction(this.db, () => {
-      this.db.prepare("INSERT OR IGNORE INTO users(id) VALUES (?)").run(memberId);
-      const exists = this.db.prepare("SELECT 1 FROM members WHERE workspace_id=? AND member_id=?").get(workspaceId, memberId);
-      if (exists && !reset)
-        throw new HubError(
-          409,
-          "MEMBER_EXISTS",
-          "Member exists; use member reset to replace its credential and device binding."
-        );
-      if (!exists && reset) throw new HubError(404, "MEMBER_NOT_FOUND", "Member does not exist.");
-      this.db.prepare(
-        `INSERT INTO members (workspace_id, member_id, token_hash) VALUES (?, ?, ?)
-        ON CONFLICT(workspace_id, member_id) DO UPDATE SET token_hash=excluded.token_hash, device_id=NULL, enabled=1, member_revision=member_revision+1`
-      ).run(workspaceId, memberId, digest(token));
-    });
-    return token;
-  }
-  revokeMember(workspaceId, memberId) {
-    const result = this.db.prepare(
-      "UPDATE members SET token_hash=NULL, device_id=NULL, enabled=0, member_revision=member_revision+1 WHERE workspace_id=? AND member_id=?"
-    ).run(NameSchema.parse(workspaceId), NameSchema.parse(memberId));
-    if (!result.changes) throw new HubError(404, "MEMBER_NOT_FOUND", "Member does not exist.");
-    this.db.prepare("DELETE FROM device_status WHERE workspace_id=? AND member_id=?").run(workspaceId, memberId);
-  }
-  identity(authorization) {
-    const match = authorization?.match(/^Bearer (tmy_[a-f0-9]{64})$/);
-    const row = match && this.db.prepare(
-      "SELECT m.workspace_id,m.member_id,m.device_id FROM members m JOIN users u ON u.id=m.member_id WHERE m.token_hash=? AND m.enabled=1 AND u.enabled=1"
-    ).get(digest(match[1]));
-    if (!row) throw new HubError(401, "UNAUTHORIZED", "A valid member credential is required.");
-    return {
-      workspaceId: String(row.workspace_id),
-      memberId: String(row.member_id),
-      deviceId: row.device_id
-    };
-  }
-  bind(authorization, deviceId, projectId2) {
-    return transaction(this.db, () => {
-      const identity = this.identity(authorization);
-      if (projectId2 && projectId2 !== identity.workspaceId)
-        throw new HubError(403, "PROJECT_MISMATCH", "Token belongs to a different project.");
-      if (identity.deviceId && identity.deviceId !== deviceId)
-        throw new HubError(
-          409,
-          "DEVICE_BOUND",
-          "This member is bound to another device. An administrator must reset the binding."
-        );
-      this.db.prepare("UPDATE members SET device_id=? WHERE workspace_id=? AND member_id=?").run(deviceId, identity.workspaceId, identity.memberId);
-      return BindingSchema.parse({ ...identity, deviceId });
-    });
-  }
-  authorize(authorization, deviceId) {
-    const identity = this.identity(authorization);
-    if (!identity.deviceId || identity.deviceId !== deviceId)
-      throw new HubError(
-        403,
-        "DEVICE_MISMATCH",
-        "Connect this device before using workspace APIs."
-      );
-    return BindingSchema.parse(identity);
-  }
-  members(identity) {
-    return this.db.prepare("SELECT member_id FROM members WHERE workspace_id=? ORDER BY member_id").all(identity.workspaceId).map((row) => String(row.member_id));
-  }
-};
-
-// apps/server/ai/jobs.ts
-import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
-
-// packages/protocol/ai.ts
-import { z as z5 } from "zod";
-
-// packages/protocol/files.ts
-import { z as z2 } from "zod";
-var MAX_BLOB_BYTES = 10 * 1024 * 1024;
-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);
-var FilePathSchema = z2.string().min(1).max(1024).refine((path) => {
-  if (path !== path.normalize("NFC") || /[\\\x00-\x1f\x7f:<>"|?*]/.test(path)) return false;
-  return path.split("/").every(
-    (part) => part.length > 0 && part.length <= 255 && part !== "." && part !== ".." && !/[. ]$/.test(part) && !/^\.teammy(?:-|$)/i.test(part) && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part)
-  );
-}, "Path must be a portable, normalized relative file path.");
-var BlobRefSchema = z2.object({
-  sha256: HashSchema,
-  size: z2.number().int().min(0).max(MAX_BLOB_BYTES)
-});
-var FileChangeSchema = z2.discriminatedUnion("kind", [
-  BlobRefSchema.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)
-}).strict().refine(
-  (batch) => new Set(batch.changes.map((change) => change.path)).size === batch.changes.length,
-  "Duplicate paths in a batch."
-);
-var CommitResultSchema = z2.object({ operationId: z2.uuid(), revision: RevisionSchema });
-var FileEntrySchema = BlobRefSchema.extend({
-  path: FilePathSchema,
-  revision: RevisionSchema
-});
-var ManifestSchema = z2.object({
-  revision: RevisionSchema,
-  files: z2.array(FileEntrySchema),
-  nextCursor: z2.string().nullable()
-});
-var FileRevisionSchema = z2.object({
-  revision: RevisionSchema,
-  operationId: z2.uuid(),
-  createdAt: z2.string(),
-  changes: z2.array(FileChangeSchema)
-});
-var ChangesSchema = z2.object({
-  headRevision: RevisionSchema,
-  revisions: z2.array(FileRevisionSchema)
-});
-var BlobCheckSchema = z2.object({ hashes: z2.array(HashSchema).max(MAX_BATCH_FILES) }).strict();
-var MissingBlobsSchema = z2.object({ missing: z2.array(HashSchema) });
-var FileTreeEntrySchema = z2.discriminatedUnion("kind", [
-  FileEntrySchema.extend({ kind: z2.literal("file") }),
-  z2.object({
-    kind: z2.literal("directory"),
-    path: FilePathSchema,
-    fileCount: z2.number().int().positive()
-  })
-]);
-var FileTreeSchema = z2.object({
-  revision: RevisionSchema,
-  path: z2.union([z2.literal(""), FilePathSchema]),
-  entries: z2.array(FileTreeEntrySchema),
-  nextCursor: z2.string().nullable()
-});
-var FileSelectionSchema = z2.object({ revision: RevisionSchema, file: FileEntrySchema });
+// apps/server/project.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 
 // packages/protocol/project.ts
-import { z as z3 } from "zod";
-var ServerUrlSchema = z3.string().url().max(2048).refine((value) => {
+import { z as z4 } from "zod";
+var ServerUrlSchema = z4.string().url().max(2048).refine((value) => {
   const url = new URL(value);
   return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
 }, "Use an HTTP(S) server URL without credentials, query or fragment.");
-var SyncPolicySchema = z3.object({
-  checkIntervalSeconds: z3.number().int().min(1).max(86400),
-  fileSettleSeconds: z3.number().int().min(0).max(86400)
+var SyncPolicySchema = z4.object({
+  checkIntervalSeconds: z4.number().int().min(1).max(86400),
+  fileSettleSeconds: z4.number().int().min(0).max(86400)
 }).strict();
 var DEFAULT_POLICY = { checkIntervalSeconds: 60, fileSettleSeconds: 60 };
-var ProjectConfigSchema = z3.object({
-  schemaVersion: z3.literal(1),
+var ProjectConfigSchema = z4.object({
+  schemaVersion: z4.literal(1),
   projectId: NameSchema,
-  projectName: z3.string().trim().min(1).max(120),
-  description: z3.string().max(2e3),
+  projectName: z4.string().trim().min(1).max(120),
+  description: z4.string().max(2e3),
   publicServerUrl: ServerUrlSchema,
   configRevision: RevisionSchema,
-  scopeProfile: z3.literal("workspace-and-sessions-v1"),
+  scopeProfile: z4.literal("workspace-and-sessions-v1"),
   sync: SyncPolicySchema
 }).strict();
-var SetupSchema = z3.object({
-  operationId: z3.uuid(),
-  projectName: z3.string().trim().min(1).max(120),
-  description: z3.string().max(2e3).default(""),
+var SetupSchema = z4.object({
+  operationId: z4.uuid(),
+  projectName: z4.string().trim().min(1).max(120),
+  description: z4.string().max(2e3).default(""),
   publicServerUrl: ServerUrlSchema,
   adminId: NameSchema,
-  members: z3.array(NameSchema).max(100).default([]),
+  members: z4.array(NameSchema).max(100).default([]),
   sync: SyncPolicySchema.default(DEFAULT_POLICY)
 }).strict();
-var SetupStatusSchema = z3.object({
-  initialized: z3.boolean()
+var SetupStatusSchema = z4.object({
+  initialized: z4.boolean()
 });
 var ConfigUpdateSchema = ProjectConfigSchema.pick({
   projectName: true,
   description: true
 }).extend({ expectedRevision: RevisionSchema.optional() }).strict();
-var MemberSchema = z3.object({
+var MemberSchema = z4.object({
   id: NameSchema,
-  displayName: z3.string().max(120),
-  enabled: z3.boolean(),
-  accountEnabled: z3.boolean(),
+  displayName: z4.string().max(120),
+  enabled: z4.boolean(),
+  accountEnabled: z4.boolean(),
   revision: RevisionSchema,
-  bound: z3.boolean(),
+  bound: z4.boolean(),
   fileRevision: RevisionSchema,
-  lastPublishedAt: z3.string().nullable()
+  lastPublishedAt: z4.string().nullable()
 });
-var WebIdentitySchema = z3.object({
+var WebIdentitySchema = z4.object({
   memberId: NameSchema,
-  displayName: z3.string(),
-  siteRole: z3.enum(["admin", "member"])
+  displayName: z4.string(),
+  siteRole: z4.enum(["admin", "member"])
 });
 var WebSessionSchema = WebIdentitySchema.extend({
   workspaceId: NameSchema
 });
-var MemberCreateSchema = z3.object({
+var MemberCreateSchema = z4.object({
   id: NameSchema
 }).strict();
-var MemberUpdateSchema = z3.object({
+var MemberUpdateSchema = z4.object({
   expectedRevision: RevisionSchema,
-  displayName: z3.string().trim().max(120).optional(),
-  enabled: z3.boolean().optional()
+  displayName: z4.string().trim().max(120).optional(),
+  enabled: z4.boolean().optional()
 }).strict();
-var ProjectCreateSchema = z3.object({
-  operationId: z3.uuid(),
-  projectName: z3.string().trim().min(1).max(120),
-  description: z3.string().max(2e3).default("")
+var ProjectCreateSchema = z4.object({
+  operationId: z4.uuid(),
+  projectName: z4.string().trim().min(1).max(120),
+  description: z4.string().max(2e3).default("")
 }).strict();
-var ProjectSummarySchema = z3.object({
+var ProjectSummarySchema = z4.object({
   projectId: NameSchema,
-  projectName: z3.string(),
-  description: z3.string()
+  projectName: z4.string(),
+  description: z4.string()
 });
-var ProjectsSchema = z3.object({ projects: z3.array(ProjectSummarySchema) });
-var SiteConfigSchema = z3.object({
+var ProjectsSchema = z4.object({ projects: z4.array(ProjectSummarySchema) });
+var SiteConfigSchema = z4.object({
   sync: SyncPolicySchema,
   publicServerUrl: ServerUrlSchema,
   revision: RevisionSchema
 });
-var SiteConfigUpdateSchema = z3.object({
+var SiteConfigUpdateSchema = z4.object({
   publicServerUrl: ServerUrlSchema.optional(),
   sync: SyncPolicySchema.optional(),
   expectedRevision: RevisionSchema
@@ -527,222 +335,28 @@ var SiteConfigUpdateSchema = z3.object({
   (v) => v.publicServerUrl !== void 0 || v.sync !== void 0,
   "Provide a setting to update."
 );
-var UserSchema = z3.object({
+var UserSchema = z4.object({
   id: NameSchema,
-  displayName: z3.string(),
-  siteRole: z3.enum(["admin", "member"]),
-  enabled: z3.boolean(),
+  displayName: z4.string(),
+  siteRole: z4.enum(["admin", "member"]),
+  enabled: z4.boolean(),
   revision: RevisionSchema
 });
-var UserCreateSchema = z3.object({
+var UserCreateSchema = z4.object({
   id: NameSchema,
-  displayName: z3.string().trim().max(120).default(""),
-  siteRole: z3.enum(["admin", "member"]).default("member")
+  displayName: z4.string().trim().max(120).default(""),
+  siteRole: z4.enum(["admin", "member"]).default("member")
 }).strict();
-var UserUpdateSchema = z3.object({
+var UserUpdateSchema = z4.object({
   expectedRevision: RevisionSchema,
-  displayName: z3.string().trim().max(120).optional(),
-  enabled: z3.boolean().optional(),
-  siteRole: z3.enum(["admin", "member"]).optional()
-}).strict();
-
-// packages/protocol/tasks.ts
-import { z as z4 } from "zod";
-var TaskStatusSchema = z4.enum(["planned", "in_progress", "in_review", "completed"]);
-var TaskFieldsSchema = z4.object({
-  title: z4.string().trim().min(1).max(200),
-  goal: z4.string().trim().min(1).max(2e3).nullable(),
-  status: TaskStatusSchema.nullable(),
-  progress: z4.string().trim().min(1).max(2e3)
+  displayName: z4.string().trim().max(120).optional(),
+  enabled: z4.boolean().optional(),
+  siteRole: z4.enum(["admin", "member"]).optional()
 }).strict();
-var TaskSourceSchema = z4.object({
-  path: FilePathSchema,
-  sha256: HashSchema,
-  revision: RevisionSchema,
-  syncedAt: z4.string()
-});
-var TaskCardSchema = TaskFieldsSchema.extend({
-  id: z4.uuid(),
-  owner: NameSchema,
-  jobId: z4.uuid(),
-  sources: z4.array(TaskSourceSchema).min(1),
-  syncedAt: z4.string(),
-  corrected: z4.boolean(),
-  needsReview: z4.boolean()
-});
-var TaskCorrectionSchema = z4.object({
-  title: TaskFieldsSchema.shape.title.optional(),
-  status: TaskStatusSchema.nullable().optional()
-}).strict().refine((v) => Object.keys(v).length > 0, "Provide a correction.");
-var TaskBoardSchema = z4.object({
-  tasks: z4.array(TaskCardSchema),
-  members: z4.array(
-    z4.object({
-      owner: NameSchema,
-      jobId: z4.uuid().nullable(),
-      status: z4.enum(["empty", "waiting", "queued", "running", "succeeded", "failed", "cancelled"]),
-      error: z4.string().nullable(),
-      sourceChanged: z4.boolean(),
-      partial: z4.boolean(),
-      uncertainties: z4.array(z4.string())
-    })
-  ),
-  modelAvailable: z4.boolean()
-});
-var TaskBootstrapRequestSchema = z4.object({ operationId: z4.uuid(), owner: NameSchema }).strict();
-var TaskBootstrapResponseSchema = z4.object({
-  jobId: z4.uuid().nullable(),
-  empty: z4.boolean()
-});
-
-// packages/protocol/ai.ts
-var AiProfileSchema = z5.object({
-  id: NameSchema,
-  name: z5.string().trim().min(1).max(120),
-  protocol: z5.enum(["openai-completions", "openai-responses", "anthropic-messages"]),
-  baseUrl: ServerUrlSchema,
-  model: z5.string().trim().min(1).max(200),
-  enabled: z5.boolean().default(true),
-  contextWindow: z5.number().int().min(4096).max(2e6).default(32e3),
-  maxOutputTokens: z5.number().int().min(128).max(16e3).default(2048)
-}).strict().refine(
-  (p) => p.maxOutputTokens < p.contextWindow,
-  "Output budget must be smaller than context window."
-);
-var AiPublicProfileSchema = AiProfileSchema.safeExtend({
-  revision: z5.number().int(),
-  keyConfigured: z5.boolean()
-});
-var AiProfileUpdateSchema = z5.object({
-  expectedRevision: z5.number().int().nonnegative(),
-  profile: AiProfileSchema,
-  apiKey: z5.string().min(1).max(4096).nullable().optional()
-}).strict();
-var AiProfilesSchema = z5.object({ profiles: z5.array(AiPublicProfileSchema) });
-var AiDefaultUpdateSchema = z5.object({
-  expectedRevision: z5.number().int().nonnegative(),
-  profileId: NameSchema.nullable()
-}).strict();
-var AiDefaultSchema = z5.object({
-  revision: z5.number().int().nonnegative(),
-  profileId: NameSchema.nullable(),
-  effectiveProfileId: NameSchema.nullable(),
-  source: z5.enum(["site", "project", "none"]),
-  available: z5.boolean()
-});
-var AiProbeSchema = z5.object({ mode: z5.enum(["text", "tools", "json"]) }).strict();
-var AiProbeResultSchema = z5.object({
-  ok: z5.literal(true),
-  mode: AiProbeSchema.shape.mode,
-  streamed: z5.boolean(),
-  inputTokens: z5.number(),
-  outputTokens: z5.number()
-});
-var AiSelectionSchema = z5.object({
-  owner: NameSchema,
-  kind: z5.enum(["file", "directory"]),
-  path: z5.union([z5.literal(""), FilePathSchema]),
-  revision: z5.number().int().nonnegative().optional()
-}).strict().refine((s) => s.kind === "directory" || s.path !== "", "A file path is required.");
-var AiJobCreateSchema = z5.object({
-  operationId: z5.uuid(),
-  profileId: NameSchema.optional(),
-  workflow: z5.enum(["file-summary", "directory-analysis", "task-bootstrap"]),
-  selection: AiSelectionSchema,
-  question: z5.string().trim().max(2e3).default("")
-}).strict();
-var AiCitationSchema = z5.object({
-  path: FilePathSchema,
-  startLine: z5.number().int().positive(),
-  endLine: z5.number().int().positive(),
-  sha256: HashSchema
-});
-var AiCoverageSchema = z5.object({
-  totalFiles: z5.number().int(),
-  readFiles: z5.array(FilePathSchema),
-  partial: z5.boolean(),
-  limitations: z5.array(z5.string())
-});
-var AiResultSchema = z5.object({
-  summary: z5.string().min(1).max(2e4),
-  findings: z5.array(z5.string().max(2e3)).max(30),
-  uncertainties: z5.array(z5.string().max(2e3)).max(30),
-  citations: z5.array(AiCitationSchema).max(50),
-  coverage: AiCoverageSchema
-});
-var TaskAnalysisResultSchema = z5.object({
-  kind: z5.literal("task-bootstrap"),
-  tasks: z5.array(
-    TaskFieldsSchema.extend({
-      taskId: z5.uuid().nullable().optional(),
-      sources: z5.array(TaskSourceSchema).min(1).max(50)
-    })
-  ).max(100),
-  uncertainties: z5.array(z5.string().max(2e3)).max(50),
-  coverage: AiCoverageSchema
-});
-var AiWorkflowResultSchema = z5.union([AiResultSchema, TaskAnalysisResultSchema]);
-var AiUsageSchema = z5.object({
-  inputTokens: z5.number().nonnegative(),
-  outputTokens: z5.number().nonnegative()
-});
-var AiJobSchema = z5.object({
-  id: z5.uuid(),
-  requester: NameSchema,
-  workflow: AiJobCreateSchema.shape.workflow,
-  question: z5.string(),
-  profileId: NameSchema,
-  model: z5.string(),
-  profileRevision: z5.number().int(),
-  promptVersion: z5.string(),
-  origin: z5.enum(["manual", "automatic"]).default("manual"),
-  status: z5.enum(["queued", "running", "succeeded", "failed", "cancelled"]),
-  createdAt: z5.string(),
-  updatedAt: z5.string(),
-  attemptCount: z5.number().int(),
-  error: z5.string().nullable(),
-  input: z5.object({
-    owner: NameSchema,
-    kind: z5.enum(["file", "directory"]),
-    path: z5.string(),
-    revision: z5.number().int(),
-    fileCount: z5.number().int(),
-    fingerprint: HashSchema
-  }),
-  result: AiWorkflowResultSchema.nullable(),
-  sourceChanged: z5.boolean()
-});
-var AiJobsSchema = z5.object({
-  jobs: z5.array(AiJobSchema),
-  nextCursor: z5.string().nullable()
-});
-var AiEventSchema = z5.object({
-  seq: z5.number().int(),
-  attempt: z5.number().int(),
-  kind: z5.string(),
-  message: z5.string(),
-  createdAt: z5.string()
-});
-var AiEventsSchema = z5.object({
-  events: z5.array(AiEventSchema),
-  nextCursor: z5.number().int()
-});
-var AiAttemptSchema = z5.object({
-  number: z5.number().int(),
-  status: z5.string(),
-  startedAt: z5.string(),
-  endedAt: z5.string().nullable(),
-  error: z5.string().nullable(),
-  usage: AiUsageSchema.nullable()
-});
-var AiJobDetailSchema = z5.object({ job: AiJobSchema, attempts: z5.array(AiAttemptSchema) });
-
-// apps/server/project.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
 
 // apps/server/site.ts
-import { randomBytes as randomBytes2, createHash as createHash2 } from "node:crypto";
-var digest2 = (value) => createHash2("sha256").update(value).digest("hex");
+import { randomBytes, createHash as createHash2 } from "node:crypto";
+var digest = (value) => createHash2("sha256").update(value).digest("hex");
 function requireSiteAdmin(identity) {
   if (identity.siteRole !== "admin")
     throw new HubError(403, "SITE_ADMIN_REQUIRED", "Site administrator access required.");
@@ -791,15 +405,15 @@ var SiteRepository = class {
     const row = this.hub.db.prepare("SELECT 1 FROM users WHERE id=? AND enabled=1").get(id);
     if (!row)
       throw new HubError(401, "UNKNOWN_MEMBER", "Member ID does not exist or has been disabled.");
-    const token = randomBytes2(32).toString("hex");
+    const token = randomBytes(32).toString("hex");
     this.hub.db.prepare("DELETE FROM web_sessions WHERE expires_at<=?").run(Date.now());
-    this.hub.db.prepare("INSERT INTO web_sessions VALUES (?,?,?)").run(digest2(token), id, Date.now() + 7 * 864e5);
+    this.hub.db.prepare("INSERT INTO web_sessions VALUES (?,?,?)").run(digest(token), id, Date.now() + 7 * 864e5);
     return { token, session: this.identity(token) };
   }
   identity(token) {
     const row = token && /^[a-f0-9]{64}$/.test(token) ? this.hub.db.prepare(
       `SELECT u.* FROM web_sessions s JOIN users u ON u.id=s.member_id WHERE s.token_hash=? AND s.expires_at>? AND u.enabled=1`
-    ).get(digest2(token), Date.now()) : void 0;
+    ).get(digest(token), Date.now()) : void 0;
     if (!row)
       throw new HubError(401, "LOGIN_REQUIRED", "Please sign in with an existing member ID.");
     return {
@@ -810,7 +424,7 @@ var SiteRepository = class {
   }
   logout(token) {
     if (token)
-      this.hub.db.prepare("DELETE FROM web_sessions WHERE token_hash=?").run(digest2(token));
+      this.hub.db.prepare("DELETE FROM web_sessions WHERE token_hash=?").run(digest(token));
   }
   users(identity) {
     requireSiteAdmin(identity);
@@ -881,7 +495,7 @@ var ProjectRepository = class {
     return ProjectConfigSchema.parse(JSON.parse(String(row.config_json)));
   }
   insertProject(value, creator, url) {
-    const fingerprint = digest2(JSON.stringify([creator, value]));
+    const fingerprint = digest(JSON.stringify([creator, value]));
     const prior = this.hub.db.prepare("SELECT id,fingerprint FROM projects WHERE operation_id=?").get(value.operationId);
     if (prior) {
       if (prior.fingerprint !== fingerprint)
@@ -894,7 +508,7 @@ var ProjectRepository = class {
     }
     const config = ProjectConfigSchema.parse({
       schemaVersion: 1,
-      projectId: `proj-${randomBytes3(8).toString("hex")}`,
+      projectId: `proj-${randomBytes2(8).toString("hex")}`,
       projectName: value.projectName,
       description: value.description,
       publicServerUrl: url,
@@ -904,11 +518,12 @@ var ProjectRepository = class {
     });
     this.hub.db.prepare("INSERT INTO projects VALUES (?,?,?,?)").run(config.projectId, JSON.stringify(config), value.operationId, fingerprint);
     this.hub.db.prepare("INSERT INTO members(workspace_id,member_id) VALUES (?,?)").run(config.projectId, creator);
+    this.hub.db.prepare("INSERT INTO project_files(workspace_id,maintainer,paths_json) VALUES (?,?,?)").run(config.projectId, creator, JSON.stringify(DEFAULT_SHARED_PATHS));
     return config;
   }
   setup(input) {
     const value = SetupSchema.parse(input);
-    const fingerprint = digest2(JSON.stringify(value));
+    const fingerprint = digest(JSON.stringify(value));
     return transaction(this.hub.db, () => {
       const prior = this.hub.db.prepare("SELECT setup_operation,setup_fingerprint FROM site_settings").get();
       if (prior) {
@@ -1084,236 +699,60 @@ var ProjectRepository = class {
   }
 };
 
-// apps/server/ai/config.ts
-import { createCipheriv, createDecipheriv, randomBytes as randomBytes4 } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
-import { join as join2 } from "node:path";
-var AiConfig = class {
+// apps/server/shared-files.ts
+var sharedFilesMigration = `
+ CREATE TABLE project_files (
+   workspace_id TEXT PRIMARY KEY, maintainer TEXT, paths_json TEXT NOT NULL,
+   config_revision INTEGER NOT NULL DEFAULT 1, file_revision INTEGER NOT NULL DEFAULT 0
+ );
+ INSERT INTO project_files(workspace_id,maintainer,paths_json)
+ SELECT p.id,(SELECT member_id FROM members m JOIN users u ON u.id=m.member_id WHERE m.workspace_id=p.id AND m.enabled=1 AND u.enabled=1 ORDER BY m.rowid LIMIT 1),'["README.md","_template/"]' FROM projects p;
+`;
+var SharedFilesRepository = class {
   constructor(hub) {
     this.hub = hub;
   }
   hub;
-  key(create = false) {
-    const path = join2(this.hub.directory, "ai-secret.key");
-    if (create) {
-      try {
-        writeFileSync(path, randomBytes4(32), { flag: "wx", mode: 384 });
-      } catch (e) {
-        if (e.code !== "EEXIST") throw e;
-      }
-    }
-    const key = readFileSync(path);
-    if (key.length !== 32) throw new Error("Invalid AI secret encryption key.");
-    return key;
-  }
-  encrypt(value, id) {
-    const iv = randomBytes4(12), cipher = createCipheriv("aes-256-gcm", this.key(true), iv);
-    cipher.setAAD(Buffer.from(JSON.stringify(["site", id])));
-    const body = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
-    return [iv, cipher.getAuthTag(), body].map((b) => b.toString("base64")).join(".");
-  }
-  list() {
-    return this.hub.db.prepare("SELECT * FROM ai_profiles ORDER BY id").all().map((row) => ({
-      ...AiProfileSchema.parse(JSON.parse(String(row.config_json))),
-      revision: Number(row.revision),
-      keyConfigured: !!row.secret
-    }));
-  }
-  get(id) {
-    const profile = this.list().find((p) => p.id === id);
-    if (!profile) throw new HubError(404, "AI_PROFILE_NOT_FOUND", "Model profile not found.");
-    const { keyConfigured: _, ...result } = profile;
-    return result;
-  }
-  secret(id) {
-    const row = this.hub.db.prepare("SELECT secret FROM ai_profiles WHERE id=?").get(id);
-    if (!row?.secret) return "";
-    const [iv, tag, body] = String(row.secret).split(".").map((s) => Buffer.from(s, "base64"));
-    const cipher = createDecipheriv("aes-256-gcm", this.key(), iv);
-    cipher.setAAD(Buffer.from(JSON.stringify(["site", id])));
-    cipher.setAuthTag(tag);
-    return Buffer.concat([cipher.update(body), cipher.final()]).toString("utf8");
-  }
-  save(session, value) {
-    requireSiteAdmin(session);
-    const input = AiProfileUpdateSchema.parse(value), { profile } = input;
-    return transaction(this.hub.db, () => {
-      const old = this.hub.db.prepare("SELECT * FROM ai_profiles WHERE id=?").get(profile.id);
-      if ((old ? Number(old.revision) : 0) !== input.expectedRevision)
-        throw new HubError(
-          409,
-          "AI_CONFIG_CONFLICT",
-          "Model configuration changed; reload before saving."
-        );
-      if (!old && this.list().length >= 20)
-        throw new HubError(400, "AI_PROFILE_LIMIT", "At most 20 model profiles are supported.");
-      const secret = input.apiKey === void 0 ? old?.secret ?? null : input.apiKey === null ? null : this.encrypt(input.apiKey, profile.id);
-      this.hub.db.prepare(
-        "INSERT INTO ai_profiles VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET revision=excluded.revision,config_json=excluded.config_json,secret=excluded.secret"
-      ).run(profile.id, input.expectedRevision + 1, JSON.stringify(profile), secret);
-      return this.list().find((p) => p.id === profile.id);
+  config(identity) {
+    new ProjectRepository(this.hub).config(identity);
+    const row = this.hub.db.prepare("SELECT * FROM project_files WHERE workspace_id=?").get(identity.workspaceId);
+    if (!row)
+      throw new HubError(500, "SHARED_CONFIG_MISSING", "Project file settings are missing.");
+    return SharedFilesConfigSchema.parse({
+      maintainer: row.maintainer,
+      paths: JSON.parse(String(row.paths_json)),
+      revision: row.config_revision
     });
   }
-};
-
-// apps/server/ai/defaults.ts
-var AiDefaults = class {
-  constructor(hub) {
-    this.hub = hub;
-  }
-  hub;
-  read(scope) {
-    const row = this.hub.db.prepare("SELECT * FROM ai_defaults WHERE scope=?").get(scope);
-    return {
-      profileId: row?.profile_id ? String(row.profile_id) : null,
-      revision: Number(row?.revision ?? 0)
-    };
-  }
-  view(projectId2) {
-    const site = this.read("site");
-    const own = projectId2 ? this.read(`project:${projectId2}`) : site;
-    const effectiveProfileId = own.profileId ?? site.profileId;
-    return {
-      ...own,
-      effectiveProfileId,
-      source: projectId2 && own.profileId ? "project" : site.profileId ? "site" : "none",
-      available: !!effectiveProfileId && new AiConfig(this.hub).get(effectiveProfileId).enabled
-    };
-  }
-  site() {
-    return this.view();
-  }
-  project(projectId2) {
-    return this.view(projectId2);
-  }
-  save(scope, value) {
-    const input = AiDefaultUpdateSchema.parse(value);
-    transaction(this.hub.db, () => {
-      if (this.read(scope).revision !== input.expectedRevision)
+  update(identity, input) {
+    new ProjectRepository(this.hub).requireMember(identity);
+    const value = SharedFilesUpdateSchema.parse(input);
+    return transaction(this.hub.db, () => {
+      const current = this.config(identity);
+      if (current.revision !== value.expectedRevision)
         throw new HubError(
           409,
-          "AI_CONFIG_CONFLICT",
-          "Model default changed; reload before saving."
+          "STALE_CONFIG",
+          "Shared file settings changed; reload before saving."
         );
-      if (input.profileId && !new AiConfig(this.hub).get(input.profileId).enabled)
-        throw new HubError(400, "AI_PROFILE_DISABLED", "Model profile is disabled.");
-      this.hub.db.prepare(
-        `INSERT INTO ai_defaults VALUES(?,?,?) ON CONFLICT(scope) DO UPDATE SET profile_id=excluded.profile_id,revision=excluded.revision`
-      ).run(scope, input.profileId, input.expectedRevision + 1);
+      if (value.maintainer && !this.hub.db.prepare(
+        "SELECT 1 FROM members m JOIN users u ON u.id=m.member_id WHERE m.workspace_id=? AND m.member_id=? AND m.enabled=1 AND u.enabled=1"
+      ).get(identity.workspaceId, value.maintainer))
+        throw new HubError(400, "INVALID_MAINTAINER", "Choose an active project member.");
+      if (current.maintainer !== value.maintainer || JSON.stringify(current.paths) !== JSON.stringify(value.paths))
+        this.hub.db.prepare(
+          "UPDATE project_files SET maintainer=?,paths_json=?,config_revision=config_revision+1 WHERE workspace_id=?"
+        ).run(value.maintainer, JSON.stringify(value.paths), identity.workspaceId);
+      return this.config(identity);
     });
   }
-  saveSite(identity, value) {
-    requireSiteAdmin(identity);
-    this.save("site", value);
-    return this.site();
-  }
-  saveProject(identity, value) {
-    new ProjectRepository(this.hub).requireMember(identity);
-    this.save(`project:${identity.workspaceId}`, value);
-    return this.project(identity.workspaceId);
-  }
-  resolve(projectId2, explicit) {
-    const id = explicit ?? this.project(projectId2).effectiveProfileId;
-    if (!id)
-      throw new HubError(400, "AI_DEFAULT_REQUIRED", "Select a model or configure a default.");
-    const profile = new AiConfig(this.hub).get(id);
-    if (!profile.enabled)
-      throw new HubError(400, "AI_PROFILE_DISABLED", "Model profile is disabled.");
-    return profile;
-  }
-};
-
-// apps/server/ai/snapshots.ts
-import { createHash as createHash5 } from "node:crypto";
-
-// apps/server/files.ts
-import { createHash as createHash4 } from "node:crypto";
-import { join as join4 } from "node:path";
-
-// packages/storage/local-blob-store.ts
-import { createHash as createHash3, randomUUID } from "node:crypto";
-import { link, mkdir, open, readFile, unlink } from "node:fs/promises";
-import { dirname as dirname2, join as join3, resolve } from "node:path";
-function hash(content) {
-  return createHash3("sha256").update(content).digest("hex");
-}
-function hasCode(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
-}
-var BlobIntegrityError = class extends Error {
-  constructor(sha256) {
-    super(`Stored content failed integrity verification: ${sha256}`);
-    this.sha256 = sha256;
-    this.name = "BlobIntegrityError";
-  }
-  sha256;
-};
-var LocalBlobStore = class {
-  root;
-  constructor(root) {
-    this.root = resolve(root);
-  }
-  async put(content) {
-    const bytes = Buffer.from(content);
-    const sha256 = hash(bytes);
-    const target = this.pathFor(sha256);
-    await mkdir(dirname2(target), { recursive: true, mode: 448 });
-    const temporary = `${target}.${randomUUID()}.tmp`;
-    const file = await open(temporary, "wx", 384);
-    try {
-      try {
-        await file.writeFile(bytes);
-        await file.sync();
-      } finally {
-        await file.close();
-      }
-      try {
-        await link(temporary, target);
-      } catch (error) {
-        if (!hasCode(error, "EEXIST")) throw error;
-        await this.get(sha256);
-      }
-      if (process.platform !== "win32") {
-        let directory = dirname2(target);
-        for (; ; ) {
-          const handle = await open(directory, "r");
-          try {
-            await handle.sync();
-          } finally {
-            await handle.close();
-          }
-          if (directory === dirname2(this.root)) break;
-          directory = dirname2(directory);
-        }
-      }
-    } finally {
-      await unlink(temporary);
-    }
-    return { sha256, size: bytes.byteLength };
-  }
-  async get(sha256) {
-    const target = this.pathFor(sha256);
-    let content;
-    try {
-      content = await readFile(target);
-    } catch (error) {
-      if (hasCode(error, "ENOENT")) return void 0;
-      throw error;
-    }
-    if (hash(content) !== sha256) throw new BlobIntegrityError(sha256);
-    return content;
-  }
-  pathFor(sha256) {
-    if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error("Invalid SHA-256 content identifier.");
-    return join3(this.root, "sha256", sha256.slice(0, 2), sha256);
-  }
 };
 
 // apps/server/files.ts
 var FileRepository = class {
   constructor(hub) {
     this.hub = hub;
-    this.blobs = new LocalBlobStore(join4(hub.directory, "blobs"));
+    this.blobs = new LocalBlobStore(join2(hub.directory, "blobs"));
   }
   hub;
   blobs;
@@ -1325,7 +764,7 @@ var FileRepository = class {
   }
   async upload(authorization, device, hash2, bytes) {
     this.hub.authorize(authorization, device);
-    if (createHash4("sha256").update(bytes).digest("hex") !== HashSchema.parse(hash2))
+    if (createHash3("sha256").update(bytes).digest("hex") !== HashSchema.parse(hash2))
       throw new HubError(400, "HASH_MISMATCH", "Content does not match its SHA-256.");
     const ref = await this.blobs.put(bytes);
     transaction(this.hub.db, () => {
@@ -1342,19 +781,41 @@ var FileRepository = class {
     return bytes;
   }
   head(identity, owner) {
+    if (owner === PROJECT_FILE_OWNER) {
+      new SharedFilesRepository(this.hub).config(identity);
+      return Number(
+        this.hub.db.prepare("SELECT file_revision FROM project_files WHERE workspace_id=?").get(identity.workspaceId).file_revision
+      );
+    }
     const row = this.hub.db.prepare("SELECT file_revision FROM members WHERE workspace_id=? AND member_id=?").get(identity.workspaceId, owner);
     if (!row) throw new HubError(404, "MEMBER_NOT_FOUND", "Member is not part of this workspace.");
     return Number(row.file_revision);
   }
-  commit(authorization, device, input) {
+  commit(authorization, device, input, sharedConfigRevision) {
     const batch = FileCommitSchema.parse(input);
+    if (batch.changes.some((change) => privateWorkspacePath(change.path)))
+      throw new HubError(400, "PRIVATE_PATH", "Teammy configuration is not a shared document.");
     const changes = [...batch.changes].sort(
       (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
     );
-    const fingerprint = createHash4("sha256").update(JSON.stringify({ parentRevision: batch.parentRevision, changes })).digest("hex");
+    const fingerprint = createHash3("sha256").update(JSON.stringify({ parentRevision: batch.parentRevision, changes })).digest("hex");
     return transaction(this.hub.db, () => {
       const identity = this.hub.authorize(authorization, device);
-      const { workspaceId: workspace, memberId: owner } = identity;
+      const workspace = identity.workspaceId;
+      const owner = sharedConfigRevision === void 0 ? identity.memberId : PROJECT_FILE_OWNER;
+      if (owner === PROJECT_FILE_OWNER) {
+        const config = new SharedFilesRepository(this.hub).config(identity);
+        if (config.maintainer !== identity.memberId)
+          throw new HubError(
+            403,
+            "SHARED_FILES_READ_ONLY",
+            "Only the designated maintainer can publish project files."
+          );
+        if (config.revision !== sharedConfigRevision)
+          throw new HubError(409, "STALE_CONFIG", "Shared file settings changed.");
+        if (batch.changes.some((change) => !sharedPathAllowed(change.path, config.paths)))
+          throw new HubError(403, "SHARED_PATH_DENIED", "Path is outside the shared file list.");
+      }
       const prior = this.hub.db.prepare(
         "SELECT fingerprint, revision FROM file_operations WHERE workspace_id=? AND owner=? AND operation_id=?"
       ).get(workspace, owner, batch.operationId);
@@ -1451,7 +912,10 @@ var FileRepository = class {
           (/* @__PURE__ */ new Date()).toISOString(),
           JSON.stringify(effective)
         );
-        this.hub.db.prepare("UPDATE members SET file_revision=? WHERE workspace_id=? AND member_id=?").run(revision, workspace, owner);
+        if (owner === PROJECT_FILE_OWNER)
+          this.hub.db.prepare("UPDATE project_files SET file_revision=? WHERE workspace_id=?").run(revision, workspace);
+        else
+          this.hub.db.prepare("UPDATE members SET file_revision=? WHERE workspace_id=? AND member_id=?").run(revision, workspace, owner);
       }
       this.hub.db.prepare("INSERT INTO file_operations VALUES (?, ?, ?, ?, ?)").run(workspace, owner, batch.operationId, fingerprint, revision);
       return { operationId: batch.operationId, revision };
@@ -1567,10 +1031,15 @@ var FileRepository = class {
 };
 
 // apps/server/ai/snapshots.ts
+function taskSnapshotCurrent(hub, workspace, snapshot) {
+  const member = hub.db.prepare("SELECT file_revision FROM members WHERE workspace_id=? AND member_id=?").get(workspace, snapshot.owner);
+  const project = hub.db.prepare("SELECT file_revision FROM project_files WHERE workspace_id=?").get(workspace);
+  return Number(member?.file_revision) === snapshot.revision && Number(project?.file_revision ?? 0) === (snapshot.project?.revision ?? 0);
+}
 function snapshotDigest(files) {
-  return createHash5("sha256").update(JSON.stringify(files.map((f) => [f.path, f.sha256]))).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(files.map((f) => [f.path, f.sha256]))).digest("hex");
 }
-function captureSnapshot(hub, identity, selection, allowEmpty = false) {
+function captureScope(hub, identity, selection, allowEmpty = false) {
   const repository = new FileRepository(hub);
   const files = [];
   let cursor = "";
@@ -1600,158 +1069,832 @@ function captureSnapshot(hub, identity, selection, allowEmpty = false) {
     fingerprint: snapshotDigest(files)
   };
 }
-var SnapshotReader = class {
-  constructor(hub, identity, snapshot, budget = 6e4) {
+function captureSnapshot(hub, identity, selection, options = {}) {
+  const snapshot = captureScope(hub, identity, selection, options.allowEmpty);
+  if (options.projectReferences && hub.db.prepare("SELECT 1 FROM project_files WHERE workspace_id=?").get(identity.workspaceId)) {
+    const shared = captureScope(
+      hub,
+      identity,
+      { owner: PROJECT_FILE_OWNER, kind: "directory", path: "" },
+      true
+    );
+    snapshot.project = {
+      revision: shared.revision,
+      files: shared.files,
+      fingerprint: shared.fingerprint
+    };
+    if (shared.revision)
+      snapshot.fingerprint = createHash4("sha256").update(snapshot.fingerprint + ":" + shared.fingerprint).digest("hex");
+  }
+  return snapshot;
+}
+var SnapshotReader = class _SnapshotReader {
+  constructor(hub, identity, snapshot, budget = 6e4, sharedBudget) {
+    this.hub = hub;
+    this.identity = identity;
+    this.snapshot = snapshot;
+    this.budget = sharedBudget ?? { remaining: budget };
+  }
+  hub;
+  identity;
+  snapshot;
+  readFiles = /* @__PURE__ */ new Set();
+  lineCounts = /* @__PURE__ */ new Map();
+  readRanges = /* @__PURE__ */ new Map();
+  limitations = /* @__PURE__ */ new Set();
+  budget;
+  commonReader;
+  projectReader() {
+    const project = this.snapshot.project;
+    if (!project)
+      throw new HubError(403, "AI_SCOPE_VIOLATION", "No project reference snapshot is available.");
+    return this.commonReader ??= new _SnapshotReader(
+      this.hub,
+      this.identity,
+      { ...project, owner: PROJECT_FILE_OWNER, kind: "directory", path: "" },
+      0,
+      this.budget
+    );
+  }
+  afterIndex(after) {
+    if (!after) return 0;
+    const index = this.snapshot.files.findIndex((f) => f.path === after);
+    if (index < 0) throw new HubError(400, "AI_CURSOR_INVALID", "Unknown snapshot cursor.");
+    return index + 1;
+  }
+  fullyRead(path) {
+    let end = 0;
+    for (const range of [...this.readRanges.get(path) ?? []].sort((a, b) => a[0] - b[0])) {
+      if (range[0] > end + 1) break;
+      end = Math.max(end, range[1]);
+    }
+    return this.lineCounts.has(path) && end >= this.lineCounts.get(path);
+  }
+  list(after = "", limit = 50) {
+    const entries = this.snapshot.files.slice(
+      this.afterIndex(after),
+      this.afterIndex(after) + limit + 1
+    );
+    return {
+      files: entries.slice(0, limit).map((f) => ({ path: f.path, size: f.size })),
+      total: this.snapshot.files.length,
+      nextCursor: entries.length > limit ? entries[limit - 1].path : null
+    };
+  }
+  source(path) {
+    const file = this.snapshot.files.find((entry) => entry.path === path);
+    if (!file || !this.readFiles.has(path))
+      throw new HubError(
+        422,
+        "AI_TASK_SOURCE_INVALID",
+        "Task source must be an actually read snapshot file."
+      );
+    const row = this.hub.db.prepare(
+      "SELECT created_at FROM file_revisions WHERE workspace_id=? AND owner=? AND revision=?"
+    ).get(this.identity.workspaceId, this.snapshot.owner, file.revision);
+    if (!row)
+      throw new HubError(500, "AI_SOURCE_VERSION_MISSING", "Source revision metadata is missing.");
+    return { ...file, syncedAt: String(row.created_at) };
+  }
+  async text(path) {
+    const entry = this.snapshot.files.find((f) => f.path === path);
+    if (!entry) throw new HubError(403, "AI_SCOPE_VIOLATION", "File is outside the task snapshot.");
+    if (entry.size > 256 * 1024)
+      throw new HubError(413, "AI_FILE_LIMIT", "File exceeds the 256 KiB analysis limit.");
+    const bytes = await new FileRepository(this.hub).download(this.identity, entry.sha256);
+    if (bytes.byteLength !== entry.size || createHash4("sha256").update(bytes).digest("hex") !== entry.sha256)
+      throw new HubError(500, "AI_CONTENT_CORRUPT", "Snapshot content verification failed.");
+    let text;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
+      throw new HubError(422, "AI_TEXT_REQUIRED", "Only UTF-8 text files can be analysed.");
+    }
+    if (text.includes("\0"))
+      throw new HubError(422, "AI_TEXT_REQUIRED", "Binary files cannot be analysed.");
+    this.lineCounts.set(path, text.split("\n").length);
+    return text;
+  }
+  async read(path, startLine = 1, limit = 150) {
+    const text = await this.text(path), lines = text.split("\n");
+    if (startLine > lines.length)
+      throw new HubError(400, "AI_LINE_RANGE", "Line is outside the file.");
+    const selected = [];
+    let size = 0;
+    for (const line of lines.slice(startLine - 1, startLine - 1 + limit)) {
+      const cost = Buffer.byteLength(line) + 1;
+      if (size + cost > Math.min(12e3, this.budget.remaining)) break;
+      selected.push(line);
+      size += cost;
+    }
+    if (!selected.length) {
+      this.limitations.add("\u8BFB\u53D6\u9884\u7B97\u6216\u5355\u884C\u957F\u5EA6\u9650\u5236\u963B\u6B62\u4E86\u7EE7\u7EED\u8BFB\u53D6\u3002");
+      throw new HubError(413, "AI_READ_BUDGET", "Read budget exceeded or line is too long.");
+    }
+    this.budget.remaining -= size;
+    this.readFiles.add(path);
+    const endLine = startLine + selected.length - 1;
+    this.readRanges.set(path, [...this.readRanges.get(path) ?? [], [startLine, endLine]]);
+    return {
+      path,
+      startLine,
+      endLine,
+      totalLines: lines.length,
+      content: selected.map((line, i) => `${startLine + i}: ${line}`).join("\n"),
+      hasMore: endLine < lines.length
+    };
+  }
+  async whole(path, budget) {
+    const text = await this.text(path);
+    if (Buffer.byteLength(text) > budget)
+      throw new HubError(
+        413,
+        "AI_CONTEXT_LIMIT",
+        "File is too large for this model budget; use directory analysis to read portions."
+      );
+    this.readFiles.add(path);
+    this.readRanges.set(path, [[1, text.split("\n").length]]);
+    return text;
+  }
+  async search(query, after = "", limit = 50) {
+    const files = this.snapshot.files.slice(this.afterIndex(after), this.afterIndex(after) + limit);
+    const matches = [];
+    let scannedBytes = 0;
+    for (const file of files) {
+      if (file.size > 256 * 1024) {
+        this.limitations.add("\u90E8\u5206\u5927\u6587\u4EF6\u672A\u53C2\u4E0E\u6B63\u6587\u641C\u7D22\u3002");
+        continue;
+      }
+      if (scannedBytes + file.size > 1024 * 1024) {
+        return {
+          matches,
+          nextCursor: files[files.indexOf(file) - 1]?.path ?? after,
+          limited: true
+        };
+      }
+      scannedBytes += file.size;
+      try {
+        const lines = (await this.text(file.path)).split("\n");
+        for (let i = 0; i < lines.length; i++)
+          if (lines[i].toLowerCase().includes(query.toLowerCase())) {
+            matches.push({ path: file.path, line: i + 1, excerpt: lines[i].slice(0, 400) });
+            if (matches.length >= 30) return { matches, nextCursor: file.path, limited: true };
+          }
+      } catch (e) {
+        if (e instanceof HubError && e.code === "AI_TEXT_REQUIRED") {
+          this.limitations.add("\u90E8\u5206\u975E\u6587\u672C\u6587\u4EF6\u672A\u53C2\u4E0E\u6B63\u6587\u641C\u7D22\u3002");
+          continue;
+        }
+        throw e;
+      }
+    }
+    return {
+      matches,
+      nextCursor: files.length === limit ? files.at(-1).path : null,
+      limited: false
+    };
+  }
+};
+
+// apps/server/ai/worker.ts
+import { setTimeout as delay } from "node:timers/promises";
+
+// apps/server/store.ts
+import { createHash as createHash5, randomBytes as randomBytes3 } from "node:crypto";
+import { join as join3 } from "node:path";
+import { existsSync } from "node:fs";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
+// apps/server/session-schema.ts
+var sessionMigration = String.raw`
+  CREATE TABLE sessions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, session_key TEXT NOT NULL,
+    agent TEXT NOT NULL, native_id TEXT NOT NULL, cwd TEXT NOT NULL, title TEXT NOT NULL,
+    revision INTEGER NOT NULL, updated_at TEXT NOT NULL, message_count INTEGER NOT NULL,
+    hash TEXT NOT NULL, size INTEGER NOT NULL,
+    UNIQUE(workspace_id, owner, session_key)
+  );
+  CREATE INDEX session_listing ON sessions(workspace_id, id);
+  CREATE TABLE session_revisions (
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, session_key TEXT NOT NULL,
+    revision INTEGER NOT NULL, info_json TEXT NOT NULL,
+    PRIMARY KEY(workspace_id, owner, session_key, revision)
+  );
+  CREATE TABLE session_operations (
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, operation_id TEXT NOT NULL,
+    fingerprint TEXT NOT NULL, revision INTEGER NOT NULL,
+    PRIMARY KEY(workspace_id, owner, operation_id)
+  );
+  CREATE TABLE session_messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, session_key TEXT NOT NULL,
+    revision INTEGER NOT NULL, message_id TEXT NOT NULL, role TEXT NOT NULL, body TEXT NOT NULL, search_text TEXT NOT NULL
+  );
+  CREATE INDEX session_message_lookup ON session_messages(workspace_id, owner, session_key);
+  CREATE VIRTUAL TABLE session_fts USING fts5(body, tokenize='trigram');
+`;
+var sessionOwnerIndexMigration = `CREATE INDEX session_owner_listing ON sessions(workspace_id,owner,id);`;
+
+// apps/server/control-schema.ts
+var controlMigration = String.raw`
+ CREATE TABLE device_status(workspace_id TEXT NOT NULL,member_id TEXT NOT NULL,device_id TEXT NOT NULL,seen_at TEXT NOT NULL,status_json TEXT NOT NULL,PRIMARY KEY(workspace_id,member_id));
+`;
+
+// apps/server/device-schema.ts
+var deviceMigration = String.raw`
+ CREATE TABLE device_enrollments(workspace_id TEXT NOT NULL, member_id TEXT NOT NULL, operation_id TEXT NOT NULL, fingerprint TEXT NOT NULL, PRIMARY KEY(workspace_id,member_id,operation_id));
+`;
+
+// apps/server/project-schema.ts
+var projectMigration = String.raw`
+  ALTER TABLE members ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1;
+  ALTER TABLE members ADD COLUMN role TEXT NOT NULL DEFAULT 'member';
+  ALTER TABLE members ADD COLUMN display_name TEXT NOT NULL DEFAULT '';
+  ALTER TABLE members ADD COLUMN member_revision INTEGER NOT NULL DEFAULT 1;
+  UPDATE members SET enabled=0 WHERE token_hash IS NULL;
+  CREATE TABLE project_settings(id INTEGER PRIMARY KEY CHECK(id=1), config_json TEXT NOT NULL, setup_operation TEXT NOT NULL, setup_fingerprint TEXT NOT NULL);
+  CREATE TABLE web_sessions(token_hash TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, member_id TEXT NOT NULL, expires_at INTEGER NOT NULL);
+`;
+var multiProjectMigration = String.raw`
+  DROP TABLE project_settings;
+  DROP TABLE web_sessions;
+  ALTER TABLE members DROP COLUMN display_name;
+  CREATE TABLE users (
+    id TEXT PRIMARY KEY, display_name TEXT NOT NULL DEFAULT '',
+    site_role TEXT NOT NULL DEFAULT 'member', enabled INTEGER NOT NULL DEFAULT 1,
+    revision INTEGER NOT NULL DEFAULT 1
+  );
+  CREATE TABLE projects (
+    id TEXT PRIMARY KEY, config_json TEXT NOT NULL,
+    operation_id TEXT NOT NULL UNIQUE, fingerprint TEXT NOT NULL
+  );
+  CREATE TABLE site_settings (
+    id INTEGER PRIMARY KEY CHECK(id=1), config_json TEXT NOT NULL,
+    setup_operation TEXT NOT NULL, setup_fingerprint TEXT NOT NULL
+  );
+  CREATE TABLE web_sessions (
+    token_hash TEXT PRIMARY KEY, member_id TEXT NOT NULL REFERENCES users(id), expires_at INTEGER NOT NULL
+  );
+  DROP TABLE ai_profiles;
+  CREATE TABLE ai_profiles (
+    id TEXT PRIMARY KEY, revision INTEGER NOT NULL, config_json TEXT NOT NULL, secret TEXT
+  );
+`;
+var sitePolicyMigration = `
+UPDATE site_settings SET config_json=json_set(config_json,'$.sync',json(COALESCE(
+ (SELECT json_extract(config_json,'$.sync') FROM projects ORDER BY rowid LIMIT 1),
+ '{"checkIntervalSeconds":60,"fileSettleSeconds":60}'
+)));
+UPDATE projects SET config_json=json_set(config_json,
+ '$.sync',json((SELECT json_extract(config_json,'$.sync') FROM site_settings WHERE id=1)),
+ '$.configRevision',json_extract(config_json,'$.configRevision')+1)
+WHERE json_extract(config_json,'$.sync') != (SELECT json_extract(config_json,'$.sync') FROM site_settings WHERE id=1);
+`;
+var equalMembershipMigration = `
+ALTER TABLE members DROP COLUMN role;
+ALTER TABLE members ADD COLUMN display_name TEXT NOT NULL DEFAULT '';
+`;
+
+// apps/server/file-schema.ts
+var fileMigration = String.raw`
+  ALTER TABLE members ADD COLUMN file_revision INTEGER NOT NULL DEFAULT 0;
+  CREATE TABLE workspace_blobs (workspace_id TEXT NOT NULL, hash TEXT NOT NULL, size INTEGER NOT NULL, PRIMARY KEY(workspace_id, hash));
+  CREATE TABLE file_operations (
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, operation_id TEXT NOT NULL,
+    fingerprint TEXT NOT NULL, revision INTEGER NOT NULL,
+    PRIMARY KEY(workspace_id, owner, operation_id)
+  );
+  CREATE TABLE file_revisions (
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, revision INTEGER NOT NULL,
+    operation_id TEXT NOT NULL, created_at TEXT NOT NULL, changes_json TEXT NOT NULL,
+    PRIMARY KEY(workspace_id, owner, revision)
+  );
+  CREATE TABLE current_files (
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, path TEXT NOT NULL, path_key TEXT NOT NULL,
+    hash TEXT NOT NULL, size INTEGER NOT NULL, revision INTEGER NOT NULL,
+    PRIMARY KEY(workspace_id, owner, path), UNIQUE(workspace_id, owner, path_key)
+  );
+  CREATE TABLE file_events (
+    workspace_id TEXT NOT NULL, owner TEXT NOT NULL, path TEXT NOT NULL, revision INTEGER NOT NULL,
+    hash TEXT, size INTEGER,
+    PRIMARY KEY(workspace_id, owner, path, revision)
+  );
+`;
+
+// apps/server/ai/task-schema.ts
+var taskBoardMigration = `
+ALTER TABLE ai_jobs ADD COLUMN runtime_json TEXT;
+ALTER TABLE ai_jobs ADD COLUMN origin TEXT NOT NULL DEFAULT 'manual';
+CREATE TABLE task_board_members (
+ workspace_id TEXT NOT NULL, owner TEXT NOT NULL, job_id TEXT NOT NULL REFERENCES ai_jobs(id),
+ PRIMARY KEY(workspace_id,owner)
+);
+CREATE TABLE task_cards (
+ id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, owner TEXT NOT NULL,
+ job_id TEXT NOT NULL REFERENCES ai_jobs(id), fields_json TEXT NOT NULL,
+ sources_json TEXT NOT NULL, synced_at TEXT NOT NULL, correction_json TEXT,
+ active INTEGER NOT NULL DEFAULT 1, needs_review INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX task_cards_scope ON task_cards(workspace_id,owner,active);
+`;
+var taskMaintenanceMigration = `
+ALTER TABLE ai_jobs ADD COLUMN task_context_json TEXT;
+ALTER TABLE task_board_members ADD COLUMN applied_job_id TEXT REFERENCES ai_jobs(id);
+UPDATE task_board_members SET applied_job_id=(
+ SELECT j.id FROM ai_jobs j
+ WHERE j.workspace_id=task_board_members.workspace_id AND j.status='succeeded'
+ AND json_extract(j.request_json,'$.workflow')='task-bootstrap'
+ AND json_extract(j.snapshot_json,'$.owner')=task_board_members.owner
+ ORDER BY j.rowid DESC LIMIT 1
+);
+`;
+
+// apps/server/ai/schema.ts
+var aiConfigMigration = `
+CREATE TABLE ai_profiles (
+ workspace_id TEXT NOT NULL, id TEXT NOT NULL, revision INTEGER NOT NULL,
+ config_json TEXT NOT NULL, secret TEXT,
+ PRIMARY KEY(workspace_id,id)
+);
+`;
+var aiJobsMigration = `
+CREATE TABLE ai_jobs (
+ id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, requester TEXT NOT NULL,
+ request_json TEXT NOT NULL, profile_json TEXT NOT NULL, snapshot_json TEXT NOT NULL,
+ prompt_version TEXT NOT NULL, status TEXT NOT NULL, attempt_count INTEGER NOT NULL DEFAULT 0, recovery_count INTEGER NOT NULL DEFAULT 0,
+ created_at TEXT NOT NULL, updated_at TEXT NOT NULL, run_token TEXT, lease_until INTEGER,
+ result_json TEXT, error TEXT
+);
+CREATE INDEX ai_jobs_queue ON ai_jobs(status,created_at);
+CREATE INDEX ai_jobs_workspace ON ai_jobs(workspace_id,id);
+CREATE TABLE ai_operations(workspace_id TEXT NOT NULL,requester TEXT NOT NULL,operation_id TEXT NOT NULL,fingerprint TEXT NOT NULL,job_id TEXT NOT NULL REFERENCES ai_jobs(id),PRIMARY KEY(workspace_id,requester,operation_id));
+CREATE TABLE ai_attempts(job_id TEXT NOT NULL REFERENCES ai_jobs(id),number INTEGER NOT NULL,status TEXT NOT NULL,started_at TEXT NOT NULL,ended_at TEXT,error TEXT,usage_json TEXT,PRIMARY KEY(job_id,number));
+CREATE TABLE ai_events(seq INTEGER PRIMARY KEY AUTOINCREMENT,job_id TEXT NOT NULL REFERENCES ai_jobs(id),attempt INTEGER NOT NULL,kind TEXT NOT NULL,message TEXT NOT NULL,created_at TEXT NOT NULL);
+CREATE INDEX ai_events_job ON ai_events(job_id,seq);
+`;
+var aiDefaultsMigration = `
+CREATE TABLE ai_defaults (
+ scope TEXT PRIMARY KEY, profile_id TEXT REFERENCES ai_profiles(id), revision INTEGER NOT NULL
+);
+`;
+
+// apps/server/store.ts
+function digest2(token) {
+  return createHash5("sha256").update(token).digest("hex");
+}
+var migrations = [
+  String.raw`
+  CREATE TABLE members (
+    workspace_id TEXT NOT NULL,
+    member_id TEXT NOT NULL,
+    token_hash TEXT UNIQUE,
+    device_id TEXT,
+    PRIMARY KEY (workspace_id, member_id)
+  );
+`,
+  fileMigration,
+  sessionMigration,
+  projectMigration,
+  deviceMigration,
+  controlMigration,
+  aiConfigMigration,
+  aiJobsMigration,
+  multiProjectMigration,
+  aiDefaultsMigration,
+  sitePolicyMigration,
+  sessionOwnerIndexMigration,
+  equalMembershipMigration,
+  taskBoardMigration,
+  taskMaintenanceMigration,
+  sharedFilesMigration
+];
+var HubStore = class {
+  constructor(directory) {
+    this.directory = directory;
+    const path = join3(directory, "hub.sqlite3");
+    if (existsSync(path)) {
+      const existing = new DatabaseSync2(path, { readOnly: true });
+      try {
+        const version = Number(existing.prepare("PRAGMA user_version").get().user_version);
+        if (version > 0 && version < 9)
+          throw new Error(
+            "Single-project data is not supported by this release. Start with a new --data-dir; existing data has been preserved."
+          );
+      } finally {
+        existing.close();
+      }
+    }
+    this.db = openDatabase(path, migrations);
+  }
+  directory;
+  db;
+  close() {
+    this.db.close();
+  }
+  issueMember(workspaceId, memberId, reset = false) {
+    NameSchema.parse(workspaceId);
+    NameSchema.parse(memberId);
+    const token = `tmy_${randomBytes3(32).toString("hex")}`;
+    transaction(this.db, () => {
+      this.db.prepare("INSERT OR IGNORE INTO users(id) VALUES (?)").run(memberId);
+      const exists = this.db.prepare("SELECT 1 FROM members WHERE workspace_id=? AND member_id=?").get(workspaceId, memberId);
+      if (exists && !reset)
+        throw new HubError(
+          409,
+          "MEMBER_EXISTS",
+          "Member exists; use member reset to replace its credential and device binding."
+        );
+      if (!exists && reset) throw new HubError(404, "MEMBER_NOT_FOUND", "Member does not exist.");
+      this.db.prepare(
+        `INSERT INTO members (workspace_id, member_id, token_hash) VALUES (?, ?, ?)
+        ON CONFLICT(workspace_id, member_id) DO UPDATE SET token_hash=excluded.token_hash, device_id=NULL, enabled=1, member_revision=member_revision+1`
+      ).run(workspaceId, memberId, digest2(token));
+    });
+    return token;
+  }
+  revokeMember(workspaceId, memberId) {
+    const result = this.db.prepare(
+      "UPDATE members SET token_hash=NULL, device_id=NULL, enabled=0, member_revision=member_revision+1 WHERE workspace_id=? AND member_id=?"
+    ).run(NameSchema.parse(workspaceId), NameSchema.parse(memberId));
+    if (!result.changes) throw new HubError(404, "MEMBER_NOT_FOUND", "Member does not exist.");
+    this.db.prepare("DELETE FROM device_status WHERE workspace_id=? AND member_id=?").run(workspaceId, memberId);
+  }
+  identity(authorization) {
+    const match = authorization?.match(/^Bearer (tmy_[a-f0-9]{64})$/);
+    const row = match && this.db.prepare(
+      "SELECT m.workspace_id,m.member_id,m.device_id FROM members m JOIN users u ON u.id=m.member_id WHERE m.token_hash=? AND m.enabled=1 AND u.enabled=1"
+    ).get(digest2(match[1]));
+    if (!row) throw new HubError(401, "UNAUTHORIZED", "A valid member credential is required.");
+    return {
+      workspaceId: String(row.workspace_id),
+      memberId: String(row.member_id),
+      deviceId: row.device_id
+    };
+  }
+  bind(authorization, deviceId, projectId2) {
+    return transaction(this.db, () => {
+      const identity = this.identity(authorization);
+      if (projectId2 && projectId2 !== identity.workspaceId)
+        throw new HubError(403, "PROJECT_MISMATCH", "Token belongs to a different project.");
+      if (identity.deviceId && identity.deviceId !== deviceId)
+        throw new HubError(
+          409,
+          "DEVICE_BOUND",
+          "This member is bound to another device. An administrator must reset the binding."
+        );
+      this.db.prepare("UPDATE members SET device_id=? WHERE workspace_id=? AND member_id=?").run(deviceId, identity.workspaceId, identity.memberId);
+      return BindingSchema.parse({ ...identity, deviceId });
+    });
+  }
+  authorize(authorization, deviceId) {
+    const identity = this.identity(authorization);
+    if (!identity.deviceId || identity.deviceId !== deviceId)
+      throw new HubError(
+        403,
+        "DEVICE_MISMATCH",
+        "Connect this device before using workspace APIs."
+      );
+    return BindingSchema.parse(identity);
+  }
+  members(identity) {
+    return this.db.prepare("SELECT member_id FROM members WHERE workspace_id=? ORDER BY member_id").all(identity.workspaceId).map((row) => String(row.member_id));
+  }
+};
+
+// apps/server/ai/jobs.ts
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
+
+// packages/protocol/ai.ts
+import { z as z6 } from "zod";
+
+// packages/protocol/tasks.ts
+import { z as z5 } from "zod";
+var TaskStatusSchema = z5.enum(["planned", "in_progress", "in_review", "completed"]);
+var TaskFieldsSchema = z5.object({
+  title: z5.string().trim().min(1).max(200),
+  goal: z5.string().trim().min(1).max(2e3).nullable(),
+  status: TaskStatusSchema.nullable(),
+  progress: z5.string().trim().min(1).max(2e3)
+}).strict();
+var TaskSourceSchema = z5.object({
+  path: FilePathSchema,
+  sha256: HashSchema,
+  revision: RevisionSchema,
+  syncedAt: z5.string()
+});
+var TaskCardSchema = TaskFieldsSchema.extend({
+  id: z5.uuid(),
+  owner: NameSchema,
+  jobId: z5.uuid(),
+  sources: z5.array(TaskSourceSchema).min(1),
+  syncedAt: z5.string(),
+  corrected: z5.boolean(),
+  needsReview: z5.boolean()
+});
+var TaskCorrectionSchema = z5.object({
+  title: TaskFieldsSchema.shape.title.optional(),
+  status: TaskStatusSchema.nullable().optional()
+}).strict().refine((v) => Object.keys(v).length > 0, "Provide a correction.");
+var TaskBoardSchema = z5.object({
+  tasks: z5.array(TaskCardSchema),
+  members: z5.array(
+    z5.object({
+      owner: NameSchema,
+      jobId: z5.uuid().nullable(),
+      status: z5.enum(["empty", "waiting", "queued", "running", "succeeded", "failed", "cancelled"]),
+      error: z5.string().nullable(),
+      sourceChanged: z5.boolean(),
+      partial: z5.boolean(),
+      uncertainties: z5.array(z5.string())
+    })
+  ),
+  modelAvailable: z5.boolean()
+});
+var TaskBootstrapRequestSchema = z5.object({ operationId: z5.uuid(), owner: NameSchema }).strict();
+var TaskBootstrapResponseSchema = z5.object({
+  jobId: z5.uuid().nullable(),
+  empty: z5.boolean()
+});
+
+// packages/protocol/ai.ts
+var AiProfileSchema = z6.object({
+  id: NameSchema,
+  name: z6.string().trim().min(1).max(120),
+  protocol: z6.enum(["openai-completions", "openai-responses", "anthropic-messages"]),
+  baseUrl: ServerUrlSchema,
+  model: z6.string().trim().min(1).max(200),
+  enabled: z6.boolean().default(true),
+  contextWindow: z6.number().int().min(4096).max(2e6).default(32e3),
+  maxOutputTokens: z6.number().int().min(128).max(16e3).default(2048)
+}).strict().refine(
+  (p) => p.maxOutputTokens < p.contextWindow,
+  "Output budget must be smaller than context window."
+);
+var AiPublicProfileSchema = AiProfileSchema.safeExtend({
+  revision: z6.number().int(),
+  keyConfigured: z6.boolean()
+});
+var AiProfileUpdateSchema = z6.object({
+  expectedRevision: z6.number().int().nonnegative(),
+  profile: AiProfileSchema,
+  apiKey: z6.string().min(1).max(4096).nullable().optional()
+}).strict();
+var AiProfilesSchema = z6.object({ profiles: z6.array(AiPublicProfileSchema) });
+var AiDefaultUpdateSchema = z6.object({
+  expectedRevision: z6.number().int().nonnegative(),
+  profileId: NameSchema.nullable()
+}).strict();
+var AiDefaultSchema = z6.object({
+  revision: z6.number().int().nonnegative(),
+  profileId: NameSchema.nullable(),
+  effectiveProfileId: NameSchema.nullable(),
+  source: z6.enum(["site", "project", "none"]),
+  available: z6.boolean()
+});
+var AiProbeSchema = z6.object({ mode: z6.enum(["text", "tools", "json"]) }).strict();
+var AiProbeResultSchema = z6.object({
+  ok: z6.literal(true),
+  mode: AiProbeSchema.shape.mode,
+  streamed: z6.boolean(),
+  inputTokens: z6.number(),
+  outputTokens: z6.number()
+});
+var AiSelectionSchema = z6.object({
+  owner: NameSchema,
+  kind: z6.enum(["file", "directory"]),
+  path: z6.union([z6.literal(""), FilePathSchema]),
+  revision: z6.number().int().nonnegative().optional()
+}).strict().refine((s) => s.kind === "directory" || s.path !== "", "A file path is required.");
+var AiJobCreateSchema = z6.object({
+  operationId: z6.uuid(),
+  profileId: NameSchema.optional(),
+  workflow: z6.enum(["file-summary", "directory-analysis", "task-bootstrap"]),
+  selection: AiSelectionSchema,
+  question: z6.string().trim().max(2e3).default("")
+}).strict();
+var AiCitationSchema = z6.object({
+  path: FilePathSchema,
+  startLine: z6.number().int().positive(),
+  endLine: z6.number().int().positive(),
+  sha256: HashSchema
+});
+var AiCoverageSchema = z6.object({
+  totalFiles: z6.number().int(),
+  readFiles: z6.array(FilePathSchema),
+  partial: z6.boolean(),
+  limitations: z6.array(z6.string())
+});
+var AiResultSchema = z6.object({
+  summary: z6.string().min(1).max(2e4),
+  findings: z6.array(z6.string().max(2e3)).max(30),
+  uncertainties: z6.array(z6.string().max(2e3)).max(30),
+  citations: z6.array(AiCitationSchema).max(50),
+  coverage: AiCoverageSchema
+});
+var TaskAnalysisResultSchema = z6.object({
+  kind: z6.literal("task-bootstrap"),
+  tasks: z6.array(
+    TaskFieldsSchema.extend({
+      taskId: z6.uuid().nullable().optional(),
+      sources: z6.array(TaskSourceSchema).min(1).max(50)
+    })
+  ).max(100),
+  uncertainties: z6.array(z6.string().max(2e3)).max(50),
+  coverage: AiCoverageSchema
+});
+var AiWorkflowResultSchema = z6.union([AiResultSchema, TaskAnalysisResultSchema]);
+var AiUsageSchema = z6.object({
+  inputTokens: z6.number().nonnegative(),
+  outputTokens: z6.number().nonnegative()
+});
+var AiJobSchema = z6.object({
+  id: z6.uuid(),
+  requester: NameSchema,
+  workflow: AiJobCreateSchema.shape.workflow,
+  question: z6.string(),
+  profileId: NameSchema,
+  model: z6.string(),
+  profileRevision: z6.number().int(),
+  promptVersion: z6.string(),
+  origin: z6.enum(["manual", "automatic"]).default("manual"),
+  status: z6.enum(["queued", "running", "succeeded", "failed", "cancelled"]),
+  createdAt: z6.string(),
+  updatedAt: z6.string(),
+  attemptCount: z6.number().int(),
+  error: z6.string().nullable(),
+  input: z6.object({
+    owner: NameSchema,
+    kind: z6.enum(["file", "directory"]),
+    path: z6.string(),
+    revision: z6.number().int(),
+    fileCount: z6.number().int(),
+    fingerprint: HashSchema
+  }),
+  result: AiWorkflowResultSchema.nullable(),
+  sourceChanged: z6.boolean()
+});
+var AiJobsSchema = z6.object({
+  jobs: z6.array(AiJobSchema),
+  nextCursor: z6.string().nullable()
+});
+var AiEventSchema = z6.object({
+  seq: z6.number().int(),
+  attempt: z6.number().int(),
+  kind: z6.string(),
+  message: z6.string(),
+  createdAt: z6.string()
+});
+var AiEventsSchema = z6.object({
+  events: z6.array(AiEventSchema),
+  nextCursor: z6.number().int()
+});
+var AiAttemptSchema = z6.object({
+  number: z6.number().int(),
+  status: z6.string(),
+  startedAt: z6.string(),
+  endedAt: z6.string().nullable(),
+  error: z6.string().nullable(),
+  usage: AiUsageSchema.nullable()
+});
+var AiJobDetailSchema = z6.object({ job: AiJobSchema, attempts: z6.array(AiAttemptSchema) });
+
+// apps/server/ai/config.ts
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes4 } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join as join4 } from "node:path";
+var AiConfig = class {
+  constructor(hub) {
+    this.hub = hub;
+  }
+  hub;
+  key(create = false) {
+    const path = join4(this.hub.directory, "ai-secret.key");
+    if (create) {
+      try {
+        writeFileSync(path, randomBytes4(32), { flag: "wx", mode: 384 });
+      } catch (e) {
+        if (e.code !== "EEXIST") throw e;
+      }
+    }
+    const key = readFileSync(path);
+    if (key.length !== 32) throw new Error("Invalid AI secret encryption key.");
+    return key;
+  }
+  encrypt(value, id) {
+    const iv = randomBytes4(12), cipher = createCipheriv("aes-256-gcm", this.key(true), iv);
+    cipher.setAAD(Buffer.from(JSON.stringify(["site", id])));
+    const body = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+    return [iv, cipher.getAuthTag(), body].map((b) => b.toString("base64")).join(".");
+  }
+  list() {
+    return this.hub.db.prepare("SELECT * FROM ai_profiles ORDER BY id").all().map((row) => ({
+      ...AiProfileSchema.parse(JSON.parse(String(row.config_json))),
+      revision: Number(row.revision),
+      keyConfigured: !!row.secret
+    }));
+  }
+  get(id) {
+    const profile = this.list().find((p) => p.id === id);
+    if (!profile) throw new HubError(404, "AI_PROFILE_NOT_FOUND", "Model profile not found.");
+    const { keyConfigured: _, ...result } = profile;
+    return result;
+  }
+  secret(id) {
+    const row = this.hub.db.prepare("SELECT secret FROM ai_profiles WHERE id=?").get(id);
+    if (!row?.secret) return "";
+    const [iv, tag, body] = String(row.secret).split(".").map((s) => Buffer.from(s, "base64"));
+    const cipher = createDecipheriv("aes-256-gcm", this.key(), iv);
+    cipher.setAAD(Buffer.from(JSON.stringify(["site", id])));
+    cipher.setAuthTag(tag);
+    return Buffer.concat([cipher.update(body), cipher.final()]).toString("utf8");
+  }
+  save(session, value) {
+    requireSiteAdmin(session);
+    const input = AiProfileUpdateSchema.parse(value), { profile } = input;
+    return transaction(this.hub.db, () => {
+      const old = this.hub.db.prepare("SELECT * FROM ai_profiles WHERE id=?").get(profile.id);
+      if ((old ? Number(old.revision) : 0) !== input.expectedRevision)
+        throw new HubError(
+          409,
+          "AI_CONFIG_CONFLICT",
+          "Model configuration changed; reload before saving."
+        );
+      if (!old && this.list().length >= 20)
+        throw new HubError(400, "AI_PROFILE_LIMIT", "At most 20 model profiles are supported.");
+      const secret = input.apiKey === void 0 ? old?.secret ?? null : input.apiKey === null ? null : this.encrypt(input.apiKey, profile.id);
+      this.hub.db.prepare(
+        "INSERT INTO ai_profiles VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET revision=excluded.revision,config_json=excluded.config_json,secret=excluded.secret"
+      ).run(profile.id, input.expectedRevision + 1, JSON.stringify(profile), secret);
+      return this.list().find((p) => p.id === profile.id);
+    });
+  }
+};
+
+// apps/server/ai/defaults.ts
+var AiDefaults = class {
+  constructor(hub) {
     this.hub = hub;
-    this.identity = identity;
-    this.snapshot = snapshot;
-    this.remaining = budget;
   }
   hub;
-  identity;
-  snapshot;
-  readFiles = /* @__PURE__ */ new Set();
-  lineCounts = /* @__PURE__ */ new Map();
-  readRanges = /* @__PURE__ */ new Map();
-  limitations = /* @__PURE__ */ new Set();
-  remaining;
-  afterIndex(after) {
-    if (!after) return 0;
-    const index = this.snapshot.files.findIndex((f) => f.path === after);
-    if (index < 0) throw new HubError(400, "AI_CURSOR_INVALID", "Unknown snapshot cursor.");
-    return index + 1;
-  }
-  fullyRead(path) {
-    let end = 0;
-    for (const range of [...this.readRanges.get(path) ?? []].sort((a, b) => a[0] - b[0])) {
-      if (range[0] > end + 1) break;
-      end = Math.max(end, range[1]);
-    }
-    return this.lineCounts.has(path) && end >= this.lineCounts.get(path);
+  read(scope) {
+    const row = this.hub.db.prepare("SELECT * FROM ai_defaults WHERE scope=?").get(scope);
+    return {
+      profileId: row?.profile_id ? String(row.profile_id) : null,
+      revision: Number(row?.revision ?? 0)
+    };
   }
-  list(after = "", limit = 50) {
-    const entries = this.snapshot.files.slice(
-      this.afterIndex(after),
-      this.afterIndex(after) + limit + 1
-    );
+  view(projectId2) {
+    const site = this.read("site");
+    const own = projectId2 ? this.read(`project:${projectId2}`) : site;
+    const effectiveProfileId = own.profileId ?? site.profileId;
     return {
-      files: entries.slice(0, limit).map((f) => ({ path: f.path, size: f.size })),
-      total: this.snapshot.files.length,
-      nextCursor: entries.length > limit ? entries[limit - 1].path : null
+      ...own,
+      effectiveProfileId,
+      source: projectId2 && own.profileId ? "project" : site.profileId ? "site" : "none",
+      available: !!effectiveProfileId && new AiConfig(this.hub).get(effectiveProfileId).enabled
     };
   }
-  source(path) {
-    const file = this.snapshot.files.find((entry) => entry.path === path);
-    if (!file || !this.readFiles.has(path))
-      throw new HubError(
-        422,
-        "AI_TASK_SOURCE_INVALID",
-        "Task source must be an actually read snapshot file."
-      );
-    const row = this.hub.db.prepare(
-      "SELECT created_at FROM file_revisions WHERE workspace_id=? AND owner=? AND revision=?"
-    ).get(this.identity.workspaceId, this.snapshot.owner, file.revision);
-    if (!row)
-      throw new HubError(500, "AI_SOURCE_VERSION_MISSING", "Source revision metadata is missing.");
-    return { ...file, syncedAt: String(row.created_at) };
+  site() {
+    return this.view();
   }
-  async text(path) {
-    const entry = this.snapshot.files.find((f) => f.path === path);
-    if (!entry) throw new HubError(403, "AI_SCOPE_VIOLATION", "File is outside the task snapshot.");
-    if (entry.size > 256 * 1024)
-      throw new HubError(413, "AI_FILE_LIMIT", "File exceeds the 256 KiB analysis limit.");
-    const bytes = await new FileRepository(this.hub).download(this.identity, entry.sha256);
-    if (bytes.byteLength !== entry.size || createHash5("sha256").update(bytes).digest("hex") !== entry.sha256)
-      throw new HubError(500, "AI_CONTENT_CORRUPT", "Snapshot content verification failed.");
-    let text;
-    try {
-      text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    } catch {
-      throw new HubError(422, "AI_TEXT_REQUIRED", "Only UTF-8 text files can be analysed.");
-    }
-    if (text.includes("\0"))
-      throw new HubError(422, "AI_TEXT_REQUIRED", "Binary files cannot be analysed.");
-    this.lineCounts.set(path, text.split("\n").length);
-    return text;
+  project(projectId2) {
+    return this.view(projectId2);
   }
-  async read(path, startLine = 1, limit = 150) {
-    const text = await this.text(path), lines = text.split("\n");
-    if (startLine > lines.length)
-      throw new HubError(400, "AI_LINE_RANGE", "Line is outside the file.");
-    const selected = [];
-    let size = 0;
-    for (const line of lines.slice(startLine - 1, startLine - 1 + limit)) {
-      const cost = Buffer.byteLength(line) + 1;
-      if (size + cost > Math.min(12e3, this.remaining)) break;
-      selected.push(line);
-      size += cost;
-    }
-    if (!selected.length) {
-      this.limitations.add("\u8BFB\u53D6\u9884\u7B97\u6216\u5355\u884C\u957F\u5EA6\u9650\u5236\u963B\u6B62\u4E86\u7EE7\u7EED\u8BFB\u53D6\u3002");
-      throw new HubError(413, "AI_READ_BUDGET", "Read budget exceeded or line is too long.");
-    }
-    this.remaining -= size;
-    this.readFiles.add(path);
-    const endLine = startLine + selected.length - 1;
-    this.readRanges.set(path, [...this.readRanges.get(path) ?? [], [startLine, endLine]]);
-    return {
-      path,
-      startLine,
-      endLine,
-      totalLines: lines.length,
-      content: selected.map((line, i) => `${startLine + i}: ${line}`).join("\n"),
-      hasMore: endLine < lines.length
-    };
+  save(scope, value) {
+    const input = AiDefaultUpdateSchema.parse(value);
+    transaction(this.hub.db, () => {
+      if (this.read(scope).revision !== input.expectedRevision)
+        throw new HubError(
+          409,
+          "AI_CONFIG_CONFLICT",
+          "Model default changed; reload before saving."
+        );
+      if (input.profileId && !new AiConfig(this.hub).get(input.profileId).enabled)
+        throw new HubError(400, "AI_PROFILE_DISABLED", "Model profile is disabled.");
+      this.hub.db.prepare(
+        `INSERT INTO ai_defaults VALUES(?,?,?) ON CONFLICT(scope) DO UPDATE SET profile_id=excluded.profile_id,revision=excluded.revision`
+      ).run(scope, input.profileId, input.expectedRevision + 1);
+    });
   }
-  async whole(path, budget) {
-    const text = await this.text(path);
-    if (Buffer.byteLength(text) > budget)
-      throw new HubError(
-        413,
-        "AI_CONTEXT_LIMIT",
-        "File is too large for this model budget; use directory analysis to read portions."
-      );
-    this.readFiles.add(path);
-    this.readRanges.set(path, [[1, text.split("\n").length]]);
-    return text;
+  saveSite(identity, value) {
+    requireSiteAdmin(identity);
+    this.save("site", value);
+    return this.site();
   }
-  async search(query, after = "", limit = 50) {
-    const files = this.snapshot.files.slice(this.afterIndex(after), this.afterIndex(after) + limit);
-    const matches = [];
-    let scannedBytes = 0;
-    for (const file of files) {
-      if (file.size > 256 * 1024) {
-        this.limitations.add("\u90E8\u5206\u5927\u6587\u4EF6\u672A\u53C2\u4E0E\u6B63\u6587\u641C\u7D22\u3002");
-        continue;
-      }
-      if (scannedBytes + file.size > 1024 * 1024) {
-        return {
-          matches,
-          nextCursor: files[files.indexOf(file) - 1]?.path ?? after,
-          limited: true
-        };
-      }
-      scannedBytes += file.size;
-      try {
-        const lines = (await this.text(file.path)).split("\n");
-        for (let i = 0; i < lines.length; i++)
-          if (lines[i].toLowerCase().includes(query.toLowerCase())) {
-            matches.push({ path: file.path, line: i + 1, excerpt: lines[i].slice(0, 400) });
-            if (matches.length >= 30) return { matches, nextCursor: file.path, limited: true };
-          }
-      } catch (e) {
-        if (e instanceof HubError && e.code === "AI_TEXT_REQUIRED") {
-          this.limitations.add("\u90E8\u5206\u975E\u6587\u672C\u6587\u4EF6\u672A\u53C2\u4E0E\u6B63\u6587\u641C\u7D22\u3002");
-          continue;
-        }
-        throw e;
-      }
-    }
-    return {
-      matches,
-      nextCursor: files.length === limit ? files.at(-1).path : null,
-      limited: false
-    };
+  saveProject(identity, value) {
+    new ProjectRepository(this.hub).requireMember(identity);
+    this.save(`project:${identity.workspaceId}`, value);
+    return this.project(identity.workspaceId);
+  }
+  resolve(projectId2, explicit) {
+    const id = explicit ?? this.project(projectId2).effectiveProfileId;
+    if (!id)
+      throw new HubError(400, "AI_DEFAULT_REQUIRED", "Select a model or configure a default.");
+    const profile = new AiConfig(this.hub).get(id);
+    if (!profile.enabled)
+      throw new HubError(400, "AI_PROFILE_DISABLED", "Model profile is disabled.");
+    return profile;
   }
 };
 
@@ -1760,32 +1903,32 @@ import { createHash as createHash6 } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { z as z6 } from "zod";
-var WorkflowNameSchema = z6.enum(["file-summary", "directory-analysis", "task-bootstrap"]);
-var ToolNameSchema = z6.enum(["list_files", "read_file", "search_files"]);
-var ToolTextSchema = z6.object({ label: z6.string().min(1).max(100), description: z6.string().min(1).max(2e3) }).strict();
-var RuntimeConfigSchema = z6.object({
-  version: z6.number().int().positive(),
-  thinkingLevel: z6.enum(["off", "minimal", "low", "medium", "high"]),
-  tools: z6.array(ToolNameSchema).max(3).refine((v) => new Set(v).size === v.length),
-  maxRounds: z6.number().int().min(1).max(100),
-  maxToolCalls: z6.number().int().min(1).max(500),
-  timeoutMs: z6.number().int().min(1e3).max(9e5),
-  requestTimeoutMs: z6.number().int().min(1e3).max(12e4),
-  maxReadBytes: z6.number().int().min(1024).max(2e6),
-  settleSeconds: z6.number().int().min(0).max(3600).optional()
+import { z as z7 } from "zod";
+var WorkflowNameSchema = z7.enum(["file-summary", "directory-analysis", "task-bootstrap"]);
+var ToolNameSchema = z7.enum(["list_files", "read_file", "search_files"]);
+var ToolTextSchema = z7.object({ label: z7.string().min(1).max(100), description: z7.string().min(1).max(2e3) }).strict();
+var RuntimeConfigSchema = z7.object({
+  version: z7.number().int().positive(),
+  thinkingLevel: z7.enum(["off", "minimal", "low", "medium", "high"]),
+  tools: z7.array(ToolNameSchema).max(3).refine((v) => new Set(v).size === v.length),
+  maxRounds: z7.number().int().min(1).max(100),
+  maxToolCalls: z7.number().int().min(1).max(500),
+  timeoutMs: z7.number().int().min(1e3).max(9e5),
+  requestTimeoutMs: z7.number().int().min(1e3).max(12e4),
+  maxReadBytes: z7.number().int().min(1024).max(2e6),
+  settleSeconds: z7.number().int().min(0).max(3600).optional()
 }).strict();
-var WorkflowRuntimeSchema = z6.object({
+var WorkflowRuntimeSchema = z7.object({
   workflow: WorkflowNameSchema,
-  system: z6.string().min(1).max(32e3),
-  prompt: z6.string().min(1).max(32e3),
+  system: z7.string().min(1).max(32e3),
+  prompt: z7.string().min(1).max(32e3),
   config: RuntimeConfigSchema,
-  toolText: z6.object({
+  toolText: z7.object({
     list_files: ToolTextSchema,
     read_file: ToolTextSchema,
     search_files: ToolTextSchema
   }).strict(),
-  fingerprint: z6.string().regex(/^[a-f0-9]{64}$/)
+  fingerprint: z7.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
 function loadWorkflow(workflow, directory = process.env.TEAMMY_AI_RUNTIME_DIR) {
   try {
@@ -1823,7 +1966,7 @@ function workflowPrompt(runtime, schema) {
 ${runtime.prompt}
 
 JSON Schema:
-${JSON.stringify(z6.toJSONSchema(schema))}`;
+${JSON.stringify(z7.toJSONSchema(schema))}`;
 }
 
 // apps/server/ai/access.ts
@@ -1853,8 +1996,7 @@ function applyTaskResult(hub, job, result) {
   const current = hub.db.prepare("SELECT job_id FROM task_board_members WHERE workspace_id=? AND owner=?").get(job.workspace, job.snapshot.owner);
   if (current?.job_id !== job.id)
     throw new HubError(409, "AI_TASK_SUPERSEDED", "A newer workspace analysis exists.");
-  const head = hub.db.prepare("SELECT file_revision FROM members WHERE workspace_id=? AND member_id=?").get(job.workspace, job.snapshot.owner);
-  if (Number(head?.file_revision) !== job.snapshot.revision)
+  if (!taskSnapshotCurrent(hub, job.workspace, job.snapshot))
     throw new HubError(
       409,
       "AI_SOURCE_CHANGED",
@@ -1954,7 +2096,7 @@ var TaskStore = class {
           jobId: row.job_id ?? null,
           status: row.status ?? (row.has_files ? "waiting" : "empty"),
           error: row.error ?? null,
-          sourceChanged: snapshot ? snapshot.revision !== Number(row.file_revision) : false,
+          sourceChanged: snapshot ? !taskSnapshotCurrent(this.hub, session.workspaceId, snapshot) : false,
           partial: result?.coverage.partial ?? false,
           uncertainties: result ? [...result.uncertainties, ...result.coverage.limitations] : []
         };
@@ -2023,7 +2165,10 @@ var AiJobs = class {
           this.hub,
           { workspaceId: String(row.workspace_id), memberId: String(row.requester) },
           { owner: snapshot.owner, kind: snapshot.kind, path: snapshot.path },
-          request.workflow === "task-bootstrap"
+          {
+            allowEmpty: request.workflow === "task-bootstrap",
+            projectReferences: request.workflow === "task-bootstrap"
+          }
         ).fingerprint !== snapshot.fingerprint;
       } catch {
         sourceChanged = true;
@@ -2144,18 +2289,21 @@ var AiJobs = class {
         "Task bootstrap uses the current complete member workspace without an additional question."
       );
     const id = this.operation(session, input.operationId, { action: "create", ...input }, () => {
-      const snapshot = captureSnapshot(
-        this.hub,
-        session,
-        input.selection,
-        input.workflow === "task-bootstrap"
-      );
+      const snapshot = captureSnapshot(this.hub, session, input.selection, {
+        allowEmpty: input.workflow === "task-bootstrap",
+        projectReferences: input.workflow === "task-bootstrap"
+      });
       if (input.workflow === "task-bootstrap") {
         if (origin === "automatic") {
           const published = this.hub.db.prepare(
-            "SELECT created_at FROM file_revisions WHERE workspace_id=? AND owner=? AND revision=?"
-          ).get(session.workspaceId, snapshot.owner, snapshot.revision);
-          if (!published || (scheduledAt ?? Date.now()) - Date.parse(String(published.created_at)) < resource.config.settleSeconds * 1e3)
+            "SELECT MAX(created_at) created_at FROM file_revisions WHERE workspace_id=? AND ((owner=? AND revision=?) OR (owner='_project' AND revision=?))"
+          ).get(
+            session.workspaceId,
+            snapshot.owner,
+            snapshot.revision,
+            snapshot.project?.revision ?? 0
+          );
+          if (!published?.created_at || (scheduledAt ?? Date.now()) - Date.parse(String(published.created_at)) < resource.config.settleSeconds * 1e3)
             throw new HubError(
               409,
               "AI_TASK_UNSETTLED",
@@ -2169,7 +2317,7 @@ var AiJobs = class {
         if (latest) {
           const previous = JSON.parse(String(latest.snapshot_json));
           if (["queued", "running"].includes(String(latest.status))) {
-            if (origin === "manual" && previous.revision === snapshot.revision)
+            if (origin === "manual" && previous.revision === snapshot.revision && (previous.project?.revision ?? 0) === (snapshot.project?.revision ?? 0))
               return String(latest.id);
             throw new HubError(
               409,
@@ -2177,7 +2325,7 @@ var AiJobs = class {
               "This member already has an analysis in progress."
             );
           }
-          if (origin === "automatic" && previous.revision === snapshot.revision)
+          if (origin === "automatic" && previous.revision === snapshot.revision && (previous.project?.revision ?? 0) === (snapshot.project?.revision ?? 0))
             throw new HubError(
               409,
               "AI_TASK_CURRENT",
@@ -2368,7 +2516,7 @@ import { InMemoryCredentialStore, InMemoryModelsStore } from "@earendil-works/pi
 
 // apps/server/ai/tools.ts
 import { Type } from "@earendil-works/pi-ai";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function analysisTools(reader, signal, progress, runtime) {
   let calls = 0;
   const guard = () => {
@@ -2387,15 +2535,21 @@ function analysisTools(reader, signal, progress, runtime) {
       name: "list_files",
       ...runtime.toolText.list_files,
       parameters: Type.Object(
-        { after: Type.Optional(Type.String({ maxLength: 1024 })) },
+        {
+          after: Type.Optional(Type.String({ maxLength: 1024 })),
+          scope: Type.Optional(Type.Union([Type.Literal("member"), Type.Literal("project")]))
+        },
         { additionalProperties: false }
       ),
       executionMode: "sequential",
       async execute(_id, params) {
         guard();
-        const p = z7.object({ after: z7.string().max(1024).default("") }).strict().parse(params);
+        const p = z8.object({
+          after: z8.string().max(1024).default(""),
+          scope: z8.enum(["member", "project"]).default("member")
+        }).strict().parse(params);
         progress("list", "\u6D4F\u89C8\u6587\u4EF6\u6E05\u5355\u3002");
-        return reply(reader.list(p.after, 30));
+        return reply((p.scope === "project" ? reader.projectReader() : reader).list(p.after, 30));
       }
     },
     {
@@ -2404,6 +2558,7 @@ function analysisTools(reader, signal, progress, runtime) {
       parameters: Type.Object(
         {
           path: Type.String(),
+          scope: Type.Optional(Type.Union([Type.Literal("member"), Type.Literal("project")])),
           startLine: Type.Optional(Type.Integer({ minimum: 1 })),
           limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 150 }))
         },
@@ -2412,13 +2567,20 @@ function analysisTools(reader, signal, progress, runtime) {
       executionMode: "sequential",
       async execute(_id, params) {
         guard();
-        const p = z7.object({
+        const p = z8.object({
           path: FilePathSchema,
-          startLine: z7.number().int().min(1).max(1e6).default(1),
-          limit: z7.number().int().min(1).max(150).default(150)
+          scope: z8.enum(["member", "project"]).default("member"),
+          startLine: z8.number().int().min(1).max(1e6).default(1),
+          limit: z8.number().int().min(1).max(150).default(150)
         }).strict().parse(params);
         progress("read", `\u8BFB\u53D6 ${p.path}\uFF0C\u7B2C ${p.startLine} \u884C\u8D77\u3002`);
-        return reply(await reader.read(p.path, p.startLine, p.limit));
+        return reply(
+          await (p.scope === "project" ? reader.projectReader() : reader).read(
+            p.path,
+            p.startLine,
+            p.limit
+          )
+        );
       }
     },
     {
@@ -2434,7 +2596,7 @@ function analysisTools(reader, signal, progress, runtime) {
       executionMode: "sequential",
       async execute(_id, params) {
         guard();
-        const p = z7.object({ query: z7.string().min(1).max(200), after: z7.string().max(1024).default("") }).strict().parse(params);
+        const p = z8.object({ query: z8.string().min(1).max(200), after: z8.string().max(1024).default("") }).strict().parse(params);
         progress("search", "\u641C\u7D22\u5FEB\u7167\u6B63\u6587\u3002");
         return reply(await reader.search(p.query, p.after));
       }
@@ -2704,16 +2866,16 @@ async function runAgent(profile, reader, key, signal, progress, runtime, systemP
 }
 
 // apps/server/ai/results.ts
-import { z as z8 } from "zod";
-var SummaryOutputSchema = z8.object({
-  summary: z8.string().min(1).max(2e4),
-  findings: z8.array(z8.string().max(2e3)).max(30),
-  uncertainties: z8.array(z8.string().max(2e3)).max(30),
-  citations: z8.array(
-    z8.object({
+import { z as z9 } from "zod";
+var SummaryOutputSchema = z9.object({
+  summary: z9.string().min(1).max(2e4),
+  findings: z9.array(z9.string().max(2e3)).max(30),
+  uncertainties: z9.array(z9.string().max(2e3)).max(30),
+  citations: z9.array(
+    z9.object({
       path: FilePathSchema,
-      startLine: z8.number().int().positive(),
-      endLine: z8.number().int().positive()
+      startLine: z9.number().int().positive(),
+      endLine: z9.number().int().positive()
     }).strict()
   ).min(1).max(50)
 }).strict();
@@ -2826,15 +2988,15 @@ async function summarizeFile(job, reader, key, signal, runtime) {
 }
 
 // apps/server/ai/workflows/task-bootstrap.ts
-import { z as z9 } from "zod";
-var TaskOutputSchema = z9.object({
-  tasks: z9.array(
+import { z as z10 } from "zod";
+var TaskOutputSchema = z10.object({
+  tasks: z10.array(
     TaskFieldsSchema.extend({
-      taskId: z9.uuid().nullable().optional(),
-      sources: z9.array(FilePathSchema).min(1).max(50).refine((v) => new Set(v).size === v.length)
+      taskId: z10.uuid().nullable().optional(),
+      sources: z10.array(FilePathSchema).min(1).max(50).refine((v) => new Set(v).size === v.length)
     })
   ).max(100),
-  uncertainties: z9.array(z9.string().max(2e3)).max(50)
+  uncertainties: z10.array(z10.string().max(2e3)).max(50)
 }).strict();
 function validateTasks(text, reader, context) {
   let output;
@@ -2893,7 +3055,8 @@ async function bootstrapTasks(job, reader, key, signal, progress, runtime) {
       owner: job.snapshot.owner,
       revision: job.snapshot.revision,
       inventory: reader.list("", 100),
-      previous: job.taskContext
+      previous: job.taskContext,
+      projectReferences: job.snapshot.project ? reader.projectReader().list("", 100) : null
     }
   );
   return { result: validateTasks(output.text, reader, job.taskContext), usage: output.usage };
@@ -2914,13 +3077,15 @@ function requestTaskBootstrap(hub, session, owner, operationId) {
 }
 function scheduleTaskBootstraps(hub, at = Date.now()) {
   const candidates = hub.db.prepare(
-    `SELECT m.workspace_id,m.member_id,r.created_at
+    `SELECT m.workspace_id,m.member_id,MAX(r.created_at,COALESCE(pr.created_at,r.created_at)) created_at
     FROM members m JOIN projects p ON p.id=m.workspace_id JOIN users u ON u.id=m.member_id
     JOIN file_revisions r ON r.workspace_id=m.workspace_id AND r.owner=m.member_id AND r.revision=m.file_revision
+    LEFT JOIN project_files pf ON pf.workspace_id=m.workspace_id
+    LEFT JOIN file_revisions pr ON pr.workspace_id=m.workspace_id AND pr.owner='_project' AND pr.revision=pf.file_revision
     LEFT JOIN task_board_members b ON b.workspace_id=m.workspace_id AND b.owner=m.member_id LEFT JOIN ai_jobs j ON j.id=b.job_id
     WHERE m.enabled=1 AND u.enabled=1 AND (
       (b.job_id IS NULL AND EXISTS(SELECT 1 FROM current_files f WHERE f.workspace_id=m.workspace_id AND f.owner=m.member_id))
-      OR (j.status IN ('succeeded','failed','cancelled') AND json_extract(j.snapshot_json,'$.revision') < m.file_revision)
+      OR (j.status IN ('succeeded','failed','cancelled') AND (json_extract(j.snapshot_json,'$.revision') < m.file_revision OR COALESCE(json_extract(j.snapshot_json,'$.project.revision'),0) < COALESCE(pf.file_revision,0)))
     )
     ORDER BY r.created_at,m.workspace_id,m.member_id`
   ).all();
@@ -2985,8 +3150,7 @@ async function runAiCycle(hub, stop) {
     if (!requesterActive())
       throw new HubError(403, "AI_REQUESTER_DISABLED", "Requester is disabled.");
     if (job.request.workflow === "task-bootstrap") {
-      const current = hub.db.prepare("SELECT file_revision FROM members WHERE workspace_id=? AND member_id=?").get(job.workspace, job.snapshot.owner);
-      if (Number(current?.file_revision) !== job.snapshot.revision)
+      if (!taskSnapshotCurrent(hub, job.workspace, job.snapshot))
         throw new HubError(
           409,
           "AI_SOURCE_CHANGED",
@@ -3083,7 +3247,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { parseArgs } from "node:util";
 
 // apps/server/ai/job-routes.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // apps/server/web-auth.ts
 function cookieToken(request) {
@@ -3129,10 +3293,10 @@ function authorizeRead(store, request) {
 // apps/server/ai/job-routes.ts
 function registerAiJobRoutes(server, hub) {
   const jobs = new AiJobs(hub);
-  const id = (params) => z10.object({ id: z10.uuid() }).parse(params).id;
+  const id = (params) => z11.object({ id: z11.uuid() }).parse(params).id;
   server.get("/ai/jobs", async (req) => {
-    const session = authorizeWeb(hub, req), query = z10.object({
-      after: z10.string().regex(/^\d{0,15}$/).default("")
+    const session = authorizeWeb(hub, req), query = z11.object({
+      after: z11.string().regex(/^\d{0,15}$/).default("")
     }).parse(req.query);
     return jobs.list(session.workspaceId, query.after);
   });
@@ -3145,7 +3309,7 @@ function registerAiJobRoutes(server, hub) {
     async (req) => jobs.get(authorizeWeb(hub, req).workspaceId, id(req.params))
   );
   server.get("/ai/jobs/:id/events", async (req) => {
-    const query = z10.object({ after: z10.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0) }).parse(req.query);
+    const query = z11.object({ after: z11.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0) }).parse(req.query);
     return jobs.events(authorizeWeb(hub, req).workspaceId, id(req.params), query.after);
   });
   server.post("/ai/jobs/:id/cancel", async (req) => {
@@ -3157,13 +3321,13 @@ function registerAiJobRoutes(server, hub) {
     return jobs.retry(
       authorizeWeb(hub, req),
       id(req.params),
-      z10.object({ operationId: z10.uuid() }).strict().parse(req.body).operationId
+      z11.object({ operationId: z11.uuid() }).strict().parse(req.body).operationId
     );
   });
   server.get("/ai/jobs/:id/source", async (req) => {
     const session = authorizeWeb(hub, req), jobId = id(req.params);
     jobs.get(session.workspaceId, jobId);
-    const query = z10.object({ path: z10.string().max(1024), startLine: z10.coerce.number().int().min(1).default(1) }).parse(req.query);
+    const query = z11.object({ path: z11.string().max(1024), startLine: z11.coerce.number().int().min(1).default(1) }).parse(req.query);
     const row = hub.db.prepare("SELECT snapshot_json FROM ai_jobs WHERE id=? AND workspace_id=?").get(jobId, session.workspaceId);
     if (!row) throw new HubError(404, "AI_JOB_NOT_FOUND", "Task not found.");
     return new SnapshotReader(hub, session, JSON.parse(String(row.snapshot_json))).read(
@@ -3175,10 +3339,10 @@ function registerAiJobRoutes(server, hub) {
 }
 
 // apps/server/ai/task-routes.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function registerTaskRoutes(server, hub) {
   const store = new TaskStore(hub);
-  const id = (params) => z11.object({ id: z11.uuid() }).parse(params).id;
+  const id = (params) => z12.object({ id: z12.uuid() }).parse(params).id;
   server.get("/tasks", async (req) => store.board(authorizeWeb(hub, req)));
   server.post("/tasks/bootstrap", async (req) => {
     webMutation(req);
@@ -3312,20 +3476,20 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import Fastify from "fastify";
 
 // packages/protocol/index.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var PROTOCOL_VERSION = 1;
-var HealthSchema = z12.object({ status: z12.literal("ok") });
-var ServerInfoSchema = z12.object({
-  name: z12.literal("teammy"),
-  version: z12.string().min(1),
-  protocolVersion: z12.literal(PROTOCOL_VERSION),
-  capabilities: z12.array(z12.string())
+var HealthSchema = z13.object({ status: z13.literal("ok") });
+var ServerInfoSchema = z13.object({
+  name: z13.literal("teammy"),
+  version: z13.string().min(1),
+  protocolVersion: z13.literal(PROTOCOL_VERSION),
+  capabilities: z13.array(z13.string())
 });
-var ErrorResponseSchema = z12.object({
-  error: z12.object({
-    code: z12.string(),
-    message: z12.string(),
-    requestId: z12.string()
+var ErrorResponseSchema = z13.object({
+  error: z13.object({
+    code: z13.string(),
+    message: z13.string(),
+    requestId: z13.string()
   })
 });
 
@@ -3333,43 +3497,43 @@ var ErrorResponseSchema = z12.object({
 import { ZodError } from "zod";
 
 // packages/protocol/devices.ts
-import { z as z13 } from "zod";
-var CredentialSchema = z13.string().regex(/^tmy_[a-f0-9]{64}$/);
-var EnrollmentSchema = z13.object({
-  operationId: z13.uuid(),
+import { z as z14 } from "zod";
+var CredentialSchema = z14.string().regex(/^tmy_[a-f0-9]{64}$/);
+var EnrollmentSchema = z14.object({
+  operationId: z14.uuid(),
   projectId: NameSchema,
   memberId: NameSchema,
   deviceId: DeviceIdSchema,
   credential: CredentialSchema
 }).strict();
-var EffectivePolicySchema = z13.object({
-  checkIntervalSeconds: z13.number().min(1).max(86400),
-  fileSettleSeconds: z13.number().min(0).max(86400)
+var EffectivePolicySchema = z14.object({
+  checkIntervalSeconds: z14.number().min(1).max(86400),
+  fileSettleSeconds: z14.number().min(0).max(86400)
 }).strict();
-var SyncSummarySchema = z13.object({
-  checkedAt: z13.string(),
-  published: z13.boolean(),
-  appliedFiles: z13.number().int().nonnegative(),
-  pendingFiles: z13.number().int().nonnegative(),
-  sessionSources: z13.number().int().nonnegative(),
-  errors: z13.array(z13.string().max(1e3)).max(20)
+var SyncSummarySchema = z14.object({
+  checkedAt: z14.string(),
+  published: z14.boolean(),
+  appliedFiles: z14.number().int().nonnegative(),
+  pendingFiles: z14.number().int().nonnegative(),
+  sessionSources: z14.number().int().nonnegative(),
+  errors: z14.array(z14.string().max(1e3)).max(20)
 }).strict();
-var DeviceStatusSchema = z13.object({
-  clientVersion: z13.string().max(64),
+var DeviceStatusSchema = z14.object({
+  clientVersion: z14.string().max(64),
   receivedRevision: RevisionSchema.nullable(),
   appliedRevision: RevisionSchema.nullable(),
   effectivePolicy: EffectivePolicySchema,
-  overrides: z13.array(z13.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
-  configError: z13.string().max(2e3).nullable(),
-  reportError: z13.string().max(2e3).nullable(),
+  overrides: z14.array(z14.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
+  configError: z14.string().max(2e3).nullable(),
+  reportError: z14.string().max(2e3).nullable(),
   lastSync: SyncSummarySchema.nullable()
 }).strict();
-var WebDevicesSchema = z13.object({
-  devices: z13.array(
-    z13.object({
+var WebDevicesSchema = z14.object({
+  devices: z14.array(
+    z14.object({
       memberId: NameSchema,
-      bound: z13.boolean(),
-      lastSeenAt: z13.string().nullable(),
+      bound: z14.boolean(),
+      lastSeenAt: z14.string().nullable(),
       status: DeviceStatusSchema.nullable()
     })
   )
@@ -3407,7 +3571,7 @@ function registerControlRoutes(server, store) {
 }
 
 // apps/server/project-routes.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function registerProjectRoutes(server, store) {
   const project = new ProjectRepository(store), site = new SiteRepository(store);
   server.get("/api/v1/projects", async (request) => ({
@@ -3454,7 +3618,7 @@ function registerProjectScopeRoutes(server, store) {
   });
   server.patch("/web/members/:id", async (request) => {
     webMutation(request);
-    const { id } = z14.object({ id: NameSchema }).parse(request.params);
+    const { id } = z15.object({ id: NameSchema }).parse(request.params);
     return project.updateMember(
       authorizeWeb(store, request),
       id,
@@ -3463,13 +3627,13 @@ function registerProjectScopeRoutes(server, store) {
   });
   server.post("/web/members/:id/device-reset", async (request) => {
     webMutation(request);
-    const { id } = z14.object({ id: NameSchema }).parse(request.params);
+    const { id } = z15.object({ id: NameSchema }).parse(request.params);
     return project.resetDevice(authorizeWeb(store, request), id);
   });
 }
 
 // apps/server/site-routes.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // apps/server/devices.ts
 var DeviceRepository = class {
@@ -3487,7 +3651,7 @@ var DeviceRepository = class {
       ).get(projectId2, value.memberId);
       if (!member)
         throw new HubError(401, "UNKNOWN_MEMBER", "Member ID does not exist or has been disabled.");
-      const fingerprint = digest2(JSON.stringify(value));
+      const fingerprint = digest(JSON.stringify(value));
       const prior = this.hub.db.prepare(
         "SELECT fingerprint FROM device_enrollments WHERE workspace_id=? AND member_id=? AND operation_id=?"
       ).get(projectId2, value.memberId, value.operationId);
@@ -3497,7 +3661,7 @@ var DeviceRepository = class {
           "OPERATION_MISMATCH",
           "Enrollment operation was reused with different content."
         );
-      const tokenHash = digest2(value.credential);
+      const tokenHash = digest(value.credential);
       if (prior) {
         if (member.token_hash !== tokenHash || member.device_id !== value.deviceId)
           throw new HubError(
@@ -3545,7 +3709,7 @@ function registerSiteRoutes(server, store) {
     "/api/v1/web/session",
     { onRequest: async (request) => webMutation(request) },
     async (request, reply) => {
-      const { id } = z15.object({ id: NameSchema }).strict().parse(request.body);
+      const { id } = z16.object({ id: NameSchema }).strict().parse(request.body);
       const { token, session } = site.login(id);
       const secure = request.protocol === "https" || request.headers.origin?.startsWith("https://");
       reply.header(
@@ -3559,7 +3723,7 @@ function registerSiteRoutes(server, store) {
   server.patch("/api/v1/web/session", async (request) => {
     webMutation(request);
     const identity = site.identity(cookieToken(request));
-    const { displayName } = z15.object({ displayName: z15.string().trim().max(120) }).strict().parse(request.body);
+    const { displayName } = z16.object({ displayName: z16.string().trim().max(120) }).strict().parse(request.body);
     return site.renameSelf(identity, displayName);
   });
   server.delete("/api/v1/web/session", async (request, reply) => {
@@ -3600,71 +3764,71 @@ function registerSiteRoutes(server, store) {
 }
 
 // apps/server/session-routes.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // packages/protocol/sessions.ts
-import { z as z16 } from "zod";
-var AgentSchema = z16.enum(["claude-code", "codex", "cursor", "pi", "dsh"]);
-var SessionSnapshotSchema = z16.object({
-  formatVersion: z16.literal(1),
-  adapterVersion: z16.literal(1),
+import { z as z17 } from "zod";
+var AgentSchema = z17.enum(["claude-code", "codex", "cursor", "pi", "dsh"]);
+var SessionSnapshotSchema = z17.object({
+  formatVersion: z17.literal(1),
+  adapterVersion: z17.literal(1),
   agent: AgentSchema,
-  nativeId: z16.string().min(1).max(512),
-  cwd: z16.string().min(1).max(4096),
-  messages: z16.array(
-    z16.object({
-      id: z16.string().min(1).max(1024),
-      role: z16.enum(["user", "assistant"]),
-      text: z16.string().min(1).max(2 * 1024 * 1024),
-      source: z16.string().min(1).max(1024)
+  nativeId: z17.string().min(1).max(512),
+  cwd: z17.string().min(1).max(4096),
+  messages: z17.array(
+    z17.object({
+      id: z17.string().min(1).max(1024),
+      role: z17.enum(["user", "assistant"]),
+      text: z17.string().min(1).max(2 * 1024 * 1024),
+      source: z17.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 = z16.object({
-  operationId: z16.uuid(),
+var SessionCommitSchema = z17.object({
+  operationId: z17.uuid(),
   sessionKey: HashSchema,
   parentRevision: RevisionSchema,
   blob: BlobRefSchema
 }).strict();
-var SessionInfoSchema = z16.object({
+var SessionInfoSchema = z17.object({
   owner: NameSchema,
   sessionKey: HashSchema,
   agent: AgentSchema,
-  nativeId: z16.string(),
-  cwd: z16.string(),
-  title: z16.string(),
+  nativeId: z17.string(),
+  cwd: z17.string(),
+  title: z17.string(),
   revision: RevisionSchema,
-  updatedAt: z16.string(),
-  messageCount: z16.number().int().nonnegative(),
+  updatedAt: z17.string(),
+  messageCount: z17.number().int().nonnegative(),
   blob: BlobRefSchema
 });
-var SessionListSchema = z16.object({
-  sessions: z16.array(SessionInfoSchema),
+var SessionListSchema = z17.object({
+  sessions: z17.array(SessionInfoSchema),
   nextCursor: RevisionSchema.nullable()
 });
-var SessionStatsSchema = z16.object({
-  totalSessions: z16.number().int().nonnegative(),
-  totalMessages: z16.number().int().nonnegative(),
-  memberCount: z16.number().int().nonnegative(),
-  updatedAt: z16.string().nullable()
+var SessionStatsSchema = z17.object({
+  totalSessions: z17.number().int().nonnegative(),
+  totalMessages: z17.number().int().nonnegative(),
+  memberCount: z17.number().int().nonnegative(),
+  updatedAt: z17.string().nullable()
 });
-var SessionScopeSchema = z16.object({
+var SessionScopeSchema = z17.object({
   owner: NameSchema.optional(),
   sessionKey: HashSchema.optional()
 }).strict().refine((v) => !v.sessionKey || !!v.owner, "A session scope requires an owner.");
-var SessionSearchSchema = z16.object({
-  matches: z16.array(
-    z16.object({
+var SessionSearchSchema = z17.object({
+  matches: z17.array(
+    z17.object({
       owner: NameSchema,
       sessionKey: HashSchema,
       revision: RevisionSchema,
-      messageId: z16.string(),
-      role: z16.enum(["user", "assistant"]),
-      snippet: z16.string(),
-      title: z16.string()
+      messageId: z17.string(),
+      role: z17.enum(["user", "assistant"]),
+      snippet: z17.string(),
+      title: z17.string()
     })
   ),
   nextCursor: RevisionSchema.nullable()
@@ -3881,9 +4045,9 @@ function registerSessionRoutes(server, store) {
       authorize(request);
     }
   };
-  const pagination = z17.object({
-    after: z17.coerce.number().pipe(RevisionSchema).default(0),
-    limit: z17.coerce.number().int().min(1).max(100).default(50)
+  const pagination = z18.object({
+    after: z18.coerce.number().pipe(RevisionSchema).default(0),
+    limit: z18.coerce.number().int().min(1).max(100).default(50)
   });
   server.post(
     "/sessions/commits",
@@ -3903,7 +4067,7 @@ function registerSessionRoutes(server, store) {
     const q = pagination.extend({
       owner: NameSchema.optional(),
       sessionKey: HashSchema.optional(),
-      q: z17.string().min(1).max(500).refine((s) => !s.includes("\0"))
+      q: z18.string().min(1).max(500).refine((s) => !s.includes("\0"))
     }).parse(request.query);
     return sessions.search(
       authorizeRead(store, request),
@@ -3914,16 +4078,25 @@ function registerSessionRoutes(server, store) {
     );
   });
   server.get("/sessions/:owner/:key", async (request) => {
-    const p = z17.object({ owner: NameSchema, key: HashSchema }).parse(request.params);
-    const q = z17.object({ revision: z17.coerce.number().pipe(RevisionSchema).optional() }).parse(request.query);
+    const p = z18.object({ owner: NameSchema, key: HashSchema }).parse(request.params);
+    const q = z18.object({ revision: z18.coerce.number().pipe(RevisionSchema).optional() }).parse(request.query);
     return sessions.read(authorizeRead(store, request), p.owner, p.key, q.revision);
   });
 }
 
 // apps/server/file-routes.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 function registerFileRoutes(server, store) {
   const files = new FileRepository(store);
+  const shared = new SharedFilesRepository(store);
+  server.get(
+    "/project/shared-files",
+    async (request) => shared.config(authorizeRead(store, request))
+  );
+  server.patch("/project/shared-files", async (request) => {
+    webMutation(request);
+    return shared.update(authorizeWeb(store, request), SharedFilesUpdateSchema.parse(request.body));
+  });
   const device = (request) => {
     const value = request.headers["x-teammy-device"];
     return typeof value === "string" ? value : void 0;
@@ -3943,13 +4116,13 @@ function registerFileRoutes(server, store) {
     missing: files.missing(authorize(request), BlobCheckSchema.parse(request.body).hashes)
   }));
   server.put("/blobs/:hash", { ...guard, bodyLimit: MAX_BLOB_BYTES }, async (request) => {
-    const { hash: hash2 } = z18.object({ hash: HashSchema }).parse(request.params);
+    const { hash: hash2 } = z19.object({ hash: HashSchema }).parse(request.params);
     if (!Buffer.isBuffer(request.body))
       throw Object.assign(new Error("Expected binary content"), { statusCode: 400 });
     return files.upload(request.headers.authorization, device(request), hash2, request.body);
   });
   server.get("/blobs/:hash", async (request, reply) => {
-    const { hash: hash2 } = z18.object({ hash: HashSchema }).parse(request.params);
+    const { hash: hash2 } = z19.object({ hash: HashSchema }).parse(request.params);
     return reply.type("application/octet-stream").send(Buffer.from(await files.download(authorizeRead(store, request), hash2)));
   });
   server.post(
@@ -3961,12 +4134,16 @@ function registerFileRoutes(server, store) {
       FileCommitSchema.parse(request.body)
     )
   );
+  server.post("/files/_project/commits", guard, async (request) => {
+    const { configRevision, ...batch } = SharedFileCommitSchema.parse(request.body);
+    return files.commit(request.headers.authorization, device(request), batch, configRevision);
+  });
   server.get("/files/:owner/manifest", async (request) => {
-    const { owner } = z18.object({ owner: NameSchema }).parse(request.params);
-    const query = z18.object({
-      revision: z18.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      after: z18.string().max(1024).default(""),
-      limit: z18.coerce.number().int().min(1).max(500).default(200)
+    const { owner } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
+    const query = z19.object({
+      revision: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      after: z19.string().max(1024).default(""),
+      limit: z19.coerce.number().int().min(1).max(500).default(200)
     }).parse(request.query);
     return files.manifest(
       authorizeRead(store, request),
@@ -3977,28 +4154,28 @@ function registerFileRoutes(server, store) {
     );
   });
   server.get("/files/:owner/entry", async (request) => {
-    const { owner } = z18.object({ owner: NameSchema }).parse(request.params);
-    const q = z18.object({
+    const { owner } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
+    const q = z19.object({
       path: FilePathSchema,
-      revision: z18.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
+      revision: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
     }).parse(request.query);
     return files.entry(authorizeRead(store, request), owner, q.path, q.revision);
   });
   server.get("/files/:owner/tree", async (request) => {
-    const { owner } = z18.object({ owner: NameSchema }).parse(request.params);
-    const q = z18.object({
-      path: z18.union([z18.literal(""), FilePathSchema]).default(""),
-      revision: z18.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      after: z18.string().max(255).default(""),
-      limit: z18.coerce.number().int().min(1).max(200).default(100)
+    const { owner } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
+    const q = z19.object({
+      path: z19.union([z19.literal(""), FilePathSchema]).default(""),
+      revision: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      after: z19.string().max(255).default(""),
+      limit: z19.coerce.number().int().min(1).max(200).default(100)
     }).parse(request.query);
     return files.tree(authorizeRead(store, request), owner, q.path, q.revision, q.after, q.limit);
   });
   server.get("/files/:owner/changes", async (request) => {
-    const { owner } = z18.object({ owner: NameSchema }).parse(request.params);
-    const query = z18.object({
-      after: z18.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
-      limit: z18.coerce.number().int().min(1).max(100).default(100)
+    const { owner } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
+    const query = z19.object({
+      after: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+      limit: z19.coerce.number().int().min(1).max(100).default(100)
     }).parse(request.query);
     return files.changes(authorizeRead(store, request), owner, query.after, query.limit);
   });
@@ -4050,6 +4227,7 @@ function buildServer(options) {
         "identity",
         "blobs",
         "file-revisions",
+        "project-files",
         "session-revisions",
         "session-search",
         "project-config",