@ghostpaw/questlog 0.9.2 → 0.11.0

package/dist/mcp.cjs

@@ -2,10 +2,36 @@
 
 var node_fs = require('node:fs');
 var node_path = require('node:path');
+var node_crypto = require('node:crypto');
 var node_os = require('node:os');
 
 // src/surface/open_questlog_db.ts
 
+// src/hooks/init_hook_tables.ts
+function initHookTables(db) {
+  db.exec(`
+ CREATE TABLE IF NOT EXISTS hook_targets (
+ id INTEGER PRIMARY KEY AUTOINCREMENT, url TEXT NOT NULL, secret TEXT NOT NULL,
+ tag TEXT, events TEXT NOT NULL, min_gap INTEGER NOT NULL, created_at INTEGER NOT NULL,
+ last_wake INTEGER, lease_until INTEGER, claim TEXT);
+ CREATE TABLE IF NOT EXISTS hook_events (
+ id TEXT PRIMARY KEY, occurred_at INTEGER NOT NULL, event TEXT NOT NULL);
+ CREATE TABLE IF NOT EXISTS hook_assignments (
+ target_id INTEGER NOT NULL REFERENCES hook_targets(id) ON DELETE CASCADE,
+ event_id TEXT NOT NULL REFERENCES hook_events(id), delivery_id TEXT,
+ PRIMARY KEY(target_id, event_id));
+ CREATE TABLE IF NOT EXISTS hook_deliveries (
+ id TEXT PRIMARY KEY, target_id INTEGER NOT NULL REFERENCES hook_targets(id) ON DELETE CASCADE,
+ events TEXT NOT NULL, status TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0,
+ last_attempt_at INTEGER, http_status INTEGER, error_class TEXT,
+ next_attempt_at INTEGER NOT NULL);
+ CREATE INDEX IF NOT EXISTS idx_hook_deliveries_target ON hook_deliveries(target_id, status, next_attempt_at);
+ CREATE TABLE IF NOT EXISTS hook_settings (id INTEGER PRIMARY KEY CHECK(id = 1), label TEXT NOT NULL);
+ `);
+  if (!db.prepare("PRAGMA table_info(hook_targets)").all().some((row) => row.name === "headers"))
+    db.exec("ALTER TABLE hook_targets ADD COLUMN headers TEXT NOT NULL DEFAULT '{}'");
+}
+
 // src/questlines/init_questline_tables.ts
 function initQuestlineTables(db) {
   db.exec(`
@@ -354,6 +380,7 @@ function initQuestlogTables(db) {
   initTagTables(db);
   initQuestSearch(db);
   initRumorSearch(db);
+  initHookTables(db);
 }
 
 // src/surface/open_questlog_db.ts
@@ -372,7 +399,14 @@ async function openQuestlogDb(path) {
   } finally {
     process.emitWarning = original;
   }
-  if (path !== ":memory:") node_fs.mkdirSync(node_path.dirname(path), { recursive: true });
+  if (path !== ":memory:") {
+    node_fs.mkdirSync(node_path.dirname(path), { recursive: true, mode: 448 });
+    try {
+      node_fs.closeSync(node_fs.openSync(path, "wx", 384));
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
   const db = new sqlite.DatabaseSync(path);
   try {
     db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;");
@@ -386,7 +420,7 @@ async function openQuestlogDb(path) {
 }
 
 // src/version.ts
-var questlogVersion = "0.9.2";
+var questlogVersion = "0.11.0";
 
 // src/surface/questlog_mcp_instructions.ts
 var questlogMcpInstructions = "Questlog manages local tasks, calendar commitments, and recurring work. Search before creating work, inspect before changing it, and keep uncertain work as rumors. Use unlock prerequisites to sequence work. run_quest refuses blocked starts unless force is true. Review commitments and resolve work with an honest outcome.";
@@ -731,6 +765,7 @@ function validateInput(schema, input, path = "$") {
 
 // src/tools/action_requirements.ts
 var actionRequirements = {
+  manage_hooks: { remove: ["id"] },
   shape_work: {
     create_quest: ["quest"],
     create_questline: ["questline"],
@@ -1022,6 +1057,27 @@ var captureRumorTool = defineQuestlogTool({
   handler: captureRumorToolHandler
 });
 
+// src/hooks/list_deliveries.ts
+function listDeliveries(db, options = {}) {
+  return db.prepare(
+    `SELECT * FROM hook_deliveries ${options.includeDelivered ? "" : "WHERE status <> 'delivered'"} ORDER BY target_id, next_attempt_at, id`
+  ).all().map(
+    (row) => ({
+      id: String(row.id),
+      targetId: Number(row.target_id),
+      events: JSON.parse(String(row.events)),
+      status: row.status,
+      attempts: Number(row.attempts),
+      lastAttemptAt: row.last_attempt_at == null ? null : Number(row.last_attempt_at),
+      httpStatus: row.http_status == null ? null : Number(row.http_status),
+      errorClass: row.error_class == null ? null : String(row.error_class),
+      nextAttemptAt: Number(row.next_attempt_at)
+    })
+  ).filter(
+    (d) => options.questId === void 0 || d.events.some((e) => e.questId === options.questId)
+  );
+}
+
 // src/questlines/map_questline_row.ts
 function mapQuestlineRow(row) {
   return {
@@ -1499,7 +1555,8 @@ function inspectQuestlogItemToolHandler(db, input) {
               detail: detailLevel === "full" ? detail : toQuestCompactDetail(detail)
             },
             related,
-            detailLevel
+            detailLevel,
+            deliveries: listDeliveries(db, { questId: detail.id })
           },
           { entities }
         );
@@ -1604,13 +1661,42 @@ var inspectQuestlogItemTool = defineQuestlogTool({
   ),
   handler: inspectQuestlogItemToolHandler
 });
-
-// src/assert_non_negative_seconds.ts
-function assertNonNegativeSeconds(value, label) {
-  if (value != null && value < 0) {
-    throw new Error(`${label} must not be negative.`);
-  }
-  return value;
+function hookLabel(db, name) {
+  const saved = db.prepare("SELECT label FROM hook_settings WHERE id = 1").get();
+  if (saved) return String(saved.label);
+  const path = String(
+    db.prepare("PRAGMA database_list").all().find((row) => row.name === "main")?.file ?? ""
+  );
+  return path ? node_path.basename(path, node_path.extname(path)) : "questlog";
+}
+
+// src/hooks/list_hooks.ts
+function listHooks(db) {
+  return db.prepare(`SELECT id, url, headers, tag, events, min_gap, created_at, last_wake,
+ (SELECT COUNT(*) FROM hook_assignments a LEFT JOIN hook_deliveries d ON d.id = a.delivery_id WHERE a.target_id = t.id AND (a.delivery_id IS NULL OR d.status = 'pending')) AS pending,
+ (SELECT COUNT(*) FROM hook_deliveries d WHERE d.target_id = t.id AND d.status = 'failed') AS failed
+ FROM hook_targets t ORDER BY id`).all().map((row) => {
+    const url = new URL(String(row.url));
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return {
+      id: Number(row.id),
+      headers: Object.fromEntries(
+        Object.keys(JSON.parse(String(row.headers))).map((name) => [name, "***"])
+      ),
+      scope: row.tag == null ? "database" : "tag",
+      url: url.href,
+      tag: row.tag == null ? null : String(row.tag),
+      events: JSON.parse(String(row.events)),
+      minGap: Number(row.min_gap),
+      createdAt: Number(row.created_at),
+      lastWake: row.last_wake == null ? null : Number(row.last_wake),
+      pending: Number(row.pending),
+      failed: Number(row.failed)
+    };
+  });
 }
 
 // src/with_transaction.ts
@@ -1648,6 +1734,140 @@ function withTransaction(db, fn) {
   }
 }
 
+// src/hooks/remove_hook.ts
+function removeHook(db, id) {
+  withTransaction(db, () => {
+    db.prepare("DELETE FROM hook_assignments WHERE target_id = ?").run(id);
+    db.prepare("DELETE FROM hook_deliveries WHERE target_id = ?").run(id);
+    db.prepare("DELETE FROM hook_targets WHERE id = ?").run(id);
+  });
+}
+async function sendHookDelivery(db, delivery, target, options) {
+  const now = options.now ?? options.clock?.() ?? Date.now();
+  const timestamp = String(Math.floor(now / 1e3));
+  const body = JSON.stringify({
+    type: "questlog.events",
+    db: hookLabel(db),
+    deliveryId: delivery.id,
+    sentAt: new Date(now).toISOString(),
+    events: delivery.events
+  });
+  const signature = node_crypto.createHmac("sha256", target.secret).update(`${timestamp}.${body}`).digest("hex");
+  let status = null;
+  let errorClass = null;
+  try {
+    const response = await (options.fetch ?? globalThis.fetch)(target.url, {
+      method: "POST",
+      redirect: "error",
+      headers: {
+        "user-agent": `questlog/${questlogVersion}`,
+        ...JSON.parse(
+          String(
+            db.prepare("SELECT headers FROM hook_targets WHERE id = ?").get(target.id)?.headers ?? "{}"
+          )
+        ),
+        "content-type": "application/json",
+        "x-questlog-delivery": delivery.id,
+        "x-questlog-timestamp": timestamp,
+        "x-questlog-signature": `sha256=${signature}`
+      },
+      body,
+      signal: AbortSignal.timeout(Math.max(1, Math.min(options.timeoutMs ?? 5e3, 5e3)))
+    });
+    status = response.status;
+    await response.body?.cancel();
+  } catch (error) {
+    errorClass = error instanceof Error && ["TimeoutError", "AbortError"].includes(error.name) ? error.name : "NetworkError";
+  }
+  const delivered = status != null && status >= 200 && status < 300;
+  const completedAt = options.now ?? options.clock?.() ?? Date.now();
+  withTransaction(db, () => {
+    if (!db.prepare("SELECT id FROM hook_targets WHERE id = ? AND claim = ?").get(target.id, target.claim))
+      return;
+    const delay = Math.min(36e5, 3e4 * 2 ** (delivery.attempts - 1));
+    const jitter = Number.parseInt(node_crypto.randomBytes(2).toString("hex"), 16) % 1e3;
+    db.prepare(
+      "UPDATE hook_deliveries SET status = ?, http_status = ?, error_class = ?, next_attempt_at = ? WHERE id = ?"
+    ).run(
+      delivered ? "delivered" : delivery.attempts >= 8 ? "failed" : "pending",
+      status,
+      errorClass,
+      completedAt + delay + jitter,
+      delivery.id
+    );
+    db.prepare(
+      "UPDATE hook_targets SET claim = NULL, lease_until = NULL WHERE id = ? AND claim = ?"
+    ).run(target.id, target.claim);
+    db.prepare(
+      "DELETE FROM hook_deliveries WHERE target_id = ? AND status = 'delivered' AND id NOT IN (SELECT id FROM hook_deliveries WHERE target_id = ? AND status = 'delivered' ORDER BY last_attempt_at DESC, id DESC LIMIT 500)"
+    ).run(target.id, target.id);
+  });
+  return delivered;
+}
+
+// src/quests/get_quest_or_throw.ts
+function getQuestOrThrow(db, questId) {
+  const row = db.prepare("SELECT * FROM quests WHERE id = ? AND deleted_at IS NULL").get(questId);
+  if (!row) {
+    throw new Error(`Quest ${questId} was not found.`);
+  }
+  return mapQuestRow(row);
+}
+
+// src/rewards/copy_repeatable_quest_rewards_to_quest.ts
+function copyRepeatableQuestRewardsToQuest(db, repeatableQuestId, questId, now) {
+  const effectiveNow = resolveNow(now);
+  const rows = db.prepare(
+    `SELECT kind, name, description, quantity
+       FROM repeatable_quest_rewards
+       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
+  ).all(repeatableQuestId);
+  for (const row of rows) {
+    db.prepare(
+      `INSERT INTO quest_rewards (quest_id, kind, name, description, quantity, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      questId,
+      String(row.kind),
+      String(row.name),
+      row.description == null ? null : String(row.description),
+      row.quantity == null ? null : Number(row.quantity),
+      effectiveNow
+    );
+  }
+}
+
+// src/tags/copy_repeatable_quest_tags_to_quest.ts
+function copyRepeatableQuestTagsToQuest(db, repeatableQuestId, questId, now) {
+  const effectiveNow = resolveNow(now);
+  const rows = db.prepare(
+    `SELECT tag_id
+       FROM repeatable_quest_tags
+       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
+  ).all(repeatableQuestId);
+  for (const row of rows) {
+    db.prepare(
+      `INSERT INTO quest_tags (quest_id, tag_id, created_at)
+       VALUES (?, ?, ?)`
+    ).run(questId, Number(row.tag_id), effectiveNow);
+  }
+}
+
+// src/repeatable_quests/advance_anchor.ts
+var WEEK_MS = 7 * 864e5;
+function advanceAnchor(anchorAt, freq, interval) {
+  const date = new Date(anchorAt);
+  if (freq === "MONTHLY") {
+    date.setUTCMonth(date.getUTCMonth() + interval);
+    return date.getTime();
+  }
+  if (freq === "YEARLY") {
+    date.setUTCFullYear(date.getUTCFullYear() + interval);
+    return date.getTime();
+  }
+  return anchorAt + interval * WEEK_MS;
+}
+
 // src/repeatable_quests/parse_rrule.ts
 var WEEKDAY = {
   SU: 0,
@@ -1691,265 +1911,76 @@ function parseRRule(rrule) {
   return { freq, interval, count, until, byDay };
 }
 
-// src/repeatable_quests/update_repeatable_quest.ts
-function updateRepeatableQuest(db, repeatableQuestId, input) {
-  return withTransaction(db, () => {
-    const current = getRepeatableQuestOrThrow(db, repeatableQuestId);
-    const now = resolveNow(input.now);
-    const rrule = input.rrule ?? current.rrule;
-    parseRRule(rrule);
-    db.prepare(
-      `UPDATE repeatable_quests
-       SET questline_id = ?,
-           title = ?,
-           objective = ?,
-           rrule = ?,
-           anchor_at = ?,
-           not_before_offset_seconds = ?,
-           due_offset_seconds = ?,
-           scheduled_start_offset_seconds = ?,
-           scheduled_end_offset_seconds = ?,
-           all_day = ?,
-           estimate_seconds = ?,
-           archived_at = ?,
-           updated_at = ?
-       WHERE id = ? AND deleted_at IS NULL`
-    ).run(
-      input.questlineId === void 0 ? current.questlineId : input.questlineId,
-      input.title == null ? current.title : assertNonEmpty(input.title, "Repeatable quest title"),
-      input.objective == null ? current.objective : assertNonEmpty(input.objective, "Repeatable quest objective"),
-      rrule,
-      input.anchorAt ?? current.anchorAt,
-      input.notBeforeOffsetSeconds === void 0 ? current.notBeforeOffsetSeconds : assertNonNegativeSeconds(input.notBeforeOffsetSeconds, "Repeatable not-before offset") ?? null,
-      input.dueOffsetSeconds === void 0 ? current.dueOffsetSeconds : assertNonNegativeSeconds(input.dueOffsetSeconds, "Repeatable due offset") ?? null,
-      input.scheduledStartOffsetSeconds === void 0 ? current.scheduledStartOffsetSeconds : input.scheduledStartOffsetSeconds,
-      input.scheduledEndOffsetSeconds === void 0 ? current.scheduledEndOffsetSeconds : input.scheduledEndOffsetSeconds,
-      input.allDay === void 0 ? current.allDay ? 1 : 0 : input.allDay ? 1 : 0,
-      input.estimateSeconds === void 0 ? current.estimateSeconds : assertNonNegativeSeconds(input.estimateSeconds, "Repeatable estimate") ?? null,
-      input.archivedAt === void 0 ? current.archivedAt : input.archivedAt,
-      now,
-      repeatableQuestId
-    );
-    return getRepeatableQuestOrThrow(db, repeatableQuestId);
-  });
+// src/repeatable_quests/start_of_utc_day.ts
+function startOfUtcDay(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
 }
 
-// src/repeatable_quests/archive_repeatable_quest.ts
-function archiveRepeatableQuest(db, repeatableQuestId, archivedAt) {
-  return updateRepeatableQuest(db, repeatableQuestId, { archivedAt: resolveNow(archivedAt) });
+// src/repeatable_quests/start_of_utc_week.ts
+var DAY_MS = 864e5;
+function startOfUtcWeek(dayStart) {
+  const date = new Date(dayStart);
+  return dayStart - date.getUTCDay() * DAY_MS;
 }
 
-// src/assert_active_row_exists.ts
-function assertActiveRowExists(db, table, id, label) {
-  const row = db.prepare(`SELECT id FROM ${table} WHERE id = ? AND deleted_at IS NULL`).get(id);
-  if (!row) {
-    throw new Error(`${label} ${id} was not found.`);
+// src/repeatable_quests/generate_anchors_until.ts
+var DAY_MS2 = 864e5;
+var WEEK_MS2 = 7 * DAY_MS2;
+function generateAnchorsUntil(repeatable, now) {
+  const rule = parseRRule(repeatable.rrule);
+  const anchors = [];
+  const until = rule.until == null ? now : Math.min(now, rule.until);
+  if (repeatable.anchorAt > until) {
+    return anchors;
   }
-}
-
-// src/assert_non_negative_number.ts
-function assertNonNegativeNumber(value, label) {
-  if (value != null && value < 0) {
-    throw new Error(`${label} must not be negative.`);
+  if (rule.freq === "DAILY") {
+    let occurrence2 = 0;
+    for (let current2 = repeatable.anchorAt; current2 <= until; current2 += rule.interval * DAY_MS2) {
+      occurrence2 += 1;
+      if (rule.count != null && occurrence2 > rule.count) {
+        break;
+      }
+      anchors.push(current2);
+    }
+    return anchors;
   }
-  return value;
-}
-
-// src/rewards/replace_active_repeatable_quest_rewards.ts
-function replaceActiveRepeatableQuestRewards(db, repeatableQuestId, rewards, now) {
-  const effectiveNow = resolveNow(now);
-  db.prepare(
-    "UPDATE repeatable_quest_rewards SET deleted_at = ? WHERE repeatable_quest_id = ? AND deleted_at IS NULL"
-  ).run(effectiveNow, repeatableQuestId);
-  for (const reward of rewards) {
-    db.prepare(
-      `INSERT INTO repeatable_quest_rewards (
-         repeatable_quest_id,
-         kind,
-         name,
-         description,
-         quantity,
-         created_at
-       ) VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(
-      repeatableQuestId,
-      assertNonEmpty(reward.kind, "Reward kind"),
-      assertNonEmpty(reward.name, "Reward name"),
-      reward.description?.trim() || null,
-      assertNonNegativeNumber(reward.quantity, "Reward quantity") ?? null,
-      effectiveNow
-    );
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    const anchorDayStart = startOfUtcDay(repeatable.anchorAt);
+    const anchorWeekStart = startOfUtcWeek(anchorDayStart);
+    const timeOffset = repeatable.anchorAt - anchorDayStart;
+    let occurrence2 = 0;
+    for (let day = anchorDayStart; day <= until; day += DAY_MS2) {
+      const weeksSince = Math.floor((startOfUtcWeek(day) - anchorWeekStart) / WEEK_MS2);
+      if (weeksSince < 0 || weeksSince % rule.interval !== 0) {
+        continue;
+      }
+      if (!rule.byDay.includes(new Date(day).getUTCDay())) {
+        continue;
+      }
+      const anchor = day + timeOffset;
+      if (anchor < repeatable.anchorAt || anchor > until) {
+        continue;
+      }
+      occurrence2 += 1;
+      if (rule.count != null && occurrence2 > rule.count) {
+        break;
+      }
+      anchors.push(anchor);
+    }
+    return anchors;
+  }
+  let occurrence = 0;
+  let current = repeatable.anchorAt;
+  while (current <= until) {
+    occurrence += 1;
+    if (rule.count != null && occurrence > rule.count) {
+      break;
+    }
+    anchors.push(current);
+    current = advanceAnchor(current, rule.freq, rule.interval);
   }
-}
-
-// src/tags/replace_active_repeatable_quest_tags.ts
-function getOrCreateTagId(db, name, now) {
-  const normalizedName = normalizeTagName(name);
-  if (!normalizedName) {
-    throw new Error("Tag name must not be empty.");
-  }
-  const existing = db.prepare("SELECT id FROM tags WHERE normalized_name = ? AND deleted_at IS NULL").get(normalizedName);
-  if (existing) {
-    return Number(existing.id);
-  }
-  const created = db.prepare(
-    `INSERT INTO tags (name, normalized_name, created_at)
-       VALUES (?, ?, ?)`
-  ).run(name.trim(), normalizedName, now);
-  return Number(created.lastInsertRowid);
-}
-function replaceActiveRepeatableQuestTags(db, repeatableQuestId, tagNames, now) {
-  const effectiveNow = resolveNow(now);
-  db.prepare(
-    "UPDATE repeatable_quest_tags SET deleted_at = ? WHERE repeatable_quest_id = ? AND deleted_at IS NULL"
-  ).run(effectiveNow, repeatableQuestId);
-  const uniqueNames = [...new Set(tagNames.map((tag) => tag.trim()).filter(Boolean))];
-  for (const name of uniqueNames) {
-    const tagId = getOrCreateTagId(db, name, effectiveNow);
-    db.prepare(
-      `INSERT INTO repeatable_quest_tags (repeatable_quest_id, tag_id, created_at)
-       VALUES (?, ?, ?)`
-    ).run(repeatableQuestId, tagId, effectiveNow);
-  }
-}
-
-// src/repeatable_quests/create_repeatable_quest.ts
-function createRepeatableQuest(db, input) {
-  return withTransaction(db, () => {
-    const now = resolveNow(input.now);
-    const title = assertNonEmpty(input.title, "Repeatable quest title");
-    const objective = assertNonEmpty(input.objective, "Repeatable quest objective");
-    parseRRule(input.rrule);
-    if (input.questlineId != null) {
-      assertActiveRowExists(db, "questlines", input.questlineId, "Questline");
-    }
-    const created = db.prepare(
-      `INSERT INTO repeatable_quests (
-           questline_id,
-           title,
-           objective,
-           rrule,
-           anchor_at,
-           not_before_offset_seconds,
-           due_offset_seconds,
-           scheduled_start_offset_seconds,
-           scheduled_end_offset_seconds,
-           all_day,
-           estimate_seconds,
-           created_at,
-           updated_at
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      input.questlineId ?? null,
-      title,
-      objective,
-      input.rrule,
-      input.anchorAt,
-      assertNonNegativeSeconds(input.notBeforeOffsetSeconds, "Repeatable not-before offset") ?? null,
-      assertNonNegativeSeconds(input.dueOffsetSeconds, "Repeatable due offset") ?? null,
-      input.scheduledStartOffsetSeconds ?? null,
-      input.scheduledEndOffsetSeconds ?? null,
-      input.allDay ? 1 : 0,
-      assertNonNegativeSeconds(input.estimateSeconds, "Repeatable estimate") ?? null,
-      now,
-      now
-    );
-    const repeatableQuestId = Number(created.lastInsertRowid);
-    if (input.tags && input.tags.length > 0) {
-      replaceActiveRepeatableQuestTags(db, repeatableQuestId, input.tags, now);
-    }
-    if (input.rewards && input.rewards.length > 0) {
-      replaceActiveRepeatableQuestRewards(db, repeatableQuestId, input.rewards, now);
-    }
-    return getRepeatableQuestOrThrow(db, repeatableQuestId);
-  });
-}
-
-// src/repeatable_quests/advance_anchor.ts
-var WEEK_MS = 7 * 864e5;
-function advanceAnchor(anchorAt, freq, interval) {
-  const date = new Date(anchorAt);
-  if (freq === "MONTHLY") {
-    date.setUTCMonth(date.getUTCMonth() + interval);
-    return date.getTime();
-  }
-  if (freq === "YEARLY") {
-    date.setUTCFullYear(date.getUTCFullYear() + interval);
-    return date.getTime();
-  }
-  return anchorAt + interval * WEEK_MS;
-}
-
-// src/repeatable_quests/start_of_utc_day.ts
-function startOfUtcDay(timestamp) {
-  const date = new Date(timestamp);
-  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
-}
-
-// src/repeatable_quests/start_of_utc_week.ts
-var DAY_MS = 864e5;
-function startOfUtcWeek(dayStart) {
-  const date = new Date(dayStart);
-  return dayStart - date.getUTCDay() * DAY_MS;
-}
-
-// src/repeatable_quests/generate_anchors_until.ts
-var DAY_MS2 = 864e5;
-var WEEK_MS2 = 7 * DAY_MS2;
-function generateAnchorsUntil(repeatable, now) {
-  const rule = parseRRule(repeatable.rrule);
-  const anchors = [];
-  const until = rule.until == null ? now : Math.min(now, rule.until);
-  if (repeatable.anchorAt > until) {
-    return anchors;
-  }
-  if (rule.freq === "DAILY") {
-    let occurrence2 = 0;
-    for (let current2 = repeatable.anchorAt; current2 <= until; current2 += rule.interval * DAY_MS2) {
-      occurrence2 += 1;
-      if (rule.count != null && occurrence2 > rule.count) {
-        break;
-      }
-      anchors.push(current2);
-    }
-    return anchors;
-  }
-  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
-    const anchorDayStart = startOfUtcDay(repeatable.anchorAt);
-    const anchorWeekStart = startOfUtcWeek(anchorDayStart);
-    const timeOffset = repeatable.anchorAt - anchorDayStart;
-    let occurrence2 = 0;
-    for (let day = anchorDayStart; day <= until; day += DAY_MS2) {
-      const weeksSince = Math.floor((startOfUtcWeek(day) - anchorWeekStart) / WEEK_MS2);
-      if (weeksSince < 0 || weeksSince % rule.interval !== 0) {
-        continue;
-      }
-      if (!rule.byDay.includes(new Date(day).getUTCDay())) {
-        continue;
-      }
-      const anchor = day + timeOffset;
-      if (anchor < repeatable.anchorAt || anchor > until) {
-        continue;
-      }
-      occurrence2 += 1;
-      if (rule.count != null && occurrence2 > rule.count) {
-        break;
-      }
-      anchors.push(anchor);
-    }
-    return anchors;
-  }
-  let occurrence = 0;
-  let current = repeatable.anchorAt;
-  while (current <= until) {
-    occurrence += 1;
-    if (rule.count != null && occurrence > rule.count) {
-      break;
-    }
-    anchors.push(current);
-    current = advanceAnchor(current, rule.freq, rule.interval);
-  }
-  return anchors;
+  return anchors;
 }
 
 // src/repeatable_quests/list_due_repeatable_quest_anchors.ts
@@ -1997,65 +2028,6 @@ function listDueRepeatableQuestAnchors(db, now) {
   );
 }
 
-// src/repeatable_quests/soft_delete_repeatable_quest.ts
-function softDeleteRepeatableQuest(db, repeatableQuestId, deletedAt) {
-  const now = resolveNow(deletedAt);
-  getRepeatableQuestOrThrow(db, repeatableQuestId);
-  db.prepare(
-    `UPDATE repeatable_quests
-     SET deleted_at = ?, updated_at = ?
-     WHERE id = ? AND deleted_at IS NULL`
-  ).run(now, now, repeatableQuestId);
-}
-
-// src/quests/get_quest_or_throw.ts
-function getQuestOrThrow(db, questId) {
-  const row = db.prepare("SELECT * FROM quests WHERE id = ? AND deleted_at IS NULL").get(questId);
-  if (!row) {
-    throw new Error(`Quest ${questId} was not found.`);
-  }
-  return mapQuestRow(row);
-}
-
-// src/rewards/copy_repeatable_quest_rewards_to_quest.ts
-function copyRepeatableQuestRewardsToQuest(db, repeatableQuestId, questId, now) {
-  const effectiveNow = resolveNow(now);
-  const rows = db.prepare(
-    `SELECT kind, name, description, quantity
-       FROM repeatable_quest_rewards
-       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
-  ).all(repeatableQuestId);
-  for (const row of rows) {
-    db.prepare(
-      `INSERT INTO quest_rewards (quest_id, kind, name, description, quantity, created_at)
-       VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(
-      questId,
-      String(row.kind),
-      String(row.name),
-      row.description == null ? null : String(row.description),
-      row.quantity == null ? null : Number(row.quantity),
-      effectiveNow
-    );
-  }
-}
-
-// src/tags/copy_repeatable_quest_tags_to_quest.ts
-function copyRepeatableQuestTagsToQuest(db, repeatableQuestId, questId, now) {
-  const effectiveNow = resolveNow(now);
-  const rows = db.prepare(
-    `SELECT tag_id
-       FROM repeatable_quest_tags
-       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
-  ).all(repeatableQuestId);
-  for (const row of rows) {
-    db.prepare(
-      `INSERT INTO quest_tags (quest_id, tag_id, created_at)
-       VALUES (?, ?, ?)`
-    ).run(questId, Number(row.tag_id), effectiveNow);
-  }
-}
-
 // src/repeatable_quests/spawn_due_repeatable_quests.ts
 function spawnDueRepeatableQuests(db, now) {
   return withTransaction(db, () => {
@@ -2106,6 +2078,410 @@ function spawnDueRepeatableQuests(db, now) {
   });
 }
 
+// src/hooks/detect_hook_events.ts
+function detectHookEvents(db, now) {
+  const events = [];
+  const add = (type, at, ids) => {
+    events.push({
+      id: `e_${type}_${ids.questId ?? ids.rumorId}_${ids.repeatableId ?? ""}_${at}`,
+      type,
+      ...ids,
+      occurredAt: new Date(at).toISOString()
+    });
+  };
+  for (const { detail: q } of queryQuestDetailRecords(db, {}, now)) {
+    if (q.resolvedAt == null && q.effectiveDueAt != null && q.effectiveDueAt <= now) {
+      add("quest.due", q.effectiveDueAt, { questId: q.id });
+      if (q.effectiveDueAt < now) add("quest.overdue", q.effectiveDueAt, { questId: q.id });
+    }
+    if (q.available) {
+      const prerequisites = db.prepare(
+        `SELECT p.id, p.resolved_at, u.created_at FROM quest_unlocks u JOIN quests p ON p.id = u.from_quest_id WHERE u.to_quest_id = ? AND u.deleted_at IS NULL AND p.deleted_at IS NULL AND p.success = 1 AND p.resolved_at IS NOT NULL`
+      ).all(q.id);
+      if (prerequisites.some((p) => Number(p.resolved_at) >= Number(p.created_at))) {
+        const at = Math.max(q.notBeforeAt ?? 0, ...prerequisites.map((p) => Number(p.resolved_at)));
+        if (at <= now) add("quest.unblocked", at, { questId: q.id });
+      }
+    }
+    if (q.spawnedFromRepeatableId != null && q.createdAt <= now)
+      add("repeatable.spawned", q.createdAt, {
+        questId: q.id,
+        repeatableId: q.spawnedFromRepeatableId
+      });
+  }
+  for (const row of db.prepare("SELECT id, created_at FROM rumors WHERE deleted_at IS NULL AND created_at <= ?").all(now))
+    add("rumor.captured", Number(row.created_at), { rumorId: Number(row.id) });
+  return events.sort(
+    (a, b) => a.occurredAt.localeCompare(b.occurredAt) || a.id.localeCompare(b.id)
+  );
+}
+
+// src/hooks/tick_questlog.ts
+async function tickQuestlog(db, options = {}) {
+  const now = options.now ?? options.clock?.() ?? Date.now();
+  const result = {
+    events: [],
+    batches: [],
+    sent: 0,
+    queued: 0,
+    retrying: 0,
+    failed: 0
+  };
+  const claims = [];
+  const collect = () => {
+    spawnDueRepeatableQuests(db, now);
+    const detected = detectHookEvents(db, now);
+    result.events = detected.filter(
+      (e) => !db.prepare("SELECT id FROM hook_events WHERE id = ?").get(e.id)
+    );
+    for (const event of result.events)
+      db.prepare("INSERT INTO hook_events(id, occurred_at, event) VALUES (?, ?, ?)").run(
+        event.id,
+        Date.parse(event.occurredAt),
+        JSON.stringify(event)
+      );
+    for (const target of listHooks(db)) {
+      const events = db.prepare(
+        "SELECT e.event FROM hook_events e WHERE occurred_at >= ? AND NOT EXISTS (SELECT 1 FROM hook_assignments a WHERE a.target_id = ? AND a.event_id = e.id) ORDER BY occurred_at, id"
+      ).all(target.createdAt, target.id).map((row2) => JSON.parse(String(row2.event))).filter((event) => {
+        if (!target.events.includes(event.type)) return false;
+        if (target.tag == null) return true;
+        return event.questId !== void 0 && db.prepare(
+          "SELECT 1 FROM quest_tags qt JOIN tags t ON t.id = qt.tag_id WHERE qt.quest_id = ? AND qt.deleted_at IS NULL AND t.deleted_at IS NULL AND t.normalized_name = ?"
+        ).get(event.questId, normalizeTagName(target.tag)) !== void 0;
+      });
+      for (const event of events)
+        db.prepare("INSERT INTO hook_assignments(target_id, event_id) VALUES (?, ?)").run(
+          target.id,
+          event.id
+        );
+      const row = db.prepare("SELECT url, secret, lease_until FROM hook_targets WHERE id = ?").get(target.id);
+      if (!row || row.lease_until != null && Number(row.lease_until) > now) continue;
+      let pending = listDeliveries(db).find(
+        (d) => d.targetId === target.id && d.status === "pending"
+      );
+      const queued = db.prepare(
+        "SELECT e.event FROM hook_assignments a JOIN hook_events e ON e.id = a.event_id WHERE a.target_id = ? AND a.delivery_id IS NULL ORDER BY e.occurred_at, e.id"
+      ).all(target.id).map((r) => JSON.parse(String(r.event)));
+      if (!pending && queued.length) {
+        const id = `d_${node_crypto.randomBytes(16).toString("hex")}`;
+        db.prepare(
+          "INSERT INTO hook_deliveries(id, target_id, events, status, next_attempt_at) VALUES (?, ?, ?, 'pending', ?)"
+        ).run(
+          id,
+          target.id,
+          JSON.stringify(queued),
+          Math.max(now, (target.lastWake ?? -Infinity) + target.minGap * 1e3)
+        );
+        db.prepare(
+          "UPDATE hook_assignments SET delivery_id = ? WHERE target_id = ? AND delivery_id IS NULL"
+        ).run(id, target.id);
+        pending = listDeliveries(db).find((d) => d.id === id);
+      }
+      if (!pending) continue;
+      if (pending.attempts === 0 && queued.length && !queued.every((e) => pending?.events.some((p) => p.id === e.id))) {
+        pending.events.push(...queued);
+        db.prepare("UPDATE hook_deliveries SET events = ? WHERE id = ?").run(
+          JSON.stringify(pending.events),
+          pending.id
+        );
+        db.prepare(
+          "UPDATE hook_assignments SET delivery_id = ? WHERE target_id = ? AND delivery_id IS NULL"
+        ).run(pending.id, target.id);
+      }
+      if (pending.nextAttemptAt > now || target.lastWake != null && target.lastWake + target.minGap * 1e3 > now)
+        continue;
+      if (pending.attempts >= 8) {
+        db.prepare("UPDATE hook_deliveries SET status = 'failed' WHERE id = ?").run(pending.id);
+        continue;
+      }
+      const claim = node_crypto.randomBytes(16).toString("hex");
+      db.prepare(
+        "UPDATE hook_targets SET claim = ?, lease_until = ?, last_wake = ? WHERE id = ?"
+      ).run(claim, now + 12e4, now, target.id);
+      db.prepare(
+        "UPDATE hook_deliveries SET attempts = attempts + 1, last_attempt_at = ? WHERE id = ?"
+      ).run(now, pending.id);
+      pending.attempts++;
+      pending.lastAttemptAt = now;
+      result.batches.push({ targetId: target.id, events: pending.events });
+      claims.push({
+        delivery: pending,
+        target: { id: target.id, url: String(row.url), secret: String(row.secret), claim }
+      });
+    }
+  };
+  if (options.dryRun) {
+    const rollback = new Error("preview rollback");
+    try {
+      withTransaction(db, () => {
+        collect();
+        throw rollback;
+      });
+    } catch (error) {
+      if (error !== rollback) throw error;
+    }
+  } else withTransaction(db, collect);
+  if (!options.dryRun) {
+    const sent = await Promise.all(
+      claims.map((claim) => sendHookDelivery(db, claim.delivery, claim.target, options))
+    );
+    result.sent = sent.filter(Boolean).length;
+  }
+  const deliveries = listDeliveries(db);
+  result.queued = deliveries.filter((d) => d.status === "pending" && d.attempts === 0).length + Number(
+    db.prepare(
+      "SELECT COUNT(DISTINCT target_id) AS n FROM hook_assignments WHERE delivery_id IS NULL"
+    ).get()?.n ?? 0
+  );
+  result.retrying = deliveries.filter((d) => d.status === "pending" && d.attempts > 0).length;
+  result.failed = deliveries.filter((d) => d.status === "failed").length;
+  return result;
+}
+
+// src/tools/manage_hooks_tool.ts
+var manageHooksTool = defineQuestlogTool({
+  name: "manage_hooks",
+  description: "List or remove outbound webhook targets, run a tick, or inspect pending and failed deliveries.",
+  whenToUse: "Use to operate configured outbound webhooks. Add and test targets with the CLI.",
+  whenNotToUse: "Use quest tools to change work itself.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["hook"],
+  inputDescriptions: {
+    action: "Operation to perform.",
+    id: "Target id for removal.",
+    dry_run: "Preview a tick without recording or sending."
+  },
+  outputDescription: "Returns redacted targets, delivery metadata, or a tick summary. Never returns signing secrets.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation.", ["list", "remove", "tick", "deliveries"]),
+      id: integerSchema("Target id."),
+      dry_run: booleanSchema("Preview only.")
+    },
+    ["action"]
+  ),
+  handler: async (db, input) => {
+    switch (input.action) {
+      case "list":
+        return toolSuccess("Webhook targets.", listHooks(db));
+      case "deliveries":
+        return toolSuccess("Pending and failed deliveries.", listDeliveries(db));
+      case "remove":
+        if (!Number.isSafeInteger(input.id) || Number(input.id) < 1)
+          return toolFailure(
+            "protocol",
+            "invalid_input",
+            "Target id required.",
+            "Provide a positive target id.",
+            { recovery: 'Pass {"action":"remove","id":1}' }
+          );
+        removeHook(db, Number(input.id));
+        return toolSuccess("Webhook target removed.", {});
+      case "tick":
+        return toolSuccess(
+          "Webhook tick completed.",
+          await tickQuestlog(db, { dryRun: input.dry_run ?? false })
+        );
+    }
+  }
+});
+
+// src/assert_non_negative_seconds.ts
+function assertNonNegativeSeconds(value, label) {
+  if (value != null && value < 0) {
+    throw new Error(`${label} must not be negative.`);
+  }
+  return value;
+}
+
+// src/repeatable_quests/update_repeatable_quest.ts
+function updateRepeatableQuest(db, repeatableQuestId, input) {
+  return withTransaction(db, () => {
+    const current = getRepeatableQuestOrThrow(db, repeatableQuestId);
+    const now = resolveNow(input.now);
+    const rrule = input.rrule ?? current.rrule;
+    parseRRule(rrule);
+    db.prepare(
+      `UPDATE repeatable_quests
+       SET questline_id = ?,
+           title = ?,
+           objective = ?,
+           rrule = ?,
+           anchor_at = ?,
+           not_before_offset_seconds = ?,
+           due_offset_seconds = ?,
+           scheduled_start_offset_seconds = ?,
+           scheduled_end_offset_seconds = ?,
+           all_day = ?,
+           estimate_seconds = ?,
+           archived_at = ?,
+           updated_at = ?
+       WHERE id = ? AND deleted_at IS NULL`
+    ).run(
+      input.questlineId === void 0 ? current.questlineId : input.questlineId,
+      input.title == null ? current.title : assertNonEmpty(input.title, "Repeatable quest title"),
+      input.objective == null ? current.objective : assertNonEmpty(input.objective, "Repeatable quest objective"),
+      rrule,
+      input.anchorAt ?? current.anchorAt,
+      input.notBeforeOffsetSeconds === void 0 ? current.notBeforeOffsetSeconds : assertNonNegativeSeconds(input.notBeforeOffsetSeconds, "Repeatable not-before offset") ?? null,
+      input.dueOffsetSeconds === void 0 ? current.dueOffsetSeconds : assertNonNegativeSeconds(input.dueOffsetSeconds, "Repeatable due offset") ?? null,
+      input.scheduledStartOffsetSeconds === void 0 ? current.scheduledStartOffsetSeconds : input.scheduledStartOffsetSeconds,
+      input.scheduledEndOffsetSeconds === void 0 ? current.scheduledEndOffsetSeconds : input.scheduledEndOffsetSeconds,
+      input.allDay === void 0 ? current.allDay ? 1 : 0 : input.allDay ? 1 : 0,
+      input.estimateSeconds === void 0 ? current.estimateSeconds : assertNonNegativeSeconds(input.estimateSeconds, "Repeatable estimate") ?? null,
+      input.archivedAt === void 0 ? current.archivedAt : input.archivedAt,
+      now,
+      repeatableQuestId
+    );
+    return getRepeatableQuestOrThrow(db, repeatableQuestId);
+  });
+}
+
+// src/repeatable_quests/archive_repeatable_quest.ts
+function archiveRepeatableQuest(db, repeatableQuestId, archivedAt) {
+  return updateRepeatableQuest(db, repeatableQuestId, { archivedAt: resolveNow(archivedAt) });
+}
+
+// src/assert_active_row_exists.ts
+function assertActiveRowExists(db, table, id, label) {
+  const row = db.prepare(`SELECT id FROM ${table} WHERE id = ? AND deleted_at IS NULL`).get(id);
+  if (!row) {
+    throw new Error(`${label} ${id} was not found.`);
+  }
+}
+
+// src/assert_non_negative_number.ts
+function assertNonNegativeNumber(value, label) {
+  if (value != null && value < 0) {
+    throw new Error(`${label} must not be negative.`);
+  }
+  return value;
+}
+
+// src/rewards/replace_active_repeatable_quest_rewards.ts
+function replaceActiveRepeatableQuestRewards(db, repeatableQuestId, rewards, now) {
+  const effectiveNow = resolveNow(now);
+  db.prepare(
+    "UPDATE repeatable_quest_rewards SET deleted_at = ? WHERE repeatable_quest_id = ? AND deleted_at IS NULL"
+  ).run(effectiveNow, repeatableQuestId);
+  for (const reward of rewards) {
+    db.prepare(
+      `INSERT INTO repeatable_quest_rewards (
+         repeatable_quest_id,
+         kind,
+         name,
+         description,
+         quantity,
+         created_at
+       ) VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      repeatableQuestId,
+      assertNonEmpty(reward.kind, "Reward kind"),
+      assertNonEmpty(reward.name, "Reward name"),
+      reward.description?.trim() || null,
+      assertNonNegativeNumber(reward.quantity, "Reward quantity") ?? null,
+      effectiveNow
+    );
+  }
+}
+
+// src/tags/replace_active_repeatable_quest_tags.ts
+function getOrCreateTagId(db, name, now) {
+  const normalizedName = normalizeTagName(name);
+  if (!normalizedName) {
+    throw new Error("Tag name must not be empty.");
+  }
+  const existing = db.prepare("SELECT id FROM tags WHERE normalized_name = ? AND deleted_at IS NULL").get(normalizedName);
+  if (existing) {
+    return Number(existing.id);
+  }
+  const created = db.prepare(
+    `INSERT INTO tags (name, normalized_name, created_at)
+       VALUES (?, ?, ?)`
+  ).run(name.trim(), normalizedName, now);
+  return Number(created.lastInsertRowid);
+}
+function replaceActiveRepeatableQuestTags(db, repeatableQuestId, tagNames, now) {
+  const effectiveNow = resolveNow(now);
+  db.prepare(
+    "UPDATE repeatable_quest_tags SET deleted_at = ? WHERE repeatable_quest_id = ? AND deleted_at IS NULL"
+  ).run(effectiveNow, repeatableQuestId);
+  const uniqueNames = [...new Set(tagNames.map((tag) => tag.trim()).filter(Boolean))];
+  for (const name of uniqueNames) {
+    const tagId = getOrCreateTagId(db, name, effectiveNow);
+    db.prepare(
+      `INSERT INTO repeatable_quest_tags (repeatable_quest_id, tag_id, created_at)
+       VALUES (?, ?, ?)`
+    ).run(repeatableQuestId, tagId, effectiveNow);
+  }
+}
+
+// src/repeatable_quests/create_repeatable_quest.ts
+function createRepeatableQuest(db, input) {
+  return withTransaction(db, () => {
+    const now = resolveNow(input.now);
+    const title = assertNonEmpty(input.title, "Repeatable quest title");
+    const objective = assertNonEmpty(input.objective, "Repeatable quest objective");
+    parseRRule(input.rrule);
+    if (input.questlineId != null) {
+      assertActiveRowExists(db, "questlines", input.questlineId, "Questline");
+    }
+    const created = db.prepare(
+      `INSERT INTO repeatable_quests (
+           questline_id,
+           title,
+           objective,
+           rrule,
+           anchor_at,
+           not_before_offset_seconds,
+           due_offset_seconds,
+           scheduled_start_offset_seconds,
+           scheduled_end_offset_seconds,
+           all_day,
+           estimate_seconds,
+           created_at,
+           updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.questlineId ?? null,
+      title,
+      objective,
+      input.rrule,
+      input.anchorAt,
+      assertNonNegativeSeconds(input.notBeforeOffsetSeconds, "Repeatable not-before offset") ?? null,
+      assertNonNegativeSeconds(input.dueOffsetSeconds, "Repeatable due offset") ?? null,
+      input.scheduledStartOffsetSeconds ?? null,
+      input.scheduledEndOffsetSeconds ?? null,
+      input.allDay ? 1 : 0,
+      assertNonNegativeSeconds(input.estimateSeconds, "Repeatable estimate") ?? null,
+      now,
+      now
+    );
+    const repeatableQuestId = Number(created.lastInsertRowid);
+    if (input.tags && input.tags.length > 0) {
+      replaceActiveRepeatableQuestTags(db, repeatableQuestId, input.tags, now);
+    }
+    if (input.rewards && input.rewards.length > 0) {
+      replaceActiveRepeatableQuestRewards(db, repeatableQuestId, input.rewards, now);
+    }
+    return getRepeatableQuestOrThrow(db, repeatableQuestId);
+  });
+}
+
+// src/repeatable_quests/soft_delete_repeatable_quest.ts
+function softDeleteRepeatableQuest(db, repeatableQuestId, deletedAt) {
+  const now = resolveNow(deletedAt);
+  getRepeatableQuestOrThrow(db, repeatableQuestId);
+  db.prepare(
+    `UPDATE repeatable_quests
+     SET deleted_at = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(now, now, repeatableQuestId);
+}
+
 // src/tools/manage_repeatable_tool.ts
 function manageRepeatableToolHandler(db, input) {
   try {
@@ -3325,7 +3701,7 @@ function validateReviewInput(input) {
       'Use `filters.dayAt` only with `view: "quests.scheduled_for_day"`.'
     );
   }
-  if ((input.view === "rumors" || input.view === "questlines") && hasQuestFilters(input.filters)) {
+  if ((input.view === "rumors" || input.view === "questlines" || input.view === "deliveries") && hasQuestFilters(input.filters)) {
     return toolFailure(
       "protocol",
       "invalid_input",
@@ -3393,6 +3769,15 @@ function reviewQuestlogToolHandler(db, input) {
   if (invalid) {
     return invalid;
   }
+  if (input.view === "deliveries")
+    return toolSuccess("Pending and failed deliveries.", {
+      view: input.view,
+      items: [],
+      deliveries: listDeliveries(db),
+      count: listDeliveries(db).length,
+      appliedFilters: input.filters,
+      evaluatedAt: input.now ?? Date.now()
+    });
   const now = input.now ?? Date.now();
   let items = [];
   switch (input.view) {
@@ -3452,6 +3837,7 @@ var reviewQuestlogTool = defineQuestlogTool({
   inputSchema: objectSchema(
     {
       view: enumSchema("Which operational review surface to return.", [
+        "deliveries",
         "questlines",
         "quests.active",
         "quests.available",
@@ -4814,6 +5200,7 @@ var tagWorkTool = defineQuestlogTool({
 
 // src/tools/tool_registry.ts
 var questlogTools = [
+  manageHooksTool,
   searchQuestlogTool,
   reviewQuestlogTool,
   inspectQuestlogItemTool,