@ghostpaw/questlog 0.7.0 → 0.9.0

package/dist/chunk-3Y5F3SMB.js

@@ -0,0 +1,4308 @@
+#!/usr/bin/env node
+// src/questlines/map_questline_row.ts
+function mapQuestlineRow(row) {
+  return {
+    id: Number(row.id),
+    sourceRumorId: row.source_rumor_id == null ? null : Number(row.source_rumor_id),
+    title: String(row.title),
+    description: row.description == null ? null : String(row.description),
+    startsAt: row.starts_at == null ? null : Number(row.starts_at),
+    dueAt: row.due_at == null ? null : Number(row.due_at),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    archivedAt: row.archived_at == null ? null : Number(row.archived_at),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// src/questlines/query_questline_stats.ts
+function queryQuestlineStats(db, now, questlineIds) {
+  if (questlineIds && questlineIds.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const params = [now, now];
+  const questlineFilter = questlineIds && questlineIds.length > 0 ? `AND q.questline_id IN (${questlineIds.map(() => "?").join(", ")})` : "";
+  if (questlineIds && questlineIds.length > 0) {
+    params.push(...questlineIds);
+  }
+  const rows = db.prepare(
+    `SELECT q.questline_id,
+              COUNT(*) AS total_quests,
+              SUM(CASE WHEN q.started_at IS NULL AND q.resolved_at IS NULL THEN 1 ELSE 0 END) AS open_quests,
+              SUM(CASE WHEN q.started_at IS NOT NULL AND q.resolved_at IS NULL THEN 1 ELSE 0 END) AS in_progress_quests,
+              SUM(CASE WHEN q.resolved_at IS NOT NULL AND q.success = 1 THEN 1 ELSE 0 END) AS done_quests,
+              SUM(CASE WHEN q.resolved_at IS NOT NULL AND q.success = 0 THEN 1 ELSE 0 END) AS abandoned_quests,
+              SUM(
+                CASE
+                  WHEN q.resolved_at IS NULL
+                   AND (q.not_before_at IS NULL OR q.not_before_at <= ?)
+                   AND NOT EXISTS (
+                     SELECT 1
+                     FROM quest_unlocks qu
+                     JOIN quests blocker ON blocker.id = qu.from_quest_id
+                     WHERE qu.to_quest_id = q.id
+                       AND qu.deleted_at IS NULL
+                       AND blocker.deleted_at IS NULL
+                       AND NOT (blocker.resolved_at IS NOT NULL AND blocker.success = 1)
+                   )
+                  THEN 1
+                  ELSE 0
+                END
+              ) AS available_quests,
+              SUM(
+                CASE
+                  WHEN q.resolved_at IS NULL
+                   AND COALESCE(q.due_at, ql.due_at) IS NOT NULL
+                   AND COALESCE(q.due_at, ql.due_at) < ?
+                  THEN 1
+                  ELSE 0
+                END
+              ) AS overdue_quests
+       FROM quests q
+       LEFT JOIN questlines ql ON ql.id = q.questline_id AND ql.deleted_at IS NULL
+       WHERE q.deleted_at IS NULL
+         AND q.questline_id IS NOT NULL
+         ${questlineFilter}
+       GROUP BY q.questline_id`
+  ).all(...params);
+  return new Map(
+    rows.map((row) => [
+      Number(row.questline_id),
+      {
+        totalQuests: Number(row.total_quests ?? 0),
+        openQuests: Number(row.open_quests ?? 0),
+        inProgressQuests: Number(row.in_progress_quests ?? 0),
+        doneQuests: Number(row.done_quests ?? 0),
+        abandonedQuests: Number(row.abandoned_quests ?? 0),
+        availableQuests: Number(row.available_quests ?? 0),
+        overdueQuests: Number(row.overdue_quests ?? 0)
+      }
+    ])
+  );
+}
+
+// src/questlines/list_questlines.ts
+function listQuestlines(db, now = Date.now()) {
+  const questlines = db.prepare("SELECT * FROM questlines WHERE deleted_at IS NULL ORDER BY created_at DESC, id DESC").all().map(mapQuestlineRow);
+  if (questlines.length === 0) {
+    return [];
+  }
+  const statsByQuestlineId = queryQuestlineStats(
+    db,
+    now,
+    questlines.map((questline) => questline.id)
+  );
+  return questlines.map((questline) => {
+    const stats = statsByQuestlineId.get(questline.id);
+    return {
+      ...questline,
+      totalQuests: stats?.totalQuests ?? 0,
+      openQuests: stats?.openQuests ?? 0,
+      inProgressQuests: stats?.inProgressQuests ?? 0,
+      doneQuests: stats?.doneQuests ?? 0,
+      abandonedQuests: stats?.abandonedQuests ?? 0,
+      availableQuests: stats?.availableQuests ?? 0,
+      overdueQuests: stats?.overdueQuests ?? 0
+    };
+  });
+}
+
+// src/assert_non_empty.ts
+function assertNonEmpty(value, label) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${label} must not be empty.`);
+  }
+  return trimmed;
+}
+
+// src/resolve_now.ts
+function resolveNow(now) {
+  return now ?? Date.now();
+}
+
+// src/quests/map_quest_row.ts
+function asBoolean(value) {
+  return Number(value) === 1;
+}
+function mapQuestRow(row) {
+  return {
+    id: Number(row.id),
+    questlineId: row.questline_id == null ? null : Number(row.questline_id),
+    sourceRumorId: row.source_rumor_id == null ? null : Number(row.source_rumor_id),
+    spawnedByQuestId: row.spawned_by_quest_id == null ? null : Number(row.spawned_by_quest_id),
+    spawnedFromRepeatableId: row.spawned_from_repeatable_id == null ? null : Number(row.spawned_from_repeatable_id),
+    spawnedForAt: row.spawned_for_at == null ? null : Number(row.spawned_for_at),
+    title: String(row.title),
+    objective: String(row.objective),
+    outcome: row.outcome == null ? null : String(row.outcome),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    startedAt: row.started_at == null ? null : Number(row.started_at),
+    resolvedAt: row.resolved_at == null ? null : Number(row.resolved_at),
+    success: row.success == null ? null : asBoolean(row.success),
+    effortSeconds: Number(row.effort_seconds),
+    estimateSeconds: row.estimate_seconds == null ? null : Number(row.estimate_seconds),
+    notBeforeAt: row.not_before_at == null ? null : Number(row.not_before_at),
+    dueAt: row.due_at == null ? null : Number(row.due_at),
+    scheduledStartAt: row.scheduled_start_at == null ? null : Number(row.scheduled_start_at),
+    scheduledEndAt: row.scheduled_end_at == null ? null : Number(row.scheduled_end_at),
+    allDay: asBoolean(row.all_day),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// 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/quests/resolve_quest.ts
+function resolveQuest(db, questId, success, outcome, resolvedAt) {
+  const current = getQuestOrThrow(db, questId);
+  if (current.resolvedAt != null) {
+    throw new Error("Resolved quests cannot be resolved again.");
+  }
+  const now = resolveNow(resolvedAt);
+  db.prepare(
+    `UPDATE quests
+     SET outcome = ?,
+         resolved_at = ?,
+         success = ?,
+         updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(assertNonEmpty(outcome, "Quest outcome"), now, success ? 1 : 0, now, questId);
+  return getQuestOrThrow(db, questId);
+}
+
+// src/quests/abandon_quest.ts
+function abandonQuest(db, questId, outcome, resolvedAt) {
+  return resolveQuest(db, questId, false, outcome, resolvedAt);
+}
+
+// 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/unlocks/would_create_unlock_cycle.ts
+function wouldCreateUnlockCycle(db, fromQuestId, toQuestId) {
+  const frontier = [toQuestId];
+  const seen = /* @__PURE__ */ new Set();
+  while (frontier.length > 0) {
+    const current = frontier.pop();
+    if (current === fromQuestId) {
+      return true;
+    }
+    if (seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    const rows = db.prepare(
+      `SELECT to_quest_id
+         FROM quest_unlocks
+         WHERE from_quest_id = ? AND deleted_at IS NULL`
+    ).all(current);
+    for (const row of rows) {
+      frontier.push(Number(row.to_quest_id));
+    }
+  }
+  return false;
+}
+
+// src/unlocks/add_unlock.ts
+function addUnlock(db, fromQuestId, toQuestId, now) {
+  assertActiveRowExists(db, "quests", fromQuestId, "Quest");
+  assertActiveRowExists(db, "quests", toQuestId, "Quest");
+  if (fromQuestId === toQuestId) {
+    throw new Error("A quest cannot unlock itself.");
+  }
+  if (wouldCreateUnlockCycle(db, fromQuestId, toQuestId)) {
+    throw new Error("Unlock would create a cycle.");
+  }
+  db.prepare(
+    `INSERT INTO quest_unlocks (from_quest_id, to_quest_id, created_at)
+     VALUES (?, ?, ?)`
+  ).run(fromQuestId, toQuestId, resolveNow(now));
+}
+
+// src/with_transaction.ts
+var transactionDepth = /* @__PURE__ */ new WeakMap();
+function withTransaction(db, fn) {
+  const depth = transactionDepth.get(db) ?? 0;
+  const savepoint = `questlog_${depth}`;
+  if (depth === 0) {
+    db.exec("BEGIN IMMEDIATE");
+  } else {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  }
+  transactionDepth.set(db, depth + 1);
+  try {
+    const result = fn();
+    if (depth === 0) {
+      db.exec("COMMIT");
+    } else {
+      db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+    }
+    transactionDepth.set(db, depth);
+    return result;
+  } catch (error) {
+    try {
+      if (depth === 0) {
+        db.exec("ROLLBACK");
+      } else {
+        db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+      }
+    } catch {
+    }
+    transactionDepth.set(db, depth);
+    throw error;
+  }
+}
+
+// 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/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_quest_rewards.ts
+function replaceActiveQuestRewards(db, questId, rewards, now) {
+  const effectiveNow = resolveNow(now);
+  db.prepare(
+    "UPDATE quest_rewards SET deleted_at = ? WHERE quest_id = ? AND deleted_at IS NULL"
+  ).run(effectiveNow, questId);
+  for (const reward of rewards) {
+    db.prepare(
+      `INSERT INTO quest_rewards (quest_id, kind, name, description, quantity, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      questId,
+      assertNonEmpty(reward.kind, "Reward kind"),
+      assertNonEmpty(reward.name, "Reward name"),
+      reward.description?.trim() || null,
+      assertNonNegativeNumber(reward.quantity, "Reward quantity") ?? null,
+      effectiveNow
+    );
+  }
+}
+
+// src/tags/normalize_tag_name.ts
+function normalizeTagName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+// src/tags/replace_active_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 replaceActiveQuestTags(db, questId, tagNames, now) {
+  const effectiveNow = resolveNow(now);
+  db.prepare("UPDATE quest_tags SET deleted_at = ? WHERE quest_id = ? AND deleted_at IS NULL").run(
+    effectiveNow,
+    questId
+  );
+  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)
+       VALUES (?, ?, ?)`
+    ).run(questId, tagId, effectiveNow);
+  }
+}
+
+// src/quests/create_quest.ts
+function createQuest(db, input) {
+  return withTransaction(db, () => {
+    const now = resolveNow(input.now);
+    const title = assertNonEmpty(input.title, "Quest title");
+    const objective = assertNonEmpty(input.objective, "Quest objective");
+    if (input.questlineId != null) {
+      assertActiveRowExists(db, "questlines", input.questlineId, "Questline");
+    }
+    if (input.sourceRumorId != null) {
+      assertActiveRowExists(db, "rumors", input.sourceRumorId, "Rumor");
+    }
+    if (input.spawnedByQuestId != null) {
+      assertActiveRowExists(db, "quests", input.spawnedByQuestId, "Quest");
+    }
+    if (input.spawnedFromRepeatableId != null) {
+      assertActiveRowExists(
+        db,
+        "repeatable_quests",
+        input.spawnedFromRepeatableId,
+        "Repeatable quest"
+      );
+    }
+    assertNonNegativeSeconds(input.estimateSeconds, "Quest estimate");
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.questlineId ?? null,
+      input.sourceRumorId ?? null,
+      input.spawnedByQuestId ?? null,
+      input.spawnedFromRepeatableId ?? null,
+      input.spawnedForAt ?? null,
+      title,
+      objective,
+      now,
+      now,
+      input.estimateSeconds ?? null,
+      input.notBeforeAt ?? null,
+      input.dueAt ?? null,
+      input.scheduledStartAt ?? null,
+      input.scheduledEndAt ?? null,
+      input.allDay ? 1 : 0
+    );
+    const questId = Number(created.lastInsertRowid);
+    if (input.tags && input.tags.length > 0) {
+      replaceActiveQuestTags(db, questId, input.tags, now);
+    }
+    if (input.rewards && input.rewards.length > 0) {
+      replaceActiveQuestRewards(db, questId, input.rewards, now);
+    }
+    return getQuestOrThrow(db, questId);
+  });
+}
+
+// src/quests/abandon_quest_and_spawn_followups.ts
+function abandonQuestAndSpawnFollowups(db, questId, outcome, followups, resolvedAt) {
+  return withTransaction(db, () => {
+    const abandonedQuest = abandonQuest(db, questId, outcome, resolvedAt);
+    const now = resolveNow(resolvedAt);
+    const followupQuests = followups.map(
+      (followup) => createQuest(db, {
+        ...followup,
+        questlineId: followup.questlineId ?? abandonedQuest.questlineId,
+        spawnedByQuestId: questId,
+        now
+      })
+    );
+    for (let i = 0; i < followups.length; i += 1) {
+      const followup = followups[i];
+      const created = followupQuests[i];
+      if (followup?.unlocksParent && created) {
+        addUnlock(db, created.id, questId, resolvedAt);
+      }
+    }
+    return { abandonedQuest, followupQuests };
+  });
+}
+
+// src/quests/finish_quest.ts
+function finishQuest(db, questId, outcome, resolvedAt) {
+  return resolveQuest(db, questId, true, outcome, resolvedAt);
+}
+
+// src/markers/derive_quest_marker_id.ts
+function deriveQuestMarkerId({
+  state,
+  available,
+  hasUnclaimedReward,
+  notBeforeAt,
+  blockerCount,
+  now
+}) {
+  if (state === "done") {
+    return hasUnclaimedReward ? "progress.complete" : null;
+  }
+  if (state === "abandoned") {
+    return null;
+  }
+  if (state === "in_progress") {
+    return "progress.incomplete";
+  }
+  if (available) {
+    return "attention.available";
+  }
+  if (notBeforeAt != null && notBeforeAt > now) {
+    return "attention.available.future";
+  }
+  if (blockerCount > 0) {
+    return "progress.incomplete";
+  }
+  return null;
+}
+
+// src/rewards/map_quest_reward_row.ts
+function mapQuestRewardRow(row) {
+  return {
+    id: Number(row.id),
+    questId: Number(row.quest_id),
+    kind: String(row.kind),
+    name: String(row.name),
+    description: row.description == null ? null : String(row.description),
+    quantity: row.quantity == null ? null : Number(row.quantity),
+    createdAt: Number(row.created_at),
+    claimedAt: row.claimed_at == null ? null : Number(row.claimed_at),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// src/quests/derive_quest_state.ts
+function deriveQuestState(quest) {
+  if (quest.resolvedAt != null && quest.success === true) {
+    return "done";
+  }
+  if (quest.resolvedAt != null && quest.success === false) {
+    return "abandoned";
+  }
+  if (quest.startedAt != null) {
+    return "in_progress";
+  }
+  return "open";
+}
+
+// src/quests/query_quest_detail_records.ts
+function queryQuestDetailRecords(db, filters = {}, now = Date.now(), questIds) {
+  if (questIds && questIds.length === 0) {
+    return [];
+  }
+  const clauses = [];
+  const params = [];
+  if (!filters.includeDeleted) {
+    clauses.push("q.deleted_at IS NULL");
+  }
+  if (questIds && questIds.length > 0) {
+    clauses.push(`q.id IN (${questIds.map(() => "?").join(", ")})`);
+    params.push(...questIds);
+  }
+  if (filters.questlineId != null) {
+    clauses.push("q.questline_id = ?");
+    params.push(filters.questlineId);
+  }
+  if (filters.tagNames && filters.tagNames.length > 0) {
+    const normalized = [...new Set(filters.tagNames.map(normalizeTagName).filter(Boolean))];
+    for (const tag of normalized) {
+      clauses.push(
+        `EXISTS (
+           SELECT 1
+           FROM quest_tags qt
+           JOIN tags t ON t.id = qt.tag_id
+           WHERE qt.quest_id = q.id
+             AND qt.deleted_at IS NULL
+             AND t.deleted_at IS NULL
+             AND t.normalized_name = ?
+         )`
+      );
+      params.push(tag);
+    }
+  }
+  const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+  const rows = db.prepare(
+    `SELECT q.*,
+              COALESCE(q.due_at, ql.due_at) AS effective_due_at,
+              (
+                SELECT COUNT(*)
+                FROM quest_unlocks qu
+                JOIN quests blocker ON blocker.id = qu.from_quest_id
+                WHERE qu.to_quest_id = q.id
+                  AND qu.deleted_at IS NULL
+                  AND blocker.deleted_at IS NULL
+                  AND NOT (blocker.resolved_at IS NOT NULL AND blocker.success = 1)
+              ) AS blocker_count
+       FROM quests q
+       LEFT JOIN questlines ql ON ql.id = q.questline_id AND ql.deleted_at IS NULL
+       ${where}
+       ORDER BY q.created_at DESC, q.id DESC`
+  ).all(...params);
+  if (rows.length === 0) {
+    return [];
+  }
+  const ids = rows.map((row) => Number(row.id));
+  const placeholders = ids.map(() => "?").join(", ");
+  const tagNamesByQuestId = /* @__PURE__ */ new Map();
+  const rewardsByQuestId = /* @__PURE__ */ new Map();
+  const unlocksByQuestId = /* @__PURE__ */ new Map();
+  const unlockedByQuestId = /* @__PURE__ */ new Map();
+  for (const row of db.prepare(
+    `SELECT qt.quest_id, t.name
+       FROM quest_tags qt
+       JOIN tags t ON t.id = qt.tag_id
+       WHERE qt.quest_id IN (${placeholders})
+         AND qt.deleted_at IS NULL
+         AND t.deleted_at IS NULL
+       ORDER BY qt.quest_id, t.name`
+  ).all(...ids)) {
+    const questId = Number(row.quest_id);
+    const tagNames = tagNamesByQuestId.get(questId) ?? [];
+    tagNames.push(String(row.name));
+    tagNamesByQuestId.set(questId, tagNames);
+  }
+  for (const row of db.prepare(
+    `SELECT *
+       FROM quest_rewards
+       WHERE quest_id IN (${placeholders})
+         AND deleted_at IS NULL
+       ORDER BY quest_id, created_at, id`
+  ).all(...ids)) {
+    const reward = mapQuestRewardRow(row);
+    const rewards = rewardsByQuestId.get(reward.questId) ?? [];
+    rewards.push(reward);
+    rewardsByQuestId.set(reward.questId, rewards);
+  }
+  for (const row of db.prepare(
+    `SELECT from_quest_id, to_quest_id
+       FROM quest_unlocks
+       WHERE from_quest_id IN (${placeholders})
+         AND deleted_at IS NULL
+       ORDER BY from_quest_id, to_quest_id`
+  ).all(...ids)) {
+    const questId = Number(row.from_quest_id);
+    const unlocks = unlocksByQuestId.get(questId) ?? [];
+    unlocks.push(Number(row.to_quest_id));
+    unlocksByQuestId.set(questId, unlocks);
+  }
+  for (const row of db.prepare(
+    `SELECT from_quest_id, to_quest_id
+       FROM quest_unlocks
+       WHERE to_quest_id IN (${placeholders})
+         AND deleted_at IS NULL
+       ORDER BY to_quest_id, from_quest_id`
+  ).all(...ids)) {
+    const questId = Number(row.to_quest_id);
+    const unlockedBy = unlockedByQuestId.get(questId) ?? [];
+    unlockedBy.push(Number(row.from_quest_id));
+    unlockedByQuestId.set(questId, unlockedBy);
+  }
+  return rows.map((row) => {
+    const quest = mapQuestRow(row);
+    const blockerCount = Number(row.blocker_count ?? 0);
+    const effectiveDueAt = row.effective_due_at == null ? null : Number(row.effective_due_at);
+    const rewards = rewardsByQuestId.get(quest.id) ?? [];
+    const state = deriveQuestState(quest);
+    const available = quest.deletedAt == null && quest.resolvedAt == null && (quest.notBeforeAt == null || quest.notBeforeAt <= now) && blockerCount === 0;
+    const markerId = deriveQuestMarkerId({
+      state,
+      available,
+      hasUnclaimedReward: rewards.some((reward) => reward.claimedAt == null),
+      notBeforeAt: quest.notBeforeAt,
+      blockerCount,
+      now
+    });
+    return {
+      detail: {
+        ...quest,
+        state,
+        markerId,
+        effectiveDueAt,
+        available,
+        tagNames: tagNamesByQuestId.get(quest.id) ?? [],
+        rewards,
+        unlocksQuestIds: unlocksByQuestId.get(quest.id) ?? [],
+        unlockedByQuestIds: unlockedByQuestId.get(quest.id) ?? []
+      },
+      blockerCount
+    };
+  });
+}
+
+// src/quests/get_quest_detail.ts
+function getQuestDetail(db, questId, now = Date.now()) {
+  const [record] = queryQuestDetailRecords(db, {}, now, [questId]);
+  if (!record) {
+    throw new Error(`Quest ${questId} was not found.`);
+  }
+  return record.detail;
+}
+
+// src/quests/list_quest_details.ts
+function listQuestDetails(db, filters = {}, now = Date.now()) {
+  return queryQuestDetailRecords(db, filters, now).map((record) => record.detail);
+}
+
+// src/quests/list_active_quests.ts
+function listActiveQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => quest.state === "open" || quest.state === "in_progress"
+  );
+}
+
+// src/quests/list_available_quests.ts
+function listAvailableQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter((quest) => quest.available);
+}
+
+// src/quests/list_blocked_quests.ts
+function listBlockedQuests(db, filters = {}, now = Date.now()) {
+  return queryQuestDetailRecords(db, filters, now).filter(
+    (record) => (record.detail.state === "open" || record.detail.state === "in_progress") && record.blockerCount > 0
+  ).map((record) => record.detail);
+}
+
+// src/quests/list_deferred_quests.ts
+function listDeferredQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => quest.resolvedAt == null && quest.notBeforeAt != null && quest.notBeforeAt > now
+  );
+}
+
+// src/quests/list_due_soon_quests.ts
+function listDueSoonQuests(db, horizonMs, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => quest.resolvedAt == null && quest.effectiveDueAt != null && quest.effectiveDueAt >= now && quest.effectiveDueAt <= now + horizonMs
+  );
+}
+
+// src/quests/list_in_progress_quests.ts
+function listInProgressQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter((quest) => quest.state === "in_progress");
+}
+
+// src/quests/list_missed_scheduled_quests.ts
+function listMissedScheduledQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => quest.resolvedAt == null && quest.scheduledEndAt != null && quest.scheduledEndAt < now
+  );
+}
+
+// src/quests/list_open_quests.ts
+function listOpenQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter((quest) => quest.state === "open");
+}
+
+// src/quests/list_overdue_quests.ts
+function listOverdueQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => quest.resolvedAt == null && quest.effectiveDueAt != null && quest.effectiveDueAt < now
+  );
+}
+
+// src/quests/list_resolved_quests.ts
+function listResolvedQuests(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter((quest) => quest.resolvedAt != null);
+}
+
+// src/quests/overlaps_schedule_window.ts
+function overlapsScheduleWindow(start, end, windowStart, windowEnd) {
+  if (start == null) {
+    return false;
+  }
+  const effectiveEnd = end ?? start;
+  return start < windowEnd && effectiveEnd >= windowStart;
+}
+
+// src/quests/list_scheduled_for_day.ts
+function listScheduledForDay(db, dayStart, dayEnd, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => overlapsScheduleWindow(quest.scheduledStartAt, quest.scheduledEndAt, dayStart, dayEnd)
+  );
+}
+
+// src/quests/list_scheduled_now.ts
+function listScheduledNow(db, filters = {}, now = Date.now()) {
+  return listQuestDetails(db, filters, now).filter(
+    (quest) => overlapsScheduleWindow(quest.scheduledStartAt, quest.scheduledEndAt, now, now + 1)
+  );
+}
+
+// src/quests/log_quest_effort.ts
+function logQuestEffort(db, questId, effortSeconds, now) {
+  if (effortSeconds <= 0) {
+    throw new Error("Quest effort increment must be greater than zero.");
+  }
+  getQuestOrThrow(db, questId);
+  db.prepare(
+    `UPDATE quests
+     SET effort_seconds = effort_seconds + ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(effortSeconds, resolveNow(now), questId);
+  return getQuestOrThrow(db, questId);
+}
+
+// src/quests/plan_quest_time.ts
+function planQuestTime(db, questId, input) {
+  const current = getQuestOrThrow(db, questId);
+  const now = resolveNow(input.now);
+  db.prepare(
+    `UPDATE quests
+     SET not_before_at = ?,
+         due_at = ?,
+         scheduled_start_at = ?,
+         scheduled_end_at = ?,
+         all_day = ?,
+         estimate_seconds = ?,
+         updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(
+    input.notBeforeAt === void 0 ? current.notBeforeAt : input.notBeforeAt,
+    input.dueAt === void 0 ? current.dueAt : input.dueAt,
+    input.scheduledStartAt === void 0 ? current.scheduledStartAt : input.scheduledStartAt,
+    input.scheduledEndAt === void 0 ? current.scheduledEndAt : input.scheduledEndAt,
+    input.allDay === void 0 ? current.allDay ? 1 : 0 : input.allDay ? 1 : 0,
+    input.estimateSeconds === void 0 ? current.estimateSeconds : assertNonNegativeSeconds(input.estimateSeconds, "Quest estimate") ?? null,
+    now,
+    questId
+  );
+  return getQuestOrThrow(db, questId);
+}
+
+// src/quests/revise_quest_objective.ts
+function reviseQuestObjective(db, questId, objective, now) {
+  const current = getQuestOrThrow(db, questId);
+  if (current.startedAt != null) {
+    throw new Error("Quest objective cannot change after the quest has actually started.");
+  }
+  db.prepare(
+    `UPDATE quests
+     SET objective = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(assertNonEmpty(objective, "Quest objective"), resolveNow(now), questId);
+  return getQuestOrThrow(db, questId);
+}
+
+// src/quests/soft_delete_quest.ts
+function softDeleteQuest(db, questId, now) {
+  const deletedAt = resolveNow(now);
+  getQuestOrThrow(db, questId);
+  db.prepare(
+    `UPDATE quests
+     SET deleted_at = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(deletedAt, deletedAt, questId);
+}
+
+// src/quests/start_quest.ts
+function startQuest(db, questId, startedAt) {
+  const current = getQuestOrThrow(db, questId);
+  if (current.startedAt != null) {
+    return current;
+  }
+  if (current.resolvedAt != null) {
+    throw new Error("Resolved quests cannot be started.");
+  }
+  const now = resolveNow(startedAt);
+  db.prepare(
+    `UPDATE quests
+     SET started_at = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(now, now, questId);
+  return getQuestOrThrow(db, questId);
+}
+
+// src/repeatable_quests/map_repeatable_quest_row.ts
+function asBoolean2(value) {
+  return Number(value) === 1;
+}
+function mapRepeatableQuestRow(row) {
+  return {
+    id: Number(row.id),
+    questlineId: row.questline_id == null ? null : Number(row.questline_id),
+    title: String(row.title),
+    objective: String(row.objective),
+    rrule: String(row.rrule),
+    anchorAt: Number(row.anchor_at),
+    notBeforeOffsetSeconds: row.not_before_offset_seconds == null ? null : Number(row.not_before_offset_seconds),
+    dueOffsetSeconds: row.due_offset_seconds == null ? null : Number(row.due_offset_seconds),
+    scheduledStartOffsetSeconds: row.scheduled_start_offset_seconds == null ? null : Number(row.scheduled_start_offset_seconds),
+    scheduledEndOffsetSeconds: row.scheduled_end_offset_seconds == null ? null : Number(row.scheduled_end_offset_seconds),
+    allDay: asBoolean2(row.all_day),
+    estimateSeconds: row.estimate_seconds == null ? null : Number(row.estimate_seconds),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    archivedAt: row.archived_at == null ? null : Number(row.archived_at),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+}
+
+// src/repeatable_quests/get_repeatable_quest_or_throw.ts
+function getRepeatableQuestOrThrow(db, repeatableQuestId) {
+  const row = db.prepare("SELECT * FROM repeatable_quests WHERE id = ? AND deleted_at IS NULL").get(repeatableQuestId);
+  if (!row) {
+    throw new Error(`Repeatable quest ${repeatableQuestId} was not found.`);
+  }
+  return mapRepeatableQuestRow(row);
+}
+
+// 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,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+function parseRRule(rrule) {
+  const parts = Object.fromEntries(
+    rrule.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+      const [key, value] = part.split("=");
+      return [key, value];
+    })
+  );
+  const freq = parts.FREQ;
+  if (freq !== "DAILY" && freq !== "WEEKLY" && freq !== "MONTHLY" && freq !== "YEARLY") {
+    throw new Error(`Unsupported RRULE FREQ: ${freq ?? "missing"}`);
+  }
+  const interval = parts.INTERVAL == null ? 1 : Number(parts.INTERVAL);
+  if (!Number.isFinite(interval) || interval < 1) {
+    throw new Error("RRULE INTERVAL must be a positive integer.");
+  }
+  const count = parts.COUNT == null ? null : Number(parts.COUNT);
+  if (count != null && (!Number.isFinite(count) || count < 1)) {
+    throw new Error("RRULE COUNT must be a positive integer.");
+  }
+  const until = parts.UNTIL == null ? null : Date.parse(parts.UNTIL);
+  if (parts.UNTIL != null && Number.isNaN(until)) {
+    throw new Error("RRULE UNTIL must be parseable as a date.");
+  }
+  const byDay = parts.BYDAY == null ? null : parts.BYDAY.split(",").map((token) => {
+    const value = WEEKDAY[token];
+    if (value == null) {
+      throw new Error(`Unsupported RRULE BYDAY token: ${token}`);
+    }
+    return value;
+  });
+  return { freq, interval, count, until, byDay };
+}
+
+// src/repeatable_quests/start_of_utc_day.ts
+function startOfUtcDay(timestamp) {
+  const date = new Date(timestamp);
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+
+// src/repeatable_quests/start_of_utc_week.ts
+var DAY_MS = 864e5;
+function startOfUtcWeek(dayStart) {
+  const date = new Date(dayStart);
+  return dayStart - date.getUTCDay() * DAY_MS;
+}
+
+// src/repeatable_quests/generate_anchors_until.ts
+var DAY_MS2 = 864e5;
+var WEEK_MS2 = 7 * DAY_MS2;
+function generateAnchorsUntil(repeatable, now) {
+  const rule = parseRRule(repeatable.rrule);
+  const anchors = [];
+  const until = rule.until == null ? now : Math.min(now, rule.until);
+  if (repeatable.anchorAt > until) {
+    return anchors;
+  }
+  if (rule.freq === "DAILY") {
+    let occurrence2 = 0;
+    for (let current2 = repeatable.anchorAt; current2 <= until; current2 += rule.interval * DAY_MS2) {
+      occurrence2 += 1;
+      if (rule.count != null && occurrence2 > rule.count) {
+        break;
+      }
+      anchors.push(current2);
+    }
+    return anchors;
+  }
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    const anchorDayStart = startOfUtcDay(repeatable.anchorAt);
+    const anchorWeekStart = startOfUtcWeek(anchorDayStart);
+    const timeOffset = repeatable.anchorAt - anchorDayStart;
+    let occurrence2 = 0;
+    for (let day = anchorDayStart; day <= until; day += DAY_MS2) {
+      const weeksSince = Math.floor((startOfUtcWeek(day) - anchorWeekStart) / WEEK_MS2);
+      if (weeksSince < 0 || weeksSince % rule.interval !== 0) {
+        continue;
+      }
+      if (!rule.byDay.includes(new Date(day).getUTCDay())) {
+        continue;
+      }
+      const anchor = day + timeOffset;
+      if (anchor < repeatable.anchorAt || anchor > until) {
+        continue;
+      }
+      occurrence2 += 1;
+      if (rule.count != null && occurrence2 > rule.count) {
+        break;
+      }
+      anchors.push(anchor);
+    }
+    return anchors;
+  }
+  let occurrence = 0;
+  let current = repeatable.anchorAt;
+  while (current <= until) {
+    occurrence += 1;
+    if (rule.count != null && occurrence > rule.count) {
+      break;
+    }
+    anchors.push(current);
+    current = advanceAnchor(current, rule.freq, rule.interval);
+  }
+  return anchors;
+}
+
+// src/repeatable_quests/list_due_repeatable_quest_anchors.ts
+function listDueRepeatableQuestAnchors(db, now) {
+  const repeatables = db.prepare(
+    `SELECT *
+       FROM repeatable_quests
+       WHERE deleted_at IS NULL
+         AND archived_at IS NULL`
+  ).all().map(mapRepeatableQuestRow);
+  const anchors = [];
+  if (repeatables.length === 0) {
+    return anchors;
+  }
+  const repeatableIds = repeatables.map((repeatable) => repeatable.id);
+  const maxAnchorAt = Math.max(
+    ...repeatables.map((repeatable) => Math.max(repeatable.anchorAt, now))
+  );
+  const existingRows = db.prepare(
+    `SELECT spawned_from_repeatable_id, spawned_for_at
+       FROM quests
+       WHERE spawned_from_repeatable_id IN (${repeatableIds.map(() => "?").join(", ")})
+         AND spawned_for_at IS NOT NULL
+         AND spawned_for_at <= ?`
+  ).all(...repeatableIds, maxAnchorAt);
+  const existingAnchors = new Set(
+    existingRows.map(
+      (row) => `${Number(row.spawned_from_repeatable_id)}:${Number(row.spawned_for_at)}`
+    )
+  );
+  for (const repeatable of repeatables) {
+    const dueAnchors = generateAnchorsUntil(repeatable, now);
+    for (const anchorAt of dueAnchors) {
+      if (!existingAnchors.has(`${repeatable.id}:${anchorAt}`)) {
+        anchors.push({
+          repeatableQuestId: repeatable.id,
+          anchorAt,
+          markerId: "attention.available.repeatable"
+        });
+      }
+    }
+  }
+  return anchors.sort(
+    (a, b) => a.anchorAt - b.anchorAt || a.repeatableQuestId - b.repeatableQuestId
+  );
+}
+
+// src/markers/derive_rumor_marker_id.ts
+function deriveRumorMarkerId({ state }) {
+  if (state === "open") {
+    return "attention.available";
+  }
+  return null;
+}
+
+// src/rumors/derive_rumor_state.ts
+function deriveRumorState(rumor) {
+  if (rumor.dismissedAt != null) {
+    return "dismissed";
+  }
+  if (rumor.settledAt != null) {
+    return "settled";
+  }
+  return "open";
+}
+
+// src/rumors/map_rumor_row.ts
+function mapRumorRow(row) {
+  const rumor = {
+    id: Number(row.id),
+    title: String(row.title),
+    details: row.details == null ? null : String(row.details),
+    markerId: null,
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    settledAt: row.settled_at == null ? null : Number(row.settled_at),
+    dismissedAt: row.dismissed_at == null ? null : Number(row.dismissed_at),
+    deletedAt: row.deleted_at == null ? null : Number(row.deleted_at)
+  };
+  return {
+    ...rumor,
+    markerId: deriveRumorMarkerId({ state: deriveRumorState(rumor) })
+  };
+}
+
+// src/rumors/list_rumors.ts
+function listRumors(db) {
+  return db.prepare("SELECT * FROM rumors WHERE deleted_at IS NULL ORDER BY created_at DESC, id DESC").all().map(mapRumorRow);
+}
+
+// src/tools/tool_metadata.ts
+function defineQuestlogTool(definition) {
+  return definition;
+}
+function stringSchema(description, options = {}) {
+  return { type: "string", description, ...options };
+}
+function integerSchema(description, options = {}) {
+  return { type: "integer", description, ...options };
+}
+function booleanSchema(description, options = {}) {
+  return { type: "boolean", description, ...options };
+}
+function enumSchema(description, values) {
+  const schema = {
+    description,
+    enum: values
+  };
+  if (values.every((value) => typeof value === "string")) {
+    schema.type = "string";
+  }
+  return schema;
+}
+function arraySchema(items, description) {
+  return {
+    type: "array",
+    description,
+    items
+  };
+}
+function objectSchema(properties, required, description) {
+  const schema = {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+  if (description !== void 0) {
+    schema.description = description;
+  }
+  return schema;
+}
+
+// src/tools/tool_names.ts
+var searchQuestlogToolName = "search_questlog";
+var reviewQuestlogToolName = "review_questlog";
+var inspectQuestlogItemToolName = "inspect_questlog_item";
+var captureRumorToolName = "capture_rumor";
+var shapeWorkToolName = "shape_work";
+var planQuestToolName = "plan_quest";
+var runQuestToolName = "run_quest";
+var organizeWorkToolName = "organize_work";
+var manageRepeatableToolName = "manage_repeatable";
+var tagWorkToolName = "tag_work";
+var rewardWorkToolName = "reward_work";
+var retireWorkToolName = "retire_work";
+
+// src/tools/quest_resolution_fields.ts
+function questResolutionFields({
+  outcome,
+  resolvedAt
+}) {
+  const fields = {};
+  if (outcome != null) fields.outcome = outcome;
+  if (resolvedAt != null) fields.resolvedAt = resolvedAt;
+  return fields;
+}
+
+// src/tools/tool_ref.ts
+function toQuestRef(quest) {
+  return {
+    kind: "quest",
+    id: quest.id,
+    title: quest.title,
+    markerId: "markerId" in quest ? quest.markerId : null,
+    state: "state" in quest ? quest.state : deriveQuestState(quest)
+  };
+}
+function toQuestListItem(quest) {
+  return {
+    ...questResolutionFields(quest),
+    ...toQuestRef(quest),
+    subtitle: quest.objective,
+    dueAt: quest.effectiveDueAt,
+    available: quest.available
+  };
+}
+function toQuestlineRef(questline) {
+  return {
+    kind: "questline",
+    id: questline.id,
+    title: questline.title,
+    state: questline.archivedAt == null ? "active" : "archived"
+  };
+}
+function toQuestlineListItem(questline) {
+  return {
+    ...toQuestlineRef(questline),
+    subtitle: questline.description ?? void 0,
+    dueAt: questline.dueAt,
+    available: questline.availableQuests > 0
+  };
+}
+function toRepeatableQuestRef(repeatable) {
+  return {
+    kind: "repeatable_quest",
+    id: repeatable.id,
+    title: repeatable.title,
+    state: repeatable.archivedAt == null ? "active" : "archived"
+  };
+}
+function toRepeatableAnchorListItem(anchor, repeatable) {
+  return {
+    kind: "repeatable_quest",
+    id: anchor.repeatableQuestId,
+    title: repeatable?.title,
+    markerId: anchor.markerId,
+    state: repeatable?.archivedAt == null ? "active" : "archived",
+    dueAt: anchor.anchorAt,
+    subtitle: repeatable?.objective
+  };
+}
+function toRumorRef(rumor) {
+  return {
+    kind: "rumor",
+    id: rumor.id,
+    title: rumor.title,
+    markerId: rumor.markerId,
+    state: "state" in rumor ? rumor.state : deriveRumorState(rumor)
+  };
+}
+function toRumorListItem(rumor) {
+  return {
+    ...toRumorRef(rumor),
+    subtitle: rumor.details ?? void 0
+  };
+}
+function toRewardRef(reward) {
+  return {
+    kind: "reward",
+    id: reward.id,
+    title: reward.name,
+    state: reward.claimedAt == null ? "unclaimed" : "claimed"
+  };
+}
+function toSearchListItem(result) {
+  return {
+    kind: result.entityKind,
+    id: result.entityId,
+    title: result.title,
+    markerId: result.markerId,
+    snippet: result.snippet
+  };
+}
+
+// src/tools/tool_summary.ts
+function summarizeCount(count, singular, plural = `${singular}s`) {
+  if (count === 1) {
+    return `Found 1 ${singular}.`;
+  }
+  return `Found ${count} ${plural}.`;
+}
+
+// src/tools/tool_types.ts
+function withOptionalFields(result, options) {
+  if (options.next && options.next.length > 0) {
+    result.next = options.next;
+  }
+  if (options.warnings && options.warnings.length > 0) {
+    result.warnings = options.warnings;
+  }
+  return result;
+}
+function toolWarning(code, message) {
+  return { code, message };
+}
+function toolSuccess(summary, data, options = {}) {
+  return withOptionalFields(
+    {
+      ok: true,
+      outcome: "success",
+      summary,
+      entities: options.entities ?? [],
+      data
+    },
+    options
+  );
+}
+function toolNoOp(summary, data, options = {}) {
+  return withOptionalFields(
+    {
+      ok: true,
+      outcome: "no_op",
+      summary,
+      entities: options.entities ?? [],
+      data
+    },
+    options
+  );
+}
+function toolNeedsClarification(code, question, missing, options = {}) {
+  return withOptionalFields(
+    {
+      ok: false,
+      outcome: "needs_clarification",
+      summary: question,
+      entities: options.entities ?? [],
+      clarification: {
+        code,
+        question,
+        missing,
+        options: options.options
+      }
+    },
+    options
+  );
+}
+function toolFailure(kind, code, summary, message, options = {}) {
+  return withOptionalFields(
+    {
+      ok: false,
+      outcome: "error",
+      summary,
+      entities: options.entities ?? [],
+      error: {
+        kind,
+        code,
+        message,
+        recovery: options.recovery,
+        details: options.details
+      }
+    },
+    options
+  );
+}
+
+// src/tools/review_questlog_tool.ts
+function hasQuestFilters(filters) {
+  return Boolean(
+    filters?.questlineId != null || filters?.tagNames && filters.tagNames.length > 0 || filters?.includeDeleted
+  );
+}
+function utcDayBounds(dayAt) {
+  const date = new Date(dayAt);
+  const start = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+  return { start, end: start + 24 * 60 * 60 * 1e3 };
+}
+function validateReviewInput(input) {
+  if (input.view === "quests.scheduled_for_day") {
+    if (input.filters?.dayAt == null) {
+      return toolNeedsClarification(
+        "missing_required_choice",
+        "Which day should be reviewed for the scheduled-for-day view?",
+        ["filters.dayAt"]
+      );
+    }
+    return null;
+  }
+  if (input.filters?.dayAt != null) {
+    return toolFailure(
+      "protocol",
+      "invalid_input",
+      "The `dayAt` filter is only valid for the scheduled-for-day view.",
+      'Use `filters.dayAt` only with `view: "quests.scheduled_for_day"`.'
+    );
+  }
+  if ((input.view === "rumors" || input.view === "questlines") && hasQuestFilters(input.filters)) {
+    return toolFailure(
+      "protocol",
+      "invalid_input",
+      "Quest filters are not valid for this review view.",
+      "Use quest filters only with quest list views."
+    );
+  }
+  if (input.view === "repeatables.due_anchors" && (hasQuestFilters(input.filters) || input.filters?.dayAt != null)) {
+    return toolFailure(
+      "protocol",
+      "invalid_input",
+      "Filters are not supported for the due repeatable anchors view.",
+      "Call the due repeatable anchors view without quest filters."
+    );
+  }
+  return null;
+}
+function questFilters(input) {
+  const filters = {};
+  if (input.filters?.questlineId != null) {
+    filters.questlineId = input.filters.questlineId;
+  }
+  if (input.filters?.tagNames && input.filters.tagNames.length > 0) {
+    filters.tagNames = input.filters.tagNames;
+  }
+  if (input.filters?.includeDeleted) {
+    filters.includeDeleted = input.filters.includeDeleted;
+  }
+  return filters;
+}
+function listQuestItems(view, db, filters, now, dayAt) {
+  switch (view) {
+    case "quests.open":
+      return listOpenQuests(db, filters, now);
+    case "quests.active":
+      return listActiveQuests(db, filters, now);
+    case "quests.in_progress":
+      return listInProgressQuests(db, filters, now);
+    case "quests.available":
+      return listAvailableQuests(db, filters, now);
+    case "quests.blocked":
+      return listBlockedQuests(db, filters, now);
+    case "quests.deferred":
+      return listDeferredQuests(db, filters, now);
+    case "quests.due_soon":
+      return listDueSoonQuests(db, 7 * 24 * 60 * 60 * 1e3, filters, now);
+    case "quests.overdue":
+      return listOverdueQuests(db, filters, now);
+    case "quests.scheduled_now":
+      return listScheduledNow(db, filters, now);
+    case "quests.missed_scheduled":
+      return listMissedScheduledQuests(db, filters, now);
+    case "quests.resolved":
+      return listResolvedQuests(db, filters, now);
+    case "quests.scheduled_for_day": {
+      const bounds = utcDayBounds(dayAt ?? now);
+      return listScheduledForDay(db, bounds.start, bounds.end, filters, now);
+    }
+    default:
+      return [];
+  }
+}
+function reviewQuestlogToolHandler(db, input) {
+  const invalid = validateReviewInput(input);
+  if (invalid) {
+    return invalid;
+  }
+  const now = input.now ?? Date.now();
+  let items = [];
+  switch (input.view) {
+    case "rumors":
+      items = listRumors(db).map(toRumorListItem);
+      break;
+    case "questlines":
+      items = listQuestlines(db, now).map(toQuestlineListItem);
+      break;
+    case "repeatables.due_anchors":
+      items = listDueRepeatableQuestAnchors(db, now).map(
+        (anchor) => toRepeatableAnchorListItem(anchor, getRepeatableQuestOrThrow(db, anchor.repeatableQuestId))
+      );
+      break;
+    default:
+      items = listQuestItems(input.view, db, questFilters(input), now, input.filters?.dayAt).map(
+        toQuestListItem
+      );
+      break;
+  }
+  return toolSuccess(
+    items.length === 0 ? `No items are currently in the \`${input.view}\` view.` : summarizeCount(items.length, "item"),
+    {
+      view: input.view,
+      items,
+      count: items.length,
+      appliedFilters: input.filters,
+      evaluatedAt: now
+    },
+    {
+      entities: items.map((item) => ({
+        kind: item.kind,
+        id: item.id,
+        title: item.title,
+        markerId: item.markerId,
+        state: item.state
+      })),
+      warnings: items.length === 0 ? [toolWarning("empty_result", "This review view is currently empty.")] : void 0
+    }
+  );
+}
+var reviewQuestlogTool = defineQuestlogTool({
+  name: reviewQuestlogToolName,
+  description: "Review one operational questlog surface such as available quests, open rumors, blocked work, or due repeatable anchors.",
+  whenToUse: "Use this when you want a dashboard-style list view instead of inspecting one specific item.",
+  whenNotToUse: "Do not use this when you already know the exact item you want to inspect in depth.",
+  sideEffects: "none",
+  readOnly: true,
+  supportsClarification: true,
+  targetKinds: ["quest", "questline", "repeatable_quest", "rumor"],
+  inputDescriptions: {
+    view: "Which operational read surface to return, such as available quests, open rumors, or due repeatable anchors.",
+    filters: "Optional quest-list filters. Questline, tag, and deleted filters apply only to quest views. `dayAt` applies only to the scheduled-for-day view.",
+    now: "Optional evaluation timestamp used for time-sensitive views like availability, overdue status, and due repeatable anchors."
+  },
+  outputDescription: "Returns compact list items for the chosen view, the item count, the applied filters, and the evaluation timestamp. Empty views return a structured success result, and the scheduled-for-day view can ask for a missing day instead of failing.",
+  inputSchema: objectSchema(
+    {
+      view: enumSchema("Which operational review surface to return.", [
+        "questlines",
+        "quests.active",
+        "quests.available",
+        "quests.blocked",
+        "quests.deferred",
+        "quests.due_soon",
+        "quests.in_progress",
+        "quests.missed_scheduled",
+        "quests.open",
+        "quests.overdue",
+        "quests.resolved",
+        "quests.scheduled_for_day",
+        "quests.scheduled_now",
+        "repeatables.due_anchors",
+        "rumors"
+      ]),
+      filters: objectSchema(
+        {
+          questlineId: integerSchema("Optional questline id used by quest views."),
+          tagNames: arraySchema(
+            stringSchema("Tag name."),
+            "Optional tag names used by quest views."
+          ),
+          includeDeleted: booleanSchema(
+            "Whether deleted quests should be included in quest views."
+          ),
+          dayAt: integerSchema("UTC timestamp within the day to review for scheduled-for-day.")
+        },
+        [],
+        "Optional filters for supported review surfaces."
+      ),
+      now: integerSchema("Optional evaluation timestamp for time-sensitive views.")
+    },
+    ["view"],
+    "Review one questlog surface."
+  ),
+  handler: reviewQuestlogToolHandler
+});
+
+// src/rumors/get_rumor_or_throw.ts
+function getRumorOrThrow(db, rumorId) {
+  const row = db.prepare("SELECT * FROM rumors WHERE id = ? AND deleted_at IS NULL").get(rumorId);
+  if (!row) {
+    throw new Error(`Rumor ${rumorId} was not found.`);
+  }
+  return mapRumorRow(row);
+}
+
+// src/rumors/capture_rumor.ts
+function captureRumor(db, input) {
+  const now = resolveNow(input.now);
+  const title = assertNonEmpty(input.title, "Rumor title");
+  const created = db.prepare(
+    `INSERT INTO rumors (title, details, created_at, updated_at)
+       VALUES (?, ?, ?, ?)`
+  ).run(title, input.details?.trim() || null, now, now);
+  return getRumorOrThrow(db, Number(created.lastInsertRowid));
+}
+
+// src/tools/tool_errors.ts
+function asMessage(error) {
+  if (error instanceof Error && error.message.trim()) {
+    return error.message.trim();
+  }
+  return "Unexpected system error.";
+}
+function translateToolError(error, options = {}) {
+  const message = asMessage(error);
+  const entities = options.entities ?? [];
+  const next = options.next;
+  if (/was not found\.$/.test(message)) {
+    return toolFailure(
+      "domain",
+      "not_found",
+      options.summary ?? "The requested item was not found.",
+      message,
+      {
+        entities,
+        next: next ?? [
+          {
+            kind: "use_tool",
+            message: "Search for the correct item first if the id may be wrong.",
+            tool: searchQuestlogToolName
+          }
+        ],
+        recovery: "Use search when the exact id is unknown, then retry with the correct target."
+      }
+    );
+  }
+  if (message.includes("must not be empty") || message.includes("must not be negative") || message.includes("must be greater than zero") || message.includes("must be parseable") || message.includes("must be a positive integer") || message.includes("Unsupported RRULE")) {
+    return toolFailure(
+      "protocol",
+      "invalid_input",
+      options.summary ?? "The tool input was invalid.",
+      message,
+      {
+        entities,
+        next,
+        recovery: "Fix the invalid field values and retry."
+      }
+    );
+  }
+  if (message.includes("cannot change after") || message.includes("cannot be started") || message.includes("cannot be resolved again") || message.includes("already been claimed") || message.includes("can only be claimed") || message.includes("cannot be updated") || message.includes("cannot be removed")) {
+    return toolFailure(
+      "domain",
+      "invalid_state",
+      options.summary ?? "The request is not valid in the current state.",
+      message,
+      {
+        entities,
+        next,
+        recovery: "Inspect the target item and choose a lifecycle step that matches its current state."
+      }
+    );
+  }
+  if (message === "A quest cannot unlock itself." || message === "Unlock would create a cycle.") {
+    return toolFailure(
+      "domain",
+      "constraint_violation",
+      options.summary ?? "The requested dependency change violates unlock rules.",
+      message,
+      {
+        entities,
+        next,
+        recovery: "Remove the invalid dependency or choose a different prerequisite structure."
+      }
+    );
+  }
+  return toolFailure(
+    "system",
+    "system_error",
+    options.summary ?? "The tool failed unexpectedly.",
+    message,
+    {
+      entities,
+      next,
+      recovery: "Inspect the target and retry with a narrower action if the problem persists."
+    }
+  );
+}
+
+// src/tools/tool_next.ts
+function inspectItemNext(target) {
+  return {
+    kind: "inspect_item",
+    message: `Inspect ${target.kind} ${target.id} for full detail.`,
+    tool: "inspect_questlog_item",
+    suggestedInput: {
+      target: {
+        kind: target.kind,
+        id: target.id
+      }
+    }
+  };
+}
+function reviewViewNext(view, suggestedInput = {}) {
+  return {
+    kind: "review_view",
+    message: `Review the \`${view}\` operational view next.`,
+    tool: "review_questlog",
+    suggestedInput: {
+      view,
+      ...suggestedInput
+    }
+  };
+}
+function useToolNext(tool, message, suggestedInput = {}) {
+  return {
+    kind: "use_tool",
+    message,
+    tool,
+    suggestedInput
+  };
+}
+
+// src/tools/capture_rumor_tool.ts
+function captureRumorToolHandler(db, input) {
+  try {
+    const rumor = captureRumor(db, input);
+    const rumorRef = toRumorRef(rumor);
+    return toolSuccess(
+      `Captured rumor \`${rumor.title}\`.`,
+      { rumor },
+      {
+        entities: [rumorRef],
+        next: [
+          inspectItemNext(rumorRef),
+          useToolNext(
+            shapeWorkToolName,
+            "Settle, dismiss, or reopen this rumor later when its next action is clear.",
+            {
+              action: "settle_rumor",
+              rumorId: rumor.id
+            }
+          )
+        ]
+      }
+    );
+  } catch (error) {
+    return translateToolError(error, { summary: "Could not capture the rumor." });
+  }
+}
+var captureRumorTool = defineQuestlogTool({
+  name: captureRumorToolName,
+  description: "Capture uncertain incoming work as a rumor so it can be triaged later without prematurely turning it into committed execution.",
+  whenToUse: "Use this when something matters enough to record but is not yet ready to become a quest or questline.",
+  whenNotToUse: "Do not use this for already-committed work that should be created directly as a quest or questline.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["rumor"],
+  inputDescriptions: {
+    title: "Short rumor title describing the incoming signal or possible work.",
+    details: "Optional supporting context that explains why the rumor might matter.",
+    now: "Optional creation timestamp for the rumor."
+  },
+  outputDescription: "Returns the captured rumor, its ref, and follow-up hints for inspecting or later shaping the rumor into real work.",
+  inputSchema: objectSchema(
+    {
+      title: stringSchema("Short rumor title describing the incoming signal or possible work."),
+      details: stringSchema(
+        "Optional supporting context that explains why the rumor might matter."
+      ),
+      now: integerSchema("Optional creation timestamp for the rumor.")
+    },
+    ["title"],
+    "Capture uncertain incoming work as a rumor."
+  ),
+  handler: captureRumorToolHandler
+});
+
+// src/questlines/get_questline_or_throw.ts
+function getQuestlineOrThrow(db, questlineId) {
+  const row = db.prepare("SELECT * FROM questlines WHERE id = ? AND deleted_at IS NULL").get(questlineId);
+  if (!row) {
+    throw new Error(`Questline ${questlineId} was not found.`);
+  }
+  return mapQuestlineRow(row);
+}
+
+// src/questlines/get_questline_detail.ts
+function getQuestlineDetail(db, questlineId, now = Date.now()) {
+  const questline = getQuestlineOrThrow(db, questlineId);
+  const stats = queryQuestlineStats(db, now, [questlineId]).get(questlineId);
+  return {
+    ...questline,
+    totalQuests: stats?.totalQuests ?? 0,
+    openQuests: stats?.openQuests ?? 0,
+    inProgressQuests: stats?.inProgressQuests ?? 0,
+    doneQuests: stats?.doneQuests ?? 0,
+    abandonedQuests: stats?.abandonedQuests ?? 0,
+    availableQuests: stats?.availableQuests ?? 0,
+    overdueQuests: stats?.overdueQuests ?? 0
+  };
+}
+
+// src/rumors/get_rumor_outputs.ts
+function getRumorOutputs(db, rumorId) {
+  const questOutputs = db.prepare("SELECT id FROM quests WHERE source_rumor_id = ? AND deleted_at IS NULL").all(rumorId).map((row) => ({ entityKind: "quest", entityId: Number(row.id) }));
+  const questlineOutputs = db.prepare("SELECT id FROM questlines WHERE source_rumor_id = ? AND deleted_at IS NULL").all(rumorId).map((row) => ({ entityKind: "questline", entityId: Number(row.id) }));
+  return [...questOutputs, ...questlineOutputs].sort(
+    (a, b) => a.entityKind === b.entityKind ? a.entityId - b.entityId : a.entityKind === "quest" ? -1 : 1
+  );
+}
+
+// src/rumors/get_rumor_detail.ts
+function getRumorDetail(db, rumorId) {
+  const rumor = getRumorOrThrow(db, rumorId);
+  return {
+    ...rumor,
+    state: deriveRumorState(rumor),
+    outputs: getRumorOutputs(db, rumorId)
+  };
+}
+
+// src/tools/inspect_questlog_item_tool.ts
+function compactFields(detail, keys) {
+  const compact = {};
+  for (const key of keys) compact[key] = detail[key];
+  return compact;
+}
+function toQuestCompactDetail(detail) {
+  return {
+    ...questResolutionFields(detail),
+    ...compactFields(detail, [
+      "id",
+      "title",
+      "objective",
+      "state",
+      "markerId",
+      "available",
+      "effectiveDueAt",
+      "tagNames",
+      "questlineId",
+      "sourceRumorId",
+      "spawnedFromRepeatableId"
+    ])
+  };
+}
+function toQuestlineCompactDetail(detail) {
+  return compactFields(detail, [
+    "id",
+    "title",
+    "description",
+    "dueAt",
+    "archivedAt",
+    "totalQuests",
+    "availableQuests",
+    "overdueQuests",
+    "sourceRumorId"
+  ]);
+}
+function toRepeatableQuestCompactDetail(detail) {
+  return compactFields(detail, [
+    "id",
+    "title",
+    "objective",
+    "rrule",
+    "anchorAt",
+    "questlineId",
+    "archivedAt",
+    "deletedAt"
+  ]);
+}
+function toRumorCompactDetail(detail) {
+  return compactFields(detail, ["id", "title", "details", "state", "markerId", "outputs"]);
+}
+function inspectQuestlogItemToolHandler(db, input) {
+  const detailLevel = input.detailLevel ?? "compact";
+  try {
+    switch (input.target.kind) {
+      case "quest": {
+        const detail = getQuestDetail(db, input.target.id, input.now ?? Date.now());
+        const entities = [toQuestRef(detail)];
+        const related = [];
+        if (detail.questlineId != null) {
+          related.push({ kind: "questline", id: detail.questlineId });
+        }
+        if (detail.sourceRumorId != null) {
+          related.push({ kind: "rumor", id: detail.sourceRumorId });
+        }
+        if (detail.spawnedByQuestId != null) {
+          related.push({ kind: "quest", id: detail.spawnedByQuestId });
+        }
+        if (detail.spawnedFromRepeatableId != null) {
+          related.push({ kind: "repeatable_quest", id: detail.spawnedFromRepeatableId });
+        }
+        for (const reward of detail.rewards) {
+          related.push(toRewardRef(reward));
+        }
+        return toolSuccess(
+          `Loaded quest \`${detail.title}\`.`,
+          {
+            item: {
+              kind: "quest",
+              detail: detailLevel === "full" ? detail : toQuestCompactDetail(detail)
+            },
+            related,
+            detailLevel
+          },
+          { entities }
+        );
+      }
+      case "questline": {
+        const detail = getQuestlineDetail(db, input.target.id, input.now ?? Date.now());
+        const entities = [toQuestlineRef(detail)];
+        const related = detail.sourceRumorId == null ? [] : [{ kind: "rumor", id: detail.sourceRumorId }];
+        return toolSuccess(
+          `Loaded questline \`${detail.title}\`.`,
+          {
+            item: {
+              kind: "questline",
+              detail: detailLevel === "full" ? detail : toQuestlineCompactDetail(detail)
+            },
+            related,
+            detailLevel
+          },
+          { entities }
+        );
+      }
+      case "repeatable_quest": {
+        const detail = getRepeatableQuestOrThrow(db, input.target.id);
+        const entities = [toRepeatableQuestRef(detail)];
+        const related = detail.questlineId == null ? [] : [{ kind: "questline", id: detail.questlineId }];
+        return toolSuccess(
+          `Loaded repeatable quest \`${detail.title}\`.`,
+          {
+            item: {
+              kind: "repeatable_quest",
+              detail: detailLevel === "full" ? detail : toRepeatableQuestCompactDetail(detail)
+            },
+            related,
+            detailLevel
+          },
+          { entities }
+        );
+      }
+      case "rumor": {
+        const detail = getRumorDetail(db, input.target.id);
+        const entities = [toRumorRef(detail)];
+        const related = detail.outputs.map((output) => ({
+          kind: output.entityKind,
+          id: output.entityId
+        }));
+        return toolSuccess(
+          `Loaded rumor \`${detail.title}\`.`,
+          {
+            item: {
+              kind: "rumor",
+              detail: detailLevel === "full" ? detail : toRumorCompactDetail(detail)
+            },
+            related,
+            detailLevel
+          },
+          { entities }
+        );
+      }
+    }
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not inspect ${input.target.kind} ${input.target.id}.`,
+      entities: [{ kind: input.target.kind, id: input.target.id }]
+    });
+  }
+}
+var inspectQuestlogItemTool = defineQuestlogTool({
+  name: inspectQuestlogItemToolName,
+  description: "Inspect one specific questlog item in depth and return its richer structured detail and important related refs.",
+  whenToUse: "Use this when you already know the target item id and want either compact or full detail for one rumor, quest, questline, or repeatable quest.",
+  whenNotToUse: "Do not use this to discover items when the exact target is not known yet.",
+  sideEffects: "none",
+  readOnly: true,
+  supportsClarification: false,
+  targetKinds: ["quest", "questline", "repeatable_quest", "rumor"],
+  inputDescriptions: {
+    target: "The specific item to inspect, identified by its kind and numeric id.",
+    detailLevel: "Use `compact` by default for low-token summaries, or `full` when you need the entire domain detail payload.",
+    now: "Optional evaluation timestamp used when inspecting time-sensitive quest or questline detail."
+  },
+  outputDescription: "Returns one detail payload for the requested item plus compact refs for related downstream or linked items. Compact detail is the default to reduce token load, while full detail preserves the original richer domain shape.",
+  inputSchema: objectSchema(
+    {
+      target: objectSchema(
+        {
+          kind: enumSchema("The kind of item to inspect.", [
+            "quest",
+            "questline",
+            "repeatable_quest",
+            "rumor"
+          ]),
+          id: integerSchema("The numeric id of the item to inspect.")
+        },
+        ["kind", "id"],
+        "The specific item to inspect."
+      ),
+      detailLevel: enumSchema("How much detail to return.", ["compact", "full"]),
+      now: integerSchema("Optional evaluation timestamp for time-sensitive detail.")
+    },
+    ["target"],
+    "Inspect one specific questlog item."
+  ),
+  handler: inspectQuestlogItemToolHandler
+});
+
+// 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/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 getOrCreateTagId2(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 = getOrCreateTagId2(db, name, effectiveNow);
+    db.prepare(
+      `INSERT INTO repeatable_quest_tags (repeatable_quest_id, tag_id, created_at)
+       VALUES (?, ?, ?)`
+    ).run(repeatableQuestId, tagId, effectiveNow);
+  }
+}
+
+// src/repeatable_quests/create_repeatable_quest.ts
+function createRepeatableQuest(db, input) {
+  return withTransaction(db, () => {
+    const now = resolveNow(input.now);
+    const title = assertNonEmpty(input.title, "Repeatable quest title");
+    const objective = assertNonEmpty(input.objective, "Repeatable quest objective");
+    parseRRule(input.rrule);
+    if (input.questlineId != null) {
+      assertActiveRowExists(db, "questlines", input.questlineId, "Questline");
+    }
+    const created = db.prepare(
+      `INSERT INTO repeatable_quests (
+           questline_id,
+           title,
+           objective,
+           rrule,
+           anchor_at,
+           not_before_offset_seconds,
+           due_offset_seconds,
+           scheduled_start_offset_seconds,
+           scheduled_end_offset_seconds,
+           all_day,
+           estimate_seconds,
+           created_at,
+           updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.questlineId ?? null,
+      title,
+      objective,
+      input.rrule,
+      input.anchorAt,
+      assertNonNegativeSeconds(input.notBeforeOffsetSeconds, "Repeatable not-before offset") ?? null,
+      assertNonNegativeSeconds(input.dueOffsetSeconds, "Repeatable due offset") ?? null,
+      input.scheduledStartOffsetSeconds ?? null,
+      input.scheduledEndOffsetSeconds ?? null,
+      input.allDay ? 1 : 0,
+      assertNonNegativeSeconds(input.estimateSeconds, "Repeatable estimate") ?? null,
+      now,
+      now
+    );
+    const repeatableQuestId = Number(created.lastInsertRowid);
+    if (input.tags && input.tags.length > 0) {
+      replaceActiveRepeatableQuestTags(db, repeatableQuestId, input.tags, now);
+    }
+    if (input.rewards && input.rewards.length > 0) {
+      replaceActiveRepeatableQuestRewards(db, repeatableQuestId, input.rewards, now);
+    }
+    return getRepeatableQuestOrThrow(db, repeatableQuestId);
+  });
+}
+
+// src/repeatable_quests/soft_delete_repeatable_quest.ts
+function softDeleteRepeatableQuest(db, repeatableQuestId, deletedAt) {
+  const now = resolveNow(deletedAt);
+  getRepeatableQuestOrThrow(db, repeatableQuestId);
+  db.prepare(
+    `UPDATE repeatable_quests
+     SET deleted_at = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(now, now, repeatableQuestId);
+}
+
+// src/rewards/copy_repeatable_quest_rewards_to_quest.ts
+function copyRepeatableQuestRewardsToQuest(db, repeatableQuestId, questId, now) {
+  const effectiveNow = resolveNow(now);
+  const rows = db.prepare(
+    `SELECT kind, name, description, quantity
+       FROM repeatable_quest_rewards
+       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
+  ).all(repeatableQuestId);
+  for (const row of rows) {
+    db.prepare(
+      `INSERT INTO quest_rewards (quest_id, kind, name, description, quantity, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      questId,
+      String(row.kind),
+      String(row.name),
+      row.description == null ? null : String(row.description),
+      row.quantity == null ? null : Number(row.quantity),
+      effectiveNow
+    );
+  }
+}
+
+// src/tags/copy_repeatable_quest_tags_to_quest.ts
+function copyRepeatableQuestTagsToQuest(db, repeatableQuestId, questId, now) {
+  const effectiveNow = resolveNow(now);
+  const rows = db.prepare(
+    `SELECT tag_id
+       FROM repeatable_quest_tags
+       WHERE repeatable_quest_id = ? AND deleted_at IS NULL`
+  ).all(repeatableQuestId);
+  for (const row of rows) {
+    db.prepare(
+      `INSERT INTO quest_tags (quest_id, tag_id, created_at)
+       VALUES (?, ?, ?)`
+    ).run(questId, Number(row.tag_id), effectiveNow);
+  }
+}
+
+// src/repeatable_quests/spawn_due_repeatable_quests.ts
+function spawnDueRepeatableQuests(db, now) {
+  return withTransaction(db, () => {
+    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/tools/manage_repeatable_tool.ts
+function manageRepeatableToolHandler(db, input) {
+  try {
+    switch (input.action) {
+      case "preview_due": {
+        const now = input.now ?? Date.now();
+        const items = listDueRepeatableQuestAnchors(db, now).map(
+          (anchor) => toRepeatableAnchorListItem(
+            anchor,
+            getRepeatableQuestOrThrow(db, anchor.repeatableQuestId)
+          )
+        );
+        return toolSuccess(
+          items.length === 0 ? "No repeatable quest anchors are currently due." : `Found ${items.length} due repeatable anchors.`,
+          {
+            action: input.action,
+            created: [],
+            updated: [],
+            items
+          },
+          {
+            entities: items.map((item) => ({
+              kind: item.kind,
+              id: item.id,
+              title: item.title,
+              markerId: item.markerId,
+              state: item.state
+            })),
+            warnings: items.length === 0 ? [toolWarning("empty_result", "No repeatable anchors are due right now.")] : void 0
+          }
+        );
+      }
+      case "spawn_due": {
+        const spawned = spawnDueRepeatableQuests(db, input.now);
+        if (spawned.length === 0) {
+          return toolNoOp(
+            "No repeatable quest anchors were due to spawn.",
+            {
+              action: input.action,
+              created: [],
+              spawnedQuests: []
+            },
+            {
+              warnings: [toolWarning("empty_result", "There was nothing due to materialize.")]
+            }
+          );
+        }
+        const spawnedQuests = spawned.map((quest) => getQuestDetail(db, quest.id));
+        return toolSuccess(
+          `Spawned ${spawnedQuests.length} repeatable quest occurrences.`,
+          {
+            action: input.action,
+            created: spawnedQuests.map(toQuestRef),
+            spawnedQuests
+          },
+          {
+            entities: spawnedQuests.map(toQuestRef)
+          }
+        );
+      }
+      case "create": {
+        const repeatableQuest = createRepeatableQuest(db, input.repeatableQuest);
+        return toolSuccess(
+          `Created repeatable quest \`${repeatableQuest.title}\`.`,
+          {
+            action: input.action,
+            primary: toRepeatableQuestRef(repeatableQuest),
+            created: [toRepeatableQuestRef(repeatableQuest)],
+            repeatableQuest
+          },
+          {
+            entities: [toRepeatableQuestRef(repeatableQuest)]
+          }
+        );
+      }
+      case "update": {
+        const repeatableQuest = updateRepeatableQuest(db, input.repeatableQuestId, input);
+        return toolSuccess(
+          `Updated repeatable quest \`${repeatableQuest.title}\`.`,
+          {
+            action: input.action,
+            primary: toRepeatableQuestRef(repeatableQuest),
+            updated: [toRepeatableQuestRef(repeatableQuest)],
+            repeatableQuest
+          },
+          {
+            entities: [toRepeatableQuestRef(repeatableQuest)]
+          }
+        );
+      }
+      case "archive": {
+        const current = getRepeatableQuestOrThrow(db, input.repeatableQuestId);
+        if (current.archivedAt != null) {
+          return toolNoOp(
+            `Repeatable quest \`${current.title}\` is already archived.`,
+            {
+              action: input.action,
+              primary: toRepeatableQuestRef(current),
+              repeatableQuest: current
+            },
+            {
+              entities: [toRepeatableQuestRef(current)]
+            }
+          );
+        }
+        const repeatableQuest = archiveRepeatableQuest(
+          db,
+          input.repeatableQuestId,
+          input.archivedAt
+        );
+        return toolSuccess(
+          `Archived repeatable quest \`${repeatableQuest.title}\`.`,
+          {
+            action: input.action,
+            primary: toRepeatableQuestRef(repeatableQuest),
+            updated: [toRepeatableQuestRef(repeatableQuest)],
+            repeatableQuest
+          },
+          {
+            entities: [toRepeatableQuestRef(repeatableQuest)]
+          }
+        );
+      }
+    }
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete manage-repeatable action \`${input.action}\`.`
+    });
+  }
+}
+var manageRepeatableTool = defineQuestlogTool({
+  name: manageRepeatableToolName,
+  description: "Manage recurring work definitions by creating, updating, previewing, spawning, or archiving repeatable quests.",
+  whenToUse: "Use this when the work is a repeatable template or when due recurring anchors need to be previewed or materialized.",
+  whenNotToUse: "Do not use this for one-off concrete quest execution, for inspecting an existing concrete quest, or for hiding a repeatable quest. Use `retire_work` for hiding.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["repeatable_quest", "quest"],
+  inputDescriptions: {
+    action: "Which repeatable quest lifecycle action to perform.",
+    repeatableQuest: "The repeatable quest creation input used for the create action.",
+    repeatableQuestId: "The repeatable quest definition being updated or archived.",
+    rrule: "Optional new RRULE that changes future materialization behavior.",
+    anchorAt: "Optional new recurrence anchor timestamp for future materialization.",
+    notBeforeOffsetSeconds: "Optional not-before offset in seconds applied to future spawned quests.",
+    dueOffsetSeconds: "Optional due offset in seconds applied to future spawned quests.",
+    scheduledStartOffsetSeconds: "Optional scheduled-start offset in seconds applied to future spawned quests.",
+    scheduledEndOffsetSeconds: "Optional scheduled-end offset in seconds applied to future spawned quests.",
+    allDay: "Whether future spawned schedule windows should be treated as all-day.",
+    estimateSeconds: "Optional active-effort estimate in seconds for future spawned quests.",
+    title: "Optional new repeatable quest title.",
+    objective: "Optional new repeatable quest objective.",
+    questlineId: "Optional questline that should own the repeatable quest.",
+    archivedAt: "Optional archive timestamp for the archive action.",
+    now: "Evaluation or spawn timestamp for previewing or materializing due anchors."
+  },
+  outputDescription: "Returns the changed repeatable quest, due anchor preview items, or spawned quest details for the selected recurrence action. Empty previews and empty spawns return structured success or no-op results, and repeatable hiding is now intentionally routed through `retire_work`.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", [
+        "archive",
+        "create",
+        "preview_due",
+        "spawn_due",
+        "update"
+      ]),
+      repeatableQuestId: integerSchema("Repeatable quest to archive or update."),
+      repeatableQuest: objectSchema(
+        {
+          title: stringSchema("Title for the new repeatable quest."),
+          objective: stringSchema("Objective for the new repeatable quest."),
+          rrule: stringSchema("RRULE describing recurrence."),
+          anchorAt: integerSchema("Recurrence anchor timestamp.")
+        },
+        ["title", "objective", "rrule", "anchorAt"]
+      ),
+      title: stringSchema("Optional new title for the update action."),
+      objective: stringSchema("Optional new objective for the update action."),
+      questlineId: integerSchema("Optional new questline id."),
+      rrule: stringSchema("Optional new RRULE."),
+      anchorAt: integerSchema("Optional new recurrence anchor timestamp."),
+      notBeforeOffsetSeconds: integerSchema("Optional new not-before offset in seconds."),
+      dueOffsetSeconds: integerSchema("Optional new due offset in seconds."),
+      scheduledStartOffsetSeconds: integerSchema("Optional new scheduled-start offset in seconds."),
+      scheduledEndOffsetSeconds: integerSchema("Optional new scheduled-end offset in seconds."),
+      allDay: booleanSchema("Whether future schedules are all-day."),
+      estimateSeconds: integerSchema("Optional new effort estimate."),
+      archivedAt: integerSchema("Optional archive timestamp."),
+      now: integerSchema("Evaluation or update timestamp.")
+    },
+    ["action"],
+    "Manage repeatable quest definitions and due materialization."
+  ),
+  handler: manageRepeatableToolHandler
+});
+
+// src/questlines/update_questline.ts
+function updateQuestline(db, questlineId, input) {
+  return withTransaction(db, () => {
+    const current = getQuestlineOrThrow(db, questlineId);
+    const now = resolveNow(input.now);
+    db.prepare(
+      `UPDATE questlines
+       SET title = ?,
+           description = ?,
+           starts_at = ?,
+           due_at = ?,
+           archived_at = ?,
+           updated_at = ?
+       WHERE id = ?`
+    ).run(
+      input.title == null ? current.title : assertNonEmpty(input.title, "Questline title"),
+      input.description === void 0 ? current.description : input.description?.trim() || null,
+      input.startsAt === void 0 ? current.startsAt : input.startsAt,
+      input.dueAt === void 0 ? current.dueAt : input.dueAt,
+      input.archivedAt === void 0 ? current.archivedAt : input.archivedAt,
+      now,
+      questlineId
+    );
+    return getQuestlineOrThrow(db, questlineId);
+  });
+}
+
+// src/questlines/archive_questline.ts
+function archiveQuestline(db, questlineId, archivedAt) {
+  return updateQuestline(db, questlineId, { archivedAt: resolveNow(archivedAt) });
+}
+
+// src/questlines/create_questline.ts
+function createQuestline(db, input) {
+  const now = resolveNow(input.now);
+  const title = assertNonEmpty(input.title, "Questline title");
+  if (input.sourceRumorId != null) {
+    assertActiveRowExists(db, "rumors", input.sourceRumorId, "Rumor");
+  }
+  const created = db.prepare(
+    `INSERT INTO questlines (
+         source_rumor_id,
+         title,
+         description,
+         starts_at,
+         due_at,
+         created_at,
+         updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    input.sourceRumorId ?? null,
+    title,
+    input.description?.trim() || null,
+    input.startsAt ?? null,
+    input.dueAt ?? null,
+    now,
+    now
+  );
+  return getQuestlineOrThrow(db, Number(created.lastInsertRowid));
+}
+
+// src/questlines/detach_quest_from_questline.ts
+function detachQuestFromQuestline(db, questId, now) {
+  assertActiveRowExists(db, "quests", questId, "Quest");
+  db.prepare(
+    "UPDATE quests SET questline_id = NULL, updated_at = ? WHERE id = ? AND deleted_at IS NULL"
+  ).run(resolveNow(now), questId);
+}
+
+// src/questlines/move_quest_to_questline.ts
+function moveQuestToQuestline(db, questId, questlineId, now) {
+  assertActiveRowExists(db, "quests", questId, "Quest");
+  assertActiveRowExists(db, "questlines", questlineId, "Questline");
+  db.prepare(
+    "UPDATE quests SET questline_id = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL"
+  ).run(questlineId, resolveNow(now), questId);
+}
+
+// src/questlines/soft_delete_questline.ts
+function softDeleteQuestline(db, questlineId, deletedAt) {
+  const now = resolveNow(deletedAt);
+  assertActiveRowExists(db, "questlines", questlineId, "Questline");
+  db.prepare(
+    "UPDATE questlines SET deleted_at = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL"
+  ).run(now, now, questlineId);
+}
+
+// src/unlocks/remove_unlock.ts
+function removeUnlock(db, fromQuestId, toQuestId, now) {
+  db.prepare(
+    `UPDATE quest_unlocks
+     SET deleted_at = ?
+     WHERE from_quest_id = ? AND to_quest_id = ? AND deleted_at IS NULL`
+  ).run(resolveNow(now), fromQuestId, toQuestId);
+}
+
+// src/unlocks/replace_unlocks.ts
+function replaceUnlocks(db, toQuestId, fromQuestIds, now) {
+  withTransaction(db, () => {
+    db.prepare(
+      `UPDATE quest_unlocks
+       SET deleted_at = ?
+       WHERE to_quest_id = ? AND deleted_at IS NULL`
+    ).run(resolveNow(now), toQuestId);
+    for (const fromQuestId of [...new Set(fromQuestIds)]) {
+      addUnlock(db, fromQuestId, toQuestId, now);
+    }
+  });
+}
+
+// src/tools/organize_work_tool.ts
+function sameQuestlineFields(current, input) {
+  return (input.title === void 0 || input.title === current.title) && (input.description === void 0 || input.description === current.description) && (input.startsAt === void 0 || input.startsAt === current.startsAt) && (input.dueAt === void 0 || input.dueAt === current.dueAt) && (input.archivedAt === void 0 || input.archivedAt === current.archivedAt);
+}
+function organizeWorkToolHandler(db, input) {
+  try {
+    switch (input.action) {
+      case "set_questline_fields": {
+        const current = getQuestlineDetail(db, input.questlineId);
+        if (sameQuestlineFields(current, input)) {
+          return toolNoOp(
+            `Questline \`${current.title}\` already has those fields.`,
+            {
+              action: input.action,
+              questline: current
+            },
+            {
+              entities: [toQuestlineRef(current)]
+            }
+          );
+        }
+        updateQuestline(db, input.questlineId, input);
+        const detail = getQuestlineDetail(db, input.questlineId);
+        return toolSuccess(
+          `Updated questline \`${detail.title}\`.`,
+          {
+            action: input.action,
+            questline: detail
+          },
+          {
+            entities: [toQuestlineRef(detail)]
+          }
+        );
+      }
+      case "archive_questline": {
+        const current = getQuestlineDetail(db, input.questlineId);
+        if (current.archivedAt != null) {
+          return toolNoOp(
+            `Questline \`${current.title}\` is already archived.`,
+            {
+              action: input.action,
+              questline: current
+            },
+            {
+              entities: [toQuestlineRef(current)]
+            }
+          );
+        }
+        archiveQuestline(db, input.questlineId, input.archivedAt);
+        const detail = getQuestlineDetail(db, input.questlineId);
+        return toolSuccess(
+          `Archived questline \`${detail.title}\`.`,
+          {
+            action: input.action,
+            questline: detail
+          },
+          {
+            entities: [toQuestlineRef(detail)]
+          }
+        );
+      }
+      case "add_unlock": {
+        const current = getQuestDetail(db, input.toQuestId);
+        if (current.unlockedByQuestIds.includes(input.fromQuestId)) {
+          return toolNoOp(
+            `Quest \`${current.title}\` is already blocked by that prerequisite.`,
+            {
+              action: input.action,
+              quest: current
+            },
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        addUnlock(db, input.fromQuestId, input.toQuestId, input.now);
+        const detail = getQuestDetail(db, input.toQuestId);
+        return toolSuccess(
+          `Added an unlock prerequisite to quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail), { kind: "quest", id: input.fromQuestId }]
+          }
+        );
+      }
+      case "remove_unlock": {
+        const current = getQuestDetail(db, input.toQuestId);
+        if (!current.unlockedByQuestIds.includes(input.fromQuestId)) {
+          return toolNoOp(
+            `Quest \`${current.title}\` is not blocked by that prerequisite.`,
+            {
+              action: input.action,
+              quest: current
+            },
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        removeUnlock(db, input.fromQuestId, input.toQuestId, input.now);
+        const detail = getQuestDetail(db, input.toQuestId);
+        return toolSuccess(
+          `Removed an unlock prerequisite from quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail), { kind: "quest", id: input.fromQuestId }]
+          }
+        );
+      }
+      case "replace_unlocks": {
+        const current = getQuestDetail(db, input.toQuestId);
+        const currentIds = [...current.unlockedByQuestIds].sort((a, b) => a - b);
+        const nextIds = [...new Set(input.fromQuestIds)].sort((a, b) => a - b);
+        if (currentIds.length === nextIds.length && currentIds.every((value, index) => value === nextIds[index])) {
+          return toolNoOp(
+            `Quest \`${current.title}\` already has that blocker set.`,
+            {
+              action: input.action,
+              quest: current
+            },
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        replaceUnlocks(db, input.toQuestId, input.fromQuestIds, input.now);
+        const detail = getQuestDetail(db, input.toQuestId);
+        return toolSuccess(
+          `Replaced the blocker set for quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            quest: detail
+          },
+          {
+            entities: [
+              toQuestRef(detail),
+              ...nextIds.map((id) => ({ kind: "quest", id }))
+            ]
+          }
+        );
+      }
+    }
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete organize-work action \`${input.action}\`.`
+    });
+  }
+}
+var organizeWorkTool = defineQuestlogTool({
+  name: organizeWorkToolName,
+  description: "Organize grouping and dependency structure by updating questlines or changing hard unlock prerequisites between concrete quests.",
+  whenToUse: "Use this when work structure or gating logic should change without changing quest execution state.",
+  whenNotToUse: "Do not use this for quest execution, planning-only edits, intake capture, or tag-like classification.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["quest", "questline"],
+  inputDescriptions: {
+    action: "Which structural organization action to perform.",
+    questlineId: "The questline to update or archive.",
+    title: "Optional new questline title for field updates.",
+    description: "Optional new questline description for field updates.",
+    startsAt: "Optional questline start timestamp for field updates.",
+    dueAt: "Optional questline due timestamp for field updates.",
+    archivedAt: "Optional archive timestamp for archiving a questline.",
+    toQuestId: "The quest whose incoming blocker set should change.",
+    fromQuestId: "The prerequisite quest for add-unlock or remove-unlock actions.",
+    fromQuestIds: "The full prerequisite quest id set for the replace-unlocks action.",
+    now: "Optional timestamp for unlock changes."
+  },
+  outputDescription: "Returns the updated questline detail or target quest detail after grouping or dependency changes. Repeated equivalent changes return structured no-op results.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", [
+        "add_unlock",
+        "archive_questline",
+        "remove_unlock",
+        "replace_unlocks",
+        "set_questline_fields"
+      ]),
+      questlineId: integerSchema("Questline to update or archive."),
+      title: stringSchema("Optional new questline title."),
+      description: stringSchema("Optional new questline description."),
+      startsAt: integerSchema("Optional questline start timestamp."),
+      dueAt: integerSchema("Optional questline due timestamp."),
+      archivedAt: integerSchema("Optional archive timestamp."),
+      toQuestId: integerSchema("Quest whose blockers should change."),
+      fromQuestId: integerSchema("Prerequisite quest id."),
+      fromQuestIds: arraySchema(integerSchema("Quest id."), "Full prerequisite quest id set."),
+      now: integerSchema("Optional timestamp.")
+    },
+    ["action"],
+    "Organize questline fields and unlock dependencies."
+  ),
+  handler: organizeWorkToolHandler
+});
+
+// src/tools/plan_quest_tool.ts
+function samePlanningState(current, input) {
+  return (input.notBeforeAt === void 0 || input.notBeforeAt === current.notBeforeAt) && (input.dueAt === void 0 || input.dueAt === current.dueAt) && (input.scheduledStartAt === void 0 || input.scheduledStartAt === current.scheduledStartAt) && (input.scheduledEndAt === void 0 || input.scheduledEndAt === current.scheduledEndAt) && (input.allDay === void 0 || input.allDay === current.allDay) && (input.estimateSeconds === void 0 || input.estimateSeconds === current.estimateSeconds);
+}
+function planQuestToolHandler(db, input) {
+  try {
+    const current = getQuestDetail(db, input.questId);
+    if (input.action === "revise_objective") {
+      const nextObjective = input.objective.trim();
+      if (nextObjective === current.objective) {
+        return toolNoOp(
+          `Quest \`${current.title}\` already has that objective.`,
+          {
+            action: input.action,
+            quest: current
+          },
+          {
+            entities: [toQuestRef(current)]
+          }
+        );
+      }
+      reviseQuestObjective(db, input.questId, input.objective, input.now);
+      const detail2 = getQuestDetail(db, input.questId);
+      return toolSuccess(
+        `Revised quest objective for \`${detail2.title}\`.`,
+        {
+          action: input.action,
+          quest: detail2
+        },
+        {
+          entities: [toQuestRef(detail2)]
+        }
+      );
+    }
+    if (samePlanningState(current, input)) {
+      return toolNoOp(
+        `Quest \`${current.title}\` already has that planning state.`,
+        {
+          action: input.action,
+          quest: current
+        },
+        {
+          entities: [toQuestRef(current)]
+        }
+      );
+    }
+    planQuestTime(db, input.questId, input);
+    const detail = getQuestDetail(db, input.questId);
+    return toolSuccess(
+      `Updated planning for quest \`${detail.title}\`.`,
+      {
+        action: input.action,
+        quest: detail
+      },
+      {
+        entities: [toQuestRef(detail)]
+      }
+    );
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete plan-quest action \`${input.action}\`.`
+    });
+  }
+}
+var planQuestTool = defineQuestlogTool({
+  name: planQuestToolName,
+  description: "Refine a quest by revising its objective before actual start or by changing its temporal planning fields.",
+  whenToUse: "Use this when you need to sharpen what the quest means or how it is timed without starting or resolving it.",
+  whenNotToUse: "Do not use this for lifecycle execution such as start, finish, abandon, or effort logging.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["quest"],
+  inputDescriptions: {
+    action: "Whether to revise the quest objective or update the quest timing and estimate fields.",
+    questId: "The concrete quest to refine.",
+    objective: "The new quest objective text for the revise-objective action.",
+    notBeforeAt: "Optional earliest actionable timestamp for the quest.",
+    dueAt: "Optional latest acceptable completion timestamp for the quest.",
+    scheduledStartAt: "Optional planned schedule window start timestamp.",
+    scheduledEndAt: "Optional planned schedule window end timestamp.",
+    allDay: "Whether the scheduled window should be treated as all-day.",
+    estimateSeconds: "Optional estimate of active effort in seconds.",
+    now: "Optional timestamp for updating the quest."
+  },
+  outputDescription: "Returns the updated quest detail after objective or planning changes. If the requested planning state is already present, the tool returns a structured no-op result.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", ["revise_objective", "set_time"]),
+      questId: integerSchema("The quest to refine."),
+      objective: stringSchema("The new quest objective text. Required for revise_objective."),
+      notBeforeAt: integerSchema("Optional earliest actionable timestamp."),
+      dueAt: integerSchema("Optional latest acceptable completion timestamp."),
+      scheduledStartAt: integerSchema("Optional planned schedule window start."),
+      scheduledEndAt: integerSchema("Optional planned schedule window end."),
+      allDay: booleanSchema("Whether the planned schedule window is all-day."),
+      estimateSeconds: integerSchema("Optional active-effort estimate in seconds."),
+      now: integerSchema("Optional update timestamp.")
+    },
+    ["action", "questId"],
+    "Refine a quest objective or planning state."
+  ),
+  handler: planQuestToolHandler
+});
+
+// src/rumors/soft_delete_rumor.ts
+function softDeleteRumor(db, rumorId, now) {
+  const deletedAt = resolveNow(now);
+  assertActiveRowExists(db, "rumors", rumorId, "Rumor");
+  db.prepare(
+    `UPDATE rumors
+     SET deleted_at = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(deletedAt, deletedAt, rumorId);
+}
+
+// src/tools/retire_work_tool.ts
+function readRetireStatus(db, target) {
+  switch (target.kind) {
+    case "rumor": {
+      const row = db.prepare("SELECT title, deleted_at FROM rumors WHERE id = ?").get(target.id);
+      if (!row) {
+        return null;
+      }
+      return {
+        deletedAt: row.deleted_at == null ? null : Number(row.deleted_at),
+        title: row.title == null ? null : String(row.title)
+      };
+    }
+    case "quest": {
+      const row = db.prepare("SELECT title, deleted_at FROM quests WHERE id = ?").get(target.id);
+      if (!row) {
+        return null;
+      }
+      return {
+        deletedAt: row.deleted_at == null ? null : Number(row.deleted_at),
+        title: row.title == null ? null : String(row.title)
+      };
+    }
+    case "questline": {
+      const row = db.prepare("SELECT title, deleted_at FROM questlines WHERE id = ?").get(target.id);
+      if (!row) {
+        return null;
+      }
+      return {
+        deletedAt: row.deleted_at == null ? null : Number(row.deleted_at),
+        title: row.title == null ? null : String(row.title)
+      };
+    }
+    case "repeatable_quest": {
+      const row = db.prepare("SELECT title, deleted_at FROM repeatable_quests WHERE id = ?").get(target.id);
+      if (!row) {
+        return null;
+      }
+      return {
+        deletedAt: row.deleted_at == null ? null : Number(row.deleted_at),
+        title: row.title == null ? null : String(row.title)
+      };
+    }
+  }
+}
+function retireWorkToolHandler(db, input) {
+  try {
+    const status = readRetireStatus(db, input.target);
+    if (status?.deletedAt != null) {
+      return toolNoOp(
+        `${input.target.kind} \`${status.title ?? input.target.id}\` is already hidden.`,
+        {
+          action: input.action,
+          target: input.target
+        },
+        {
+          entities: [
+            { kind: input.target.kind, id: input.target.id, title: status.title ?? void 0 }
+          ]
+        }
+      );
+    }
+    switch (input.target.kind) {
+      case "rumor":
+        softDeleteRumor(db, input.target.id, input.deletedAt);
+        break;
+      case "quest":
+        softDeleteQuest(db, input.target.id, input.deletedAt);
+        break;
+      case "questline":
+        softDeleteQuestline(db, input.target.id, input.deletedAt);
+        break;
+      case "repeatable_quest":
+        softDeleteRepeatableQuest(db, input.target.id, input.deletedAt);
+        break;
+    }
+    return toolSuccess(
+      `Hid ${input.target.kind} ${input.target.id}.`,
+      {
+        action: input.action,
+        target: input.target
+      },
+      {
+        entities: [
+          { kind: input.target.kind, id: input.target.id, title: status?.title ?? void 0 }
+        ]
+      }
+    );
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not hide ${input.target.kind} ${input.target.id}.`
+    });
+  }
+}
+var retireWorkTool = defineQuestlogTool({
+  name: retireWorkToolName,
+  description: "Hide an item from normal active operation without rewriting history by soft-deleting a rumor, quest, questline, or repeatable quest.",
+  whenToUse: "Use this when work should disappear from active reads while preserving historical truth.",
+  whenNotToUse: "Do not use this when you mean to archive a questline or repeatable quest while keeping it visible as retired structure.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["quest", "questline", "repeatable_quest", "rumor"],
+  inputDescriptions: {
+    action: "The retirement action to perform. This tool currently supports hiding an item.",
+    target: "The rumor, quest, questline, or repeatable quest to hide.",
+    deletedAt: "Optional timestamp to record when the item became hidden."
+  },
+  outputDescription: "Returns a structured success result for the hidden target, or a structured no-op when the target is already hidden.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("The retirement action to perform.", ["hide"]),
+      target: objectSchema(
+        {
+          kind: enumSchema("The kind of item to hide.", [
+            "quest",
+            "questline",
+            "repeatable_quest",
+            "rumor"
+          ]),
+          id: integerSchema("The numeric id of the item to hide.")
+        },
+        ["kind", "id"],
+        "The target to hide."
+      ),
+      deletedAt: integerSchema("Optional timestamp to record when the item became hidden.")
+    },
+    ["action", "target"],
+    "Hide a questlog item without rewriting history."
+  ),
+  handler: retireWorkToolHandler
+});
+
+// src/rewards/get_quest_reward_or_throw.ts
+function getQuestRewardOrThrow(db, rewardId) {
+  const row = db.prepare("SELECT * FROM quest_rewards WHERE id = ? AND deleted_at IS NULL").get(rewardId);
+  if (!row) {
+    throw new Error(`Quest reward ${rewardId} was not found.`);
+  }
+  return mapQuestRewardRow(row);
+}
+
+// src/rewards/add_quest_reward.ts
+function addQuestReward(db, questId, input) {
+  assertActiveRowExists(db, "quests", questId, "Quest");
+  const now = resolveNow(input.now);
+  const created = db.prepare(
+    `INSERT INTO quest_rewards (quest_id, kind, name, description, quantity, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    questId,
+    assertNonEmpty(input.kind, "Reward kind"),
+    assertNonEmpty(input.name, "Reward name"),
+    input.description?.trim() || null,
+    assertNonNegativeNumber(input.quantity, "Reward quantity") ?? null,
+    now
+  );
+  return getQuestRewardOrThrow(db, Number(created.lastInsertRowid));
+}
+
+// src/rewards/claim_quest_reward.ts
+function claimQuestReward(db, rewardId, claimedAt) {
+  const reward = getQuestRewardOrThrow(db, rewardId);
+  if (reward.claimedAt != null) {
+    throw new Error("Reward has already been claimed.");
+  }
+  const quest = getQuestOrThrow(db, reward.questId);
+  if (quest.resolvedAt == null || quest.success !== true) {
+    throw new Error("Rewards can only be claimed for successfully resolved quests.");
+  }
+  db.prepare(
+    `UPDATE quest_rewards
+     SET claimed_at = ?
+     WHERE id = ? AND claimed_at IS NULL AND deleted_at IS NULL`
+  ).run(resolveNow(claimedAt), rewardId);
+  return getQuestRewardOrThrow(db, rewardId);
+}
+
+// src/rewards/remove_quest_reward.ts
+function removeQuestReward(db, rewardId, now) {
+  const current = getQuestRewardOrThrow(db, rewardId);
+  if (current.claimedAt != null) {
+    throw new Error("Claimed rewards cannot be removed.");
+  }
+  db.prepare(
+    `UPDATE quest_rewards
+     SET deleted_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(resolveNow(now), rewardId);
+}
+
+// src/rewards/replace_repeatable_quest_rewards.ts
+function replaceRepeatableQuestRewards(db, repeatableQuestId, rewards, now) {
+  assertActiveRowExists(db, "repeatable_quests", repeatableQuestId, "Repeatable quest");
+  replaceActiveRepeatableQuestRewards(db, repeatableQuestId, rewards, now);
+  db.prepare("UPDATE repeatable_quests SET updated_at = ? WHERE id = ?").run(
+    resolveNow(now),
+    repeatableQuestId
+  );
+}
+
+// src/rewards/update_quest_reward.ts
+function updateQuestReward(db, rewardId, input) {
+  const current = getQuestRewardOrThrow(db, rewardId);
+  if (current.claimedAt != null) {
+    throw new Error("Claimed rewards cannot be updated.");
+  }
+  const now = resolveNow(input.now);
+  db.prepare(
+    `UPDATE quest_rewards
+     SET kind = ?, name = ?, description = ?, quantity = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(
+    assertNonEmpty(input.kind, "Reward kind"),
+    assertNonEmpty(input.name, "Reward name"),
+    input.description?.trim() || null,
+    assertNonNegativeNumber(input.quantity, "Reward quantity") ?? null,
+    rewardId
+  );
+  db.prepare("UPDATE quests SET updated_at = ? WHERE id = ?").run(now, current.questId);
+  return getQuestRewardOrThrow(db, rewardId);
+}
+
+// src/tools/reward_work_tool.ts
+function rewardWorkToolHandler(db, input) {
+  try {
+    switch (input.action) {
+      case "add": {
+        const reward = addQuestReward(db, input.target.id, input.reward);
+        return toolSuccess(
+          "Added quest reward.",
+          {
+            action: input.action,
+            target: input.target,
+            reward
+          },
+          {
+            entities: [{ kind: "quest", id: input.target.id }, toRewardRef(reward)]
+          }
+        );
+      }
+      case "update": {
+        const reward = updateQuestReward(db, input.target.id, input.reward);
+        return toolSuccess(
+          "Updated quest reward.",
+          {
+            action: input.action,
+            target: input.target,
+            reward
+          },
+          {
+            entities: [toRewardRef(reward)]
+          }
+        );
+      }
+      case "remove": {
+        const current = getQuestRewardOrThrow(db, input.target.id);
+        if (current.claimedAt != null) {
+          return translateToolError(new Error("Claimed rewards cannot be removed."), {
+            summary: "Could not remove the claimed reward.",
+            entities: [toRewardRef(current)]
+          });
+        }
+        removeQuestReward(db, input.target.id, input.now);
+        return toolSuccess(
+          "Removed quest reward.",
+          {
+            action: input.action,
+            target: input.target
+          },
+          {
+            entities: [toRewardRef(current)]
+          }
+        );
+      }
+      case "claim": {
+        const current = getQuestRewardOrThrow(db, input.target.id);
+        if (current.claimedAt != null) {
+          return toolNoOp(
+            `Reward \`${current.name}\` is already claimed.`,
+            {
+              action: input.action,
+              target: input.target,
+              reward: current
+            },
+            {
+              entities: [toRewardRef(current)]
+            }
+          );
+        }
+        const reward = claimQuestReward(db, input.target.id, input.claimedAt);
+        return toolSuccess(
+          "Claimed quest reward.",
+          {
+            action: input.action,
+            target: input.target,
+            reward
+          },
+          {
+            entities: [toRewardRef(reward)]
+          }
+        );
+      }
+      case "replace_repeatable_template": {
+        assertActiveRowExists(db, "repeatable_quests", input.target.id, "Repeatable quest");
+        replaceRepeatableQuestRewards(db, input.target.id, input.rewards, input.now);
+        return toolSuccess(
+          "Replaced repeatable quest future reward templates.",
+          {
+            action: input.action,
+            target: input.target
+          },
+          {
+            entities: [{ kind: "repeatable_quest", id: input.target.id }],
+            warnings: [
+              toolWarning(
+                "future_only_effect",
+                "This change only affects future spawned quests, not historical spawned rewards."
+              )
+            ]
+          }
+        );
+      }
+    }
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete reward-work action \`${input.action}\`.`
+    });
+  }
+}
+var rewardWorkTool = defineQuestlogTool({
+  name: rewardWorkToolName,
+  description: "Manage rewards by adding, updating, removing, or claiming quest rewards, or by replacing future reward templates on repeatable quests.",
+  whenToUse: "Use this when a completed or recurring piece of work should grant or update reward information.",
+  whenNotToUse: "Do not use this to finish quests themselves or to model dependencies, classification, or scheduling.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["quest", "reward", "repeatable_quest"],
+  inputDescriptions: {
+    action: "Which reward action to perform on the selected target.",
+    target: "The quest, reward, or repeatable quest that the reward action applies to.",
+    reward: "Reward fields used when adding or updating one concrete quest reward.",
+    rewards: "The full future reward template set for a repeatable quest.",
+    claimedAt: "Optional timestamp for claiming a reward.",
+    now: "Optional timestamp for removing a reward or replacing repeatable reward templates."
+  },
+  outputDescription: "Returns the updated or claimed reward when one concrete reward changes, or a structured success result for repeatable future template replacement. Already-claimed rewards return a structured no-op for claim and an error for invalid update or remove attempts.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", [
+        "add",
+        "claim",
+        "remove",
+        "replace_repeatable_template",
+        "update"
+      ]),
+      target: objectSchema(
+        {
+          id: integerSchema("Target entity id."),
+          kind: enumSchema("Target kind.", ["quest", "reward", "repeatable_quest"])
+        },
+        ["id", "kind"]
+      ),
+      reward: objectSchema(
+        {
+          kind: stringSchema("Reward kind."),
+          name: stringSchema("Reward name."),
+          now: integerSchema("Optional update timestamp for the update action.")
+        },
+        []
+      ),
+      rewards: arraySchema(
+        objectSchema(
+          {
+            kind: stringSchema("Reward kind."),
+            name: stringSchema("Reward name.")
+          },
+          ["kind", "name"]
+        ),
+        "Full future reward template set. Required for replace_repeatable_template."
+      ),
+      claimedAt: integerSchema("Optional claim timestamp."),
+      now: integerSchema("Optional timestamp for removal or template replacement.")
+    },
+    ["action", "target"],
+    "Manage quest rewards and repeatable reward templates."
+  ),
+  handler: rewardWorkToolHandler
+});
+
+// src/tools/run_quest_tool.ts
+function runQuestToolHandler(db, input) {
+  try {
+    const current = getQuestDetail(db, input.questId);
+    if (input.action !== "start" && input.action !== "log_effort") {
+      const outcome = input.outcome;
+      if (typeof outcome !== "string") {
+        return toolNeedsClarification(
+          "missing_required_choice",
+          `What outcome should be recorded for quest \`${current.title}\`?`,
+          ["outcome"]
+        );
+      }
+    }
+    switch (input.action) {
+      case "start": {
+        if (current.resolvedAt != null) {
+          return translateToolError(new Error("Resolved quests cannot be started."), {
+            summary: `Could not start quest \`${current.title}\`.`,
+            entities: [toQuestRef(current)]
+          });
+        }
+        if (current.startedAt != null) {
+          return toolNoOp(
+            `Quest \`${current.title}\` is already started.`,
+            {
+              action: input.action,
+              primary: toQuestRef(current),
+              quest: current
+            },
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        const blockers = db.prepare(
+          `SELECT blocker.id FROM quest_unlocks prerequisite
+                     JOIN quests blocker ON blocker.id = prerequisite.from_quest_id
+                     WHERE prerequisite.to_quest_id = ?
+                       AND prerequisite.deleted_at IS NULL
+                       AND blocker.deleted_at IS NULL
+                       AND NOT (blocker.resolved_at IS NOT NULL AND blocker.success = 1)
+                     ORDER BY blocker.id`
+        ).all(current.id).map(({ id }) => getQuestDetail(db, id));
+        if (blockers.length && !input.force) {
+          return toolFailure(
+            "domain",
+            "invalid_state",
+            `Quest "${current.title}" is blocked by ${blockers.map((quest) => quest.title).join(", ")}.`,
+            "Finish the blocking prerequisites before starting this quest, or set force to true.",
+            {
+              entities: [toQuestRef(current), ...blockers.map(toQuestRef)],
+              next: blockers.map((quest) => ({
+                ...inspectItemNext(toQuestRef(quest)),
+                message: `Inspect and finish blocker "${quest.title}".`
+              }))
+            }
+          );
+        }
+        startQuest(db, input.questId, input.startedAt);
+        const detail = getQuestDetail(db, input.questId);
+        return toolSuccess(
+          `Started quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            updated: [toQuestRef(detail)],
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail)],
+            warnings: blockers.length ? [
+              {
+                code: "derived_value_used",
+                message: `Forced start with unmet prerequisites: ${blockers.map((quest) => quest.title).join(", ")}.`
+              }
+            ] : void 0
+          }
+        );
+      }
+      case "log_effort": {
+        logQuestEffort(db, input.questId, input.effortSeconds, input.now);
+        const detail = getQuestDetail(db, input.questId);
+        return toolSuccess(
+          `Logged effort on quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            updated: [toQuestRef(detail)],
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail)]
+          }
+        );
+      }
+      case "finish": {
+        finishQuest(db, input.questId, input.outcome, input.resolvedAt);
+        const detail = getQuestDetail(db, input.questId);
+        return toolSuccess(
+          `Finished quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            updated: [toQuestRef(detail)],
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail)]
+          }
+        );
+      }
+      case "abandon": {
+        abandonQuest(db, input.questId, input.outcome, input.resolvedAt);
+        const detail = getQuestDetail(db, input.questId);
+        return toolSuccess(
+          `Abandoned quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            updated: [toQuestRef(detail)],
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail)]
+          }
+        );
+      }
+      case "abandon_and_spawn_followups": {
+        if (input.followups.length === 0) {
+          return toolFailure(
+            "protocol",
+            "invalid_input",
+            "Follow-up quests are required for this action.",
+            "Provide at least one follow-up quest, or use the plain abandon action instead.",
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        const result = abandonQuestAndSpawnFollowups(
+          db,
+          input.questId,
+          input.outcome,
+          input.followups,
+          input.resolvedAt
+        );
+        const detail = getQuestDetail(db, input.questId);
+        const followupQuests = result.followupQuests.map((quest) => getQuestDetail(db, quest.id));
+        return toolSuccess(
+          `Abandoned quest \`${detail.title}\` and created follow-up work.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            created: followupQuests.map(toQuestRef),
+            updated: [toQuestRef(detail)],
+            quest: detail,
+            followupQuests
+          },
+          {
+            entities: [toQuestRef(detail), ...followupQuests.map(toQuestRef)],
+            next: followupQuests.length === 1 && followupQuests[0] ? [inspectItemNext(toQuestRef(followupQuests[0]))] : void 0
+          }
+        );
+      }
+    }
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete run-quest action \`${input.action}\`.`
+    });
+  }
+}
+var runQuestTool = defineQuestlogTool({
+  name: runQuestToolName,
+  description: "Run quest lifecycle actions such as starting, logging effort, finishing, abandoning, or abandoning and spawning follow-up quests atomically.",
+  whenToUse: "Use this for actual execution lifecycle steps after the quest already exists.",
+  whenNotToUse: "Do not use this for work shaping, planning-only edits, tagging, or rewards.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["quest"],
+  inputDescriptions: {
+    action: "Which execution lifecycle step to perform on the quest.",
+    questId: "The concrete quest whose execution state should change.",
+    startedAt: "Optional actual start timestamp for the start action.",
+    force: "Start despite unmet unlock prerequisites. Defaults to false.",
+    effortSeconds: "Positive active-effort increment in seconds for the log-effort action.",
+    now: "Optional timestamp for the effort log action.",
+    outcome: "Terminal outcome text for finish or abandon actions.",
+    resolvedAt: "Optional terminal timestamp for finish or abandon actions.",
+    followups: "Follow-up quest creation inputs used only for the abandon-and-spawn-followups action."
+  },
+  outputDescription: "Returns the updated quest detail after the selected lifecycle action, plus purpose-shaped primary, updated, and created refs when follow-up work is spawned. Safe repeated starts return structured no-op results.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", [
+        "start",
+        "log_effort",
+        "finish",
+        "abandon",
+        "abandon_and_spawn_followups"
+      ]),
+      questId: integerSchema("Quest whose execution state should change."),
+      startedAt: integerSchema("Optional start timestamp for the start action."),
+      force: booleanSchema("Start despite unmet unlock prerequisites. Defaults to false."),
+      effortSeconds: integerSchema(
+        "Positive active-effort increment in seconds. Required for log_effort."
+      ),
+      now: integerSchema("Optional effort-log timestamp."),
+      outcome: stringSchema(
+        "Terminal outcome text. Required for finish, abandon, and abandon_and_spawn_followups."
+      ),
+      resolvedAt: integerSchema("Optional resolved timestamp for finish or abandon actions."),
+      followups: arraySchema(
+        objectSchema(
+          {
+            title: stringSchema("Title for a follow-up quest."),
+            objective: stringSchema("Objective for a follow-up quest.")
+          },
+          ["title", "objective"]
+        ),
+        "Follow-up quests to create atomically. Required for abandon_and_spawn_followups."
+      )
+    },
+    ["action", "questId"],
+    "Run quest lifecycle actions."
+  ),
+  handler: runQuestToolHandler
+});
+
+// src/search_questlog.ts
+function searchQuestlog(db, query) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const now = Date.now();
+  const questRows = db.prepare(
+    `SELECT q.id,
+              q.title,
+              snippet(quests_fts, 1, '[', ']', '\u2026', 10) AS snippet,
+              q.started_at,
+              q.resolved_at,
+              q.success,
+              q.not_before_at,
+              EXISTS(
+                SELECT 1
+                FROM quest_rewards qr
+                WHERE qr.quest_id = q.id
+                  AND qr.deleted_at IS NULL
+                  AND qr.claimed_at IS NULL
+              ) AS has_unclaimed_rewards,
+              EXISTS(
+                SELECT 1
+                FROM quest_unlocks qu
+                JOIN quests blocker ON blocker.id = qu.from_quest_id
+                WHERE qu.to_quest_id = q.id
+                  AND qu.deleted_at IS NULL
+                  AND blocker.deleted_at IS NULL
+                  AND NOT (blocker.resolved_at IS NOT NULL AND blocker.success = 1)
+              ) AS has_blockers
+       FROM quests_fts CROSS JOIN quests q ON q.id = quests_fts.rowid
+       WHERE quests_fts MATCH ? AND q.deleted_at IS NULL`
+  ).all(trimmed).map((row) => {
+    const state = deriveQuestState({
+      startedAt: row.started_at == null ? null : Number(row.started_at),
+      resolvedAt: row.resolved_at == null ? null : Number(row.resolved_at),
+      success: row.success == null ? null : Number(row.success) === 1
+    });
+    const notBeforeAt = row.not_before_at == null ? null : Number(row.not_before_at);
+    const blockerCount = Number(row.has_blockers ?? 0);
+    const available = state === "open" && (notBeforeAt == null || notBeforeAt <= now) && blockerCount === 0;
+    return {
+      entityKind: "quest",
+      entityId: Number(row.id),
+      title: String(row.title),
+      snippet: String(row.snippet),
+      markerId: deriveQuestMarkerId({
+        state,
+        available,
+        hasUnclaimedReward: Number(row.has_unclaimed_rewards ?? 0) === 1,
+        notBeforeAt,
+        blockerCount,
+        now
+      })
+    };
+  });
+  const rumorRows = db.prepare(
+    `SELECT r.id,
+              r.title,
+              snippet(rumors_fts, 1, '[', ']', '\u2026', 10) AS snippet,
+              r.settled_at,
+              r.dismissed_at
+       FROM rumors_fts CROSS JOIN rumors r ON r.id = rumors_fts.rowid
+       WHERE rumors_fts MATCH ? AND r.deleted_at IS NULL`
+  ).all(trimmed).map((row) => ({
+    entityKind: "rumor",
+    entityId: Number(row.id),
+    title: String(row.title),
+    snippet: String(row.snippet),
+    markerId: deriveRumorMarkerId({
+      state: deriveRumorState({
+        settledAt: row.settled_at == null ? null : Number(row.settled_at),
+        dismissedAt: row.dismissed_at == null ? null : Number(row.dismissed_at)
+      })
+    })
+  }));
+  return [...questRows, ...rumorRows];
+}
+
+// src/tools/search_questlog_tool.ts
+function searchQuestlogToolHandler(db, input) {
+  const query = input.query.trim();
+  if (!query) {
+    return toolFailure(
+      "protocol",
+      "invalid_input",
+      "Search query is required.",
+      "Provide a non-empty search query."
+    );
+  }
+  if (input.limit != null && input.limit < 1) {
+    return toolFailure(
+      "protocol",
+      "invalid_input",
+      "Search limit must be at least 1.",
+      "Provide a positive limit when you want to cap returned matches."
+    );
+  }
+  const allHits = searchQuestlog(db, query);
+  const filteredHits = input.kinds && input.kinds.length > 0 ? allHits.filter((hit) => input.kinds?.includes(hit.entityKind)) : allHits;
+  const limitedHits = input.limit && input.limit > 0 ? filteredHits.slice(0, input.limit) : filteredHits;
+  const items = limitedHits.map(toSearchListItem);
+  const mode = input.mode ?? "browse";
+  if (mode === "identify_one" && filteredHits.length > 1) {
+    return toolNeedsClarification(
+      "ambiguous_target",
+      `More than one item matches \`${query}\`. Which one did you mean?`,
+      ["query"],
+      {
+        entities: items.slice(0, 5).map((item) => ({
+          kind: item.kind,
+          id: item.id,
+          title: item.title,
+          markerId: item.markerId,
+          state: item.state
+        })),
+        options: items.slice(0, 5).map((item) => ({
+          label: `${item.kind}: ${item.title ?? item.id}`,
+          value: item.id
+        }))
+      }
+    );
+  }
+  const data = {
+    items,
+    returnedCount: items.length,
+    totalCount: filteredHits.length,
+    mode
+  };
+  if (input.kinds && input.kinds.length > 0) {
+    data.appliedKinds = input.kinds;
+  }
+  return toolSuccess(
+    items.length === 0 ? "No matching questlog items were found." : summarizeCount(items.length, "match"),
+    data,
+    {
+      entities: items.map((item) => ({
+        kind: item.kind,
+        id: item.id,
+        title: item.title,
+        markerId: item.markerId,
+        state: item.state
+      })),
+      next: items.length === 1 && items[0] ? [
+        inspectItemNext({
+          kind: items[0].kind,
+          id: items[0].id,
+          title: items[0].title,
+          markerId: items[0].markerId,
+          state: items[0].state
+        })
+      ] : void 0,
+      warnings: items.length === 0 ? [toolWarning("empty_result", "No items matched the search query.")] : void 0
+    }
+  );
+}
+var searchQuestlogTool = defineQuestlogTool({
+  name: searchQuestlogToolName,
+  description: "Search quests and rumors by text when you need to find an existing item before inspecting or changing it.",
+  whenToUse: "Use this first when the exact quest, rumor, or id is not already known.",
+  whenNotToUse: "Do not use this when you already know the exact item id and want its full detail.",
+  sideEffects: "none",
+  readOnly: true,
+  supportsClarification: true,
+  targetKinds: ["quest", "rumor"],
+  inputDescriptions: {
+    query: "Text to search for in rumor and quest titles and body text.",
+    limit: "Maximum number of matches to return. Leave unset to return all matches.",
+    kinds: "Optional entity kinds to restrict the search to quests, rumors, or both.",
+    mode: "Use `browse` to return matches normally, or `identify_one` to ask for clarification when several matches are plausible."
+  },
+  outputDescription: "Returns compact matching items with ids, titles, snippets, and markers, plus returned and total counts. In identify-one mode, the tool can return structured clarification instead of guessing.",
+  inputSchema: objectSchema(
+    {
+      query: stringSchema("Text to search for in rumor and quest titles and body text."),
+      limit: integerSchema("Maximum number of matches to return."),
+      kinds: arraySchema(
+        enumSchema("Optional kinds to restrict the search to.", ["quest", "rumor"]),
+        "Optional entity kinds to search."
+      ),
+      mode: enumSchema(
+        "Whether to browse results normally or ask for clarification when several matches are found.",
+        ["browse", "identify_one"]
+      )
+    },
+    ["query"],
+    "Search quests and rumors by text."
+  ),
+  handler: searchQuestlogToolHandler
+});
+
+// src/rumors/dismiss_rumor.ts
+function dismissRumor(db, rumorId, dismissedAt) {
+  const now = resolveNow(dismissedAt);
+  assertActiveRowExists(db, "rumors", rumorId, "Rumor");
+  db.prepare(
+    `UPDATE rumors
+     SET dismissed_at = ?, settled_at = NULL, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(now, now, rumorId);
+  return getRumorOrThrow(db, rumorId);
+}
+
+// src/rumors/reopen_rumor.ts
+function reopenRumor(db, rumorId, now) {
+  assertActiveRowExists(db, "rumors", rumorId, "Rumor");
+  const effectiveNow = resolveNow(now);
+  db.prepare(
+    `UPDATE rumors
+     SET settled_at = NULL, dismissed_at = NULL, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(effectiveNow, rumorId);
+  return getRumorOrThrow(db, rumorId);
+}
+
+// src/rumors/settle_rumor.ts
+function settleRumor(db, rumorId, input) {
+  return withTransaction(db, () => {
+    const rumor = getRumorOrThrow(db, rumorId);
+    const settledAt = input.settledAt ?? Date.now();
+    let questline = null;
+    if (input.questline) {
+      questline = createQuestline(db, {
+        ...input.questline,
+        sourceRumorId: rumor.id,
+        now: settledAt
+      });
+    }
+    const quests = (input.quests ?? []).map(
+      (quest) => createQuest(db, {
+        ...quest,
+        sourceRumorId: rumor.id,
+        questlineId: quest.questlineId ?? questline?.id ?? null,
+        now: settledAt
+      })
+    );
+    db.prepare(
+      `UPDATE rumors
+       SET settled_at = ?, updated_at = ?
+       WHERE id = ? AND deleted_at IS NULL`
+    ).run(settledAt, settledAt, rumorId);
+    return {
+      rumor: getRumorOrThrow(db, rumorId),
+      questline,
+      quests
+    };
+  });
+}
+
+// src/rumors/update_rumor.ts
+function updateRumor(db, rumorId, input) {
+  if (input.title == null && input.details == null) {
+    throw new Error("At least one of title or details must be provided to update a rumor.");
+  }
+  const current = getRumorOrThrow(db, rumorId);
+  if (current.settledAt != null) {
+    throw new Error(`Rumor ${rumorId} is already settled and cannot be updated.`);
+  }
+  if (current.dismissedAt != null) {
+    throw new Error(`Rumor ${rumorId} is dismissed and cannot be updated. Reopen it first.`);
+  }
+  const now = resolveNow(input.now);
+  const nextTitle = input.title != null ? assertNonEmpty(input.title, "Rumor title") : current.title;
+  const nextDetails = input.details != null ? input.details.trim() || null : current.details;
+  db.prepare(
+    `UPDATE rumors
+     SET title = ?, details = ?, updated_at = ?
+     WHERE id = ? AND deleted_at IS NULL`
+  ).run(nextTitle, nextDetails, now, rumorId);
+  return getRumorOrThrow(db, rumorId);
+}
+
+// src/tools/shape_work_tool.ts
+function shapeWorkToolHandler(db, input) {
+  try {
+    switch (input.action) {
+      case "dismiss_rumor": {
+        const current = getRumorDetail(db, input.rumorId);
+        if (current.state === "dismissed") {
+          return toolNoOp(
+            `Rumor \`${current.title}\` is already dismissed.`,
+            {
+              action: input.action,
+              primary: toRumorRef(current),
+              rumor: current
+            },
+            {
+              entities: [toRumorRef(current)]
+            }
+          );
+        }
+        const rumor = dismissRumor(db, input.rumorId, input.dismissedAt);
+        return toolSuccess(
+          `Dismissed rumor \`${rumor.title}\`.`,
+          {
+            action: input.action,
+            primary: toRumorRef(rumor),
+            updated: [toRumorRef(rumor)],
+            rumor: getRumorDetail(db, rumor.id)
+          },
+          {
+            entities: [toRumorRef(rumor)]
+          }
+        );
+      }
+      case "reopen_rumor": {
+        const current = getRumorDetail(db, input.rumorId);
+        if (current.state === "open") {
+          return toolNoOp(
+            `Rumor \`${current.title}\` is already open.`,
+            {
+              action: input.action,
+              primary: toRumorRef(current),
+              rumor: current
+            },
+            {
+              entities: [toRumorRef(current)]
+            }
+          );
+        }
+        const rumor = reopenRumor(db, input.rumorId, input.now);
+        const detail = getRumorDetail(db, rumor.id);
+        return toolSuccess(
+          `Reopened rumor \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toRumorRef(detail),
+            updated: [toRumorRef(detail)],
+            rumor: detail
+          },
+          {
+            entities: [toRumorRef(detail)],
+            next: [inspectItemNext(toRumorRef(detail))]
+          }
+        );
+      }
+      case "settle_rumor": {
+        if (!input.questline && (!input.quests || input.quests.length === 0)) {
+          return toolNeedsClarification(
+            "missing_required_choice",
+            "How should this rumor be settled into real work?",
+            ["questline", "quests"]
+          );
+        }
+        const settleInput = {};
+        if (input.questline) {
+          settleInput.questline = input.questline;
+        }
+        if (input.quests) {
+          settleInput.quests = input.quests;
+        }
+        if (input.settledAt != null) {
+          settleInput.settledAt = input.settledAt;
+        }
+        const settled = settleRumor(db, input.rumorId, settleInput);
+        const rumorDetail = getRumorDetail(db, settled.rumor.id);
+        const createdQuestline = settled.questline == null ? void 0 : getQuestlineDetail(db, settled.questline.id);
+        const createdQuests = settled.quests.map((quest) => getQuestDetail(db, quest.id));
+        return toolSuccess(
+          `Settled rumor \`${rumorDetail.title}\`.`,
+          {
+            action: input.action,
+            primary: toRumorRef(rumorDetail),
+            created: [
+              ...createdQuestline ? [toQuestlineRef(createdQuestline)] : [],
+              ...createdQuests.map(toQuestRef)
+            ],
+            updated: [toRumorRef(rumorDetail)],
+            rumor: rumorDetail,
+            questline: createdQuestline,
+            quests: createdQuests
+          },
+          {
+            entities: [
+              toRumorRef(rumorDetail),
+              ...createdQuestline ? [toQuestlineRef(createdQuestline)] : [],
+              ...createdQuests.map(toQuestRef)
+            ],
+            next: [reviewViewNext("quests.available")]
+          }
+        );
+      }
+      case "create_quest": {
+        const quest = createQuest(db, input.quest);
+        const detail = getQuestDetail(db, quest.id);
+        return toolSuccess(
+          `Created quest \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            created: [toQuestRef(detail)],
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail)],
+            next: [inspectItemNext(toQuestRef(detail))]
+          }
+        );
+      }
+      case "create_questline": {
+        const questline = createQuestline(db, input.questline);
+        const detail = getQuestlineDetail(db, questline.id);
+        return toolSuccess(
+          `Created questline \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toQuestlineRef(detail),
+            created: [toQuestlineRef(detail)],
+            questline: detail
+          },
+          {
+            entities: [toQuestlineRef(detail)]
+          }
+        );
+      }
+      case "attach_quest_to_questline": {
+        const current = getQuestDetail(db, input.questId);
+        if (current.questlineId === input.questlineId) {
+          return toolNoOp(
+            `Quest \`${current.title}\` is already in that questline.`,
+            {
+              action: input.action,
+              primary: toQuestRef(current),
+              quest: current
+            },
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        moveQuestToQuestline(db, input.questId, input.questlineId, input.now);
+        const detail = getQuestDetail(db, input.questId);
+        return toolSuccess(
+          `Attached quest \`${detail.title}\` to questline ${input.questlineId}.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            updated: [
+              toQuestRef(detail),
+              toQuestlineRef(getQuestlineDetail(db, input.questlineId))
+            ],
+            quest: detail,
+            questline: getQuestlineDetail(db, input.questlineId)
+          },
+          {
+            entities: [toQuestRef(detail), { kind: "questline", id: input.questlineId }]
+          }
+        );
+      }
+      case "detach_quest_from_questline": {
+        const current = getQuestDetail(db, input.questId);
+        if (current.questlineId == null) {
+          return toolNoOp(
+            `Quest \`${current.title}\` is not attached to a questline.`,
+            {
+              action: input.action,
+              primary: toQuestRef(current),
+              quest: current
+            },
+            {
+              entities: [toQuestRef(current)]
+            }
+          );
+        }
+        detachQuestFromQuestline(db, input.questId, input.now);
+        const detail = getQuestDetail(db, input.questId);
+        return toolSuccess(
+          `Detached quest \`${detail.title}\` from its questline.`,
+          {
+            action: input.action,
+            primary: toQuestRef(detail),
+            updated: [toQuestRef(detail)],
+            quest: detail
+          },
+          {
+            entities: [toQuestRef(detail)]
+          }
+        );
+      }
+      case "update_rumor": {
+        updateRumor(db, input.rumorId, {
+          ...input.title != null && { title: input.title },
+          ...input.details != null && { details: input.details },
+          ...input.now != null && { now: input.now }
+        });
+        const detail = getRumorDetail(db, input.rumorId);
+        return toolSuccess(
+          `Updated rumor \`${detail.title}\`.`,
+          {
+            action: input.action,
+            primary: toRumorRef(detail),
+            updated: [toRumorRef(detail)],
+            rumor: detail
+          },
+          {
+            entities: [toRumorRef(detail)],
+            next: [inspectItemNext(toRumorRef(detail))]
+          }
+        );
+      }
+    }
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete shape-work action \`${input.action}\`.`
+    });
+  }
+}
+var shapeWorkTool = defineQuestlogTool({
+  name: shapeWorkToolName,
+  description: "Create a quest (with timing, tags, and objective in one call), create a questline, settle a rumor into concrete work, or manage quest-questline membership. Use create_quest for clear commitments \u2014 include tags and timing directly to avoid follow-up calls.",
+  whenToUse: "Use this when deciding what real work exists and how it should be grouped before or around execution. Prefer a single create_quest call with all fields over separate create + plan_quest + tag_work calls.",
+  whenNotToUse: "Do not use this for quest execution steps like starting, finishing, abandoning, or logging effort.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: true,
+  targetKinds: ["quest", "questline", "rumor"],
+  inputDescriptions: {
+    action: "Which structure-shaping action to perform, such as settling a rumor, creating a quest, or attaching a quest to a questline.",
+    rumorId: "The rumor to dismiss, reopen, or settle when the action targets intake.",
+    questline: "Questline creation data used when creating a questline directly or as part of rumor settlement. Include description for context.",
+    quests: "Concrete quest creation inputs when settling a rumor into real work. Each quest supports the same fields as the quest property \u2014 include timing and tags directly.",
+    settledAt: "Optional settlement timestamp for rumor settlement.",
+    quest: "Quest creation input when directly creating one concrete quest. Include timing fields (dueAt, scheduledStartAt, etc.), tags, and rewards to create a fully specified quest in one call.",
+    questId: "The concrete quest being attached to or detached from a questline.",
+    questlineId: "The questline that should receive the quest for attach actions.",
+    dismissedAt: "Optional dismissal timestamp for dismissing a rumor.",
+    now: "Optional timestamp for reopen, questline membership, or rumor update.",
+    title: "New title for the update_rumor action.",
+    details: "New or enriched context for the update_rumor action. Append evidence as rumors accumulate information across conversations."
+  },
+  outputDescription: "Returns the changed or created rumor, quest, questline, or created quest set for the selected shape-work action, plus purpose-shaped primary and created or updated refs. Repeated safe actions return structured no-op results, and rumor settlement can ask for missing structure instead of failing.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", [
+        "attach_quest_to_questline",
+        "create_quest",
+        "create_questline",
+        "detach_quest_from_questline",
+        "dismiss_rumor",
+        "reopen_rumor",
+        "settle_rumor",
+        "update_rumor"
+      ]),
+      questId: integerSchema("Quest to attach or detach."),
+      questlineId: integerSchema("Questline that should receive the quest."),
+      quest: objectSchema(
+        {
+          title: stringSchema("Title for the new quest."),
+          objective: stringSchema("Objective for the new quest."),
+          questlineId: integerSchema("Optional questline to place the quest in."),
+          tags: arraySchema(stringSchema("Tag name."), "Optional tags to apply at creation."),
+          rewards: arraySchema(
+            objectSchema(
+              {
+                kind: stringSchema("Reward kind."),
+                name: stringSchema("Reward name.")
+              },
+              ["kind", "name"]
+            ),
+            "Optional rewards to attach at creation."
+          ),
+          dueAt: integerSchema("Optional latest acceptable completion timestamp."),
+          notBeforeAt: integerSchema("Optional earliest actionable timestamp."),
+          scheduledStartAt: integerSchema("Optional planned schedule window start."),
+          scheduledEndAt: integerSchema("Optional planned schedule window end."),
+          allDay: booleanSchema("Whether the scheduled window is all-day."),
+          estimateSeconds: integerSchema("Optional active-effort estimate in seconds.")
+        },
+        ["title", "objective"]
+      ),
+      questline: objectSchema(
+        {
+          title: stringSchema("Questline title."),
+          description: stringSchema("Optional questline description.")
+        },
+        []
+      ),
+      rumorId: integerSchema("Rumor to settle, dismiss, or reopen."),
+      dismissedAt: integerSchema("Optional dismissal timestamp."),
+      settledAt: integerSchema("Optional settlement timestamp."),
+      quests: arraySchema(
+        objectSchema(
+          {
+            title: stringSchema("Title for a created quest."),
+            objective: stringSchema("Objective for a created quest."),
+            tags: arraySchema(stringSchema("Tag name."), "Optional tags to apply at creation."),
+            rewards: arraySchema(
+              objectSchema(
+                {
+                  kind: stringSchema("Reward kind."),
+                  name: stringSchema("Reward name.")
+                },
+                ["kind", "name"]
+              ),
+              "Optional rewards to attach at creation."
+            ),
+            dueAt: integerSchema("Optional latest acceptable completion timestamp."),
+            notBeforeAt: integerSchema("Optional earliest actionable timestamp."),
+            scheduledStartAt: integerSchema("Optional planned schedule window start."),
+            scheduledEndAt: integerSchema("Optional planned schedule window end."),
+            allDay: booleanSchema("Whether the scheduled window is all-day."),
+            estimateSeconds: integerSchema("Optional active-effort estimate in seconds.")
+          },
+          ["title", "objective"]
+        ),
+        "Quests to create during rumor settlement. Include timing and tags directly."
+      ),
+      now: integerSchema("Optional timestamp for membership, reopen, or rumor update."),
+      title: stringSchema("New title for the update_rumor action."),
+      details: stringSchema("New or enriched context text for the update_rumor action.")
+    },
+    ["action"],
+    "Create quests with timing and tags, create questlines, settle rumors into work, manage quest-questline membership, or enrich open rumors with new context."
+  ),
+  handler: shapeWorkToolHandler
+});
+
+// src/tags/replace_quest_tags.ts
+function replaceQuestTags(db, questId, tagNames, now) {
+  assertActiveRowExists(db, "quests", questId, "Quest");
+  replaceActiveQuestTags(db, questId, tagNames, now);
+  db.prepare("UPDATE quests SET updated_at = ? WHERE id = ?").run(resolveNow(now), questId);
+}
+
+// src/tags/replace_repeatable_quest_tags.ts
+function replaceRepeatableQuestTags(db, repeatableQuestId, tagNames, now) {
+  assertActiveRowExists(db, "repeatable_quests", repeatableQuestId, "Repeatable quest");
+  replaceActiveRepeatableQuestTags(db, repeatableQuestId, tagNames, now);
+  db.prepare("UPDATE repeatable_quests SET updated_at = ? WHERE id = ?").run(
+    resolveNow(now),
+    repeatableQuestId
+  );
+}
+
+// src/tags/tag_quest.ts
+function tagQuest(db, questId, tagNames, now) {
+  assertActiveRowExists(db, "quests", questId, "Quest");
+  const current = db.prepare(
+    `SELECT t.name
+       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`
+  ).all(questId).map((row) => String(row.name));
+  replaceActiveQuestTags(db, questId, [...current, ...tagNames], now);
+  db.prepare("UPDATE quests SET updated_at = ? WHERE id = ?").run(resolveNow(now), questId);
+}
+
+// src/tags/untag_quest.ts
+function untagQuest(db, questId, tagNames, now) {
+  assertActiveRowExists(db, "quests", questId, "Quest");
+  const removeSet = new Set(tagNames.map((tag) => tag.trim().toLowerCase()));
+  const current = db.prepare(
+    `SELECT t.name
+       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`
+  ).all(questId).map((row) => String(row.name)).filter((name) => !removeSet.has(name.trim().toLowerCase()));
+  replaceActiveQuestTags(db, questId, current, now);
+  db.prepare("UPDATE quests SET updated_at = ? WHERE id = ?").run(resolveNow(now), questId);
+}
+
+// src/tools/tag_work_tool.ts
+function normalizeTagNames(tagNames) {
+  return [...new Set(tagNames.map((tag) => tag.trim()).filter(Boolean))];
+}
+function readQuestTagNames(db, questId) {
+  return db.prepare(
+    `SELECT t.name
+       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
+       ORDER BY t.name ASC`
+  ).all(questId).map((row) => String(row.name));
+}
+function readRepeatableTagNames(db, repeatableQuestId) {
+  return db.prepare(
+    `SELECT t.name
+       FROM repeatable_quest_tags rqt
+       JOIN tags t ON t.id = rqt.tag_id
+       WHERE rqt.repeatable_quest_id = ? AND rqt.deleted_at IS NULL AND t.deleted_at IS NULL
+       ORDER BY t.name ASC`
+  ).all(repeatableQuestId).map((row) => String(row.name));
+}
+function tagWorkToolHandler(db, input) {
+  try {
+    const normalized = normalizeTagNames(input.tagNames);
+    if (input.target.kind === "quest") {
+      assertActiveRowExists(db, "quests", input.target.id, "Quest");
+      const current2 = readQuestTagNames(db, input.target.id);
+      const currentSet2 = new Set(current2.map((name) => name.trim().toLowerCase()));
+      const normalizedSet2 = new Set(normalized.map((name) => name.trim().toLowerCase()));
+      if (input.action === "add") {
+        if (normalized.every((name) => currentSet2.has(name.trim().toLowerCase()))) {
+          return toolNoOp(
+            "Those tags are already present on the quest.",
+            {
+              action: input.action,
+              target: input.target,
+              tagNames: current2
+            },
+            {
+              entities: [{ kind: "quest", id: input.target.id }]
+            }
+          );
+        }
+        tagQuest(db, input.target.id, normalized, input.now);
+      } else if (input.action === "remove") {
+        if (normalized.every((name) => !currentSet2.has(name.trim().toLowerCase()))) {
+          return toolNoOp(
+            "None of those tags are present on the quest.",
+            {
+              action: input.action,
+              target: input.target,
+              tagNames: current2
+            },
+            {
+              entities: [{ kind: "quest", id: input.target.id }]
+            }
+          );
+        }
+        untagQuest(db, input.target.id, normalized, input.now);
+      } else {
+        const same2 = currentSet2.size === normalizedSet2.size && [...currentSet2].every((value) => normalizedSet2.has(value));
+        if (same2) {
+          return toolNoOp(
+            "The quest already has exactly that tag set.",
+            {
+              action: input.action,
+              target: input.target,
+              tagNames: current2
+            },
+            {
+              entities: [{ kind: "quest", id: input.target.id }]
+            }
+          );
+        }
+        replaceQuestTags(db, input.target.id, normalized, input.now);
+      }
+      return toolSuccess(
+        "Updated quest tags.",
+        {
+          action: input.action,
+          target: input.target,
+          tagNames: readQuestTagNames(db, input.target.id)
+        },
+        {
+          entities: [{ kind: "quest", id: input.target.id }]
+        }
+      );
+    }
+    if (input.action !== "replace") {
+      return toolFailure(
+        "protocol",
+        "unsupported_target",
+        "Repeatable quest tags only support replacement.",
+        "Use the replace action when changing the future auto-tag template set for a repeatable quest.",
+        {
+          entities: [{ kind: "repeatable_quest", id: input.target.id }]
+        }
+      );
+    }
+    assertActiveRowExists(db, "repeatable_quests", input.target.id, "Repeatable quest");
+    const current = readRepeatableTagNames(db, input.target.id);
+    const currentSet = new Set(current.map((name) => name.trim().toLowerCase()));
+    const normalizedSet = new Set(normalized.map((name) => name.trim().toLowerCase()));
+    const same = currentSet.size === normalizedSet.size && [...currentSet].every((value) => normalizedSet.has(value));
+    if (same) {
+      return toolNoOp(
+        "The repeatable quest already has exactly that future tag template set.",
+        {
+          action: input.action,
+          target: input.target,
+          tagNames: current
+        },
+        {
+          entities: [{ kind: "repeatable_quest", id: input.target.id }]
+        }
+      );
+    }
+    replaceRepeatableQuestTags(db, input.target.id, normalized, input.now);
+    return toolSuccess(
+      "Updated repeatable quest future tags.",
+      {
+        action: input.action,
+        target: input.target,
+        tagNames: readRepeatableTagNames(db, input.target.id)
+      },
+      {
+        entities: [{ kind: "repeatable_quest", id: input.target.id }]
+      }
+    );
+  } catch (error) {
+    return translateToolError(error, {
+      summary: `Could not complete tag-work action \`${input.action}\`.`
+    });
+  }
+}
+var tagWorkTool = defineQuestlogTool({
+  name: tagWorkToolName,
+  description: "Classify work by adding, removing, or replacing tags on quests and by replacing the future tag template set on repeatable quests.",
+  whenToUse: "Use this when you want classification, reporting, or saved-filter semantics rather than lifecycle or dependency semantics.",
+  whenNotToUse: "Do not use tags to model status, time planning, or hard prerequisites.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["quest", "repeatable_quest"],
+  inputDescriptions: {
+    action: "Whether to add, remove, or replace tags on the chosen target.",
+    target: "The quest or repeatable quest whose tag set should change.",
+    tagNames: "The tag names to add, remove, or make the full replacement set.",
+    now: "Optional timestamp for the tag mutation."
+  },
+  outputDescription: "Returns the normalized final tag set for the target after the selected tag action. Repeated equivalent changes return structured no-op results.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action to perform.", ["add", "remove", "replace"]),
+      target: objectSchema(
+        {
+          id: integerSchema("Target entity id."),
+          kind: enumSchema("Target kind.", ["quest", "repeatable_quest"])
+        },
+        ["id", "kind"]
+      ),
+      tagNames: arraySchema(stringSchema("Tag name."), "Tag names to add, remove, or replace."),
+      now: integerSchema("Optional timestamp for the tag mutation.")
+    },
+    ["action", "target", "tagNames"],
+    "Mutate tags on quests or repeatable quests."
+  ),
+  handler: tagWorkToolHandler
+});
+
+// src/tools/tool_registry.ts
+var questlogTools = [
+  searchQuestlogTool,
+  reviewQuestlogTool,
+  inspectQuestlogItemTool,
+  captureRumorTool,
+  shapeWorkTool,
+  planQuestTool,
+  runQuestTool,
+  organizeWorkTool,
+  manageRepeatableTool,
+  tagWorkTool,
+  rewardWorkTool,
+  retireWorkTool
+];
+
+// src/surface/questlog_surface_tools.ts
+var questlogSurfaceTools = questlogTools.map(
+  (tool) => ({
+    name: tool.name,
+    description: tool.description,
+    whenToUse: tool.whenToUse,
+    whenNotToUse: tool.whenNotToUse ?? "",
+    readOnly: tool.readOnly,
+    sideEffects: tool.sideEffects,
+    inputSchema: { ...tool.inputSchema, type: "object" },
+    handler: tool.handler
+  })
+);
+
+export { getQuestDetail, questlogSurfaceTools, reviewQuestlogTool };