@ghostpaw/questlog 0.9.1 → 0.10.1

package/dist/mcp-server.js

@@ -1,18 +1,79 @@
 #!/usr/bin/env node
 import { mkdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { basename, extname, dirname, join } from 'node:path';
+import { randomBytes, createHmac } from 'node:crypto';
 import { homedir } from 'node:os';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/surfaces/schema_actions.ts
+function registerSchemaActions(schema, actions) {
+  requirements.set(schema, actions);
+}
+function requiredForAction(schema, action) {
+  return requirements.get(schema)?.[String(action)] ?? [];
+}
+var requirements;
+var init_schema_actions = __esm({
+  "src/surfaces/schema_actions.ts"() {
+    requirements = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/surfaces/schema_examples.ts
+function minimalInput(schema, action, name = "") {
+  const constant = "const" in schema ? schema.const : void 0;
+  if (constant !== void 0) return constant;
+  if (schema.enum)
+    return action !== void 0 && schema.enum.includes(action) ? action : schema.enum[0];
+  const branch = schema.oneOf?.[0];
+  if (schema.type === "object" || schema.properties) {
+    action ??= schema.properties?.action?.enum?.[0];
+    const properties = { ...schema.properties, ...branch?.properties };
+    return Object.fromEntries(
+      [
+        .../* @__PURE__ */ new Set([
+          ...schema.required ?? [],
+          ...requiredForAction(schema, action),
+          ...schema.properties?.outcome && ["finish", "abandon", "abandon_and_spawn_followups"].includes(String(action)) ? ["outcome"] : [],
+          ...branch?.required ?? []
+        ])
+      ].map((key) => [
+        key,
+        minimalInput(properties[key] ?? {}, key === "action" ? action : void 0, key)
+      ])
+    );
+  }
+  if (branch) return minimalInput(branch, action, name);
+  if (schema.type === "array") return [minimalInput(schema.items ?? {}, void 0, name)];
+  if (schema.type === "integer" || schema.type === "number")
+    return name === "anchorAt" ? 18e11 : name === "toQuestId" ? 2 : 1;
+  if (schema.type === "boolean") return false;
+  if (schema.type === "null") return null;
+  if (name === "rrule") return "FREQ=WEEKLY";
+  if (name === "title") return "Review release notes";
+  if (name === "objective") return "Check changes against the release";
+  return "release";
+}
+var init_schema_examples = __esm({
+  "src/surfaces/schema_examples.ts"() {
+    init_schema_actions();
+  }
+});
+
 // src/surfaces/surface_types.ts
 function isErrorResult(result) {
   return typeof result === "object" && result !== null && "ok" in result && result.ok === false;
@@ -46,11 +107,22 @@ function validateInput(schema, input, path = "$") {
   }
   if (schema.enum && !schema.enum.some((value) => JSON.stringify(value) === JSON.stringify(input)))
     errors.push(`${path}: expected one of ${JSON.stringify(schema.enum)}`);
-  if (schema.oneOf && !schema.oneOf.some((branch) => validateInput(branch, input, path).length === 0))
-    errors.push(`${path}: must match at least one schema branch`);
+  const constant = "const" in schema ? schema.const : void 0;
+  if (constant !== void 0 && constant !== input)
+    errors.push(`${path}: expected ${JSON.stringify(constant)}`);
+  if (schema.oneOf) {
+    const branches = schema.oneOf.map((branch) => validateInput(branch, input, path));
+    if (!branches.some((errors2) => errors2.length === 0)) {
+      errors.push(
+        ...branches.sort((a, b) => a.length - b.length)[0] ?? [
+          `${path}: must match at least one schema branch`
+        ]
+      );
+    }
+  }
   if (typeof input === "object" && input !== null && !Array.isArray(input)) {
     const record = input;
-    for (const name of schema.required ?? [])
+    for (const name of [...schema.required ?? [], ...requiredForAction(schema, record.action)])
       if (!Object.hasOwn(record, name)) errors.push(`${path}.${name}: required`);
     for (const [name, property] of Object.entries(schema.properties ?? {}))
       if (Object.hasOwn(record, name))
@@ -64,6 +136,7 @@ function validateInput(schema, input, path = "$") {
 }
 var init_validate_input = __esm({
   "src/surfaces/validate_input.ts"() {
+    init_schema_actions();
   }
 });
 
@@ -158,7 +231,15 @@ Not for: ${tool.whenNotToUse}` : ""),
         const input = params.arguments === void 0 ? {} : params.arguments;
         const errors = validateInput(tool.inputSchema, input);
         if (errors.length)
-          return result({ content: [{ type: "text", text: errors.join("\n") }], isError: true });
+          return result({
+            content: [
+              {
+                type: "text",
+                text: `${errors.join("\n")}; pass ${JSON.stringify(minimalInput(tool.inputSchema, input?.action))}`
+              }
+            ],
+            isError: true
+          });
         try {
           context ??= Promise.resolve().then(options.context);
           const value = await tool.handler(await context, input);
@@ -197,6 +278,7 @@ Not for: ${tool.whenNotToUse}` : ""),
 var MCP_LATEST_PROTOCOL_VERSION, MCP_SUPPORTED_PROTOCOL_VERSIONS;
 var init_mcp_server = __esm({
   "src/surfaces/mcp_server.ts"() {
+    init_schema_examples();
     init_surface_types();
     init_validate_input();
     MCP_LATEST_PROTOCOL_VERSION = "2026-07-28";
@@ -242,6 +324,33 @@ var init_mcp_stdio = __esm({
   }
 });
 
+// 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);
+ `);
+}
+var init_init_hook_tables = __esm({
+  "src/hooks/init_hook_tables.ts"() {
+  }
+});
+
 // src/questlines/init_questline_tables.ts
 function initQuestlineTables(db) {
   db.exec(`
@@ -626,9 +735,11 @@ function initQuestlogTables(db) {
   initTagTables(db);
   initQuestSearch(db);
   initRumorSearch(db);
+  initHookTables(db);
 }
 var init_init_questlog_tables = __esm({
   "src/init_questlog_tables.ts"() {
+    init_init_hook_tables();
     init_init_questline_tables();
     init_init_quest_search();
     init_init_quest_tables();
@@ -677,7 +788,7 @@ var init_open_questlog_db = __esm({
 var questlogVersion;
 var init_version = __esm({
   "src/version.ts"() {
-    questlogVersion = "0.9.1";
+    questlogVersion = "0.10.1";
   }
 });
 
@@ -979,8 +1090,62 @@ var init_tool_errors = __esm({
   }
 });
 
+// src/tools/action_requirements.ts
+var actionRequirements;
+var init_action_requirements = __esm({
+  "src/tools/action_requirements.ts"() {
+    actionRequirements = {
+      manage_hooks: { remove: ["id"] },
+      shape_work: {
+        create_quest: ["quest"],
+        create_questline: ["questline"],
+        attach_quest_to_questline: ["questId", "questlineId"],
+        detach_quest_from_questline: ["questId"],
+        dismiss_rumor: ["rumorId"],
+        reopen_rumor: ["rumorId"],
+        settle_rumor: ["rumorId"],
+        update_rumor: ["rumorId"]
+      },
+      manage_repeatable: {
+        create: ["repeatableQuest"],
+        archive: ["repeatableQuestId"],
+        update: ["repeatableQuestId"],
+        spawn_due: ["now"]
+      },
+      organize_work: {
+        add_unlock: ["fromQuestId", "toQuestId"],
+        remove_unlock: ["fromQuestId", "toQuestId"],
+        replace_unlocks: ["fromQuestIds", "toQuestId"],
+        archive_questline: ["questlineId"],
+        set_questline_fields: ["questlineId"]
+      },
+      plan_quest: { revise_objective: ["objective"] },
+      run_quest: {
+        abandon_and_spawn_followups: ["followups"],
+        log_effort: ["effortSeconds"]
+      },
+      reward_work: { add: ["reward"], update: ["reward"], replace_repeatable_template: ["rewards"] }
+    };
+  }
+});
+
 // src/tools/tool_metadata.ts
 function defineQuestlogTool(definition) {
+  const requirements2 = actionRequirements[definition.name];
+  if (requirements2) registerSchemaActions(definition.inputSchema, requirements2);
+  const handler = definition.handler;
+  definition.handler = (db, input) => {
+    const errors = validateInput(definition.inputSchema, input);
+    if (errors.length) {
+      const action = input?.action;
+      const example = minimalInput(definition.inputSchema, action);
+      const message = errors.join("; ");
+      return toolFailure("protocol", "invalid_input", message, message, {
+        recovery: `${message}; pass ${JSON.stringify(example)}`
+      });
+    }
+    return handler(db, input);
+  };
   return definition;
 }
 function stringSchema(description, options = {}) {
@@ -1023,6 +1188,11 @@ function objectSchema(properties, required, description) {
 }
 var init_tool_metadata = __esm({
   "src/tools/tool_metadata.ts"() {
+    init_schema_actions();
+    init_schema_examples();
+    init_validate_input();
+    init_action_requirements();
+    init_tool_types();
   }
 });
 
@@ -1259,6 +1429,31 @@ var init_capture_rumor_tool = __esm({
   }
 });
 
+// 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)
+  );
+}
+var init_list_deliveries = __esm({
+  "src/hooks/list_deliveries.ts"() {
+  }
+});
+
 // src/questlines/map_questline_row.ts
 function mapQuestlineRow(row) {
   return {
@@ -1805,7 +2000,8 @@ function inspectQuestlogItemToolHandler(db, input) {
               detail: detailLevel === "full" ? detail : toQuestCompactDetail(detail)
             },
             related,
-            detailLevel
+            detailLevel,
+            deliveries: listDeliveries(db, { questId: detail.id })
           },
           { entities }
         );
@@ -1875,6 +2071,7 @@ function inspectQuestlogItemToolHandler(db, input) {
 var inspectQuestlogItemTool;
 var init_inspect_questlog_item_tool = __esm({
   "src/tools/inspect_questlog_item_tool.ts"() {
+    init_list_deliveries();
     init_get_questline_detail();
     init_get_quest_detail();
     init_get_repeatable_quest_or_throw();
@@ -1925,16 +2122,46 @@ var init_inspect_questlog_item_tool = __esm({
     });
   }
 });
-
-// src/assert_non_negative_seconds.ts
-function assertNonNegativeSeconds(value, label) {
-  if (value != null && value < 0) {
-    throw new Error(`${label} must not be negative.`);
+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 ? basename(path, extname(path)) : "questlog";
+}
+var init_hook_label = __esm({
+  "src/hooks/hook_label.ts"() {
   }
-  return value;
+});
+
+// src/hooks/list_hooks.ts
+function listHooks(db) {
+  return db.prepare(`SELECT id, url, 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),
+      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)
+    };
+  });
 }
-var init_assert_non_negative_seconds = __esm({
-  "src/assert_non_negative_seconds.ts"() {
+var init_list_hooks = __esm({
+  "src/hooks/list_hooks.ts"() {
   }
 });
 
@@ -1978,6 +2205,167 @@ var init_with_transaction = __esm({
   }
 });
 
+// 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);
+  });
+}
+var init_remove_hook = __esm({
+  "src/hooks/remove_hook.ts"() {
+    init_with_transaction();
+  }
+});
+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 = 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: {
+        "content-type": "application/json",
+        "user-agent": `questlog/${questlogVersion}`,
+        "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(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;
+}
+var init_send_hook_delivery = __esm({
+  "src/hooks/send_hook_delivery.ts"() {
+    init_version();
+    init_with_transaction();
+    init_hook_label();
+  }
+});
+
+// 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);
+}
+var init_get_quest_or_throw = __esm({
+  "src/quests/get_quest_or_throw.ts"() {
+    init_map_quest_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
+    );
+  }
+}
+var init_copy_repeatable_quest_rewards_to_quest = __esm({
+  "src/rewards/copy_repeatable_quest_rewards_to_quest.ts"() {
+    init_resolve_now();
+  }
+});
+
+// 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);
+  }
+}
+var init_copy_repeatable_quest_tags_to_quest = __esm({
+  "src/tags/copy_repeatable_quest_tags_to_quest.ts"() {
+    init_resolve_now();
+  }
+});
+
+// src/repeatable_quests/advance_anchor.ts
+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;
+}
+var WEEK_MS;
+var init_advance_anchor = __esm({
+  "src/repeatable_quests/advance_anchor.ts"() {
+    WEEK_MS = 7 * 864e5;
+  }
+});
+
 // src/repeatable_quests/parse_rrule.ts
 function parseRRule(rrule) {
   const parts = Object.fromEntries(
@@ -2026,279 +2414,35 @@ var init_parse_rrule = __esm({
   }
 });
 
-// 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());
 }
-var init_update_repeatable_quest = __esm({
-  "src/repeatable_quests/update_repeatable_quest.ts"() {
-    init_assert_non_empty();
-    init_assert_non_negative_seconds();
-    init_resolve_now();
-    init_with_transaction();
-    init_get_repeatable_quest_or_throw();
-    init_parse_rrule();
+var init_start_of_utc_day = __esm({
+  "src/repeatable_quests/start_of_utc_day.ts"() {
   }
 });
 
-// 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
+function startOfUtcWeek(dayStart) {
+  const date = new Date(dayStart);
+  return dayStart - date.getUTCDay() * DAY_MS;
 }
-var init_archive_repeatable_quest = __esm({
-  "src/repeatable_quests/archive_repeatable_quest.ts"() {
-    init_resolve_now();
-    init_update_repeatable_quest();
+var DAY_MS;
+var init_start_of_utc_week = __esm({
+  "src/repeatable_quests/start_of_utc_week.ts"() {
+    DAY_MS = 864e5;
   }
 });
 
-// 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.`);
-  }
-}
-var init_assert_active_row_exists = __esm({
-  "src/assert_active_row_exists.ts"() {
-  }
-});
-
-// 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;
-}
-var init_assert_non_negative_number = __esm({
-  "src/assert_non_negative_number.ts"() {
-  }
-});
-
-// 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
-    );
-  }
-}
-var init_replace_active_repeatable_quest_rewards = __esm({
-  "src/rewards/replace_active_repeatable_quest_rewards.ts"() {
-    init_assert_non_empty();
-    init_assert_non_negative_number();
-    init_resolve_now();
-  }
-});
-
-// 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);
-  }
-}
-var init_replace_active_repeatable_quest_tags = __esm({
-  "src/tags/replace_active_repeatable_quest_tags.ts"() {
-    init_resolve_now();
-    init_normalize_tag_name();
-  }
-});
-
-// 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);
-  });
-}
-var init_create_repeatable_quest = __esm({
-  "src/repeatable_quests/create_repeatable_quest.ts"() {
-    init_assert_active_row_exists();
-    init_assert_non_empty();
-    init_assert_non_negative_seconds();
-    init_resolve_now();
-    init_replace_active_repeatable_quest_rewards();
-    init_replace_active_repeatable_quest_tags();
-    init_with_transaction();
-    init_get_repeatable_quest_or_throw();
-    init_parse_rrule();
-  }
-});
-
-// src/repeatable_quests/advance_anchor.ts
-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;
-}
-var WEEK_MS;
-var init_advance_anchor = __esm({
-  "src/repeatable_quests/advance_anchor.ts"() {
-    WEEK_MS = 7 * 864e5;
-  }
-});
-
-// 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());
-}
-var init_start_of_utc_day = __esm({
-  "src/repeatable_quests/start_of_utc_day.ts"() {
-  }
-});
-
-// src/repeatable_quests/start_of_utc_week.ts
-function startOfUtcWeek(dayStart) {
-  const date = new Date(dayStart);
-  return dayStart - date.getUTCDay() * DAY_MS;
-}
-var DAY_MS;
-var init_start_of_utc_week = __esm({
-  "src/repeatable_quests/start_of_utc_week.ts"() {
-    DAY_MS = 864e5;
-  }
-});
-
-// src/repeatable_quests/generate_anchors_until.ts
-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/repeatable_quests/generate_anchors_until.ts
+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;
@@ -2411,143 +2555,559 @@ var init_list_due_repeatable_quest_anchors = __esm({
   }
 });
 
