subagent-extension-for-codex 0.1.1 → 0.2.0

package/dist/bundle/chunks/chunk-ZSLXLKU2.js

@@ -0,0 +1,1702 @@
+import { createRequire as __bundleCreateRequire } from "node:module"; const require = __bundleCreateRequire(import.meta.url);
+import {
+  CONSTANTS,
+  Column,
+  DefaultLogger,
+  DrizzleQueryError,
+  NoopLogger,
+  SQL,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction,
+  SQLiteDialect,
+  and,
+  approvalModeSchema,
+  booleanFromInteger,
+  bufferFromBytes,
+  castToText,
+  dateFromStoredMilliseconds,
+  dateFromStoredSeconds,
+  deliveries,
+  desc,
+  entityKind,
+  eq,
+  extractExtendedColumnType,
+  formatToMillis,
+  getColumnTable,
+  getColumns,
+  getTableName,
+  gt,
+  inArray,
+  index,
+  integer,
+  is,
+  isTable,
+  isView,
+  isWithEnum,
+  jitCompatCheck,
+  logError,
+  logEvent,
+  lt,
+  lte,
+  max,
+  or,
+  packagePath,
+  primaryKey,
+  providerOptionsSchema,
+  refineSqliteCodecs,
+  roles,
+  sql,
+  sqliteTable,
+  statuses,
+  text,
+  uniqueIndex,
+  withLogContext
+} from "./chunk-MOWBM7MZ.js";
+import {
+  external_exports
+} from "./chunk-5TX3SEV2.js";
+
+// src/service/features/tasks/storage/store.ts
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+// src/shared/tasks/conversation/unread.ts
+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/shared/time.ts
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+
+// src/service/platform/database/database.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
+// node_modules/drizzle-orm/node-sqlite/codecs.js
+var nodeSQLiteCodecs = refineSqliteCodecs({
+  "integer:boolean": { normalize: booleanFromInteger },
+  "integer:timestamp": { normalize: dateFromStoredSeconds },
+  "integer:timestamp_ms": { normalize: dateFromStoredMilliseconds },
+  "text:json": { normalize: JSON.parse },
+  blob: { normalize: bufferFromBytes },
+  "blob:json": {
+    cast: castToText,
+    normalize: JSON.parse
+  },
+  "blob:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  },
+  numeric: {
+    cast: castToText,
+    normalize: String
+  },
+  "numeric:number": { normalize: Number },
+  "numeric:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  }
+});
+
+// node_modules/drizzle-orm/node-sqlite/session.js
+var NodeSQLiteSession = class extends SQLiteAsyncSession {
+  client;
+  relations;
+  options;
+  static [entityKind] = "SQLJsSession";
+  logger;
+  constructor(client, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.prepare(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, this.options.paramsInErrors ? query.params : void 0, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: (params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.all(...params);
+        if (mode === "objects") return res.map((row) => ({ ...row }));
+        return res;
+      },
+      get: (params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.get(...params);
+        if (res && mode === "objects") return { ...res };
+        return res;
+      },
+      run: (params) => {
+        stmt.setReturnArrays(false);
+        return stmt.run(...params);
+      }
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0, this.options.paramsInErrors);
+  }
+  transaction(transaction, config = {}) {
+    if (config?.behavior === "concurrent") throw new Error("Concurrent transactions are not supported by driver");
+    const tx = new NodeSQLiteTransaction("sync", this.dialect, this, this.relations);
+    this.run(sql.raw(`begin${config.behavior ? ` ${config.behavior}` : ""}`));
+    try {
+      const result = transaction(tx);
+      this.run(sql`commit`);
+      return result;
+    } catch (err) {
+      try {
+        this.run(sql`rollback`);
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var NodeSQLiteTransaction = class NodeSQLiteTransaction2 extends SQLiteAsyncTransaction {
+  static [entityKind] = "SQLJsTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new NodeSQLiteTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    tx.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      tx.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      try {
+        tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+
+// node_modules/drizzle-orm/node-sqlite/driver.js
+import { DatabaseSync } from "node:sqlite";
+var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
+  static [entityKind] = "NodeSQLiteDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new SQLiteDialect({
+    codecs: config.codecs ?? nodeSQLiteCodecs,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  let logger;
+  if (config.logger === true) logger = new DefaultLogger();
+  else if (config.logger !== false) logger = config.logger;
+  const relations = config.relations ?? {};
+  const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client, dialect, relations, {
+    logger,
+    paramsInErrors: config.paramsInErrors
+  }), relations);
+  db.$client = client;
+  return db;
+}
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
+  const { connection, client, ...config } = params[0];
+  if (client) return construct(client, config);
+  if (typeof connection === "object") {
+    const { path, ...options } = connection;
+    return construct(new DatabaseSync(path ?? ":memory:", options), config);
+  }
+  return construct(new DatabaseSync(connection ?? ":memory:"), config);
+}
+(function(_drizzle) {
+  function mock(config) {
+    return construct({}, config);
+  }
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+
+// node_modules/drizzle-orm/migrator.js
+import crypto from "node:crypto";
+import fs, { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+function readMigrationFiles(config) {
+  if (fs.existsSync(`${config.migrationsFolder}/meta/_journal.json`)) throw Error('We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run "drizzle-kit up"');
+  const migrationFolderTo = config.migrationsFolder;
+  const migrationQueries = [];
+  const migrations = readdirSync(migrationFolderTo).map((subdir) => ({
+    path: join(migrationFolderTo, subdir, "migration.sql"),
+    name: subdir
+  })).filter((it) => existsSync(it.path));
+  migrations.sort((a, b) => a.name.localeCompare(b.name));
+  for (const migration of migrations) {
+    const migrationPath = migration.path;
+    const migrationDate = migration.name.slice(0, 14);
+    const query = fs.readFileSync(migrationPath).toString();
+    const result = query.split("--> statement-breakpoint").map((it) => {
+      return it;
+    });
+    const millis = formatToMillis(migrationDate);
+    migrationQueries.push({
+      sql: result,
+      bps: true,
+      folderMillis: millis,
+      hash: crypto.createHash("sha256").update(query).digest("hex"),
+      name: migration.name
+    });
+  }
+  return migrationQueries;
+}
+
+// src/service/platform/database/backup.ts
+import { mkdirSync, readdirSync as readdirSync2, rmSync } from "node:fs";
+import { basename, dirname, extname, join as join2 } from "node:path";
+var KEEP = 3;
+function backUpDatabase(client, path, lastMigration) {
+  const directory = join2(dirname(path), "backups");
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  const name = basename(path, extname(path));
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backup = join2(directory, `${name}-${lastMigration}-${stamp}.sqlite`);
+  client.prepare("VACUUM INTO ?").run(backup);
+  const stamped = new RegExp(`^${name}-.+-(\\d{4}-[\\dT-]+Z)\\.sqlite$`);
+  const backups = readdirSync2(directory).flatMap((file) => {
+    const time = file.match(stamped)?.[1];
+    return time ? [{ file, time }] : [];
+  }).sort(
+    (a, b) => b.time.localeCompare(a.time) || b.file.localeCompare(a.file)
+  );
+  for (const { file } of backups.slice(KEEP)) {
+    rmSync(join2(directory, file), { force: true });
+  }
+  return backup;
+}
+
+// src/service/platform/database/migrate.ts
+var LEDGER = "__drizzle_migrations";
+function migrate(client, folder, path) {
+  const migrations = readMigrationFiles({ migrationsFolder: folder });
+  if (!migrations.length) throw new Error(`No migrations found in ${folder}`);
+  const before = ledger(client);
+  if (before.length && path !== ":memory:" && migrations.some((m) => !before.includes(m.name))) {
+    backUpDatabase(client, path, before.at(-1));
+  }
+  client.exec("BEGIN IMMEDIATE");
+  try {
+    const versioned = client.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(LEDGER);
+    if (!versioned) {
+      const tables = client.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+      ).all();
+      if (tables.length) {
+        throw new Error(
+          `${path} was created by an unsupported earlier version. Delete its data directory to start over.`
+        );
+      }
+      client.exec(
+        `CREATE TABLE ${LEDGER}(id INTEGER PRIMARY KEY, hash TEXT NOT NULL, created_at NUMERIC, name TEXT, applied_at TEXT)`
+      );
+    }
+    const applied = new Set(ledger(client));
+    const known = new Set(migrations.map((m) => m.name));
+    const unknown = [...applied].filter((name) => !known.has(name));
+    if (unknown.length) {
+      throw new Error(
+        `${path} has migration history this build does not recognize (${unknown.join(", ")}). Use a build that includes those migrations, or delete its data directory to start over.`
+      );
+    }
+    const record = client.prepare(
+      `INSERT INTO ${LEDGER}(hash, created_at, name, applied_at) VALUES(?,?,?,?)`
+    );
+    for (const migration of migrations) {
+      if (applied.has(migration.name)) continue;
+      for (const statement of migration.sql) {
+        if (statement.trim()) client.exec(statement);
+      }
+      record.run(
+        migration.hash,
+        migration.folderMillis,
+        migration.name,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    }
+    client.exec("COMMIT");
+  } catch (error) {
+    client.exec("ROLLBACK");
+    throw error;
+  }
+}
+function ledger(client) {
+  const exists = client.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(LEDGER);
+  if (!exists) return [];
+  return client.prepare(`SELECT name FROM ${LEDGER} ORDER BY id`).all().map((row) => String(row.name));
+}
+
+// src/service/platform/database/database.ts
+var migrationsFolder = packagePath("migrations");
+for (const method of ["run", "all", "get", "values"]) {
+  const prototype = SQLiteAsyncPreparedQuery.prototype;
+  const execute = prototype[method];
+  if (!execute) {
+    throw new Error(
+      `Drizzle's prepared queries have no ${method} method to wrap; check the drizzle-orm upgrade.`
+    );
+  }
+  prototype[method] = function(...args) {
+    try {
+      return execute.apply(this, args);
+    } catch (error) {
+      throw error instanceof DrizzleQueryError && error.cause instanceof Error ? error.cause : error;
+    }
+  };
+}
+var BUSY_TIMEOUT_MS = 5e3;
+var SQLITE_BUSY = 5;
+function busy(error) {
+  return (error.errcode ?? 0) % 256 === SQLITE_BUSY;
+}
+function useWal(client) {
+  const deadline = Date.now() + BUSY_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      if (client.prepare("PRAGMA journal_mode").get()?.journal_mode === "wal") {
+        return;
+      }
+      client.exec("PRAGMA journal_mode=WAL");
+      return;
+    } catch (error) {
+      if (!busy(error) || Date.now() > deadline) throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+  }
+}
+function thenable(value) {
+  return typeof value?.then === "function";
+}
+function transactions(client) {
+  let queued;
+  return {
+    transaction(fn) {
+      if (queued) {
+        throw new Error(
+          "A transaction is already open; run this work inside it"
+        );
+      }
+      const notifications = [];
+      queued = notifications;
+      let result;
+      client.exec("BEGIN IMMEDIATE");
+      try {
+        result = fn();
+        if (thenable(result)) {
+          throw new Error("Database transactions must be synchronous");
+        }
+        client.exec("COMMIT");
+      } catch (error) {
+        client.exec("ROLLBACK");
+        throw error;
+      } finally {
+        queued = void 0;
+      }
+      for (const notify of notifications) notify();
+      return result;
+    },
+    afterCommit(notify) {
+      if (queued) queued.push(notify);
+      else notify();
+    }
+  };
+}
+function openDatabase(path, migrations = migrationsFolder) {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  const client = new DatabaseSync2(path, { timeout: BUSY_TIMEOUT_MS });
+  try {
+    useWal(client);
+    client.exec("PRAGMA foreign_keys=ON");
+    migrate(client, migrations, path);
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+  return {
+    client,
+    orm: drizzle({ client }),
+    ...transactions(client),
+    close: () => client.close()
+  };
+}
+var INCREMENTAL = 2;
+function useIncrementalVacuum(database) {
+  const { client } = database;
+  const mode = client.prepare("PRAGMA auto_vacuum").get()?.auto_vacuum;
+  if (mode === INCREMENTAL) return;
+  const started = performance.now();
+  logEvent("info", "database.vacuum_started");
+  client.exec("PRAGMA auto_vacuum=INCREMENTAL");
+  client.exec("VACUUM");
+  logEvent("info", "database.vacuum_completed", {
+    duration_ms: Math.round(performance.now() - started)
+  });
+}
+
+// src/shared/providers/activity/presentation-contract.generated.ts
+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/tasks/event-contract.generated.ts
+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()
+});
+var taskWaitingPayloadSchema = external_exports.object({
+  reason: external_exports.string().optional(),
+  dependency_id: 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.waiting": taskWaitingPayloadSchema,
+  "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 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.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/service/features/tasks/storage/schema.ts
+var tasks = sqliteTable("tasks", {
+  id: text().primaryKey(),
+  owner: text().notNull(),
+  body: text().notNull()
+});
+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()
+  },
+  (t) => [
+    index("events_task").on(t.task_id, 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 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
+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
+  }).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
+  });
+}
+
+// node_modules/drizzle-orm/zod/column.js
+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 min;
+  let max2;
+  let integer2 = false;
+  switch (constraint) {
+    case "int8":
+      min = CONSTANTS.INT8_MIN;
+      max2 = CONSTANTS.INT8_MAX;
+      integer2 = true;
+      break;
+    case "uint8":
+      min = 0;
+      max2 = CONSTANTS.INT8_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int16":
+      min = CONSTANTS.INT16_MIN;
+      max2 = CONSTANTS.INT16_MAX;
+      integer2 = true;
+      break;
+    case "uint16":
+      min = 0;
+      max2 = CONSTANTS.INT16_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int24":
+      min = CONSTANTS.INT24_MIN;
+      max2 = CONSTANTS.INT24_MAX;
+      integer2 = true;
+      break;
+    case "uint24":
+      min = 0;
+      max2 = CONSTANTS.INT24_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int32":
+      min = CONSTANTS.INT32_MIN;
+      max2 = CONSTANTS.INT32_MAX;
+      integer2 = true;
+      break;
+    case "uint32":
+      min = 0;
+      max2 = CONSTANTS.INT32_UNSIGNED_MAX;
+      integer2 = true;
+      break;
+    case "int53":
+      min = Number.MIN_SAFE_INTEGER;
+      max2 = Number.MAX_SAFE_INTEGER;
+      integer2 = true;
+      break;
+    case "uint53":
+      min = 0;
+      max2 = Number.MAX_SAFE_INTEGER;
+      integer2 = true;
+      break;
+    case "float":
+      min = CONSTANTS.INT24_MIN;
+      max2 = CONSTANTS.INT24_MAX;
+      break;
+    case "ufloat":
+      min = 0;
+      max2 = CONSTANTS.INT24_UNSIGNED_MAX;
+      break;
+    case "double":
+      min = CONSTANTS.INT48_MIN;
+      max2 = CONSTANTS.INT48_MAX;
+      break;
+    case "udouble":
+      min = 0;
+      max2 = CONSTANTS.INT48_UNSIGNED_MAX;
+      break;
+    case "year":
+      min = 1901;
+      max2 = 2155;
+      integer2 = true;
+      break;
+    case "unsigned":
+      min = 0;
+      max2 = Number.MAX_SAFE_INTEGER;
+      break;
+    default:
+      min = 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(min).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 min;
+  let max2;
+  switch (constraint) {
+    case "int64":
+      min = CONSTANTS.INT64_MIN;
+      max2 = CONSTANTS.INT64_MAX;
+      break;
+    case "uint64":
+      min = 0n;
+      max2 = CONSTANTS.INT64_UNSIGNED_MAX;
+  }
+  let schema = coerce === true || coerce?.bigint ? z.coerce.bigint() : z.bigint();
+  if (min !== void 0) schema = schema.min(min);
+  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
+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/service/platform/database/decode.ts
+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
+});
+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(),
+  depends_on: external_exports.array(external_exports.string()),
+  context: external_exports.array(external_exports.string()),
+  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),
+  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: external_exports.array(message),
+  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/chat-events.ts
+function chatEvents(orm, id, types) {
+  const compaction = and(
+    eq(events.type, "claude.activity"),
+    // A plain text match first, so most activity skips parsing its JSON.
+    sql`instr(${events.data}, 'compact') > 0`,
+    sql`(json_extract(${events.data},'$.subtype')='compact_boundary' OR json_extract(${events.data},'$.compact_result')='failed')`
+  );
+  return orm.select(eventColumns).from(events).where(
+    and(eq(events.task_id, id), or(inArray(events.type, types), compaction))
+  ).orderBy(events.id).all().map(decodeEvent);
+}
+
+// src/service/features/tasks/storage/event-storage-metrics.ts
+var EventStorageMetrics = class {
+  active = /* @__PURE__ */ new Map();
+  begin(taskId, turn) {
+    const counters = {
+      event_count: 0,
+      json_bytes: 0,
+      original_response_event_count: 0
+    };
+    this.active.set(taskId, counters);
+    return (status) => {
+      if (this.active.get(taskId) !== counters) return;
+      this.active.delete(taskId);
+      try {
+        logEvent("info", "task.event_storage", {
+          task_id: taskId,
+          turn,
+          status,
+          ...counters
+        });
+      } catch {
+      }
+    };
+  }
+  committed(database, taskId, serialized, originalResponse) {
+    const counters = this.active.get(taskId);
+    if (!counters) return;
+    const bytes = Buffer.byteLength(serialized, "utf8") + (originalResponse ? Buffer.byteLength(originalResponse, "utf8") : 0);
+    database.afterCommit(() => {
+      if (this.active.get(taskId) !== counters) return;
+      counters.event_count++;
+      counters.json_bytes += bytes;
+      counters.original_response_event_count += Number(
+        originalResponse !== void 0
+      );
+    });
+  }
+};
+
+// src/service/features/tasks/storage/publish-listeners.ts
+function publishListeners(bus, name, args) {
+  for (const listener of bus.listeners(name)) {
+    try {
+      listener(...args);
+    } catch (error) {
+      logError("store.listener_failed", error, { listener: name });
+    }
+  }
+}
+
+// src/service/features/tasks/storage/read-metrics.ts
+var WINDOW_MS = 6e4;
+var SLOW_MS = 50;
+var ReadMetrics = class {
+  summaries = /* @__PURE__ */ new Map();
+  timer;
+  started = 0;
+  measure(operation, run) {
+    const started = performance.now();
+    const work = { rows: 0, tally_rows: 0 };
+    let outcome = "error";
+    try {
+      const result = run(work);
+      outcome = "success";
+      return result;
+    } finally {
+      const duration = performance.now() - started;
+      try {
+        logEvent("debug", "storage.read", {
+          operation,
+          duration_ms: duration,
+          outcome,
+          ...work
+        });
+      } catch {
+      }
+      const summary = this.summaries.get(operation) ?? {
+        count: 0,
+        total_ms: 0,
+        max_ms: 0,
+        rows: 0,
+        tally_rows: 0,
+        slow_count: 0,
+        error_count: 0
+      };
+      summary.count++;
+      summary.total_ms += duration;
+      summary.max_ms = Math.max(summary.max_ms, duration);
+      summary.rows += work.rows;
+      summary.tally_rows += work.tally_rows;
+      summary.slow_count += Number(duration >= SLOW_MS);
+      summary.error_count += Number(outcome === "error");
+      this.summaries.set(operation, summary);
+      if (!this.timer) {
+        this.started = performance.now();
+        this.timer = setTimeout(() => this.flush(), WINDOW_MS);
+        this.timer.unref();
+      }
+    }
+  }
+  rows(operation, run) {
+    return this.measure(operation, (work) => {
+      const rows = run();
+      work.rows = rows.length;
+      return rows;
+    });
+  }
+  flush() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    try {
+      withLogContext(
+        {},
+        () => {
+          for (const [operation, summary] of this.summaries) {
+            logEvent("info", "storage.read_summary", {
+              operation,
+              ...summary,
+              window_ms: performance.now() - this.started,
+              slow_threshold_ms: SLOW_MS
+            });
+          }
+        },
+        { inherit: false }
+      );
+    } catch {
+    } finally {
+      this.summaries.clear();
+    }
+  }
+};
+
+// src/service/features/tasks/storage/store.ts
+var PAGE = 1e3;
+var toTask = (row) => decodeTask(row.id, row.body);
+var Store = class {
+  /** The shared connection, which other features' storage also uses. */
+  database;
+  reads = new ReadMetrics();
+  eventStorage = new EventStorageMetrics();
+  /** The tasks saved in the open transaction, with the `updated_at` to restore on rollback. */
+  saved;
+  /** The owners whose tasks the open transaction changed. */
+  changed;
+  /** Distinguishes this process's revisions from a restarted service's. */
+  bootId = randomUUID();
+  revisions = /* @__PURE__ */ new Map();
+  projectRevision = 0;
+  // Long-poll reads each listen while they wait, so there can be many.
+  bus = new EventEmitter().setMaxListeners(0);
+  constructor(path) {
+    this.database = openDatabase(path);
+  }
+  beginEventStorage(taskId, turn) {
+    return this.eventStorage.begin(taskId, turn);
+  }
+  get orm() {
+    return this.database.orm;
+  }
+  /**
+   * Runs `fn` in one transaction, so the task state and events it writes
+   * commit together. Listeners hear its events only after the commit; on a
+   * rollback they hear nothing, and saved tasks get back their `updated_at`.
+   */
+  transaction(fn) {
+    if (this.saved) {
+      throw new Error("A transaction is already open; run this work inside it");
+    }
+    const saved = [];
+    this.saved = saved;
+    this.changed = /* @__PURE__ */ new Set();
+    try {
+      return this.database.transaction(() => {
+        try {
+          return fn();
+        } finally {
+          this.saved = void 0;
+          this.changed = void 0;
+        }
+      });
+    } catch (error) {
+      for (const [t, updated] of saved.reverse()) t.updated_at = updated;
+      throw error;
+    }
+  }
+  save(t) {
+    const updated = t.updated_at;
+    t.updated_at = now();
+    const body = JSON.stringify(t);
+    try {
+      this.orm.insert(tasks).values({ id: t.id, owner: t.owner, body }).onConflictDoUpdate({ target: tasks.id, set: { body } }).run();
+    } catch (error) {
+      t.updated_at = updated;
+      throw error;
+    }
+    this.saved?.push([t, updated]);
+    this.markChanged(t.owner);
+  }
+  /**
+   * Deletes a task. Its events and pending forms
+   * reference it and are deleted with it, and the service's database returns
+   * their space to the file system.
+   */
+  delete(id, owner) {
+    this.get(id, owner);
+    this.orm.delete(tasks).where(and(eq(tasks.id, id), eq(tasks.owner, owner))).run();
+    this.database.client.exec("PRAGMA incremental_vacuum");
+    this.markChanged(owner);
+  }
+  /**
+   * Announces `change` for an owner once the open transaction commits, once
+   * per transaction however many writes it holds; at once outside one.
+   * Other task storage built on this connection announces its writes here.
+   */
+  markChanged(owner) {
+    const changed = this.changed;
+    if (!changed) {
+      this.announce([owner]);
+      return;
+    }
+    if (!changed.size) this.database.afterCommit(() => this.announce(changed));
+    changed.add(owner);
+  }
+  announce(owners) {
+    for (const owner of owners) {
+      this.revisions.set(owner, (this.revisions.get(owner) ?? 0) + 1);
+      this.publish("change", owner);
+    }
+  }
+  /** Announces a change to the project list, which every owner shares. */
+  projectsChanged() {
+    this.projectRevision++;
+    this.publish("change", void 0);
+  }
+  /**
+   * An opaque token for the state of an owner's tasks and the project list.
+   * It differs whenever either has changed, including across a restart, so
+   * clients compare it only for equality.
+   */
+  revision(owner) {
+    const count = (this.revisions.get(owner) ?? 0) + this.projectRevision;
+    return `${this.bootId}:${count}`;
+  }
+  /** An owner's tasks, or every task without one, newest first. */
+  all(owner) {
+    return this.reads.rows(
+      "task_list",
+      () => this.orm.select({ id: tasks.id, body: tasks.body }).from(tasks).where(owner ? eq(tasks.owner, owner) : void 0).all().map(toTask).sort((a, b) => b.created_at.localeCompare(a.created_at))
+    );
+  }
+  get(id, owner) {
+    const task = this.find(id, owner);
+    if (!task) throw new Error("Task not found");
+    return task;
+  }
+  /** An owner's task, or undefined when it has none with this id. */
+  find(id, owner) {
+    const row = this.orm.select({ id: tasks.id, body: tasks.body }).from(tasks).where(and(eq(tasks.id, id), eq(tasks.owner, owner))).get();
+    return row && toTask(row);
+  }
+  event(t, type, ...args) {
+    const data = args[0] ?? {};
+    return this.writeEvent(t, type, data);
+  }
+  /** Records a provider-owned event through the explicit opaque extension path. */
+  eventOpaque(t, type, data = {}) {
+    return this.writeEvent(t, type, data);
+  }
+  writeEvent(t, type, data) {
+    const event = insertEvent(
+      this.database,
+      this.eventStorage,
+      t.id,
+      type,
+      data
+    );
+    this.database.afterCommit(() => this.publish("event", event, t.owner));
+    this.markChanged(t.owner);
+    return event;
+  }
+  /** Isolate listener failures after commit so consumers can still catch up. */
+  publish(name, ...args) {
+    publishListeners(this.bus, name, args);
+  }
+  events(id, owner, after = 0) {
+    this.get(id, owner);
+    return this.orm.select(eventColumns).from(events).where(and(eq(events.task_id, id), gt(events.id, after))).orderBy(events.id).limit(PAGE).all().map(decodeEvent);
+  }
+  /** Resolves an original response after checking task ownership. */
+  originalResponse(id, owner, responseRef) {
+    this.get(id, owner);
+    return readOriginalResponse(this.database, id, responseRef);
+  }
+  /**
+   * The id of a task's event `depth` places from its newest, so the newest
+   * `depth` events are those from it on; 0 when there are fewer than that.
+   * `depth` is at least 1: the query offsets by `depth - 1`.
+   */
+  eventWindowStart(id, depth) {
+    return this.orm.select({ id: events.id }).from(events).where(eq(events.task_id, id)).orderBy(desc(events.id)).limit(1).offset(depth - 1).get()?.id ?? 0;
+  }
+  /**
+   * The id of the `depth`th newest of a task's events after `after` and
+   * through `through`, so those events from it on are the newest `depth`;
+   * `after + 1` when there are fewer than that.
+   */
+  rangeWindowStart(id, after, through, depth) {
+    return this.orm.select({ id: events.id }).from(events).where(
+      and(
+        eq(events.task_id, id),
+        gt(events.id, after),
+        lte(events.id, through)
+      )
+    ).orderBy(desc(events.id)).limit(1).offset(depth - 1).get()?.id ?? after + 1;
+  }
+  /**
+   * What the owner has read of a task: whether it has a reply, outcome or
+   * request they haven't read, and the newest event they had read.
+   */
+  readState(id) {
+    const mark = this.orm.select({ through: taskRead.through, unread: taskRead.unread }).from(taskRead).where(eq(taskRead.task_id, id)).get();
+    const latest = this.orm.select({ id: max(events.id) }).from(events).where(and(eq(events.task_id, id), inArray(events.type, READ_EVENTS))).get();
+    return {
+      unread: isUnread(latest?.id ?? 0, mark),
+      through: mark?.through ?? 0
+    };
+  }
+  /**
+   * Records that the owner has read a task through event `through`, or its
+   * newest event without one. It never moves back, never passes the newest
+   * event and clears the task's unread mark.
+   */
+  markRead(t, through) {
+    const newest = this.lastEventId(t.id);
+    const read = Math.min(through ?? newest, newest);
+    this.orm.insert(taskRead).values({ task_id: t.id, through: read, unread: false }).onConflictDoUpdate({
+      target: taskRead.task_id,
+      set: { through: sql`max(${taskRead.through}, ${read})`, unread: false }
+    }).run();
+    this.markChanged(t.owner);
+  }
+  /** Marks a task unread from event `from` on; unlike `markRead`, it can move the read point back. */
+  markUnreadFrom(t, from) {
+    const through = Math.min(from - 1, this.lastEventId(t.id));
+    const mark = { through, unread: false };
+    this.orm.insert(taskRead).values({ task_id: t.id, ...mark }).onConflictDoUpdate({ target: taskRead.task_id, set: mark }).run();
+    this.markChanged(t.owner);
+  }
+  /** Marks a task unread until the owner next sees it. */
+  markUnread(t) {
+    this.orm.insert(taskRead).values({ task_id: t.id, through: 0, unread: true }).onConflictDoUpdate({ target: taskRead.task_id, set: { unread: true } }).run();
+    this.markChanged(t.owner);
+  }
+  /** The id of a task's `task.turn_ended` event for a turn; absent until it ends. */
+  turnEnded(id, turn) {
+    return this.orm.select({ id: events.id }).from(events).where(
+      and(
+        eq(events.task_id, id),
+        eq(events.type, "task.turn_ended"),
+        eq(sql`json_extract(${events.data}, '$.turn')`, turn)
+      )
+    ).orderBy(events.id).limit(1).get()?.id;
+  }
+  /** A task's first event after `after` with one of `types`. */
+  nextEventOfType(id, after, types) {
+    return this.orm.select({ id: events.id, type: events.type }).from(events).where(
+      and(
+        eq(events.task_id, id),
+        gt(events.id, after),
+        inArray(events.type, types)
+      )
+    ).orderBy(events.id).limit(1).get();
+  }
+  /**
+   * A task's events after `after`, and before `before` when given, a page at a
+   * time. Internal: callers check the task's owner first.
+   */
+  taskEvents(id, after, before) {
+    return this.orm.select(eventColumns).from(events).where(
+      and(
+        eq(events.task_id, id),
+        gt(events.id, after),
+        before === void 0 ? void 0 : lt(events.id, before)
+      )
+    ).orderBy(events.id).limit(PAGE).all().map(decodeEvent);
+  }
+  recentEvents(id, owner) {
+    this.get(id, owner);
+    return this.orm.select(eventColumns).from(events).where(eq(events.task_id, id)).orderBy(desc(events.id)).limit(200).all().reverse().map(decodeEvent);
+  }
+  /** The id of the latest event, or of a task's latest one; 0 before any. */
+  lastEventId(id) {
+    const row = this.orm.select({ id: max(events.id) }).from(events).where(id === void 0 ? void 0 : eq(events.task_id, id)).get();
+    return row?.id ?? 0;
+  }
+  /** A task's latest event of a type, such as its latest `agent.reply`. */
+  latestEvent(id, type) {
+    const row = this.orm.select(eventColumns).from(events).where(and(eq(events.task_id, id), eq(events.type, type))).orderBy(desc(events.id)).limit(1).get();
+    return row && decodeEvent(row);
+  }
+  /** Every event of the given types for a task, in order, with no page limit. */
+  eventsOfTypes(id, types) {
+    return this.orm.select(eventColumns).from(events).where(and(eq(events.task_id, id), inArray(events.type, types))).orderBy(events.id).all().map(decodeEvent);
+  }
+  /**
+   * The events Chat is built from: those of the given types, and context
+   * compactions, which Claude reports among its other system messages.
+   */
+  chatEvents(id, types) {
+    return this.reads.rows("chat", () => chatEvents(this.orm, id, types));
+  }
+  close() {
+    this.reads.flush();
+    this.database.close();
+  }
+};
+
+export {
+  now,
+  createSelectSchema,
+  checkStored,
+  decodeStored,
+  tasks,
+  events,
+  parentSeen,
+  taskArchive,
+  sendReceipts,
+  eventColumns,
+  decodeEvent,
+  useIncrementalVacuum,
+  Store
+};
+//# sourceMappingURL=chunk-ZSLXLKU2.js.map