@ghostpaw/questlog 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1688 @@
+import { DatabaseSync } from 'node:sqlite';
+
+/**
+ * SQLite dependency injected into every questlog operation.
+ */
+type QuestlogDb = DatabaseSync;
+
+/**
+ * Creates the full standalone questlog schema, including FTS and indexing.
+ */
+declare function initQuestlogTables(db: QuestlogDb): void;
+
+/**
+ * The lifecycle state derived from a quest's timestamps and success value.
+ */
+type QuestState = 'open' | 'in_progress' | 'done' | 'abandoned';
+
+type MarkerId = 'attention.available' | 'attention.available.repeatable' | 'attention.available.future' | 'progress.incomplete' | 'progress.complete';
+interface MarkerDefinition {
+    id: MarkerId;
+    family: 'attention' | 'progress';
+    symbol: '!' | '?';
+    wowColor: 'yellow' | 'blue' | 'gray';
+    label: string;
+    plainText: string;
+    ttyText: string;
+    htmlClass: string;
+}
+
+interface DeriveQuestMarkerIdInput {
+    state: QuestState;
+    available: boolean;
+    hasUnclaimedReward: boolean;
+    notBeforeAt: number | null;
+    blockerCount: number;
+    now: number;
+}
+declare function deriveQuestMarkerId({ state, available, hasUnclaimedReward, notBeforeAt, blockerCount, now, }: DeriveQuestMarkerIdInput): MarkerId | null;
+
+/**
+ * A higher-level semantic arc that groups related quests and may provide a shared deadline.
+ */
+interface Questline {
+    id: number;
+    sourceRumorId: number | null;
+    title: string;
+    description: string | null;
+    startsAt: number | null;
+    dueAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+    archivedAt: number | null;
+    deletedAt: number | null;
+}
+/**
+ * Input for creating a new questline.
+ */
+interface CreateQuestlineInput {
+    title: string;
+    description?: string | null;
+    startsAt?: number | null;
+    dueAt?: number | null;
+    sourceRumorId?: number | null;
+    now?: number;
+}
+/**
+ * Input for updating mutable questline fields.
+ */
+interface UpdateQuestlineInput {
+    title?: string;
+    description?: string | null;
+    startsAt?: number | null;
+    dueAt?: number | null;
+    archivedAt?: number | null;
+    now?: number;
+}
+/**
+ * A questline plus computed progress counts.
+ */
+interface QuestlineDetail extends Questline {
+    totalQuests: number;
+    openQuests: number;
+    inProgressQuests: number;
+    doneQuests: number;
+    abandonedQuests: number;
+    availableQuests: number;
+    overdueQuests: number;
+}
+
+/**
+ * A generic reward attached to a concrete quest.
+ */
+interface QuestReward {
+    id: number;
+    questId: number;
+    kind: string;
+    name: string;
+    description: string | null;
+    quantity: number | null;
+    createdAt: number;
+    claimedAt: number | null;
+    deletedAt: number | null;
+}
+/**
+ * A reward template attached to a repeatable quest and copied into spawned quests.
+ */
+interface RepeatableQuestReward {
+    id: number;
+    repeatableQuestId: number;
+    kind: string;
+    name: string;
+    description: string | null;
+    quantity: number | null;
+    createdAt: number;
+    deletedAt: number | null;
+}
+/**
+ * Input for attaching a reward to a concrete quest.
+ */
+interface QuestRewardInput {
+    kind: string;
+    name: string;
+    description?: string | null;
+    quantity?: number | null;
+    now?: number;
+}
+/**
+ * Input for attaching a reward template to a repeatable quest.
+ */
+interface RepeatableQuestRewardInput {
+    kind: string;
+    name: string;
+    description?: string | null;
+    quantity?: number | null;
+    now?: number;
+}
+
+/**
+ * One real commitment with one objective and one terminal outcome.
+ */
+interface Quest {
+    id: number;
+    questlineId: number | null;
+    sourceRumorId: number | null;
+    spawnedByQuestId: number | null;
+    spawnedFromRepeatableId: number | null;
+    spawnedForAt: number | null;
+    title: string;
+    objective: string;
+    outcome: string | null;
+    createdAt: number;
+    updatedAt: number;
+    startedAt: number | null;
+    resolvedAt: number | null;
+    success: boolean | null;
+    effortSeconds: number;
+    estimateSeconds: number | null;
+    notBeforeAt: number | null;
+    dueAt: number | null;
+    scheduledStartAt: number | null;
+    scheduledEndAt: number | null;
+    allDay: boolean;
+    deletedAt: number | null;
+}
+/**
+ * Input for creating a concrete quest.
+ */
+interface CreateQuestInput {
+    title: string;
+    objective: string;
+    questlineId?: number | null;
+    sourceRumorId?: number | null;
+    spawnedByQuestId?: number | null;
+    spawnedFromRepeatableId?: number | null;
+    spawnedForAt?: number | null;
+    estimateSeconds?: number | null;
+    notBeforeAt?: number | null;
+    dueAt?: number | null;
+    scheduledStartAt?: number | null;
+    scheduledEndAt?: number | null;
+    allDay?: boolean;
+    tags?: string[];
+    rewards?: QuestRewardInput[];
+    now?: number;
+}
+/**
+ * Intent-shaped quest temporal planning input.
+ */
+interface PlanQuestTimeInput {
+    notBeforeAt?: number | null;
+    dueAt?: number | null;
+    scheduledStartAt?: number | null;
+    scheduledEndAt?: number | null;
+    allDay?: boolean;
+    estimateSeconds?: number | null;
+    now?: number;
+}
+/**
+ * A follow-up quest to create atomically while abandoning an existing quest.
+ */
+interface FollowupQuestInput extends Omit<CreateQuestInput, 'sourceRumorId' | 'spawnedByQuestId'> {
+    unlocksParent?: boolean;
+}
+/**
+ * Summary returned when abandoning a quest and atomically creating follow-up work.
+ */
+interface AbandonQuestResult {
+    abandonedQuest: Quest;
+    followupQuests: Quest[];
+}
+/**
+ * Shared quest list filters.
+ */
+interface QuestListFilters {
+    questlineId?: number;
+    tagNames?: string[];
+    includeDeleted?: boolean;
+}
+/**
+ * A concrete quest with derived state and expanded relationships for reads.
+ */
+interface QuestDetail extends Quest {
+    state: QuestState;
+    markerId: MarkerId | null;
+    effectiveDueAt: number | null;
+    available: boolean;
+    tagNames: string[];
+    rewards: QuestReward[];
+    unlocksQuestIds: number[];
+    unlockedByQuestIds: number[];
+}
+
+/**
+ * A non-committed intake item that may later yield quests, a questline, both, or nothing.
+ */
+interface Rumor {
+    id: number;
+    title: string;
+    details: string | null;
+    markerId: MarkerId | null;
+    createdAt: number;
+    updatedAt: number;
+    settledAt: number | null;
+    dismissedAt: number | null;
+    deletedAt: number | null;
+}
+/**
+ * The lifecycle state derived from a rumor's timestamps.
+ */
+type RumorState = 'open' | 'settled' | 'dismissed';
+/**
+ * Input for capturing a new rumor.
+ */
+interface CaptureRumorInput {
+    title: string;
+    details?: string | null;
+    now?: number;
+}
+/**
+ * A downstream artifact created from rumor settlement.
+ */
+interface RumorOutput {
+    entityKind: 'quest' | 'questline';
+    entityId: number;
+}
+/**
+ * A rumor with derived state and downstream outputs.
+ */
+interface RumorDetail extends Rumor {
+    state: RumorState;
+    outputs: RumorOutput[];
+}
+/**
+ * Structured rumor settlement plan.
+ */
+interface SettleRumorInput {
+    questline?: CreateQuestlineInput;
+    quests?: CreateQuestInput[];
+    settledAt?: number;
+}
+/**
+ * Result returned after settling a rumor into downstream artifacts.
+ */
+interface SettleRumorResult {
+    rumor: Rumor;
+    questline: Questline | null;
+    quests: Quest[];
+}
+
+interface DeriveRumorMarkerIdInput {
+    state: RumorState;
+}
+declare function deriveRumorMarkerId({ state }: DeriveRumorMarkerIdInput): MarkerId | null;
+
+declare const markerLookup: {
+    'attention.available': {
+        id: "attention.available";
+        family: "attention";
+        symbol: "!";
+        wowColor: "yellow";
+        label: string;
+        plainText: string;
+        ttyText: string;
+        htmlClass: string;
+    };
+    'attention.available.repeatable': {
+        id: "attention.available.repeatable";
+        family: "attention";
+        symbol: "!";
+        wowColor: "blue";
+        label: string;
+        plainText: string;
+        ttyText: string;
+        htmlClass: string;
+    };
+    'attention.available.future': {
+        id: "attention.available.future";
+        family: "attention";
+        symbol: "!";
+        wowColor: "gray";
+        label: string;
+        plainText: string;
+        ttyText: string;
+        htmlClass: string;
+    };
+    'progress.incomplete': {
+        id: "progress.incomplete";
+        family: "progress";
+        symbol: "?";
+        wowColor: "gray";
+        label: string;
+        plainText: string;
+        ttyText: string;
+        htmlClass: string;
+    };
+    'progress.complete': {
+        id: "progress.complete";
+        family: "progress";
+        symbol: "?";
+        wowColor: "yellow";
+        label: string;
+        plainText: string;
+        ttyText: string;
+        htmlClass: string;
+    };
+};
+
+type index$2_MarkerDefinition = MarkerDefinition;
+type index$2_MarkerId = MarkerId;
+declare const index$2_deriveQuestMarkerId: typeof deriveQuestMarkerId;
+declare const index$2_deriveRumorMarkerId: typeof deriveRumorMarkerId;
+declare const index$2_markerLookup: typeof markerLookup;
+declare namespace index$2 {
+  export { type index$2_MarkerDefinition as MarkerDefinition, type index$2_MarkerId as MarkerId, index$2_deriveQuestMarkerId as deriveQuestMarkerId, index$2_deriveRumorMarkerId as deriveRumorMarkerId, index$2_markerLookup as markerLookup };
+}
+
+/**
+ * Archives a questline without deleting it.
+ */
+declare function archiveQuestline(db: QuestlogDb, questlineId: number, archivedAt?: number): Questline;
+
+/**
+ * Creates a new questline.
+ */
+declare function createQuestline(db: QuestlogDb, input: CreateQuestlineInput): Questline;
+
+/**
+ * Detaches a quest from its questline.
+ */
+declare function detachQuestFromQuestline(db: QuestlogDb, questId: number, now?: number): void;
+
+/**
+ * Loads a questline with computed progress counts.
+ */
+declare function getQuestlineDetail(db: QuestlogDb, questlineId: number, now?: number): QuestlineDetail;
+
+/**
+ * Lists active questlines.
+ */
+declare function listQuestlines(db: QuestlogDb, now?: number): QuestlineDetail[];
+
+/**
+ * Moves a quest into a questline.
+ */
+declare function moveQuestToQuestline(db: QuestlogDb, questId: number, questlineId: number, now?: number): void;
+
+/**
+ * Soft-deletes a questline.
+ */
+declare function softDeleteQuestline(db: QuestlogDb, questlineId: number, deletedAt?: number): void;
+
+/**
+ * Updates mutable questline fields.
+ */
+declare function updateQuestline(db: QuestlogDb, questlineId: number, input: UpdateQuestlineInput): Questline;
+
+/**
+ * Abandons a quest with terminal outcome text.
+ */
+declare function abandonQuest(db: QuestlogDb, questId: number, outcome: string, resolvedAt?: number): Quest;
+
+/**
+ * Abandons a quest and atomically creates follow-up quests that point back to it.
+ */
+declare function abandonQuestAndSpawnFollowups(db: QuestlogDb, questId: number, outcome: string, followups: FollowupQuestInput[], resolvedAt?: number): AbandonQuestResult;
+
+/**
+ * Creates a concrete quest commitment.
+ */
+declare function createQuest(db: QuestlogDb, input: CreateQuestInput): Quest;
+
+/**
+ * Resolves a quest successfully.
+ */
+declare function finishQuest(db: QuestlogDb, questId: number, outcome: string, resolvedAt?: number): Quest;
+
+/**
+ * Loads a quest with derived state, rewards, tags, and dependency context.
+ */
+declare function getQuestDetail(db: QuestlogDb, questId: number, now?: number): QuestDetail;
+
+/**
+ * Lists all non-terminal quests, whether open or already in progress.
+ */
+declare function listActiveQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists quests that are available to work on now.
+ */
+declare function listAvailableQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists unresolved quests that are blocked by unmet unlock prerequisites.
+ */
+declare function listBlockedQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists quests deferred until a future moment.
+ */
+declare function listDeferredQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists quests due before the provided horizon.
+ */
+declare function listDueSoonQuests(db: QuestlogDb, horizonMs: number, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists in-progress quests.
+ */
+declare function listInProgressQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists unresolved quests whose scheduled window has already been missed.
+ */
+declare function listMissedScheduledQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists open quests.
+ */
+declare function listOpenQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists quests that are overdue by their effective due date.
+ */
+declare function listOverdueQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists resolved quests.
+ */
+declare function listResolvedQuests(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists quests scheduled for a UTC day window.
+ */
+declare function listScheduledForDay(db: QuestlogDb, dayStart: number, dayEnd: number, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Lists quests whose scheduled window overlaps now.
+ */
+declare function listScheduledNow(db: QuestlogDb, filters?: QuestListFilters, now?: number): QuestDetail[];
+
+/**
+ * Adds active effort time to a quest.
+ */
+declare function logQuestEffort(db: QuestlogDb, questId: number, effortSeconds: number, now?: number): Quest;
+
+/**
+ * Updates a quest's temporal planning fields.
+ */
+declare function planQuestTime(db: QuestlogDb, questId: number, input: PlanQuestTimeInput): Quest;
+
+/**
+ * Revises a quest objective while the quest has not actually started.
+ */
+declare function reviseQuestObjective(db: QuestlogDb, questId: number, objective: string, now?: number): Quest;
+
+/**
+ * Soft-deletes a quest.
+ */
+declare function softDeleteQuest(db: QuestlogDb, questId: number, now?: number): void;
+
+/**
+ * Marks actual work on a quest as started.
+ */
+declare function startQuest(db: QuestlogDb, questId: number, startedAt?: number): Quest;
+
+/**
+ * A recurring definition that spawns concrete quest instances for due anchors.
+ */
+interface RepeatableQuest {
+    id: number;
+    questlineId: number | null;
+    title: string;
+    objective: string;
+    rrule: string;
+    anchorAt: number;
+    notBeforeOffsetSeconds: number | null;
+    dueOffsetSeconds: number | null;
+    scheduledStartOffsetSeconds: number | null;
+    scheduledEndOffsetSeconds: number | null;
+    allDay: boolean;
+    estimateSeconds: number | null;
+    createdAt: number;
+    updatedAt: number;
+    archivedAt: number | null;
+    deletedAt: number | null;
+}
+/**
+ * Input for creating a recurring quest definition.
+ */
+interface CreateRepeatableQuestInput {
+    title: string;
+    objective: string;
+    questlineId?: number | null;
+    rrule: string;
+    anchorAt: number;
+    notBeforeOffsetSeconds?: number | null;
+    dueOffsetSeconds?: number | null;
+    scheduledStartOffsetSeconds?: number | null;
+    scheduledEndOffsetSeconds?: number | null;
+    allDay?: boolean;
+    estimateSeconds?: number | null;
+    tags?: string[];
+    rewards?: RepeatableQuestRewardInput[];
+    now?: number;
+}
+/**
+ * Input for updating a repeatable quest definition.
+ */
+interface UpdateRepeatableQuestInput {
+    title?: string;
+    objective?: string;
+    questlineId?: number | null;
+    rrule?: string;
+    anchorAt?: number;
+    notBeforeOffsetSeconds?: number | null;
+    dueOffsetSeconds?: number | null;
+    scheduledStartOffsetSeconds?: number | null;
+    scheduledEndOffsetSeconds?: number | null;
+    allDay?: boolean;
+    estimateSeconds?: number | null;
+    archivedAt?: number | null;
+    now?: number;
+}
+/**
+ * A recurrence anchor that is due for materialization.
+ */
+interface DueRepeatableAnchor {
+    repeatableQuestId: number;
+    anchorAt: number;
+    markerId: MarkerId;
+}
+
+/**
+ * Archives a repeatable quest definition.
+ */
+declare function archiveRepeatableQuest(db: QuestlogDb, repeatableQuestId: number, archivedAt?: number): RepeatableQuest;
+
+/**
+ * Creates a repeatable quest definition.
+ */
+declare function createRepeatableQuest(db: QuestlogDb, input: CreateRepeatableQuestInput): RepeatableQuest;
+
+/**
+ * Lists recurrence anchors that should be materialized into concrete quests.
+ */
+declare function listDueRepeatableQuestAnchors(db: QuestlogDb, now: number): DueRepeatableAnchor[];
+
+/**
+ * Soft-deletes a repeatable quest definition.
+ */
+declare function softDeleteRepeatableQuest(db: QuestlogDb, repeatableQuestId: number, deletedAt?: number): void;
+
+/**
+ * Materializes all due repeatable quest anchors into concrete quests.
+ */
+declare function spawnDueRepeatableQuests(db: QuestlogDb, now: number): Quest[];
+
+/**
+ * Updates a repeatable quest definition for future materializations only.
+ */
+declare function updateRepeatableQuest(db: QuestlogDb, repeatableQuestId: number, input: UpdateRepeatableQuestInput): RepeatableQuest;
+
+/**
+ * Captures a new rumor for later triage.
+ */
+declare function captureRumor(db: QuestlogDb, input: CaptureRumorInput): Rumor;
+
+/**
+ * Dismisses a rumor without producing downstream artifacts.
+ */
+declare function dismissRumor(db: QuestlogDb, rumorId: number, dismissedAt?: number): Rumor;
+
+/**
+ * Loads a rumor with derived state and downstream outputs.
+ */
+declare function getRumorDetail(db: QuestlogDb, rumorId: number): RumorDetail;
+
+/**
+ * Lists outputs that a rumor produced.
+ */
+declare function getRumorOutputs(db: QuestlogDb, rumorId: number): RumorOutput[];
+
+/**
+ * Lists all active rumors.
+ */
+declare function listRumors(db: QuestlogDb): Rumor[];
+
+/**
+ * Reopens a previously dismissed or settled rumor.
+ */
+declare function reopenRumor(db: QuestlogDb, rumorId: number, now?: number): Rumor;
+
+/**
+ * Canonically settles a rumor into zero or more downstream artifacts.
+ */
+declare function settleRumor(db: QuestlogDb, rumorId: number, input: SettleRumorInput): SettleRumorResult;
+
+/**
+ * Soft-deletes a rumor.
+ */
+declare function softDeleteRumor(db: QuestlogDb, rumorId: number, now?: number): void;
+
+/**
+ * Search result across questlog content.
+ */
+interface QuestlogSearchResult {
+    entityKind: 'quest' | 'rumor';
+    entityId: number;
+    title: string;
+    snippet: string;
+    markerId: MarkerId | null;
+}
+
+/**
+ * Full-text search across quest and rumor content.
+ */
+declare function searchQuestlog(db: QuestlogDb, query: string): QuestlogSearchResult[];
+
+declare const read_getQuestDetail: typeof getQuestDetail;
+declare const read_getQuestlineDetail: typeof getQuestlineDetail;
+declare const read_getRumorDetail: typeof getRumorDetail;
+declare const read_getRumorOutputs: typeof getRumorOutputs;
+declare const read_listActiveQuests: typeof listActiveQuests;
+declare const read_listAvailableQuests: typeof listAvailableQuests;
+declare const read_listBlockedQuests: typeof listBlockedQuests;
+declare const read_listDeferredQuests: typeof listDeferredQuests;
+declare const read_listDueRepeatableQuestAnchors: typeof listDueRepeatableQuestAnchors;
+declare const read_listDueSoonQuests: typeof listDueSoonQuests;
+declare const read_listInProgressQuests: typeof listInProgressQuests;
+declare const read_listMissedScheduledQuests: typeof listMissedScheduledQuests;
+declare const read_listOpenQuests: typeof listOpenQuests;
+declare const read_listOverdueQuests: typeof listOverdueQuests;
+declare const read_listQuestlines: typeof listQuestlines;
+declare const read_listResolvedQuests: typeof listResolvedQuests;
+declare const read_listRumors: typeof listRumors;
+declare const read_listScheduledForDay: typeof listScheduledForDay;
+declare const read_listScheduledNow: typeof listScheduledNow;
+declare const read_searchQuestlog: typeof searchQuestlog;
+declare namespace read {
+  export { read_getQuestDetail as getQuestDetail, read_getQuestlineDetail as getQuestlineDetail, read_getRumorDetail as getRumorDetail, read_getRumorOutputs as getRumorOutputs, read_listActiveQuests as listActiveQuests, read_listAvailableQuests as listAvailableQuests, read_listBlockedQuests as listBlockedQuests, read_listDeferredQuests as listDeferredQuests, read_listDueRepeatableQuestAnchors as listDueRepeatableQuestAnchors, read_listDueSoonQuests as listDueSoonQuests, read_listInProgressQuests as listInProgressQuests, read_listMissedScheduledQuests as listMissedScheduledQuests, read_listOpenQuests as listOpenQuests, read_listOverdueQuests as listOverdueQuests, read_listQuestlines as listQuestlines, read_listResolvedQuests as listResolvedQuests, read_listRumors as listRumors, read_listScheduledForDay as listScheduledForDay, read_listScheduledNow as listScheduledNow, read_searchQuestlog as searchQuestlog };
+}
+
+/**
+ * Attaches a reward to a concrete quest.
+ */
+declare function addQuestReward(db: QuestlogDb, questId: number, input: QuestRewardInput): QuestReward;
+
+/**
+ * Claims a reward exactly once for a successfully resolved quest.
+ */
+declare function claimQuestReward(db: QuestlogDb, rewardId: number, claimedAt?: number): QuestReward;
+
+/**
+ * Soft-deletes an unclaimed reward.
+ */
+declare function removeQuestReward(db: QuestlogDb, rewardId: number, now?: number): void;
+
+/**
+ * Replaces the active reward templates on a repeatable quest definition.
+ */
+declare function replaceRepeatableQuestRewards(db: QuestlogDb, repeatableQuestId: number, rewards: RepeatableQuestRewardInput[], now?: number): void;
+
+/**
+ * Updates an unclaimed quest reward.
+ */
+declare function updateQuestReward(db: QuestlogDb, rewardId: number, input: Omit<QuestRewardInput, 'now'> & {
+    now?: number;
+}): QuestReward;
+
+declare const archiveDeleteAndPruneSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const chooseWorkShapeSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const clarifyAmbiguousRequestsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const closeWorkAndClaimOutcomesSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const createConcreteQuestSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const detectSlipsAndStalenessSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const escalateAndUnblockSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const frameInitiativeQuestlineSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const handleExceptionsAndWeirdCasesSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const intakeTriageSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const maintainClearOwnershipSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const manageApprovalsAndPromisesSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const planSuccessorWorkSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const planTimeCorrectlySkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const prioritizeAcrossStreamsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const protectCapacityAndFocusSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const recoverFromModelingMistakesSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const reportStatusAndManageExpectationsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const reviseOrReshapeCommitmentSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const runOperationalReviewSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const runRecurringRhythmsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const searchAndRetrieveContextSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const sequenceWithUnlocksSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const settleRumorIntoStructureSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const questlogSkills: {
+    name: string;
+    description: string;
+    content: string;
+}[];
+declare function listQuestlogSkills(): {
+    name: string;
+    description: string;
+    content: string;
+}[];
+declare function getQuestlogSkillByName(name: string): {
+    name: string;
+    description: string;
+    content: string;
+} | null;
+
+interface QuestlogSkill {
+    name: string;
+    description: string;
+    content: string;
+}
+type QuestlogSkillRegistry = readonly QuestlogSkill[];
+declare function defineQuestlogSkill<TSkill extends QuestlogSkill>(skill: TSkill): TSkill;
+
+declare const tagAndFilterPortfoliosSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+type index$1_QuestlogSkill = QuestlogSkill;
+type index$1_QuestlogSkillRegistry = QuestlogSkillRegistry;
+declare const index$1_archiveDeleteAndPruneSkill: typeof archiveDeleteAndPruneSkill;
+declare const index$1_chooseWorkShapeSkill: typeof chooseWorkShapeSkill;
+declare const index$1_clarifyAmbiguousRequestsSkill: typeof clarifyAmbiguousRequestsSkill;
+declare const index$1_closeWorkAndClaimOutcomesSkill: typeof closeWorkAndClaimOutcomesSkill;
+declare const index$1_createConcreteQuestSkill: typeof createConcreteQuestSkill;
+declare const index$1_defineQuestlogSkill: typeof defineQuestlogSkill;
+declare const index$1_detectSlipsAndStalenessSkill: typeof detectSlipsAndStalenessSkill;
+declare const index$1_escalateAndUnblockSkill: typeof escalateAndUnblockSkill;
+declare const index$1_frameInitiativeQuestlineSkill: typeof frameInitiativeQuestlineSkill;
+declare const index$1_getQuestlogSkillByName: typeof getQuestlogSkillByName;
+declare const index$1_handleExceptionsAndWeirdCasesSkill: typeof handleExceptionsAndWeirdCasesSkill;
+declare const index$1_intakeTriageSkill: typeof intakeTriageSkill;
+declare const index$1_listQuestlogSkills: typeof listQuestlogSkills;
+declare const index$1_maintainClearOwnershipSkill: typeof maintainClearOwnershipSkill;
+declare const index$1_manageApprovalsAndPromisesSkill: typeof manageApprovalsAndPromisesSkill;
+declare const index$1_planSuccessorWorkSkill: typeof planSuccessorWorkSkill;
+declare const index$1_planTimeCorrectlySkill: typeof planTimeCorrectlySkill;
+declare const index$1_prioritizeAcrossStreamsSkill: typeof prioritizeAcrossStreamsSkill;
+declare const index$1_protectCapacityAndFocusSkill: typeof protectCapacityAndFocusSkill;
+declare const index$1_questlogSkills: typeof questlogSkills;
+declare const index$1_recoverFromModelingMistakesSkill: typeof recoverFromModelingMistakesSkill;
+declare const index$1_reportStatusAndManageExpectationsSkill: typeof reportStatusAndManageExpectationsSkill;
+declare const index$1_reviseOrReshapeCommitmentSkill: typeof reviseOrReshapeCommitmentSkill;
+declare const index$1_runOperationalReviewSkill: typeof runOperationalReviewSkill;
+declare const index$1_runRecurringRhythmsSkill: typeof runRecurringRhythmsSkill;
+declare const index$1_searchAndRetrieveContextSkill: typeof searchAndRetrieveContextSkill;
+declare const index$1_sequenceWithUnlocksSkill: typeof sequenceWithUnlocksSkill;
+declare const index$1_settleRumorIntoStructureSkill: typeof settleRumorIntoStructureSkill;
+declare const index$1_tagAndFilterPortfoliosSkill: typeof tagAndFilterPortfoliosSkill;
+declare namespace index$1 {
+  export { type index$1_QuestlogSkill as QuestlogSkill, type index$1_QuestlogSkillRegistry as QuestlogSkillRegistry, index$1_archiveDeleteAndPruneSkill as archiveDeleteAndPruneSkill, index$1_chooseWorkShapeSkill as chooseWorkShapeSkill, index$1_clarifyAmbiguousRequestsSkill as clarifyAmbiguousRequestsSkill, index$1_closeWorkAndClaimOutcomesSkill as closeWorkAndClaimOutcomesSkill, index$1_createConcreteQuestSkill as createConcreteQuestSkill, index$1_defineQuestlogSkill as defineQuestlogSkill, index$1_detectSlipsAndStalenessSkill as detectSlipsAndStalenessSkill, index$1_escalateAndUnblockSkill as escalateAndUnblockSkill, index$1_frameInitiativeQuestlineSkill as frameInitiativeQuestlineSkill, index$1_getQuestlogSkillByName as getQuestlogSkillByName, index$1_handleExceptionsAndWeirdCasesSkill as handleExceptionsAndWeirdCasesSkill, index$1_intakeTriageSkill as intakeTriageSkill, index$1_listQuestlogSkills as listQuestlogSkills, index$1_maintainClearOwnershipSkill as maintainClearOwnershipSkill, index$1_manageApprovalsAndPromisesSkill as manageApprovalsAndPromisesSkill, index$1_planSuccessorWorkSkill as planSuccessorWorkSkill, index$1_planTimeCorrectlySkill as planTimeCorrectlySkill, index$1_prioritizeAcrossStreamsSkill as prioritizeAcrossStreamsSkill, index$1_protectCapacityAndFocusSkill as protectCapacityAndFocusSkill, index$1_questlogSkills as questlogSkills, index$1_recoverFromModelingMistakesSkill as recoverFromModelingMistakesSkill, index$1_reportStatusAndManageExpectationsSkill as reportStatusAndManageExpectationsSkill, index$1_reviseOrReshapeCommitmentSkill as reviseOrReshapeCommitmentSkill, index$1_runOperationalReviewSkill as runOperationalReviewSkill, index$1_runRecurringRhythmsSkill as runRecurringRhythmsSkill, index$1_searchAndRetrieveContextSkill as searchAndRetrieveContextSkill, index$1_sequenceWithUnlocksSkill as sequenceWithUnlocksSkill, index$1_settleRumorIntoStructureSkill as settleRumorIntoStructureSkill, index$1_tagAndFilterPortfoliosSkill as tagAndFilterPortfoliosSkill };
+}
+
+interface QuestlogSoulTrait {
+    principle: string;
+    provenance: string;
+}
+interface QuestlogSoul {
+    slug: string;
+    name: string;
+    description: string;
+    essence: string;
+    traits: readonly QuestlogSoulTrait[];
+}
+declare const questlogSoulEssence = "You think like a disciplined manager whose main instrument is Questlog. Your job is not to sound organized. Your job is to keep the system's representation of work true enough that decisions made from it stay good over time. You see work as a progression: uncertainty enters, shape is clarified, commitments are formed, execution begins, blockers appear or clear, outcomes resolve, and closure either happens properly or leaks into the future as hidden debt. You are always asking: what state is this really in, what is the least distorted way to represent it, and what move keeps tomorrow simpler instead of messier.\n\nYour first boundary is between uncertainty and commitment. Not everything that arrives deserves to become executable work. Some things should remain rumors, some need clarification, some deserve a full questline, some are only one concrete quest, and some are rhythms that belong in repeatables. You do not rush past that boundary just to feel decisive. Premature commitment is one of the main ways systems become noisy and untrustworthy. Once vague work is stored as execution truth, every later decision is forced to work around that distortion. You would rather delay commitment by one step than pollute the model by one bad shape.\n\nYour second boundary is between derived truth and improvised interpretation. You trust the system to compute what it already knows how to compute. Available is not the same as open. Blocked is not the same as deferred. Missed schedule is not the same as overdue. Done is not the same as fully closed. You read those distinctions before you act, because each one points to a different treatment. When work is slipping, you do not settle for vague concern. You determine whether the problem is timing, shape, dependency, approval, staleness, or simple overload. The system becomes powerful only when those meanings stay separate.\n\nYour third boundary is historical truth. Once work has actually started, you do not rewrite it to make the present look cleaner. If the objective changed, the model must show that reality changed. If a path failed, the system must show failure or abandonment, not a cosmetically updated objective that pretends the original commitment never existed. You prefer finishing honestly, abandoning honestly, or spawning the next truthful work.\n\nYou also think in terms of delayed failure. Many bad outcomes do not come from dramatic mistakes. They come from quiet ones: stale work left open too long, dependencies never modeled, approvals left implicit, recurring work handled manually, items that are technically resolved but not actually closed. You use Questlog well by choosing the right representation, reading the right slice, and making the smallest honest write that improves the future instead of merely tidying the present.";
+declare const questlogSoulTraits: {
+    principle: string;
+    provenance: string;
+}[];
+declare const questlogSoul: QuestlogSoul;
+declare function renderQuestlogSoulPromptFoundation(soul?: QuestlogSoul): string;
+
+type soul_QuestlogSoul = QuestlogSoul;
+type soul_QuestlogSoulTrait = QuestlogSoulTrait;
+declare const soul_questlogSoul: typeof questlogSoul;
+declare const soul_questlogSoulEssence: typeof questlogSoulEssence;
+declare const soul_questlogSoulTraits: typeof questlogSoulTraits;
+declare const soul_renderQuestlogSoulPromptFoundation: typeof renderQuestlogSoulPromptFoundation;
+declare namespace soul {
+  export { type soul_QuestlogSoul as QuestlogSoul, type soul_QuestlogSoulTrait as QuestlogSoulTrait, soul_questlogSoul as questlogSoul, soul_questlogSoulEssence as questlogSoulEssence, soul_questlogSoulTraits as questlogSoulTraits, soul_renderQuestlogSoulPromptFoundation as renderQuestlogSoulPromptFoundation };
+}
+
+/**
+ * Replaces the active tags on a concrete quest.
+ */
+declare function replaceQuestTags(db: QuestlogDb, questId: number, tagNames: string[], now?: number): void;
+
+/**
+ * Replaces the active tag templates on a repeatable quest definition.
+ */
+declare function replaceRepeatableQuestTags(db: QuestlogDb, repeatableQuestId: number, tagNames: string[], now?: number): void;
+
+/**
+ * Adds tags to a concrete quest without disturbing existing active tags.
+ */
+declare function tagQuest(db: QuestlogDb, questId: number, tagNames: string[], now?: number): void;
+
+/**
+ * A normalized cross-cutting label for concrete quests.
+ */
+interface Tag {
+    id: number;
+    name: string;
+    normalizedName: string;
+    createdAt: number;
+    deletedAt: number | null;
+}
+
+/**
+ * Removes tags from a concrete quest.
+ */
+declare function untagQuest(db: QuestlogDb, questId: number, tagNames: string[], now?: number): void;
+
+type ToolEntityKind = 'quest' | 'questline' | 'repeatable_quest' | 'reward' | 'rumor' | 'tag';
+type ToolOutcomeKind = 'success' | 'no_op' | 'needs_clarification' | 'error';
+type ToolErrorCode = 'clarification_needed' | 'conflict' | 'constraint_violation' | 'invalid_input' | 'invalid_state' | 'not_found' | 'system_error' | 'unsupported_target';
+type ToolErrorKind = 'domain' | 'protocol' | 'system';
+type ToolWarningCode = 'already_in_state' | 'derived_value_used' | 'empty_result' | 'future_only_effect' | 'partial_match' | 'unchanged';
+type ToolClarificationCode = 'ambiguous_action' | 'ambiguous_target' | 'missing_required_choice' | 'multiple_plausible_matches';
+type ToolNextStepHintKind = 'ask_user' | 'inspect_item' | 'review_view' | 'retry_with' | 'use_tool';
+interface ToolEntityRef {
+    kind: ToolEntityKind;
+    id: number;
+    title?: string | undefined;
+    markerId?: MarkerId | null | undefined;
+    state?: string | null | undefined;
+}
+interface ToolListItem extends ToolEntityRef {
+    subtitle?: string | undefined;
+    snippet?: string | undefined;
+    dueAt?: number | null | undefined;
+    available?: boolean | undefined;
+}
+interface ToolWarning {
+    code: ToolWarningCode;
+    message: string;
+}
+interface ToolNextStepHint {
+    kind: ToolNextStepHintKind;
+    message: string;
+    tool?: string;
+    suggestedInput?: Record<string, unknown>;
+}
+interface ToolBaseResult {
+    ok: boolean;
+    outcome: ToolOutcomeKind;
+    summary: string;
+    entities: ToolEntityRef[];
+    warnings?: ToolWarning[] | undefined;
+    next?: ToolNextStepHint[] | undefined;
+}
+interface ToolSuccess<TData> extends ToolBaseResult {
+    ok: true;
+    outcome: 'success' | 'no_op';
+    data: TData;
+}
+interface ToolNeedsClarification extends ToolBaseResult {
+    ok: false;
+    outcome: 'needs_clarification';
+    clarification: {
+        code: ToolClarificationCode;
+        question: string;
+        missing: string[];
+        options?: Array<{
+            label: string;
+            value: number | string;
+        }> | undefined;
+    };
+}
+interface ToolFailure extends ToolBaseResult {
+    ok: false;
+    outcome: 'error';
+    error: {
+        kind: ToolErrorKind;
+        code: ToolErrorCode;
+        message: string;
+        recovery?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+}
+type ToolResult<TData> = ToolFailure | ToolNeedsClarification | ToolSuccess<TData>;
+interface ToolResultOptions {
+    entities?: ToolEntityRef[] | undefined;
+    next?: ToolNextStepHint[] | undefined;
+    warnings?: ToolWarning[] | undefined;
+}
+declare function toolWarning(code: ToolWarningCode, message: string): ToolWarning;
+declare function toolSuccess<TData>(summary: string, data: TData, options?: ToolResultOptions): ToolSuccess<TData>;
+declare function toolNoOp<TData>(summary: string, data: TData, options?: ToolResultOptions): ToolSuccess<TData>;
+interface ToolClarificationOptions extends ToolResultOptions {
+    options?: Array<{
+        label: string;
+        value: number | string;
+    }> | undefined;
+}
+declare function toolNeedsClarification(code: ToolClarificationCode, question: string, missing: string[], options?: ToolClarificationOptions): ToolNeedsClarification;
+interface ToolFailureOptions extends ToolResultOptions {
+    details?: Record<string, unknown> | undefined;
+    recovery?: string | undefined;
+}
+declare function toolFailure(kind: ToolErrorKind, code: ToolErrorCode, summary: string, message: string, options?: ToolFailureOptions): ToolFailure;
+
+type ToolInputDescriptions = Readonly<Record<string, string>>;
+type ToolOutputDescription = string;
+type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+interface JsonSchema {
+    type?: JsonSchemaType | undefined;
+    description?: string | undefined;
+    enum?: ReadonlyArray<boolean | number | string | null> | undefined;
+    const?: boolean | number | string | null;
+    items?: JsonSchema | undefined;
+    properties?: Readonly<Record<string, JsonSchema>> | undefined;
+    required?: ReadonlyArray<string> | undefined;
+    additionalProperties?: boolean | undefined;
+    oneOf?: ReadonlyArray<JsonSchema> | undefined;
+    anyOf?: ReadonlyArray<JsonSchema> | undefined;
+}
+type ToolSideEffects = 'none' | 'writes_state';
+interface QuestlogToolDefinition<TInput, TResult extends ToolResult<unknown>> {
+    name: string;
+    description: string;
+    whenToUse: string;
+    whenNotToUse?: string | undefined;
+    sideEffects: ToolSideEffects;
+    readOnly: boolean;
+    supportsClarification: boolean;
+    targetKinds: readonly string[];
+    inputDescriptions: ToolInputDescriptions;
+    outputDescription: ToolOutputDescription;
+    inputSchema: JsonSchema;
+    handler: (db: QuestlogDb, input: TInput) => TResult;
+}
+type ToolDefinitionRegistry = readonly QuestlogToolDefinition<never, ToolResult<unknown>>[];
+declare function defineQuestlogTool<TInput, TResult extends ToolResult<unknown>>(definition: QuestlogToolDefinition<TInput, TResult>): QuestlogToolDefinition<TInput, TResult>;
+declare function stringSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function numberSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function integerSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function booleanSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function enumSchema(description: string, values: ReadonlyArray<boolean | number | string | null>): JsonSchema;
+declare function literalSchema(value: boolean | number | string | null, description?: string): JsonSchema;
+declare function arraySchema(items: JsonSchema, description: string): JsonSchema;
+declare function objectSchema(properties: Record<string, JsonSchema>, required: ReadonlyArray<string>, description?: string): JsonSchema;
+declare function oneOfSchema(schemas: ReadonlyArray<JsonSchema>, description?: string): JsonSchema;
+
+interface CaptureRumorToolData {
+    rumor: ReturnType<typeof captureRumor>;
+}
+type CaptureRumorToolResult = ToolResult<CaptureRumorToolData>;
+declare function captureRumorToolHandler(db: Parameters<typeof captureRumor>[0], input: CaptureRumorInput): CaptureRumorToolResult;
+declare const captureRumorTool: QuestlogToolDefinition<CaptureRumorInput, CaptureRumorToolResult>;
+
+interface InspectQuestlogItemToolInput {
+    target: {
+        kind: 'quest';
+        id: number;
+    } | {
+        kind: 'questline';
+        id: number;
+    } | {
+        kind: 'repeatable_quest';
+        id: number;
+    } | {
+        kind: 'rumor';
+        id: number;
+    };
+    detailLevel?: 'compact' | 'full';
+    now?: number;
+}
+interface InspectQuestlogItemToolData {
+    item: QuestInspectItem;
+    related: ToolEntityRef[];
+    detailLevel: 'compact' | 'full';
+}
+interface QuestCompactDetail {
+    id: number;
+    title: string;
+    objective: string;
+    state: ReturnType<typeof getQuestDetail>['state'];
+    markerId: ReturnType<typeof getQuestDetail>['markerId'];
+    available: boolean;
+    effectiveDueAt: number | null;
+    tagNames: string[];
+    questlineId: number | null;
+    sourceRumorId: number | null;
+    spawnedFromRepeatableId: number | null;
+}
+interface QuestlineCompactDetail {
+    id: number;
+    title: string;
+    description: string | null;
+    dueAt: number | null;
+    archivedAt: number | null;
+    totalQuests: number;
+    availableQuests: number;
+    overdueQuests: number;
+    sourceRumorId: number | null;
+}
+interface RepeatableQuestCompactDetail {
+    id: number;
+    title: string;
+    objective: string;
+    rrule: string;
+    anchorAt: number;
+    questlineId: number | null;
+    archivedAt: number | null;
+    deletedAt: number | null;
+}
+interface RumorCompactDetail {
+    id: number;
+    title: string;
+    details: string | null;
+    state: RumorDetail['state'];
+    markerId: RumorDetail['markerId'];
+    outputs: RumorDetail['outputs'];
+}
+type QuestInspectItem = {
+    kind: 'quest';
+    detail: QuestCompactDetail | ReturnType<typeof getQuestDetail>;
+} | {
+    kind: 'questline';
+    detail: QuestlineCompactDetail | ReturnType<typeof getQuestlineDetail>;
+} | {
+    kind: 'repeatable_quest';
+    detail: RepeatableQuestCompactDetail | RepeatableQuest;
+} | {
+    kind: 'rumor';
+    detail: RumorCompactDetail | RumorDetail;
+};
+type InspectQuestlogItemToolResult = ToolResult<InspectQuestlogItemToolData>;
+declare function inspectQuestlogItemToolHandler(db: Parameters<typeof getQuestDetail>[0], input: InspectQuestlogItemToolInput): InspectQuestlogItemToolResult;
+declare const inspectQuestlogItemTool: QuestlogToolDefinition<InspectQuestlogItemToolInput, InspectQuestlogItemToolResult>;
+
+/**
+ * Loads a single active repeatable quest or throws.
+ */
+declare function getRepeatableQuestOrThrow(db: QuestlogDb, repeatableQuestId: number): RepeatableQuest;
+
+type ManageRepeatableToolInput = {
+    action: 'archive';
+    archivedAt?: number;
+    repeatableQuestId: number;
+} | {
+    action: 'create';
+    repeatableQuest: CreateRepeatableQuestInput;
+} | {
+    action: 'preview_due';
+    now?: number;
+} | {
+    action: 'spawn_due';
+    now: number;
+} | ({
+    action: 'update';
+    repeatableQuestId: number;
+} & UpdateRepeatableQuestInput);
+interface ManageRepeatableToolData {
+    action: ManageRepeatableToolInput['action'];
+    primary?: ToolEntityRef | undefined;
+    created?: ToolEntityRef[] | undefined;
+    updated?: ToolEntityRef[] | undefined;
+    items?: ToolListItem[] | undefined;
+    repeatableQuest?: ReturnType<typeof getRepeatableQuestOrThrow> | undefined;
+    spawnedQuests?: Array<ReturnType<typeof getQuestDetail>> | undefined;
+}
+type ManageRepeatableToolResult = ToolResult<ManageRepeatableToolData>;
+declare function manageRepeatableToolHandler(db: Parameters<typeof createRepeatableQuest>[0], input: ManageRepeatableToolInput): ManageRepeatableToolResult;
+declare const manageRepeatableTool: QuestlogToolDefinition<ManageRepeatableToolInput, ManageRepeatableToolResult>;
+
+type OrganizeWorkToolInput = {
+    action: 'add_unlock';
+    fromQuestId: number;
+    now?: number;
+    toQuestId: number;
+} | {
+    action: 'archive_questline';
+    archivedAt?: number;
+    questlineId: number;
+} | {
+    action: 'remove_unlock';
+    fromQuestId: number;
+    now?: number;
+    toQuestId: number;
+} | {
+    action: 'replace_unlocks';
+    fromQuestIds: number[];
+    now?: number;
+    toQuestId: number;
+} | ({
+    action: 'set_questline_fields';
+    questlineId: number;
+} & UpdateQuestlineInput);
+interface OrganizeWorkToolData {
+    action: OrganizeWorkToolInput['action'];
+    quest?: ReturnType<typeof getQuestDetail>;
+    questline?: ReturnType<typeof getQuestlineDetail>;
+}
+type OrganizeWorkToolResult = ToolResult<OrganizeWorkToolData>;
+declare function organizeWorkToolHandler(db: Parameters<typeof getQuestlineDetail>[0], input: OrganizeWorkToolInput): OrganizeWorkToolResult;
+declare const organizeWorkTool: QuestlogToolDefinition<OrganizeWorkToolInput, OrganizeWorkToolResult>;
+
+type PlanQuestToolInput = {
+    action: 'revise_objective';
+    now?: number;
+    objective: string;
+    questId: number;
+} | ({
+    action: 'set_time';
+    questId: number;
+} & PlanQuestTimeInput);
+interface PlanQuestToolData {
+    action: PlanQuestToolInput['action'];
+    quest: ReturnType<typeof getQuestDetail>;
+}
+type PlanQuestToolResult = ToolResult<PlanQuestToolData>;
+declare function planQuestToolHandler(db: Parameters<typeof getQuestDetail>[0], input: PlanQuestToolInput): PlanQuestToolResult;
+declare const planQuestTool: QuestlogToolDefinition<PlanQuestToolInput, PlanQuestToolResult>;
+
+interface RetireWorkToolInput {
+    action: 'hide';
+    deletedAt?: number;
+    target: {
+        id: number;
+        kind: 'quest';
+    } | {
+        id: number;
+        kind: 'questline';
+    } | {
+        id: number;
+        kind: 'repeatable_quest';
+    } | {
+        id: number;
+        kind: 'rumor';
+    };
+}
+interface RetireWorkToolData {
+    action: 'hide';
+    target: RetireWorkToolInput['target'];
+}
+type RetireWorkToolResult = ToolResult<RetireWorkToolData>;
+declare function retireWorkToolHandler(db: QuestlogDb, input: RetireWorkToolInput): RetireWorkToolResult;
+declare const retireWorkTool: QuestlogToolDefinition<RetireWorkToolInput, RetireWorkToolResult>;
+
+type ReviewQuestlogToolView = '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';
+interface ReviewQuestlogToolInput {
+    view: ReviewQuestlogToolView;
+    filters?: {
+        questlineId?: number;
+        tagNames?: string[];
+        includeDeleted?: boolean;
+        dayAt?: number;
+    };
+    now?: number;
+}
+interface ReviewQuestlogToolData {
+    view: ReviewQuestlogToolView;
+    items: ToolListItem[];
+    count: number;
+    appliedFilters: ReviewQuestlogToolInput['filters'] | undefined;
+    evaluatedAt: number;
+}
+type ReviewQuestlogToolResult = ToolResult<ReviewQuestlogToolData>;
+declare function reviewQuestlogToolHandler(db: Parameters<typeof listRumors>[0], input: ReviewQuestlogToolInput): ReviewQuestlogToolResult;
+declare const reviewQuestlogTool: QuestlogToolDefinition<ReviewQuestlogToolInput, ReviewQuestlogToolResult>;
+
+/**
+ * Loads a single active quest reward or throws.
+ */
+declare function getQuestRewardOrThrow(db: QuestlogDb, rewardId: number): QuestReward;
+
+type RewardWorkToolInput = {
+    action: 'add';
+    reward: QuestRewardInput;
+    target: {
+        id: number;
+        kind: 'quest';
+    };
+} | {
+    action: 'claim';
+    claimedAt?: number;
+    target: {
+        id: number;
+        kind: 'reward';
+    };
+} | {
+    action: 'remove';
+    now?: number;
+    target: {
+        id: number;
+        kind: 'reward';
+    };
+} | {
+    action: 'replace_repeatable_template';
+    now?: number;
+    rewards: RepeatableQuestRewardInput[];
+    target: {
+        id: number;
+        kind: 'repeatable_quest';
+    };
+} | {
+    action: 'update';
+    reward: Omit<QuestRewardInput, 'now'> & {
+        now?: number;
+    };
+    target: {
+        id: number;
+        kind: 'reward';
+    };
+};
+interface RewardWorkToolData {
+    action: RewardWorkToolInput['action'];
+    reward?: ReturnType<typeof getQuestRewardOrThrow> | undefined;
+    rewards?: Array<ReturnType<typeof getQuestRewardOrThrow>> | undefined;
+    target: RewardWorkToolInput['target'];
+}
+type RewardWorkToolResult = ToolResult<RewardWorkToolData>;
+declare function rewardWorkToolHandler(db: QuestlogDb, input: RewardWorkToolInput): RewardWorkToolResult;
+declare const rewardWorkTool: QuestlogToolDefinition<RewardWorkToolInput, RewardWorkToolResult>;
+
+type RunQuestToolInput = {
+    action: 'abandon';
+    outcome: string;
+    questId: number;
+    resolvedAt?: number;
+} | {
+    action: 'abandon_and_spawn_followups';
+    followups: FollowupQuestInput[];
+    outcome: string;
+    questId: number;
+    resolvedAt?: number;
+} | {
+    action: 'finish';
+    outcome: string;
+    questId: number;
+    resolvedAt?: number;
+} | {
+    action: 'log_effort';
+    effortSeconds: number;
+    now?: number;
+    questId: number;
+} | {
+    action: 'start';
+    questId: number;
+    startedAt?: number;
+};
+interface RunQuestToolData {
+    action: RunQuestToolInput['action'];
+    primary: ToolEntityRef;
+    created?: ToolEntityRef[] | undefined;
+    updated?: ToolEntityRef[] | undefined;
+    followupQuests?: Array<ReturnType<typeof getQuestDetail>> | undefined;
+    quest: ReturnType<typeof getQuestDetail>;
+}
+type RunQuestToolResult = ToolResult<RunQuestToolData>;
+declare function runQuestToolHandler(db: Parameters<typeof getQuestDetail>[0], input: RunQuestToolInput): RunQuestToolResult;
+declare const runQuestTool: QuestlogToolDefinition<RunQuestToolInput, RunQuestToolResult>;
+
+interface SearchQuestlogToolInput {
+    query: string;
+    limit?: number;
+    kinds?: Array<'quest' | 'rumor'>;
+    mode?: 'browse' | 'identify_one';
+}
+interface SearchQuestlogToolData {
+    items: ToolListItem[];
+    returnedCount: number;
+    totalCount: number;
+    appliedKinds?: Array<'quest' | 'rumor'> | undefined;
+    mode: 'browse' | 'identify_one';
+}
+type SearchQuestlogToolResult = ToolResult<SearchQuestlogToolData>;
+declare function searchQuestlogToolHandler(db: Parameters<typeof searchQuestlog>[0], input: SearchQuestlogToolInput): SearchQuestlogToolResult;
+declare const searchQuestlogTool: QuestlogToolDefinition<SearchQuestlogToolInput, SearchQuestlogToolResult>;
+
+type ShapeWorkToolInput = {
+    action: 'attach_quest_to_questline';
+    now?: number;
+    questId: number;
+    questlineId: number;
+} | {
+    action: 'create_quest';
+    quest: CreateQuestInput;
+} | {
+    action: 'create_questline';
+    questline: CreateQuestlineInput;
+} | {
+    action: 'detach_quest_from_questline';
+    now?: number;
+    questId: number;
+} | {
+    action: 'dismiss_rumor';
+    dismissedAt?: number;
+    rumorId: number;
+} | {
+    action: 'reopen_rumor';
+    now?: number;
+    rumorId: number;
+} | ({
+    action: 'settle_rumor';
+    rumorId: number;
+} & SettleRumorInput);
+interface ShapeWorkToolData {
+    action: ShapeWorkToolInput['action'];
+    primary?: ToolEntityRef | undefined;
+    created?: ToolEntityRef[] | undefined;
+    updated?: ToolEntityRef[] | undefined;
+    quest?: ReturnType<typeof getQuestDetail> | undefined;
+    questline?: ReturnType<typeof getQuestlineDetail> | undefined;
+    quests?: Array<ReturnType<typeof getQuestDetail>> | undefined;
+    rumor?: ReturnType<typeof getRumorDetail> | undefined;
+}
+type ShapeWorkToolResult = ToolResult<ShapeWorkToolData>;
+declare function shapeWorkToolHandler(db: Parameters<typeof createQuest>[0], input: ShapeWorkToolInput): ShapeWorkToolResult;
+declare const shapeWorkTool: QuestlogToolDefinition<ShapeWorkToolInput, ShapeWorkToolResult>;
+
+type TagWorkToolInput = {
+    action: 'add';
+    now?: number;
+    tagNames: string[];
+    target: {
+        id: number;
+        kind: 'quest';
+    };
+} | {
+    action: 'remove';
+    now?: number;
+    tagNames: string[];
+    target: {
+        id: number;
+        kind: 'quest';
+    };
+} | {
+    action: 'replace';
+    now?: number;
+    tagNames: string[];
+    target: {
+        id: number;
+        kind: 'quest' | 'repeatable_quest';
+    };
+};
+interface TagWorkToolData {
+    action: TagWorkToolInput['action'];
+    tagNames: string[];
+    target: TagWorkToolInput['target'];
+}
+type TagWorkToolResult = ToolResult<TagWorkToolData>;
+declare function tagWorkToolHandler(db: QuestlogDb, input: TagWorkToolInput): TagWorkToolResult;
+declare const tagWorkTool: QuestlogToolDefinition<TagWorkToolInput, TagWorkToolResult>;
+
+interface QuestlogToolMapping {
+    source: string;
+    tool: string;
+    action?: string;
+    notes?: string;
+}
+declare const questlogToolMappings: QuestlogToolMapping[];
+
+declare const searchQuestlogToolName = "search_questlog";
+declare const reviewQuestlogToolName = "review_questlog";
+declare const inspectQuestlogItemToolName = "inspect_questlog_item";
+declare const captureRumorToolName = "capture_rumor";
+declare const shapeWorkToolName = "shape_work";
+declare const planQuestToolName = "plan_quest";
+declare const runQuestToolName = "run_quest";
+declare const organizeWorkToolName = "organize_work";
+declare const manageRepeatableToolName = "manage_repeatable";
+declare const tagWorkToolName = "tag_work";
+declare const rewardWorkToolName = "reward_work";
+declare const retireWorkToolName = "retire_work";
+
+declare const questlogTools: (QuestlogToolDefinition<CaptureRumorInput, CaptureRumorToolResult> | QuestlogToolDefinition<InspectQuestlogItemToolInput, InspectQuestlogItemToolResult> | QuestlogToolDefinition<ManageRepeatableToolInput, ManageRepeatableToolResult> | QuestlogToolDefinition<OrganizeWorkToolInput, OrganizeWorkToolResult> | QuestlogToolDefinition<PlanQuestToolInput, PlanQuestToolResult> | QuestlogToolDefinition<RetireWorkToolInput, RetireWorkToolResult> | QuestlogToolDefinition<ReviewQuestlogToolInput, ReviewQuestlogToolResult> | QuestlogToolDefinition<RewardWorkToolInput, RewardWorkToolResult> | QuestlogToolDefinition<RunQuestToolInput, RunQuestToolResult> | QuestlogToolDefinition<SearchQuestlogToolInput, SearchQuestlogToolResult> | QuestlogToolDefinition<ShapeWorkToolInput, ShapeWorkToolResult> | QuestlogToolDefinition<TagWorkToolInput, TagWorkToolResult>)[];
+declare function listQuestlogToolDefinitions(): (QuestlogToolDefinition<CaptureRumorInput, CaptureRumorToolResult> | QuestlogToolDefinition<InspectQuestlogItemToolInput, InspectQuestlogItemToolResult> | QuestlogToolDefinition<ManageRepeatableToolInput, ManageRepeatableToolResult> | QuestlogToolDefinition<OrganizeWorkToolInput, OrganizeWorkToolResult> | QuestlogToolDefinition<PlanQuestToolInput, PlanQuestToolResult> | QuestlogToolDefinition<RetireWorkToolInput, RetireWorkToolResult> | QuestlogToolDefinition<ReviewQuestlogToolInput, ReviewQuestlogToolResult> | QuestlogToolDefinition<RewardWorkToolInput, RewardWorkToolResult> | QuestlogToolDefinition<RunQuestToolInput, RunQuestToolResult> | QuestlogToolDefinition<SearchQuestlogToolInput, SearchQuestlogToolResult> | QuestlogToolDefinition<ShapeWorkToolInput, ShapeWorkToolResult> | QuestlogToolDefinition<TagWorkToolInput, TagWorkToolResult>)[];
+declare function getQuestlogToolByName(name: string): QuestlogToolDefinition<CaptureRumorInput, CaptureRumorToolResult> | QuestlogToolDefinition<InspectQuestlogItemToolInput, InspectQuestlogItemToolResult> | QuestlogToolDefinition<ManageRepeatableToolInput, ManageRepeatableToolResult> | QuestlogToolDefinition<OrganizeWorkToolInput, OrganizeWorkToolResult> | QuestlogToolDefinition<PlanQuestToolInput, PlanQuestToolResult> | QuestlogToolDefinition<RetireWorkToolInput, RetireWorkToolResult> | QuestlogToolDefinition<ReviewQuestlogToolInput, ReviewQuestlogToolResult> | QuestlogToolDefinition<RewardWorkToolInput, RewardWorkToolResult> | QuestlogToolDefinition<RunQuestToolInput, RunQuestToolResult> | QuestlogToolDefinition<SearchQuestlogToolInput, SearchQuestlogToolResult> | QuestlogToolDefinition<ShapeWorkToolInput, ShapeWorkToolResult> | QuestlogToolDefinition<TagWorkToolInput, TagWorkToolResult> | null;
+
+type index_JsonSchema = JsonSchema;
+type index_JsonSchemaType = JsonSchemaType;
+type index_QuestlogToolDefinition<TInput, TResult extends ToolResult<unknown>> = QuestlogToolDefinition<TInput, TResult>;
+type index_QuestlogToolMapping = QuestlogToolMapping;
+type index_ToolClarificationCode = ToolClarificationCode;
+type index_ToolDefinitionRegistry = ToolDefinitionRegistry;
+type index_ToolEntityKind = ToolEntityKind;
+type index_ToolEntityRef = ToolEntityRef;
+type index_ToolErrorCode = ToolErrorCode;
+type index_ToolErrorKind = ToolErrorKind;
+type index_ToolFailure = ToolFailure;
+type index_ToolInputDescriptions = ToolInputDescriptions;
+type index_ToolListItem = ToolListItem;
+type index_ToolNeedsClarification = ToolNeedsClarification;
+type index_ToolNextStepHint = ToolNextStepHint;
+type index_ToolNextStepHintKind = ToolNextStepHintKind;
+type index_ToolOutcomeKind = ToolOutcomeKind;
+type index_ToolOutputDescription = ToolOutputDescription;
+type index_ToolResult<TData> = ToolResult<TData>;
+type index_ToolSideEffects = ToolSideEffects;
+type index_ToolSuccess<TData> = ToolSuccess<TData>;
+type index_ToolWarning = ToolWarning;
+type index_ToolWarningCode = ToolWarningCode;
+declare const index_arraySchema: typeof arraySchema;
+declare const index_booleanSchema: typeof booleanSchema;
+declare const index_captureRumorTool: typeof captureRumorTool;
+declare const index_captureRumorToolHandler: typeof captureRumorToolHandler;
+declare const index_captureRumorToolName: typeof captureRumorToolName;
+declare const index_defineQuestlogTool: typeof defineQuestlogTool;
+declare const index_enumSchema: typeof enumSchema;
+declare const index_getQuestlogToolByName: typeof getQuestlogToolByName;
+declare const index_inspectQuestlogItemTool: typeof inspectQuestlogItemTool;
+declare const index_inspectQuestlogItemToolHandler: typeof inspectQuestlogItemToolHandler;
+declare const index_inspectQuestlogItemToolName: typeof inspectQuestlogItemToolName;
+declare const index_integerSchema: typeof integerSchema;
+declare const index_listQuestlogToolDefinitions: typeof listQuestlogToolDefinitions;
+declare const index_literalSchema: typeof literalSchema;
+declare const index_manageRepeatableTool: typeof manageRepeatableTool;
+declare const index_manageRepeatableToolHandler: typeof manageRepeatableToolHandler;
+declare const index_manageRepeatableToolName: typeof manageRepeatableToolName;
+declare const index_numberSchema: typeof numberSchema;
+declare const index_objectSchema: typeof objectSchema;
+declare const index_oneOfSchema: typeof oneOfSchema;
+declare const index_organizeWorkTool: typeof organizeWorkTool;
+declare const index_organizeWorkToolHandler: typeof organizeWorkToolHandler;
+declare const index_organizeWorkToolName: typeof organizeWorkToolName;
+declare const index_planQuestTool: typeof planQuestTool;
+declare const index_planQuestToolHandler: typeof planQuestToolHandler;
+declare const index_planQuestToolName: typeof planQuestToolName;
+declare const index_questlogToolMappings: typeof questlogToolMappings;
+declare const index_questlogTools: typeof questlogTools;
+declare const index_retireWorkTool: typeof retireWorkTool;
+declare const index_retireWorkToolHandler: typeof retireWorkToolHandler;
+declare const index_retireWorkToolName: typeof retireWorkToolName;
+declare const index_reviewQuestlogTool: typeof reviewQuestlogTool;
+declare const index_reviewQuestlogToolHandler: typeof reviewQuestlogToolHandler;
+declare const index_reviewQuestlogToolName: typeof reviewQuestlogToolName;
+declare const index_rewardWorkTool: typeof rewardWorkTool;
+declare const index_rewardWorkToolHandler: typeof rewardWorkToolHandler;
+declare const index_rewardWorkToolName: typeof rewardWorkToolName;
+declare const index_runQuestTool: typeof runQuestTool;
+declare const index_runQuestToolHandler: typeof runQuestToolHandler;
+declare const index_runQuestToolName: typeof runQuestToolName;
+declare const index_searchQuestlogTool: typeof searchQuestlogTool;
+declare const index_searchQuestlogToolHandler: typeof searchQuestlogToolHandler;
+declare const index_searchQuestlogToolName: typeof searchQuestlogToolName;
+declare const index_shapeWorkTool: typeof shapeWorkTool;
+declare const index_shapeWorkToolHandler: typeof shapeWorkToolHandler;
+declare const index_shapeWorkToolName: typeof shapeWorkToolName;
+declare const index_stringSchema: typeof stringSchema;
+declare const index_tagWorkTool: typeof tagWorkTool;
+declare const index_tagWorkToolHandler: typeof tagWorkToolHandler;
+declare const index_tagWorkToolName: typeof tagWorkToolName;
+declare const index_toolFailure: typeof toolFailure;
+declare const index_toolNeedsClarification: typeof toolNeedsClarification;
+declare const index_toolNoOp: typeof toolNoOp;
+declare const index_toolSuccess: typeof toolSuccess;
+declare const index_toolWarning: typeof toolWarning;
+declare namespace index {
+  export { type index_JsonSchema as JsonSchema, type index_JsonSchemaType as JsonSchemaType, type index_QuestlogToolDefinition as QuestlogToolDefinition, type index_QuestlogToolMapping as QuestlogToolMapping, type index_ToolClarificationCode as ToolClarificationCode, type index_ToolDefinitionRegistry as ToolDefinitionRegistry, type index_ToolEntityKind as ToolEntityKind, type index_ToolEntityRef as ToolEntityRef, type index_ToolErrorCode as ToolErrorCode, type index_ToolErrorKind as ToolErrorKind, type index_ToolFailure as ToolFailure, type index_ToolInputDescriptions as ToolInputDescriptions, type index_ToolListItem as ToolListItem, type index_ToolNeedsClarification as ToolNeedsClarification, type index_ToolNextStepHint as ToolNextStepHint, type index_ToolNextStepHintKind as ToolNextStepHintKind, type index_ToolOutcomeKind as ToolOutcomeKind, type index_ToolOutputDescription as ToolOutputDescription, type index_ToolResult as ToolResult, type index_ToolSideEffects as ToolSideEffects, type index_ToolSuccess as ToolSuccess, type index_ToolWarning as ToolWarning, type index_ToolWarningCode as ToolWarningCode, index_arraySchema as arraySchema, index_booleanSchema as booleanSchema, index_captureRumorTool as captureRumorTool, index_captureRumorToolHandler as captureRumorToolHandler, index_captureRumorToolName as captureRumorToolName, index_defineQuestlogTool as defineQuestlogTool, index_enumSchema as enumSchema, index_getQuestlogToolByName as getQuestlogToolByName, index_inspectQuestlogItemTool as inspectQuestlogItemTool, index_inspectQuestlogItemToolHandler as inspectQuestlogItemToolHandler, index_inspectQuestlogItemToolName as inspectQuestlogItemToolName, index_integerSchema as integerSchema, index_listQuestlogToolDefinitions as listQuestlogToolDefinitions, index_literalSchema as literalSchema, index_manageRepeatableTool as manageRepeatableTool, index_manageRepeatableToolHandler as manageRepeatableToolHandler, index_manageRepeatableToolName as manageRepeatableToolName, index_numberSchema as numberSchema, index_objectSchema as objectSchema, index_oneOfSchema as oneOfSchema, index_organizeWorkTool as organizeWorkTool, index_organizeWorkToolHandler as organizeWorkToolHandler, index_organizeWorkToolName as organizeWorkToolName, index_planQuestTool as planQuestTool, index_planQuestToolHandler as planQuestToolHandler, index_planQuestToolName as planQuestToolName, index_questlogToolMappings as questlogToolMappings, index_questlogTools as questlogTools, index_retireWorkTool as retireWorkTool, index_retireWorkToolHandler as retireWorkToolHandler, index_retireWorkToolName as retireWorkToolName, index_reviewQuestlogTool as reviewQuestlogTool, index_reviewQuestlogToolHandler as reviewQuestlogToolHandler, index_reviewQuestlogToolName as reviewQuestlogToolName, index_rewardWorkTool as rewardWorkTool, index_rewardWorkToolHandler as rewardWorkToolHandler, index_rewardWorkToolName as rewardWorkToolName, index_runQuestTool as runQuestTool, index_runQuestToolHandler as runQuestToolHandler, index_runQuestToolName as runQuestToolName, index_searchQuestlogTool as searchQuestlogTool, index_searchQuestlogToolHandler as searchQuestlogToolHandler, index_searchQuestlogToolName as searchQuestlogToolName, index_shapeWorkTool as shapeWorkTool, index_shapeWorkToolHandler as shapeWorkToolHandler, index_shapeWorkToolName as shapeWorkToolName, index_stringSchema as stringSchema, index_tagWorkTool as tagWorkTool, index_tagWorkToolHandler as tagWorkToolHandler, index_tagWorkToolName as tagWorkToolName, index_toolFailure as toolFailure, index_toolNeedsClarification as toolNeedsClarification, index_toolNoOp as toolNoOp, index_toolSuccess as toolSuccess, index_toolWarning as toolWarning };
+}
+
+/**
+ * Adds a hard prerequisite relation between two quests.
+ */
+declare function addUnlock(db: QuestlogDb, fromQuestId: number, toQuestId: number, now?: number): void;
+
+/**
+ * Removes an active unlock relation.
+ */
+declare function removeUnlock(db: QuestlogDb, fromQuestId: number, toQuestId: number, now?: number): void;
+
+/**
+ * Replaces the active prerequisites for a target quest.
+ */
+declare function replaceUnlocks(db: QuestlogDb, toQuestId: number, fromQuestIds: number[], now?: number): void;
+
+/**
+ * A hard prerequisite relation where one quest must resolve successfully before another becomes available.
+ */
+interface QuestUnlock {
+    id: number;
+    fromQuestId: number;
+    toQuestId: number;
+    createdAt: number;
+    deletedAt: number | null;
+}
+
+declare const write_abandonQuest: typeof abandonQuest;
+declare const write_abandonQuestAndSpawnFollowups: typeof abandonQuestAndSpawnFollowups;
+declare const write_addQuestReward: typeof addQuestReward;
+declare const write_addUnlock: typeof addUnlock;
+declare const write_archiveQuestline: typeof archiveQuestline;
+declare const write_archiveRepeatableQuest: typeof archiveRepeatableQuest;
+declare const write_captureRumor: typeof captureRumor;
+declare const write_claimQuestReward: typeof claimQuestReward;
+declare const write_createQuest: typeof createQuest;
+declare const write_createQuestline: typeof createQuestline;
+declare const write_createRepeatableQuest: typeof createRepeatableQuest;
+declare const write_detachQuestFromQuestline: typeof detachQuestFromQuestline;
+declare const write_dismissRumor: typeof dismissRumor;
+declare const write_finishQuest: typeof finishQuest;
+declare const write_logQuestEffort: typeof logQuestEffort;
+declare const write_moveQuestToQuestline: typeof moveQuestToQuestline;
+declare const write_planQuestTime: typeof planQuestTime;
+declare const write_removeQuestReward: typeof removeQuestReward;
+declare const write_removeUnlock: typeof removeUnlock;
+declare const write_reopenRumor: typeof reopenRumor;
+declare const write_replaceQuestTags: typeof replaceQuestTags;
+declare const write_replaceRepeatableQuestRewards: typeof replaceRepeatableQuestRewards;
+declare const write_replaceRepeatableQuestTags: typeof replaceRepeatableQuestTags;
+declare const write_replaceUnlocks: typeof replaceUnlocks;
+declare const write_reviseQuestObjective: typeof reviseQuestObjective;
+declare const write_settleRumor: typeof settleRumor;
+declare const write_softDeleteQuest: typeof softDeleteQuest;
+declare const write_softDeleteQuestline: typeof softDeleteQuestline;
+declare const write_softDeleteRepeatableQuest: typeof softDeleteRepeatableQuest;
+declare const write_softDeleteRumor: typeof softDeleteRumor;
+declare const write_spawnDueRepeatableQuests: typeof spawnDueRepeatableQuests;
+declare const write_startQuest: typeof startQuest;
+declare const write_tagQuest: typeof tagQuest;
+declare const write_untagQuest: typeof untagQuest;
+declare const write_updateQuestReward: typeof updateQuestReward;
+declare const write_updateQuestline: typeof updateQuestline;
+declare const write_updateRepeatableQuest: typeof updateRepeatableQuest;
+declare namespace write {
+  export { write_abandonQuest as abandonQuest, write_abandonQuestAndSpawnFollowups as abandonQuestAndSpawnFollowups, write_addQuestReward as addQuestReward, write_addUnlock as addUnlock, write_archiveQuestline as archiveQuestline, write_archiveRepeatableQuest as archiveRepeatableQuest, write_captureRumor as captureRumor, write_claimQuestReward as claimQuestReward, write_createQuest as createQuest, write_createQuestline as createQuestline, write_createRepeatableQuest as createRepeatableQuest, write_detachQuestFromQuestline as detachQuestFromQuestline, write_dismissRumor as dismissRumor, write_finishQuest as finishQuest, write_logQuestEffort as logQuestEffort, write_moveQuestToQuestline as moveQuestToQuestline, write_planQuestTime as planQuestTime, write_removeQuestReward as removeQuestReward, write_removeUnlock as removeUnlock, write_reopenRumor as reopenRumor, write_replaceQuestTags as replaceQuestTags, write_replaceRepeatableQuestRewards as replaceRepeatableQuestRewards, write_replaceRepeatableQuestTags as replaceRepeatableQuestTags, write_replaceUnlocks as replaceUnlocks, write_reviseQuestObjective as reviseQuestObjective, write_settleRumor as settleRumor, write_softDeleteQuest as softDeleteQuest, write_softDeleteQuestline as softDeleteQuestline, write_softDeleteRepeatableQuest as softDeleteRepeatableQuest, write_softDeleteRumor as softDeleteRumor, write_spawnDueRepeatableQuests as spawnDueRepeatableQuests, write_startQuest as startQuest, write_tagQuest as tagQuest, write_untagQuest as untagQuest, write_updateQuestReward as updateQuestReward, write_updateQuestline as updateQuestline, write_updateRepeatableQuest as updateRepeatableQuest };
+}
+
+export { type AbandonQuestResult, type CaptureRumorInput, type CreateQuestInput, type CreateQuestlineInput, type CreateRepeatableQuestInput, type DueRepeatableAnchor, type FollowupQuestInput, type JsonSchema, type JsonSchemaType, type MarkerDefinition, type MarkerId, type PlanQuestTimeInput, type Quest, type QuestDetail, type QuestListFilters, type QuestReward, type QuestRewardInput, type QuestState, type QuestUnlock, type Questline, type QuestlineDetail, type QuestlogDb, type QuestlogSearchResult, type QuestlogSkill, type QuestlogSkillRegistry, type QuestlogSoul, type QuestlogSoulTrait, type QuestlogToolDefinition, type QuestlogToolMapping, type RepeatableQuest, type RepeatableQuestReward, type RepeatableQuestRewardInput, type Rumor, type RumorDetail, type RumorOutput, type RumorState, type SettleRumorInput, type SettleRumorResult, type Tag, type ToolClarificationCode, type ToolDefinitionRegistry, type ToolEntityKind, type ToolEntityRef, type ToolErrorCode, type ToolErrorKind, type ToolFailure, type ToolInputDescriptions, type ToolListItem, type ToolNeedsClarification, type ToolNextStepHint, type ToolNextStepHintKind, type ToolOutcomeKind, type ToolOutputDescription, type ToolResult, type ToolSideEffects, type ToolSuccess, type ToolWarning, type ToolWarningCode, type UpdateQuestlineInput, type UpdateRepeatableQuestInput, abandonQuest, abandonQuestAndSpawnFollowups, addQuestReward, addUnlock, archiveDeleteAndPruneSkill, archiveQuestline, archiveRepeatableQuest, arraySchema, booleanSchema, captureRumor, captureRumorTool, captureRumorToolHandler, captureRumorToolName, chooseWorkShapeSkill, claimQuestReward, clarifyAmbiguousRequestsSkill, closeWorkAndClaimOutcomesSkill, createConcreteQuestSkill, createQuest, createQuestline, createRepeatableQuest, defineQuestlogSkill, defineQuestlogTool, detachQuestFromQuestline, detectSlipsAndStalenessSkill, dismissRumor, enumSchema, escalateAndUnblockSkill, finishQuest, frameInitiativeQuestlineSkill, getQuestDetail, getQuestlineDetail, getQuestlogSkillByName, getQuestlogToolByName, getRumorDetail, getRumorOutputs, handleExceptionsAndWeirdCasesSkill, initQuestlogTables, inspectQuestlogItemTool, inspectQuestlogItemToolHandler, inspectQuestlogItemToolName, intakeTriageSkill, integerSchema, listActiveQuests, listAvailableQuests, listBlockedQuests, listDeferredQuests, listDueRepeatableQuestAnchors, listDueSoonQuests, listInProgressQuests, listMissedScheduledQuests, listOpenQuests, listOverdueQuests, listQuestlines, listQuestlogSkills, listQuestlogToolDefinitions, listResolvedQuests, listRumors, listScheduledForDay, listScheduledNow, literalSchema, logQuestEffort, maintainClearOwnershipSkill, manageApprovalsAndPromisesSkill, manageRepeatableTool, manageRepeatableToolHandler, manageRepeatableToolName, index$2 as markers, moveQuestToQuestline, numberSchema, objectSchema, oneOfSchema, organizeWorkTool, organizeWorkToolHandler, organizeWorkToolName, planQuestTime, planQuestTool, planQuestToolHandler, planQuestToolName, planSuccessorWorkSkill, planTimeCorrectlySkill, prioritizeAcrossStreamsSkill, protectCapacityAndFocusSkill, questlogSkills, questlogToolMappings, questlogTools, read, recoverFromModelingMistakesSkill, removeQuestReward, removeUnlock, reopenRumor, replaceQuestTags, replaceRepeatableQuestRewards, replaceRepeatableQuestTags, replaceUnlocks, reportStatusAndManageExpectationsSkill, retireWorkTool, retireWorkToolHandler, retireWorkToolName, reviewQuestlogTool, reviewQuestlogToolHandler, reviewQuestlogToolName, reviseOrReshapeCommitmentSkill, reviseQuestObjective, rewardWorkTool, rewardWorkToolHandler, rewardWorkToolName, runOperationalReviewSkill, runQuestTool, runQuestToolHandler, runQuestToolName, runRecurringRhythmsSkill, searchAndRetrieveContextSkill, searchQuestlogTool, searchQuestlogToolHandler, searchQuestlogToolName, sequenceWithUnlocksSkill, settleRumor, settleRumorIntoStructureSkill, shapeWorkTool, shapeWorkToolHandler, shapeWorkToolName, index$1 as skills, softDeleteQuest, softDeleteQuestline, softDeleteRepeatableQuest, softDeleteRumor, soul, spawnDueRepeatableQuests, startQuest, stringSchema, tagAndFilterPortfoliosSkill, tagQuest, tagWorkTool, tagWorkToolHandler, tagWorkToolName, toolFailure, toolNeedsClarification, toolNoOp, toolSuccess, toolWarning, index as tools, untagQuest, updateQuestReward, updateQuestline, updateRepeatableQuest, write };