@hasna/todos 0.11.56 → 0.11.58

package/dist/registry.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);
@@ -4769,6 +4769,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",
@@ -5809,7 +5870,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();
@@ -6469,6 +6530,7 @@ function explainRunnerSandbox(input = {}) {
 // src/lib/event-hooks.ts
 init_config();
 var LOCAL_EVENT_TYPES = [
+  "task.created",
   "task.assigned",
   "task.blocked",
   "task.started",
@@ -6711,6 +6773,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) {
@@ -6973,7 +7781,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 : {};
@@ -7127,7 +7935,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) {
@@ -7471,18 +8282,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,
@@ -7500,6 +8300,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();
@@ -8232,9 +9048,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();
@@ -8270,8 +9089,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);
@@ -8312,8 +9144,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 };
@@ -8499,9 +9335,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",
@@ -8511,6 +9344,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;
@@ -8585,9 +9423,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();
@@ -9646,8 +10487,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:");
@@ -9659,15 +10500,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");
@@ -9708,7 +10549,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())
@@ -9725,9 +10566,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);
   }
@@ -9787,7 +10628,7 @@ function verifyStoredArtifact(input) {
     };
   }
   const storedPath = artifactStorePath(store.relative_path);
-  if (!existsSync7(storedPath)) {
+  if (!existsSync8(storedPath)) {
     return {
       id: input.id,
       path: input.path,
@@ -9868,15 +10709,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()) {
@@ -9889,7 +10730,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;
@@ -9899,7 +10740,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 {
@@ -9911,8 +10752,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) {
@@ -10987,7 +11828,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) {
@@ -11023,7 +11864,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),
@@ -11678,7 +12519,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);
@@ -12504,7 +13345,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) {
@@ -13814,7 +14655,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);
@@ -13835,9 +14676,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 [];
 }
@@ -13860,7 +14701,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]
   });
@@ -13918,7 +14759,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")
@@ -14109,8 +14950,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)
@@ -14125,7 +14966,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,
@@ -14149,7 +14990,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)),
@@ -14168,7 +15009,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)
     },
@@ -14176,7 +15017,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
       })),
@@ -14184,7 +15025,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
       })),
@@ -14195,14 +15036,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)
     },
@@ -14307,7 +15148,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([
@@ -14453,7 +15294,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);
@@ -15170,7 +16011,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,
@@ -15181,8 +16022,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);
@@ -15242,7 +16083,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,
@@ -15257,11 +16098,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;
 }
@@ -15321,7 +16162,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),
@@ -15332,8 +16173,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);
@@ -15724,7 +16565,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";
@@ -15770,7 +16611,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));
@@ -17182,6 +18023,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();
 
@@ -17284,13 +18589,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) {
@@ -17356,8 +18661,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,
@@ -17366,8 +18671,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
     };
@@ -18017,12 +19322,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) {
@@ -18355,7 +19660,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;
@@ -18377,11 +19682,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();
@@ -18414,7 +19719,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",
@@ -18471,7 +19776,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",
@@ -18506,7 +19811,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;