-// 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/repeatable_quests/spawn_due_repeatable_quests.ts
+function spawnDueRepeatableQuests(db, now) {
+  return withTransaction(db, () => {
+    const anchors = listDueRepeatableQuestAnchors(db, now);
+    const quests = [];
+    for (const anchor of anchors) {
+      const repeatable = getRepeatableQuestOrThrow(db, anchor.repeatableQuestId);
+      const created = db.prepare(
+        `INSERT INTO quests (
+             questline_id,
+             source_rumor_id,
+             spawned_by_quest_id,
+             spawned_from_repeatable_id,
+             spawned_for_at,
+             title,
+             objective,
+             created_at,
+             updated_at,
+             effort_seconds,
+             estimate_seconds,
+             not_before_at,
+             due_at,
+             scheduled_start_at,
+             scheduled_end_at,
+             all_day
+           ) VALUES (?, NULL, NULL, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        repeatable.questlineId ?? null,
+        repeatable.id,
+        anchor.anchorAt,
+        repeatable.title,
+        repeatable.objective,
+        now,
+        now,
+        repeatable.estimateSeconds ?? null,
+        repeatable.notBeforeOffsetSeconds == null ? null : anchor.anchorAt + repeatable.notBeforeOffsetSeconds * 1e3,
+        repeatable.dueOffsetSeconds == null ? null : anchor.anchorAt + repeatable.dueOffsetSeconds * 1e3,
+        repeatable.scheduledStartOffsetSeconds == null ? null : anchor.anchorAt + repeatable.scheduledStartOffsetSeconds * 1e3,
+        repeatable.scheduledEndOffsetSeconds == null ? null : anchor.anchorAt + repeatable.scheduledEndOffsetSeconds * 1e3,
+        repeatable.allDay ? 1 : 0
+      );
+      const questId = Number(created.lastInsertRowid);
+      copyRepeatableQuestTagsToQuest(db, repeatable.id, questId, now);
+      copyRepeatableQuestRewardsToQuest(db, repeatable.id, questId, now);
+      quests.push(getQuestOrThrow(db, questId));
+    }
+    return quests;
+  });
+}
+var init_spawn_due_repeatable_quests = __esm({
+  "src/repeatable_quests/spawn_due_repeatable_quests.ts"() {
+    init_get_quest_or_throw();
+    init_copy_repeatable_quest_rewards_to_quest();
+    init_copy_repeatable_quest_tags_to_quest();
+    init_with_transaction();
+    init_get_repeatable_quest_or_throw();
+    init_list_due_repeatable_quest_anchors();
+  }
+});
+
+// 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)
+  );
+}
+var init_detect_hook_events = __esm({
+  "src/hooks/detect_hook_events.ts"() {
+    init_query_quest_detail_records();
+  }
+});
+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_${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 = 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;
+}
+var init_tick_questlog = __esm({
+  "src/hooks/tick_questlog.ts"() {
+    init_spawn_due_repeatable_quests();
+    init_normalize_tag_name();
+    init_with_transaction();
+    init_detect_hook_events();
+    init_list_deliveries();
+    init_list_hooks();
+    init_send_hook_delivery();
+  }
+});
+
+// src/hooks/index.ts
+var init_hooks = __esm({
+  "src/hooks/index.ts"() {
+    init_list_deliveries();
+    init_list_hooks();
+    init_remove_hook();
+    init_tick_questlog();
+  }
+});
+
+// src/tools/manage_hooks_tool.ts
+var manageHooksTool;
+var init_manage_hooks_tool = __esm({
+  "src/tools/manage_hooks_tool.ts"() {
+    init_hooks();
+    init_tool_metadata();
+    init_tool_types();
+    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;
+}
+var init_assert_non_negative_seconds = __esm({
+  "src/assert_non_negative_seconds.ts"() {
+  }
+});
+
+// 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);
+  });
+}
+var init_update_repeatable_quest = __esm({
+  "src/repeatable_quests/update_repeatable_quest.ts"() {
+    init_assert_non_empty();
+    init_assert_non_negative_seconds();
+    init_resolve_now();
+    init_with_transaction();
+    init_get_repeatable_quest_or_throw();
+    init_parse_rrule();
+  }
+});
+
+// src/repeatable_quests/archive_repeatable_quest.ts
+function archiveRepeatableQuest(db, repeatableQuestId, archivedAt) {
+  return updateRepeatableQuest(db, repeatableQuestId, { archivedAt: resolveNow(archivedAt) });
 }
-var init_soft_delete_repeatable_quest = __esm({
-  "src/repeatable_quests/soft_delete_repeatable_quest.ts"() {
+var init_archive_repeatable_quest = __esm({
+  "src/repeatable_quests/archive_repeatable_quest.ts"() {
     init_resolve_now();
-    init_get_repeatable_quest_or_throw();
+    init_update_repeatable_quest();
   }
 });
 
-// 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);
+// 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(`Quest ${questId} was not found.`);
+    throw new Error(`${label} ${id} was not found.`);
   }
-  return mapQuestRow(row);
 }
-var init_get_quest_or_throw = __esm({
-  "src/quests/get_quest_or_throw.ts"() {
-    init_map_quest_row();
+var init_assert_active_row_exists = __esm({
+  "src/assert_active_row_exists.ts"() {
   }
 });
 
-// src/rewards/copy_repeatable_quest_rewards_to_quest.ts
-function copyRepeatableQuestRewardsToQuest(db, repeatableQuestId, questId, now) {
+// 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;
+}
+var init_assert_non_negative_number = __esm({
+  "src/assert_non_negative_number.ts"() {
+  }
+});
+
+// src/rewards/replace_active_repeatable_quest_rewards.ts
+function replaceActiveRepeatableQuestRewards(db, repeatableQuestId, rewards, 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(
+    "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 quest_rewards (quest_id, kind, name, description, quantity, created_at)
-       VALUES (?, ?, ?, ?, ?, ?)`
+      `INSERT INTO repeatable_quest_rewards (
+         repeatable_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),
+      repeatableQuestId,
+      assertNonEmpty(reward.kind, "Reward kind"),
+      assertNonEmpty(reward.name, "Reward name"),
+      reward.description?.trim() || null,
+      assertNonNegativeNumber(reward.quantity, "Reward quantity") ?? null,
       effectiveNow
     );
   }
 }
-var init_copy_repeatable_quest_rewards_to_quest = __esm({
-  "src/rewards/copy_repeatable_quest_rewards_to_quest.ts"() {
+var init_replace_active_repeatable_quest_rewards = __esm({
+  "src/rewards/replace_active_repeatable_quest_rewards.ts"() {
+    init_assert_non_empty();
+    init_assert_non_negative_number();
     init_resolve_now();
   }
 });
 
-// src/tags/copy_repeatable_quest_tags_to_quest.ts
-function copyRepeatableQuestTagsToQuest(db, repeatableQuestId, questId, now) {
+// 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);
-  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(
+    "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 quest_tags (quest_id, tag_id, created_at)
+      `INSERT INTO repeatable_quest_tags (repeatable_quest_id, tag_id, created_at)
        VALUES (?, ?, ?)`
-    ).run(questId, Number(row.tag_id), effectiveNow);
+    ).run(repeatableQuestId, tagId, effectiveNow);
   }
 }
-var init_copy_repeatable_quest_tags_to_quest = __esm({
-  "src/tags/copy_repeatable_quest_tags_to_quest.ts"() {
+var init_replace_active_repeatable_quest_tags = __esm({
+  "src/tags/replace_active_repeatable_quest_tags.ts"() {
     init_resolve_now();
+    init_normalize_tag_name();
   }
 });
 
-// src/repeatable_quests/spawn_due_repeatable_quests.ts
-function spawnDueRepeatableQuests(db, now) {
+// src/repeatable_quests/create_repeatable_quest.ts
+function createRepeatableQuest(db, input) {
   return withTransaction(db, () => {
-    const anchors = listDueRepeatableQuestAnchors(db, now);
-    const quests = [];
-    for (const anchor of anchors) {
-      const repeatable = getRepeatableQuestOrThrow(db, anchor.repeatableQuestId);
-      const created = db.prepare(
-        `INSERT INTO quests (
-             questline_id,
-             source_rumor_id,
-             spawned_by_quest_id,
-             spawned_from_repeatable_id,
-             spawned_for_at,
-             title,
-             objective,
-             created_at,
-             updated_at,
-             effort_seconds,
-             estimate_seconds,
-             not_before_at,
-             due_at,
-             scheduled_start_at,
-             scheduled_end_at,
-             all_day
-           ) VALUES (?, NULL, NULL, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)`
-      ).run(
-        repeatable.questlineId ?? null,
-        repeatable.id,
-        anchor.anchorAt,
-        repeatable.title,
-        repeatable.objective,
-        now,
-        now,
-        repeatable.estimateSeconds ?? null,
-        repeatable.notBeforeOffsetSeconds == null ? null : anchor.anchorAt + repeatable.notBeforeOffsetSeconds * 1e3,
-        repeatable.dueOffsetSeconds == null ? null : anchor.anchorAt + repeatable.dueOffsetSeconds * 1e3,
-        repeatable.scheduledStartOffsetSeconds == null ? null : anchor.anchorAt + repeatable.scheduledStartOffsetSeconds * 1e3,
-        repeatable.scheduledEndOffsetSeconds == null ? null : anchor.anchorAt + repeatable.scheduledEndOffsetSeconds * 1e3,
-        repeatable.allDay ? 1 : 0
-      );
-      const questId = Number(created.lastInsertRowid);
-      copyRepeatableQuestTagsToQuest(db, repeatable.id, questId, now);
-      copyRepeatableQuestRewardsToQuest(db, repeatable.id, questId, now);
-      quests.push(getQuestOrThrow(db, questId));
+    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");
     }
-    return quests;
+    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);
   });
 }
-var init_spawn_due_repeatable_quests = __esm({
-  "src/repeatable_quests/spawn_due_repeatable_quests.ts"() {
-    init_get_quest_or_throw();
-    init_copy_repeatable_quest_rewards_to_quest();
-    init_copy_repeatable_quest_tags_to_quest();
+var init_create_repeatable_quest = __esm({
+  "src/repeatable_quests/create_repeatable_quest.ts"() {
+    init_assert_active_row_exists();
+    init_assert_non_empty();
+    init_assert_non_negative_seconds();
+    init_resolve_now();
+    init_replace_active_repeatable_quest_rewards();
+    init_replace_active_repeatable_quest_tags();
     init_with_transaction();
     init_get_repeatable_quest_or_throw();
-    init_list_due_repeatable_quest_anchors();
+    init_parse_rrule();
+  }
+});
+
+// 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);
+}
+var init_soft_delete_repeatable_quest = __esm({
+  "src/repeatable_quests/soft_delete_repeatable_quest.ts"() {
+    init_resolve_now();
+    init_get_repeatable_quest_or_throw();
   }
 });
 
@@ -4117,7 +4677,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",
@@ -4185,6 +4745,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) {
@@ -4229,6 +4798,7 @@ function reviewQuestlogToolHandler(db, input) {
 var reviewQuestlogTool;
 var init_review_questlog_tool = __esm({
   "src/tools/review_questlog_tool.ts"() {
+    init_list_deliveries();
     init_list_questlines();
     init_quests();
     init_get_repeatable_quest_or_throw();
@@ -4257,6 +4827,7 @@ var init_review_questlog_tool = __esm({
       inputSchema: objectSchema(
         {
           view: enumSchema("Which operational review surface to return.", [
+            "deliveries",
             "questlines",
             "quests.active",
             "quests.available",
@@ -4599,7 +5170,7 @@ var init_reward_work_tool = __esm({
               name: stringSchema("Reward name."),
               now: integerSchema("Optional update timestamp for the update action.")
             },
-            []
+            ["kind", "name"]
           ),
           rewards: arraySchema(
             objectSchema(
@@ -5513,7 +6084,7 @@ var init_shape_work_tool = __esm({
               title: stringSchema("Questline title."),
               description: stringSchema("Optional questline description.")
             },
-            []
+            ["title"]
           ),
           rumorId: integerSchema("Rumor to settle, dismiss, or reopen."),
           dismissedAt: integerSchema("Optional dismissal timestamp."),
@@ -5827,6 +6398,7 @@ var init_tool_registry = __esm({
   "src/tools/tool_registry.ts"() {
     init_capture_rumor_tool();
     init_inspect_questlog_item_tool();
+    init_manage_hooks_tool();
     init_manage_repeatable_tool();
     init_organize_work_tool();
     init_plan_quest_tool();
@@ -5838,6 +6410,7 @@ var init_tool_registry = __esm({
     init_shape_work_tool();
     init_tag_work_tool();
     questlogTools = [
+      manageHooksTool,
       searchQuestlogTool,
       reviewQuestlogTool,
       inspectQuestlogItemTool,
@@ -5867,7 +6440,7 @@ var init_questlog_surface_tools = __esm({
         whenNotToUse: tool.whenNotToUse ?? "",
         readOnly: tool.readOnly,
         sideEffects: tool.sideEffects,
-        inputSchema: { ...tool.inputSchema, type: "object" },
+        inputSchema: tool.inputSchema,
         handler: tool.handler
       })
     );