@ghostpaw/questlog 0.9.1 → 0.10.1

package/dist/mcp.js

@@ -1,9 +1,33 @@
 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';
 
 // 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);
+ `);
+}
+
 // src/questlines/init_questline_tables.ts
 function initQuestlineTables(db) {
   db.exec(`
@@ -352,6 +376,7 @@ function initQuestlogTables(db) {
   initTagTables(db);
   initQuestSearch(db);
   initRumorSearch(db);
+  initHookTables(db);
 }
 
 // src/surface/open_questlog_db.ts
@@ -384,7 +409,7 @@ async function openQuestlogDb(path) {
 }
 
 // src/version.ts
-var questlogVersion = "0.9.1";
+var questlogVersion = "0.10.1";
 
 // 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.";
@@ -630,8 +655,154 @@ function translateToolError(error, options = {}) {
   );
 }
 
+// src/surfaces/schema_actions.ts
+var requirements = /* @__PURE__ */ new WeakMap();
+function registerSchemaActions(schema, actions) {
+  requirements.set(schema, actions);
+}
+function requiredForAction(schema, action) {
+  return requirements.get(schema)?.[String(action)] ?? [];
+}
+
+// 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";
+}
+
+// src/surfaces/validate_input.ts
+function validateInput(schema, input, path = "$") {
+  const errors = [];
+  const matchesType = (type) => {
+    switch (type) {
+      case "object":
+        return typeof input === "object" && input !== null && !Array.isArray(input);
+      case "array":
+        return Array.isArray(input);
+      case "integer":
+        return typeof input === "number" && Number.isInteger(input);
+      case "number":
+        return typeof input === "number" && Number.isFinite(input);
+      case "null":
+        return input === null;
+      default:
+        return typeof input === type;
+    }
+  };
+  if (schema.type && !(Array.isArray(schema.type) ? schema.type : [schema.type]).some(matchesType)) {
+    return [`${path}: expected ${String(schema.type)}`];
+  }
+  if (schema.enum && !schema.enum.some((value) => JSON.stringify(value) === JSON.stringify(input)))
+    errors.push(`${path}: expected one of ${JSON.stringify(schema.enum)}`);
+  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 ?? [], ...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))
+        errors.push(...validateInput(property, record[name], `${path}.${name}`));
+  }
+  if (Array.isArray(input) && schema.items)
+    input.forEach((value, index) => {
+      errors.push(...validateInput(schema.items, value, `${path}[${index}]`));
+    });
+  return errors;
+}
+
+// src/tools/action_requirements.ts
+var 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 = {}) {
@@ -875,6 +1046,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 {
@@ -1352,7 +1544,8 @@ function inspectQuestlogItemToolHandler(db, input) {
               detail: detailLevel === "full" ? detail : toQuestCompactDetail(detail)
             },
             related,
-            detailLevel
+            detailLevel,
+            deliveries: listDeliveries(db, { questId: detail.id })
           },
           { entities }
         );
@@ -1457,13 +1650,39 @@ 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 ? basename(path, extname(path)) : "questlog";
+}
+
+// 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)
+    };
+  });
 }
 
 // src/with_transaction.ts
@@ -1501,6 +1720,135 @@ 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 = 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;
+}
+
+// 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,
@@ -1544,195 +1892,6 @@ 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/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/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);
@@ -1850,115 +2009,460 @@ 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/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;
+  });
+}
+
+// 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_${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;
+}
+
+// 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/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);
 }
 
-// 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;
+}
+
+// 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
     );
   }
 }
 
-// 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);
   }
 }
 
-// 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);
   });
 }
 
+// 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 {
@@ -3178,7 +3682,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",
@@ -3246,6 +3750,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) {
@@ -3305,6 +3818,7 @@ var reviewQuestlogTool = defineQuestlogTool({
   inputSchema: objectSchema(
     {
       view: enumSchema("Which operational review surface to return.", [
+        "deliveries",
         "questlines",
         "quests.active",
         "quests.available",
@@ -3581,7 +4095,7 @@ var rewardWorkTool = defineQuestlogTool({
           name: stringSchema("Reward name."),
           now: integerSchema("Optional update timestamp for the update action.")
         },
-        []
+        ["kind", "name"]
       ),
       rewards: arraySchema(
         objectSchema(
@@ -4408,7 +4922,7 @@ var shapeWorkTool = defineQuestlogTool({
           title: stringSchema("Questline title."),
           description: stringSchema("Optional questline description.")
         },
-        []
+        ["title"]
       ),
       rumorId: integerSchema("Rumor to settle, dismiss, or reopen."),
       dismissedAt: integerSchema("Optional dismissal timestamp."),
@@ -4667,6 +5181,7 @@ var tagWorkTool = defineQuestlogTool({
 
 // src/tools/tool_registry.ts
 var questlogTools = [
+  manageHooksTool,
   searchQuestlogTool,
   reviewQuestlogTool,
   inspectQuestlogItemTool,
@@ -4690,7 +5205,7 @@ var questlogSurfaceTools = questlogTools.map(
     whenNotToUse: tool.whenNotToUse ?? "",
     readOnly: tool.readOnly,
     sideEffects: tool.sideEffects,
-    inputSchema: { ...tool.inputSchema, type: "object" },
+    inputSchema: tool.inputSchema,
     handler: tool.handler
   })
 );
@@ -4725,47 +5240,6 @@ function isErrorResult(result) {
   return typeof result === "object" && result !== null && "ok" in result && result.ok === false;
 }
 
-// src/surfaces/validate_input.ts
-function validateInput(schema, input, path = "$") {
-  const errors = [];
-  const matchesType = (type) => {
-    switch (type) {
-      case "object":
-        return typeof input === "object" && input !== null && !Array.isArray(input);
-      case "array":
-        return Array.isArray(input);
-      case "integer":
-        return typeof input === "number" && Number.isInteger(input);
-      case "number":
-        return typeof input === "number" && Number.isFinite(input);
-      case "null":
-        return input === null;
-      default:
-        return typeof input === type;
-    }
-  };
-  if (schema.type && !(Array.isArray(schema.type) ? schema.type : [schema.type]).some(matchesType)) {
-    return [`${path}: expected ${String(schema.type)}`];
-  }
-  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`);
-  if (typeof input === "object" && input !== null && !Array.isArray(input)) {
-    const record = input;
-    for (const name of schema.required ?? [])
-      if (!Object.hasOwn(record, name)) errors.push(`${path}.${name}: required`);
-    for (const [name, property] of Object.entries(schema.properties ?? {}))
-      if (Object.hasOwn(record, name))
-        errors.push(...validateInput(property, record[name], `${path}.${name}`));
-  }
-  if (Array.isArray(input) && schema.items)
-    input.forEach((value, index) => {
-      errors.push(...validateInput(schema.items, value, `${path}[${index}]`));
-    });
-  return errors;
-}
-
 // src/surfaces/mcp_server.ts
 var MCP_LATEST_PROTOCOL_VERSION = "2026-07-28";
 var MCP_SUPPORTED_PROTOCOL_VERSIONS = [
@@ -4865,7 +5339,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);