subagent-extension-for-codex 0.2.0 → 0.3.0

package/dist/bundle/chunks/{chunk-MOWBM7MZ.js → chunk-36LESPFG.js}

@@ -1,38 +1,71 @@
 import { createRequire as __bundleCreateRequire } from "node:module"; const require = __bundleCreateRequire(import.meta.url);
 import {
-  external_exports
-} from "./chunk-5TX3SEV2.js";
+  external_exports,
+  init_define_EXTENSION_BUILD_INFO
+} from "./chunk-FT2Y2DFZ.js";
 
 // src/service/platform/logging/logger.ts
+init_define_EXTENSION_BUILD_INFO();
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 
 // src/service/platform/logging/error-metadata.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/tasks/failure.ts
+init_define_EXTENSION_BUILD_INFO();
+var FAILURE_MESSAGES = /* @__PURE__ */ new Map([
+  ["cost_budget_exhausted", "Cost limit reached."],
+  ["runtime_budget_exhausted", "Runtime limit reached."],
+  ["error_max_turns", "Claude stopped at its turn limit."],
+  [
+    "error_max_structured_output_retries",
+    "Claude couldn't produce the structured reply it was asked for."
+  ],
+  ["error_during_execution", "Claude stopped because of an error."]
+]);
+function isBudgetFailure(code) {
+  return code === "cost_budget_exhausted" || code === "runtime_budget_exhausted";
+}
+function failureMessage({
+  error_code,
+  error
+}) {
+  const summary2 = error_code ? FAILURE_MESSAGES.get(error_code) ?? `Unexpected error: ${error_code}.` : void 0;
+  return [summary2, error].filter(Boolean).join(" ") || void 0;
+}
+
+// src/service/platform/logging/error-metadata.ts
+var PolicyRejectedError = class extends Error {
+  name = "PolicyRejectedError";
+};
 function errorCategory(error) {
   if (!(error instanceof Error)) return "unknown";
-  const message = error.message.toLowerCase();
+  if (error instanceof PolicyRejectedError) return "policy";
+  if ("code" in error && isBudgetFailure(error.code)) return "budget";
+  const message2 = error.message.toLowerCase();
   const status = "status" in error ? error.status : void 0;
   if (status === 401 || status === 403 || /unauthorized|authentication|invalid.*(?:token|api.?key)|missing.*(?:token|api.?key)|not logged in/.test(
-    message
+    message2
   )) {
     return "authentication";
   }
-  if (status === 429 || /rate.?limit|too many requests/.test(message)) {
+  if (status === 429 || /rate.?limit|too many requests/.test(message2)) {
     return "rate_limit";
   }
   if (error.name === "AbortError") return "aborted";
-  if (error.name === "TimeoutError" || /timed? ?out|timeout/.test(message)) {
+  if (error.name === "TimeoutError" || /timed? ?out|timeout/.test(message2)) {
     return "timeout";
   }
-  if (/econnrefused|econnreset|enotfound|fetch failed|network/.test(message)) {
+  if (/econnrefused|econnreset|enotfound|fetch failed|network/.test(message2)) {
     return "connection";
   }
-  if (/budget.*exhausted|maximum.*budget/.test(message)) return "budget";
   return "unknown";
 }
 
 // src/service/platform/logging/jsonl-writer.ts
+init_define_EXTENSION_BUILD_INFO();
 import { appendFile, chmod, rename, stat } from "node:fs/promises";
 var JsonlWriter = class {
   constructor(path, options = {}) {
@@ -225,6 +258,7 @@ function flushLogs() {
 }
 
 // src/service/platform/service/runtime.ts
+init_define_EXTENSION_BUILD_INFO();
 import { readFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -278,26 +312,24 @@ function databasePath(data) {
 }
 
 // src/service/features/workspaces/workspace.ts
-import {
-  access,
-  copyFile,
-  mkdir,
-  mkdtemp,
-  opendir,
-  realpath as realpath2,
-  rm,
-  stat as stat2,
-  utimes
-} from "node:fs/promises";
-import { isAbsolute, join as join2, relative, resolve as resolve2, sep } from "node:path";
+init_define_EXTENSION_BUILD_INFO();
+import { access, mkdir, opendir, realpath as realpath4, stat as stat2 } from "node:fs/promises";
+import { isAbsolute, join as join4, relative, sep as sep2 } from "node:path";
 
 // src/service/features/workspaces/git.ts
+init_define_EXTENSION_BUILD_INFO();
 import { execFile } from "node:child_process";
 import { realpath } from "node:fs/promises";
 import { promisify } from "node:util";
 var exec = promisify(execFile);
+var SAFE_CONFIG = [
+  "-c",
+  "core.hooksPath=/dev/null",
+  "-c",
+  "core.fsmonitor=false"
+];
 async function git(cwd, args, env, input, timeoutMs) {
-  const run = exec("git", ["-C", cwd, ...args], {
+  const run = exec("git", [...SAFE_CONFIG, "-C", cwd, ...args], {
     // Diffs are returned whole, however large.
     maxBuffer: 1024 * 1024 * 1024,
     ...timeoutMs ? { timeout: timeoutMs, killSignal: "SIGKILL" } : {},
@@ -312,6 +344,18 @@ async function git(cwd, args, env, input, timeoutMs) {
   if (stdinError) throw stdinError;
   return stdout;
 }
+async function gitBytes(cwd, args, maxBytes, timeoutMs) {
+  const run = exec("git", [...SAFE_CONFIG, "-C", cwd, ...args], {
+    encoding: "buffer",
+    maxBuffer: maxBytes,
+    timeout: timeoutMs,
+    killSignal: "SIGKILL",
+    // Optional locks would let a read refresh the user's index.
+    env: { ...process.env, LC_ALL: "C", GIT_OPTIONAL_LOCKS: "0" }
+  });
+  run.child.stdin?.end();
+  return (await run).stdout;
+}
 var ROOT_PROBE_TIMEOUT_MS = 5e3;
 async function gitRepositoryRoot(cwd) {
   try {
@@ -362,6 +406,138 @@ async function gitState(cwd) {
   }
 }
 
+// src/service/features/workspaces/workspace-deletion.ts
+init_define_EXTENSION_BUILD_INFO();
+import { createHash } from "node:crypto";
+import { lstat as lstat2, realpath as realpath3 } from "node:fs/promises";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
+
+// src/service/platform/filesystem/path-symlinks.ts
+init_define_EXTENSION_BUILD_INFO();
+import { lstat, realpath as realpath2 } from "node:fs/promises";
+import { join as join2, parse, resolve as resolve2, sep } from "node:path";
+async function pathSymlinks(path) {
+  const absolute = resolve2(path);
+  const root = parse(absolute).root;
+  const links = [];
+  let current = root;
+  for (const part of absolute.slice(root.length).split(sep)) {
+    current = join2(current, part);
+    let entry;
+    try {
+      entry = await lstat(current);
+    } catch (error) {
+      if (error.code === "ENOENT") break;
+      throw error;
+    }
+    if (entry.isSymbolicLink()) {
+      links.push({ path: current, target: await realpath2(current) });
+    }
+  }
+  return links;
+}
+
+// src/service/features/workspaces/workspace-deletion.ts
+async function workspaceDeletion(task, managedRoot) {
+  if (task.workspace_strategy !== "worktree" || !task.workspace && !task.branch) {
+    return { version: "none" };
+  }
+  const root = resolve3(managedRoot);
+  const expectedPath = resolve3(root, task.id);
+  if (!task.workspace || !task.branch || dirname2(expectedPath) !== root || resolve3(task.workspace) !== expectedPath) {
+    const retained = retainedWorktree(task);
+    return { retained, version: JSON.stringify(retained) };
+  }
+  const entry = await worktreeEntry(task.workspace);
+  const repository = await realpath3(task.repository);
+  const repositoryIdentity = await lstat2(repository);
+  const repositoryCommon = await commonDirectory(repository);
+  const commonIdentity = await lstat2(repositoryCommon);
+  let worktree;
+  if (entry) {
+    if (!entry.isDirectory() || task.workspace_removed) {
+      throw new Error(
+        "The task's worktree was replaced or linked. It cannot be deleted safely."
+      );
+    }
+    const actual = await realpath3(task.workspace);
+    if (actual !== join3(await realpath3(root), task.id) || await gitRepositoryRoot(actual) !== actual) {
+      throw new Error("The task's worktree location changed.");
+    }
+    const [branch, common] = await Promise.all([
+      git(actual, ["symbolic-ref", "--quiet", "HEAD"]),
+      commonDirectory(actual)
+    ]);
+    if (branch.trim() !== `refs/heads/${task.branch}` || common !== repositoryCommon) {
+      throw new Error(
+        "The worktree now belongs to a different branch or repository."
+      );
+    }
+    worktree = actual;
+  }
+  const tip = await branchTip(task.repository, task.branch);
+  const worktreeSymlinks = await pathSymlinks(task.workspace);
+  if (tip && task.branch_deleted) {
+    throw new Error(
+      "The task's deleted branch was recreated. It will be kept."
+    );
+  }
+  return {
+    worktree,
+    worktreeSymlinks,
+    branch: tip ? task.branch : void 0,
+    branchTip: tip,
+    version: createHash("sha256").update(
+      JSON.stringify([
+        repository,
+        repositoryIdentity.dev,
+        repositoryIdentity.ino,
+        repositoryCommon,
+        commonIdentity.dev,
+        commonIdentity.ino,
+        expectedPath,
+        entry?.dev,
+        entry?.ino,
+        task.branch,
+        tip,
+        worktreeSymlinks
+      ])
+    ).digest("hex")
+  };
+}
+function retainedWorktree(task) {
+  return {
+    ...!task.workspace_removed ? { worktree: task.workspace } : {},
+    ...!task.branch_deleted ? { branch: task.branch } : {}
+  };
+}
+async function branchTip(repository, branch) {
+  return git(repository, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    `refs/heads/${branch}`
+  ]).then(
+    (value) => value.trim(),
+    (error) => {
+      if (error.code === 1) return void 0;
+      throw error;
+    }
+  );
+}
+async function commonDirectory(path) {
+  const common = (await git(path, ["rev-parse", "--git-common-dir"])).trim();
+  return realpath3(resolve3(path, common));
+}
+async function worktreeEntry(path) {
+  try {
+    return await lstat2(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+
 // src/service/features/workspaces/workspace.ts
 var exists = (path) => access(path).then(
   () => true,
@@ -369,11 +545,11 @@ var exists = (path) => access(path).then(
 );
 var within = (parent, path) => {
   const child = relative(parent, path);
-  return child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
+  return child !== ".." && !child.startsWith(`..${sep2}`) && !isAbsolute(child);
 };
 async function accessibleRealpath(path) {
   try {
-    const actual = await realpath2(path);
+    const actual = await realpath4(path);
     if ((await stat2(actual)).isDirectory()) {
       await (await opendir(actual)).close();
     }
@@ -392,7 +568,7 @@ async function accessibleRealpath(path) {
 var realRoots = (roots) => Promise.all(
   roots.map(async (root) => {
     try {
-      return await realpath2(root);
+      return await realpath4(root);
     } catch (error) {
       const code = error.code;
       if (code === "ENOENT" || code === "ENOTDIR" || code === "EPERM" || code === "EACCES") {
@@ -412,73 +588,6 @@ var Workspaces = class {
   root;
   allowedRoots;
   exactRoots;
-  /**
-   * Records a checkout's files, as `git add -A` would stage them, as a tree
-   * id. A temporary index in the extension's directory keeps the checkout's
-   * own index and files untouched. `.gitignore` applies. New content is
-   * written to the object store as unreferenced blobs, which `git gc` prunes
-   * after its grace period.
-   */
-  async snapshot(cwd) {
-    await mkdir(this.root, { recursive: true, mode: 448 });
-    const dir = await mkdtemp(join2(this.root, ".snapshot-"));
-    const index2 = join2(dir, "index");
-    const run = (args, input) => git(
-      cwd,
-      [
-        "-c",
-        "core.splitIndex=false",
-        "-c",
-        "core.fsmonitor=false",
-        // Otherwise Git would trust every cached entry, as assume-unchanged.
-        "-c",
-        "core.ignoreStat=false",
-        ...args
-      ],
-      { GIT_INDEX_FILE: index2 },
-      input
-    );
-    try {
-      if (await this.copyIndex(cwd, index2)) {
-        try {
-          const assumed = (await run(["ls-files", "-v", "-z"])).split("\0").filter((entry) => /^[a-z] /.test(entry)).map((entry) => entry.slice(2));
-          if (assumed.length) {
-            await run(
-              ["update-index", "--no-assume-unchanged", "-z", "--stdin"],
-              assumed.join("\0")
-            );
-          }
-          await run(["add", "-A"]);
-          return (await run(["write-tree"])).trim();
-        } catch {
-          await rm(index2, { force: true });
-        }
-      }
-      await run(["read-tree", "HEAD"]);
-      await run(["add", "-A"]);
-      return (await run(["write-tree"])).trim();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  }
-  /**
-   * Copies a checkout's index to `target`; false when it has none. Git
-   * replaces the index by renaming a finished file, so a copy is never torn.
-   */
-  async copyIndex(cwd, target) {
-    const path = resolve2(
-      cwd,
-      (await git(cwd, ["rev-parse", "--git-path", "index"])).trim()
-    );
-    try {
-      const { atime, mtime } = await stat2(path);
-      await copyFile(path, target);
-      await utimes(target, atime, mtime);
-      return true;
-    } catch {
-      return false;
-    }
-  }
   async repository(path) {
     const actual = await accessibleRealpath(path);
     const roots = await realRoots(this.allowedRoots);
@@ -517,7 +626,7 @@ var Workspaces = class {
       throw new Error(`Invalid worktree branch name: ${branchPrefix}${t.id}`);
     })).trim();
     await mkdir(this.root, { recursive: true, mode: 448 });
-    const workspace = join2(this.root, t.id);
+    const workspace = join4(this.root, t.id);
     await git(t.repository, [
       "worktree",
       "add",
@@ -540,6 +649,7 @@ var Workspaces = class {
     if (!await exists(t.workspace)) {
       throw new Error("The worktree was already removed.");
     }
+    const resources = await this.managedDeletion(t);
     if (!force) {
       const entries = (await git(t.workspace, ["status", "--porcelain", "-z"])).split("\0"), files = [];
       for (let index2 = 0; index2 < entries.length; index2++) {
@@ -554,13 +664,12 @@ var Workspaces = class {
       "worktree",
       "remove",
       ...force ? ["--force"] : [],
-      t.workspace
+      resources.worktree
     ]);
     return { status: "removed" };
   }
   /**
-   * Deletes a worktree task's branch, once its worktree is removed, and its
-   * snapshot refs, since nothing reads its changes after that.
+   * Deletes a worktree task's branch once its worktree is removed.
    */
   async deleteBranch(t) {
     if (t.workspace_strategy !== "worktree" || !t.workspace || !t.branch) {
@@ -569,23 +678,58 @@ var Workspaces = class {
     if (await exists(t.workspace)) {
       throw new Error("Remove the worktree before deleting its branch.");
     }
+    await this.managedDeletion(t);
     await git(t.repository, ["branch", "-D", "--end-of-options", t.branch]);
   }
   /**
-   * Removes everything a task left in its repository: a worktree task's
-   * worktree, uncommitted changes included, its branch and its snapshot refs.
-   * A current_repo task's checkout is the user's own and stays as it is.
+   * Removes the task's worktree, including uncommitted files, and its branch.
+   * A current_repo task's checkout stays as it is.
    */
-  async discard(t) {
-    if (t.workspace_strategy === "worktree" && t.workspace) {
-      if (await exists(t.workspace)) {
-        await git(t.repository, ["worktree", "remove", "--force", t.workspace]);
+  async discard(t, expectedVersion) {
+    const resources = await this.deletion(t);
+    if (expectedVersion && expectedVersion !== resources.version) {
+      throw new Error(
+        "Worktree or branch changed. Review the deletion details again."
+      );
+    }
+    if (resources.worktree) {
+      await git(t.repository, [
+        "worktree",
+        "remove",
+        "--force",
+        resources.worktree
+      ]);
+    }
+    if (resources.branch) {
+      const tip = await branchTip(t.repository, resources.branch);
+      if (tip && tip !== resources.branchTip) {
+        throw new Error(
+          "The branch changed during cleanup. Review the deletion details again."
+        );
       }
-      if (t.branch && await this.branchExists(t)) {
-        await git(t.repository, ["branch", "-D", "--end-of-options", t.branch]);
+      if (tip) {
+        await git(t.repository, [
+          "branch",
+          "-D",
+          "--end-of-options",
+          resources.branch
+        ]);
       }
     }
   }
+  deletion(t) {
+    return workspaceDeletion(t, this.root);
+  }
+  /** Worktree actions only change a worktree inside the managed folder. */
+  async managedDeletion(t) {
+    const resources = await this.deletion(t);
+    if (resources.retained) {
+      throw new Error(
+        "The recorded worktree is outside this task's managed location."
+      );
+    }
+    return resources;
+  }
   /** Whether a worktree task's worktree is gone, so its next turn recreates it. */
   async worktreeMissing(t) {
     return t.workspace_strategy === "worktree" && !!t.workspace && !await exists(t.workspace);
@@ -627,19 +771,20 @@ var Workspaces = class {
       () => false
     );
   }
-  /** The diff between two trees or commits, as one text. */
-  async diff(cwd, from, to) {
-    return git(cwd, ["diff", "--no-ext-diff", "--no-color", from, to, "--"]);
-  }
 };
 
 // src/service/features/projects/projects.ts
+init_define_EXTENSION_BUILD_INFO();
 import { realpathSync } from "node:fs";
-import { realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { realpath as realpath5, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { basename, dirname as dirname2, isAbsolute as isAbsolute2 } from "node:path";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2 } from "node:path";
+
+// node_modules/drizzle-orm/index.js
+init_define_EXTENSION_BUILD_INFO();
 
 // node_modules/drizzle-orm/entity.js
+init_define_EXTENSION_BUILD_INFO();
 var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
 var kindsByConstructor = /* @__PURE__ */ new WeakMap();
 function collectKinds(ctor) {
@@ -663,14 +808,18 @@ function entityKindsOf(value) {
   return kindsByConstructor.get(ctor) ?? collectKinds(ctor);
 }
 
+// node_modules/drizzle-orm/table.utils.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/errors.js
+init_define_EXTENSION_BUILD_INFO();
 var DrizzleError = class extends Error {
   static [entityKind] = "DrizzleError";
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  constructor({ message, cause }) {
-    super(message);
+  constructor({ message: message2, cause }) {
+    super(message2);
     this.name = "DrizzleError";
     this.cause = cause;
   }
@@ -715,6 +864,7 @@ var Qualifier = /* @__PURE__ */ Symbol.for("drizzle:Qualifier");
 var ExtraConfigBuilder = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder");
 
 // node_modules/drizzle-orm/table.js
+init_define_EXTENSION_BUILD_INFO();
 var IsDrizzleTable = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
 var Table = class {
   static [entityKind] = "Table";
@@ -780,7 +930,11 @@ function getTableName(table) {
   return table[TableName];
 }
 
+// node_modules/drizzle-orm/column.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/column-common.js
+init_define_EXTENSION_BUILD_INFO();
 var OriginalColumn = /* @__PURE__ */ Symbol.for("drizzle:OriginalColumn");
 
 // node_modules/drizzle-orm/column.js
@@ -862,6 +1016,7 @@ function getColumnTable(column) {
 }
 
 // node_modules/drizzle-orm/sql/common-chunks.js
+init_define_EXTENSION_BUILD_INFO();
 var StringChunk = class {
   value;
   static [entityKind] = "StringChunk";
@@ -926,7 +1081,14 @@ var commonStringChunks = {
   "first(": new StringChunk("first(")
 };
 
+// node_modules/drizzle-orm/sql/sql.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/view.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/view-common.js
+init_define_EXTENSION_BUILD_INFO();
 var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
 
 // node_modules/drizzle-orm/view.js
@@ -977,6 +1139,7 @@ function isView(view) {
 }
 
 // node_modules/drizzle-orm/subquery.js
+init_define_EXTENSION_BUILD_INFO();
 var Subquery = class {
   static [entityKind] = "Subquery";
   static [Symbol.hasInstance](value) {
@@ -1001,12 +1164,12 @@ var Subquery = class {
   get [TableColumns]() {
     return this._.selectedFields;
   }
-  constructor(sql2, fields, alias, isWith = false) {
+  constructor(sql2, fields, alias2, isWith = false) {
     this._ = {
       brand: "Subquery",
       sql: sql2,
       selectedFields: fields,
-      alias,
+      alias: alias2,
       isWith
     };
   }
@@ -1016,6 +1179,7 @@ var WithSubquery = class extends Subquery {
 };
 
 // node_modules/drizzle-orm/tracing.js
+init_define_EXTENSION_BUILD_INFO();
 var hasTelemetry = false;
 var tracer = { startActiveSpan(name2, fn) {
   return fn();
@@ -1268,9 +1432,9 @@ var SQL = class SQL2 {
   getSQL() {
     return this;
   }
-  as(alias) {
-    if (alias === void 0) return this;
-    return new SQL2.Aliased(this, alias);
+  as(alias2) {
+    if (alias2 === void 0) return this;
+    return new SQL2.Aliased(this, alias2);
   }
   mapWith(decoder) {
     this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
@@ -1426,7 +1590,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   _sql.raw = raw;
-  function join3(chunks, separator) {
+  function join5(chunks, separator) {
     const { length } = chunks;
     if (separator === void 0 || length === 0) return new SQL(chunks.slice());
     const result = new Array(length * 2 - 1);
@@ -1436,7 +1600,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join3;
+  _sql.join = join5;
   function identifier(value) {
     return new Name(value);
   }
@@ -1646,6 +1810,7 @@ defineQualifier(View.prototype, (view) => qualifiedName(view[ViewBaseConfig].sch
 defineQualifier(Subquery.prototype, (subquery) => new Name(subquery._.alias));
 
 // node_modules/drizzle-orm/utils.js
+init_define_EXTENSION_BUILD_INFO();
 function resolveNullableObjectPaths(columns, joinsNotNullableMap) {
   if (!joinsNotNullableMap) return void 0;
   const tableOf = /* @__PURE__ */ new Map();
@@ -1998,6 +2163,7 @@ var CONSTANTS = {
 };
 
 // node_modules/drizzle-orm/alias.js
+init_define_EXTENSION_BUILD_INFO();
 var ColumnTableAliasProxyHandler = class {
   table;
   ignoreColumnAlias;
@@ -2052,8 +2218,8 @@ var TableAliasProxyHandler = class {
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  constructor(alias, replaceOriginalName, ignoreColumnAlias) {
-    this.alias = alias;
+  constructor(alias2, replaceOriginalName, ignoreColumnAlias) {
+    this.alias = alias2;
     this.replaceOriginalName = replaceOriginalName;
     this.ignoreColumnAlias = ignoreColumnAlias;
   }
@@ -2120,9 +2286,9 @@ var SubquerySelectionAliasProxyHandler = class {
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  constructor(subquery, alias) {
+  constructor(subquery, alias2) {
     this.subquery = subquery;
-    this.alias = alias;
+    this.alias = alias2;
   }
   memo;
   columnHandler;
@@ -2149,8 +2315,8 @@ var SubqueryAliasProxyHandler = class {
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  constructor(alias) {
-    this.alias = alias;
+  constructor(alias2) {
+    this.alias = alias2;
   }
   /** Alias as identifier, replaces `[Qualifier]` of subqueries */
   qualifier;
@@ -2181,8 +2347,8 @@ var ColumnAliasProxyHandler = class {
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  constructor(alias) {
-    this.alias = alias;
+  constructor(alias2) {
+    this.alias = alias2;
   }
   get(target, prop) {
     if (prop === "isAlias") return true;
@@ -2198,8 +2364,8 @@ var RelationTableAliasProxyHandler = class {
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  constructor(alias) {
-    this.alias = alias;
+  constructor(alias2) {
+    this.alias = alias2;
   }
   get(target, prop) {
     if (prop === "sourceTable") return aliasedTable(target.sourceTable, this.alias);
@@ -2214,17 +2380,18 @@ function aliasedTableSQL(table) {
   const name2 = sql.identifier(table[Table.Symbol.OriginalName]);
   return schema ? sql`${sql.identifier(schema)}.${name2} ${table}` : sql`${name2} ${table}`;
 }
-function aliasedColumn(column, alias) {
-  return new Proxy(column, new ColumnAliasProxyHandler(alias));
+function aliasedColumn(column, alias2) {
+  return new Proxy(column, new ColumnAliasProxyHandler(alias2));
 }
-Column.prototype.as = function(alias) {
-  return aliasedColumn(this, alias);
+Column.prototype.as = function(alias2) {
+  return aliasedColumn(this, alias2);
 };
 function getOriginalColumnFromAlias(column) {
   return column[OriginalColumn]();
 }
 
 // node_modules/drizzle-orm/column-builder.js
+init_define_EXTENSION_BUILD_INFO();
 function extractExtendedColumnType(column) {
   const [type, constraint] = column.dataType.split(" ");
   return {
@@ -2343,13 +2510,14 @@ var ColumnBuilder = class {
 };
 
 // node_modules/drizzle-orm/logger.js
+init_define_EXTENSION_BUILD_INFO();
 var ConsoleLogWriter = class {
   static [entityKind] = "ConsoleLogWriter";
   static [Symbol.hasInstance](value) {
     return is(value, this);
   }
-  write(message) {
-    console.log(message);
+  write(message2) {
+    console.log(message2);
   }
 };
 var DefaultLogger = class {
@@ -2383,6 +2551,7 @@ var NoopLogger = class {
 };
 
 // node_modules/drizzle-orm/query-promise.js
+init_define_EXTENSION_BUILD_INFO();
 var QueryPromise = class {
   static [entityKind] = "QueryPromise";
   static [Symbol.hasInstance](value) {
@@ -2407,6 +2576,7 @@ var QueryPromise = class {
 };
 
 // node_modules/drizzle-orm/sql/expressions/conditions.js
+init_define_EXTENSION_BUILD_INFO();
 function bindIfParam(value, column) {
   if (isDriverValueEncoder(column) && !isSQLWrapper(value)) {
     const kind = chunkKindOf(value);
@@ -2533,6 +2703,7 @@ function arrayOverlaps(column, values) {
 }
 
 // node_modules/drizzle-orm/sql/expressions/select.js
+init_define_EXTENSION_BUILD_INFO();
 function asc(column) {
   return sql`${column} asc`;
 }
@@ -2541,6 +2712,7 @@ function desc(column) {
 }
 
 // node_modules/drizzle-orm/relations.js
+init_define_EXTENSION_BUILD_INFO();
 var Relation = class {
   targetTableName;
   static [entityKind] = "RelationV2";
@@ -3626,11 +3798,25 @@ function getTableAsAliasSQL(table, collectTo = []) {
 var EmptyFilter = /* @__PURE__ */ Symbol.for("drizzle:EmptyFilter");
 
 // node_modules/drizzle-orm/sql/functions/aggregate.js
+init_define_EXTENSION_BUILD_INFO();
+function count(expression) {
+  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
+}
 function max(expression) {
   return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
 }
 
+// src/service/features/projects/schema.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/sqlite-core/index.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/sqlite-core/columns/common.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+init_define_EXTENSION_BUILD_INFO();
 var ForeignKeyBuilder = class {
   static [entityKind] = "SQLiteForeignKeyBuilder";
   static [Symbol.hasInstance](value) {
@@ -3754,7 +3940,14 @@ var SQLiteColumn = class extends Column {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/columns/blob.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/sqlite-core/codecs.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/codecs.js
+init_define_EXTENSION_BUILD_INFO();
 var noopCodecs = {};
 var noCodecs = {
   cast: void 0,
@@ -4190,6 +4383,7 @@ function blob(a, b) {
 }
 
 // node_modules/drizzle-orm/sqlite-core/columns/custom.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteCustomColumnBuilder";
   constructor(name2, fieldConfig, customTypeParams) {
@@ -4231,6 +4425,7 @@ function customType(customTypeParams) {
 }
 
 // node_modules/drizzle-orm/sqlite-core/columns/integer.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteBaseIntegerBuilder";
   constructor(name2, dataType, columnType) {
@@ -4321,6 +4516,7 @@ function integer(a, b) {
 }
 
 // node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteNumericBuilder";
   constructor(name2) {
@@ -4384,6 +4580,7 @@ function numeric(a, b) {
 }
 
 // node_modules/drizzle-orm/sqlite-core/columns/real.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteRealBuilder";
   constructor(name2) {
@@ -4407,6 +4604,7 @@ function real(name2) {
 }
 
 // node_modules/drizzle-orm/sqlite-core/columns/text.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteTextBuilder";
   constructor(name2, config) {
@@ -4458,7 +4656,11 @@ function text(a, b = {}) {
   return new SQLiteTextBuilder(name2, config);
 }
 
+// node_modules/drizzle-orm/sqlite-core/table.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/columns/all.js
+init_define_EXTENSION_BUILD_INFO();
 function getSQLiteColumnBuilders() {
   return {
     blob,
@@ -4471,6 +4673,7 @@ function getSQLiteColumnBuilders() {
 }
 
 // node_modules/drizzle-orm/casing.js
+init_define_EXTENSION_BUILD_INFO();
 function toSnakeCase(input) {
   return (input.replace(/['\u2019]/g, "").match(/[\d\p{Ll}\p{Lo}]+|[\p{Lu}]+(?![\p{Ll}\p{Lo}])|[\p{Lu}][\d\p{Ll}\p{Lo}]+/gu) ?? []).map((word) => word.toLowerCase()).join("_");
 }
@@ -4521,6 +4724,7 @@ function sqliteTableWithCasing(casing) {
 var sqliteTable = sqliteTableWithCasing(void 0);
 
 // node_modules/drizzle-orm/sqlite-core/indexes.js
+init_define_EXTENSION_BUILD_INFO();
 var IndexBuilderOn = class {
   name;
   unique;
@@ -4586,6 +4790,7 @@ function uniqueIndex(name2) {
 }
 
 // node_modules/drizzle-orm/sqlite-core/primary-keys.js
+init_define_EXTENSION_BUILD_INFO();
 function primaryKey(...config) {
   if (config[0].columns) return new PrimaryKeyBuilder(config[0].columns, config[0].name);
   return new PrimaryKeyBuilder(config);
@@ -4628,6 +4833,12 @@ var PrimaryKey = class {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/dialect.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/sqlite-core/columns/index.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/dialect.js
 var escapeSQLiteName = memoizeEscape((name2) => `"${name2.replace(/"/g, '""')}"`);
 var rqbChunks = {
@@ -4851,7 +5062,7 @@ var SQLiteDialect = class {
     const fieldsList = fieldsFlat ?? orderSelectedFields(fields, void 0, this.codecs);
     const tableKind = chunkKindOf(table);
     const ownTableName = isChunk(table, tableKind, chunkKinds.subquery) ? table._.alias : isChunk(table, tableKind, chunkKinds.view) ? table[ViewBaseConfig].name : isChunk(table, tableKind, chunkKinds.sql) ? void 0 : getTableName(table);
-    for (const f of fieldsList) if (is(f.field, Column) && getTableName(f.field.table) !== ownTableName && !((table2) => joins?.some(({ alias }) => alias === (table2[Table.Symbol.IsAlias] ? getTableName(table2) : table2[Table.Symbol.BaseName])))(f.field.table)) {
+    for (const f of fieldsList) if (is(f.field, Column) && getTableName(f.field.table) !== ownTableName && !((table2) => joins?.some(({ alias: alias2 }) => alias2 === (table2[Table.Symbol.IsAlias] ? getTableName(table2) : table2[Table.Symbol.BaseName])))(f.field.table)) {
       const tableName = getTableName(f.field.table);
       throw new Error(`Your "${f.path.join("->")}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`);
     }
@@ -5051,7 +5262,7 @@ var SQLiteDialect = class {
     }
     if (!selected && !withKeys.length) throw new DrizzleError({ message: `No fields selected for table "${tableConfig.name}"${currentPath ? ` ("${currentPath}")` : ""}` });
     for (const k of withKeys) {
-      const join3 = withParam[k];
+      const join5 = withParam[k];
       const relation = tableConfig.relations[k];
       if (!relation) throw new DrizzleError({ message: `Unknown relation "${tableConfig.name}" -> "${k}"` });
       const isSingle2 = relation.relationType === "one";
@@ -5067,7 +5278,7 @@ var SQLiteDialect = class {
         table: targetTable,
         mode: isSingle2 ? "first" : "many",
         schema,
-        queryConfig: join3,
+        queryConfig: join5,
         tableConfig: schema[relation.targetTableName],
         relationWhere: filter,
         nested: true,
@@ -5101,7 +5312,7 @@ var SQLiteDialect = class {
         key: k,
         selection: innerSelection,
         isArray: !isSingle2,
-        isOptional: (relation.optional ?? false) || join3 !== true && !!join3.where
+        isOptional: (relation.optional ?? false) || join5 !== true && !!join5.where
       });
     }
     collectTo.push(commonStringChunks[" from "]);
@@ -5120,12 +5331,17 @@ var SQLiteDialect = class {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/query-builders/select.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/view-base.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteViewBase = class extends View {
   static [entityKind] = "SQLiteViewBase";
 };
 
 // node_modules/drizzle-orm/selection-proxy.js
+init_define_EXTENSION_BUILD_INFO();
 var SelectionProxyHandler = class SelectionProxyHandler2 {
   static [entityKind] = "SelectionProxyHandler";
   static [Symbol.hasInstance](value) {
@@ -5174,6 +5390,7 @@ var SelectionProxyHandler = class SelectionProxyHandler2 {
 };
 
 // node_modules/drizzle-orm/used-tables.js
+init_define_EXTENSION_BUILD_INFO();
 function usedTablesOf(source) {
   if (is(source, Table)) return [source[CacheKey]];
   const out = /* @__PURE__ */ new Set();
@@ -5182,6 +5399,7 @@ function usedTablesOf(source) {
 }
 
 // node_modules/drizzle-orm/query-builders/query-builder.js
+init_define_EXTENSION_BUILD_INFO();
 var TypedQueryBuilder = class {
   static [entityKind] = "TypedQueryBuilder";
   static [Symbol.hasInstance](value) {
@@ -5274,7 +5492,7 @@ var SQLiteSelectBase = class extends TypedQueryBuilder {
     return (table, on) => {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins?.some((join3) => join3.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins?.some((join5) => join5.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       this.config.fieldsFlat = void 0;
       this.config.mapper = void 0;
       if (!this.isPartialSelect) {
@@ -5731,9 +5949,9 @@ var SQLiteSelectBase = class extends TypedQueryBuilder {
   toSQL(withCastCodecs = true) {
     return this.dialect.sqlToQuery(this.getSQL(withCastCodecs));
   }
-  as(alias) {
-    return new Proxy(new Subquery(this.getSQL(), this.config.fields, alias), new SelectionProxyHandler({
-      alias,
+  as(alias2) {
+    return new Proxy(new Subquery(this.getSQL(), this.config.fields, alias2), new SelectionProxyHandler({
+      alias: alias2,
       sqlAliasedBehavior: "alias",
       sqlBehavior: "error"
     }));
@@ -5773,6 +5991,7 @@ var intersect = createSetOperator("intersect", false);
 var except = createSetOperator("except", false);
 
 // node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
+init_define_EXTENSION_BUILD_INFO();
 var QueryBuilder = class {
   static [entityKind] = "SQLiteQueryBuilder";
   static [Symbol.hasInstance](value) {
@@ -5784,13 +6003,13 @@ var QueryBuilder = class {
     this.dialect = is(dialect, SQLiteDialect) ? dialect : void 0;
     this.dialectConfig = is(dialect, SQLiteDialect) ? void 0 : dialect;
   }
-  $with = (alias, selection) => {
+  $with = (alias2, selection) => {
     const queryBuilder = this;
     const as = (qb) => {
       if (typeof qb === "function") qb = qb(queryBuilder);
       const sql2 = qb.getSQL();
-      return new Proxy(new WithSubquery(sql2, selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({
-        alias,
+      return new Proxy(new WithSubquery(sql2, selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias2, true), new SelectionProxyHandler({
+        alias: alias2,
         sqlAliasedBehavior: "alias",
         sqlBehavior: "error"
       }));
@@ -5843,6 +6062,7 @@ var QueryBuilder = class {
 };
 
 // node_modules/drizzle-orm/sqlite-core/session.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLitePreparedQuery = class {
   query;
   mode;
@@ -5875,7 +6095,17 @@ var SQLiteSession = class {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/alias.js
+init_define_EXTENSION_BUILD_INFO();
+function alias(table, alias2) {
+  return new Proxy(table, new TableAliasProxyHandler(alias2, false));
+}
+
+// node_modules/drizzle-orm/sqlite-core/async/count.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/query-builders/count.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteCountBuilder = class SQLiteCountBuilder2 extends SQL {
   countConfig;
   static [entityKind] = "SQLiteCountBuilder";
@@ -5932,7 +6162,11 @@ var SQLiteSyncCountBuilder = class extends SQLiteAsyncCountBuilder {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/async/query.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/query-builders/query.js
+init_define_EXTENSION_BUILD_INFO();
 var RelationalQueryBuilder = class {
   mode;
   schema;
@@ -6054,7 +6288,14 @@ var SQLiteSyncRelationalQuery = class extends SQLiteAsyncRelationalQuery {
 };
 applyMixins(SQLiteAsyncRelationalQuery, [QueryPromise]);
 
+// node_modules/drizzle-orm/sqlite-core/async/db.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/sqlite-core/async/delete.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteDeleteBase = class {
   table;
   session;
@@ -6174,7 +6415,11 @@ var SQLiteAsyncDeleteBase = class extends SQLiteDeleteBase {
 };
 applyMixins(SQLiteAsyncDeleteBase, [QueryPromise]);
 
+// node_modules/drizzle-orm/sqlite-core/async/insert.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteInsertBuilder = class {
   table;
   session;
@@ -6321,7 +6566,11 @@ var SQLiteAsyncInsertBase = class extends SQLiteInsertBase {
 };
 applyMixins(SQLiteAsyncInsertBase, [QueryPromise]);
 
+// node_modules/drizzle-orm/sqlite-core/async/raw.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/query-builders/raw.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteRaw = class {
   prepared;
   sql;
@@ -6360,6 +6609,7 @@ var SQLiteAsyncRaw = class extends SQLiteRaw {
 applyMixins(SQLiteAsyncRaw, [QueryPromise]);
 
 // node_modules/drizzle-orm/sqlite-core/async/select.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteAsyncSelectBase = class extends SQLiteSelectBase {
   static [entityKind] = "SQLiteAsyncSelect";
   /** @internal */
@@ -6394,7 +6644,11 @@ var SQLiteAsyncSelectBase = class extends SQLiteSelectBase {
 };
 applyMixins(SQLiteAsyncSelectBase, [QueryPromise]);
 
+// node_modules/drizzle-orm/sqlite-core/async/update.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/query-builders/update.js
+init_define_EXTENSION_BUILD_INFO();
 var SQLiteUpdateBuilder = class {
   table;
   session;
@@ -6442,7 +6696,7 @@ var SQLiteUpdateBase = class {
   createJoin(joinType) {
     return ((table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join3) => join3.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins.some((join5) => join5.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (typeof on === "function") {
         const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
         on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -6570,6 +6824,9 @@ var SQLiteAsyncUpdateBase = class extends SQLiteUpdateBase {
 };
 applyMixins(SQLiteAsyncUpdateBase, [QueryPromise]);
 
+// node_modules/drizzle-orm/sqlite-core/query-builders/index.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/sqlite-core/async/db.js
 var SQLiteAsyncDatabase = class {
   resultKind;
@@ -6628,13 +6885,13 @@ var SQLiteAsyncDatabase = class {
   * const result = await db.with(sq).select({ name: sq.name }).from(sq);
   * ```
   */
-  $with = (alias, selection) => {
+  $with = (alias2, selection) => {
     const self = this;
     const as = (qb) => {
       if (typeof qb === "function") qb = qb(new QueryBuilder(self.dialect));
       const sql2 = qb.getSQL();
-      return new Proxy(new WithSubquery(sql2, selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({
-        alias,
+      return new Proxy(new WithSubquery(sql2, selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias2, true), new SelectionProxyHandler({
+        alias: alias2,
         sqlAliasedBehavior: "alias",
         sqlBehavior: "error"
       }));
@@ -6818,7 +7075,11 @@ var SQLiteAsyncDatabase = class {
   }
 };
 
+// node_modules/drizzle-orm/sqlite-core/async/session.js
+init_define_EXTENSION_BUILD_INFO();
+
 // node_modules/drizzle-orm/cache/core/cache.js
+init_define_EXTENSION_BUILD_INFO();
 var Cache = class {
   static [entityKind] = "Cache";
   static [Symbol.hasInstance](value) {
@@ -7078,8 +7339,8 @@ function serializeParam(value) {
 }
 async function hashQuery(sql2, params) {
   const dataToHash = `${sql2}-${serializeParam(params)}`;
-  const createHash = getNodeCreateHash();
-  if (createHash) return createHash("sha256").update(dataToHash).digest("hex");
+  const createHash2 = getNodeCreateHash();
+  if (createHash2) return createHash2("sha256").update(dataToHash).digest("hex");
   encoder ??= new TextEncoder();
   const data = encoder.encode(dataToHash);
   const subtle = typeof globalThis.crypto !== "undefined" ? globalThis.crypto.subtle : void 0;
@@ -7087,6 +7348,7 @@ async function hashQuery(sql2, params) {
 }
 
 // node_modules/drizzle-orm/migrator.utils.js
+init_define_EXTENSION_BUILD_INFO();
 function formatToMillis(dateStr) {
   const year = parseInt(dateStr.slice(0, 4), 10);
   const month = parseInt(dateStr.slice(4, 6), 10) - 1;
@@ -7285,10 +7547,10 @@ var projectRoots = sqliteTable("project_roots", {
 });
 
 // src/service/features/projects/projects.ts
-var realpathOrSame = (path) => realpath3(path).catch(() => path);
+var realpathOrSame = (path) => realpath5(path).catch(() => path);
 async function assertPlainFolderAllowed(folder) {
   const home = await realpathOrSame(homedir3());
-  if (dirname2(folder) === folder || within(folder, home)) {
+  if (dirname3(folder) === folder || within(folder, home)) {
     throw new Error(
       `${folder} is too broad to add. Choose a more specific folder.`
     );
@@ -7367,6 +7629,19 @@ var Projects = class {
       )
     );
   }
+  /**
+   * The list now, with each repository's Git state from `known`, an earlier
+   * `listWithGit` result. A project added since has no Git state yet.
+   */
+  withKnownGit(known) {
+    const states = new Map(
+      known.map((project) => [project.repository, project.git])
+    );
+    return this.list().map((project) => {
+      const git2 = project.kind === "repository" ? states.get(project.repository) : void 0;
+      return git2 ? { ...project, git: git2 } : project;
+    });
+  }
   async recentGitState(repository) {
     const recent = this.gitStates.get(repository);
     if (recent && Date.now() - recent.readAt < GIT_STATE_REUSE_MS) {
@@ -7391,11 +7666,12 @@ var Projects = class {
    * removed. Another spelling of a saved root, such as a symlink, removes the
    * root it resolves to, so a removal never leaves the approval in place.
    * Removing a root that is already gone succeeds.
+   * Exact removal keeps a changed symlink from redirecting a reviewed saved key.
    */
-  remove(repository) {
+  remove(repository, exact = false) {
     this.gitStates.clear();
     const deleted = (path) => this.database.orm.delete(projectRoots).where(eq(projectRoots.path, path)).run().changes;
-    if (!deleted(repository)) {
+    if (!deleted(repository) && !exact) {
       try {
         deleted(realpathSync(repository));
       } catch {
@@ -7405,30 +7681,1108 @@ var Projects = class {
     this.onChange();
     return { repository };
   }
-  async resolve(path) {
-    this.refresh();
-    if (!isAbsolute2(path)) throw new Error("Use an absolute repository path");
-    const actual = await realpath3(path);
-    const approved = () => this.list().some((root) => {
-      if (root.kind === "repository") return root.repository === actual;
-      return within(root.repository, actual);
-    });
-    if (!approved()) {
+  /** Rejects a folder no stored root approves. Reads the stored roots, which the CLI can change. */
+  assertApproved(actual) {
+    const approved = this.list().some(
+      (root) => root.kind === "repository" ? root.repository === actual : within(root.repository, actual)
+    );
+    if (!approved) {
       throw new Error(
         "Repository outside allowed roots (register this repository or approve its parent)"
       );
     }
+  }
+  async resolve(path) {
+    this.refresh();
+    if (!isAbsolute2(path)) throw new Error("Use an absolute repository path");
+    const actual = await realpath5(path);
+    this.assertApproved(actual);
     const repository = await this.workspaces.repository(actual);
-    if (!approved()) {
-      throw new Error(
-        "Repository outside allowed roots (register this repository or approve its parent)"
+    this.assertApproved(actual);
+    return repository;
+  }
+};
+
+// node_modules/zod/index.js
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/time.ts
+init_define_EXTENSION_BUILD_INFO();
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+
+// src/service/features/tasks/storage/schema.ts
+init_define_EXTENSION_BUILD_INFO();
+var bodyField = (field) => text().generatedAlwaysAs(sql.raw(`json_extract(body, '$.${field}')`), {
+  mode: "virtual"
+});
+var tasks = sqliteTable(
+  "tasks",
+  {
+    id: text().primaryKey(),
+    owner: text().notNull(),
+    body: text().notNull(),
+    status: bodyField("status"),
+    created_at: bodyField("created_at"),
+    conversation_id: bodyField("conversation_id")
+  },
+  (t) => [
+    index("tasks_owner_created").on(t.owner, t.created_at),
+    index("tasks_owner_conversation").on(
+      t.owner,
+      t.conversation_id,
+      t.created_at
+    ),
+    index("tasks_status").on(t.status)
+  ]
+);
+var events = sqliteTable(
+  "events",
+  {
+    id: integer().primaryKey({ autoIncrement: true }),
+    task_id: text().notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    type: text().notNull(),
+    timestamp: text().notNull(),
+    data: text().notNull(),
+    response_ref: text(),
+    original_response: text(),
+    /** Whether Chat shows the event, as `isChatEvent` decides. */
+    chat: integer({ mode: "boolean" }).notNull().default(false)
+  },
+  (t) => [
+    index("events_task").on(t.task_id, t.id),
+    index("events_task_type").on(t.task_id, t.type, t.id),
+    index("events_task_chat").on(t.task_id, t.chat, t.id),
+    uniqueIndex("events_response").on(t.response_ref)
+  ]
+);
+var taskRead = sqliteTable("task_read", {
+  task_id: text().primaryKey().references(() => tasks.id, { onDelete: "cascade" }),
+  through: integer().notNull(),
+  unread: integer({ mode: "boolean" }).notNull()
+});
+var parentSeen = sqliteTable("task_parent_seen", {
+  event_id: integer().primaryKey().references(() => events.id, { onDelete: "cascade" })
+});
+var taskArchive = sqliteTable("task_archive", {
+  task_id: text().primaryKey().references(() => tasks.id, { onDelete: "cascade" }),
+  archived_at: text().notNull()
+});
+var taskMessages = sqliteTable(
+  "task_messages",
+  {
+    task_id: text().notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    seq: integer().notNull(),
+    message_id: text().notNull(),
+    message: text().notNull(),
+    sender: text({ enum: ["user", "parent"] }).notNull()
+  },
+  (t) => [primaryKey({ columns: [t.task_id, t.seq] })]
+);
+var sendReceipts = sqliteTable(
+  "task_send_receipts",
+  {
+    owner: text().notNull(),
+    task_id: text().notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    sender: text().notNull(),
+    request_id: text().notNull(),
+    fingerprint: text().notNull(),
+    message_id: text().notNull(),
+    state: text().notNull()
+  },
+  (t) => [
+    primaryKey({ columns: [t.owner, t.task_id, t.sender, t.request_id] })
+  ]
+);
+
+// src/service/features/tasks/storage/event-records.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/events/decode.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/providers/activity/presentation-contract.generated.ts
+init_define_EXTENSION_BUILD_INFO();
+var activityRateLimitWindowSchema = external_exports.object({
+  id: external_exports.string(),
+  label: external_exports.string(),
+  utilization: external_exports.number(),
+  resetsAt: external_exports.number().optional()
+});
+var activityStreamAppendSchema = external_exports.union([
+  external_exports.object({
+    field: external_exports.literal("text"),
+    type: external_exports.literal("text"),
+    text: external_exports.string()
+  }),
+  external_exports.object({
+    field: external_exports.literal("thinking"),
+    type: external_exports.literal("thinking"),
+    text: external_exports.string()
+  }),
+  external_exports.object({
+    field: external_exports.literal("partial_json"),
+    type: external_exports.literal("input_json_delta"),
+    text: external_exports.string()
+  })
+]);
+var activityContentSchema = external_exports.lazy(
+  () => external_exports.union([external_exports.string(), activityContentBlockSchema])
+);
+var activityContentBlockSchema = external_exports.lazy(
+  () => external_exports.union([
+    external_exports.object({
+      type: external_exports.literal("text"),
+      text: external_exports.string()
+    }),
+    external_exports.object({
+      type: external_exports.literal("thinking"),
+      thinking: external_exports.string()
+    }),
+    external_exports.object({
+      type: external_exports.literal("input_json_delta"),
+      partial_json: external_exports.string()
+    }),
+    external_exports.object({
+      type: external_exports.literal("tool_use"),
+      id: external_exports.string(),
+      name: external_exports.string(),
+      input: external_exports.record(external_exports.string(), external_exports.unknown())
+    }),
+    external_exports.object({
+      type: external_exports.literal("tool_result"),
+      tool_use_id: external_exports.string(),
+      content: external_exports.union([external_exports.string(), external_exports.array(activityContentSchema)]),
+      is_error: external_exports.boolean().optional()
+    }),
+    external_exports.object({
+      type: external_exports.literal("opaque"),
+      data: external_exports.record(external_exports.string(), external_exports.unknown())
+    })
+  ])
+);
+var activityPresentationSchema = external_exports.lazy(
+  () => external_exports.object({
+    kind: external_exports.string().optional(),
+    title: external_exports.string().optional(),
+    summary: external_exports.string().optional(),
+    summaryIsResponse: external_exports.boolean().optional(),
+    statusTitle: external_exports.string().optional(),
+    liveStatus: external_exports.boolean().optional(),
+    quiet: external_exports.boolean().optional(),
+    thinking: external_exports.boolean().optional(),
+    failed: external_exports.boolean().optional(),
+    messageId: external_exports.string().optional(),
+    hasThinking: external_exports.boolean().optional(),
+    rateLimitWindows: external_exports.array(activityRateLimitWindowSchema).optional(),
+    statusState: external_exports.union([
+      external_exports.literal("running"),
+      external_exports.literal("completed"),
+      external_exports.literal("failed"),
+      external_exports.literal("info")
+    ]).optional(),
+    operation: external_exports.object({
+      id: external_exports.string(),
+      kind: external_exports.union([external_exports.literal("tool"), external_exports.literal("operation")]),
+      title: external_exports.string(),
+      summary: external_exports.string().optional(),
+      started: external_exports.boolean().optional(),
+      completed: external_exports.boolean().optional(),
+      stopped: external_exports.boolean().optional()
+    }).optional(),
+    stream: external_exports.object({
+      id: external_exports.string(),
+      messageId: external_exports.string().optional(),
+      started: external_exports.boolean().optional(),
+      completed: external_exports.boolean().optional(),
+      title: external_exports.string().optional(),
+      content: external_exports.union([activityContentSchema, external_exports.array(activityContentSchema)]).optional(),
+      details: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+      update: external_exports.object({
+        index: external_exports.number(),
+        block: activityContentBlockSchema.optional(),
+        append: activityStreamAppendSchema.optional()
+      }).optional()
+    }).optional(),
+    body: external_exports.object({
+      role: external_exports.union([external_exports.literal("assistant"), external_exports.literal("user")]).optional(),
+      content: external_exports.array(activityContentSchema).optional(),
+      error: external_exports.union([external_exports.boolean(), external_exports.string()]).optional()
+    }).optional()
+  })
+);
+
+// src/shared/events/event-contract.generated.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/tasks/event-contract.generated.ts
+init_define_EXTENSION_BUILD_INFO();
+var emptyEventPayloadSchema = external_exports.record(external_exports.string(), external_exports.never());
+var taskStartedPayloadSchema = external_exports.object({
+  turn: external_exports.number()
+});
+var taskTurnEndedPayloadSchema = external_exports.object({
+  turn: external_exports.number(),
+  outcome: external_exports.union([
+    external_exports.literal("completed"),
+    external_exports.literal("failed"),
+    external_exports.literal("interrupted")
+  ]),
+  runtime_ms: external_exports.number(),
+  cost_usd: external_exports.number()
+});
+var taskInstructionPayloadSchema = external_exports.object({
+  message_id: external_exports.string(),
+  message: external_exports.string(),
+  from: external_exports.union([external_exports.literal("user"), external_exports.literal("parent")]),
+  delivery: external_exports.union([
+    external_exports.literal("steer"),
+    external_exports.literal("queue"),
+    external_exports.literal("interrupt")
+  ])
+});
+var taskQueueChangedPayloadSchema = external_exports.object({
+  queue: external_exports.array(
+    external_exports.object({
+      message_id: external_exports.string(),
+      message: external_exports.string(),
+      from: external_exports.union([external_exports.literal("user"), external_exports.literal("parent")])
+    })
+  ),
+  paused: external_exports.boolean()
+});
+var taskSessionStartedPayloadSchema = external_exports.object({
+  reason: external_exports.union([external_exports.literal("no_session"), external_exports.literal("session_unavailable")])
+});
+var taskWorktreeRecreatedPayloadSchema = external_exports.object({
+  from: external_exports.union([external_exports.literal("branch"), external_exports.literal("base")])
+});
+var taskInterruptedPayloadSchema = external_exports.object({
+  reason: external_exports.literal("service_restart").optional(),
+  error: external_exports.string().optional()
+});
+var taskFailedPayloadSchema = external_exports.object({
+  error: external_exports.string().optional(),
+  error_code: external_exports.string().optional()
+});
+var taskWorktreeRemovedPayloadSchema = external_exports.object({
+  path: external_exports.string().optional(),
+  branch: external_exports.string().optional(),
+  forced: external_exports.boolean().optional()
+});
+var taskBranchDeletedPayloadSchema = external_exports.object({
+  branch: external_exports.string().optional()
+});
+var taskControlRequestedPayloadSchema = external_exports.object({
+  status: external_exports.literal("interrupted")
+});
+var taskSteerTakenPayloadSchema = external_exports.object({
+  message_id: external_exports.string()
+});
+var taskMessageRemovedPayloadSchema = external_exports.object({
+  message_id: external_exports.string()
+});
+var taskStatusPayloadSchema = external_exports.object({
+  error: external_exports.string().optional()
+});
+var taskEventPayloadMapSchema = external_exports.object({
+  "task.started": taskStartedPayloadSchema,
+  "task.turn_ended": taskTurnEndedPayloadSchema,
+  "task.instruction": taskInstructionPayloadSchema,
+  "task.queue_changed": taskQueueChangedPayloadSchema,
+  "task.session_started": taskSessionStartedPayloadSchema,
+  "task.worktree_recreated": taskWorktreeRecreatedPayloadSchema,
+  "task.interrupted": taskInterruptedPayloadSchema,
+  "task.failed": taskFailedPayloadSchema,
+  "task.worktree_removed": taskWorktreeRemovedPayloadSchema,
+  "task.branch_deleted": taskBranchDeletedPayloadSchema,
+  "task.control_requested": taskControlRequestedPayloadSchema,
+  "task.steer_taken": taskSteerTakenPayloadSchema,
+  "task.message_removed": taskMessageRemovedPayloadSchema,
+  "task.queued": emptyEventPayloadSchema,
+  "task.completed": taskStatusPayloadSchema
+});
+
+// src/shared/events/event-contract.generated.ts
+var eventEnvelopeSchema = external_exports.object({
+  id: external_exports.number(),
+  task_id: external_exports.string(),
+  type: external_exports.string(),
+  timestamp: external_exports.string(),
+  data: external_exports.record(external_exports.string(), external_exports.unknown())
+});
+var toolStartedPayloadSchema = external_exports.object({
+  id: external_exports.string().optional(),
+  name: external_exports.string().optional(),
+  input: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+});
+var toolCompletedPayloadSchema = external_exports.object({
+  id: external_exports.string().optional(),
+  name: external_exports.string().optional(),
+  input: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+  error: external_exports.boolean().optional(),
+  content: external_exports.union([external_exports.string(), external_exports.array(activityContentSchema)]).optional()
+});
+var agentMessageFieldsSchema = external_exports.object({
+  message_id: external_exports.string().optional(),
+  parent_tool_use_id: external_exports.string().optional().nullable()
+});
+var agentMessagePayloadSchema = agentMessageFieldsSchema.extend({
+  role: external_exports.literal("assistant"),
+  text: external_exports.string(),
+  content: external_exports.union([activityContentSchema, external_exports.array(activityContentSchema)]).optional()
+});
+var agentContentPayloadSchema = agentMessageFieldsSchema.extend({
+  role: external_exports.union([external_exports.literal("assistant"), external_exports.literal("user")]),
+  content: external_exports.union([activityContentSchema, external_exports.array(activityContentSchema)]),
+  text: external_exports.string().optional()
+});
+var agentReplyPayloadSchema = external_exports.object({
+  text: external_exports.string(),
+  turn: external_exports.number()
+});
+var agentStartedPayloadSchema = external_exports.object({
+  model: external_exports.string().optional(),
+  tools: external_exports.array(external_exports.string()).optional()
+});
+var agentLimitedPayloadSchema = external_exports.object({
+  setting: external_exports.union([external_exports.literal("permission_mode"), external_exports.literal("model")]),
+  requested: external_exports.string(),
+  effective: external_exports.string(),
+  reason: external_exports.string()
+});
+var agentCompletedPayloadSchema = external_exports.object({
+  cost_usd: external_exports.number().optional(),
+  total_cost_usd: external_exports.number().optional(),
+  duration_ms: external_exports.number().optional(),
+  result: external_exports.string().optional(),
+  subtype: external_exports.string().optional(),
+  is_error: external_exports.boolean().optional(),
+  errors: external_exports.array(external_exports.string()).optional(),
+  usage: external_exports.object({
+    input_tokens: external_exports.number().optional(),
+    output_tokens: external_exports.number().optional(),
+    cache_creation_input_tokens: external_exports.number().optional(),
+    cache_read_input_tokens: external_exports.number().optional()
+  }).optional()
+});
+var agentInputRequiredPayloadSchema = external_exports.object({
+  request: external_exports.object({
+    id: external_exports.string(),
+    tool: external_exports.string(),
+    kind: external_exports.union([external_exports.literal("question"), external_exports.literal("permission")]),
+    input: external_exports.record(external_exports.string(), external_exports.unknown())
+  }).optional()
+});
+var agentInputSubmittedPayloadSchema = external_exports.object({
+  approved: external_exports.boolean()
+});
+var agentPermissionDecidedPayloadSchema = external_exports.object({
+  tool: external_exports.string(),
+  input: external_exports.record(external_exports.string(), external_exports.unknown()),
+  approval_mode: external_exports.union([
+    external_exports.literal("ask_user"),
+    external_exports.literal("parent_agent"),
+    external_exports.literal("auto_approve"),
+    external_exports.literal("deny")
+  ]),
+  approved: external_exports.boolean(),
+  authority: external_exports.literal("policy")
+});
+var agentInputDecisionPayloadSchema = external_exports.object({
+  request_id: external_exports.string(),
+  approved: external_exports.boolean(),
+  authority: external_exports.union([external_exports.literal("user"), external_exports.literal("parent")])
+});
+var eventPayloadMapSchema = taskEventPayloadMapSchema.extend({
+  "tool.started": toolStartedPayloadSchema,
+  "tool.completed": toolCompletedPayloadSchema,
+  "agent.message": agentMessagePayloadSchema,
+  "agent.content": agentContentPayloadSchema,
+  "agent.reply": agentReplyPayloadSchema,
+  "agent.started": agentStartedPayloadSchema,
+  "agent.limited": agentLimitedPayloadSchema,
+  "agent.completed": agentCompletedPayloadSchema,
+  "agent.input_required": agentInputRequiredPayloadSchema,
+  "agent.input_submitted": agentInputSubmittedPayloadSchema,
+  "agent.permission_decided": agentPermissionDecidedPayloadSchema,
+  "agent.input_decision": agentInputDecisionPayloadSchema
+});
+
+// src/shared/events/decode.ts
+var knownEventTypes = new Set(Object.keys(eventPayloadMapSchema.shape));
+function decodeEventView(type, data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("Event data must be an object");
+  }
+  if (!knownEventTypes.has(type)) {
+    return {
+      kind: "opaque",
+      type,
+      data
+    };
+  }
+  const eventType = type;
+  const schema = eventPayloadMapSchema.shape[eventType];
+  const parsed = schema.safeParse(data);
+  if (!parsed.success) {
+    return { kind: "opaque", type, data };
+  }
+  return {
+    kind: "known",
+    type: eventType,
+    data: parsed.data
+  };
+}
+function decodedEvent(event) {
+  const parsedPresentation = activityPresentationSchema.safeParse(
+    event.data.activity
+  );
+  return {
+    id: event.id,
+    task_id: event.task_id,
+    type: event.type,
+    timestamp: event.timestamp,
+    data: event.data,
+    view: decodeEventView(event.type, event.data),
+    ...parsedPresentation.success ? { presentation: parsedPresentation.data } : {}
+  };
+}
+
+// src/shared/tasks/conversation/chat.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/events/payload.ts
+init_define_EXTENSION_BUILD_INFO();
+function eventPayload(event, type) {
+  const view = event.view;
+  if (view.kind !== "known" || view.type !== type) return void 0;
+  return view.data;
+}
+
+// src/shared/tasks/conversation/messages.ts
+init_define_EXTENSION_BUILD_INFO();
+var MESSAGE_EVENTS = [
+  "task.started",
+  "task.instruction",
+  "agent.message",
+  "agent.reply"
+];
+function workerMessageId(e) {
+  return eventPayload(e, "agent.message")?.message_id ?? `evt_${e.id}`;
+}
+function workerText(e) {
+  const message2 = eventPayload(e, "agent.message");
+  if (!message2 || message2.parent_tool_use_id) return void 0;
+  return message2.text.trim() ? message2.text : void 0;
+}
+var same = (message2, reply) => {
+  const a = message2.trim(), b = reply.trim();
+  return a === b || a.endsWith(b);
+};
+function queueState(id, pending, queued) {
+  if (pending.has(id)) return { state: "pending_steer" };
+  if (queued.has(id)) return { state: "queued" };
+  return {};
+}
+function conversation(task, events2) {
+  const pending = new Set(task.pending_steers.map((m) => m.id));
+  const queued = new Set(task.queue.map((m) => m.id));
+  let turn = 1;
+  const messages = [
+    {
+      id: "request",
+      event_id: 0,
+      timestamp: task.created_at,
+      turn,
+      from: task.created_by,
+      kind: "request",
+      text: task.description
+    }
+  ];
+  for (const e of [...events2].sort((a, b) => a.id - b.id)) {
+    const started = eventPayload(e, "task.started");
+    if (started) turn = started.turn;
+    const instruction = eventPayload(e, "task.instruction");
+    if (instruction) {
+      const id = instruction.message_id;
+      messages.push({
+        id,
+        event_id: e.id,
+        timestamp: e.timestamp,
+        turn,
+        from: instruction.from,
+        kind: "message",
+        text: instruction.message,
+        delivery: instruction.delivery,
+        ...queueState(id, pending, queued)
+      });
+    }
+    if (eventPayload(e, "agent.message")) {
+      const text2 = workerText(e);
+      if (text2 === void 0) continue;
+      const id = workerMessageId(e);
+      const previous = messages.at(-1);
+      if (previous?.id === id && previous.from === "worker") {
+        previous.text = `${previous.text}
+
+${text2}`;
+        previous.event_id = e.id;
+        continue;
+      }
+      messages.push({
+        id,
+        event_id: e.id,
+        timestamp: e.timestamp,
+        turn,
+        from: "worker",
+        kind: "message",
+        text: text2
+      });
+    }
+    const reply = eventPayload(e, "agent.reply");
+    if (reply) {
+      const text2 = reply.text;
+      const replyTurn = reply.turn;
+      const last = messages.findLast(
+        (m) => m.from === "worker" && m.turn === replyTurn
       );
+      if (last && last.kind === "message" && same(last.text, text2)) {
+        last.kind = "reply";
+        last.event_id = e.id;
+        continue;
+      }
+      messages.push({
+        id: `reply_${e.id}`,
+        event_id: e.id,
+        timestamp: e.timestamp,
+        turn: replyTurn,
+        from: "worker",
+        kind: "reply",
+        text: text2
+      });
     }
-    return repository;
   }
+  return messages.sort((a, b) => a.event_id - b.event_id);
+}
+
+// src/shared/tasks/conversation/chat.ts
+var CHAT_EVENTS = [
+  "task.started",
+  "task.instruction",
+  "agent.message",
+  "agent.reply",
+  "task.turn_ended",
+  "task.failed",
+  "task.session_started",
+  "task.worktree_recreated",
+  "agent.limited",
+  "agent.input_required"
+];
+var isChatEvent = (type, data) => CHAT_EVENTS.includes(type) || type === "claude.activity" && (data.subtype === "compact_boundary" || data.compact_result === "failed");
+var isCompaction = (e) => {
+  return e.presentation?.kind === "compact_boundary";
+};
+function note(e) {
+  const base = {
+    kind: "note",
+    id: `evt_${e.id}`,
+    event_id: e.id,
+    timestamp: e.timestamp
+  };
+  const session = eventPayload(e, "task.session_started");
+  if (session) {
+    return {
+      ...base,
+      note: "session",
+      text: session.reason === "no_session" ? "New session: the task had none to continue" : "New session: the earlier one couldn't continue"
+    };
+  }
+  const worktree = eventPayload(e, "task.worktree_recreated");
+  if (worktree) {
+    return {
+      ...base,
+      note: "worktree",
+      text: worktree.from === "base" ? "Worktree recreated from the base commit, since its branch was deleted" : "Worktree recreated from its branch"
+    };
+  }
+  const limited = eventPayload(e, "agent.limited");
+  if (limited) return { ...base, note: "limited", text: limited.reason };
+  const failed = eventPayload(e, "task.failed");
+  if (failed) {
+    return {
+      ...base,
+      note: "failure",
+      text: `Task failed: ${failureMessage(failed) ?? "Unknown error"}`
+    };
+  }
+  if (isCompaction(e)) {
+    return { ...base, note: "compaction", text: "Context compacted" };
+  }
+  if (e.type === "claude.activity" && e.presentation?.statusTitle === "Context compaction failed") {
+    return { ...base, note: "failure", text: "Context compaction failed" };
+  }
+  return void 0;
+}
+function chatItems(task, events2) {
+  const sorted = [...events2].sort((a, b) => a.id - b.id);
+  const messages = conversation(task, sorted);
+  const items = [];
+  let next = 0;
+  let failedOutcome;
+  const flush = (until) => {
+    for (let message2 = messages[next]; message2 && message2.event_id <= until; message2 = messages[++next]) {
+      items.push({
+        kind: "message",
+        id: message2.id,
+        event_id: message2.event_id,
+        message: message2
+      });
+    }
+  };
+  for (const e of sorted) {
+    const turnEnded = eventPayload(e, "task.turn_ended");
+    if (turnEnded) {
+      flush(e.id);
+      const outcome = {
+        kind: "outcome",
+        id: `turn_${turnEnded.turn}_${e.id}`,
+        event_id: e.id,
+        timestamp: e.timestamp,
+        turn: turnEnded.turn,
+        outcome: turnEnded.outcome,
+        runtime_ms: turnEnded.runtime_ms,
+        cost_usd: turnEnded.cost_usd
+      };
+      items.push(outcome);
+      failedOutcome = outcome.outcome === "failed" ? outcome : void 0;
+    } else if (eventPayload(e, "task.failed")) {
+      if (failedOutcome) {
+        failedOutcome.error = failureMessage(eventPayload(e, "task.failed"));
+        failedOutcome.event_id = e.id;
+      } else {
+        flush(e.id);
+        items.push(note(e));
+      }
+      failedOutcome = void 0;
+    } else {
+      if (eventPayload(e, "task.instruction") !== void 0 || eventPayload(e, "task.queued") !== void 0 || eventPayload(e, "task.started") !== void 0) {
+        failedOutcome = void 0;
+      }
+      const marker = note(e);
+      if (marker) {
+        flush(e.id);
+        items.push(marker);
+      }
+    }
+  }
+  flush(Infinity);
+  return items;
+}
+
+// src/service/features/tasks/storage/event-records.ts
+var eventColumns = {
+  id: events.id,
+  task_id: events.task_id,
+  type: events.type,
+  timestamp: events.timestamp,
+  data: events.data
+};
+function readOriginalResponse(database, id, responseRef) {
+  const row = database.orm.select({ body: events.original_response }).from(events).where(and(eq(events.response_ref, responseRef), eq(events.task_id, id))).get();
+  return row?.body ? JSON.parse(row.body) : void 0;
+}
+function splitOriginalResponse(payload) {
+  const response = typeof payload.response_ref === "string" && payload.raw_response !== void 0 ? {
+    id: payload.response_ref,
+    body: JSON.stringify(payload.raw_response)
+  } : void 0;
+  const { raw_response: _original, ...data } = payload;
+  return { data, response, serialized: JSON.stringify(data) };
+}
+function insertEvent(database, metrics, taskId, type, payload) {
+  const timestamp = now();
+  const stored = splitOriginalResponse(payload);
+  const { id } = database.orm.insert(events).values({
+    task_id: taskId,
+    type,
+    timestamp,
+    data: stored.serialized,
+    response_ref: stored.response?.id,
+    original_response: stored.response?.body,
+    chat: isChatEvent(type, stored.data)
+  }).returning({ id: events.id }).get();
+  metrics.committed(database, taskId, stored.serialized, stored.response?.body);
+  return decodedEvent({
+    id,
+    task_id: taskId,
+    type,
+    timestamp,
+    data: stored.data
+  });
+}
+
+// src/service/features/tasks/storage/stored.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/zod/index.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/zod/column.js
+init_define_EXTENSION_BUILD_INFO();
+var literalSchema = external_exports.union([
+  external_exports.string(),
+  external_exports.number(),
+  external_exports.boolean(),
+  external_exports.null()
+]);
+var jsonSchema = external_exports.union([
+  literalSchema,
+  external_exports.record(external_exports.string(), external_exports.any()),
+  external_exports.array(external_exports.any())
+]);
+var bufferSchema = external_exports.custom((v) => v instanceof Buffer);
+function columnToSchema(column, factory) {
+  const z$1 = factory?.zodInstance ?? external_exports;
+  const coerce = factory?.coerce ?? {};
+  let schema;
+  const dimensions = column.dimensions;
+  if (typeof dimensions === "number" && dimensions > 0) return pgArrayColumnToSchema(column, dimensions, z$1, coerce);
+  const { type, constraint } = extractExtendedColumnType(column);
+  switch (type) {
+    case "array":
+      schema = arrayColumnToSchema(column, constraint, z$1);
+      break;
+    case "object":
+      schema = objectColumnToSchema(column, constraint, z$1, coerce);
+      break;
+    case "number":
+      schema = numberColumnToSchema(column, constraint, z$1, coerce);
+      break;
+    case "bigint":
+      schema = bigintColumnToSchema(column, constraint, z$1, coerce);
+      break;
+    case "boolean":
+      schema = coerce === true || coerce.boolean ? z$1.coerce.boolean() : z$1.boolean();
+      break;
+    case "string":
+      schema = stringColumnToSchema(column, constraint, z$1, coerce);
+      break;
+    case "custom":
+      schema = z$1.any();
+      break;
+    default:
+      schema = z$1.any();
+  }
+  return schema;
+}
+function numberColumnToSchema(column, constraint, z, coerce) {
+  let min2;
+  let max2;
+  let integer2 = false;
+  switch (constraint) {
+    case "int8":
+      min2 = CONSTANTS.INT8_MIN;
+      max2 = CONSTANTS.INT8_MAX;
+      integer2 = true;
+      break;
+    case "uint8":
+      min2 = 0;
+      max2 = CONSTANTS.INT8_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int16":
+      min2 = CONSTANTS.INT16_MIN;
+      max2 = CONSTANTS.INT16_MAX;
+      integer2 = true;
+      break;
+    case "uint16":
+      min2 = 0;
+      max2 = CONSTANTS.INT16_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int24":
+      min2 = CONSTANTS.INT24_MIN;
+      max2 = CONSTANTS.INT24_MAX;
+      integer2 = true;
+      break;
+    case "uint24":
+      min2 = 0;
+      max2 = CONSTANTS.INT24_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int32":
+      min2 = CONSTANTS.INT32_MIN;
+      max2 = CONSTANTS.INT32_MAX;
+      integer2 = true;
+      break;
+    case "uint32":
+      min2 = 0;
+      max2 = CONSTANTS.INT32_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int53":
+      min2 = Number.MIN_SAFE_INTEGER;
+      max2 = Number.MAX_SAFE_INTEGER;
+      integer2 = true;
+      break;
+    case "uint53":
+      min2 = 0;
+      max2 = Number.MAX_SAFE_INTEGER;
+      integer2 = true;
+      break;
+    case "float":
+      min2 = CONSTANTS.INT24_MIN;
+      max2 = CONSTANTS.INT24_MAX;
+      break;
+    case "ufloat":
+      min2 = 0;
+      max2 = CONSTANTS.INT24_UNSIGNED_MAX;
+      break;
+    case "double":
+      min2 = CONSTANTS.INT48_MIN;
+      max2 = CONSTANTS.INT48_MAX;
+      break;
+    case "udouble":
+      min2 = 0;
+      max2 = CONSTANTS.INT48_UNSIGNED_MAX;
+      break;
+    case "year":
+      min2 = 1901;
+      max2 = 2155;
+      integer2 = true;
+      break;
+    case "unsigned":
+      min2 = 0;
+      max2 = Number.MAX_SAFE_INTEGER;
+      break;
+    default:
+      min2 = Number.MIN_SAFE_INTEGER;
+      max2 = Number.MAX_SAFE_INTEGER;
+  }
+  let schema = coerce === true || coerce?.number ? integer2 ? z.coerce.number().int() : z.coerce.number() : integer2 ? z.int() : z.number();
+  schema = schema.gte(min2).lte(max2);
+  return schema;
+}
+var bigintStringModeSchema = external_exports.string().regex(/^-?\d+$/).transform(BigInt).pipe(external_exports.bigint().gte(CONSTANTS.INT64_MIN).lte(CONSTANTS.INT64_MAX)).transform(String);
+var unsignedBigintStringModeSchema = external_exports.string().regex(/^\d+$/).transform(BigInt).pipe(external_exports.bigint().gte(0n).lte(CONSTANTS.INT64_MAX)).transform(String);
+function bigintColumnToSchema(column, constraint, z, coerce) {
+  let min2;
+  let max2;
+  switch (constraint) {
+    case "int64":
+      min2 = CONSTANTS.INT64_MIN;
+      max2 = CONSTANTS.INT64_MAX;
+      break;
+    case "uint64":
+      min2 = 0n;
+      max2 = CONSTANTS.INT64_UNSIGNED_MAX;
+  }
+  let schema = coerce === true || coerce?.bigint ? z.coerce.bigint() : z.bigint();
+  if (min2 !== void 0) schema = schema.min(min2);
+  if (max2 !== void 0) schema = schema.max(max2);
+  return schema;
+}
+function pgArrayColumnToSchema(column, dimensions, z, coerce) {
+  const [baseType, baseConstraint] = column.dataType.split(" ");
+  let baseSchema;
+  switch (baseType) {
+    case "number":
+      baseSchema = numberColumnToSchema(column, baseConstraint, z, coerce);
+      break;
+    case "bigint":
+      baseSchema = bigintColumnToSchema(column, baseConstraint, z, coerce);
+      break;
+    case "boolean":
+      baseSchema = coerce === true || coerce?.boolean ? z.coerce.boolean() : z.boolean();
+      break;
+    case "string":
+      baseSchema = stringColumnToSchema(column, baseConstraint, z, coerce);
+      break;
+    case "object":
+      baseSchema = objectColumnToSchema(column, baseConstraint, z, coerce);
+      break;
+    case "array":
+      baseSchema = arrayColumnToSchema(column, baseConstraint, z);
+      break;
+    default:
+      baseSchema = z.any();
+  }
+  let schema = z.array(baseSchema);
+  for (let i = 1; i < dimensions; i++) schema = z.array(schema);
+  return schema;
+}
+function arrayColumnToSchema(column, constraint, z) {
+  switch (constraint) {
+    case "geometry":
+    case "point":
+      return z.tuple([z.number(), z.number()]);
+    case "line":
+      return z.tuple([
+        z.number(),
+        z.number(),
+        z.number()
+      ]);
+    case "vector":
+    case "halfvector": {
+      const length = column.length;
+      return length ? z.array(z.number()).length(length) : z.array(z.number());
+    }
+    case "int64vector": {
+      const length = column.length;
+      return length ? z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX)).length(length) : z.array(z.bigint().min(CONSTANTS.INT64_MIN).max(CONSTANTS.INT64_MAX));
+    }
+    default:
+      return z.array(z.any());
+  }
+}
+function objectColumnToSchema(column, constraint, z, coerce) {
+  switch (constraint) {
+    case "buffer":
+      return bufferSchema;
+    case "date":
+      return coerce === true || coerce?.date ? z.coerce.date() : z.date();
+    case "geometry":
+    case "point":
+      return z.object({
+        x: z.number(),
+        y: z.number()
+      });
+    case "json":
+      return jsonSchema;
+    case "line":
+      return z.object({
+        a: z.number(),
+        b: z.number(),
+        c: z.number()
+      });
+    default:
+      return z.looseObject({});
+  }
+}
+function stringColumnToSchema(column, constraint, z, coerce) {
+  const { name: columnName, length, isLengthExact } = column;
+  let regex;
+  if (constraint === "binary") regex = /^[01]*$/;
+  if (constraint === "uuid") return z.uuid();
+  if (constraint === "enum") {
+    const enumValues = column.enumValues;
+    if (!enumValues) throw new Error(`Column "${getTableName(getColumnTable(column))}"."${columnName}" is of 'enum' type, but lacks enum values`);
+    return z.enum(enumValues);
+  }
+  if (constraint === "int64") return bigintStringModeSchema;
+  if (constraint === "uint64") return unsignedBigintStringModeSchema;
+  let schema = coerce === true || coerce?.string ? z.coerce.string() : z.string();
+  schema = regex ? schema.regex(regex) : schema;
+  return length && isLengthExact ? schema.length(length) : length ? schema.max(length) : schema;
+}
+
+// node_modules/drizzle-orm/zod/schema.js
+init_define_EXTENSION_BUILD_INFO();
+function handleColumns(columns, refinements, conditions, factory) {
+  const columnSchemas = {};
+  for (const [key, selected] of Object.entries(columns)) {
+    if (!is(selected, Column) && !is(selected, SQL) && !is(selected, SQL.Aliased) && typeof selected === "object") {
+      columnSchemas[key] = handleColumns(isTable(selected) || isView(selected) ? getColumns(selected) : selected, refinements[key] ?? {}, conditions, factory);
+      continue;
+    }
+    const refinement = refinements[key];
+    if (refinement !== void 0 && typeof refinement !== "function") {
+      columnSchemas[key] = refinement;
+      continue;
+    }
+    const column = is(selected, Column) ? selected : void 0;
+    const schema = column ? columnToSchema(column, factory) : external_exports.any();
+    const refined = typeof refinement === "function" ? refinement(schema) : schema;
+    if (conditions.never(column)) continue;
+    else columnSchemas[key] = refined;
+    if (column) {
+      if (conditions.nullable(column)) columnSchemas[key] = columnSchemas[key].nullable();
+      if (conditions.optional(column)) columnSchemas[key] = columnSchemas[key].optional();
+    }
+  }
+  return external_exports.object(columnSchemas);
+}
+function handleEnum(enum_, factory) {
+  return (factory?.zodInstance ?? external_exports).enum(enum_.enumValues);
+}
+var selectConditions = {
+  never: () => false,
+  optional: () => false,
+  nullable: (column) => !column.notNull
+};
+var createSelectSchema = (entity, refine) => {
+  if (isWithEnum(entity)) return handleEnum(entity);
+  return handleColumns(getColumns(entity), refine ?? {}, selectConditions);
 };
 
+// src/shared/tasks/model.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/attachments/attachment-error.ts
+init_define_EXTENSION_BUILD_INFO();
+var AttachmentError = class extends Error {
+  name = "AttachmentError";
+};
+
+// src/shared/attachments/model.ts
+init_define_EXTENSION_BUILD_INFO();
+var ATTACHMENT_LIMITS = {
+  count: 20,
+  summaryChars: 200,
+  titleChars: 60,
+  inlineChars: 8e3,
+  referenceBytes: 2 * 1024 * 1024,
+  taskBytes: 10 * 1024 * 1024,
+  paths: 50,
+  pathChars: 1024
+};
+var attachmentFormats = ["diff", "code", "markdown", "text"];
+var attachmentSources = ["inline", "diff", "file"];
+var summary = external_exports.string().trim().min(1).max(ATTACHMENT_LIMITS.summaryChars, "Keep the summary to one sentence.").describe(
+  "One sentence on what the attachment is and why the worker needs it."
+);
+var title = external_exports.string().trim().min(1).max(ATTACHMENT_LIMITS.titleChars).optional().describe("A short label. Set it only when the generated one isn't clear.");
+var projectPath = external_exports.string().min(1).max(ATTACHMENT_LIMITS.pathChars);
+var inlineAttachment = external_exports.strictObject({
+  source: external_exports.literal("inline"),
+  summary,
+  title,
+  format: external_exports.enum(attachmentFormats),
+  text: external_exports.string().min(1).max(
+    ATTACHMENT_LIMITS.inlineChars,
+    'Inline text is limited to 8,000 characters. Attach project content by reference with { source: "file", path } or { source: "diff" }, or save the content to a project file and attach that.'
+  ).describe("Short content that exists only in the chat."),
+  path: projectPath.optional().describe("A label that picks highlighting. The service never reads it.")
+});
+var diffAttachment = external_exports.strictObject({
+  source: external_exports.literal("diff"),
+  summary,
+  title,
+  paths: external_exports.array(projectPath).min(1).max(ATTACHMENT_LIMITS.paths).optional().describe("Limit the diff to these project paths.")
+});
+var fileAttachment = external_exports.strictObject({
+  source: external_exports.literal("file"),
+  path: projectPath.describe("A file in the project folder."),
+  summary,
+  title,
+  start_line: external_exports.number().int().positive().optional(),
+  end_line: external_exports.number().int().positive().optional()
+}).refine(
+  (a) => a.start_line === void 0 || a.end_line === void 0 || a.start_line <= a.end_line,
+  { message: "start_line must not be after end_line", path: ["end_line"] }
+);
+var attachmentInputSchema = external_exports.discriminatedUnion("source", [
+  inlineAttachment,
+  diffAttachment,
+  fileAttachment
+]);
+var attachmentsSchema = external_exports.array(attachmentInputSchema).max(ATTACHMENT_LIMITS.count).optional().describe(
+  'Material the worker needs, which it reads from files. Prefer references for anything in the project, regardless of size: { source: "file", path, start_line?, end_line? }, or { source: "diff", paths? } for the uncommitted changes against HEAD including untracked files. Inline { source: "inline", format, text } is only for short content that exists only in this chat, such as decisions or notes. Every item needs a one-sentence summary.'
+);
+var ATTACHMENT_PAGE_BYTES = 512 * 1024;
+
 // src/shared/tasks/reasoning.ts
+init_define_EXTENSION_BUILD_INFO();
 var reasoningLevels = [
   "none",
   "minimal",
@@ -7466,7 +8820,7 @@ var providerOptionsSchema = external_exports.record(
 );
 var startSchema = external_exports.object({
   provider_options: providerOptionsSchema.optional().describe(
-    "Provider-owned options, isolated under the selected provider ID and validated by that provider."
+    "Provider-owned options, isolated under the selected provider ID and validated by that provider. Claude takes permission_mode, approval_decider and sandbox. sandbox true runs Bash in Claude Code's sandbox. Only the user can set it false when settings turn it on."
   ),
   approval_mode: approvalModeSchema.optional().describe(
     "Whole-execution approval policy for providers that support it. Model calls cannot increase approval authority."
@@ -7475,22 +8829,19 @@ var startSchema = external_exports.object({
     "Worker provider id from list_workers; only enabled providers can run."
   ),
   worker_profile: external_exports.enum(roles).default("reviewer").describe(
-    "reviewer, researcher and security_reviewer are read-only in either workspace. Other profiles can edit their workspace."
+    "reviewer, researcher and security_reviewer start in plan mode, which asks before editing, unless provider_options.claude.permission_mode names another mode. Other profiles can edit their workspace."
   ),
   model: modelNameSchema.optional().describe(
     "Model ID or provider alias. Blank inherits configured defaults."
   ),
-  reasoning_effort: reasoningSchema.optional().describe("Reasoning effort; default inherits configured defaults."),
+  reasoning_effort: reasoningSchema.optional().describe("Reasoning. The default inherits configured defaults."),
   description: external_exports.string().min(1).max(2e4).describe("The full task instructions and details for the worker."),
   repository: external_exports.string().min(1).describe(
     "Explicit absolute project folder from list_projects or get_current_project. Starting a task for the chat's unregistered Git root registers it when the user allows."
   ),
   revision: external_exports.string().default("HEAD"),
   conversation_id: external_exports.string().optional(),
-  depends_on: external_exports.array(external_exports.string()).max(50).default([]).describe("Task IDs that must finish before this task starts."),
-  context: external_exports.array(external_exports.string().max(2e4)).max(20).default([]).describe(
-    "Bounded excerpts the worker needs, such as a diff or file sections. Conversation history is not copied."
-  ),
+  attachments: attachmentsSchema,
   workspace_strategy: external_exports.enum(["worktree", "current_repo"]).default("current_repo").describe(
     "current_repo uses the approved project folder directly, including uncommitted files, and requires revision HEAD. worktree creates an isolated checkout at revision without uncommitted files and needs a Git repository with at least one commit. Use it for isolated or parallel edits."
   ),
@@ -7504,6 +8855,13 @@ var startSchema = external_exports.object({
     max_tokens: external_exports.number().int().positive().optional()
   }).default({ max_runtime_minutes: null, max_cost_usd: null })
 });
+function assertNoLegacyContext(input) {
+  if (input && typeof input === "object" && Object.hasOwn(input, "context")) {
+    throw new AttachmentError(
+      "context was replaced by attachments. Pass project content by reference and chat-only notes inline."
+    );
+  }
+}
 var statuses = [
   "queued",
   "starting",
@@ -7522,7 +8880,186 @@ function pendingInputKind(input) {
   return input.kind;
 }
 
+// src/service/platform/database/decode.ts
+init_define_EXTENSION_BUILD_INFO();
+function checkStored(schema, value, record) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    throw new Error(
+      `Stored ${record} is malformed: ${external_exports.prettifyError(result.error)}`
+    );
+  }
+  return result.data;
+}
+function decodeStored(schema, json, record) {
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch (error) {
+    throw new Error(`Stored ${record} is not valid JSON`, { cause: error });
+  }
+  return checkStored(schema, value, record);
+}
+
+// src/service/features/tasks/storage/stored.ts
+var eventRowSchema = createSelectSchema(events).omit({
+  response_ref: true,
+  original_response: true,
+  chat: true
+});
+var eventDataSchema = external_exports.record(external_exports.string(), external_exports.unknown());
+var sender = external_exports.enum(["user", "parent"]);
+var message = external_exports.looseObject({
+  id: external_exports.string(),
+  message: external_exports.string(),
+  from: sender
+});
+var storedTaskSchema = external_exports.looseObject({
+  id: external_exports.string().min(1),
+  owner: external_exports.string().min(1),
+  title: external_exports.string(),
+  description: external_exports.string(),
+  provider: external_exports.string(),
+  provider_options: providerOptionsSchema.optional(),
+  approval_mode: approvalModeSchema.optional(),
+  worker_profile: external_exports.enum(roles),
+  repository: external_exports.string(),
+  revision: external_exports.string(),
+  workspace_strategy: external_exports.enum(["worktree", "current_repo"]),
+  no_git: external_exports.literal(true).optional(),
+  workspace_fallback: external_exports.enum(["no_git", "no_commits"]).optional(),
+  context: external_exports.array(external_exports.string()).optional(),
+  budget: external_exports.looseObject({
+    max_runtime_minutes: external_exports.number().nullable(),
+    max_cost_usd: external_exports.number().nullable(),
+    max_tokens: external_exports.number().optional()
+  }),
+  budget_raised_for_turn: external_exports.looseObject({
+    turn: external_exports.number().int().nonnegative(),
+    cost: external_exports.literal(true).optional(),
+    runtime: external_exports.literal(true).optional()
+  }).optional(),
+  created_by: sender,
+  status: external_exports.enum(statuses),
+  error_code: external_exports.string().optional(),
+  created_at: external_exports.string(),
+  updated_at: external_exports.string(),
+  pending_input: external_exports.looseObject({
+    id: external_exports.string(),
+    tool: external_exports.string(),
+    kind: external_exports.enum(["question", "permission"]),
+    input: external_exports.record(external_exports.string(), external_exports.unknown())
+  }).optional(),
+  profile_instructions: external_exports.string().optional(),
+  instructions_sent: external_exports.number().int().nonnegative(),
+  pending_steers: external_exports.array(message),
+  queue: external_exports.array(
+    message.extend({
+      delivery: external_exports.enum(deliveries),
+      recorded: external_exports.boolean().optional()
+    })
+  ),
+  turn: external_exports.number().int().nonnegative(),
+  runtime_ms: external_exports.number().nonnegative()
+});
+function decodeTask(id, body) {
+  return decodeStored(storedTaskSchema, body, `task ${id}`);
+}
+function decodeEvent(row) {
+  const stored = checkStored(eventRowSchema, row, `event ${row.id}`);
+  const event = {
+    ...stored,
+    data: decodeStored(eventDataSchema, stored.data, `event ${stored.id}`)
+  };
+  return decodedEvent(event);
+}
+
+// src/service/features/tasks/storage/task-rows.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// src/shared/tasks/conversation/unread.ts
+init_define_EXTENSION_BUILD_INFO();
+var READ_EVENTS = [
+  "agent.message",
+  "agent.reply",
+  "task.turn_ended",
+  "task.failed",
+  "agent.input_required"
+];
+var isUnread = (latest, mark) => Boolean(mark?.unread) || latest > (mark?.through ?? 0);
+
+// src/service/features/tasks/storage/task-rows.ts
+var archivedFilters = ["exclude", "include", "only"];
+var archived = sql`exists (select 1 from ${taskArchive} where ${taskArchive.task_id} = ${tasks.id})`;
+var readEventTypes = sql.join(
+  READ_EVENTS.map((type) => sql`${type}`),
+  sql`, `
+);
+var readCompleted = sql`${tasks.status} = 'completed' and coalesce((select max(read_event.id) from ${events} read_event where read_event.task_id = ${tasks.id} and read_event.type in (${readEventTypes})), 0) <= coalesce((select iif(${taskRead.unread}, -1, ${taskRead.through}) from ${taskRead} where ${taskRead.task_id} = ${tasks.id}), 0)`;
+function taskFilters(owner, filters) {
+  const matching = and(
+    filters.conversation === void 0 ? void 0 : eq(tasks.conversation_id, filters.conversation),
+    filters.repository === void 0 ? void 0 : eq(
+      sql`json_extract(${tasks.body}, '$.repository')`,
+      filters.repository
+    ),
+    filters.archived === "only" ? archived : void 0,
+    filters.archived === "exclude" ? not(archived) : void 0,
+    filters.ids === void 0 ? void 0 : inArray(tasks.id, [...filters.ids])
+  );
+  return and(
+    eq(tasks.owner, owner),
+    matching && filters.include?.length ? or(inArray(tasks.id, filters.include), matching) : matching
+  );
+}
+function readCompletedFlags(orm, where, order) {
+  return orm.select({
+    id: tasks.id,
+    repository: sql`json_extract(${tasks.body}, '$.repository')`,
+    readCompleted: sql`${readCompleted}`.mapWith(Boolean)
+  }).from(tasks).where(where).orderBy(order).all();
+}
+function taskExists(orm, id) {
+  return !!orm.select({ id: tasks.id }).from(tasks).where(eq(tasks.id, id)).get();
+}
+function readTasks(orm, where, order, limit) {
+  const query = orm.select({ id: tasks.id, body: tasks.body }).from(tasks).where(where).orderBy(...order ? [order] : []);
+  return (limit === void 0 ? query : query.limit(limit)).all().map((row) => decodeTask(row.id, row.body));
+}
+function newestEvent(orm, types) {
+  const latest = alias(events, "latest");
+  const id = orm.select({ id: max(latest.id) }).from(latest).where(and(eq(latest.task_id, tasks.id), inArray(latest.type, types)));
+  return sql`(${id})`;
+}
+function readStates(orm, where) {
+  const rows = orm.select({
+    id: tasks.id,
+    through: taskRead.through,
+    unread: taskRead.unread,
+    latest: newestEvent(orm, READ_EVENTS)
+  }).from(tasks).leftJoin(taskRead, eq(taskRead.task_id, tasks.id)).where(where).all();
+  return new Map(
+    rows.map((row) => {
+      const mark = row.through === null ? void 0 : { through: row.through, unread: Boolean(row.unread) };
+      return [
+        row.id,
+        {
+          unread: isUnread(row.latest ?? 0, mark),
+          through: mark?.through ?? 0
+        }
+      ];
+    })
+  );
+}
+function latestEvents(orm, where, type) {
+  const rows = orm.select(eventColumns).from(tasks).innerJoin(events, eq(events.id, newestEvent(orm, [type]))).where(where).all();
+  return new Map(rows.map((row) => [row.task_id, decodeEvent(row)]));
+}
+
 export {
+  isBudgetFailure,
+  failureMessage,
+  PolicyRejectedError,
   errorCategory,
   JsonlWriter,
   configureLogging,
@@ -7533,26 +9070,15 @@ export {
   logError,
   flushLogs,
   entityKind,
-  is,
   DrizzleQueryError,
-  isTable,
-  getTableName,
-  Column,
-  getColumnTable,
-  isView,
-  SQL,
   sql,
   jitCompatCheck,
-  getColumns,
-  isWithEnum,
-  CONSTANTS,
-  extractExtendedColumnType,
   DefaultLogger,
   NoopLogger,
   eq,
   and,
-  or,
   gt,
+  gte,
   lt,
   lte,
   inArray,
@@ -7560,6 +9086,7 @@ export {
   notExists,
   asc,
   desc,
+  count,
   max,
   defaultPort,
   installRoot,
@@ -7568,11 +9095,12 @@ export {
   packageVersion,
   dataDirectory,
   databasePath,
-  git,
+  gitBytes,
   gitRepositoryRoot,
   gitWorkTreeRoot,
   WORKTREE_NEEDS_GIT,
   gitState,
+  pathSymlinks,
   within,
   Workspaces,
   castToText,
@@ -7584,8 +9112,6 @@ export {
   integer,
   text,
   sqliteTable,
-  index,
-  uniqueIndex,
   primaryKey,
   SQLiteDialect,
   SQLiteAsyncDatabase,
@@ -7596,16 +9122,46 @@ export {
   assertPlainFolderAllowed,
   Projects,
   reasoningLevels,
+  AttachmentError,
+  ATTACHMENT_LIMITS,
+  attachmentFormats,
+  attachmentSources,
+  ATTACHMENT_PAGE_BYTES,
   roles,
   modelNameSchema,
   reasoningSchema,
   approvalModeSchema,
   approvalDeciderSchema,
-  providerOptionsSchema,
   startSchema,
-  statuses,
+  assertNoLegacyContext,
   deliveries,
   budgetRaiseSchema,
-  pendingInputKind
-};
-//# sourceMappingURL=chunk-MOWBM7MZ.js.map
+  pendingInputKind,
+  eventPayload,
+  now,
+  createSelectSchema,
+  checkStored,
+  decodeStored,
+  tasks,
+  events,
+  taskRead,
+  parentSeen,
+  taskArchive,
+  taskMessages,
+  sendReceipts,
+  MESSAGE_EVENTS,
+  conversation,
+  chatItems,
+  eventColumns,
+  readOriginalResponse,
+  insertEvent,
+  decodeEvent,
+  archivedFilters,
+  taskFilters,
+  readCompletedFlags,
+  taskExists,
+  readTasks,
+  readStates,
+  latestEvents
+};
+//# sourceMappingURL=chunk-36LESPFG.js.map