@hasna/todos 0.11.56 → 0.11.58

package/dist/index.js

@@ -3050,7 +3050,7 @@ var init_redaction = __esm(() => {
 });
 
 // src/lib/secret-redaction.ts
-import { readFileSync as readFileSync3, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
 function registerCustomRedactor(fn) {
   customRedactors.push(fn);
 }
@@ -3115,7 +3115,7 @@ function scanAndRedactText(text, options = {}) {
   };
 }
 function scanFileForSecrets(path, options = {}) {
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     throw new Error(`File not found: ${path}`);
   const content = readFileSync3(path, "utf8");
   return scanAndRedactText(content, options);
@@ -4874,6 +4874,67 @@ var TODOS_JSON_CONTRACTS = [
     },
     optional: {}
   }),
+  contract({
+    id: "tester_issue_report",
+    name: "Tester Issue Report",
+    description: "Generic issue report payload emitted by @hasna/testers or compatible test runners for conversion into local tasks.",
+    surfaces: ["cli", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("string", "Must be testers.issue_report.v1."),
+      title: field("string", "Short human-readable issue title.")
+    },
+    optional: {
+      kind: field("string", "Issue kind such as assertion_failure, console_error, network_error, accessibility, or unknown."),
+      severity: field("string", "Issue severity mapped to task priority: low, medium, high, or critical."),
+      id: idField,
+      fingerprint: field("string", "Stable tester-side fingerprint. If omitted, @hasna/todos derives one from issue fields."),
+      summary: field(["string", "null"], "Short issue summary.", true),
+      source: field("object", "Run, result, scenario, URL, commit, and branch source metadata."),
+      target: field("object", "URL, route, selector, component, browser, and viewport metadata."),
+      failure: field("object", "Failure message, expected/actual values, stack, reasoning, and reproduction steps."),
+      evidence: field("object", "Logs, screenshots, and artifact references."),
+      labels: tagsField,
+      metadata: metadataField,
+      occurred_at: isoDateField
+    }
+  }),
+  contract({
+    id: "tester_issue_report_result",
+    name: "Tester Issue Report Result",
+    description: "Local-only dry-run or applied result from mapping a tester issue report to a task.",
+    surfaces: ["cli", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("string", "Result schema version."),
+      local_only: field("boolean", "Always true; issue reports are applied to local todos state."),
+      dry_run: field("boolean", "True when no task was created or updated."),
+      processed_at: isoDateField,
+      action: field("string", "preview, matched, created, updated, or regressed."),
+      fingerprint: field("string", "Computed or supplied tester issue fingerprint."),
+      report: field("object", "Normalized tester issue report."),
+      task: field(["object", "null"], "Created, updated, matched, or null task.", true),
+      warnings: field("array", "Non-fatal warnings."),
+      commands: field("array", "Follow-up CLI commands for operators and agents.")
+    },
+    optional: {}
+  }),
+  contract({
+    id: "tester_issue_report_batch_result",
+    name: "Tester Issue Report Batch Result",
+    description: "Local-only dry-run or applied batch result from mapping tester issue reports to tasks.",
+    surfaces: ["cli", "sdk"],
+    stability: "stable",
+    required: {
+      schema_version: field("string", "Batch result schema version."),
+      local_only: field("boolean", "Always true; issue reports are applied to local todos state."),
+      dry_run: field("boolean", "True when no tasks were created or updated."),
+      processed_at: isoDateField,
+      results: field("array", "Single report result entries."),
+      summary: field("object", "Counts grouped by action plus total.")
+    },
+    optional: {}
+  }),
   contract({
     id: "verification_provider",
     name: "Verification Provider",
@@ -5914,7 +5975,7 @@ var TODOS_JSON_CONTRACTS_MANIFEST = createJsonContractsManifest({
 });
 // src/lib/onboarding-fixtures.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/lib/local-bridge.ts
 init_database();
@@ -6574,6 +6635,7 @@ function explainRunnerSandbox(input = {}) {
 // src/lib/event-hooks.ts
 init_config();
 var LOCAL_EVENT_TYPES = [
+  "task.created",
   "task.assigned",
   "task.blocked",
   "task.started",
@@ -6816,6 +6878,752 @@ async function testLocalEventHook(name, input) {
   return emitLocalEventHooks({ ...input, hooks: [hook] });
 }
 
+// node_modules/.bun/@hasna+events@0.1.9/node_modules/@hasna/events/dist/index.js
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { homedir } from "os";
+import { join as join5 } from "path";
+import { createHmac, timingSafeEqual } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID22 } from "crypto";
+function getPathValue(input, path) {
+  return path.split(".").reduce((value, part) => {
+    if (value && typeof value === "object" && part in value) {
+      return value[part];
+    }
+    return;
+  }, input);
+}
+function wildcardToRegExp(pattern, options = {}) {
+  let body = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        body += ".*";
+        index += 1;
+      } else {
+        body += options.segmentSafe ? "[^/]*" : ".*";
+      }
+    } else {
+      body += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${body}$`);
+}
+function matchString(value, matcher, options = {}) {
+  if (matcher === undefined)
+    return true;
+  if (value === undefined)
+    return false;
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.some((item) => wildcardToRegExp(item, options).test(value));
+}
+function matchRecord(input, matcher) {
+  if (!matcher)
+    return true;
+  return Object.entries(matcher).every(([path, expected]) => {
+    const actual = getPathValue(input, path);
+    if (typeof expected === "string" || Array.isArray(expected)) {
+      return matchString(actual === undefined ? undefined : String(actual), expected, {
+        segmentSafe: path.endsWith("_path") || path.endsWith(".path")
+      });
+    }
+    return actual === expected;
+  });
+}
+function eventMatchesFilter(event, filter) {
+  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
+}
+function channelMatchesEvent(channel, event) {
+  if (!channel.enabled)
+    return false;
+  if (!channel.filters || channel.filters.length === 0)
+    return true;
+  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
+}
+var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
+var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
+function getEventsDataDir(override) {
+  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join5(homedir(), ".hasna", "events");
+}
+class JsonEventsStore {
+  dataDir;
+  channelsPath;
+  eventsPath;
+  deliveriesPath;
+  constructor(dataDir = getEventsDataDir()) {
+    this.dataDir = dataDir;
+    this.channelsPath = join5(dataDir, "channels.json");
+    this.eventsPath = join5(dataDir, "events.json");
+    this.deliveriesPath = join5(dataDir, "deliveries.json");
+  }
+  async init() {
+    await mkdir(this.dataDir, { recursive: true, mode: 448 });
+    await chmod(this.dataDir, 448).catch(() => {
+      return;
+    });
+    await this.ensureArrayFile(this.channelsPath);
+    await this.ensureArrayFile(this.eventsPath);
+    await this.ensureArrayFile(this.deliveriesPath);
+  }
+  async addChannel(channel) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const index = channels.findIndex((item) => item.id === channel.id);
+    if (index >= 0) {
+      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
+    } else {
+      channels.push(channel);
+    }
+    await this.writeJson(this.channelsPath, channels);
+    return index >= 0 ? channels[index] : channel;
+  }
+  async listChannels() {
+    await this.init();
+    return this.readJson(this.channelsPath, []);
+  }
+  async getChannel(id) {
+    const channels = await this.listChannels();
+    return channels.find((channel) => channel.id === id);
+  }
+  async removeChannel(id) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const next = channels.filter((channel) => channel.id !== id);
+    await this.writeJson(this.channelsPath, next);
+    return next.length !== channels.length;
+  }
+  async appendEvent(event) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    events.push(event);
+    await this.writeJson(this.eventsPath, events);
+    return event;
+  }
+  async listEvents() {
+    await this.init();
+    return this.readJson(this.eventsPath, []);
+  }
+  async findEventByIdentity(identity) {
+    const events = await this.listEvents();
+    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+  }
+  async appendDelivery(result) {
+    await this.init();
+    const deliveries = await this.readJson(this.deliveriesPath, []);
+    deliveries.push(result);
+    await this.writeJson(this.deliveriesPath, deliveries);
+    return result;
+  }
+  async listDeliveries() {
+    await this.init();
+    return this.readJson(this.deliveriesPath, []);
+  }
+  async exportData() {
+    return {
+      channels: await this.listChannels(),
+      events: await this.listEvents(),
+      deliveries: await this.listDeliveries()
+    };
+  }
+  async ensureArrayFile(path) {
+    if (!existsSync6(path)) {
+      await writeFile(path, `[]
+`, { encoding: "utf-8", mode: 384 });
+    }
+    await chmod(path, 384).catch(() => {
+      return;
+    });
+  }
+  async readJson(path, fallback) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      if (!raw.trim())
+        return fallback;
+      return JSON.parse(raw);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return fallback;
+      throw error;
+    }
+  }
+  async writeJson(path, value) {
+    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf-8", mode: 384 });
+    await rename(tempPath, path);
+    await chmod(path, 384).catch(() => {
+      return;
+    });
+  }
+}
+var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
+function buildSignatureBase(timestamp, body) {
+  return `${timestamp}.${body}`;
+}
+function signPayload(secret, timestamp, body) {
+  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
+  return `sha256=${digest}`;
+}
+function now2() {
+  return new Date().toISOString();
+}
+function truncate(value, max = 4096) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function buildWebhookRequest(event, channel) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const body = JSON.stringify(event);
+  const timestamp = event.time;
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "@hasna/events",
+    "X-Hasna-Event-Id": event.id,
+    "X-Hasna-Event-Type": event.type,
+    "X-Hasna-Timestamp": timestamp,
+    ...channel.webhook.headers
+  };
+  if (channel.webhook.secret) {
+    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+  }
+  return { body, headers };
+}
+async function dispatchWebhook(event, channel, options = {}) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const startedAt = now2();
+  const { body, headers } = buildWebhookRequest(event, channel);
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
+  try {
+    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const responseBody = truncate(await response.text());
+    return {
+      attempt: 1,
+      status: response.ok ? "success" : "failed",
+      startedAt,
+      completedAt: now2(),
+      responseStatus: response.status,
+      responseBody,
+      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      attempt: 1,
+      status: "failed",
+      startedAt,
+      completedAt: now2(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function dispatchCommand(event, channel) {
+  if (!channel.command)
+    throw new Error(`Channel ${channel.id} has no command config`);
+  const startedAt = now2();
+  const eventJson = JSON.stringify(event);
+  const env = {
+    ...process.env,
+    ...channel.command.env,
+    HASNA_CHANNEL_ID: channel.id,
+    HASNA_EVENT_ID: event.id,
+    HASNA_EVENT_TYPE: event.type,
+    HASNA_EVENT_SOURCE: event.source,
+    HASNA_EVENT_SUBJECT: event.subject ?? "",
+    HASNA_EVENT_SEVERITY: event.severity,
+    HASNA_EVENT_TIME: event.time,
+    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
+    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
+    HASNA_EVENT_JSON: eventJson
+  };
+  return new Promise((resolve6) => {
+    const child = spawn(channel.command.command, channel.command.args ?? [], {
+      cwd: channel.command.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
+    child.stdin.end(eventJson);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve6({
+        attempt: 1,
+        status: "failed",
+        startedAt,
+        completedAt: now2(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: error.message
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      const success = code === 0;
+      resolve6({
+        attempt: 1,
+        status: success ? "success" : "failed",
+        startedAt,
+        completedAt: now2(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+      });
+    });
+  });
+}
+async function dispatchChannel(event, channel, options = {}) {
+  if (channel.transport === "webhook")
+    return dispatchWebhook(event, channel, options);
+  if (channel.transport === "command")
+    return dispatchCommand(event, channel);
+  return {
+    attempt: 1,
+    status: "skipped",
+    startedAt: now2(),
+    completedAt: now2(),
+    error: `Unsupported transport: ${channel.transport}`
+  };
+}
+function createDeliveryResult(event, channel, attempts) {
+  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
+  return {
+    id: randomUUID2(),
+    eventId: event.id,
+    channelId: channel.id,
+    transport: channel.transport,
+    status,
+    attempts,
+    createdAt: attempts[0]?.startedAt ?? now2(),
+    completedAt: attempts.at(-1)?.completedAt ?? now2()
+  };
+}
+function createEvent(input) {
+  return {
+    id: input.id ?? randomUUID22(),
+    source: input.source,
+    type: input.type,
+    time: normalizeTime(input.time),
+    subject: input.subject,
+    severity: input.severity ?? "info",
+    data: input.data ?? {},
+    message: input.message,
+    dedupeKey: input.dedupeKey,
+    schemaVersion: input.schemaVersion ?? "1.0",
+    metadata: input.metadata ?? {}
+  };
+}
+
+class EventsClient {
+  store;
+  redactors;
+  transportOptions;
+  constructor(options = {}) {
+    this.store = options.store ?? new JsonEventsStore(options.dataDir);
+    this.redactors = options.redactors ?? [];
+    this.transportOptions = { fetchImpl: options.fetchImpl };
+  }
+  async addChannel(input) {
+    const timestamp = new Date().toISOString();
+    return this.store.addChannel({
+      ...input,
+      createdAt: input.createdAt ?? timestamp,
+      updatedAt: input.updatedAt ?? timestamp
+    });
+  }
+  async listChannels() {
+    return this.store.listChannels();
+  }
+  async removeChannel(id) {
+    return this.store.removeChannel(id);
+  }
+  async emit(input, options = {}) {
+    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
+    if (options.dedupe !== false) {
+      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return { event: existing, deliveries: [], deduped: true };
+      }
+    }
+    await this.store.appendEvent(event);
+    const deliveries = options.deliver === false ? [] : await this.deliver(event);
+    return { event, deliveries, deduped: false };
+  }
+  async listEvents() {
+    return this.store.listEvents();
+  }
+  async listDeliveries() {
+    return this.store.listDeliveries();
+  }
+  async deliver(event) {
+    const channels = await this.store.listChannels();
+    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
+    const deliveries = [];
+    for (const channel of selected) {
+      const eventForChannel = await this.applyRedaction(event, channel);
+      const result = await this.deliverWithRetry(eventForChannel, channel);
+      await this.store.appendDelivery(result);
+      deliveries.push(result);
+    }
+    return deliveries;
+  }
+  async matchChannel(id, input = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const event = createEvent({
+      source: input.source ?? "hasna.events",
+      type: input.type ?? "events.test",
+      subject: input.subject ?? id,
+      severity: input.severity ?? "info",
+      data: input.data ?? { test: true },
+      message: input.message ?? "Hasna events test delivery",
+      dedupeKey: input.dedupeKey,
+      schemaVersion: input.schemaVersion,
+      metadata: input.metadata,
+      time: input.time,
+      id: input.id
+    });
+    const matched = channelMatchesEvent(channel, event);
+    return {
+      channelId: channel.id,
+      matched,
+      event,
+      filters: channel.filters,
+      reason: matched ? undefined : channel.enabled ? "event did not match channel filters" : "channel is disabled"
+    };
+  }
+  async testChannel(id, input = {}, options = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const match = await this.matchChannel(id, input);
+    const event = match.event;
+    if (options.honorFilters && !match.matched) {
+      const timestamp = new Date().toISOString();
+      const result2 = createDeliveryResult(event, channel, [{
+        attempt: 1,
+        status: "skipped",
+        startedAt: timestamp,
+        completedAt: timestamp,
+        error: match.reason
+      }]);
+      result2.metadata = { reason: "filter_mismatch" };
+      await this.store.appendDelivery(result2);
+      return result2;
+    }
+    const eventForChannel = await this.applyRedaction(event, channel);
+    const result = await this.deliverWithRetry(eventForChannel, channel);
+    await this.store.appendDelivery(result);
+    return result;
+  }
+  async replay(options = {}) {
+    const events = (await this.store.listEvents()).filter((event) => {
+      if (options.eventId && event.id !== options.eventId)
+        return false;
+      if (options.source && event.source !== options.source)
+        return false;
+      if (options.type && event.type !== options.type)
+        return false;
+      return true;
+    });
+    if (options.dryRun)
+      return { events, deliveries: [] };
+    const deliveries = [];
+    for (const event of events) {
+      deliveries.push(...await this.deliver(event));
+    }
+    return { events, deliveries };
+  }
+  async applyRedaction(event, channel) {
+    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
+    for (const redactor of this.redactors) {
+      next = await redactor(next, channel);
+    }
+    return next;
+  }
+  async deliverWithRetry(event, channel) {
+    const policy = normalizeRetryPolicy(channel.retry);
+    const attempts = [];
+    for (let index = 0;index < policy.maxAttempts; index += 1) {
+      const attempt = await dispatchChannel(event, channel, this.transportOptions);
+      attempt.attempt = index + 1;
+      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
+        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
+      }
+      attempts.push(attempt);
+      if (attempt.status !== "failed")
+        break;
+      if (attempt.nextBackoffMs)
+        await Bun.sleep(attempt.nextBackoffMs);
+    }
+    return createDeliveryResult(event, channel, attempts);
+  }
+}
+function redactPaths(event, paths, replacement = "[REDACTED]") {
+  if (paths.length === 0)
+    return event;
+  const copy = structuredClone(event);
+  for (const path of paths) {
+    setPath(copy, path, replacement);
+  }
+  return copy;
+}
+function redactSensitiveKeys(event, replacement = "[REDACTED]") {
+  return redactValue2(event, replacement);
+}
+function shouldRedactKey(key) {
+  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+}
+function redactValue2(value, replacement) {
+  if (Array.isArray(value))
+    return value.map((item) => redactValue2(item, replacement));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    shouldRedactKey(key) ? replacement : redactValue2(item, replacement)
+  ]));
+}
+function setPath(input, path, replacement) {
+  const parts = path.split(".");
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object")
+      return;
+    cursor = next;
+  }
+  const last = parts.at(-1);
+  if (last && last in cursor)
+    cursor[last] = replacement;
+}
+function normalizeTime(value) {
+  if (!value)
+    return new Date().toISOString();
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeRetryPolicy(policy) {
+  return {
+    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
+    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
+    multiplier: Math.max(1, policy?.multiplier ?? 2)
+  };
+}
+
+// src/lib/shared-events.ts
+init_database();
+
+// src/db/task-lists.ts
+init_types();
+init_database();
+function rowToTaskList(row) {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function createTaskList(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const slug = input.slug || slugify(input.name);
+  if (!input.project_id) {
+    const existing = d.query("SELECT id FROM task_lists WHERE project_id IS NULL AND slug = ?").get(slug);
+    if (existing) {
+      throw new Error(`Standalone task list with slug "${slug}" already exists`);
+    }
+  }
+  d.run(`INSERT INTO task_lists (id, project_id, slug, name, description, metadata, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.project_id || null, slug, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp, timestamp]);
+  return getTaskList(id, d);
+}
+function getTaskList(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM task_lists WHERE id = ?").get(id);
+  return row ? rowToTaskList(row) : null;
+}
+function getTaskListBySlug(slug, projectId, db) {
+  const d = db || getDatabase();
+  let row;
+  if (projectId) {
+    row = d.query("SELECT * FROM task_lists WHERE slug = ? AND project_id = ?").get(slug, projectId);
+  } else {
+    row = d.query("SELECT * FROM task_lists WHERE slug = ? AND project_id IS NULL").get(slug);
+  }
+  return row ? rowToTaskList(row) : null;
+}
+function listTaskLists(projectId, db) {
+  const d = db || getDatabase();
+  if (projectId) {
+    return d.query("SELECT * FROM task_lists WHERE project_id = ? ORDER BY name").all(projectId).map(rowToTaskList);
+  }
+  return d.query("SELECT * FROM task_lists ORDER BY name").all().map(rowToTaskList);
+}
+function updateTaskList(id, input, db) {
+  const d = db || getDatabase();
+  const existing = getTaskList(id, d);
+  if (!existing)
+    throw new TaskListNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  params.push(id);
+  d.run(`UPDATE task_lists SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getTaskList(id, d);
+}
+function deleteTaskList(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM task_lists WHERE id = ?", [id]).changes > 0;
+}
+function ensureTaskList(name, slug, projectId, db) {
+  const d = db || getDatabase();
+  const existing = getTaskListBySlug(slug, projectId, d);
+  if (existing)
+    return existing;
+  return createTaskList({ name, slug, project_id: projectId }, d);
+}
+
+// src/lib/shared-events.ts
+var SOURCE = "todos";
+function taskEventData(task, extra = {}) {
+  return {
+    id: task.id,
+    task_id: task.id,
+    short_id: task.short_id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    project_id: task.project_id,
+    parent_id: task.parent_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    agent_id: task.agent_id,
+    assigned_to: task.assigned_to,
+    session_id: task.session_id,
+    working_dir: task.working_dir,
+    tags: task.tags,
+    metadata: task.metadata,
+    version: task.version,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+    started_at: task.started_at,
+    completed_at: task.completed_at,
+    due_at: task.due_at,
+    ...extra
+  };
+}
+function taskEventMetadata(task) {
+  const metadata = {
+    package: "@hasna/todos",
+    todos_event_schema_version: 1,
+    task_id: task.id,
+    task_short_id: task.short_id,
+    project_id: task.project_id,
+    task_list_id: task.task_list_id,
+    working_dir: task.working_dir
+  };
+  try {
+    const project = task.project_id ? getProject(task.project_id) : null;
+    const projectPath = project ? readMachineLocalPath(project) ?? project.path : task.working_dir;
+    if (project) {
+      metadata.project_id = project.id;
+      metadata.project_name = project.name;
+      metadata.project_path = projectPath;
+      metadata.project_canonical_path = project.path;
+      metadata.project_default_task_list_slug = project.task_list_id;
+      metadata.root_project_id = inferRootProjectId(project);
+    } else if (projectPath) {
+      metadata.project_path = projectPath;
+      metadata.project_canonical_path = projectPath;
+    }
+    if (projectPath) {
+      metadata.project_kind = classifyProjectKind(projectPath);
+      metadata.project_is_worktree = isWorktreePath(projectPath);
+      if (typeof task.metadata.route_enabled === "boolean") {
+        metadata.route_enabled = task.metadata.route_enabled;
+      }
+      metadata.working_dir = task.working_dir ?? projectPath;
+    }
+    const taskList = task.task_list_id ? getTaskList(task.task_list_id) ?? (project ? getTaskListBySlug(task.task_list_id, project.id) : null) : project?.task_list_id ? getTaskListBySlug(project.task_list_id, project.id) : null;
+    if (taskList) {
+      metadata.task_list_id = taskList.id;
+      metadata.task_list_slug = taskList.slug;
+      metadata.task_list_name = taskList.name;
+      metadata.task_list_project_id = taskList.project_id;
+      metadata.task_list_is_project_default = Boolean(project?.task_list_id && taskList.slug === project.task_list_id);
+    }
+  } catch {}
+  return metadata;
+}
+function classifyProjectKind(path) {
+  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
+}
+function isWorktreePath(path) {
+  return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
+}
+function inferRootProjectId(project) {
+  return isWorktreePath(project.path) ? null : project.id;
+}
+function readMachineLocalPath(project) {
+  const machineId = process.env["TODOS_MACHINE_ID"];
+  if (!machineId)
+    return null;
+  try {
+    const row = getDatabase().query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(project.id, machineId);
+    return row?.path ?? null;
+  } catch {
+    return null;
+  }
+}
+async function emitSharedTaskEvent(input) {
+  const data = taskEventData(input.task, input.data);
+  await new EventsClient().emit({
+    source: SOURCE,
+    type: input.type,
+    subject: input.task.id,
+    severity: input.severity ?? "info",
+    message: input.message ?? `${input.type}: ${input.task.title}`,
+    data,
+    dedupeKey: input.dedupeKey ?? `${input.type}:${input.task.id}:${input.task.version}`,
+    metadata: taskEventMetadata(input.task)
+  }, { deliver: true, dedupe: true });
+}
+function emitSharedTaskEventQuiet(input) {
+  emitSharedTaskEvent(input).catch(() => {
+    return;
+  });
+}
+
 // src/db/audit.ts
 init_database();
 function logTaskChange(taskId, action, field2, oldValue, newValue, agentId, db) {
@@ -7078,7 +7886,7 @@ async function deliverWebhook(wh, event, body, attempt, db) {
     activeDeliveries--;
   }
 }
-async function dispatchWebhook(event, payload, db) {
+async function dispatchWebhook2(event, payload, db) {
   const d = db || getDatabase();
   const webhooks = listWebhooks(d).filter((w) => w.active && (w.events.length === 0 || w.events.includes(event)));
   const payloadObj = typeof payload === "object" && payload !== null ? payload : {};
@@ -7232,7 +8040,10 @@ function createTask(input, db) {
     insertTaskTags(id, tags, d);
   }
   const task = getTask(id, d);
-  dispatchWebhook("task.created", { id: task.id, short_id: task.short_id, title: task.title, status: task.status, priority: task.priority, project_id: task.project_id, assigned_to: task.assigned_to }, d).catch(() => {});
+  const payload = taskEventData(task);
+  dispatchWebhook2("task.created", payload, d).catch(() => {});
+  emitLocalEventHooksQuiet({ type: "task.created", payload });
+  emitSharedTaskEventQuiet({ type: "task.created", task });
   return task;
 }
 function getTask(id, db) {
@@ -7576,18 +8387,7 @@ function updateTask(id, input, db) {
     logTaskChange(id, "update", "assigned_to", task.assigned_to, input.assigned_to, agentId, d);
   if (input.approved_by !== undefined)
     logTaskChange(id, "approve", "approved_by", null, input.approved_by, agentId, d);
-  if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to) {
-    dispatchWebhook("task.assigned", { id, assigned_to: input.assigned_to, title: task.title }, d).catch(() => {});
-    emitLocalEventHooksQuiet({ type: "task.assigned", payload: { id, assigned_to: input.assigned_to, title: task.title } });
-  }
-  if (input.status !== undefined && input.status !== task.status) {
-    dispatchWebhook("task.status_changed", { id, old_status: task.status, new_status: input.status, title: task.title }, d).catch(() => {});
-    emitLocalEventHooksQuiet({ type: "task.status_changed", payload: { id, old_status: task.status, new_status: input.status, title: task.title } });
-  }
-  if (input.approved_by !== undefined) {
-    emitLocalEventHooksQuiet({ type: "approval.decided", payload: { id, approved_by: input.approved_by, title: task.title } });
-  }
-  return {
+  const updatedTask = {
     ...task,
     ...Object.fromEntries(Object.entries(input).filter(([, v]) => v !== undefined)),
     tags: input.tags ?? task.tags,
@@ -7605,6 +8405,22 @@ function updateTask(id, input, db) {
     approved_by: input.approved_by ?? task.approved_by,
     approved_at: input.approved_by ? timestamp : task.approved_at
   };
+  if (input.assigned_to !== undefined && input.assigned_to !== task.assigned_to) {
+    const payload = taskEventData(updatedTask, { assigned_to: input.assigned_to, old_assigned_to: task.assigned_to });
+    dispatchWebhook2("task.assigned", payload, d).catch(() => {});
+    emitLocalEventHooksQuiet({ type: "task.assigned", payload });
+    emitSharedTaskEventQuiet({ type: "task.assigned", task: updatedTask, data: { old_assigned_to: task.assigned_to } });
+  }
+  if (input.status !== undefined && input.status !== task.status) {
+    const payload = taskEventData(updatedTask, { old_status: task.status, new_status: input.status });
+    dispatchWebhook2("task.status_changed", payload, d).catch(() => {});
+    emitLocalEventHooksQuiet({ type: "task.status_changed", payload });
+    emitSharedTaskEventQuiet({ type: "task.status_changed", task: updatedTask, data: { old_status: task.status, new_status: input.status } });
+  }
+  if (input.approved_by !== undefined) {
+    emitLocalEventHooksQuiet({ type: "approval.decided", payload: { id, approved_by: input.approved_by, title: task.title } });
+  }
+  return updatedTask;
 }
 function deleteTask(id, db) {
   const d = db || getDatabase();
@@ -8337,9 +9153,12 @@ function startTask(id, agentId, db) {
     throw new Error(`Task ${id} could not be started because it changed during claim`);
   }
   logTaskChange(id, "start", "status", "pending", "in_progress", agentId, d);
-  dispatchWebhook("task.started", { id, agent_id: agentId, title: task.title }, d).catch(() => {});
-  emitLocalEventHooksQuiet({ type: "task.started", payload: { id, agent_id: agentId, title: task.title } });
-  return { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp, started_at: task.started_at || timestamp, version: task.version + 1, updated_at: timestamp };
+  const startedTask = { ...task, status: "in_progress", assigned_to: agentId, locked_by: agentId, locked_at: timestamp, started_at: task.started_at || timestamp, version: task.version + 1, updated_at: timestamp };
+  const payload = taskEventData(startedTask, { agent_id: agentId });
+  dispatchWebhook2("task.started", payload, d).catch(() => {});
+  emitLocalEventHooksQuiet({ type: "task.started", payload });
+  emitSharedTaskEventQuiet({ type: "task.started", task: startedTask, data: { agent_id: agentId } });
+  return startedTask;
 }
 function completeTask(id, agentId, db, options) {
   const d = db || getDatabase();
@@ -8375,8 +9194,21 @@ function completeTask(id, agentId, db, options) {
   });
   tx();
   logTaskChange(id, "complete", "status", task.status, "completed", agentId || null, d);
-  dispatchWebhook("task.completed", { id, agent_id: agentId, title: task.title, completed_at: timestamp }, d).catch(() => {});
-  emitLocalEventHooksQuiet({ type: "task.completed", payload: { id, agent_id: agentId, title: task.title, completed_at: timestamp } });
+  const completedTaskForEvent = {
+    ...task,
+    status: "completed",
+    locked_by: null,
+    locked_at: null,
+    completed_at: timestamp,
+    confidence,
+    version: task.version + 1,
+    updated_at: timestamp,
+    metadata: hasMeta ? { ...task.metadata, ...completionMeta } : task.metadata
+  };
+  const completionPayload = taskEventData(completedTaskForEvent, { agent_id: agentId, completed_at: timestamp });
+  dispatchWebhook2("task.completed", completionPayload, d).catch(() => {});
+  emitLocalEventHooksQuiet({ type: "task.completed", payload: completionPayload });
+  emitSharedTaskEventQuiet({ type: "task.completed", task: completedTaskForEvent, data: { agent_id: agentId, completed_at: timestamp } });
   let spawnedTask = null;
   if (task.recurrence_rule && !options?.skip_recurrence) {
     spawnedTask = spawnNextRecurrence(task, d, timestamp);
@@ -8417,8 +9249,12 @@ function completeTask(id, agentId, db, options) {
   if (unblockedDeps.length > 0) {
     meta._unblocked = unblockedDeps.map((d2) => ({ id: d2.id, short_id: d2.short_id, title: d2.title }));
     for (const dep of unblockedDeps) {
-      dispatchWebhook("task.unblocked", { id: dep.id, unblocked_by: id, title: dep.title }, d).catch(() => {});
-      emitLocalEventHooksQuiet({ type: "task.unblocked", payload: { id: dep.id, unblocked_by: id, title: dep.title } });
+      const depTask = getTask(dep.id, d);
+      const payload = depTask ? taskEventData(depTask, { unblocked_by: id }) : { id: dep.id, unblocked_by: id, title: dep.title };
+      dispatchWebhook2("task.unblocked", payload, d).catch(() => {});
+      emitLocalEventHooksQuiet({ type: "task.unblocked", payload });
+      if (depTask)
+        emitSharedTaskEventQuiet({ type: "task.unblocked", task: depTask, data: { unblocked_by: id } });
     }
   }
   return { ...task, status: "completed", locked_by: null, locked_at: null, completed_at: timestamp, confidence, version: task.version + 1, updated_at: timestamp, metadata: meta };
@@ -8604,9 +9440,6 @@ function failTask(id, agentId, reason, options, db) {
   const timestamp = now();
   d.run(`UPDATE tasks SET status = 'failed', locked_by = NULL, locked_at = NULL, metadata = ?, version = version + 1, updated_at = ?
      WHERE id = ?`, [JSON.stringify(meta), timestamp, id]);
-  logTaskChange(id, "fail", "status", task.status, "failed", agentId || null, d);
-  dispatchWebhook("task.failed", { id, reason, error_code: options?.error_code, agent_id: agentId, title: task.title }, d).catch(() => {});
-  emitLocalEventHooksQuiet({ type: "task.failed", payload: { id, reason, error_code: options?.error_code, agent_id: agentId, title: task.title } });
   const failedTask = {
     ...task,
     status: "failed",
@@ -8616,6 +9449,11 @@ function failTask(id, agentId, reason, options, db) {
     version: task.version + 1,
     updated_at: timestamp
   };
+  logTaskChange(id, "fail", "status", task.status, "failed", agentId || null, d);
+  const failurePayload = taskEventData(failedTask, { reason, error_code: options?.error_code, agent_id: agentId });
+  dispatchWebhook2("task.failed", failurePayload, d).catch(() => {});
+  emitLocalEventHooksQuiet({ type: "task.failed", payload: failurePayload });
+  emitSharedTaskEventQuiet({ type: "task.failed", task: failedTask, data: { reason, error_code: options?.error_code, agent_id: agentId }, severity: "warning" });
   let retryTask;
   if (options?.retry) {
     const retryCount = (task.retry_count || 0) + 1;
@@ -8690,9 +9528,12 @@ function stealTask(agentId, opts, db) {
     return null;
   logTaskChange(target.id, "steal", "assigned_to", target.assigned_to, agentId, agentId, d);
   logTaskChange(target.id, "steal", "locked_by", target.locked_by, agentId, agentId, d);
-  dispatchWebhook("task.assigned", { id: target.id, agent_id: agentId, title: target.title, stolen_from: target.assigned_to }, d).catch(() => {});
-  emitLocalEventHooksQuiet({ type: "task.assigned", payload: { id: target.id, agent_id: agentId, title: target.title, stolen_from: target.assigned_to } });
-  return { ...target, assigned_to: agentId, locked_by: agentId, locked_at: timestamp, updated_at: timestamp, version: target.version + 1 };
+  const stolenTask = { ...target, assigned_to: agentId, locked_by: agentId, locked_at: timestamp, updated_at: timestamp, version: target.version + 1 };
+  const payload = taskEventData(stolenTask, { agent_id: agentId, stolen_from: target.assigned_to });
+  dispatchWebhook2("task.assigned", payload, d).catch(() => {});
+  emitLocalEventHooksQuiet({ type: "task.assigned", payload });
+  emitSharedTaskEventQuiet({ type: "task.assigned", task: stolenTask, data: { agent_id: agentId, stolen_from: target.assigned_to } });
+  return stolenTask;
 }
 function claimOrSteal(agentId, filters, db) {
   const d = db || getDatabase();
@@ -9751,8 +10592,8 @@ init_database();
 init_database();
 init_redaction();
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname as dirname5, join as join5, resolve as resolve6 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname as dirname5, join as join6, resolve as resolve6 } from "path";
 import { tmpdir } from "os";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
@@ -9764,15 +10605,15 @@ function artifactStoreRoot() {
     return resolve6(process.env["TODOS_ARTIFACTS_DIR"]);
   const dbPath = getDatabasePath();
   if (isInMemoryDb2(dbPath))
-    return join5(tmpdir(), "hasna-todos-artifacts");
-  return join5(dirname5(resolve6(dbPath)), "artifacts");
+    return join6(tmpdir(), "hasna-todos-artifacts");
+  return join6(dirname5(resolve6(dbPath)), "artifacts");
 }
 function artifactStorePath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
   if (normalized.includes("..") || normalized.startsWith("/") || normalized.length === 0) {
     throw new Error("Invalid artifact store path");
   }
-  return join5(artifactStoreRoot(), normalized);
+  return join6(artifactStoreRoot(), normalized);
 }
 function sha256(buffer) {
   return createHash2("sha256").update(buffer).digest("hex");
@@ -9813,7 +10654,7 @@ function mediaTypeFor(path, textLike) {
 }
 function storeArtifactContent(input) {
   const sourcePath = resolve6(input.path);
-  if (!existsSync7(sourcePath))
+  if (!existsSync8(sourcePath))
     return null;
   const sourceStat = statSync2(sourcePath);
   if (!sourceStat.isFile())
@@ -9830,9 +10671,9 @@ function storeArtifactContent(input) {
       redactionStatus = "redacted";
   }
   const storedSha = sha256(storedBuffer);
-  const relativePath = join5("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
+  const relativePath = join6("sha256", storedSha.slice(0, 2), storedSha).replace(/\\/g, "/");
   const destination = artifactStorePath(relativePath);
-  if (!existsSync7(destination)) {
+  if (!existsSync8(destination)) {
     mkdirSync4(dirname5(destination), { recursive: true });
     writeFileSync2(destination, storedBuffer);
   }
@@ -9892,7 +10733,7 @@ function verifyStoredArtifact(input) {
     };
   }
   const storedPath = artifactStorePath(store.relative_path);
-  if (!existsSync7(storedPath)) {
+  if (!existsSync8(storedPath)) {
     return {
       id: input.id,
       path: input.path,
@@ -9973,15 +10814,15 @@ function getArtifactStoreRoot(dbPath) {
     return resolve6(process.env["TODOS_ARTIFACTS_DIR"]);
   const path = dbPath ?? getDatabasePath();
   if (isInMemoryDb2(path))
-    return join5(tmpdir(), "hasna-todos-artifacts");
-  return join5(dirname5(resolve6(path)), "artifacts");
+    return join6(tmpdir(), "hasna-todos-artifacts");
+  return join6(dirname5(resolve6(path)), "artifacts");
 }
 function computeContentHash(path) {
   return sha256(readFileSync4(resolve6(path)));
 }
 function storeArtifactFile(input) {
   const sourcePath = resolve6(input.sourcePath);
-  if (!existsSync7(sourcePath)) {
+  if (!existsSync8(sourcePath)) {
     throw new Error(`Source file not found: ${input.sourcePath}`);
   }
   if (!statSync2(sourcePath).isFile()) {
@@ -9994,7 +10835,7 @@ function storeArtifactFile(input) {
   let localPath = sourcePath;
   if (storageMode === "copy") {
     const fileName = input.name && input.name.trim().length > 0 ? basename(input.name) : basename(sourcePath);
-    const destination = join5(getArtifactStoreRoot(input.dbPath), input.artifactId, fileName);
+    const destination = join6(getArtifactStoreRoot(input.dbPath), input.artifactId, fileName);
     mkdirSync4(dirname5(destination), { recursive: true });
     writeFileSync2(destination, buffer);
     localPath = destination;
@@ -10004,7 +10845,7 @@ function storeArtifactFile(input) {
 function deleteStoredArtifactFile(localPath, storageMode, _dbPath2) {
   if (storageMode === "reference")
     return false;
-  if (!localPath || !existsSync7(localPath))
+  if (!localPath || !existsSync8(localPath))
     return false;
   rmSync(localPath, { force: true });
   try {
@@ -10016,8 +10857,8 @@ function isArtifactExpired(deletedAt, policy = {}) {
   if (!deletedAt)
     return false;
   const retentionDays = policy.deleted_retention_days ?? DEFAULT_DELETED_RETENTION_DAYS;
-  const now2 = policy.now ?? new Date;
-  const ageMs = now2.getTime() - new Date(deletedAt).getTime();
+  const now3 = policy.now ?? new Date;
+  const ageMs = now3.getTime() - new Date(deletedAt).getTime();
   return ageMs > retentionDays * 24 * 60 * 60 * 1000;
 }
 function buildArtifactExportManifest(artifacts, dbPath) {
@@ -11092,7 +11933,7 @@ function rowToTask2(row) {
     requires_approval: Boolean(row.requires_approval)
   };
 }
-function rowToTaskList(row) {
+function rowToTaskList2(row) {
   return { ...row, metadata: parseJsonObject3(row.metadata) };
 }
 function rowWithMetadata(row) {
@@ -11128,7 +11969,7 @@ function createLocalBridgeBundle(options = {}, db) {
   const project = options.project_id ? d.query("SELECT * FROM projects WHERE id = ?").get(options.project_id) : null;
   const data = redactValue({
     projects: options.project_id ? project ? [project] : [] : d.query("SELECT * FROM projects ORDER BY name").all(),
-    task_lists: (options.project_id ? d.query("SELECT * FROM task_lists WHERE project_id = ? ORDER BY name").all(options.project_id) : d.query("SELECT * FROM task_lists ORDER BY name").all()).map(rowToTaskList),
+    task_lists: (options.project_id ? d.query("SELECT * FROM task_lists WHERE project_id = ? ORDER BY name").all(options.project_id) : d.query("SELECT * FROM task_lists ORDER BY name").all()).map(rowToTaskList2),
     plans: options.project_id ? d.query("SELECT * FROM plans WHERE project_id = ? ORDER BY created_at").all(options.project_id) : d.query("SELECT * FROM plans ORDER BY created_at").all(),
     tasks: queryByTaskIds(d, "SELECT * FROM tasks WHERE id IN (__TASK_IDS__) ORDER BY created_at", taskIds).map(rowToTask2),
     task_dependencies: queryByTaskIds(d, "SELECT task_id, depends_on, external_project_id, external_task_id FROM task_dependencies WHERE task_id IN (__TASK_IDS__) ORDER BY task_id, depends_on", taskIds),
@@ -11783,7 +12624,7 @@ function writeOnboardingFixtureFiles(directory) {
   mkdirSync5(directory, { recursive: true });
   const files = [];
   for (const fixture of allFixtures()) {
-    const path = join6(directory, `${fixture.summary.name}.bridge.json`);
+    const path = join7(directory, `${fixture.summary.name}.bridge.json`);
     writeFileSync3(path, `${JSON.stringify(fixture.bundle, null, 2)}
 `, "utf-8");
     files.push(path);
@@ -12609,7 +13450,7 @@ function renderLocalSnapshotMarkdown(snapshot) {
 }
 // src/lib/sdk-integration-fixtures.ts
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/cli-mcp-parity.ts
 function source4(version) {
@@ -13919,7 +14760,7 @@ function limits(input) {
     stale_after_hours: clamp(input.stale_after_hours, DEFAULT_LIMITS.stale_after_hours, 24 * 365)
   };
 }
-function truncate(value, max) {
+function truncate2(value, max) {
   if (!value)
     return value ?? null;
   const redacted = redactEvidenceText(value);
@@ -13940,9 +14781,9 @@ function acceptanceCriteria(task2, maxText) {
   const metadata = task2.metadata || {};
   const raw = metadata["acceptance_criteria"] ?? metadata["acceptanceCriteria"] ?? metadata["criteria"];
   if (Array.isArray(raw))
-    return raw.map((item) => truncate(String(item), maxText)).filter((item) => Boolean(item));
+    return raw.map((item) => truncate2(String(item), maxText)).filter((item) => Boolean(item));
   if (typeof raw === "string") {
-    return raw.split(/\r?\n/).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean).map((line) => truncate(line, maxText)).filter((item) => Boolean(item));
+    return raw.split(/\r?\n/).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean).map((line) => truncate2(line, maxText)).filter((item) => Boolean(item));
   }
   return [];
 }
@@ -13965,7 +14806,7 @@ function addFile(files, path, source5, base) {
     path,
     status: base?.status || "active",
     agent_id: base?.agent_id ?? null,
-    note: truncate(base?.note, 240),
+    note: truncate2(base?.note, 240),
     updated_at: base?.updated_at || "",
     sources: [source5]
   });
@@ -14023,7 +14864,7 @@ function estimateTokens(value) {
   return Math.max(1, Math.ceil((text || "").length / 4));
 }
 function summarizeStrings(values, maxChars) {
-  return truncate(values.filter(Boolean).join("; "), maxChars) || "No local details were available before this section was omitted.";
+  return truncate2(values.filter(Boolean).join("; "), maxChars) || "No local details were available before this section was omitted.";
 }
 function summarizeSection(pack, section, maxChars) {
   if (section === "project")
@@ -14214,8 +15055,8 @@ function createAgentContextPack(input, db) {
     ...taskFiles.map((file) => file.updated_at)
   ], task2.updated_at);
   const warnings = [];
-  const now2 = input.now ? new Date(input.now) : new Date;
-  if (Date.parse(task2.updated_at) < now2.getTime() - limit.stale_after_hours * 60 * 60 * 1000) {
+  const now3 = input.now ? new Date(input.now) : new Date;
+  if (Date.parse(task2.updated_at) < now3.getTime() - limit.stale_after_hours * 60 * 60 * 1000) {
     warnings.push(`task state is older than ${limit.stale_after_hours} hours`);
   }
   if (comments.length > recentComments.length)
@@ -14230,7 +15071,7 @@ function createAgentContextPack(input, db) {
     id: task2.id,
     short_id: task2.short_id,
     title: redactEvidenceText(task2.title),
-    description: truncate(task2.description, limit.max_text_chars),
+    description: truncate2(task2.description, limit.max_text_chars),
     status: task2.status,
     priority: task2.priority,
     assigned_to: task2.assigned_to,
@@ -14254,7 +15095,7 @@ function createAgentContextPack(input, db) {
     plan: plan ? {
       id: plan.id,
       name: plan.name,
-      description: truncate(plan.description, limit.max_text_chars),
+      description: truncate2(plan.description, limit.max_text_chars),
       status: plan.status,
       agent_id: plan.agent_id,
       tasks: planTasks.slice(0, limit.plan_task_limit).map(taskSummary).filter((item) => Boolean(item)),
@@ -14273,7 +15114,7 @@ function createAgentContextPack(input, db) {
         type: comment.type,
         progress_pct: comment.progress_pct,
         created_at: comment.created_at,
-        content: truncate(comment.content, limit.max_text_chars) || ""
+        content: truncate2(comment.content, limit.max_text_chars) || ""
       })),
       omitted: Math.max(0, comments.length - recentComments.length)
     },
@@ -14281,7 +15122,7 @@ function createAgentContextPack(input, db) {
     traceability: {
       commits: traceability.commits.map((commit) => ({
         sha: commit.sha,
-        message: truncate(commit.message, 240),
+        message: truncate2(commit.message, 240),
         files_changed: commit.files_changed,
         committed_at: commit.committed_at
       })),
@@ -14289,7 +15130,7 @@ function createAgentContextPack(input, db) {
       verifications: verifications.map((verification) => ({
         command: verification.command,
         status: verification.status,
-        output_summary: truncate(verification.output_summary, limit.max_text_chars),
+        output_summary: truncate2(verification.output_summary, limit.max_text_chars),
         artifact_path: verification.artifact_path,
         run_at: verification.run_at
       })),
@@ -14300,14 +15141,14 @@ function createAgentContextPack(input, db) {
         id: ledger.run.id,
         title: ledger.run.title,
         status: ledger.run.status,
-        summary: truncate(ledger.run.summary, limit.max_text_chars),
+        summary: truncate2(ledger.run.summary, limit.max_text_chars),
         agent_id: ledger.run.agent_id,
         started_at: ledger.run.started_at,
         completed_at: ledger.run.completed_at,
-        events: ledger.events.map((event) => ({ event_type: event.event_type, message: truncate(event.message, 500), created_at: event.created_at })),
-        commands: ledger.commands.map((command) => ({ command: command.command, status: command.status, output_summary: truncate(command.output_summary, limit.max_text_chars), artifact_path: command.artifact_path })),
-        files: ledger.files.map((file) => ({ path: file.path, status: file.status, note: truncate(file.note, 240) })),
-        artifacts: ledger.artifacts.map((artifact) => ({ path: artifact.path, artifact_type: artifact.artifact_type, description: truncate(artifact.description, 240), sha256: artifact.sha256 }))
+        events: ledger.events.map((event) => ({ event_type: event.event_type, message: truncate2(event.message, 500), created_at: event.created_at })),
+        commands: ledger.commands.map((command) => ({ command: command.command, status: command.status, output_summary: truncate2(command.output_summary, limit.max_text_chars), artifact_path: command.artifact_path })),
+        files: ledger.files.map((file) => ({ path: file.path, status: file.status, note: truncate2(file.note, 240) })),
+        artifacts: ledger.artifacts.map((artifact) => ({ path: artifact.path, artifact_type: artifact.artifact_type, description: truncate2(artifact.description, 240), sha256: artifact.sha256 }))
       })),
       omitted: Math.max(0, runs.length - selectedRuns.length)
     },
@@ -14412,7 +15253,7 @@ function renderAgentContextPackCompactMarkdown(pack) {
   const lines = [
     `# Context: ${pack.task.title}`,
     `${pack.task.status} | ${pack.task.priority} | ${pack.task.short_id || pack.task.id.slice(0, 8)}`,
-    pack.task.description ? truncate(pack.task.description, Math.min(pack.limits.summary_char_limit, 700)) : null,
+    pack.task.description ? truncate2(pack.task.description, Math.min(pack.limits.summary_char_limit, 700)) : null,
     "",
     "## Must Know",
     bullet([
@@ -14558,7 +15399,7 @@ function writeSdkIntegrationFixtures(directory, options = {}) {
   ];
   const written = [];
   for (const [name, payload] of files) {
-    const file = join7(directory, name);
+    const file = join8(directory, name);
     writeFileSync5(file, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
     written.push(file);
@@ -15275,7 +16116,7 @@ function createRoadmap(input) {
   if (!name)
     throw new Error("Roadmap name is required");
   const store = readStore();
-  const now2 = timestamp();
+  const now3 = timestamp();
   const roadmap = {
     id: newId("roadmap"),
     name,
@@ -15286,8 +16127,8 @@ function createRoadmap(input) {
     agent_id: cleanString(input.agent_id),
     release: cleanString(input.release),
     milestone_ids: [],
-    created_at: now2,
-    updated_at: now2
+    created_at: now3,
+    updated_at: now3
   };
   store.roadmaps[roadmap.id] = roadmap;
   writeStore(store);
@@ -15347,7 +16188,7 @@ function createMilestone(input) {
   const title = input.title.trim();
   if (!title)
     throw new Error("Milestone title is required");
-  const now2 = timestamp();
+  const now3 = timestamp();
   const milestone = {
     id: newId("milestone"),
     roadmap_id: roadmapId,
@@ -15362,11 +16203,11 @@ function createMilestone(input) {
     run_ids: cleanList3(input.run_ids),
     release: cleanString(input.release ?? roadmap.release ?? undefined),
     tags: cleanList3(input.tags),
-    created_at: now2,
-    updated_at: now2
+    created_at: now3,
+    updated_at: now3
   };
   store.milestones[milestone.id] = milestone;
-  store.roadmaps[roadmapId] = { ...roadmap, milestone_ids: cleanList3([...roadmap.milestone_ids, milestone.id]), updated_at: now2 };
+  store.roadmaps[roadmapId] = { ...roadmap, milestone_ids: cleanList3([...roadmap.milestone_ids, milestone.id]), updated_at: now3 };
   writeStore(store);
   return milestone;
 }
@@ -15426,7 +16267,7 @@ function upsertReleaseGroup(input) {
     throw new Error("Release group name is required");
   const key = releaseKey(roadmapId, name);
   const existing = store.releases[key];
-  const now2 = timestamp();
+  const now3 = timestamp();
   const release = {
     name,
     version: input.version === undefined ? existing?.version ?? null : cleanString(input.version),
@@ -15437,8 +16278,8 @@ function upsertReleaseGroup(input) {
     plan_ids: input.plan_ids === undefined ? existing?.plan_ids ?? [] : cleanList3(input.plan_ids),
     run_ids: input.run_ids === undefined ? existing?.run_ids ?? [] : cleanList3(input.run_ids),
     notes: input.notes === undefined ? existing?.notes ?? null : cleanString(input.notes),
-    created_at: existing?.created_at ?? now2,
-    updated_at: now2
+    created_at: existing?.created_at ?? now3,
+    updated_at: now3
   };
   store.releases[key] = release;
   writeStore(store);
@@ -15829,7 +16670,7 @@ function renderLocalAuditLedgerMarkdown(ledger) {
 init_migrations();
 init_schema();
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join8, resolve as resolve8 } from "path";
+import { join as join9, resolve as resolve8 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 var LOCAL_RELEASE_COMPATIBILITY_SCHEMA_VERSION = 1;
 var EXPECTED_PACKAGE_NAME = "@hasna/todos";
@@ -15875,7 +16716,7 @@ function warn(id, message, details) {
   return { id, status: "warning", message, details };
 }
 function readPackageJson(root) {
-  return JSON.parse(readFileSync6(join8(root, "package.json"), "utf8"));
+  return JSON.parse(readFileSync6(join9(root, "package.json"), "utf8"));
 }
 function sortedKeys(value) {
   return Object.keys(value ?? {}).sort((left, right) => left.localeCompare(right));
@@ -17287,6 +18128,470 @@ function importExternalIssues(input, db) {
     ]
   };
 }
+// src/lib/tester-issue-reports.ts
+init_database();
+import { createHash as createHash7 } from "crypto";
+init_redaction();
+var TESTERS_ISSUE_REPORT_SCHEMA_VERSION = "testers.issue_report.v1";
+var TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION = "todos.tester_issue_report_result.v1";
+var TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION = "todos.tester_issue_report_batch_result.v1";
+var PRIORITIES3 = ["low", "medium", "high", "critical"];
+var SEVERITIES = new Set(PRIORITIES3);
+var KINDS = new Set([
+  "assertion_failure",
+  "runtime_error",
+  "console_error",
+  "network_error",
+  "visual_regression",
+  "accessibility",
+  "performance",
+  "broken_link",
+  "security",
+  "unknown"
+]);
+function asObject3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString3(value) {
+  if (typeof value === "string" && value.trim())
+    return value.trim();
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  return null;
+}
+function stringArray(value, limit = 20) {
+  if (!Array.isArray(value))
+    return [];
+  return [...new Set(value.map((item) => asString3(item)).filter((item) => Boolean(item)))].slice(0, limit);
+}
+function objectArray(value, limit = 20) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map(asObject3).filter((item) => Object.keys(item).length > 0).slice(0, limit);
+}
+function cleanKey(value) {
+  return value.toLowerCase().trim().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function truncate3(value, max) {
+  if (!value)
+    return;
+  const redacted = redactEvidenceText(value).trim();
+  if (!redacted)
+    return;
+  return redacted.length > max ? `${redacted.slice(0, max - 3)}...` : redacted;
+}
+function normalizeText2(value) {
+  return (value || "").toLowerCase().replace(/https?:\/\/\S+/g, " ").replace(/[`"'()[\]{}.,:;!?/#\\_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeUrlPattern(value) {
+  if (!value)
+    return "";
+  try {
+    const url = new URL(value);
+    return `${url.origin.toLowerCase()}${url.pathname.replace(/\/+$/, "") || "/"}`;
+  } catch {
+    return value.split(/[?#]/, 1)[0].replace(/\/+$/, "").toLowerCase();
+  }
+}
+function normalizeKind(value) {
+  const raw = cleanKey(asString3(value) || "unknown").replace(/-/g, "_");
+  return KINDS.has(raw) ? raw : raw || "unknown";
+}
+function normalizeSeverity(value, fallback) {
+  const raw = cleanKey(asString3(value) || fallback);
+  if (SEVERITIES.has(raw))
+    return raw;
+  if (/^(p0|blocker|urgent|highest)$/.test(raw))
+    return "critical";
+  if (/^(p1|major)$/.test(raw))
+    return "high";
+  if (/^(p3|minor|info)$/.test(raw))
+    return "low";
+  return fallback;
+}
+function reportSource(input) {
+  const source6 = asObject3(input["source"]);
+  const normalized = {
+    tool: asString3(source6["tool"]) || asString3(input["tool"]) || "testers",
+    run_id: asString3(source6["run_id"]) || asString3(input["run_id"]) || undefined,
+    result_id: asString3(source6["result_id"]) || asString3(input["result_id"]) || undefined,
+    scenario_id: asString3(source6["scenario_id"]) || asString3(input["scenario_id"]) || undefined,
+    scenario_name: asString3(source6["scenario_name"]) || asString3(input["scenario_name"]) || undefined,
+    project_id: asString3(source6["project_id"]) || asString3(input["project_id"]) || undefined,
+    url: asString3(source6["url"]) || asString3(input["url"]) || undefined,
+    page_url: asString3(source6["page_url"]) || asString3(input["page_url"]) || undefined,
+    artifact_url: asString3(source6["artifact_url"]) || undefined,
+    screenshot_url: asString3(source6["screenshot_url"]) || undefined,
+    commit: asString3(source6["commit"]) || undefined,
+    branch: asString3(source6["branch"]) || undefined
+  };
+  return Object.values(normalized).some(Boolean) ? normalized : undefined;
+}
+function reportTarget(input) {
+  const target = asObject3(input["target"]);
+  const normalized = {
+    url: asString3(target["url"]) || asString3(input["target_url"]) || undefined,
+    route: asString3(target["route"]) || undefined,
+    selector: asString3(target["selector"]) || undefined,
+    component: asString3(target["component"]) || undefined,
+    browser: asString3(target["browser"]) || undefined,
+    viewport: asString3(target["viewport"]) || undefined
+  };
+  return Object.values(normalized).some(Boolean) ? normalized : undefined;
+}
+function reportFailure(input) {
+  const failure = asObject3(input["failure"]);
+  const steps = stringArray(failure["steps"] ?? input["steps"], 50);
+  const normalized = {
+    message: truncate3(asString3(failure["message"]) || asString3(input["error"]) || asString3(input["message"]), 1000),
+    expected: truncate3(asString3(failure["expected"]), 1000),
+    actual: truncate3(asString3(failure["actual"]), 1000),
+    stack: truncate3(asString3(failure["stack"]) || asString3(input["stack"]), 3000),
+    reasoning: truncate3(asString3(failure["reasoning"]) || asString3(input["reasoning"]), 1500),
+    steps: steps.length > 0 ? steps.map((step) => truncate3(step, 400)).filter(Boolean) : undefined
+  };
+  return Object.values(normalized).some(Boolean) ? normalized : undefined;
+}
+function artifactArray(value) {
+  return objectArray(value, 12).map((item) => ({
+    kind: asString3(item["kind"]) || undefined,
+    label: asString3(item["label"]) || asString3(item["name"]) || undefined,
+    path: asString3(item["path"]) || asString3(item["file_path"]) || undefined,
+    url: asString3(item["url"]) || undefined
+  })).filter((item) => item.kind || item.label || item.path || item.url);
+}
+function reportEvidence(input) {
+  const evidence = asObject3(input["evidence"]);
+  const logs = stringArray(evidence["logs"], 8).map((log) => truncate3(log, 1000)).filter(Boolean);
+  const screenshots = artifactArray(evidence["screenshots"] ?? input["screenshots"]);
+  const artifacts = artifactArray(evidence["artifacts"] ?? input["artifacts"]);
+  const normalized = {
+    logs: logs.length > 0 ? logs : undefined,
+    screenshots: screenshots.length > 0 ? screenshots : undefined,
+    artifacts: artifacts.length > 0 ? artifacts : undefined
+  };
+  return Object.values(normalized).some(Boolean) ? normalized : undefined;
+}
+function normalizeTesterIssueReport(value, fallbackPriority = "medium") {
+  const input = asObject3(value);
+  if (input["schema_version"] !== TESTERS_ISSUE_REPORT_SCHEMA_VERSION) {
+    throw new Error(`Expected schema_version ${TESTERS_ISSUE_REPORT_SCHEMA_VERSION}`);
+  }
+  const failure = reportFailure(input);
+  const source6 = reportSource(input);
+  const target = reportTarget(input);
+  const title = truncate3(asString3(input["title"]) || asString3(input["summary"]) || failure?.message || source6?.scenario_name || "Tester issue report", 220);
+  if (!title)
+    throw new Error("Tester issue report requires a title");
+  const labels = [
+    ...stringArray(input["labels"], 20),
+    ...stringArray(input["tags"], 20)
+  ].map(cleanKey).filter(Boolean);
+  const report = {
+    schema_version: TESTERS_ISSUE_REPORT_SCHEMA_VERSION,
+    id: asString3(input["id"]) || undefined,
+    fingerprint: asString3(input["fingerprint"]) || undefined,
+    title,
+    summary: truncate3(asString3(input["summary"]), 1000) ?? null,
+    kind: normalizeKind(input["kind"] ?? input["type"]),
+    severity: normalizeSeverity(input["severity"] ?? input["priority"], fallbackPriority),
+    source: source6,
+    target,
+    failure,
+    evidence: reportEvidence(input),
+    labels: labels.length > 0 ? [...new Set(labels)].slice(0, 20) : undefined,
+    metadata: redactValue(asObject3(input["metadata"])),
+    occurred_at: asString3(input["occurred_at"]) || asString3(input["timestamp"]) || undefined
+  };
+  return redactValue(report);
+}
+function fingerprintTesterIssueReport(report) {
+  if (report.fingerprint)
+    return `testers:${cleanKey(report.fingerprint)}`;
+  const stackTop = report.failure?.stack?.split(/\r?\n/).map((line) => line.trim()).find(Boolean) || "";
+  const url = normalizeUrlPattern(report.target?.url || report.source?.page_url || report.source?.url || "");
+  const raw = [
+    report.kind || "unknown",
+    report.source?.project_id || "",
+    report.source?.scenario_id || report.source?.scenario_name || "",
+    url,
+    report.target?.route || "",
+    report.target?.selector || report.target?.component || "",
+    normalizeText2(report.failure?.message || report.summary || report.title).slice(0, 240),
+    normalizeText2(stackTop).slice(0, 160)
+  ].join("::");
+  return `testers:${createHash7("sha256").update(raw).digest("hex").slice(0, 16)}`;
+}
+function priorityForSeverity(severity, fallback) {
+  return PRIORITIES3.includes(severity) ? severity : fallback;
+}
+function maxPriority(left, right) {
+  return PRIORITIES3.indexOf(right) > PRIORITIES3.indexOf(left) ? right : left;
+}
+function taskTitle2(report) {
+  const title = report.title.replace(/^BUG:\s*/i, "").replace(/^\[testers\]\s*/i, "");
+  return `BUG: [testers] ${title}`.slice(0, 240);
+}
+function evidenceLines(report) {
+  const lines = [];
+  for (const item of report.evidence?.screenshots || []) {
+    lines.push(`Screenshot: ${item.label || item.kind || item.path || item.url}${item.path ? ` (${item.path})` : item.url ? ` (${item.url})` : ""}`);
+  }
+  for (const item of report.evidence?.artifacts || []) {
+    lines.push(`Artifact: ${item.label || item.kind || item.path || item.url}${item.path ? ` (${item.path})` : item.url ? ` (${item.url})` : ""}`);
+  }
+  for (const log of report.evidence?.logs || [])
+    lines.push(`Log: ${log}`);
+  return lines.slice(0, 12);
+}
+function taskDescription2(report, fingerprint2) {
+  const failure = report.failure;
+  const lines = [
+    "Tester issue report.",
+    "",
+    `Schema: ${report.schema_version}`,
+    `Fingerprint: ${fingerprint2}`,
+    `Kind: ${report.kind || "unknown"}`,
+    `Severity: ${report.severity || "medium"}`,
+    report.source?.run_id ? `Run: ${report.source.run_id}` : null,
+    report.source?.result_id ? `Result: ${report.source.result_id}` : null,
+    report.source?.scenario_name || report.source?.scenario_id ? `Scenario: ${report.source.scenario_name || report.source.scenario_id}` : null,
+    report.target?.url || report.source?.page_url || report.source?.url ? `URL: ${report.target?.url || report.source?.page_url || report.source?.url}` : null,
+    report.target?.route ? `Route: ${report.target.route}` : null,
+    report.target?.selector ? `Selector: ${report.target.selector}` : null,
+    report.occurred_at ? `Occurred at: ${report.occurred_at}` : null,
+    "",
+    report.summary ? `Summary:
+${report.summary}` : null,
+    failure?.message ? `Failure:
+${failure.message}` : null,
+    failure?.expected ? `Expected:
+${failure.expected}` : null,
+    failure?.actual ? `Actual:
+${failure.actual}` : null,
+    failure?.reasoning ? `Reasoning:
+${failure.reasoning}` : null,
+    failure?.steps?.length ? `Steps:
+${failure.steps.map((step, index) => `${index + 1}. ${step}`).join(`
+`)}` : null,
+    evidenceLines(report).length ? `Evidence:
+${evidenceLines(report).map((line) => `- ${line}`).join(`
+`)}` : null,
+    failure?.stack ? `Stack:
+${failure.stack}` : null
+  ].filter((line) => line !== null);
+  return lines.join(`
+`).replace(/\n{3,}/g, `
+
+`).slice(0, 6000);
+}
+function taskTags(report) {
+  return [...new Set([
+    "bug",
+    "testers",
+    "tester-report",
+    report.kind ? cleanKey(String(report.kind)).replace(/_/g, "-") : "unknown",
+    ...report.labels || []
+  ].filter(Boolean))].slice(0, 16);
+}
+function storedReportSummary(report) {
+  return {
+    id: report.id ?? null,
+    title: report.title,
+    kind: report.kind ?? "unknown",
+    severity: report.severity ?? "medium",
+    run_id: report.source?.run_id ?? null,
+    result_id: report.source?.result_id ?? null,
+    scenario_id: report.source?.scenario_id ?? null,
+    scenario_name: report.source?.scenario_name ?? null,
+    url: report.target?.url ?? report.source?.page_url ?? report.source?.url ?? null,
+    occurred_at: report.occurred_at ?? null
+  };
+}
+function testerMetadata(report, fingerprint2, previous, timestamp2) {
+  const occurrenceCount = typeof previous?.["occurrence_count"] === "number" ? previous["occurrence_count"] + 1 : 1;
+  const previousRecent = previous?.["recent_reports"];
+  const recent = Array.isArray(previousRecent) ? previousRecent : [];
+  return {
+    schema_version: TESTERS_ISSUE_REPORT_SCHEMA_VERSION,
+    fingerprint: fingerprint2,
+    first_seen_at: asString3(previous?.["first_seen_at"]) || timestamp2,
+    last_seen_at: timestamp2,
+    occurrence_count: occurrenceCount,
+    latest_report: storedReportSummary(report),
+    recent_reports: [...recent.slice(-4), storedReportSummary(report)]
+  };
+}
+function sourceMetadata(report) {
+  const url = report.target?.url || report.source?.page_url || report.source?.url || null;
+  return {
+    ...url ? { source_url: url, external_url: url, issue_url: url } : {},
+    ...report.source?.run_id ? { tester_run_id: report.source.run_id } : {},
+    ...report.source?.result_id ? { tester_result_id: report.source.result_id } : {},
+    ...report.source?.scenario_id ? { tester_scenario_id: report.source.scenario_id } : {},
+    ...report.source?.project_id ? { tester_project_id: report.source.project_id } : {}
+  };
+}
+function findExistingTask2(fingerprint2, input, db) {
+  for (const task2 of listTasks({
+    include_archived: true,
+    project_id: input.project_id,
+    task_list_id: input.task_list_id
+  }, db)) {
+    const metadata = task2.metadata || {};
+    const tester = asObject3(metadata["tester_issue_report"]);
+    if (tester["fingerprint"] === fingerprint2)
+      return task2;
+    if (metadata["tester_issue_fingerprint"] === fingerprint2)
+      return task2;
+    if (metadata["external_ref"] === fingerprint2)
+      return task2;
+  }
+  return null;
+}
+function commandsFor(task2) {
+  return [
+    "todos issues report --file tester-report.json --apply --json",
+    task2 ? `todos show ${task2.id.slice(0, 8)}` : `todos list --tags tester-report --json`,
+    `todos dedupe scan --threshold 0.8 --json`
+  ];
+}
+function updateExistingTask(task2, report, fingerprint2, input, timestamp2, db) {
+  if (input.update_existing === false)
+    return { action: "matched", task: task2 };
+  const previous = asObject3(task2.metadata["tester_issue_report"]);
+  const severityPriority = priorityForSeverity(report.severity, input.default_priority || "medium");
+  const nextStatus = task2.status === "completed" || task2.status === "cancelled" ? "pending" : task2.status;
+  const action = nextStatus !== task2.status ? "regressed" : "updated";
+  const updated = updateTask(task2.id, {
+    version: task2.version,
+    title: taskTitle2(report),
+    description: taskDescription2(report, fingerprint2),
+    priority: maxPriority(task2.priority, severityPriority),
+    status: nextStatus,
+    completed_at: nextStatus !== task2.status ? null : undefined,
+    tags: [...new Set([...task2.tags, ...taskTags(report)])],
+    metadata: {
+      ...task2.metadata,
+      ...sourceMetadata(report),
+      external_ref: fingerprint2,
+      tester_issue_fingerprint: fingerprint2,
+      tester_issue_report: testerMetadata(report, fingerprint2, previous, timestamp2)
+    },
+    ...input.assigned_to !== undefined ? { assigned_to: input.assigned_to } : {},
+    task_type: task2.task_type || "bug"
+  }, db);
+  return { action, task: updated };
+}
+function upsertTesterIssueReport(input, db) {
+  const d = db || getDatabase();
+  const timestamp2 = now();
+  const warnings = [];
+  const report = normalizeTesterIssueReport(input.report, input.default_priority || "medium");
+  const fingerprint2 = fingerprintTesterIssueReport(report);
+  const existing = findExistingTask2(fingerprint2, input, d);
+  if (!input.apply) {
+    const action = existing ? "matched" : "preview";
+    return {
+      schema_version: TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
+      local_only: true,
+      dry_run: true,
+      processed_at: timestamp2,
+      action,
+      fingerprint: fingerprint2,
+      report,
+      task: existing,
+      warnings,
+      commands: commandsFor(existing)
+    };
+  }
+  if (existing) {
+    const updated = updateExistingTask(existing, report, fingerprint2, input, timestamp2, d);
+    return {
+      schema_version: TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
+      local_only: true,
+      dry_run: false,
+      processed_at: timestamp2,
+      action: updated.action,
+      fingerprint: fingerprint2,
+      report,
+      task: updated.task,
+      warnings,
+      commands: commandsFor(updated.task)
+    };
+  }
+  const priority = priorityForSeverity(report.severity, input.default_priority || "medium");
+  const task2 = createTask({
+    title: taskTitle2(report),
+    description: taskDescription2(report, fingerprint2),
+    priority,
+    status: "pending",
+    tags: taskTags(report),
+    metadata: {
+      ...sourceMetadata(report),
+      external_ref: fingerprint2,
+      tester_issue_fingerprint: fingerprint2,
+      tester_issue_report: testerMetadata(report, fingerprint2, null, timestamp2),
+      tester_issue_report_raw: redactValue({
+        ...report,
+        evidence: report.evidence ? {
+          screenshots: report.evidence.screenshots,
+          artifacts: report.evidence.artifacts
+        } : undefined
+      })
+    },
+    project_id: input.project_id,
+    task_list_id: input.task_list_id,
+    agent_id: input.agent_id,
+    assigned_to: input.assigned_to,
+    task_type: "bug"
+  }, d);
+  return {
+    schema_version: TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
+    local_only: true,
+    dry_run: false,
+    processed_at: timestamp2,
+    action: "created",
+    fingerprint: fingerprint2,
+    report,
+    task: task2,
+    warnings,
+    commands: commandsFor(task2)
+  };
+}
+function upsertTesterIssueReports(input, db) {
+  const d = db || getDatabase();
+  const run = () => input.reports.map((report) => upsertTesterIssueReport({ ...input, report }, d));
+  const results = input.apply ? d.transaction(run)() : run();
+  const summary = {
+    total: results.length,
+    preview: 0,
+    matched: 0,
+    created: 0,
+    updated: 0,
+    regressed: 0
+  };
+  for (const result of results)
+    summary[result.action]++;
+  return {
+    schema_version: TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION,
+    local_only: true,
+    dry_run: !input.apply,
+    processed_at: now(),
+    results,
+    summary
+  };
+}
+function readTesterIssueReportsPayload(value) {
+  if (Array.isArray(value))
+    return value;
+  const record = asObject3(value);
+  if (Array.isArray(record["reports"]))
+    return record["reports"];
+  if (Array.isArray(record["issues"]))
+    return record["issues"];
+  return [value];
+}
 // src/lib/local-notifications.ts
 init_database();
 
@@ -17389,13 +18694,13 @@ function eventSeverity(eventType) {
 function payloadText(payload) {
   return JSON.stringify(payload).toLowerCase();
 }
-function asString3(value) {
+function asString4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 function fieldMatches(allowed, value) {
   if (!allowed || allowed.length === 0)
     return true;
-  const stringValue = asString3(value);
+  const stringValue = asString4(value);
   return Boolean(stringValue && allowed.includes(stringValue));
 }
 function containsMatches(needles, payload) {
@@ -17461,8 +18766,8 @@ function evaluateTerminalWatchRules(input, rules = listTerminalNotificationRules
     if (isQuietTime(rule.quiet_hours, timestamp2))
       skipped.push("quiet hours active");
     const matched = skipped.length === 0;
-    const title = asString3(payload["title"]) || asString3(payload["name"]) || input.type;
-    const taskId = asString3(payload["id"]) || asString3(payload["task_id"]);
+    const title = asString4(payload["title"]) || asString4(payload["name"]) || input.type;
+    const taskId = asString4(payload["id"]) || asString4(payload["task_id"]);
     const notification = {
       rule: rule.name,
       event_type: input.type,
@@ -17471,8 +18776,8 @@ function evaluateTerminalWatchRules(input, rules = listTerminalNotificationRules
       message: `${input.type}: ${title}`,
       timestamp: timestamp2,
       task_id: taskId,
-      project_id: asString3(payload["project_id"]),
-      agent_id: asString3(payload["agent_id"]) || asString3(payload["assigned_to"]),
+      project_id: asString4(payload["project_id"]),
+      agent_id: asString4(payload["agent_id"]) || asString4(payload["assigned_to"]),
       bell: rule.bell && severity === "critical",
       payload
     };
@@ -18122,12 +19427,12 @@ function summarizeTask(task2) {
   };
 }
 function overdueTasks(tasks, nowIso) {
-  const now2 = Date.parse(nowIso);
+  const now3 = Date.parse(nowIso);
   return tasks.filter((task2) => {
     if (isTerminal(task2) || !task2.due_at)
       return false;
     const due = Date.parse(task2.due_at);
-    return Number.isFinite(due) && due < now2;
+    return Number.isFinite(due) && due < now3;
   });
 }
 function isReady(task2, db) {
@@ -18460,7 +19765,7 @@ function renderLocalReportMarkdown(report) {
 // src/lib/local-encryption.ts
 init_config();
 init_redaction();
-import { createCipheriv, createDecipheriv, createHash as createHash7, randomBytes, scryptSync, timingSafeEqual } from "crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash8, randomBytes, scryptSync, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var TODOS_ENCRYPTED_VALUE_KIND = "hasna.todos.encrypted-value";
 var TODOS_ENCRYPTED_BRIDGE_KIND = "hasna.todos.encrypted-bridge";
 var TODOS_ENCRYPTION_SCHEMA_VERSION = 1;
@@ -18482,11 +19787,11 @@ class EncryptedPayloadError extends Error {
     super(message);
   }
 }
-function now2() {
+function now3() {
   return new Date().toISOString();
 }
 function sha2564(value) {
-  return createHash7("sha256").update(value).digest("hex");
+  return createHash8("sha256").update(value).digest("hex");
 }
 function normalizeProfileName(value) {
   const name = (value || DEFAULT_ENCRYPTION_PROFILE).trim();
@@ -18519,7 +19824,7 @@ function upsertEncryptionProfile(input) {
   const name = normalizeProfileName(input.name);
   const config = loadConfig();
   const existing = config.encryption_profiles?.[name];
-  const timestamp2 = now2();
+  const timestamp2 = now3();
   const profile = {
     name,
     algorithm: "aes-256-gcm",
@@ -18576,7 +19881,7 @@ function encryptString(plaintext, options = {}) {
   return {
     schemaVersion: TODOS_ENCRYPTION_SCHEMA_VERSION,
     kind: TODOS_ENCRYPTED_VALUE_KIND,
-    encryptedAt: options.encryptedAt ?? now2(),
+    encryptedAt: options.encryptedAt ?? now3(),
     profile: profile.name,
     key_env: profile.key_env,
     algorithm: "aes-256-gcm",
@@ -18611,7 +19916,7 @@ function decryptString(envelope, env = process.env) {
   ]).toString("utf8");
   const expected = Buffer.from(envelope.plaintext_sha256, "hex");
   const actual = Buffer.from(sha2564(plaintext), "hex");
-  if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
+  if (expected.length !== actual.length || !timingSafeEqual2(expected, actual)) {
     throw new EncryptedPayloadError("decrypted payload checksum mismatch");
   }
   return plaintext;
@@ -20053,87 +21358,6 @@ function getCapableAgents(capabilities, opts, db) {
   return opts?.limit ? scored.slice(0, opts.limit) : scored;
 }
 
-// src/db/task-lists.ts
-init_types();
-init_database();
-function rowToTaskList2(row) {
-  return {
-    ...row,
-    metadata: JSON.parse(row.metadata || "{}")
-  };
-}
-function createTaskList(input, db) {
-  const d = db || getDatabase();
-  const id = uuid();
-  const timestamp2 = now();
-  const slug = input.slug || slugify(input.name);
-  if (!input.project_id) {
-    const existing = d.query("SELECT id FROM task_lists WHERE project_id IS NULL AND slug = ?").get(slug);
-    if (existing) {
-      throw new Error(`Standalone task list with slug "${slug}" already exists`);
-    }
-  }
-  d.run(`INSERT INTO task_lists (id, project_id, slug, name, description, metadata, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.project_id || null, slug, input.name, input.description || null, JSON.stringify(input.metadata || {}), timestamp2, timestamp2]);
-  return getTaskList(id, d);
-}
-function getTaskList(id, db) {
-  const d = db || getDatabase();
-  const row = d.query("SELECT * FROM task_lists WHERE id = ?").get(id);
-  return row ? rowToTaskList2(row) : null;
-}
-function getTaskListBySlug(slug, projectId, db) {
-  const d = db || getDatabase();
-  let row;
-  if (projectId) {
-    row = d.query("SELECT * FROM task_lists WHERE slug = ? AND project_id = ?").get(slug, projectId);
-  } else {
-    row = d.query("SELECT * FROM task_lists WHERE slug = ? AND project_id IS NULL").get(slug);
-  }
-  return row ? rowToTaskList2(row) : null;
-}
-function listTaskLists(projectId, db) {
-  const d = db || getDatabase();
-  if (projectId) {
-    return d.query("SELECT * FROM task_lists WHERE project_id = ? ORDER BY name").all(projectId).map(rowToTaskList2);
-  }
-  return d.query("SELECT * FROM task_lists ORDER BY name").all().map(rowToTaskList2);
-}
-function updateTaskList(id, input, db) {
-  const d = db || getDatabase();
-  const existing = getTaskList(id, d);
-  if (!existing)
-    throw new TaskListNotFoundError(id);
-  const sets = ["updated_at = ?"];
-  const params = [now()];
-  if (input.name !== undefined) {
-    sets.push("name = ?");
-    params.push(input.name);
-  }
-  if (input.description !== undefined) {
-    sets.push("description = ?");
-    params.push(input.description);
-  }
-  if (input.metadata !== undefined) {
-    sets.push("metadata = ?");
-    params.push(JSON.stringify(input.metadata));
-  }
-  params.push(id);
-  d.run(`UPDATE task_lists SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getTaskList(id, d);
-}
-function deleteTaskList(id, db) {
-  const d = db || getDatabase();
-  return d.run("DELETE FROM task_lists WHERE id = ?", [id]).changes > 0;
-}
-function ensureTaskList(name, slug, projectId, db) {
-  const d = db || getDatabase();
-  const existing = getTaskListBySlug(slug, projectId, d);
-  if (existing)
-    return existing;
-  return createTaskList({ name, slug, project_id: projectId }, d);
-}
-
 // src/storage/local-sqlite.ts
 init_database();
 
@@ -20702,7 +21926,7 @@ function createHybridTodosStorageAdapter(options) {
 }
 
 // src/storage/postgres-adapter.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 function createPostgresTodosStorageAdapter(options) {
   const store = new PostgresJsonRecordStore(options);
   const adapter = {
@@ -20885,7 +22109,7 @@ async function createTask2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   const shortId = input.project_id ? await nextTaskShortId2(input.project_id, store, context) : null;
   const task2 = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     short_id: shortId,
     project_id: input.project_id ?? context?.projectId ?? null,
     parent_id: input.parent_id ?? null,
@@ -21052,7 +22276,7 @@ async function getChangedSince(since, filters, store) {
 async function createProject2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   const project = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     name: input.name,
     path: input.path,
     description: input.description ?? null,
@@ -21072,7 +22296,7 @@ async function updateProject2(id, input, store) {
 async function createPlan2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   return store.upsert("plans", {
-    id: randomUUID2(),
+    id: randomUUID3(),
     project_id: input.project_id ?? context?.projectId ?? null,
     task_list_id: input.task_list_id ?? context?.taskListId ?? null,
     agent_id: input.agent_id ?? context?.agentId ?? null,
@@ -21094,7 +22318,7 @@ async function registerAgent2(input, store, context) {
   }
   const timestamp2 = new Date().toISOString();
   const agent = {
-    id: existing?.id ?? randomUUID2().slice(0, 8),
+    id: existing?.id ?? randomUUID3().slice(0, 8),
     name: input.name,
     description: input.description ?? existing?.description ?? null,
     role: input.role ?? existing?.role ?? null,
@@ -21130,7 +22354,7 @@ async function updateAgent2(id, input, store) {
 async function createTaskList2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   return store.upsert("task_lists", {
-    id: randomUUID2(),
+    id: randomUUID3(),
     project_id: input.project_id ?? context?.projectId ?? null,
     slug: input.slug ?? slugify2(input.name),
     name: input.name,
@@ -21152,7 +22376,7 @@ async function updateTaskList2(id, input, store) {
 async function createTemplate2(input, store, context) {
   const timestamp2 = new Date().toISOString();
   return store.upsert("templates", {
-    id: randomUUID2(),
+    id: randomUUID3(),
     name: input.name,
     title_pattern: input.title_pattern,
     description: input.description ?? null,
@@ -21181,7 +22405,7 @@ async function updateTemplate2(id, input, store) {
 }
 async function logTaskChange2(taskId, action, field2, oldValue, newValue, agentId, store, context) {
   const entry2 = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     task_id: taskId,
     action,
     field: field2 ?? null,
@@ -21194,7 +22418,7 @@ async function logTaskChange2(taskId, action, field2, oldValue, newValue, agentI
 }
 async function addComment2(input, store, context) {
   const comment = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     task_id: input.task_id,
     agent_id: input.agent_id ?? context?.agentId ?? null,
     session_id: input.session_id ?? context?.sessionId ?? null,
@@ -21369,10 +22593,10 @@ function assertRemoteAdapterCapabilities(adapter, mode) {
   }
 }
 // src/storage/s3-artifacts.ts
-import { createHash as createHash8, createHmac } from "crypto";
+import { createHash as createHash9, createHmac as createHmac2 } from "crypto";
 function createTodosS3ArtifactStore(options) {
   const requestFetch = options.fetch ?? fetch;
-  const now3 = options.now ?? (() => new Date);
+  const now4 = options.now ?? (() => new Date);
   return {
     objectKey: (relativePath) => buildS3ObjectKey(options.config, relativePath),
     objectUrl: (relativePath) => buildS3ObjectUrl(options.config, buildS3ObjectKey(options.config, relativePath)),
@@ -21394,7 +22618,7 @@ function createTodosS3ArtifactStore(options) {
         headers,
         body,
         credentials: options.credentials,
-        now: now3()
+        now: now4()
       });
       const response = await requestFetch(url, { method: "PUT", headers: signed.headers, body });
       if (!response.ok)
@@ -21415,7 +22639,7 @@ function createTodosS3ArtifactStore(options) {
         service: "s3",
         headers: {},
         credentials: options.credentials,
-        now: now3()
+        now: now4()
       });
       const response = await requestFetch(url, { method: "GET", headers: signed.headers });
       if (!response.ok)
@@ -21431,7 +22655,7 @@ function createTodosS3ArtifactStore(options) {
         service: "s3",
         headers: {},
         credentials: options.credentials,
-        now: now3()
+        now: now4()
       });
       const response = await requestFetch(url, { method: "DELETE", headers: signed.headers });
       if (!response.ok && response.status !== 404)
@@ -21541,13 +22765,13 @@ function toAmzDate(date) {
   return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
 }
 function sha256Hex(value) {
-  return createHash8("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function hmac(key, value) {
-  return createHmac("sha256", key).update(value).digest();
+  return createHmac2("sha256", key).update(value).digest();
 }
 function hmacHex(key, value) {
-  return createHmac("sha256", key).update(value).digest("hex");
+  return createHmac2("sha256", key).update(value).digest("hex");
 }
 function getSigningKey(secretAccessKey, dateStamp, region, service) {
   const dateKey = hmac(`AWS4${secretAccessKey}`, dateStamp);
@@ -21559,7 +22783,7 @@ function getSigningKey(secretAccessKey, dateStamp, region, service) {
 init_database();
 async function uploadRunArtifactsToS3(options) {
   const db = options.db ?? getDatabase();
-  const now3 = options.now ?? (() => new Date);
+  const now4 = options.now ?? (() => new Date);
   const result = emptyResult();
   for (const artifact of listRunArtifacts(db, options.filter)) {
     try {
@@ -21598,7 +22822,7 @@ async function uploadRunArtifactsToS3(options) {
         url: ref.url,
         sha256: content.sha256,
         size_bytes: content.size_bytes,
-        uploaded_at: now3().toISOString()
+        uploaded_at: now4().toISOString()
       };
       updateArtifactMetadata(db, artifact.id, {
         ...metadata,
@@ -21673,7 +22897,7 @@ function planRunArtifactsS3Sync(options) {
 }
 async function downloadRunArtifactsFromS3(options) {
   const db = options.db ?? getDatabase();
-  const now3 = options.now ?? (() => new Date);
+  const now4 = options.now ?? (() => new Date);
   const result = emptyResult();
   for (const artifact of listRunArtifacts(db, options.filter)) {
     try {
@@ -21709,7 +22933,7 @@ async function downloadRunArtifactsFromS3(options) {
         ...metadata,
         remote_artifact_store: {
           ...remote,
-          downloaded_at: now3().toISOString()
+          downloaded_at: now4().toISOString()
         }
       });
       result.downloaded += 1;
@@ -22728,7 +23952,7 @@ function parseObject2(value) {
 function normalizeTags(tags) {
   return [...new Set((tags || []).map((tag) => tag.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
 }
-function normalizeText2(value) {
+function normalizeText3(value) {
   if (value === undefined)
     return null;
   const trimmed = value.trim();
@@ -22783,9 +24007,9 @@ function createKnowledgeRecord(input, db) {
     id,
     input.record_type,
     title,
-    normalizeText2(input.content),
-    normalizeText2(input.decision),
-    normalizeText2(input.rationale),
+    normalizeText3(input.content),
+    normalizeText3(input.decision),
+    normalizeText3(input.rationale),
     JSON.stringify(input.alternatives || []),
     resolveKnownId("tasks", input.task_id, d),
     resolveKnownId("projects", input.project_id, d),
@@ -22980,7 +24204,7 @@ function parseObject3(value) {
 function normalizeTags2(tags) {
   return [...new Set((tags || []).flatMap((tag) => tag.split(",")).map((tag) => tag.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
 }
-function normalizeText3(value) {
+function normalizeText4(value) {
   if (value === null || value === undefined)
     return null;
   const trimmed = value.trim();
@@ -23049,13 +24273,13 @@ function createRisk(input, db) {
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
     title,
-    normalizeText3(input.description),
+    normalizeText4(input.description),
     status,
     severity,
     probability,
-    normalizeText3(input.owner),
-    normalizeText3(input.mitigation),
-    normalizeText3(input.due_at),
+    normalizeText4(input.owner),
+    normalizeText4(input.mitigation),
+    normalizeText4(input.due_at),
     resolveKnownId2("projects", input.project_id, d),
     resolveKnownId2("plans", input.plan_id, d),
     resolveKnownId2("tasks", input.task_id, d),
@@ -23090,7 +24314,7 @@ function updateRisk(id, input, db) {
   }
   if (input.description !== undefined) {
     sets.push("description = ?");
-    params.push(normalizeText3(input.description));
+    params.push(normalizeText4(input.description));
   }
   if (input.status !== undefined) {
     assertStatus(input.status);
@@ -23111,15 +24335,15 @@ function updateRisk(id, input, db) {
   }
   if (input.owner !== undefined) {
     sets.push("owner = ?");
-    params.push(normalizeText3(input.owner));
+    params.push(normalizeText4(input.owner));
   }
   if (input.mitigation !== undefined) {
     sets.push("mitigation = ?");
-    params.push(normalizeText3(input.mitigation));
+    params.push(normalizeText4(input.mitigation));
   }
   if (input.due_at !== undefined) {
     sets.push("due_at = ?");
-    params.push(normalizeText3(input.due_at));
+    params.push(normalizeText4(input.due_at));
   }
   if (input.project_id !== undefined) {
     sets.push("project_id = ?");
@@ -23640,7 +24864,7 @@ function renderRetrospectiveMarkdown(record) {
 }
 // src/lib/project-bootstrap.ts
 init_database();
-import { existsSync as existsSync8, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
 import { basename as basename2, dirname as dirname7, resolve as resolve9 } from "path";
 function safeStat(path) {
   try {
@@ -23659,7 +24883,7 @@ function canonicalPath(input) {
 function findUp(start, marker) {
   let current = canonicalPath(start);
   while (true) {
-    if (existsSync8(resolve9(current, marker)))
+    if (existsSync9(resolve9(current, marker)))
       return current;
     const parent = dirname7(current);
     if (parent === current)
@@ -23671,7 +24895,7 @@ function readPackageJson2(path) {
   if (!path)
     return null;
   const file = resolve9(path, "package.json");
-  if (!existsSync8(file))
+  if (!existsSync9(file))
     return null;
   try {
     const parsed = JSON.parse(readFileSync7(file, "utf-8"));
@@ -23693,7 +24917,7 @@ function workspaceMarker(root, rootPackage) {
   if (rootPackage?.workspaces)
     markers.push("package.json#workspaces");
   for (const marker of ["pnpm-workspace.yaml", "turbo.json", "nx.json", "lerna.json", "rush.json", "bun.lock", "bun.lockb"]) {
-    if (existsSync8(resolve9(root, marker)))
+    if (existsSync9(resolve9(root, marker)))
       markers.push(marker);
   }
   const kind = markers.find((marker) => marker !== "bun.lock" && marker !== "bun.lockb") ?? null;
@@ -23801,7 +25025,7 @@ function getProjectByPathForBootstrap(path, db) {
 }
 // src/db/api-keys.ts
 init_database();
-import { createHash as createHash9, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHash as createHash10, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "crypto";
 function rowToRecord(row) {
   return {
     id: row.id,
@@ -23815,12 +25039,12 @@ function rowToRecord(row) {
   };
 }
 function hashApiKey(key) {
-  return createHash9("sha256").update(key).digest("hex");
+  return createHash10("sha256").update(key).digest("hex");
 }
 function safeEqualHex(a, b) {
   if (a.length !== b.length)
     return false;
-  return timingSafeEqual2(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+  return timingSafeEqual3(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
 }
 function generatePlaintextKey() {
   return `tdos_${randomBytes2(32).toString("base64url")}`;
@@ -24006,18 +25230,18 @@ var gatherTrainingData = async (options = {}) => {
 };
 // src/lib/model-config.ts
 init_sync_utils();
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10 } from "path";
 var DEFAULT_MODEL = "gpt-4o-mini";
 function getConfigDir() {
   return getTodosGlobalDir();
 }
 function getConfigPath2() {
-  return join9(getConfigDir(), "config.json");
+  return join10(getConfigDir(), "config.json");
 }
 function readConfig() {
   const configPath = getConfigPath2();
-  if (!existsSync9(configPath))
+  if (!existsSync10(configPath))
     return {};
   try {
     const raw = readFileSync8(configPath, "utf-8");
@@ -24028,7 +25252,7 @@ function readConfig() {
 }
 function writeConfig(config) {
   const configDir = getConfigDir();
-  if (!existsSync9(configDir)) {
+  if (!existsSync10(configDir)) {
     mkdirSync8(configDir, { recursive: true });
   }
   writeFileSync6(getConfigPath2(), JSON.stringify(config, null, 2) + `
@@ -24753,7 +25977,7 @@ CLI equivalent: \`${r.equivalent_cli}\`
 `);
 }
 // src/lib/verification-providers.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
 init_database();
 init_config();
 init_redaction();
@@ -24919,7 +26143,7 @@ Timed out after ${provider.timeout_ms}ms`);
   };
 }
 function runCiLogProvider(input) {
-  const text = input.log_text ?? (input.log_path && existsSync10(input.log_path) ? readFileSync9(input.log_path, "utf-8") : "");
+  const text = input.log_text ?? (input.log_path && existsSync11(input.log_path) ? readFileSync9(input.log_path, "utf-8") : "");
   return {
     status: classifyLog(text),
     attempts: 1,
@@ -24931,7 +26155,7 @@ function runBrowserProvider(input) {
   if (!input.artifact_path) {
     return { status: "unknown", attempts: 1, exit_code: null, output_summary: "browser provider needs a screenshot or artifact path" };
   }
-  if (!existsSync10(input.artifact_path)) {
+  if (!existsSync11(input.artifact_path)) {
     return { status: "failed", attempts: 1, exit_code: null, output_summary: `artifact not found: ${input.artifact_path}` };
   }
   return {
@@ -25529,11 +26753,11 @@ function buildResourceSnapshot(uri, staleMs = DEFAULT_STALE_MS) {
     content_hash: hashContent(content)
   };
 }
-function isSnapshotStale(snapshot, now3 = new Date) {
+function isSnapshotStale(snapshot, now4 = new Date) {
   const staleAt = Date.parse(snapshot.stale_after);
   if (!Number.isFinite(staleAt))
     return true;
-  return now3.getTime() >= staleAt;
+  return now4.getTime() >= staleAt;
 }
 function subscribeResource(uri, agentId) {
   const key = `${uri}:${agentId || "*"}`;
@@ -25570,21 +26794,21 @@ function resourceDiagnostics() {
   };
 }
 // src/lib/sandbox-profiles.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
-import { join as join10, dirname as dirname9 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
+import { join as join11, dirname as dirname9 } from "path";
 var SANDBOX_PROFILE_VERSION = "todos.sandbox-profile.v1";
 function getProfilesPath() {
   if (process.env["TODOS_SANDBOX_PROFILES_PATH"]) {
     return process.env["TODOS_SANDBOX_PROFILES_PATH"];
   }
-  const localDir = join10(process.cwd(), ".todos");
-  const local = join10(localDir, "sandbox-profiles.json");
-  if (existsSync11(localDir))
+  const localDir = join11(process.cwd(), ".todos");
+  const local = join11(localDir, "sandbox-profiles.json");
+  if (existsSync12(localDir))
     return local;
-  if (existsSync11(local))
+  if (existsSync12(local))
     return local;
   const home = process.env["HOME"] || "~";
-  return join10(home, ".hasna", "todos", "sandbox-profiles.json");
+  return join11(home, ".hasna", "todos", "sandbox-profiles.json");
 }
 var cached2 = null;
 function resetSandboxProfileCache() {
@@ -25616,7 +26840,7 @@ function loadSandboxProfiles() {
   if (cached2)
     return cached2;
   const path = getProfilesPath();
-  if (!existsSync11(path)) {
+  if (!existsSync12(path)) {
     cached2 = getDefaultSandboxProfiles();
     return cached2;
   }
@@ -25989,7 +27213,7 @@ function getDefaultAgentAdapters() {
 }
 function resetAgentAdapterCache() {}
 // src/lib/git-traceability.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
 import { resolve as resolve11 } from "path";
 var GIT_TRACEABILITY_SCHEMA_VERSION = "todos.git_traceability.v1";
@@ -26035,7 +27259,7 @@ function inspectGitCommit(sha, cwd) {
 }
 function loadCiSnapshot(path) {
   const target = path ? resolve11(path) : resolve11(process.cwd(), ".todos", "ci-snapshot.json");
-  if (!existsSync12(target))
+  if (!existsSync13(target))
     return null;
   try {
     const parsed = JSON.parse(readFileSync11(target, "utf8"));
@@ -26131,8 +27355,8 @@ function formatTraceabilityReport(report) {
 `);
 }
 // src/lib/mention-resolver.ts
-import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
-import { basename as basename3, isAbsolute, join as join11, relative as relative4, resolve as resolve12, sep } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
+import { basename as basename3, isAbsolute, join as join12, relative as relative4, resolve as resolve12, sep } from "path";
 init_database();
 var PREFIXES = {
   file: "file",
@@ -26283,7 +27507,7 @@ function resolveFile(parsed, workspace) {
     return resolution;
   }
   resolution.path = relPath;
-  if (!existsSync13(absolutePath)) {
+  if (!existsSync14(absolutePath)) {
     resolution.warnings.push("file does not exist in the local workspace");
     return resolution;
   }
@@ -26316,7 +27540,7 @@ function walkSourceFiles(root, current = root, files = []) {
       if (SKIP_DIRS.has(entry2.name))
         continue;
     }
-    const absolutePath = join11(current, entry2.name);
+    const absolutePath = join12(current, entry2.name);
     if (entry2.isDirectory()) {
       if (!SKIP_DIRS.has(entry2.name))
         walkSourceFiles(root, absolutePath, files);
@@ -28189,9 +29413,9 @@ function getAdapterDocsFingerprint() {
 }
 // src/lib/inbox-intake.ts
 init_database();
-import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
 import { basename as basename4 } from "path";
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 init_secret_redaction();
 var INBOX_INTAKE_SCHEMA = "todos.inbox_intake.v1";
 var INTAKE_SOURCE_TYPES = [
@@ -28204,7 +29428,7 @@ var INTAKE_SOURCE_TYPES = [
 ];
 var INTAKE_TRIAGE_STATUSES = ["preview", "triaged", "duplicate", "created"];
 function fingerprint2(text) {
-  return createHash10("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash11("sha256").update(text).digest("hex").slice(0, 16);
 }
 function loadRawContent(input) {
   if (input.github_url) {
@@ -28235,7 +29459,7 @@ function loadRawContent(input) {
     }
   }
   if (input.file_path) {
-    if (!existsSync14(input.file_path))
+    if (!existsSync15(input.file_path))
       throw new Error(`File not found: ${input.file_path}`);
     const raw = readFileSync13(input.file_path, "utf8");
     const name = basename4(input.file_path).toLowerCase();
@@ -28853,7 +30077,7 @@ function formatNlIntakePreviewText(preview) {
 }
 // src/lib/issue-importers.ts
 init_database();
-import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
 var ISSUE_IMPORT_SCHEMA = "todos.issue_import.v1";
 var ISSUE_SOURCES = ["github", "linear", "jira", "auto"];
 var GITHUB_LABEL_PRIORITY = {
@@ -29072,7 +30296,7 @@ function parseIssueExport(data, source9 = "auto") {
   return normalized;
 }
 function loadIssueExportFromFile(path) {
-  if (!existsSync15(path))
+  if (!existsSync16(path))
     throw new Error(`File not found: ${path}`);
   return JSON.parse(readFileSync14(path, "utf8"));
 }
@@ -29232,8 +30456,8 @@ todos import issues ./linear.json --source linear --dry-run
 // src/lib/run-records.ts
 init_database();
 init_secret_redaction();
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join12, dirname as dirname10 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join13, dirname as dirname10 } from "path";
 var RUN_RECORD_SCHEMA = "todos.run_record.v1";
 var RUN_RECORD_STATUSES = ["active", "completed", "failed", "archived"];
 function parseJsonArray3(raw, fallback = []) {
@@ -29426,7 +30650,7 @@ function buildRunReplayBundle(id, db) {
 }
 function exportRunReplay(id, outputPath, db) {
   const bundle = buildRunReplayBundle(id, db);
-  const path = outputPath ?? join12(process.cwd(), ".todos", "replays", `${id.slice(0, 8)}.json`);
+  const path = outputPath ?? join13(process.cwd(), ".todos", "replays", `${id.slice(0, 8)}.json`);
   mkdirSync11(dirname10(path), { recursive: true });
   writeFileSync9(path, JSON.stringify(bundle, null, 2));
   const d = db || getDatabase();
@@ -29466,16 +30690,16 @@ function formatRunRecordMarkdown(record) {
 `;
 }
 function getDefaultReplayDir() {
-  const local = join12(process.cwd(), ".todos", "replays");
-  if (existsSync16(join12(process.cwd(), ".todos")))
+  const local = join13(process.cwd(), ".todos", "replays");
+  if (existsSync17(join13(process.cwd(), ".todos")))
     return local;
   const home = process.env["HOME"] || "~";
-  return join12(home, ".hasna", "todos", "replays");
+  return join13(home, ".hasna", "todos", "replays");
 }
 // src/lib/release-checks.ts
 init_secret_redaction();
-import { existsSync as existsSync17, readFileSync as readFileSync15, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
-import { join as join13, relative as relative5 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
+import { join as join14, relative as relative5 } from "path";
 var RELEASE_CHECK_SCHEMA = "todos.release_check.v1";
 var FORBIDDEN_DIST_PATTERNS = [
   {
@@ -29488,16 +30712,16 @@ var FORBIDDEN_DIST_PATTERNS = [
 ];
 var REQUIRED_BINS = ["todos", "todos-mcp", "todos-serve"];
 function readPackageJson3(root) {
-  const path = join13(root, "package.json");
-  if (!existsSync17(path))
+  const path = join14(root, "package.json");
+  if (!existsSync18(path))
     throw new Error(`package.json not found in ${root}`);
   return JSON.parse(readFileSync15(path, "utf8"));
 }
 function walkFiles(dir, acc = []) {
-  if (!existsSync17(dir))
+  if (!existsSync18(dir))
     return acc;
   for (const entry2 of readdirSync3(dir)) {
-    const full = join13(dir, entry2);
+    const full = join14(dir, entry2);
     const st = statSync5(full);
     if (st.isDirectory())
       walkFiles(full, acc);
@@ -29515,8 +30739,8 @@ function auditPackageContents(root) {
     checks.push({ id: "files_dist", severity: "error", message: "package.json files must include dist" });
   }
   for (const pattern of files) {
-    const target = join13(root, pattern);
-    if (!existsSync17(target)) {
+    const target = join14(root, pattern);
+    if (!existsSync18(target)) {
       checks.push({ id: `files_missing_${pattern}`, severity: "error", message: `Published file path missing: ${pattern}` });
     }
   }
@@ -29530,8 +30754,8 @@ function auditPackageContents(root) {
       checks.push({ id: `bin_${name}`, severity: "error", message: `Missing bin entry: ${name}` });
       continue;
     }
-    const binPath = join13(root, rel);
-    if (!existsSync17(binPath)) {
+    const binPath = join14(root, rel);
+    if (!existsSync18(binPath)) {
       checks.push({ id: `bin_path_${name}`, severity: "error", message: `Bin file missing: ${rel}` });
     } else {
       checks.push({ id: `bin_ok_${name}`, severity: "info", message: `Bin present: ${name} \u2192 ${rel}` });
@@ -29548,8 +30772,8 @@ function auditPackageContents(root) {
 }
 function scanDistArtifacts(root) {
   const checks = [];
-  const distDir = join13(root, "dist");
-  if (!existsSync17(distDir)) {
+  const distDir = join14(root, "dist");
+  if (!existsSync18(distDir)) {
     checks.push({ id: "dist_missing", severity: "error", message: "dist/ directory not found \u2014 run bun run build" });
     return checks;
   }
@@ -29855,8 +31079,8 @@ function renderReleaseNotesMarkdown(document) {
 // src/lib/db-backup.ts
 init_database();
 init_migrations();
-import { existsSync as existsSync18, copyFileSync, mkdirSync as mkdirSync12, readFileSync as readFileSync16, statSync as statSync6, writeFileSync as writeFileSync10, unlinkSync } from "fs";
-import { dirname as dirname11, join as join14, resolve as resolve13 } from "path";
+import { existsSync as existsSync19, copyFileSync, mkdirSync as mkdirSync12, readFileSync as readFileSync16, statSync as statSync6, writeFileSync as writeFileSync10, unlinkSync } from "fs";
+import { dirname as dirname11, join as join15, resolve as resolve13 } from "path";
 import { Database as Database3 } from "bun:sqlite";
 var DB_BACKUP_SCHEMA = "todos.db_backup.v1";
 function resolveDbPath(dbPath) {
@@ -29873,7 +31097,7 @@ function resolveDbPath(dbPath) {
 }
 function backupDatabase(outputPath, sourcePath) {
   const source9 = resolveDbPath(sourcePath);
-  if (!existsSync18(source9))
+  if (!existsSync19(source9))
     throw new Error(`Database not found: ${source9}`);
   mkdirSync12(dirname11(outputPath), { recursive: true });
   closeDatabase();
@@ -29896,7 +31120,7 @@ function backupDatabase(outputPath, sourcePath) {
   };
 }
 function restoreDatabase(backupPath, targetPath) {
-  if (!existsSync18(backupPath))
+  if (!existsSync19(backupPath))
     throw new Error(`Backup not found: ${backupPath}`);
   const integrity = checkDatabaseIntegrity(backupPath);
   if (!integrity.ok) {
@@ -29923,7 +31147,7 @@ function restoreDatabase(backupPath, targetPath) {
 function checkDatabaseIntegrity(dbPath) {
   const path = dbPath ? resolve13(dbPath) : resolveDbPath();
   const errors = [];
-  if (!existsSync18(path)) {
+  if (!existsSync19(path)) {
     return {
       schema_version: DB_BACKUP_SCHEMA,
       path,
@@ -30022,11 +31246,11 @@ function migrationDryRun(dbPath) {
 function defaultBackupPath(dbPath) {
   const base = dbPath ? dirname11(resolve13(dbPath)) : dirname11(resolveDbPath());
   const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-  return join14(base, "backups", `todos-${stamp}.db`);
+  return join15(base, "backups", `todos-${stamp}.db`);
 }
 function readBackupManifest(backupPath) {
   const manifestPath = `${backupPath}.json`;
-  if (!existsSync18(manifestPath))
+  if (!existsSync19(manifestPath))
     return null;
   try {
     return JSON.parse(readFileSync16(manifestPath, "utf8"));
@@ -30054,7 +31278,10 @@ var SCHEMA_ENTITIES = [
   "verification_evidence",
   "handoff",
   "import_export_bundle",
-  "mcp_response"
+  "mcp_response",
+  "tester_issue_report",
+  "tester_issue_report_result",
+  "tester_issue_report_batch_result"
 ];
 var ISO_DATE = { type: "string", description: "ISO-8601 timestamp" };
 function def(entity, schemaVersion, title, required, properties) {
@@ -30184,6 +31411,81 @@ var JSON_SCHEMAS = {
       }
     },
     is_error: { type: "boolean" }
+  }),
+  tester_issue_report: def("tester_issue_report", "testers.issue_report.v1", "TesterIssueReport", ["schema_version", "title"], {
+    schema_version: { type: "string", enum: ["testers.issue_report.v1"] },
+    id: { type: "string" },
+    fingerprint: { type: "string" },
+    title: { type: "string" },
+    summary: { type: ["string", "null"] },
+    kind: { type: "string" },
+    severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
+    source: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        tool: { type: "string" },
+        run_id: { type: "string" },
+        result_id: { type: "string" },
+        scenario_id: { type: "string" },
+        scenario_name: { type: "string" },
+        project_id: { type: "string" },
+        url: { type: "string" },
+        page_url: { type: "string" },
+        artifact_url: { type: "string" },
+        screenshot_url: { type: "string" },
+        commit: { type: "string" },
+        branch: { type: "string" }
+      }
+    },
+    target: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        url: { type: "string" },
+        route: { type: "string" },
+        selector: { type: "string" },
+        component: { type: "string" },
+        browser: { type: "string" },
+        viewport: { type: "string" }
+      }
+    },
+    failure: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        message: { type: "string" },
+        expected: { type: "string" },
+        actual: { type: "string" },
+        stack: { type: "string" },
+        reasoning: { type: "string" },
+        steps: { type: "array", items: { type: "string" } }
+      }
+    },
+    evidence: { type: "object", additionalProperties: true },
+    labels: { type: "array", items: { type: "string" } },
+    metadata: { type: "object", additionalProperties: true },
+    occurred_at: ISO_DATE
+  }),
+  tester_issue_report_result: def("tester_issue_report_result", "todos.tester_issue_report_result.v1", "TesterIssueReportResult", ["schema_version", "local_only", "dry_run", "processed_at", "action", "fingerprint", "report", "task", "warnings", "commands"], {
+    schema_version: { type: "string", enum: ["todos.tester_issue_report_result.v1"] },
+    local_only: { type: "boolean" },
+    dry_run: { type: "boolean" },
+    processed_at: ISO_DATE,
+    action: { type: "string", enum: ["preview", "matched", "created", "updated", "regressed"] },
+    fingerprint: { type: "string" },
+    report: { type: "object", additionalProperties: true },
+    task: { type: ["object", "null"], additionalProperties: true },
+    warnings: { type: "array", items: { type: "string" } },
+    commands: { type: "array", items: { type: "string" } }
+  }),
+  tester_issue_report_batch_result: def("tester_issue_report_batch_result", "todos.tester_issue_report_batch_result.v1", "TesterIssueReportBatchResult", ["schema_version", "local_only", "dry_run", "processed_at", "results", "summary"], {
+    schema_version: { type: "string", enum: ["todos.tester_issue_report_batch_result.v1"] },
+    local_only: { type: "boolean" },
+    dry_run: { type: "boolean" },
+    processed_at: ISO_DATE,
+    results: { type: "array", items: { type: "object", additionalProperties: true } },
+    summary: { type: "object", additionalProperties: true }
   })
 };
 var SCHEMA_CONTRACT_FIXTURES = {
@@ -30264,6 +31566,47 @@ var SCHEMA_CONTRACT_FIXTURES = {
   mcp_response: {
     schema_version: "todos.mcp_response.v1",
     content: [{ type: "text", text: "ok" }]
+  },
+  tester_issue_report: {
+    schema_version: "testers.issue_report.v1",
+    title: "Checkout button fails",
+    kind: "assertion_failure",
+    severity: "high",
+    fingerprint: "checkout-button-1234",
+    source: {
+      tool: "testers",
+      run_id: "run-001",
+      scenario_id: "scenario-001",
+      url: "https://preview.example.com/checkout"
+    },
+    failure: {
+      message: "Expected checkout button to become enabled",
+      steps: ["Open checkout", "Fill required fields"]
+    },
+    labels: ["checkout", "regression"]
+  },
+  tester_issue_report_result: {
+    schema_version: "todos.tester_issue_report_result.v1",
+    local_only: true,
+    dry_run: false,
+    processed_at: "2026-01-01T00:00:00.000Z",
+    action: "created",
+    fingerprint: "testers:checkout-button-1234",
+    report: {
+      schema_version: "testers.issue_report.v1",
+      title: "Checkout button fails"
+    },
+    task: null,
+    warnings: [],
+    commands: []
+  },
+  tester_issue_report_batch_result: {
+    schema_version: "todos.tester_issue_report_batch_result.v1",
+    local_only: true,
+    dry_run: false,
+    processed_at: "2026-01-01T00:00:00.000Z",
+    results: [],
+    summary: { total: 0, preview: 0, matched: 0, created: 0, updated: 0, regressed: 0 }
   }
 };
 function typeMatches(value, expected) {
@@ -30427,15 +31770,15 @@ ${SCHEMA_ENTITIES.map((e) => `- **${e}**: \`${JSON_SCHEMAS[e].schema_version}\``
 }
 function exportSchemasToDirectory(dir) {
   const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync11 } = __require("fs");
-  const { join: join15 } = __require("path");
+  const { join: join16 } = __require("path");
   mkdirSync13(dir, { recursive: true });
   const written = [];
   for (const entity of SCHEMA_ENTITIES) {
-    const path = join15(dir, `${entity}.${JSON_SCHEMAS[entity].schema_version.replace(/\./g, "-")}.json`);
+    const path = join16(dir, `${entity}.${JSON_SCHEMAS[entity].schema_version.replace(/\./g, "-")}.json`);
     writeFileSync11(path, JSON.stringify(JSON_SCHEMAS[entity], null, 2));
     written.push(path);
   }
-  const catalogPath = join15(dir, "catalog.json");
+  const catalogPath = join16(dir, "catalog.json");
   writeFileSync11(catalogPath, JSON.stringify({
     catalog_version: JSON_SCHEMA_CATALOG_VERSION,
     semver: SCHEMA_SEMVER,
@@ -30641,6 +31984,9 @@ function hasFts(db) {
 function escapeFtsQuery(q) {
   return q.replace(/["*^()]/g, " ").trim().split(/\s+/).filter(Boolean).map((token) => `"${token}"*`).join(" ");
 }
+function shouldUseFts(q) {
+  return /^[\p{L}\p{N}_\-\s]+$/u.test(q);
+}
 function searchTasks(options, projectId, taskListId, db) {
   const opts = typeof options === "string" ? { query: options || undefined, project_id: projectId, task_list_id: taskListId } : options;
   const d = db || getDatabase();
@@ -30649,7 +31995,8 @@ function searchTasks(options, projectId, taskListId, db) {
   let sql;
   const raw = opts.query?.trim() ?? "";
   const q = raw === "*" ? "" : raw;
-  if (hasFts(d) && q) {
+  const useFts = hasFts(d) && q && shouldUseFts(q);
+  if (useFts) {
     const ftsQuery = escapeFtsQuery(q);
     sql = `SELECT t.* FROM tasks t
       INNER JOIN tasks_fts fts ON fts.rowid = t.rowid
@@ -30657,8 +32004,16 @@ function searchTasks(options, projectId, taskListId, db) {
     params.push(ftsQuery);
   } else if (q) {
     const pattern = `%${q}%`;
-    sql = `SELECT * FROM tasks t WHERE (t.title LIKE ? OR t.description LIKE ? OR EXISTS (SELECT 1 FROM task_tags WHERE task_tags.task_id = t.id AND tag LIKE ?))`;
-    params.push(pattern, pattern, pattern);
+    sql = `SELECT * FROM tasks t WHERE (
+      t.id LIKE ?
+      OR t.short_id LIKE ?
+      OR t.title LIKE ?
+      OR t.description LIKE ?
+      OR t.working_dir LIKE ?
+      OR t.metadata LIKE ?
+      OR EXISTS (SELECT 1 FROM task_tags WHERE task_tags.task_id = t.id AND tag LIKE ?)
+    )`;
+    params.push(pattern, pattern, pattern, pattern, pattern, pattern, pattern);
   } else {
     sql = `SELECT * FROM tasks t WHERE 1=1`;
   }
@@ -30714,7 +32069,7 @@ function searchTasks(options, projectId, taskListId, db) {
   } else if (opts.is_blocked === false) {
     sql += " AND t.id NOT IN (SELECT td.task_id FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed')";
   }
-  if (hasFts(d) && q) {
+  if (useFts) {
     sql += ` ORDER BY bm25(tasks_fts),
       CASE t.priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
       t.created_at DESC`;
@@ -32992,7 +34347,7 @@ function generateCliReferenceMarkdown() {
 // src/db/builtin-templates.ts
 init_database();
 import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync13 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var BUILTIN_TEMPLATE_LIBRARY_VERSION = "2026-05-21";
 var BUILTIN_TEMPLATE_LIBRARY_SOURCE = "bundled-local-template-library";
 var TEMPLATE_LIBRARY_SCHEMA = "todos.template_library.v1";
@@ -33268,7 +34623,7 @@ function writeBuiltinTemplateFiles(directory) {
   mkdirSync15(directory, { recursive: true });
   const files = [];
   for (const entry2 of exportBuiltinTemplateFiles()) {
-    const path = join15(directory, entry2.filename);
+    const path = join16(directory, entry2.filename);
     writeFileSync13(path, `${JSON.stringify(entry2.template, null, 2)}
 `, "utf-8");
     files.push(path);
@@ -33550,10 +34905,10 @@ todos machines topology      # full diagnostic report
 `;
 }
 // src/lib/environment-snapshots.ts
-import { createHash as createHash11 } from "crypto";
-import { existsSync as existsSync19, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
+import { createHash as createHash12 } from "crypto";
+import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync7 } from "fs";
 import { hostname as hostname3, platform, arch } from "os";
-import { dirname as dirname15, join as join16, resolve as resolve14 } from "path";
+import { dirname as dirname15, join as join17, resolve as resolve14 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 init_database();
 init_redaction();
@@ -33575,11 +34930,11 @@ var CONFIG_FILES = [
   "dashboard/vite.config.ts"
 ];
 function sha2565(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function fileRecord(root, relativePath) {
-  const path = join16(root, relativePath);
-  if (!existsSync19(path))
+  const path = join17(root, relativePath);
+  if (!existsSync20(path))
     return null;
   const stat = statSync7(path);
   if (!stat.isFile())
@@ -33591,7 +34946,7 @@ function manifestRecord(root, relativePath) {
   const base = fileRecord(root, relativePath);
   if (!base)
     return null;
-  const parsed = readJsonFile(join16(root, relativePath));
+  const parsed = readJsonFile(join17(root, relativePath));
   if (!parsed)
     return { ...base, redacted: {} };
   const redacted = redactValue({
@@ -33686,8 +35041,8 @@ function commandEnv(env, includeValues) {
 function defaultSnapshotDir() {
   const dbPath = getDatabasePath();
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
-    return join16(tmpdir2(), "hasna-todos", "environment-snapshots");
-  return join16(dirname15(resolve14(dbPath)), "environment-snapshots");
+    return join17(tmpdir2(), "hasna-todos", "environment-snapshots");
+  return join17(dirname15(resolve14(dbPath)), "environment-snapshots");
 }
 function snapshotWithId(snapshot) {
   const digest = sha2565(JSON.stringify(snapshot)).slice(0, 24);
@@ -33734,7 +35089,7 @@ function captureEnvironmentSnapshot(input = {}) {
   });
 }
 function writeEnvironmentSnapshot(snapshot, outputPath) {
-  const path = outputPath ? resolve14(outputPath) : join16(defaultSnapshotDir(), `${snapshot.id}.json`);
+  const path = outputPath ? resolve14(outputPath) : join17(defaultSnapshotDir(), `${snapshot.id}.json`);
   ensureDir2(dirname15(path));
   writeJsonFile(path, snapshot);
   return path;
@@ -33825,9 +35180,9 @@ function compareEnvironmentSnapshotFiles(leftPath, rightPath) {
 }
 // src/lib/decision-records.ts
 init_database();
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname16, join as join17 } from "path";
+import { dirname as dirname16, join as join18 } from "path";
 var DECISION_RECORD_SCHEMA = "todos.decision_record.v1";
 var KNOWLEDGE_SNAPSHOT_SCHEMA = "todos.knowledge_snapshot.v1";
 var DECISION_STATUSES = ["proposed", "accepted", "deprecated", "superseded", "rejected"];
@@ -33881,7 +35236,7 @@ function rowToDecisionRecord(row) {
 }
 function stableSnapshotHash(payload) {
   const { captured_at: _capturedAt, ...rest } = payload;
-  return createHash12("sha256").update(JSON.stringify(rest)).digest("hex");
+  return createHash13("sha256").update(JSON.stringify(rest)).digest("hex");
 }
 function createDecisionRecord(input, db) {
   const d = db || getDatabase();
@@ -34057,7 +35412,7 @@ function exportDecisionRecord(id, outputPath, format = "markdown", db) {
   if (!record)
     throw new Error(`Decision record not found: ${id}`);
   const content = format === "markdown" ? formatDecisionRecordMarkdown(record) : JSON.stringify(record, null, 2);
-  const path = outputPath ?? join17(process.cwd(), ".todos", "decisions", `${record.short_ref}.${format === "markdown" ? "md" : "json"}`);
+  const path = outputPath ?? join18(process.cwd(), ".todos", "decisions", `${record.short_ref}.${format === "markdown" ? "md" : "json"}`);
   mkdirSync17(dirname16(path), { recursive: true });
   writeFileSync15(path, content, "utf8");
   return { path, content };
@@ -34205,7 +35560,7 @@ function exportKnowledgeSnapshot(id, outputPath, format = "markdown", db) {
     throw new Error(`Knowledge snapshot not found: ${id}`);
   const content = format === "markdown" ? formatKnowledgeSnapshotMarkdown(record) : JSON.stringify(record, null, 2);
   const slug = record.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-  const path = outputPath ?? join17(process.cwd(), ".todos", "knowledge", `${slug || record.id.slice(0, 8)}.${format === "markdown" ? "md" : "json"}`);
+  const path = outputPath ?? join18(process.cwd(), ".todos", "knowledge", `${slug || record.id.slice(0, 8)}.${format === "markdown" ? "md" : "json"}`);
   mkdirSync17(dirname16(path), { recursive: true });
   writeFileSync15(path, content, "utf8");
   return { path, content };
@@ -34500,8 +35855,8 @@ todos report export --kind retrospective --days 14 --format markdown --out retro
 `;
 }
 // src/lib/command-aliases.ts
-import { existsSync as existsSync20, readFileSync as readFileSync20, writeFileSync as writeFileSync17, mkdirSync as mkdirSync19 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync17, mkdirSync as mkdirSync19 } from "fs";
+import { join as join19 } from "path";
 var COMMAND_ALIASES_SCHEMA = "todos.command_aliases.v1";
 var RESERVED = new Set([...listTopLevelCommands(), "help", "version", "alias", "shortcuts"]);
 var BUILTIN_SHORTCUTS = [
@@ -34520,7 +35875,7 @@ var BUILTIN_SHORTCUTS = [
   { pattern: /^reports?$/, argv: ["report", "docs"], explain: "Report export documentation" }
 ];
 function aliasesPath(cwd = process.cwd()) {
-  return join18(cwd, ".todos", "aliases.json");
+  return join19(cwd, ".todos", "aliases.json");
 }
 function emptyStore() {
   return { schema_version: COMMAND_ALIASES_SCHEMA, aliases: {}, updated_at: new Date(0).toISOString() };
@@ -34537,7 +35892,7 @@ function validateAliasName(name) {
 }
 function loadAliasStore(cwd) {
   const path = aliasesPath(cwd);
-  if (!existsSync20(path))
+  if (!existsSync21(path))
     return emptyStore();
   const parsed = JSON.parse(readFileSync20(path, "utf8"));
   if (parsed.schema_version !== COMMAND_ALIASES_SCHEMA) {
@@ -34547,7 +35902,7 @@ function loadAliasStore(cwd) {
 }
 function saveAliasStore(store, cwd) {
   const path = aliasesPath(cwd);
-  mkdirSync19(join18(path, ".."), { recursive: true });
+  mkdirSync19(join19(path, ".."), { recursive: true });
   store.updated_at = new Date().toISOString();
   writeFileSync17(path, JSON.stringify(store, null, 2), "utf8");
 }
@@ -35195,18 +36550,18 @@ function createBranchWorkPlan(input, db) {
 }
 // src/lib/user-scaffolds.ts
 init_database();
-import { existsSync as existsSync21, readFileSync as readFileSync21, writeFileSync as writeFileSync18, mkdirSync as mkdirSync20 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync18, mkdirSync as mkdirSync20 } from "fs";
+import { join as join20 } from "path";
 var USER_SCAFFOLD_SCHEMA = "todos.user_scaffold.v1";
 var SCAFFOLD_KINDS = ["task", "project", "plan", "checklist", "contract", "verification_policy"];
 function storeDir(cwd = process.cwd()) {
-  return join19(cwd, ".todos", "scaffolds");
+  return join20(cwd, ".todos", "scaffolds");
 }
 function storePath(cwd) {
-  return join19(storeDir(cwd), "store.json");
+  return join20(storeDir(cwd), "store.json");
 }
 function versionsDir(cwd) {
-  return join19(storeDir(cwd), "versions");
+  return join20(storeDir(cwd), "versions");
 }
 function slugify5(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -35216,7 +36571,7 @@ function emptyStore2() {
 }
 function loadUserScaffoldStore(cwd) {
   const path = storePath(cwd);
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return emptyStore2();
   const parsed = JSON.parse(readFileSync21(path, "utf8"));
   if (parsed.schema_version !== USER_SCAFFOLD_SCHEMA) {
@@ -35231,7 +36586,7 @@ function saveUserScaffoldStore(store, cwd) {
 }
 function snapshotVersion(scaffold, cwd) {
   mkdirSync20(versionsDir(cwd), { recursive: true });
-  const path = join19(versionsDir(cwd), `${scaffold.id}-v${scaffold.version}.json`);
+  const path = join20(versionsDir(cwd), `${scaffold.id}-v${scaffold.version}.json`);
   writeFileSync18(path, JSON.stringify(scaffold, null, 2), "utf8");
 }
 function listUserScaffolds(kind, cwd) {
@@ -35478,7 +36833,7 @@ function listLinkedTemplates(db, cwd) {
 // src/lib/agent-workflow-demo.ts
 init_database();
 import { mkdtempSync } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 var AGENT_WORKFLOW_DEMO_SCHEMA = "todos.agent_workflow_demo.v1";
 var DEMO_DEFAULT_AGENT = "demoagent";
@@ -35494,7 +36849,7 @@ function setupEphemeralDemoDb(options = {}) {
   if (options.db_path) {
     db_path = options.db_path;
   } else if (options.persist) {
-    db_path = join20(mkdtempSync(join20(tmpdir3(), "todos-demo-")), "todos.db");
+    db_path = join21(mkdtempSync(join21(tmpdir3(), "todos-demo-")), "todos.db");
   } else {
     db_path = ":memory:";
   }
@@ -37830,18 +39185,18 @@ function runSearchView(idOrName, db) {
   return { ...runSavedSearch(view.filters, view.scope, d), view };
 }
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync22, readFileSync as readFileSync22, readdirSync as readdirSync4, writeFileSync as writeFileSync19 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync22, readdirSync as readdirSync4, writeFileSync as writeFileSync19 } from "fs";
+import { join as join22 } from "path";
 init_config();
 init_sync_utils();
 function getTaskListDir(taskListId) {
-  return join21(HOME, ".claude", "tasks", taskListId);
+  return join22(HOME, ".claude", "tasks", taskListId);
 }
 function readClaudeTask(dir, filename) {
-  return readJsonFile(join21(dir, filename));
+  return readJsonFile(join22(dir, filename));
 }
 function writeClaudeTask(dir, task2) {
-  writeJsonFile(join21(dir, `${task2.id}.json`), task2);
+  writeJsonFile(join22(dir, `${task2.id}.json`), task2);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -37853,14 +39208,14 @@ function toSqliteStatus(status) {
   return status;
 }
 function readPrefixCounter(dir) {
-  const path = join21(dir, ".prefix-counter");
-  if (!existsSync22(path))
+  const path = join22(dir, ".prefix-counter");
+  if (!existsSync23(path))
     return 0;
   const val = parseInt(readFileSync22(path, "utf-8").trim(), 10);
   return isNaN(val) ? 0 : val;
 }
 function writePrefixCounter(dir, value) {
-  writeFileSync19(join21(dir, ".prefix-counter"), String(value));
+  writeFileSync19(join22(dir, ".prefix-counter"), String(value));
 }
 function formatPrefixedSubject(title, prefix, counter) {
   const padded = String(counter).padStart(5, "0");
@@ -37887,7 +39242,7 @@ function taskToClaudeTask(task2, claudeTaskId, existingMeta) {
 }
 function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync22(dir))
+  if (!existsSync23(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -37896,7 +39251,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join21(dir, f);
+    const path = join22(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
       existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
@@ -37983,7 +39338,7 @@ function pushToClaudeTaskList(taskListId, projectId, options = {}) {
 }
 function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync22(dir)) {
+  if (!existsSync23(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync4(dir).filter((f) => f.endsWith(".json"));
@@ -38003,7 +39358,7 @@ function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join21(dir, f);
+      const filePath = join22(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -38071,22 +39426,22 @@ function syncClaudeTaskList(taskListId, projectId, options = {}) {
 }
 
 // src/lib/agent-tasks.ts
-import { existsSync as existsSync23 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join23 } from "path";
 init_sync_utils();
 init_config();
 function agentBaseDir(agent) {
   const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
-  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join22(getTodosGlobalDir(), "agents");
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join23(getTodosGlobalDir(), "agents");
 }
 function getTaskListDir2(agent, taskListId) {
-  return join22(agentBaseDir(agent), agent, taskListId);
+  return join23(agentBaseDir(agent), agent, taskListId);
 }
 function readAgentTask(dir, filename) {
-  return readJsonFile(join22(dir, filename));
+  return readJsonFile(join23(dir, filename));
 }
 function writeAgentTask(dir, task2) {
-  writeJsonFile(join22(dir, `${task2.id}.json`), task2);
+  writeJsonFile(join23(dir, `${task2.id}.json`), task2);
 }
 function taskToAgentTask(task2, externalId, existingMeta) {
   return {
@@ -38111,7 +39466,7 @@ function metadataKey(agent) {
 }
 function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync23(dir))
+  if (!existsSync24(dir))
     ensureDir2(dir);
   const filter = {};
   if (projectId)
@@ -38120,7 +39475,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
   const existingByTodosId = new Map;
   const files = listJsonFiles(dir);
   for (const f of files) {
-    const path = join22(dir, f);
+    const path = join23(dir, f);
     const at = readAgentTask(dir, f);
     if (at?.metadata?.["todos_id"]) {
       existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
@@ -38194,7 +39549,7 @@ function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
 }
 function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   const dir = getTaskListDir2(agent, taskListId);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = listJsonFiles(dir);
@@ -38213,7 +39568,7 @@ function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
   }
   for (const f of files) {
     try {
-      const filePath = join22(dir, f);
+      const filePath = join23(dir, f);
       const at = readAgentTask(dir, f);
       if (!at)
         continue;
@@ -38351,9 +39706,9 @@ function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both"
   return { pushed, pulled, errors };
 }
 // src/lib/extract.ts
-import { existsSync as existsSync24, readFileSync as readFileSync23, statSync as statSync8 } from "fs";
-import { createHash as createHash13 } from "crypto";
-import { relative as relative6, resolve as resolve15, join as join23 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync23, statSync as statSync8 } from "fs";
+import { createHash as createHash14 } from "crypto";
+import { relative as relative6, resolve as resolve15, join as join24 } from "path";
 var EXTRACT_TAGS = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"];
 var DEFAULT_EXTENSIONS = new Set([
   ".ts",
@@ -38417,15 +39772,15 @@ var SKIP_DIRS2 = new Set([
   ".parcel-cache"
 ]);
 function stableHash(value) {
-  return createHash13("sha256").update(value).digest("hex");
+  return createHash14("sha256").update(value).digest("hex");
 }
 function normalizePathForMatch(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readGitignorePatterns(basePath) {
   const root = statSync8(basePath).isFile() ? resolve15(basePath, "..") : basePath;
-  const gitignorePath = join23(root, ".gitignore");
-  if (!existsSync24(gitignorePath))
+  const gitignorePath = join24(root, ".gitignore");
+  if (!existsSync25(gitignorePath))
     return [];
   try {
     return readFileSync23(gitignorePath, "utf-8").split(`
@@ -38567,7 +39922,7 @@ function buildCodebaseIndex(options) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const indexed = [];
   for (const file of files) {
-    const fullPath = statSync8(basePath).isFile() ? basePath : join23(basePath, file);
+    const fullPath = statSync8(basePath).isFile() ? basePath : join24(basePath, file);
     try {
       const source9 = readFileSync23(fullPath, "utf-8");
       const relPath = statSync8(basePath).isFile() ? relative6(resolve15(basePath, ".."), fullPath) : file;
@@ -38598,7 +39953,7 @@ function extractTodos(options, db) {
   const files = collectFiles(basePath, extensions, excludes, respectGitignore);
   const allComments = [];
   for (const file of files) {
-    const fullPath = statSync8(basePath).isFile() ? basePath : join23(basePath, file);
+    const fullPath = statSync8(basePath).isFile() ? basePath : join24(basePath, file);
     try {
       const source9 = readFileSync23(fullPath, "utf-8");
       const relPath = statSync8(basePath).isFile() ? relative6(resolve15(basePath, ".."), fullPath) : file;
@@ -38633,7 +39988,7 @@ function extractTodos(options, db) {
       skipped++;
       continue;
     }
-    const taskTags = ["extracted", comment.tag.toLowerCase(), ...options.tags || []];
+    const taskTags2 = ["extracted", comment.tag.toLowerCase(), ...options.tags || []];
     const task2 = createTask({
       title: `[${comment.tag}] ${comment.message}`,
       description: `Extracted from code comment in \`${comment.file}\` at line ${comment.line}:
@@ -38645,7 +40000,7 @@ ${comment.raw.trim()}
       task_list_id: options.task_list_id,
       assigned_to: options.assigned_to,
       agent_id: options.agent_id,
-      tags: taskTags,
+      tags: taskTags2,
       metadata: {
         source: "code_comment",
         comment_type: comment.tag,
@@ -38906,7 +40261,7 @@ init_config();
 // src/lib/natural-language-intake.ts
 init_database();
 init_redaction();
-var PRIORITIES3 = new Set(["low", "medium", "high", "critical"]);
+var PRIORITIES4 = new Set(["low", "medium", "high", "critical"]);
 function compact2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -38918,7 +40273,7 @@ function splitItems(text) {
 }
 function parsePriority(line, fallback) {
   const explicit = line.match(/\b(?:priority[:= ]+|p:)(critical|high|medium|low)\b/i)?.[1]?.toLowerCase();
-  if (explicit && PRIORITIES3.has(explicit))
+  if (explicit && PRIORITIES4.has(explicit))
     return explicit;
   if (/\b(p0|urgent|blocker|critical)\b/i.test(line))
     return "critical";
@@ -39305,7 +40660,7 @@ function renderWorkflowStatesMarkdown(states = listWorkflowStates()) {
 }
 // src/lib/agent-replay-simulator.ts
 init_redaction();
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { readFileSync as readFileSync24 } from "fs";
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -39327,7 +40682,7 @@ function stable2(value) {
   return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable2(value[key])]));
 }
 function fingerprint3(value) {
-  return createHash14("sha256").update(JSON.stringify(stable2(value))).digest("hex");
+  return createHash15("sha256").update(JSON.stringify(stable2(value))).digest("hex");
 }
 function unpackFixture(input) {
   if (!isObject(input))
@@ -39566,9 +40921,9 @@ function renderAgentReplaySimulationMarkdown(simulation) {
 }
 // src/lib/local-extensions.ts
 init_config();
-import { createHash as createHash15, createVerify } from "crypto";
-import { existsSync as existsSync25, readdirSync as readdirSync5, readFileSync as readFileSync25, statSync as statSync9 } from "fs";
-import { basename as basename5, join as join24, resolve as resolve16 } from "path";
+import { createHash as createHash16, createVerify } from "crypto";
+import { existsSync as existsSync26, readdirSync as readdirSync5, readFileSync as readFileSync25, statSync as statSync9 } from "fs";
+import { basename as basename5, join as join25, resolve as resolve16 } from "path";
 init_redaction();
 function isObject2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -39653,7 +41008,7 @@ function parseJson(path) {
   return JSON.parse(readFileSync25(path, "utf8"));
 }
 function sha2566(bytes) {
-  return `sha256:${createHash15("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash16("sha256").update(bytes).digest("hex")}`;
 }
 function compareVersions(a, b) {
   const left = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -39849,10 +41204,10 @@ function verifyExtensionSignature(input) {
 }
 function inspectExtensionSource(source9) {
   const resolved = resolve16(source9);
-  if (!existsSync25(resolved))
+  if (!existsSync26(resolved))
     throw new Error(`extension source not found: ${source9}`);
   const stat = statSync9(resolved);
-  const manifestPath = stat.isDirectory() ? [join24(resolved, "todos.extension.json"), join24(resolved, "extension.json")].find(existsSync25) : resolved;
+  const manifestPath = stat.isDirectory() ? [join25(resolved, "todos.extension.json"), join25(resolved, "extension.json")].find(existsSync26) : resolved;
   if (!manifestPath)
     throw new Error(`extension directory ${source9} is missing todos.extension.json`);
   const raw = readFileSync25(manifestPath);
@@ -39948,20 +41303,20 @@ function projectExtensionSources(projectPath) {
     return [];
   const root = resolve16(projectPath);
   const candidates = [
-    join24(root, "todos.extension.json"),
-    join24(root, ".todos", "todos.extension.json")
+    join25(root, "todos.extension.json"),
+    join25(root, ".todos", "todos.extension.json")
   ];
-  const extensionDir = join24(root, ".todos", "extensions");
-  if (existsSync25(extensionDir)) {
+  const extensionDir = join25(root, ".todos", "extensions");
+  if (existsSync26(extensionDir)) {
     for (const entry2 of readdirSync5(extensionDir)) {
       if (entry2.startsWith("."))
         continue;
-      const full = join24(extensionDir, entry2);
+      const full = join25(extensionDir, entry2);
       if (statSync9(full).isDirectory() || entry2.endsWith(".json"))
         candidates.push(full);
     }
   }
-  return candidates.filter(existsSync25);
+  return candidates.filter(existsSync26);
 }
 function discoverLocalExtensions(options = {}) {
   const config = loadConfig();
@@ -40248,6 +41603,18 @@ function formatDispatchMessage(tasks, opts = {}) {
 // src/lib/tmux.ts
 var DELAY_MIN = 3000;
 var DELAY_MAX = 5000;
+var IDLE_TMUX_COMMANDS = new Set([
+  "bash",
+  "dash",
+  "elvish",
+  "fish",
+  "ksh",
+  "nu",
+  "pwsh",
+  "sh",
+  "tmux",
+  "zsh"
+]);
 function parseTmuxTarget(spec) {
   if (!spec || spec.trim() === "") {
     throw new Error("tmux target spec cannot be empty");
@@ -40304,17 +41671,73 @@ async function validateTmuxTarget(spec) {
     throw new Error(`tmux target "${targetStr}" not found: ${stderr.trim() || "unknown error"}`);
   }
 }
+async function inspectTmuxPane(target) {
+  const proc = Bun.spawn([
+    "tmux",
+    "display-message",
+    "-p",
+    "-t",
+    target,
+    "#{pane_id}\t#{pane_current_command}\t#{pane_dead}\t#{pane_input_off}\t#{pane_in_mode}"
+  ], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`tmux target "${target}" not found: ${stderr.trim() || "unknown error"}`);
+  }
+  const stdout = (await new Response(proc.stdout).text()).trim();
+  const [paneId, currentCommand = "", paneDead = "0", inputOff = "0", inMode = "0"] = stdout.split("\t");
+  if (!paneId) {
+    throw new Error(`tmux target "${target}" did not resolve to a pane`);
+  }
+  return {
+    target,
+    paneId,
+    currentCommand,
+    paneDead: paneDead === "1",
+    inputOff: inputOff === "1",
+    inMode: inMode === "1"
+  };
+}
+function tmuxPaneBusyStatus(pane) {
+  if (pane.paneDead) {
+    return { busy: true, reason: "pane is dead" };
+  }
+  if (pane.inputOff) {
+    return { busy: true, reason: "pane input is disabled" };
+  }
+  if (pane.inMode) {
+    return { busy: true, reason: "pane is in copy or alternate mode" };
+  }
+  const currentCommand = pane.currentCommand.trim();
+  if (currentCommand && !IDLE_TMUX_COMMANDS.has(currentCommand)) {
+    return { busy: true, reason: `pane is running ${currentCommand}` };
+  }
+  return { busy: false, reason: null };
+}
 function calculateDelay(message) {
   const len = message.length;
   const extra = Math.floor(len / 100 * 40);
   return Math.min(DELAY_MIN + extra, DELAY_MAX);
 }
-async function sendToTmux(target, message, delayMs, dryRun = false) {
+async function sendToTmux(target, message, delayMs, options = false) {
+  const opts = typeof options === "boolean" ? { dryRun: options } : options;
+  const dryRun = opts.dryRun ?? false;
   if (dryRun) {
     console.log(`[dry-run] sendToTmux target=${target} delay=${delayMs}ms`);
     console.log(`[dry-run] message: ${message.slice(0, 200)}`);
     return;
   }
+  if (!opts.confirmBusy) {
+    const pane = await inspectTmuxPane(target);
+    const status = tmuxPaneBusyStatus(pane);
+    if (status.busy) {
+      throw new Error(`tmux target "${target}" appears busy (${status.reason}). Re-run with --confirm-busy to send anyway.`);
+    }
+  }
   const sendProc = Bun.spawn(["tmux", "send-keys", "-t", target, message, ""], {
     stdout: "pipe",
     stderr: "pipe"
@@ -40346,7 +41769,10 @@ async function executeDispatch(dispatch, opts = {}, db) {
   }
   const delayMs = dispatch.delay_ms ?? calculateDelay(message);
   try {
-    await sendToTmux(dispatch.target_window, message, delayMs, opts.dryRun ?? false);
+    await sendToTmux(dispatch.target_window, message, delayMs, {
+      dryRun: opts.dryRun ?? false,
+      confirmBusy: opts.confirmBusy ?? false
+    });
     createDispatchLog({
       dispatch_id: dispatch.id,
       target_window: dispatch.target_window,
@@ -40404,7 +41830,7 @@ async function dispatchToMultiple(input, opts = {}, db) {
 init_redaction();
 
 // src/lib/retention-cleanup.ts
-import { existsSync as existsSync26, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync27, unlinkSync as unlinkSync2 } from "fs";
 init_database();
 var RETENTION_CLEANUP_CONFIRMATION = "delete-local-retention-data";
 var ALL_SCOPES = ["comments", "runs", "verifications", "expired_artifacts"];
@@ -40616,7 +42042,7 @@ function applyRetentionCleanup(input, db) {
   for (const artifact of report.candidates.artifact_files) {
     try {
       const path = artifactStorePath(artifact.relative_path);
-      if (!existsSync26(path)) {
+      if (!existsSync27(path)) {
         report.warnings.push(`stored artifact already missing: ${artifact.relative_path}`);
         continue;
       }
@@ -40854,8 +42280,8 @@ function renderScalePerformanceReportMarkdown(report) {
 init_database();
 init_migrations();
 init_schema();
-import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync27, mkdirSync as mkdirSync21, statSync as statSync10 } from "fs";
-import { basename as basename6, dirname as dirname18, join as join25 } from "path";
+import { chmodSync, copyFileSync as copyFileSync2, existsSync as existsSync28, mkdirSync as mkdirSync21, statSync as statSync10 } from "fs";
+import { basename as basename6, dirname as dirname18, join as join26 } from "path";
 var REQUIRED_TABLES2 = [
   "_migrations",
   "projects",
@@ -40962,7 +42388,7 @@ function findMissingProjectRoots(db) {
       continue;
     if (!row.path.startsWith("/"))
       continue;
-    if (!existsSync27(row.path))
+    if (!existsSync28(row.path))
       missing++;
   }
   return missing;
@@ -41022,16 +42448,16 @@ function databasePermissionsAreUnsafe(dbPath) {
 function createBackup(dbPath) {
   if (dbPath === ":memory:" || dbPath.startsWith("file::memory:"))
     return;
-  if (!existsSync27(dbPath))
+  if (!existsSync28(dbPath))
     return;
   const stamp = now().replace(/[:.]/g, "-");
-  const backupDir = join25(dirname18(dbPath), `${basename6(dbPath)}.backup-${stamp}`);
+  const backupDir = join26(dirname18(dbPath), `${basename6(dbPath)}.backup-${stamp}`);
   const files = [];
   mkdirSync21(backupDir, { recursive: true });
   for (const source9 of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!existsSync27(source9))
+    if (!existsSync28(source9))
       continue;
-    const target = join25(backupDir, basename6(source9));
+    const target = join26(backupDir, basename6(source9));
     copyFileSync2(source9, target);
     files.push(target);
   }
@@ -41320,7 +42746,7 @@ function upsertCapacityProfile(input) {
   const store = readStore2();
   const key = profileKey(agentId, projectId);
   const existing = store.profiles[key];
-  const now3 = timestamp2();
+  const now4 = timestamp2();
   const profile = {
     id: existing?.id ?? key,
     agent_id: agentId,
@@ -41328,8 +42754,8 @@ function upsertCapacityProfile(input) {
     minutes_per_day: assertMinutes(input.minutes_per_day),
     working_days: normalizeWorkingDays(input.working_days),
     effective_from: cleanString2(input.effective_from),
-    created_at: existing?.created_at ?? now3,
-    updated_at: now3
+    created_at: existing?.created_at ?? now4,
+    updated_at: now4
   };
   store.profiles[key] = profile;
   writeStore2(store);
@@ -41726,6 +43152,8 @@ export {
   uuid,
   upsertWorkspaceTrustProfile,
   upsertVerificationProvider,
+  upsertTesterIssueReports,
+  upsertTesterIssueReport,
   upsertTerminalNotificationRule,
   upsertSecretSafetyConfig,
   upsertRunnerSandboxProfile,
@@ -41937,6 +43365,7 @@ export {
   recordTaskReview,
   recordFilesTouched,
   recordEnvironmentSnapshot,
+  readTesterIssueReportsPayload,
   readLocalBackupFile,
   readEnvironmentSnapshot,
   readBundleFile,
@@ -41975,6 +43404,7 @@ export {
   parseCiLog,
   now,
   notifyUpcomingDeadlines2 as notifyUpcomingDeadlines,
+  normalizeTesterIssueReport,
   normalizeScope,
   normalizeGeneratedAgentNames,
   normalizeFeatureManifest,
@@ -42363,6 +43793,7 @@ export {
   formatAgentWorkflowDemoReport,
   formatActivityRecordText,
   finishTaskRun,
+  fingerprintTesterIssueReport,
   fingerprintInboxInput,
   findTasksByFile,
   findTaskByCommit,
@@ -42422,7 +43853,7 @@ export {
   emitLocalEventHooksQuiet,
   emitLocalEventHooks,
   downloadRunArtifactsFromS3,
-  dispatchWebhook,
+  dispatchWebhook2 as dispatchWebhook,
   dispatchToMultiple,
   dismissReminder,
   discoverVerificationProviderCapabilities,
@@ -42665,6 +44096,9 @@ export {
   TODOS_CLI_MCP_PARITY,
   TODOS_CAPABILITIES,
   TODOS_API_ROUTES,
+  TESTERS_ISSUE_REPORT_SCHEMA_VERSION,
+  TESTERS_ISSUE_REPORT_RESULT_SCHEMA_VERSION,
+  TESTERS_ISSUE_REPORT_BATCH_RESULT_SCHEMA_VERSION,
   TASK_STATUSES,
   TASK_SCHEDULING_SCHEMA,
   TASK_PRIORITIES,