@teammy/server 0.0.7 → 0.0.9

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);
@@ -33,10 +110,10 @@ function openDatabase(path, migrations2, busyTimeoutMs = 5e3) {
       `PRAGMA busy_timeout = ${busyTimeoutMs}; PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL;`
     );
     transaction(db, () => {
-      const version = Number(db.prepare("PRAGMA user_version").get().user_version);
-      if (version > migrations2.length)
+      const version2 = Number(db.prepare("PRAGMA user_version").get().user_version);
+      if (version2 > migrations2.length)
         throw new Error("Database was created by a newer Teammy version.");
-      for (let index = version; index < migrations2.length; index++) {
+      for (let index = version2; index < migrations2.length; index++) {
         db.exec(migrations2[index]);
         db.exec(`PRAGMA user_version = ${index + 1}`);
       }
@@ -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,36 +1069,61 @@ 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 = Number.POSITIVE_INFINITY, sharedBudget) {
     this.hub = hub;
     this.identity = identity;
     this.snapshot = snapshot;
-    this.remaining = budget;
+    this.budget = sharedBudget ?? { remaining: budget };
   }
   hub;
   identity;
   snapshot;
   readFiles = /* @__PURE__ */ new Set();
-  lineCounts = /* @__PURE__ */ new Map();
-  readRanges = /* @__PURE__ */ new Map();
   limitations = /* @__PURE__ */ new Set();
-  remaining;
+  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
+    );
+  }
+  forSnapshot(snapshot) {
+    return new _SnapshotReader(this.hub, this.identity, snapshot, 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) {
+  list(after = "", limit = this.snapshot.files.length) {
     const entries = this.snapshot.files.slice(
       this.afterIndex(after),
       this.afterIndex(after) + limit + 1
@@ -1642,12 +1136,10 @@ var SnapshotReader = class {
   }
   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."
-      );
+    if (!file) {
+      this.limitations.add(`\u6765\u6E90\u672A\u80FD\u5173\u8054\u5230\u672C\u8F6E\u8D44\u6599\uFF1A${path}`);
+      return null;
+    }
     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);
@@ -1655,45 +1147,35 @@ var SnapshotReader = class {
       throw new HubError(500, "AI_SOURCE_VERSION_MISSING", "Source revision metadata is missing.");
     return { ...file, syncedAt: String(row.created_at) };
   }
-  async text(path) {
+  async bytes(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)
+    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.");
+    return bytes;
+  }
+  async text(path) {
+    return new TextDecoder().decode(await this.bytes(path));
+  }
+  consume(size) {
+    if (size > this.budget.remaining) {
+      this.limitations.add("\u672C\u6B21\u5206\u6790\u7684\u7D2F\u8BA1\u6B63\u6587\u8BFB\u53D6\u91CF\u5DF2\u8FBE\u5230\u914D\u7F6E\u989D\u5EA6\u3002");
+      throw new HubError(413, "AI_READ_BUDGET", "Workflow read allowance exceeded.");
     }
-    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;
+    this.budget.remaining -= size;
   }
-  async read(path, startLine = 1, limit = 150) {
+  async read(path, startLine = 1, limit) {
     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;
+    const selected = lines.slice(
+      startLine - 1,
+      limit === void 0 ? void 0 : startLine - 1 + limit
+    );
+    this.consume(Buffer.byteLength(selected.join("\n")));
     this.readFiles.add(path);
     const endLine = startLine + selected.length - 1;
-    this.readRanges.set(path, [...this.readRanges.get(path) ?? [], [startLine, endLine]]);
     return {
       path,
       startLine,
@@ -1703,56 +1185,713 @@ var SnapshotReader = class {
       hasMore: endLine < lines.length
     };
   }
-  async whole(path, budget) {
+  async whole(path) {
     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.consume(Buffer.byteLength(text));
     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);
+  async search(query, after = "", files = this.snapshot.files) {
+    const fingerprint = snapshotDigest(files) + ":" + this.snapshot.owner + ":" + this.snapshot.revision;
+    let fileIndex = 0, startLine = 1;
+    if (after) {
+      try {
+        const cursor = JSON.parse(Buffer.from(after, "base64url").toString("utf8"));
+        fileIndex = files.findIndex((file) => file.path === cursor.path);
+        if (fileIndex < 0 || cursor.query !== query || cursor.fingerprint !== fingerprint || !Number.isSafeInteger(cursor.line) || cursor.line < 1)
+          throw new Error();
+        startLine = cursor.line;
+      } catch {
+        throw new HubError(
+          400,
+          "AI_CURSOR_INVALID",
+          "Search cursor does not match this query and snapshot."
+        );
+      }
+    }
     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;
+    const needle = query.toLowerCase();
+    for (let f = fileIndex; f < files.length; f++) {
+      const file = files[f];
+      const lines = (await this.text(file.path)).split("\n");
+      for (let i = f === fileIndex ? startLine - 1 : 0; i < lines.length; i++) {
+        if (!lines[i].toLowerCase().includes(needle)) continue;
+        if (matches.length === 100) {
+          return {
+            matches,
+            nextCursor: Buffer.from(
+              JSON.stringify({
+                fingerprint,
+                query,
+                path: file.path,
+                line: i + 1
+              })
+            ).toString("base64url"),
+            limited: true
+          };
+        }
+        matches.push({ path: file.path, line: i + 1, excerpt: lines[i] });
       }
-      if (scannedBytes + file.size > 1024 * 1024) {
-        return {
-          matches,
-          nextCursor: files[files.indexOf(file) - 1]?.path ?? after,
-          limited: true
-        };
+    }
+    return { matches, nextCursor: 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
+);
+`;
+var aiRetryMigration = `
+ALTER TABLE ai_jobs ADD COLUMN auto_retry_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE ai_jobs ADD COLUMN next_retry_at INTEGER;
+`;
+
+// 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,
+  aiRetryMigration
+];
+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 version2 = Number(existing.prepare("PRAGMA user_version").get().user_version);
+        if (version2 > 0 && version2 < 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();
       }
-      scannedBytes += file.size;
+    }
+    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(),
+  goal: z5.string().trim().nullable(),
+  status: TaskStatusSchema.nullable(),
+  progress: z5.string().trim(),
+  needsConfirmation: z5.boolean().default(false)
+}).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),
+  syncedAt: z5.string().nullable(),
+  corrected: z5.boolean(),
+  needsReview: z5.boolean()
+});
+var TaskCorrectionSchema = z5.object({
+  title: TaskFieldsSchema.shape.title.optional(),
+  status: TaskStatusSchema.nullable().optional(),
+  goal: TaskFieldsSchema.shape.goal.optional(),
+  progress: TaskFieldsSchema.shape.progress.optional(),
+  needsConfirmation: z5.boolean().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(),
+      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)
+}).strict();
+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().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(),
+  // Access diagnostics only; reading a file does not establish semantic completeness.
+  readFiles: z6.array(FilePathSchema),
+  accessTracking: z6.literal("unavailable").optional(),
+  limitations: z6.array(z6.string())
+});
+var AiResultSchema = z6.object({
+  summary: z6.string(),
+  findings: z6.array(z6.string()),
+  uncertainties: z6.array(z6.string()).default([]),
+  citations: z6.array(AiCitationSchema),
+  coverage: AiCoverageSchema
+});
+var TaskAnalysisResultSchema = z6.object({
+  kind: z6.literal("task-bootstrap"),
+  // Absent for historical full-list results; new workflows publish explicit patches.
+  updateMode: z6.literal("patch").optional(),
+  archive: z6.array(z6.uuid()).optional(),
+  tasks: z6.array(
+    TaskFieldsSchema.extend({
+      taskId: z6.uuid().nullable().optional(),
+      sources: z6.array(TaskSourceSchema)
+    })
+  ),
+  // Read historical result notes without asking new task workflows to generate them.
+  uncertainties: z6.array(z6.string()).optional(),
+  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 {
-        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 };
-          }
+        writeFileSync(path, randomBytes4(32), { flag: "wx", mode: 384 });
       } 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;
+        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) => {
+      const {
+        contextWindow: _context,
+        maxOutputTokens: _output,
+        ...profile
+      } = JSON.parse(String(row.config_json));
+      return {
+        ...AiProfileSchema.parse(profile),
+        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;
+  }
+  hub;
+  read(scope2) {
+    const row = this.hub.db.prepare("SELECT * FROM ai_defaults WHERE scope=?").get(scope2);
     return {
-      matches,
-      nextCursor: files.length === limit ? files.at(-1).path : null,
-      limited: false
+      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(scope2, value) {
+    const input = AiDefaultUpdateSchema.parse(value);
+    transaction(this.hub.db, () => {
+      if (this.read(scope2).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(scope2, input.profileId, input.expectedRevision + 1);
+    });
+  }
+  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/runtime-resources.ts
@@ -1760,33 +1899,59 @@ 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()
-}).strict();
-var WorkflowRuntimeSchema = z6.object({
+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",
+  "inspect_changes",
+  "query_tasks",
+  "read",
+  "bash",
+  "grep",
+  "find",
+  "ls"
+]);
+var ToolTextSchema = z7.object({ label: z7.string().min(1).max(100), description: z7.string().min(1) }).strict();
+var RuntimeConfigSchema = z7.object({
+  version: z7.number().int().positive(),
+  execution: z7.enum(["snapshot-tools", "native-sandbox"]).optional(),
+  thinkingLevel: z7.enum(["off", "minimal", "low", "medium", "high"]),
+  tools: z7.array(ToolNameSchema).refine((v) => new Set(v).size === v.length),
+  maxRounds: z7.number().int().min(1).max(384),
+  timeoutMs: z7.number().int().min(1e3).max(21e5),
+  requestTimeoutMs: z7.number().int().min(1e3).max(3e5),
+  maxReadBytes: z7.number().int().positive().max(1024 * 1024 * 1024).optional(),
+  settleSeconds: z7.number().int().min(0).max(3600).optional()
+}).strict().refine((config) => {
+  const allowed = config.execution === "native-sandbox" ? ["read", "bash", "grep", "find", "ls", "query_tasks"] : ["list_files", "read_file", "search_files", "inspect_changes", "query_tasks"];
+  return config.tools.every((tool) => allowed.includes(tool));
+}, "Native file tools require the isolated runtime.");
+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),
+  prompt: z7.string().min(1),
   config: RuntimeConfigSchema,
-  toolText: z6.object({
+  toolText: z7.object({
     list_files: ToolTextSchema,
     read_file: ToolTextSchema,
-    search_files: ToolTextSchema
+    search_files: ToolTextSchema,
+    inspect_changes: ToolTextSchema.optional(),
+    query_tasks: ToolTextSchema.optional()
   }).strict(),
-  fingerprint: z6.string().regex(/^[a-f0-9]{64}$/)
+  fingerprint: z7.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
+function withoutLegacyToolLimit(value) {
+  const { maxToolCalls: _removed, ...config } = value;
+  return config;
+}
+function parseWorkflowRuntime(value) {
+  return WorkflowRuntimeSchema.parse({
+    ...value,
+    config: withoutLegacyToolLimit(value.config)
+  });
+}
 function loadWorkflow(workflow, directory = process.env.TEAMMY_AI_RUNTIME_DIR) {
   try {
     WorkflowNameSchema.parse(workflow);
@@ -1796,15 +1961,21 @@ function loadWorkflow(workflow, directory = process.env.TEAMMY_AI_RUNTIME_DIR) {
       workflow,
       system: read("shared/system.md"),
       prompt: read(`workflows/${workflow}/prompt.md`),
-      config: RuntimeConfigSchema.parse(JSON.parse(read(`workflows/${workflow}/config.json`))),
+      config: RuntimeConfigSchema.parse(
+        withoutLegacyToolLimit(JSON.parse(read(`workflows/${workflow}/config.json`)))
+      ),
       toolText: JSON.parse(read("shared/tools.json"))
     };
-    if (workflow !== "file-summary" && !resource.config.tools.includes("read_file"))
+    const native = resource.config.execution === "native-sandbox";
+    if (workflow !== "file-summary" && !resource.config.tools.includes(native ? "read" : "read_file"))
       throw new Error("Reader required");
     if (workflow === "file-summary" && resource.config.tools.length)
       throw new Error("Direct workflow has no tools");
     if (workflow === "task-bootstrap" && resource.config.settleSeconds === void 0)
       throw new Error("Settle interval required");
+    for (const tool of resource.config.tools)
+      if (!["read", "bash", "grep", "find", "ls"].includes(tool) && !resource.toolText[tool])
+        throw new Error("Missing tool description");
     return WorkflowRuntimeSchema.parse({
       ...resource,
       fingerprint: createHash6("sha256").update(JSON.stringify(resource)).digest("hex")
@@ -1823,7 +1994,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,42 +2024,55 @@ 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",
       "Workspace changed during analysis; analyse the new revision."
     );
-  const previous = hub.db.prepare("SELECT * FROM task_cards WHERE workspace_id=? AND owner=? AND active=1").all(job.workspace, job.snapshot.owner);
+  const patch = result.updateMode === "patch";
+  const previous = hub.db.prepare(
+    "SELECT * FROM task_cards WHERE workspace_id=? AND owner=?" + (patch ? "" : " AND active=1")
+  ).all(job.workspace, job.snapshot.owner);
+  const previousById = new Map(previous.map((row) => [String(row.id), row]));
+  const frozenIds = new Set(job.taskContext?.tasks.map((task) => task.taskId));
   const used = /* @__PURE__ */ new Set();
   const explicit = new Set(result.tasks.flatMap((task) => task.taskId ? [task.taskId] : []));
+  const archive = new Set(result.archive ?? []);
+  if (patch) {
+    const ids = [...explicit, ...archive];
+    if (explicit.size !== result.tasks.filter((task) => task.taskId).length || archive.size !== (result.archive ?? []).length || ids.some(
+      (id) => explicit.has(id) && archive.has(id) || !previousById.has(id) || !frozenIds.has(id)
+    ) || result.tasks.some((task) => task.taskId === void 0))
+      throw new HubError(
+        422,
+        "AI_TASK_ID_INVALID",
+        "Task changes must reference unique identities in the frozen member context."
+      );
+  }
   for (const task of result.tasks) {
-    const candidates = previous.filter(
-      (row) => !used.has(String(row.id)) && !explicit.has(String(row.id))
-    );
-    let old = task.taskId ? previous.find((row) => row.id === task.taskId) : void 0;
-    if (task.taskId && (!old || used.has(task.taskId) || !job.taskContext?.tasks.some((item) => item.taskId === task.taskId)))
+    let old = task.taskId ? previousById.get(task.taskId) : void 0;
+    if (task.taskId && (!old || used.has(task.taskId) || !frozenIds.has(task.taskId)))
       throw new HubError(
         422,
         "AI_TASK_ID_INVALID",
         "Task identity is outside the frozen member context."
       );
-    if (task.taskId === void 0)
-      old = candidates.find(
-        (row) => paths(sources(row)) === paths(task.sources) && title(fields(row).title) === title(task.title)
+    if (!patch && task.taskId === void 0)
+      old = previous.find(
+        (row) => !used.has(String(row.id)) && !explicit.has(String(row.id)) && paths(sources(row)) === paths(task.sources) && title(fields(row).title) === title(task.title)
       );
-    if (!old && task.taskId === void 0) {
+    if (!patch && !old && task.taskId === void 0 && task.sources.length) {
       const primary = task.sources[0].path;
-      const oldGroup = previous.filter((row) => sources(row)[0].path === primary);
-      const newGroup = result.tasks.filter((item) => item.sources[0].path === primary);
+      const oldGroup = previous.filter((row) => sources(row)[0]?.path === primary);
+      const newGroup = result.tasks.filter((item) => item.sources[0]?.path === primary);
       if (oldGroup.length === 1 && newGroup.length === 1 && !used.has(String(oldGroup[0].id)) && !explicit.has(String(oldGroup[0].id)))
         old = oldGroup[0];
     }
     const id = old ? String(old.id) : randomUUID2();
     used.add(id);
     const { sources: source, taskId: _taskId, ...content } = task;
-    const syncedAt = source.map((item) => item.syncedAt).sort().at(-1);
+    const syncedAt = source.map((item) => item.syncedAt).sort().at(-1) ?? "";
     hub.db.prepare(
       `INSERT INTO task_cards(id,workspace_id,owner,job_id,fields_json,sources_json,synced_at)
       VALUES(?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET job_id=excluded.job_id,fields_json=excluded.fields_json,
@@ -1904,11 +2088,8 @@ function applyTaskResult(hub, job, result) {
     );
   }
   for (const old of previous)
-    if (!used.has(String(old.id))) {
-      const hasSource = sources(old).some(
-        (source) => job.snapshot.files.some((file) => file.path === source.path)
-      );
-      const retain = Boolean(old.correction_json) || result.coverage.partial && hasSource;
+    if (patch ? archive.has(String(old.id)) : !used.has(String(old.id))) {
+      const retain = Boolean(old.correction_json);
       hub.db.prepare("UPDATE task_cards SET active=?,needs_review=? WHERE id=?").run(retain ? 1 : 0, retain ? 1 : 0, old.id);
     }
   hub.db.prepare("UPDATE task_board_members SET applied_job_id=? WHERE workspace_id=? AND owner=?").run(job.id, job.workspace, job.snapshot.owner);
@@ -1926,9 +2107,9 @@ var TaskStore = class {
       owner: row.owner,
       jobId: row.job_id,
       sources: sources(row),
-      syncedAt: row.synced_at,
+      syncedAt: row.synced_at || null,
       corrected: Boolean(row.correction_json),
-      needsReview: Boolean(row.needs_review)
+      needsReview: Boolean(row.needs_review && row.correction_json)
     });
   }
   board(session) {
@@ -1954,9 +2135,8 @@ 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,
-          partial: result?.coverage.partial ?? false,
-          uncertainties: result ? [...result.uncertainties, ...result.coverage.limitations] : []
+          sourceChanged: snapshot ? !taskSnapshotCurrent(this.hub, session.workspaceId, snapshot) : false,
+          uncertainties: result ? [...result.uncertainties ?? [], ...result.coverage.limitations] : []
         };
       }),
       modelAvailable: new AiDefaults(this.hub).project(session.workspaceId).available
@@ -1977,26 +2157,34 @@ var TaskStore = class {
 };
 
 // apps/server/ai/task-context.ts
+function changedPaths(beforeFiles, afterFiles) {
+  const before = new Map(beforeFiles.map((file) => [file.path, file.sha256]));
+  const after = new Map(afterFiles.map((file) => [file.path, file.sha256]));
+  return {
+    added: afterFiles.filter((file) => !before.has(file.path)).map((file) => file.path),
+    modified: afterFiles.filter((file) => before.has(file.path) && before.get(file.path) !== file.sha256).map((file) => file.path),
+    deleted: [...before.keys()].filter((path) => !after.has(path))
+  };
+}
 function captureTaskContext(hub, workspace, snapshot) {
   const applied = hub.db.prepare(
     `SELECT j.snapshot_json FROM task_board_members b JOIN ai_jobs j ON j.id=b.applied_job_id
        WHERE b.workspace_id=? AND b.owner=?`
   ).get(workspace, snapshot.owner);
   const previous = applied ? JSON.parse(String(applied.snapshot_json)) : null;
-  const before = new Map(previous?.files.map((file) => [file.path, file.sha256]));
-  const after = new Map(snapshot.files.map((file) => [file.path, file.sha256]));
   return {
     previousRevision: previous?.revision ?? null,
-    changes: {
-      added: snapshot.files.filter((file) => !before.has(file.path)).map((file) => file.path),
-      modified: snapshot.files.filter((file) => before.has(file.path) && before.get(file.path) !== file.sha256).map((file) => file.path),
-      deleted: [...before.keys()].filter((path) => !after.has(path))
-    },
+    baseline: previous,
+    changes: changedPaths(previous?.files ?? [], snapshot.files),
     tasks: hub.db.prepare(
-      "SELECT id,fields_json,sources_json FROM task_cards WHERE workspace_id=? AND owner=? AND active=1 ORDER BY id"
+      "SELECT id,fields_json,correction_json,sources_json,active FROM task_cards WHERE workspace_id=? AND owner=? ORDER BY id"
     ).all(workspace, snapshot.owner).map((row) => ({
-      ...JSON.parse(String(row.fields_json)),
+      ...TaskFieldsSchema.parse({
+        ...JSON.parse(String(row.fields_json)),
+        ...row.correction_json ? JSON.parse(String(row.correction_json)) : {}
+      }),
       taskId: String(row.id),
+      active: Boolean(row.active),
       sources: JSON.parse(String(row.sources_json))
     }))
   };
@@ -2004,6 +2192,7 @@ function captureTaskContext(hub, workspace, snapshot) {
 
 // apps/server/ai/jobs.ts
 var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var retryDelays = [5e3, 15e3, 45e3];
 var AiJobs = class {
   constructor(hub) {
     this.hub = hub;
@@ -2023,7 +2212,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 +2336,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 +2364,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 +2372,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",
@@ -2240,7 +2435,7 @@ var AiJobs = class {
       this.own(session, row);
       if (["queued", "running"].includes(String(row.status))) {
         this.hub.db.prepare(
-          "UPDATE ai_jobs SET status='cancelled',updated_at=?,run_token=NULL,lease_until=NULL WHERE id=?"
+          "UPDATE ai_jobs SET status='cancelled',updated_at=?,run_token=NULL,lease_until=NULL,next_retry_at=NULL WHERE id=?"
         ).run(now(), id);
         this.hub.db.prepare(
           "UPDATE ai_attempts SET status='cancelled',ended_at=? WHERE job_id=? AND status='running'"
@@ -2260,20 +2455,49 @@ var AiJobs = class {
       if (!["failed", "cancelled"].includes(String(row.status)))
         throw new HubError(409, "AI_TASK_STATE", "Only failed or cancelled tasks can be retried.");
       this.hub.db.prepare(
-        "UPDATE ai_jobs SET status='queued',updated_at=?,error=NULL,result_json=NULL,recovery_count=0 WHERE id=?"
+        "UPDATE ai_jobs SET status='queued',updated_at=?,error=NULL,result_json=NULL,recovery_count=0,auto_retry_count=0,next_retry_at=NULL WHERE id=?"
       ).run(now(), id);
       this.event(id, Number(row.attempt_count), "queued", "\u4F7F\u7528\u539F\u8F93\u5165\u5FEB\u7167\u91CD\u8BD5\u3002");
       return id;
     });
     return this.get(session.workspaceId, id);
   }
+  cancelStaleTaskJobs() {
+    return transaction(this.hub.db, () => {
+      const rows = this.hub.db.prepare(
+        "SELECT * FROM ai_jobs WHERE status IN ('queued','running') AND json_extract(request_json,'$.workflow')='task-bootstrap'"
+      ).all();
+      for (const row of rows) {
+        if (taskSnapshotCurrent(
+          this.hub,
+          String(row.workspace_id),
+          JSON.parse(String(row.snapshot_json))
+        ))
+          continue;
+        this.hub.db.prepare(
+          "UPDATE ai_jobs SET status='cancelled',error='AI_SOURCE_CHANGED',updated_at=?,run_token=NULL,lease_until=NULL,next_retry_at=NULL WHERE id=?"
+        ).run(now(), row.id);
+        this.hub.db.prepare(
+          "UPDATE ai_attempts SET status='cancelled',ended_at=?,error='AI_SOURCE_CHANGED' WHERE job_id=? AND status='running'"
+        ).run(now(), row.id);
+        this.event(
+          String(row.id),
+          Number(row.attempt_count),
+          "cancelled",
+          "\u8D44\u6599\u5DF2\u66F4\u65B0\uFF0C\u53D6\u6D88\u65E7\u7248\u672C\u5206\u6790\uFF0C\u7B49\u5F85\u65B0\u7248\u672C\u6574\u7406\u3002"
+        );
+      }
+    });
+  }
   claim(at = Date.now()) {
+    this.cancelStaleTaskJobs();
     return transaction(this.hub.db, () => {
       for (const old of this.hub.db.prepare("SELECT * FROM ai_jobs WHERE status='running' AND lease_until<=?").all(at)) {
-        const status = Number(old.recovery_count) < 1 ? "queued" : "failed";
+        const retry = Number(old.auto_retry_count) < retryDelays.length;
+        const status = retry ? "queued" : "failed";
         this.hub.db.prepare(
-          "UPDATE ai_jobs SET status=?,run_token=NULL,lease_until=NULL,error=?,updated_at=?,recovery_count=recovery_count+1 WHERE id=?"
-        ).run(status, "AI_WORKER_INTERRUPTED", now(), old.id);
+          "UPDATE ai_jobs SET status=?,run_token=NULL,lease_until=NULL,error=?,updated_at=?,recovery_count=recovery_count+1,auto_retry_count=auto_retry_count+?,next_retry_at=NULL WHERE id=?"
+        ).run(status, "AI_WORKER_INTERRUPTED", now(), retry ? 1 : 0, old.id);
         this.hub.db.prepare(
           "UPDATE ai_attempts SET status='interrupted',ended_at=?,error='AI_WORKER_INTERRUPTED' WHERE job_id=? AND status='running'"
         ).run(now(), old.id);
@@ -2286,11 +2510,13 @@ var AiJobs = class {
       }
       if (this.hub.db.prepare("SELECT 1 FROM ai_jobs WHERE status='running'").get())
         return void 0;
-      const row = this.hub.db.prepare("SELECT * FROM ai_jobs WHERE status='queued' ORDER BY created_at,id LIMIT 1").get();
+      const row = this.hub.db.prepare(
+        "SELECT * FROM ai_jobs WHERE status='queued' AND (next_retry_at IS NULL OR next_retry_at<=?) ORDER BY created_at,id LIMIT 1"
+      ).get(at);
       if (!row) return void 0;
       const token = randomUUID3(), attempt = Number(row.attempt_count) + 1, date = now();
       this.hub.db.prepare(
-        "UPDATE ai_jobs SET status='running',attempt_count=?,run_token=?,lease_until=?,updated_at=?,error=NULL WHERE id=?"
+        "UPDATE ai_jobs SET status='running',attempt_count=?,run_token=?,lease_until=?,updated_at=?,error=NULL,next_retry_at=NULL WHERE id=?"
       ).run(attempt, token, at + 3e4, date, row.id);
       this.hub.db.prepare("INSERT INTO ai_attempts(job_id,number,status,started_at) VALUES(?,?,?,?)").run(row.id, attempt, "running", date);
       this.event(String(row.id), attempt, "running", "\u5F00\u59CB\u5206\u6790\u3002");
@@ -2304,12 +2530,16 @@ var AiJobs = class {
         profile: JSON.parse(String(row.profile_json)),
         snapshot: JSON.parse(String(row.snapshot_json)),
         promptVersion: String(row.prompt_version),
-        runtime: row.runtime_json ? WorkflowRuntimeSchema.parse(JSON.parse(String(row.runtime_json))) : null,
+        runtime: row.runtime_json ? parseWorkflowRuntime(JSON.parse(String(row.runtime_json))) : null,
         taskContext: row.task_context_json ? JSON.parse(String(row.task_context_json)) : null
       };
     });
   }
   heartbeat(job) {
+    if (job.request.workflow === "task-bootstrap" && !taskSnapshotCurrent(this.hub, job.workspace, job.snapshot)) {
+      this.cancelStaleTaskJobs();
+      return false;
+    }
     return this.hub.db.prepare(
       "UPDATE ai_jobs SET lease_until=? WHERE id=? AND run_token=? AND status='running' AND lease_until>?"
     ).run(Date.now() + 3e4, job.id, job.token, Date.now()).changes === 1;
@@ -2330,20 +2560,40 @@ var AiJobs = class {
   }
   finish(job, result, error, usage) {
     return transaction(this.hub.db, () => {
-      const status = result ? "succeeded" : "failed";
+      const row = this.hub.db.prepare(
+        "SELECT auto_retry_count,runtime_json FROM ai_jobs WHERE id=? AND run_token=? AND status='running' AND lease_until>?"
+      ).get(job.id, job.token, Date.now());
+      if (!row) return false;
+      const obsolete = error === "AI_SOURCE_CHANGED" || error === "AI_TASK_SUPERSEDED";
+      const retryCount = Number(row.auto_retry_count);
+      const retry = !result && !obsolete && retryCount < retryDelays.length;
+      const attemptStatus = result ? "succeeded" : obsolete ? "cancelled" : "failed";
+      const status = retry ? "queued" : attemptStatus;
       if (result) {
         AiWorkflowResultSchema.parse(result);
         const taskResult = "kind" in result;
         if (job.request.workflow === "task-bootstrap" !== taskResult)
           throw new HubError(422, "AI_RESULT_INVALID", "Result does not match the workflow.");
+        if (taskResult && row.runtime_json) {
+          const runtime = JSON.parse(String(row.runtime_json));
+          const expectsPatch = runtime.config.version >= 7;
+          if (expectsPatch !== (result.updateMode === "patch"))
+            throw new HubError(
+              422,
+              "AI_RESULT_INVALID",
+              "Task result does not match its frozen output contract."
+            );
+        }
       }
       const changed = this.hub.db.prepare(
-        "UPDATE ai_jobs SET status=?,result_json=?,error=?,run_token=NULL,lease_until=NULL,updated_at=? WHERE id=? AND run_token=? AND status='running' AND lease_until>?"
+        "UPDATE ai_jobs SET status=?,result_json=?,error=?,run_token=NULL,lease_until=NULL,updated_at=?,auto_retry_count=auto_retry_count+?,next_retry_at=? WHERE id=? AND run_token=? AND status='running' AND lease_until>?"
       ).run(
         status,
         result ? JSON.stringify(result) : null,
         error,
         now(),
+        retry ? 1 : 0,
+        retry ? Date.now() + retryDelays[retryCount] : null,
         job.id,
         job.token,
         Date.now()
@@ -2352,8 +2602,27 @@ var AiJobs = class {
         if (result && "kind" in result) applyTaskResult(this.hub, job, result);
         this.hub.db.prepare(
           "UPDATE ai_attempts SET status=?,ended_at=?,error=?,usage_json=? WHERE job_id=? AND number=?"
-        ).run(status, now(), error, usage ? JSON.stringify(usage) : null, job.id, job.attempt);
-        this.event(job.id, job.attempt, status, result ? "\u5206\u6790\u5B8C\u6210\u3002" : error ?? "\u5206\u6790\u5931\u8D25\u3002");
+        ).run(
+          attemptStatus,
+          now(),
+          error,
+          usage ? JSON.stringify(usage) : null,
+          job.id,
+          job.attempt
+        );
+        this.event(
+          job.id,
+          job.attempt,
+          attemptStatus,
+          result ? "\u5206\u6790\u5B8C\u6210\u3002" : error ?? "\u5206\u6790\u5931\u8D25\u3002"
+        );
+        if (retry)
+          this.event(
+            job.id,
+            job.attempt,
+            "queued",
+            `\u5C06\u5728 ${retryDelays[retryCount] / 1e3} \u79D2\u540E\u81EA\u52A8\u91CD\u8BD5\uFF08${retryCount + 1}/3\uFF09\u3002`
+          );
       }
       return changed === 1;
     });
@@ -2361,23 +2630,97 @@ var AiJobs = class {
 };
 
 // apps/server/ai/pi-runner.ts
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join7 } from "node:path";
 import { InMemoryCredentialStore, InMemoryModelsStore } from "@earendil-works/pi-ai";
 
-// apps/server/ai/tools.ts
+// apps/server/ai/task-tools.ts
 import { Type } from "@earendil-works/pi-ai";
-import { z as z7 } from "zod";
-function analysisTools(reader, signal, progress, runtime) {
-  let calls = 0;
-  const guard = () => {
-    signal.throwIfAborted();
-    if (++calls > runtime.config.maxToolCalls) {
-      reader.limitations.add("\u5DE5\u5177\u8C03\u7528\u5DF2\u8FBE\u5230\u672C\u6B21\u5206\u6790\u9884\u7B97\u3002");
-      throw new HubError(413, "AI_TOOL_BUDGET", "Tool call budget exhausted.");
-    }
-  };
+import { z as z8 } from "zod";
+var scope = z8.enum(["member", "project"]).optional();
+var version = z8.enum(["current", "baseline"]).optional();
+var filter = {
+  path: z8.string().optional(),
+  query: z8.string().optional(),
+  pattern: z8.string().optional()
+};
+function taskTools(explorer, signal, progress, runtime) {
+  function tool(name, schema, execute) {
+    const text = runtime.toolText[name];
+    return {
+      name,
+      ...text,
+      parameters: Type.Unsafe(z8.toJSONSchema(schema)),
+      executionMode: "sequential",
+      async execute(_id, params) {
+        signal.throwIfAborted();
+        const parsed = schema.parse(params);
+        progress(name, `${text.label}\u3002`);
+        const value = await execute(parsed);
+        signal.throwIfAborted();
+        return { content: [{ type: "text", text: JSON.stringify(value) }], details: {} };
+      }
+    };
+  }
+  return [
+    tool(
+      "list_files",
+      z8.object({ ...filter, scope, version }).strict(),
+      (p) => explorer.list(p, p.scope, p.version)
+    ),
+    tool(
+      "read_file",
+      z8.object({
+        path: FilePathSchema,
+        scope,
+        version,
+        startLine: z8.number().int().positive().optional(),
+        limit: z8.number().int().positive().optional()
+      }).strict(),
+      (p) => explorer.reader(p.scope, p.version).read(p.path, p.startLine, p.limit)
+    ),
+    tool(
+      "search_files",
+      z8.object({
+        path: filter.path,
+        pattern: filter.pattern,
+        query: z8.string().min(1),
+        after: z8.string().optional(),
+        scope,
+        version
+      }).strict(),
+      (p) => explorer.search(p.query, p.after, { path: p.path, pattern: p.pattern }, p.scope, p.version)
+    ),
+    tool(
+      "inspect_changes",
+      z8.object({
+        ...filter,
+        scope,
+        version,
+        startLine: z8.number().int().positive().optional(),
+        endLine: z8.number().int().positive().optional()
+      }).strict(),
+      (p) => explorer.inspect(p, p.scope)
+    ),
+    tool(
+      "query_tasks",
+      z8.object({
+        id: z8.uuid().optional(),
+        source: z8.string().optional(),
+        query: z8.string().optional(),
+        visibility: z8.enum(["active", "archived", "all"]).optional()
+      }).strict(),
+      (p) => explorer.queryTasks(p)
+    )
+  ].filter((tool2) => runtime.config.tools.some((name) => name === tool2.name));
+}
+
+// apps/server/ai/tools.ts
+import { Type as Type2 } from "@earendil-works/pi-ai";
+import { z as z9 } from "zod";
+function analysisTools(reader, signal, progress, runtime, explorer) {
+  if (explorer) return taskTools(explorer, signal, progress, runtime);
   const reply = (value) => ({
     content: [{ type: "text", text: JSON.stringify(value) }],
     details: {}
@@ -2386,55 +2729,69 @@ function analysisTools(reader, signal, progress, runtime) {
     {
       name: "list_files",
       ...runtime.toolText.list_files,
-      parameters: Type.Object(
-        { after: Type.Optional(Type.String({ maxLength: 1024 })) },
+      parameters: Type2.Object(
+        {
+          after: Type2.Optional(Type2.String()),
+          scope: Type2.Optional(Type2.Union([Type2.Literal("member"), Type2.Literal("project")]))
+        },
         { additionalProperties: false }
       ),
       executionMode: "sequential",
       async execute(_id, params) {
-        guard();
-        const p = z7.object({ after: z7.string().max(1024).default("") }).strict().parse(params);
+        signal.throwIfAborted();
+        const p = z9.object({
+          after: z9.string().default(""),
+          scope: z9.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));
       }
     },
     {
       name: "read_file",
       ...runtime.toolText.read_file,
-      parameters: Type.Object(
+      parameters: Type2.Object(
         {
-          path: Type.String(),
-          startLine: Type.Optional(Type.Integer({ minimum: 1 })),
-          limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 150 }))
+          path: Type2.String(),
+          scope: Type2.Optional(Type2.Union([Type2.Literal("member"), Type2.Literal("project")])),
+          startLine: Type2.Optional(Type2.Integer({ minimum: 1 })),
+          limit: Type2.Optional(Type2.Integer({ minimum: 1 }))
         },
         { additionalProperties: false }
       ),
       executionMode: "sequential",
       async execute(_id, params) {
-        guard();
-        const p = z7.object({
+        signal.throwIfAborted();
+        const p = z9.object({
           path: FilePathSchema,
-          startLine: z7.number().int().min(1).max(1e6).default(1),
-          limit: z7.number().int().min(1).max(150).default(150)
+          scope: z9.enum(["member", "project"]).default("member"),
+          startLine: z9.number().int().min(1).default(1),
+          limit: z9.number().int().min(1).optional()
         }).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
+          )
+        );
       }
     },
     {
       name: "search_files",
       ...runtime.toolText.search_files,
-      parameters: Type.Object(
+      parameters: Type2.Object(
         {
-          query: Type.String({ minLength: 1, maxLength: 200 }),
-          after: Type.Optional(Type.String({ maxLength: 1024 }))
+          query: Type2.String({ minLength: 1 }),
+          after: Type2.Optional(Type2.String())
         },
         { additionalProperties: false }
       ),
       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);
+        signal.throwIfAborted();
+        const p = z9.object({ query: z9.string().min(1), after: z9.string().default("") }).strict().parse(params);
         progress("search", "\u641C\u7D22\u5FEB\u7167\u6B63\u6587\u3002");
         return reply(await reader.search(p.query, p.after));
       }
@@ -2444,10 +2801,19 @@ function analysisTools(reader, signal, progress, runtime) {
 }
 
 // apps/server/ai/models.ts
-import { createModels, createProvider, Type as Type2 } from "@earendil-works/pi-ai";
+import { createModels, createProvider, Type as Type3 } from "@earendil-works/pi-ai";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+function withoutOutputLimits(payload) {
+  const {
+    max_tokens: _chat,
+    max_completion_tokens: _completion,
+    max_output_tokens: _response,
+    ...rest
+  } = payload;
+  return rest;
+}
 function modelAccess(profile, key, reasoning = false) {
   const model = {
     id: profile.model,
@@ -2457,8 +2823,8 @@ function modelAccess(profile, key, reasoning = false) {
     baseUrl: profile.protocol === "anthropic-messages" ? profile.baseUrl.replace(/\/v1\/?$/, "") : profile.baseUrl,
     reasoning,
     input: ["text"],
-    contextWindow: profile.contextWindow,
-    maxTokens: profile.maxOutputTokens,
+    contextWindow: 0,
+    maxTokens: Number.MAX_SAFE_INTEGER,
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     ...profile.protocol === "openai-completions" ? {
       compat: {
@@ -2504,11 +2870,11 @@ async function modelCall(profile, key, context, signal, extra = {}, thinkingLeve
   const { models, model } = modelAccess(profile, key, thinkingLevel !== "off");
   const options = {
     ...extra,
-    maxTokens: profile.maxOutputTokens,
     maxRetries: 0,
-    timeoutMs: extra.timeoutMs ?? 6e4,
+    timeoutMs: extra.timeoutMs ?? 3e5,
     signal,
-    transport: "sse"
+    transport: "sse",
+    onPayload: async (payload, model2) => withoutOutputLimits(await extra.onPayload?.(payload, model2) ?? payload)
   };
   const stream = thinkingLevel === "off" ? models.stream(model, context, options) : models.streamSimple(model, context, { ...options, reasoning: thinkingLevel });
   let streamed = false;
@@ -2538,13 +2904,13 @@ async function probeModel(profile, key, mode, signal) {
         {
           name: "ping",
           description: "Get the verification marker.",
-          parameters: Type2.Object({ value: Type2.String() })
+          parameters: Type3.Object({ value: Type3.String() })
         }
       ]
     } : {}
   };
   const first = await modelCall(
-    { ...profile, maxOutputTokens: Math.min(512, profile.maxOutputTokens) },
+    profile,
     key,
     context,
     signal,
@@ -2600,8 +2966,522 @@ async function probeModel(profile, key, mode, signal) {
   return { ok: true, mode, streamed, inputTokens, outputTokens };
 }
 
+// apps/server/ai/native-sandbox.ts
+import { spawn } from "node:child_process";
+import { lstat, mkdtemp, readlink, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname as dirname4, join as join6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// apps/server/ai/agent-channel.ts
+import { createInterface } from "node:readline";
+var AgentChannel = class {
+  constructor(input, output) {
+    this.output = output;
+    this.lines = createInterface({ input, crlfDelay: Infinity });
+    this.iterator = this.lines[Symbol.asyncIterator]();
+    output.on("error", () => {
+    });
+  }
+  output;
+  lines;
+  iterator;
+  writes = Promise.resolve();
+  async *messages() {
+    for await (const line of this.iterator) if (line) yield JSON.parse(line);
+  }
+  send(value) {
+    const write = this.writes.then(
+      () => new Promise((resolve4, reject) => {
+        this.output.write(
+          JSON.stringify(value) + "\n",
+          (error) => error ? reject(error) : resolve4()
+        );
+      })
+    );
+    this.writes = write.catch(() => {
+    });
+    return write;
+  }
+  close() {
+    this.lines.close();
+    this.output.end();
+  }
+};
+
+// apps/server/ai/agent-workspace.ts
+import { mkdir as mkdir2, writeFile } from "node:fs/promises";
+import { dirname as dirname3, join as join5 } from "node:path";
+
+// apps/server/ai/line-diff.ts
+import { Worker } from "node:worker_threads";
+async function lineChanges(before, after, signal) {
+  signal?.throwIfAborted();
+  const worker = new Worker(new URL("./line-diff-worker.js", import.meta.url), {
+    workerData: { before, after }
+  });
+  let abort;
+  try {
+    return await new Promise((resolve4, reject) => {
+      abort = () => reject(signal.reason);
+      signal?.addEventListener("abort", abort, { once: true });
+      worker.once("message", resolve4);
+      worker.once("error", reject);
+      worker.once(
+        "exit",
+        (code) => reject(new Error(`Line comparison exited without a result (${code}).`))
+      );
+      if (signal?.aborted) abort();
+    });
+  } finally {
+    if (abort) signal?.removeEventListener("abort", abort);
+    await worker.terminate();
+  }
+}
+
+// apps/server/ai/task-explorer.ts
+import { matchesGlob } from "node:path";
+var displayCount = 40;
+function abbreviated(items) {
+  const shown = items.slice(0, displayCount), omitted = items.length - shown.length;
+  return {
+    items: shown,
+    total: items.length,
+    omitted,
+    ...omitted ? { note: `\u2026\u2026\u7B49 ${omitted} \u9879\uFF1B\u53EF\u7F29\u5C0F\u67E5\u8BE2\u8303\u56F4\u3002` } : {}
+  };
+}
+function matchesFile(path, filter2) {
+  const prefix = filter2.path?.replace(/\/$/, "") ?? "";
+  return (!prefix || path === prefix || path.startsWith(prefix + "/")) && (!filter2.query || path.toLowerCase().includes(filter2.query.toLowerCase())) && (!filter2.pattern || matchesGlob(path, filter2.pattern));
+}
+var TaskExplorer = class {
+  constructor(current, context, signal) {
+    this.current = current;
+    this.context = context;
+    this.signal = signal;
+    this.baseline = context?.baseline ? current.forSnapshot(context.baseline) : void 0;
+  }
+  current;
+  context;
+  signal;
+  baseline;
+  ranges = /* @__PURE__ */ new Map();
+  reader(scope2 = "member", version2 = "current") {
+    const reader = version2 === "current" ? this.current : this.baseline;
+    if (!reader)
+      throw new HubError(
+        404,
+        "AI_BASELINE_UNAVAILABLE",
+        "There is no successful baseline snapshot."
+      );
+    return scope2 === "project" ? reader.projectReader() : reader;
+  }
+  files(scope2, version2) {
+    const snapshot = version2 === "current" ? this.current.snapshot : this.context?.baseline;
+    return (scope2 === "project" ? snapshot?.project?.files : snapshot?.files) ?? [];
+  }
+  list(filter2 = {}, scope2 = "member", version2 = "current") {
+    this.reader(scope2, version2);
+    const files = this.files(scope2, version2).filter((file) => matchesFile(file.path, filter2));
+    const prefix = filter2.path?.replace(/\/$/, "") ?? "";
+    const directories = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const relative = prefix && file.path.startsWith(prefix + "/") ? file.path.slice(prefix.length + 1) : file.path;
+      if (!relative.includes("/")) continue;
+      const path = (prefix ? prefix + "/" : "") + relative.split("/")[0];
+      directories.set(path, (directories.get(path) ?? 0) + 1);
+    }
+    return {
+      scope: scope2,
+      version: version2,
+      files: abbreviated(files.map(({ path, size }) => ({ path, size }))),
+      directories: abbreviated([...directories].map(([path, files2]) => ({ path, files: files2 })))
+    };
+  }
+  async search(query, after = "", filter2 = {}, scope2 = "member", version2 = "current") {
+    const reader = this.reader(scope2, version2);
+    return reader.search(
+      query,
+      after,
+      reader.snapshot.files.filter((file) => matchesFile(file.path, filter2))
+    );
+  }
+  changes(filter2 = {}, scope2 = "member") {
+    const changes = changedPaths(this.files(scope2, "baseline"), this.files(scope2, "current"));
+    return Object.entries(changes).flatMap(([kind, paths2]) => paths2.map((path) => ({ path, kind }))).filter((file) => matchesFile(file.path, filter2)).sort((a, b) => a.path.localeCompare(b.path));
+  }
+  overview() {
+    return {
+      owner: this.current.snapshot.owner,
+      revision: this.current.snapshot.revision,
+      mode: this.context?.baseline ? "incremental" : "cold_start",
+      baselineRevision: this.context?.previousRevision ?? null,
+      inventory: this.list(),
+      projectReferences: this.current.snapshot.project ? this.list({}, "project") : null,
+      changes: {
+        member: abbreviated(this.changes()),
+        project: abbreviated(this.changes({}, "project"))
+      },
+      previousTasks: {
+        active: this.context?.tasks.filter((task) => task.active !== false).length ?? 0,
+        archived: this.context?.tasks.filter((task) => task.active === false).length ?? 0
+      }
+    };
+  }
+  queryTasks(filter2 = {}) {
+    const visibility = filter2.visibility ?? (filter2.id ? "all" : "active");
+    return abbreviated(
+      (this.context?.tasks ?? []).filter(
+        (task) => (!filter2.id || task.taskId === filter2.id) && (visibility === "all" || (visibility === "active" ? task.active !== false : task.active === false)) && (!filter2.source || task.sources.some((source) => matchesFile(source.path, { path: filter2.source }))) && (!filter2.query || [
+          task.title,
+          task.goal ?? "",
+          task.progress,
+          ...task.sources.map((source) => source.path)
+        ].some((text) => text.toLowerCase().includes(filter2.query.toLowerCase())))
+      )
+    );
+  }
+  async inspect(filter2 = {}, scope2 = "member") {
+    const changes = this.changes(filter2, scope2);
+    const response = abbreviated(changes);
+    const items = [];
+    for (const change of response.items) {
+      this.signal.throwIfAborted();
+      const before = this.files(scope2, "baseline").find((file) => file.path === change.path);
+      const after = this.files(scope2, "current").find((file) => file.path === change.path);
+      const key = `${before?.sha256 ?? ""}:${after?.sha256 ?? ""}`;
+      try {
+        let pending = this.ranges.get(key);
+        if (!pending) {
+          pending = (async () => lineChanges(
+            before ? await this.reader(scope2, "baseline").text(change.path) : "",
+            after ? await this.reader(scope2).text(change.path) : "",
+            this.signal
+          ))();
+          this.ranges.set(key, pending);
+        }
+        const ranges = await pending;
+        this.signal.throwIfAborted();
+        const selected = ranges.filter((range) => {
+          const location = filter2.version === "baseline" ? range.before : range.after;
+          return (filter2.startLine === void 0 || location.startLine + Math.max(1, location.count) - 1 >= filter2.startLine) && (filter2.endLine === void 0 || location.startLine <= filter2.endLine);
+        });
+        items.push({ ...change, available: true, ranges: abbreviated(selected) });
+      } catch (error) {
+        this.signal.throwIfAborted();
+        items.push({
+          ...change,
+          available: false,
+          reason: error instanceof HubError ? error.code : "DIFF_UNAVAILABLE"
+        });
+      }
+    }
+    return { scope: scope2, ...response, items };
+  }
+};
+
+// apps/server/ai/agent-workspace.ts
+async function materializeWorkspace(root, reader, signal) {
+  const owner = FileOwnerSchema.parse(reader.snapshot.owner);
+  await mkdir2(join5(root, owner), { recursive: true });
+  async function copy(source, prefix, shared = false) {
+    for (const file of source.snapshot.files) {
+      signal.throwIfAborted();
+      const path = FilePathSchema.parse(file.path);
+      if (shared && !sharedPathAllowed(path, DEFAULT_SHARED_PATHS)) continue;
+      const target = join5(root, prefix, path);
+      await mkdir2(dirname3(target), { recursive: true });
+      await writeFile(target, await source.bytes(path), { flag: "wx", mode: 292 });
+    }
+  }
+  await copy(reader, owner);
+  if (reader.snapshot.project) await copy(reader.projectReader(), "", true);
+}
+function memberSourcePath(path, owner) {
+  const relative = path.replace(/^\/workspaces\//, "").replace(/^\.\//, "");
+  return relative.startsWith(owner + "/") ? relative.slice(owner.length + 1) : null;
+}
+async function taskInput(reader, context, signal) {
+  const owner = reader.snapshot.owner;
+  const lines = [
+    `\u672C\u8F6E\u7EF4\u62A4\u6210\u5458 ${owner} \u7684\u4EFB\u52A1\u6E05\u5355\u3002`,
+    `\u6A21\u5F0F\uFF1A${context?.baseline ? "\u589E\u91CF\u7EF4\u62A4" : "\u9996\u6B21\u6574\u7406"}\uFF1B\u5F53\u524D\u8D44\u6599\uFF1A/workspaces/${owner}/\u3002`,
+    "\u516C\u5171\u8BF4\u660E\u53CA\u6A21\u677F\uFF08\u5982\u6709\uFF09\uFF1A/workspaces/README.md\u3001/workspaces/_template/\u3002",
+    context?.baseline ? "\u5386\u53F2\u57FA\u7EBF\uFF1A/baseline/workspaces/\u3002" : "\u672C\u8F6E\u6CA1\u6709\u5386\u53F2\u57FA\u7EBF\u3002"
+  ];
+  if (context?.baseline) {
+    const explorer = new TaskExplorer(reader, context, signal);
+    const changes = [
+      ...explorer.changes().map((change) => ({ ...change, scope: "member" })),
+      ...explorer.changes({}, "project").map((change) => ({ ...change, scope: "project" }))
+    ];
+    lines.push("\u672C\u8F6E\u53D8\u5316\uFF1A");
+    for (const change of changes.slice(0, 20)) {
+      signal.throwIfAborted();
+      const path = change.scope === "member" ? `${owner}/${change.path}` : change.path;
+      let detail = "";
+      if (change.kind === "modified") {
+        const diff = await explorer.inspect({ path: change.path }, change.scope);
+        const item = diff.items[0];
+        if (item?.available) {
+          detail = "\uFF1B\u53D8\u5316\u884C\uFF08\u65E7\u2192\u65B0\uFF09" + item.ranges.items.slice(0, 3).map(
+            (range) => `${range.before.startLine}+${range.before.count}\u2192${range.after.startLine}+${range.after.count}`
+          ).join("\u3001");
+          if (item.ranges.total > 3) detail += `\uFF0C\u53E6\u6709 ${item.ranges.total - 3} \u5904`;
+        }
+      }
+      lines.push(`- ${change.kind} ${JSON.stringify(path)}${detail}`);
+    }
+    if (changes.length > 20) lines.push(`\u2026\u2026\u53E6\u6709 ${changes.length - 20} \u4E2A\u6587\u4EF6\u53D1\u751F\u53D8\u5316\u3002`);
+    if (!changes.length) lines.push("- \u65E0\u6587\u4EF6\u53D8\u5316\u3002");
+  }
+  lines.push("\u5DF2\u6709\u4EFB\u52A1\u53EF\u901A\u8FC7 query_tasks \u67E5\u8BE2\u3002");
+  return lines.join("\n");
+}
+
+// apps/server/ai/agent-protocol.ts
+import { z as z10 } from "zod";
+var TaskQuerySchema = z10.object({
+  id: z10.uuid().optional(),
+  source: z10.string().optional(),
+  query: z10.string().optional(),
+  visibility: z10.enum(["active", "archived", "all"]).optional()
+}).strict();
+
+// apps/server/ai/task-query.ts
+function queryTasks(context, owner, input) {
+  const filter2 = TaskQuerySchema.parse(input);
+  const visibility = filter2.visibility ?? (filter2.id ? "all" : "active");
+  return abbreviated(
+    (context?.tasks ?? []).map((task) => ({
+      ...task,
+      sources: task.sources.map((source) => ({ ...source, path: `${owner}/${source.path}` }))
+    })).filter(
+      (task) => (!filter2.id || task.taskId === filter2.id) && (visibility === "all" || (visibility === "active" ? task.active !== false : task.active === false)) && (!filter2.source || task.sources.some((source) => matchesFile(source.path, { path: filter2.source }))) && (!filter2.query || [
+        task.title,
+        task.goal ?? "",
+        task.progress,
+        ...task.sources.map((source) => source.path)
+      ].some((text) => text.toLowerCase().includes(filter2.query.toLowerCase())))
+    )
+  );
+}
+
+// apps/server/ai/native-sandbox.ts
+async function sandboxCommand(root, baseline) {
+  if (process.platform !== "linux")
+    throw new HubError(
+      503,
+      "AI_SANDBOX_UNAVAILABLE",
+      "Native analysis requires a Linux worker with Bubblewrap."
+    );
+  let dependencies = dirname4(fileURLToPath2(import.meta.resolve("@earendil-works/pi-coding-agent")));
+  while (basename(dependencies) !== "node_modules") {
+    const parent = dirname4(dependencies);
+    if (parent === dependencies) throw new Error("Pi dependency root not found.");
+    dependencies = parent;
+  }
+  const args = [
+    "--unshare-all",
+    "--unshare-user",
+    "--die-with-parent",
+    "--new-session",
+    "--cap-drop",
+    "ALL",
+    "--ro-bind",
+    "/usr",
+    "/usr"
+  ];
+  for (const path of ["/bin", "/sbin", "/lib", "/lib64"]) {
+    const stat = await lstat(path).catch(() => null);
+    if (!stat) continue;
+    if (stat.isSymbolicLink()) args.push("--symlink", await readlink(path), path);
+    else args.push("--ro-bind", path, path);
+  }
+  if (await lstat("/etc/alternatives").catch(() => null))
+    args.push("--ro-bind", "/etc/alternatives", "/etc/alternatives");
+  args.push(
+    "--proc",
+    "/proc",
+    "--dev",
+    "/dev",
+    "--tmpfs",
+    "/tmp",
+    "--dir",
+    "/home/agent",
+    "--setenv",
+    "HOME",
+    "/home/agent",
+    "--setenv",
+    "PATH",
+    "/opt/node-bin:/usr/local/bin:/usr/bin:/bin",
+    "--setenv",
+    "LANG",
+    "C.UTF-8",
+    "--setenv",
+    "SHELL",
+    "/bin/bash",
+    "--setenv",
+    "PI_SKIP_VERSION_CHECK",
+    "1",
+    "--ro-bind",
+    process.execPath,
+    "/opt/node-bin/node",
+    "--ro-bind",
+    dependencies,
+    "/opt/teammy/node_modules",
+    "--ro-bind",
+    fileURLToPath2(new URL("./native-pi-entry.js", import.meta.url)),
+    "/opt/teammy/native-pi-entry.mjs",
+    "--ro-bind",
+    join6(root, "workspaces"),
+    "/workspaces"
+  );
+  if (baseline) args.push("--ro-bind", join6(root, "baseline/workspaces"), "/baseline/workspaces");
+  args.push("--chdir", "/workspaces", "/opt/node-bin/node", "/opt/teammy/native-pi-entry.mjs");
+  return { command: "bwrap", args };
+}
+async function runNativeAgent(profile, reader, key, signal, progress, runtime, systemPrompt, input, context = null) {
+  signal.throwIfAborted();
+  const root = await mkdtemp(join6(tmpdir(), "teammy-agent-"));
+  try {
+    await materializeWorkspace(join6(root, "workspaces"), reader, signal);
+    if (context?.baseline)
+      await materializeWorkspace(
+        join6(root, "baseline/workspaces"),
+        reader.forSnapshot(context.baseline),
+        signal
+      );
+    const { command, args } = await sandboxCommand(root, Boolean(context?.baseline));
+    signal.throwIfAborted();
+    const child = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+      env: { PATH: "/usr/bin:/bin" }
+    });
+    const channel = new AgentChannel(child.stdout, child.stdin);
+    const active = new AbortController();
+    const requestSignal = AbortSignal.any([signal, active.signal]);
+    let failure, text, rounds = 0;
+    const usage = { inputTokens: 0, outputTokens: 0 };
+    const stop = () => {
+      active.abort();
+      if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    };
+    const closed = new Promise((resolve4) => {
+      child.once("error", () => {
+        failure ??= new HubError(
+          503,
+          "AI_SANDBOX_UNAVAILABLE",
+          "Could not start Bubblewrap; check the Linux worker setup."
+        );
+      });
+      child.once("close", (code) => {
+        if (code !== 0 && !signal.aborted)
+          failure ??= new HubError(
+            503,
+            "AI_SANDBOX_FAILED",
+            "Sandbox exited unsuccessfully; check worker isolation support."
+          );
+        active.abort();
+        resolve4();
+      });
+    });
+    child.stderr.resume();
+    signal.addEventListener("abort", stop, { once: true });
+    const pending = /* @__PURE__ */ new Set();
+    const handle = async (message) => {
+      if (message.type === "progress") {
+        if (runtime.config.tools.some((tool) => tool === message.tool))
+          progress("tool", `\u4F7F\u7528 ${message.tool}\u3002`);
+      } else if (message.type === "result") {
+        if (typeof message.text !== "string" || text !== void 0)
+          throw new Error("Invalid result.");
+        text = message.text;
+      } else if (message.type === "failed") {
+        throw new HubError(422, "AI_RESULT_INVALID", "Agent did not complete analysis.");
+      } else if (message.type === "request") {
+        let value;
+        if (message.method === "model") {
+          if (++rounds > runtime.config.maxRounds)
+            throw new HubError(413, "AI_ROUND_LIMIT", "Analysis exceeded its model round budget.");
+          progress("model", `\u6A21\u578B\u5206\u6790\u7B2C ${rounds} \u8F6E\u3002`);
+          const response = await modelCall(
+            profile,
+            key,
+            message.input,
+            requestSignal,
+            { timeoutMs: runtime.config.requestTimeoutMs },
+            runtime.config.thinkingLevel
+          );
+          value = response.message;
+          usage.inputTokens += response.message.usage.input;
+          usage.outputTokens += response.message.usage.output;
+        } else if (message.method === "query_tasks" && runtime.config.tools.includes("query_tasks")) {
+          value = queryTasks(context, reader.snapshot.owner, message.input);
+        } else throw new HubError(403, "AI_TOOL_UNAVAILABLE", "Tool is unavailable for this job.");
+        await channel.send({ type: "response", id: message.id, value });
+      } else throw new Error("Invalid sandbox message.");
+    };
+    try {
+      const { model } = modelAccess(
+        { ...profile, baseUrl: "http://model.invalid" },
+        "",
+        runtime.config.thinkingLevel !== "off"
+      );
+      await channel.send({ type: "start", config: { model, runtime, systemPrompt, input } });
+      if (signal.aborted) stop();
+      for await (const message of channel.messages()) {
+        const task = handle(message).catch((error) => {
+          failure ??= error;
+          stop();
+        });
+        pending.add(task);
+        void task.finally(() => pending.delete(task));
+      }
+      await closed;
+      await Promise.all(pending);
+      signal.throwIfAborted();
+      if (failure) throw failure;
+      if (text === void 0) throw new HubError(422, "AI_RESULT_EMPTY", "No analysis result.");
+      return { text, usage };
+    } catch (error) {
+      stop();
+      await closed;
+      signal.throwIfAborted();
+      throw failure ?? error;
+    } finally {
+      signal.removeEventListener("abort", stop);
+      stop();
+      channel.close();
+      await closed;
+      await Promise.allSettled(pending);
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+
 // apps/server/ai/pi-runner.ts
-async function runAgent(profile, reader, key, signal, progress, runtime, systemPrompt, input) {
+async function runAgent(profile, reader, key, signal, progress, runtime, systemPrompt, input, explorer, context = null) {
+  if (runtime.config.execution === "native-sandbox")
+    return runNativeAgent(
+      profile,
+      reader,
+      key,
+      signal,
+      progress,
+      runtime,
+      systemPrompt,
+      typeof input === "string" ? input : JSON.stringify(input),
+      context
+    );
   const {
     createAgentSession,
     createExtensionRuntime,
@@ -2609,7 +3489,7 @@ async function runAgent(profile, reader, key, signal, progress, runtime, systemP
     SessionManager,
     SettingsManager
   } = await import("@earendil-works/pi-coding-agent");
-  const cwd = await mkdtemp(join5(tmpdir(), "teammy-ai-run-"));
+  const cwd = await mkdtemp2(join7(tmpdir2(), "teammy-ai-run-"));
   try {
     const { models, model } = modelAccess(profile, key, runtime.config.thinkingLevel !== "off");
     const modelRuntime = await ModelRuntime.create({
@@ -2650,29 +3530,29 @@ async function runAgent(profile, reader, key, signal, progress, runtime, systemP
         cacheWarming: "off"
       }),
       tools: runtime.config.tools,
-      customTools: analysisTools(reader, signal, progress, runtime)
+      customTools: analysisTools(reader, signal, progress, runtime, explorer)
     });
     let requests = 0, budgetError;
     const usage = { inputTokens: 0, outputTokens: 0 };
-    session.agent.streamFunction = (_model, context, options) => {
+    session.agent.streamFunction = (_model, context2, options) => {
       signal.throwIfAborted();
-      if (++requests > runtime.config.maxRounds || Buffer.byteLength(JSON.stringify(context)) + profile.maxOutputTokens > profile.contextWindow) {
+      if (++requests > runtime.config.maxRounds) {
         budgetError = new HubError(
           413,
-          "AI_CONTEXT_OR_ROUND_LIMIT",
-          "Analysis exceeded its context or model round budget."
+          "AI_ROUND_LIMIT",
+          "Analysis exceeded its model round budget."
         );
         throw budgetError;
       }
       progress("model", `\u6A21\u578B\u5206\u6790\u7B2C ${requests} \u8F6E\u3002`);
-      return models.streamSimple(model, context, {
+      return models.streamSimple(model, context2, {
         ...options,
         ...runtime.config.thinkingLevel !== "off" ? { reasoning: runtime.config.thinkingLevel } : {},
         signal: options?.signal ? AbortSignal.any([signal, options.signal]) : signal,
         maxRetries: 0,
-        maxTokens: profile.maxOutputTokens,
         timeoutMs: runtime.config.requestTimeoutMs,
-        transport: "sse"
+        transport: "sse",
+        onPayload: async (payload, model2) => withoutOutputLimits(await options?.onPayload?.(payload, model2) ?? payload)
       });
     };
     const unsubscribe = session.subscribe((event) => {
@@ -2699,25 +3579,25 @@ async function runAgent(profile, reader, key, signal, progress, runtime, systemP
       session.dispose();
     }
   } finally {
-    await rm(cwd, { recursive: true, force: true });
+    await rm2(cwd, { recursive: true, force: true });
   }
 }
 
 // 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({
-      path: FilePathSchema,
-      startLine: z8.number().int().positive(),
-      endLine: z8.number().int().positive()
+import { z as z11 } from "zod";
+var SummaryOutputSchema = z11.object({
+  summary: z11.string(),
+  findings: z11.array(z11.string()),
+  uncertainties: z11.array(z11.string()).optional(),
+  citations: z11.array(
+    z11.object({
+      path: z11.string(),
+      startLine: z11.number().int().positive(),
+      endLine: z11.number().int().positive()
     }).strict()
-  ).min(1).max(50)
+  )
 }).strict();
-function validateResult(text, reader) {
+function validateResult(text, reader, native = false) {
   let output;
   try {
     output = SummaryOutputSchema.parse(
@@ -2730,29 +3610,29 @@ function validateResult(text, reader) {
       "Analysis did not produce the required JSON result."
     );
   }
-  const citations = output.citations.map((c) => {
-    const file = reader.snapshot.files.find((f) => f.path === c.path);
-    if (!file || !reader.readRanges.get(c.path)?.some(
-      ([start, end]) => c.startLine >= start && c.endLine <= end && c.endLine >= c.startLine
-    ))
-      throw new HubError(
-        422,
-        "AI_CITATION_INVALID",
-        "Analysis cited a file or line range it did not read."
-      );
-    return { ...c, sha256: file.sha256 };
+  const citations = output.citations.flatMap((c) => {
+    const path = native ? memberSourcePath(c.path, reader.snapshot.owner) : c.path;
+    const file = reader.snapshot.files.find((f) => f.path === path);
+    if (c.endLine < c.startLine)
+      throw new HubError(422, "AI_CITATION_INVALID", "Citation line range must be ordered.");
+    if (!file) {
+      reader.limitations.add(`\u5F15\u7528\u672A\u80FD\u5173\u8054\u5230\u672C\u8F6E\u8D44\u6599\uFF1A${c.path}`);
+      return [];
+    }
+    return [{ ...c, path: file.path, sha256: file.sha256 }];
   });
   return AiResultSchema.parse({
     ...output,
     citations,
-    coverage: coverage(reader)
+    uncertainties: output.uncertainties ?? [],
+    coverage: coverage(reader, native)
   });
 }
-function coverage(reader) {
+function coverage(reader, native = false) {
   return {
     totalFiles: reader.snapshot.files.length,
     readFiles: [...reader.readFiles],
-    partial: reader.snapshot.files.some((f) => !reader.fullyRead(f.path)) || reader.limitations.size > 0,
+    ...native ? { accessTracking: "unavailable" } : {},
     limitations: [...reader.limitations]
   };
 }
@@ -2769,25 +3649,23 @@ async function analyzeDirectory(job, reader, key, signal, progress, runtime) {
     workflowPrompt(runtime, SummaryOutputSchema),
     {
       owner: job.snapshot.owner,
+      workspace: `/workspaces/${job.snapshot.owner}/`,
       scope: job.snapshot.path || "/",
       revision: job.snapshot.revision,
       totalFiles: job.snapshot.files.length,
       question: job.request.question
     }
   );
-  return { result: validateResult(output.text, reader), usage: output.usage };
+  return {
+    result: validateResult(output.text, reader, runtime.config.execution === "native-sandbox"),
+    usage: output.usage
+  };
 }
 
 // apps/server/ai/workflows/file-summary.ts
 async function summarizeFile(job, reader, key, signal, runtime) {
   const path = job.snapshot.path;
-  const body = await reader.whole(
-    path,
-    Math.min(
-      runtime.config.maxReadBytes,
-      Math.max(1024, job.profile.contextWindow - job.profile.maxOutputTokens - 4e3)
-    )
-  );
+  const body = await reader.whole(path);
   const context = {
     systemPrompt: workflowPrompt(runtime, SummaryOutputSchema),
     messages: [
@@ -2802,13 +3680,6 @@ async function summarizeFile(job, reader, key, signal, runtime) {
       }
     ]
   };
-  if (Buffer.byteLength(JSON.stringify(context)) + job.profile.maxOutputTokens > job.profile.contextWindow) {
-    throw new HubError(
-      413,
-      "AI_CONTEXT_OR_ROUND_LIMIT",
-      "File exceeds the analysis context budget."
-    );
-  }
   const { message } = await modelCall(
     job.profile,
     key,
@@ -2826,61 +3697,81 @@ 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 z12 } from "zod";
+var LegacyTaskOutputSchema = z12.object({
+  tasks: z12.array(
+    TaskFieldsSchema.extend({
+      taskId: z12.uuid().nullable().optional(),
+      sources: z12.array(z12.string())
+    })
+  ),
+  uncertainties: z12.array(z12.string()).optional()
+}).strict();
+var LegacyPatchOutputSchema = z12.object({
+  upsert: z12.array(
+    TaskFieldsSchema.extend({ taskId: z12.uuid().nullable(), sources: z12.array(z12.string()) })
+  ),
+  archive: z12.array(z12.uuid()),
+  uncertainties: z12.array(z12.string()).optional()
+}).strict();
+var TaskOutputSchema = z12.object({
+  upsert: z12.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: z12.uuid().nullable(),
+      sources: z12.array(z12.string()),
+      needsConfirmation: z12.boolean()
     })
-  ).max(100),
-  uncertainties: z9.array(z9.string().max(2e3)).max(50)
+  ),
+  archive: z12.array(z12.uuid())
 }).strict();
-function validateTasks(text, reader, context) {
+function validateTasks(text, reader, context, patch = true, native = false) {
   let output;
   try {
-    output = TaskOutputSchema.parse(
-      JSON.parse(text.trim().replace(/^```(?:json)?\s*\n([\s\S]*)\n```$/, "$1"))
-    );
+    const json = JSON.parse(text.trim().replace(/^```(?:json)?\s*\n([\s\S]*)\n```$/, "$1"));
+    if (patch) {
+      const parsed = native ? TaskOutputSchema.parse(json) : LegacyPatchOutputSchema.parse(json);
+      output = {
+        tasks: parsed.upsert,
+        archive: parsed.archive,
+        uncertainties: native ? void 0 : parsed.uncertainties
+      };
+    } else output = LegacyTaskOutputSchema.parse(json);
   } catch {
-    throw new HubError(422, "AI_RESULT_INVALID", "Analysis did not produce a valid task list.");
+    throw new HubError(422, "AI_RESULT_INVALID", "Analysis did not produce valid task changes.");
   }
-  if (!reader.readFiles.size)
-    throw new HubError(
-      422,
-      "AI_TASK_SOURCE_INVALID",
-      "Read workspace material before deciding whether it contains tasks."
-    );
-  const keys = output.tasks.map((task) => JSON.stringify([task.title, [...task.sources].sort()]));
-  if (new Set(keys).size !== keys.length)
-    throw new HubError(422, "AI_TASK_DUPLICATE", "Task list contains identical entries.");
   const previous = new Map(context?.tasks.map((task) => [task.taskId, task]));
   const used = /* @__PURE__ */ new Set();
-  for (const task of output.tasks) {
-    if (!task.taskId) continue;
-    const old = previous.get(task.taskId);
-    if (!old || used.has(task.taskId) || !task.sources.some((path) => {
-      const current = reader.snapshot.files.find((file) => file.path === path);
-      return current && old.sources.some((source) => source.path === path || source.sha256 === current.sha256);
-    }))
+  for (const id of [
+    ...output.tasks.flatMap((task) => task.taskId ? [task.taskId] : []),
+    ...output.archive ?? []
+  ]) {
+    if (!previous.has(id) || used.has(id))
       throw new HubError(
         422,
         "AI_TASK_ID_INVALID",
-        "Existing task identity must be unique and supported by this member\u2019s prior sources."
+        "Existing task identity must be unique and belong to this member."
       );
-    used.add(task.taskId);
+    used.add(id);
   }
   return TaskAnalysisResultSchema.parse({
     kind: "task-bootstrap",
+    ...patch ? { updateMode: "patch", archive: output.archive } : {},
     tasks: output.tasks.map((task) => ({
       ...task,
-      sources: task.sources.map((path) => reader.source(path))
+      sources: [...new Set(task.sources)].flatMap((path) => {
+        const relative = native ? memberSourcePath(path, reader.snapshot.owner) : path;
+        const source = reader.source(relative ?? path);
+        return source ? [source] : [];
+      })
     })),
-    uncertainties: output.uncertainties,
-    coverage: coverage(reader)
+    ...!native ? { uncertainties: output.uncertainties ?? [] } : {},
+    coverage: coverage(reader, native)
   });
 }
 async function bootstrapTasks(job, reader, key, signal, progress, runtime) {
+  const patch = runtime.config.version >= 7;
+  const native = runtime.config.execution === "native-sandbox";
+  const explorer = patch && !native ? new TaskExplorer(reader, job.taskContext, signal) : void 0;
   const output = await runAgent(
     job.profile,
     reader,
@@ -2888,15 +3779,28 @@ async function bootstrapTasks(job, reader, key, signal, progress, runtime) {
     signal,
     progress,
     runtime,
-    workflowPrompt(runtime, TaskOutputSchema),
-    {
+    workflowPrompt(
+      runtime,
+      native ? TaskOutputSchema : patch ? LegacyPatchOutputSchema : LegacyTaskOutputSchema
+    ),
+    native ? await taskInput(reader, job.taskContext, signal) : explorer?.overview() ?? {
       owner: job.snapshot.owner,
       revision: job.snapshot.revision,
-      inventory: reader.list("", 100),
-      previous: job.taskContext
-    }
+      inventory: reader.list(),
+      previous: job.taskContext ? {
+        previousRevision: job.taskContext.previousRevision,
+        changes: job.taskContext.changes,
+        tasks: job.taskContext.tasks.filter((task) => task.active !== false)
+      } : null,
+      projectReferences: job.snapshot.project ? reader.projectReader().list() : null
+    },
+    explorer,
+    job.taskContext
   );
-  return { result: validateTasks(output.text, reader, job.taskContext), usage: output.usage };
+  return {
+    result: validateTasks(output.text, reader, job.taskContext, patch, native),
+    usage: output.usage
+  };
 }
 
 // apps/server/ai/bootstrap.ts
@@ -2913,20 +3817,24 @@ function requestTaskBootstrap(hub, session, owner, operationId) {
   return { jobId: job.id, empty: false };
 }
 function scheduleTaskBootstraps(hub, at = Date.now()) {
+  const jobs = new AiJobs(hub);
+  jobs.cancelStaleTaskJobs();
   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();
   if (!candidates.length) return 0;
   const runtime = loadWorkflow("task-bootstrap");
-  const defaults = new AiDefaults(hub), jobs = new AiJobs(hub);
+  const defaults = new AiDefaults(hub);
   let queued = 0;
   for (const row of candidates) {
     if (at - Date.parse(String(row.created_at)) < runtime.config.settleSeconds * 1e3) continue;
@@ -2985,8 +3893,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",
@@ -2998,9 +3905,10 @@ async function runAiCycle(hub, stop) {
           job,
           {
             kind: "task-bootstrap",
+            ...runtime.config.version >= 7 ? { updateMode: "patch", archive: [] } : {},
             tasks: [],
-            uncertainties: [],
-            coverage: { totalFiles: 0, readFiles: [], partial: false, limitations: [] }
+            ...runtime.config.execution !== "native-sandbox" ? { uncertainties: [] } : {},
+            coverage: { totalFiles: 0, readFiles: [], limitations: [] }
           },
           null,
           { inputTokens: 0, outputTokens: 0 }
@@ -3017,10 +3925,7 @@ async function runAiCycle(hub, stop) {
       hub,
       { workspaceId: job.workspace, memberId: job.requester },
       job.snapshot,
-      Math.min(
-        runtime.config.maxReadBytes,
-        Math.max(2048, job.profile.contextWindow - job.profile.maxOutputTokens - 4e3)
-      )
+      runtime.config.maxReadBytes
     );
     const key = config.secret(profile.id);
     const output = job.request.workflow === "file-summary" ? await summarizeFile(job, reader, key, signal, runtime) : await (job.request.workflow === "task-bootstrap" ? bootstrapTasks : analyzeDirectory)(
@@ -3079,11 +3984,11 @@ async function runAiWorker(directory, once = false) {
 }
 
 // apps/server/main.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { parseArgs } from "node:util";
 
 // apps/server/ai/job-routes.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 
 // apps/server/web-auth.ts
 function cookieToken(request) {
@@ -3129,10 +4034,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) => z13.object({ id: z13.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 = z13.object({
+      after: z13.string().regex(/^\d{0,15}$/).default("")
     }).parse(req.query);
     return jobs.list(session.workspaceId, query.after);
   });
@@ -3145,7 +4050,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 = z13.object({ after: z13.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 +4062,13 @@ function registerAiJobRoutes(server, hub) {
     return jobs.retry(
       authorizeWeb(hub, req),
       id(req.params),
-      z10.object({ operationId: z10.uuid() }).strict().parse(req.body).operationId
+      z13.object({ operationId: z13.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 = z13.object({ path: z13.string().max(1024), startLine: z13.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 +4080,10 @@ function registerAiJobRoutes(server, hub) {
 }
 
 // apps/server/ai/task-routes.ts
-import { z as z11 } from "zod";
+import { z as z14 } 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) => z14.object({ id: z14.uuid() }).parse(params).id;
   server.get("/tasks", async (req) => store.board(authorizeWeb(hub, req)));
   server.post("/tasks/bootstrap", async (req) => {
     webMutation(req);
@@ -3253,7 +4158,7 @@ function registerAiRoutes(server, store) {
         profile,
         config.secret(profile.id),
         mode,
-        AbortSignal.any([controller.signal, AbortSignal.timeout(3e4)])
+        AbortSignal.any([controller.signal, AbortSignal.timeout(3e5)])
       );
     } catch (e) {
       if (e instanceof HubError) throw e;
@@ -3270,11 +4175,11 @@ function registerAiRoutes(server, store) {
 }
 
 // apps/server/static.ts
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 import fastifyStatic from "@fastify/static";
 function registerWeb(server, root) {
   server.register(fastifyStatic, {
-    root: join6(root, "assets"),
+    root: join8(root, "assets"),
     prefix: "/assets/",
     immutable: true,
     maxAge: "1y",
@@ -3312,20 +4217,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 z15 } 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 = z15.object({ status: z15.literal("ok") });
+var ServerInfoSchema = z15.object({
+  name: z15.literal("teammy"),
+  version: z15.string().min(1),
+  protocolVersion: z15.literal(PROTOCOL_VERSION),
+  capabilities: z15.array(z15.string())
 });
-var ErrorResponseSchema = z12.object({
-  error: z12.object({
-    code: z12.string(),
-    message: z12.string(),
-    requestId: z12.string()
+var ErrorResponseSchema = z15.object({
+  error: z15.object({
+    code: z15.string(),
+    message: z15.string(),
+    requestId: z15.string()
   })
 });
 
@@ -3333,43 +4238,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 z16 } from "zod";
+var CredentialSchema = z16.string().regex(/^tmy_[a-f0-9]{64}$/);
+var EnrollmentSchema = z16.object({
+  operationId: z16.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 = z16.object({
+  checkIntervalSeconds: z16.number().min(1).max(86400),
+  fileSettleSeconds: z16.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 = z16.object({
+  checkedAt: z16.string(),
+  published: z16.boolean(),
+  appliedFiles: z16.number().int().nonnegative(),
+  pendingFiles: z16.number().int().nonnegative(),
+  sessionSources: z16.number().int().nonnegative(),
+  errors: z16.array(z16.string().max(1e3)).max(20)
 }).strict();
-var DeviceStatusSchema = z13.object({
-  clientVersion: z13.string().max(64),
+var DeviceStatusSchema = z16.object({
+  clientVersion: z16.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: z16.array(z16.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
+  configError: z16.string().max(2e3).nullable(),
+  reportError: z16.string().max(2e3).nullable(),
   lastSync: SyncSummarySchema.nullable()
 }).strict();
-var WebDevicesSchema = z13.object({
-  devices: z13.array(
-    z13.object({
+var WebDevicesSchema = z16.object({
+  devices: z16.array(
+    z16.object({
       memberId: NameSchema,
-      bound: z13.boolean(),
-      lastSeenAt: z13.string().nullable(),
+      bound: z16.boolean(),
+      lastSeenAt: z16.string().nullable(),
       status: DeviceStatusSchema.nullable()
     })
   )
@@ -3407,7 +4312,7 @@ function registerControlRoutes(server, store) {
 }
 
 // apps/server/project-routes.ts
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 function registerProjectRoutes(server, store) {
   const project = new ProjectRepository(store), site = new SiteRepository(store);
   server.get("/api/v1/projects", async (request) => ({
@@ -3454,7 +4359,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 } = z17.object({ id: NameSchema }).parse(request.params);
     return project.updateMember(
       authorizeWeb(store, request),
       id,
@@ -3463,13 +4368,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 } = z17.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 z18 } from "zod";
 
 // apps/server/devices.ts
 var DeviceRepository = class {
@@ -3487,7 +4392,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 +4402,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 +4450,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 } = z18.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 +4464,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 } = z18.object({ displayName: z18.string().trim().max(120) }).strict().parse(request.body);
     return site.renameSelf(identity, displayName);
   });
   server.delete("/api/v1/web/session", async (request, reply) => {
@@ -3600,71 +4505,71 @@ function registerSiteRoutes(server, store) {
 }
 
 // apps/server/session-routes.ts
-import { z as z17 } from "zod";
+import { z as z20 } 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 z19 } from "zod";
+var AgentSchema = z19.enum(["claude-code", "codex", "cursor", "pi", "dsh"]);
+var SessionSnapshotSchema = z19.object({
+  formatVersion: z19.literal(1),
+  adapterVersion: z19.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: z19.string().min(1).max(512),
+  cwd: z19.string().min(1).max(4096),
+  messages: z19.array(
+    z19.object({
+      id: z19.string().min(1).max(1024),
+      role: z19.enum(["user", "assistant"]),
+      text: z19.string().min(1).max(2 * 1024 * 1024),
+      source: z19.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 = z19.object({
+  operationId: z19.uuid(),
   sessionKey: HashSchema,
   parentRevision: RevisionSchema,
   blob: BlobRefSchema
 }).strict();
-var SessionInfoSchema = z16.object({
+var SessionInfoSchema = z19.object({
   owner: NameSchema,
   sessionKey: HashSchema,
   agent: AgentSchema,
-  nativeId: z16.string(),
-  cwd: z16.string(),
-  title: z16.string(),
+  nativeId: z19.string(),
+  cwd: z19.string(),
+  title: z19.string(),
   revision: RevisionSchema,
-  updatedAt: z16.string(),
-  messageCount: z16.number().int().nonnegative(),
+  updatedAt: z19.string(),
+  messageCount: z19.number().int().nonnegative(),
   blob: BlobRefSchema
 });
-var SessionListSchema = z16.object({
-  sessions: z16.array(SessionInfoSchema),
+var SessionListSchema = z19.object({
+  sessions: z19.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 = z19.object({
+  totalSessions: z19.number().int().nonnegative(),
+  totalMessages: z19.number().int().nonnegative(),
+  memberCount: z19.number().int().nonnegative(),
+  updatedAt: z19.string().nullable()
 });
-var SessionScopeSchema = z16.object({
+var SessionScopeSchema = z19.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 = z19.object({
+  matches: z19.array(
+    z19.object({
       owner: NameSchema,
       sessionKey: HashSchema,
       revision: RevisionSchema,
-      messageId: z16.string(),
-      role: z16.enum(["user", "assistant"]),
-      snippet: z16.string(),
-      title: z16.string()
+      messageId: z19.string(),
+      role: z19.enum(["user", "assistant"]),
+      snippet: z19.string(),
+      title: z19.string()
     })
   ),
   nextCursor: RevisionSchema.nullable()
@@ -3835,21 +4740,21 @@ var SessionRepository = class {
       nextCursor: rows.length > limit ? Number(rows[limit - 1].id) : null
     };
   }
-  search(identity, query, after, limit, scope = {}) {
-    SessionScopeSchema.parse(scope);
+  search(identity, query, after, limit, scope2 = {}) {
+    SessionScopeSchema.parse(scope2);
     const lower = query.toLowerCase();
     const indexed = [...lower].length >= 3;
     const rows = this.hub.db.prepare(
       `SELECT m.*,s.title,s.native_id FROM session_messages m JOIN sessions s USING(workspace_id,owner,session_key)
       WHERE m.workspace_id=? AND m.id>? AND instr(m.search_text, ?)>0
-      ${scope.owner ? "AND m.owner=?" : ""} ${scope.sessionKey ? "AND m.session_key=?" : ""}
+      ${scope2.owner ? "AND m.owner=?" : ""} ${scope2.sessionKey ? "AND m.session_key=?" : ""}
       ${indexed ? "AND m.id IN (SELECT rowid FROM session_fts WHERE session_fts MATCH ?)" : ""} ORDER BY m.id LIMIT ?`
     ).all(
       identity.workspaceId,
       after,
       lower,
-      ...scope.owner ? [scope.owner] : [],
-      ...scope.sessionKey ? [scope.sessionKey] : [],
+      ...scope2.owner ? [scope2.owner] : [],
+      ...scope2.sessionKey ? [scope2.sessionKey] : [],
       ...indexed ? [`"${lower.replaceAll('"', '""')}"`] : [],
       limit + 1
     );
@@ -3881,9 +4786,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 = z20.object({
+    after: z20.coerce.number().pipe(RevisionSchema).default(0),
+    limit: z20.coerce.number().int().min(1).max(100).default(50)
   });
   server.post(
     "/sessions/commits",
@@ -3903,7 +4808,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: z20.string().min(1).max(500).refine((s) => !s.includes("\0"))
     }).parse(request.query);
     return sessions.search(
       authorizeRead(store, request),
@@ -3914,16 +4819,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 = z20.object({ owner: NameSchema, key: HashSchema }).parse(request.params);
+    const q = z20.object({ revision: z20.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 z21 } 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 +4857,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 } = z21.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 } = z21.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 +4875,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 } = z21.object({ owner: FileOwnerSchema }).parse(request.params);
+    const query = z21.object({
+      revision: z21.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      after: z21.string().max(1024).default(""),
+      limit: z21.coerce.number().int().min(1).max(500).default(200)
     }).parse(request.query);
     return files.manifest(
       authorizeRead(store, request),
@@ -3977,28 +4895,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 } = z21.object({ owner: FileOwnerSchema }).parse(request.params);
+    const q = z21.object({
       path: FilePathSchema,
-      revision: z18.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
+      revision: z21.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 } = z21.object({ owner: FileOwnerSchema }).parse(request.params);
+    const q = z21.object({
+      path: z21.union([z21.literal(""), FilePathSchema]).default(""),
+      revision: z21.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      after: z21.string().max(255).default(""),
+      limit: z21.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 } = z21.object({ owner: FileOwnerSchema }).parse(request.params);
+    const query = z21.object({
+      after: z21.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+      limit: z21.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 +4968,7 @@ function buildServer(options) {
         "identity",
         "blobs",
         "file-revisions",
+        "project-files",
         "session-revisions",
         "session-search",
         "project-config",
@@ -4066,14 +4985,14 @@ function buildServer(options) {
     registerSiteRoutes(server, store);
     registerProjectRoutes(server, store);
     registerAiRoutes(server, store);
-    const projectRoutes = async (scope) => {
-      registerProjectScopeRoutes(scope, store);
-      registerAiJobRoutes(scope, store);
-      registerTaskRoutes(scope, store);
-      registerControlRoutes(scope, store);
-      registerFileRoutes(scope, store);
-      registerSessionRoutes(scope, store);
-      scope.get("/members", async (request) => ({
+    const projectRoutes = async (scope2) => {
+      registerProjectScopeRoutes(scope2, store);
+      registerAiJobRoutes(scope2, store);
+      registerTaskRoutes(scope2, store);
+      registerControlRoutes(scope2, store);
+      registerFileRoutes(scope2, store);
+      registerSessionRoutes(scope2, store);
+      scope2.get("/members", async (request) => ({
         members: store.members(authorizeDevice(store, request))
       }));
     };
@@ -4090,7 +5009,7 @@ function buildServer(options) {
 
 // apps/server/main.ts
 import { homedir } from "node:os";
-import { join as join7, resolve as resolve3 } from "node:path";
+import { join as join9, resolve as resolve3 } from "node:path";
 var help = `teammy-server \u2014 the Teammy collaboration hub
 
 Usage: teammy-server [--host HOST] [--port PORT]
@@ -4115,13 +5034,13 @@ Open the server URL to initialize the Web dashboard and preset member IDs.
 File synchronization, session search and manual AI analysis are available.
 AI tasks require a separate ai-worker process using the same data directory.
 `;
-async function runServerCli(args, version) {
+async function runServerCli(args, version2) {
   try {
     if (args[0] === "ai-worker") {
       const { values: values2 } = parseArgs({
         args: args.slice(1),
         options: {
-          "data-dir": { type: "string", default: join7(homedir(), ".teammy", "server") },
+          "data-dir": { type: "string", default: join9(homedir(), ".teammy", "server") },
           once: { type: "boolean" }
         }
       });
@@ -4137,7 +5056,7 @@ async function runServerCli(args, version) {
         options: {
           workspace: { type: "string" },
           member: { type: "string" },
-          "data-dir": { type: "string", default: join7(homedir(), ".teammy", "server") }
+          "data-dir": { type: "string", default: join9(homedir(), ".teammy", "server") }
         }
       });
       if (!values2.workspace || !values2.member)
@@ -4162,7 +5081,7 @@ async function runServerCli(args, version) {
         version: { type: "boolean", short: "v" },
         host: { type: "string", default: "127.0.0.1" },
         port: { type: "string", default: "4317" },
-        "data-dir": { type: "string", default: join7(homedir(), ".teammy", "server") }
+        "data-dir": { type: "string", default: join9(homedir(), ".teammy", "server") }
       }
     });
     if (values.help) {
@@ -4170,7 +5089,7 @@ async function runServerCli(args, version) {
       return 0;
     }
     if (values.version) {
-      process.stdout.write(`${version}
+      process.stdout.write(`${version2}
 `);
       return 0;
     }
@@ -4180,10 +5099,10 @@ async function runServerCli(args, version) {
     }
     if (!values.host?.trim()) throw new Error("Host must not be empty.");
     const server = buildServer({
-      version,
+      version: version2,
       logger: true,
       dataDir: resolve3(values["data-dir"]),
-      webDir: fileURLToPath2(new URL("./web/", import.meta.url))
+      webDir: fileURLToPath3(new URL("./web/", import.meta.url))
     });
     try {
       await server.listen({ host: values.host, port: Number(portText) });