@teammy/server 0.0.8 → 0.0.9

package/dist/main.js

@@ -110,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}`);
       }
@@ -1089,7 +1089,7 @@ function captureSnapshot(hub, identity, selection, options = {}) {
   return snapshot;
 }
 var SnapshotReader = class _SnapshotReader {
-  constructor(hub, identity, snapshot, budget = 6e4, sharedBudget) {
+  constructor(hub, identity, snapshot, budget = Number.POSITIVE_INFINITY, sharedBudget) {
     this.hub = hub;
     this.identity = identity;
     this.snapshot = snapshot;
@@ -1099,8 +1099,6 @@ var SnapshotReader = class _SnapshotReader {
   identity;
   snapshot;
   readFiles = /* @__PURE__ */ new Set();
-  lineCounts = /* @__PURE__ */ new Map();
-  readRanges = /* @__PURE__ */ new Map();
   limitations = /* @__PURE__ */ new Set();
   budget;
   commonReader;
@@ -1116,21 +1114,16 @@ var SnapshotReader = class _SnapshotReader {
       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
@@ -1143,12 +1136,10 @@ var SnapshotReader = class _SnapshotReader {
   }
   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);
@@ -1156,45 +1147,35 @@ var SnapshotReader = class _SnapshotReader {
       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 || 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.budget.remaining)) break;
-      selected.push(line);
-      size += cost;
-    }
-    if (!selected.length) {
-      this.limitations.add("\u8BFB\u53D6\u9884\u7B97\u6216\u5355\u884C\u957F\u5EA6\u9650\u5236\u963B\u6B62\u4E86\u7EE7\u7EED\u8BFB\u53D6\u3002");
-      throw new HubError(413, "AI_READ_BUDGET", "Read budget exceeded or line is too long.");
-    }
-    this.budget.remaining -= size;
+    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,
@@ -1204,55 +1185,55 @@ var SnapshotReader = class _SnapshotReader {
       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);
-    const matches = [];
-    let scannedBytes = 0;
-    for (const file of files) {
-      if (file.size > 256 * 1024) {
-        this.limitations.add("\u90E8\u5206\u5927\u6587\u4EF6\u672A\u53C2\u4E0E\u6B63\u6587\u641C\u7D22\u3002");
-        continue;
-      }
-      if (scannedBytes + file.size > 1024 * 1024) {
-        return {
-          matches,
-          nextCursor: files[files.indexOf(file) - 1]?.path ?? after,
-          limited: true
-        };
-      }
-      scannedBytes += file.size;
+  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 lines = (await this.text(file.path)).split("\n");
-        for (let i = 0; i < lines.length; i++)
-          if (lines[i].toLowerCase().includes(query.toLowerCase())) {
-            matches.push({ path: file.path, line: i + 1, excerpt: lines[i].slice(0, 400) });
-            if (matches.length >= 30) return { matches, nextCursor: file.path, limited: true };
-          }
-      } catch (e) {
-        if (e instanceof HubError && e.code === "AI_TEXT_REQUIRED") {
-          this.limitations.add("\u90E8\u5206\u975E\u6587\u672C\u6587\u4EF6\u672A\u53C2\u4E0E\u6B63\u6587\u641C\u7D22\u3002");
-          continue;
+        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 = [];
+    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
+          };
         }
-        throw e;
+        matches.push({ path: file.path, line: i + 1, excerpt: lines[i] });
       }
     }
-    return {
-      matches,
-      nextCursor: files.length === limit ? files.at(-1).path : null,
-      limited: false
-    };
+    return { matches, nextCursor: null, limited: false };
   }
 };
 
@@ -1438,6 +1419,10 @@ 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) {
@@ -1467,7 +1452,8 @@ var migrations = [
   equalMembershipMigration,
   taskBoardMigration,
   taskMaintenanceMigration,
-  sharedFilesMigration
+  sharedFilesMigration,
+  aiRetryMigration
 ];
 var HubStore = class {
   constructor(directory) {
@@ -1476,8 +1462,8 @@ var HubStore = class {
     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)
+        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."
           );
@@ -1572,10 +1558,11 @@ import { z as z6 } from "zod";
 import { z as z5 } from "zod";
 var TaskStatusSchema = z5.enum(["planned", "in_progress", "in_review", "completed"]);
 var TaskFieldsSchema = z5.object({
-  title: z5.string().trim().min(1).max(200),
-  goal: z5.string().trim().min(1).max(2e3).nullable(),
+  title: z5.string().trim(),
+  goal: z5.string().trim().nullable(),
   status: TaskStatusSchema.nullable(),
-  progress: z5.string().trim().min(1).max(2e3)
+  progress: z5.string().trim(),
+  needsConfirmation: z5.boolean().default(false)
 }).strict();
 var TaskSourceSchema = z5.object({
   path: FilePathSchema,
@@ -1587,14 +1574,17 @@ var TaskCardSchema = TaskFieldsSchema.extend({
   id: z5.uuid(),
   owner: NameSchema,
   jobId: z5.uuid(),
-  sources: z5.array(TaskSourceSchema).min(1),
-  syncedAt: z5.string(),
+  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()
+  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),
@@ -1605,7 +1595,6 @@ var TaskBoardSchema = z5.object({
       status: z5.enum(["empty", "waiting", "queued", "running", "succeeded", "failed", "cancelled"]),
       error: z5.string().nullable(),
       sourceChanged: z5.boolean(),
-      partial: z5.boolean(),
       uncertainties: z5.array(z5.string())
     })
   ),
@@ -1624,13 +1613,8 @@ var AiProfileSchema = z6.object({
   protocol: z6.enum(["openai-completions", "openai-responses", "anthropic-messages"]),
   baseUrl: ServerUrlSchema,
   model: z6.string().trim().min(1).max(200),
-  enabled: z6.boolean().default(true),
-  contextWindow: z6.number().int().min(4096).max(2e6).default(32e3),
-  maxOutputTokens: z6.number().int().min(128).max(16e3).default(2048)
-}).strict().refine(
-  (p) => p.maxOutputTokens < p.contextWindow,
-  "Output budget must be smaller than context window."
-);
+  enabled: z6.boolean().default(true)
+}).strict();
 var AiPublicProfileSchema = AiProfileSchema.safeExtend({
   revision: z6.number().int(),
   keyConfigured: z6.boolean()
@@ -1671,7 +1655,7 @@ var AiJobCreateSchema = z6.object({
   profileId: NameSchema.optional(),
   workflow: z6.enum(["file-summary", "directory-analysis", "task-bootstrap"]),
   selection: AiSelectionSchema,
-  question: z6.string().trim().max(2e3).default("")
+  question: z6.string().trim().default("")
 }).strict();
 var AiCitationSchema = z6.object({
   path: FilePathSchema,
@@ -1681,26 +1665,31 @@ var AiCitationSchema = z6.object({
 });
 var AiCoverageSchema = z6.object({
   totalFiles: z6.number().int(),
+  // Access diagnostics only; reading a file does not establish semantic completeness.
   readFiles: z6.array(FilePathSchema),
-  partial: z6.boolean(),
+  accessTracking: z6.literal("unavailable").optional(),
   limitations: z6.array(z6.string())
 });
 var AiResultSchema = z6.object({
-  summary: z6.string().min(1).max(2e4),
-  findings: z6.array(z6.string().max(2e3)).max(30),
-  uncertainties: z6.array(z6.string().max(2e3)).max(30),
-  citations: z6.array(AiCitationSchema).max(50),
+  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).min(1).max(50)
+      sources: z6.array(TaskSourceSchema)
     })
-  ).max(100),
-  uncertainties: z6.array(z6.string().max(2e3)).max(50),
+  ),
+  // 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]);
@@ -1788,11 +1777,18 @@ var AiConfig = class {
     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
-    }));
+    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);
@@ -1837,8 +1833,8 @@ var AiDefaults = class {
     this.hub = hub;
   }
   hub;
-  read(scope) {
-    const row = this.hub.db.prepare("SELECT * FROM ai_defaults WHERE scope=?").get(scope);
+  read(scope2) {
+    const row = this.hub.db.prepare("SELECT * FROM ai_defaults WHERE scope=?").get(scope2);
     return {
       profileId: row?.profile_id ? String(row.profile_id) : null,
       revision: Number(row?.revision ?? 0)
@@ -1861,10 +1857,10 @@ var AiDefaults = class {
   project(projectId2) {
     return this.view(projectId2);
   }
-  save(scope, value) {
+  save(scope2, value) {
     const input = AiDefaultUpdateSchema.parse(value);
     transaction(this.hub.db, () => {
-      if (this.read(scope).revision !== input.expectedRevision)
+      if (this.read(scope2).revision !== input.expectedRevision)
         throw new HubError(
           409,
           "AI_CONFIG_CONFLICT",
@@ -1874,7 +1870,7 @@ var AiDefaults = class {
         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);
+      ).run(scope2, input.profileId, input.expectedRevision + 1);
     });
   }
   saveSite(identity, value) {
@@ -1905,31 +1901,57 @@ import { resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z as z7 } from "zod";
 var WorkflowNameSchema = z7.enum(["file-summary", "directory-analysis", "task-bootstrap"]);
-var ToolNameSchema = z7.enum(["list_files", "read_file", "search_files"]);
-var ToolTextSchema = z7.object({ label: z7.string().min(1).max(100), description: z7.string().min(1).max(2e3) }).strict();
+var 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).max(3).refine((v) => new Set(v).size === v.length),
-  maxRounds: z7.number().int().min(1).max(100),
-  maxToolCalls: z7.number().int().min(1).max(500),
-  timeoutMs: z7.number().int().min(1e3).max(9e5),
-  requestTimeoutMs: z7.number().int().min(1e3).max(12e4),
-  maxReadBytes: z7.number().int().min(1024).max(2e6),
+  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();
+}).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: z7.string().min(1).max(32e3),
-  prompt: z7.string().min(1).max(32e3),
+  system: z7.string().min(1),
+  prompt: z7.string().min(1),
   config: RuntimeConfigSchema,
   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: 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);
@@ -1939,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")
@@ -2002,35 +2030,49 @@ function applyTaskResult(hub, job, result) {
       "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,
@@ -2046,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);
@@ -2068,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) {
@@ -2097,8 +2136,7 @@ var TaskStore = class {
           status: row.status ?? (row.has_files ? "waiting" : "empty"),
           error: row.error ?? null,
           sourceChanged: snapshot ? !taskSnapshotCurrent(this.hub, session.workspaceId, snapshot) : false,
-          partial: result?.coverage.partial ?? false,
-          uncertainties: result ? [...result.uncertainties, ...result.coverage.limitations] : []
+          uncertainties: result ? [...result.uncertainties ?? [], ...result.coverage.limitations] : []
         };
       }),
       modelAvailable: new AiDefaults(this.hub).project(session.workspaceId).available
@@ -2119,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))
     }))
   };
@@ -2146,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;
@@ -2388,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'"
@@ -2408,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);
@@ -2434,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");
@@ -2452,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;
@@ -2478,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()
@@ -2500,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;
     });
@@ -2509,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 z8 } 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.");
-    }
-  };
+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: {}
@@ -2534,44 +2729,44 @@ function analysisTools(reader, signal, progress, runtime) {
     {
       name: "list_files",
       ...runtime.toolText.list_files,
-      parameters: Type.Object(
+      parameters: Type2.Object(
         {
-          after: Type.Optional(Type.String({ maxLength: 1024 })),
-          scope: Type.Optional(Type.Union([Type.Literal("member"), Type.Literal("project")]))
+          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 = z8.object({
-          after: z8.string().max(1024).default(""),
-          scope: z8.enum(["member", "project"]).default("member")
+        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((p.scope === "project" ? reader.projectReader() : 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(),
-          scope: Type.Optional(Type.Union([Type.Literal("member"), Type.Literal("project")])),
-          startLine: Type.Optional(Type.Integer({ minimum: 1 })),
-          limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 150 }))
+          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 = z8.object({
+        signal.throwIfAborted();
+        const p = z9.object({
           path: FilePathSchema,
-          scope: z8.enum(["member", "project"]).default("member"),
-          startLine: z8.number().int().min(1).max(1e6).default(1),
-          limit: z8.number().int().min(1).max(150).default(150)
+          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(
@@ -2586,17 +2781,17 @@ function analysisTools(reader, signal, progress, runtime) {
     {
       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 = z8.object({ query: z8.string().min(1).max(200), after: z8.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));
       }
@@ -2606,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,
@@ -2619,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: {
@@ -2666,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;
@@ -2700,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,
@@ -2762,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,
@@ -2771,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({
@@ -2812,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) => {
@@ -2861,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 z9 } from "zod";
-var SummaryOutputSchema = z9.object({
-  summary: z9.string().min(1).max(2e4),
-  findings: z9.array(z9.string().max(2e3)).max(30),
-  uncertainties: z9.array(z9.string().max(2e3)).max(30),
-  citations: z9.array(
-    z9.object({
-      path: FilePathSchema,
-      startLine: z9.number().int().positive(),
-      endLine: z9.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(
@@ -2892,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]
   };
 }
@@ -2931,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: [
@@ -2964,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,
@@ -2988,61 +3697,81 @@ async function summarizeFile(job, reader, key, signal, runtime) {
 }
 
 // apps/server/ai/workflows/task-bootstrap.ts
-import { z as z10 } from "zod";
-var TaskOutputSchema = z10.object({
-  tasks: z10.array(
+import { z as z12 } from "zod";
+var LegacyTaskOutputSchema = z12.object({
+  tasks: z12.array(
     TaskFieldsSchema.extend({
-      taskId: z10.uuid().nullable().optional(),
-      sources: z10.array(FilePathSchema).min(1).max(50).refine((v) => new Set(v).size === v.length)
+      taskId: z12.uuid().nullable().optional(),
+      sources: z12.array(z12.string())
     })
-  ).max(100),
-  uncertainties: z10.array(z10.string().max(2e3)).max(50)
+  ),
+  uncertainties: z12.array(z12.string()).optional()
 }).strict();
-function validateTasks(text, reader, context) {
+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: z12.uuid().nullable(),
+      sources: z12.array(z12.string()),
+      needsConfirmation: z12.boolean()
+    })
+  ),
+  archive: z12.array(z12.uuid())
+}).strict();
+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,
@@ -3050,16 +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,
-      projectReferences: job.snapshot.project ? reader.projectReader().list("", 100) : null
-    }
+      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
@@ -3076,6 +3817,8 @@ 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,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
@@ -3091,7 +3834,7 @@ function scheduleTaskBootstraps(hub, at = Date.now()) {
   ).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;
@@ -3162,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 }
@@ -3181,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)(
@@ -3243,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 z11 } from "zod";
+import { z as z13 } from "zod";
 
 // apps/server/web-auth.ts
 function cookieToken(request) {
@@ -3293,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) => z11.object({ id: z11.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 = z11.object({
-      after: z11.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);
   });
@@ -3309,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 = z11.object({ after: z11.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) => {
@@ -3321,13 +4062,13 @@ function registerAiJobRoutes(server, hub) {
     return jobs.retry(
       authorizeWeb(hub, req),
       id(req.params),
-      z11.object({ operationId: z11.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 = z11.object({ path: z11.string().max(1024), startLine: z11.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(
@@ -3339,10 +4080,10 @@ function registerAiJobRoutes(server, hub) {
 }
 
 // apps/server/ai/task-routes.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 function registerTaskRoutes(server, hub) {
   const store = new TaskStore(hub);
-  const id = (params) => z12.object({ id: z12.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);
@@ -3417,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;
@@ -3434,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",
@@ -3476,20 +4217,20 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import Fastify from "fastify";
 
 // packages/protocol/index.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 var PROTOCOL_VERSION = 1;
-var HealthSchema = z13.object({ status: z13.literal("ok") });
-var ServerInfoSchema = z13.object({
-  name: z13.literal("teammy"),
-  version: z13.string().min(1),
-  protocolVersion: z13.literal(PROTOCOL_VERSION),
-  capabilities: z13.array(z13.string())
+var 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 = z13.object({
-  error: z13.object({
-    code: z13.string(),
-    message: z13.string(),
-    requestId: z13.string()
+var ErrorResponseSchema = z15.object({
+  error: z15.object({
+    code: z15.string(),
+    message: z15.string(),
+    requestId: z15.string()
   })
 });
 
@@ -3497,43 +4238,43 @@ var ErrorResponseSchema = z13.object({
 import { ZodError } from "zod";
 
 // packages/protocol/devices.ts
-import { z as z14 } from "zod";
-var CredentialSchema = z14.string().regex(/^tmy_[a-f0-9]{64}$/);
-var EnrollmentSchema = z14.object({
-  operationId: z14.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 = z14.object({
-  checkIntervalSeconds: z14.number().min(1).max(86400),
-  fileSettleSeconds: z14.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 = z14.object({
-  checkedAt: z14.string(),
-  published: z14.boolean(),
-  appliedFiles: z14.number().int().nonnegative(),
-  pendingFiles: z14.number().int().nonnegative(),
-  sessionSources: z14.number().int().nonnegative(),
-  errors: z14.array(z14.string().max(1e3)).max(20)
+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 = z14.object({
-  clientVersion: z14.string().max(64),
+var DeviceStatusSchema = z16.object({
+  clientVersion: z16.string().max(64),
   receivedRevision: RevisionSchema.nullable(),
   appliedRevision: RevisionSchema.nullable(),
   effectivePolicy: EffectivePolicySchema,
-  overrides: z14.array(z14.enum(["checkIntervalSeconds", "fileSettleSeconds"])).max(2),
-  configError: z14.string().max(2e3).nullable(),
-  reportError: z14.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 = z14.object({
-  devices: z14.array(
-    z14.object({
+var WebDevicesSchema = z16.object({
+  devices: z16.array(
+    z16.object({
       memberId: NameSchema,
-      bound: z14.boolean(),
-      lastSeenAt: z14.string().nullable(),
+      bound: z16.boolean(),
+      lastSeenAt: z16.string().nullable(),
       status: DeviceStatusSchema.nullable()
     })
   )
@@ -3571,7 +4312,7 @@ function registerControlRoutes(server, store) {
 }
 
 // apps/server/project-routes.ts
-import { z as z15 } 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) => ({
@@ -3618,7 +4359,7 @@ function registerProjectScopeRoutes(server, store) {
   });
   server.patch("/web/members/:id", async (request) => {
     webMutation(request);
-    const { id } = z15.object({ id: NameSchema }).parse(request.params);
+    const { id } = z17.object({ id: NameSchema }).parse(request.params);
     return project.updateMember(
       authorizeWeb(store, request),
       id,
@@ -3627,13 +4368,13 @@ function registerProjectScopeRoutes(server, store) {
   });
   server.post("/web/members/:id/device-reset", async (request) => {
     webMutation(request);
-    const { id } = z15.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 z16 } from "zod";
+import { z as z18 } from "zod";
 
 // apps/server/devices.ts
 var DeviceRepository = class {
@@ -3709,7 +4450,7 @@ function registerSiteRoutes(server, store) {
     "/api/v1/web/session",
     { onRequest: async (request) => webMutation(request) },
     async (request, reply) => {
-      const { id } = z16.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(
@@ -3723,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 } = z16.object({ displayName: z16.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) => {
@@ -3764,71 +4505,71 @@ function registerSiteRoutes(server, store) {
 }
 
 // apps/server/session-routes.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 
 // packages/protocol/sessions.ts
-import { z as z17 } from "zod";
-var AgentSchema = z17.enum(["claude-code", "codex", "cursor", "pi", "dsh"]);
-var SessionSnapshotSchema = z17.object({
-  formatVersion: z17.literal(1),
-  adapterVersion: z17.literal(1),
+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: z17.string().min(1).max(512),
-  cwd: z17.string().min(1).max(4096),
-  messages: z17.array(
-    z17.object({
-      id: z17.string().min(1).max(1024),
-      role: z17.enum(["user", "assistant"]),
-      text: z17.string().min(1).max(2 * 1024 * 1024),
-      source: z17.string().min(1).max(1024)
+  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 = z17.object({
-  operationId: z17.uuid(),
+var SessionCommitSchema = z19.object({
+  operationId: z19.uuid(),
   sessionKey: HashSchema,
   parentRevision: RevisionSchema,
   blob: BlobRefSchema
 }).strict();
-var SessionInfoSchema = z17.object({
+var SessionInfoSchema = z19.object({
   owner: NameSchema,
   sessionKey: HashSchema,
   agent: AgentSchema,
-  nativeId: z17.string(),
-  cwd: z17.string(),
-  title: z17.string(),
+  nativeId: z19.string(),
+  cwd: z19.string(),
+  title: z19.string(),
   revision: RevisionSchema,
-  updatedAt: z17.string(),
-  messageCount: z17.number().int().nonnegative(),
+  updatedAt: z19.string(),
+  messageCount: z19.number().int().nonnegative(),
   blob: BlobRefSchema
 });
-var SessionListSchema = z17.object({
-  sessions: z17.array(SessionInfoSchema),
+var SessionListSchema = z19.object({
+  sessions: z19.array(SessionInfoSchema),
   nextCursor: RevisionSchema.nullable()
 });
-var SessionStatsSchema = z17.object({
-  totalSessions: z17.number().int().nonnegative(),
-  totalMessages: z17.number().int().nonnegative(),
-  memberCount: z17.number().int().nonnegative(),
-  updatedAt: z17.string().nullable()
+var SessionStatsSchema = z19.object({
+  totalSessions: z19.number().int().nonnegative(),
+  totalMessages: z19.number().int().nonnegative(),
+  memberCount: z19.number().int().nonnegative(),
+  updatedAt: z19.string().nullable()
 });
-var SessionScopeSchema = z17.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 = z17.object({
-  matches: z17.array(
-    z17.object({
+var SessionSearchSchema = z19.object({
+  matches: z19.array(
+    z19.object({
       owner: NameSchema,
       sessionKey: HashSchema,
       revision: RevisionSchema,
-      messageId: z17.string(),
-      role: z17.enum(["user", "assistant"]),
-      snippet: z17.string(),
-      title: z17.string()
+      messageId: z19.string(),
+      role: z19.enum(["user", "assistant"]),
+      snippet: z19.string(),
+      title: z19.string()
     })
   ),
   nextCursor: RevisionSchema.nullable()
@@ -3999,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
     );
@@ -4045,9 +4786,9 @@ function registerSessionRoutes(server, store) {
       authorize(request);
     }
   };
-  const pagination = z18.object({
-    after: z18.coerce.number().pipe(RevisionSchema).default(0),
-    limit: z18.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",
@@ -4067,7 +4808,7 @@ function registerSessionRoutes(server, store) {
     const q = pagination.extend({
       owner: NameSchema.optional(),
       sessionKey: HashSchema.optional(),
-      q: z18.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),
@@ -4078,14 +4819,14 @@ function registerSessionRoutes(server, store) {
     );
   });
   server.get("/sessions/:owner/:key", async (request) => {
-    const p = z18.object({ owner: NameSchema, key: HashSchema }).parse(request.params);
-    const q = z18.object({ revision: z18.coerce.number().pipe(RevisionSchema).optional() }).parse(request.query);
+    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 z19 } from "zod";
+import { z as z21 } from "zod";
 function registerFileRoutes(server, store) {
   const files = new FileRepository(store);
   const shared = new SharedFilesRepository(store);
@@ -4116,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 } = z19.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 } = z19.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(
@@ -4139,11 +4880,11 @@ function registerFileRoutes(server, store) {
     return files.commit(request.headers.authorization, device(request), batch, configRevision);
   });
   server.get("/files/:owner/manifest", async (request) => {
-    const { owner } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
-    const query = z19.object({
-      revision: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      after: z19.string().max(1024).default(""),
-      limit: z19.coerce.number().int().min(1).max(500).default(200)
+    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),
@@ -4154,28 +4895,28 @@ function registerFileRoutes(server, store) {
     );
   });
   server.get("/files/:owner/entry", async (request) => {
-    const { owner } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
-    const q = z19.object({
+    const { owner } = z21.object({ owner: FileOwnerSchema }).parse(request.params);
+    const q = z21.object({
       path: FilePathSchema,
-      revision: z19.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 } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
-    const q = z19.object({
-      path: z19.union([z19.literal(""), FilePathSchema]).default(""),
-      revision: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
-      after: z19.string().max(255).default(""),
-      limit: z19.coerce.number().int().min(1).max(200).default(100)
+    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 } = z19.object({ owner: FileOwnerSchema }).parse(request.params);
-    const query = z19.object({
-      after: z19.coerce.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
-      limit: z19.coerce.number().int().min(1).max(100).default(100)
+    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);
   });
@@ -4244,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))
       }));
     };
@@ -4268,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]
@@ -4293,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" }
         }
       });
@@ -4315,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)
@@ -4340,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) {
@@ -4348,7 +5089,7 @@ async function runServerCli(args, version) {
       return 0;
     }
     if (values.version) {
-      process.stdout.write(`${version}
+      process.stdout.write(`${version2}
 `);
       return 0;
     }
@@ -4358,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) });