whydid 1.0.0

package/dist/llm/agent-prompt.js

@@ -0,0 +1,36 @@
+function describeEntry(entry) {
+    return entry.turnPrompt ?? entry.annotationSummary ?? entry.stateLabel ?? entry.stateType;
+}
+export function buildAgentPromptQuestion(req) {
+    const laterSummary = req.laterEntries.length > 0
+        ? req.laterEntries.map((e, i) => `${i + 1}. ${describeEntry(e)} (state #${e.stateId.slice(0, 8)})`).join("\n")
+        : "(nothing else has changed this file since)";
+    const question = req.mode === "revert"
+        ? `Write a clear, ready-to-paste prompt I can give to my AI coding agent (like Claude Code) to REVERT ONLY this specific change to ${req.filePath}, without disturbing the later changes listed below that were built on top of it. If a clean revert isn't possible without touching that later work, say so plainly in the generated prompt and describe what to check instead of pretending it's safe.`
+        : `Write a clear, ready-to-paste prompt I can give to my AI coding agent (like Claude Code) to build on top of this specific past change to ${req.filePath}: "${req.continueInstruction}". The prompt must make the agent aware of the later changes listed below so it doesn't conflict with or duplicate that work.`;
+    const context = [
+        `File: ${req.filePath}`,
+        "",
+        `Original change I want to ${req.mode === "revert" ? "revert" : "build on"} (state #${req.targetEntry.stateId.slice(0, 8)}):`,
+        `Prompt that caused it: ${req.targetEntry.turnPrompt ?? "(unknown — no session context)"}`,
+        `Summary: ${req.targetEntry.annotationSummary ?? "(unknown — no AI annotation)"}`,
+        "Diff:",
+        req.targetDiff,
+        "",
+        "Changes to this same file that happened AFTER this one:",
+        laterSummary,
+    ].join("\n");
+    return { question, context };
+}
+/**
+ * Asks the configured provider to synthesize a ready-to-paste prompt for the
+ * user's own AI coding agent. Throws on provider failure — callers decide
+ * how to surface that (CLI prints it, the API returns 502), since unlike
+ * annotation this is a synchronous, user-requested action with no local
+ * fallback to degrade to.
+ */
+export async function generateAgentPrompt(provider, req) {
+    const { question, context } = buildAgentPromptQuestion(req);
+    return provider.answerQuestion(question, context);
+}
+//# sourceMappingURL=agent-prompt.js.map

package/dist/llm/annotate-checkpoint.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { computeFileDiff } from "../core/diff.js";
+import { annotateState } from "./annotate.js";
+const MAX_DIFF_CHARS = 12000;
+function buildDiffText(ctx, fileChanges) {
+    const parts = [];
+    for (const change of fileChanges) {
+        if (change.changeType === "deleted") {
+            parts.push(`--- ${change.filePath} (deleted) ---`);
+            continue;
+        }
+        const diff = computeFileDiff(ctx.store, change);
+        parts.push(diff.binary ? `--- ${change.filePath} (binary, diff omitted) ---` : diff.unified);
+    }
+    const joined = parts.join("\n\n");
+    return joined.length > MAX_DIFF_CHARS ? `${joined.slice(0, MAX_DIFF_CHARS)}\n... (diff truncated)` : joined;
+}
+/**
+ * Generates and persists an annotation for a checkpoint. Never throws —
+ * a failed or unavailable LLM call must never take down the checkpoint
+ * that already succeeded locally.
+ */
+export async function annotateCheckpoint(ctx, provider, stateId, fileChanges, opts = {}) {
+    if (provider.id === "noop" || fileChanges.length === 0) {
+        return { status: "unavailable" };
+    }
+    const sendPrompts = opts.sendPrompts ?? true;
+    const sendDiffs = opts.sendDiffs ?? true;
+    try {
+        const state = ctx.db.getState(stateId);
+        const parentSummary = state?.parentStateId ? ctx.db.getAnnotation(state.parentStateId)?.summary : undefined;
+        // Ground truth beats inference: if the state is linked to a real turn
+        // (from a session adapter like Claude Code) and the caller didn't pass
+        // an explicit instruction, use the turn's own recorded prompt.
+        const rawInstruction = opts.userInstruction ?? (state?.turnId ? ctx.db.getTurn(state.turnId)?.prompt ?? undefined : undefined);
+        const result = await annotateState(provider, {
+            summaryContext: parentSummary ? `Previous change: ${parentSummary}` : "",
+            diffText: sendDiffs ? buildDiffText(ctx, fileChanges) : "(diff withheld by privacy settings — file names and prompt only)",
+            filesOfInterest: fileChanges.map((c) => c.filePath),
+            userInstruction: sendPrompts ? rawInstruction : undefined,
+        });
+        ctx.db.insertAnnotation({
+            id: randomUUID(),
+            stateId,
+            summary: result.status === "generated" ? result.summary : null,
+            reason: result.status === "generated" ? result.reason : null,
+            decisions: result.status === "generated" ? result.decisions : [],
+            riskLevel: result.status === "generated" ? result.riskLevel : null,
+            generatedBy: provider.id,
+            model: result.model ?? null,
+            status: result.status,
+            inputTokens: result.usage?.inputTokens ?? null,
+            outputTokens: result.usage?.outputTokens ?? null,
+        });
+        // Feeds the project chat's retrieval step — only real, generated
+        // content is worth ever surfacing as an answer's grounding.
+        if (result.status === "generated" && state) {
+            const searchText = [result.summary, result.reason, ...result.decisions].join(" ");
+            ctx.db.indexAnnotationForSearch(stateId, state.projectId, searchText);
+        }
+        return { status: result.status };
+    }
+    catch {
+        return { status: "failed" };
+    }
+}
+//# sourceMappingURL=annotate-checkpoint.js.map

package/dist/llm/annotate.js

@@ -0,0 +1,11 @@
+import { redactSecrets } from "../shared/redaction.js";
+export async function annotateState(provider, input) {
+    const sanitized = { ...input, diffText: redactSecrets(input.diffText) };
+    try {
+        return await provider.generateAnnotation(sanitized);
+    }
+    catch {
+        return { summary: "", reason: "", decisions: [], riskLevel: "low", status: "failed" };
+    }
+}
+//# sourceMappingURL=annotate.js.map

package/dist/llm/anthropic-provider.js

@@ -0,0 +1,97 @@
+import { buildAnnotationPrompt, buildQuestionPrompt, buildSocialPostPrompt, buildChatPrompt } from "./prompt.js";
+import { parseAnnotationJson, parseSocialPostJson, parseChatAnswerJson } from "./schema.js";
+import { describeHttpError } from "./http-error.js";
+const ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
+const ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_MODEL = "claude-sonnet-5";
+const KNOWN_MODELS = ["claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5-20251001"];
+export class AnthropicProvider {
+    apiKey;
+    id = "anthropic";
+    model;
+    constructor(apiKey, model) {
+        this.apiKey = apiKey;
+        this.model = model && model.length > 0 ? model : DEFAULT_MODEL;
+    }
+    async models() {
+        return KNOWN_MODELS;
+    }
+    async complete(system, user, maxTokens) {
+        const res = await fetch(ANTHROPIC_API_URL, {
+            method: "POST",
+            headers: {
+                "x-api-key": this.apiKey,
+                "anthropic-version": ANTHROPIC_VERSION,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                model: this.model,
+                max_tokens: maxTokens,
+                system,
+                messages: [{ role: "user", content: user }],
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(describeHttpError("Anthropic", "ANTHROPIC_API_KEY", res.status, body));
+        }
+        const data = (await res.json());
+        const text = data.content.find((block) => block.type === "text")?.text;
+        if (!text) {
+            // Newer Claude models think adaptively by default, and thinking tokens
+            // count against max_tokens — a long reasoning pass can consume the
+            // entire budget before any text is written, leaving a response with
+            // no text block at all (a documented, real Anthropic API behavior,
+            // not something specific to any one prompt). The generous max_tokens
+            // budgets below are the primary defense; this distinguishes that
+            // specific, actionable case from a genuinely broken response instead
+            // of surfacing an opaque "no text content" message to the user.
+            if (data.stop_reason === "max_tokens") {
+                throw new Error("Anthropic's response used its entire token budget on internal reasoning before writing an answer. Try again — if it keeps happening, a shorter or simpler request may help.");
+            }
+            throw new Error("Anthropic API returned no text content");
+        }
+        return { text, usage: { inputTokens: data.usage.input_tokens, outputTokens: data.usage.output_tokens } };
+    }
+    async generateAnnotation(input) {
+        const { system, user } = buildAnnotationPrompt(input);
+        const { text, usage } = await this.complete(system, user, 4096);
+        const parsed = parseAnnotationJson(text);
+        if (!parsed) {
+            return { summary: "", reason: "", decisions: [], riskLevel: "low", status: "failed", usage, model: this.model };
+        }
+        return {
+            summary: parsed.summary,
+            reason: parsed.reason,
+            decisions: parsed.decisions,
+            riskLevel: parsed.risk_level,
+            status: "generated",
+            usage,
+            model: this.model,
+        };
+    }
+    async answerQuestion(question, context) {
+        const { system, user } = buildQuestionPrompt(question, context);
+        const { text } = await this.complete(system, user, 2048);
+        return text;
+    }
+    async generateSocialPost(input) {
+        const { system, user } = buildSocialPostPrompt(input);
+        const { text, usage } = await this.complete(system, user, 4096);
+        const parsed = parseSocialPostJson(text);
+        if (!parsed) {
+            return { worthSharing: false, content: "", usage, model: this.model };
+        }
+        return { worthSharing: parsed.worth_sharing, content: parsed.content, usage, model: this.model };
+    }
+    async answerProjectQuestion(input) {
+        const { system, user } = buildChatPrompt(input);
+        const { text, usage } = await this.complete(system, user, 4096);
+        const parsed = parseChatAnswerJson(text);
+        if (!parsed) {
+            return { answer: "Something went wrong generating an answer — try asking again.", citedStateIds: [], usage, model: this.model };
+        }
+        return { answer: parsed.answer, citedStateIds: parsed.cited_state_ids, usage, model: this.model };
+    }
+}
+//# sourceMappingURL=anthropic-provider.js.map

package/dist/llm/chat.js

@@ -0,0 +1,35 @@
+import { randomUUID } from "node:crypto";
+import { retrieveContextForQuestion } from "../core/chat-retrieval.js";
+const TITLE_MAX_LENGTH = 60;
+/**
+ * Answers one question in an existing conversation: retrieves grounding
+ * context (recent + keyword-matched real checkpoints), asks the provider
+ * with the running conversation history, and persists both the question
+ * and the answer. The conversation's first message also sets its title —
+ * callers create conversations with a placeholder title since there's
+ * nothing to title them with until the user actually asks something.
+ */
+export async function askProjectQuestion(ctx, provider, projectId, conversationId, question) {
+    const priorMessages = ctx.db.listChatMessages(conversationId);
+    const conversationHistory = priorMessages.map((m) => ({ role: m.role, content: m.content }));
+    if (priorMessages.length === 0) {
+        const title = question.length > TITLE_MAX_LENGTH ? `${question.slice(0, TITLE_MAX_LENGTH - 1)}…` : question;
+        ctx.db.setChatConversationTitle(conversationId, title);
+    }
+    const groundingContext = retrieveContextForQuestion(ctx, projectId, question);
+    const userMessageId = randomUUID();
+    ctx.db.insertChatMessage({ id: userMessageId, conversationId, role: "user", content: question });
+    const result = await provider.answerProjectQuestion({ question, conversationHistory, groundingContext });
+    const assistantMessageId = randomUUID();
+    ctx.db.insertChatMessage({
+        id: assistantMessageId, conversationId, role: "assistant", content: result.answer,
+        citedStateIds: result.citedStateIds, model: result.model ?? null,
+        inputTokens: result.usage?.inputTokens ?? null, outputTokens: result.usage?.outputTokens ?? null,
+    });
+    ctx.db.touchChatConversation(conversationId);
+    const messages = ctx.db.listChatMessages(conversationId);
+    const userMessage = messages.find((m) => m.id === userMessageId);
+    const assistantMessage = messages.find((m) => m.id === assistantMessageId);
+    return { userMessage, assistantMessage };
+}
+//# sourceMappingURL=chat.js.map

package/dist/llm/community-pricing.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+// LiteLLM's community-maintained pricing dataset — a public, unauthenticated
+// JSON file many other cost-tracking tools already lean on for exactly this
+// problem, since neither Anthropic nor OpenAI publish pricing through an
+// API of their own. Fetching it is a pure inbound read: no project data,
+// prompts, or usage figures leave this machine — it's the same kind of
+// request a browser makes loading a webpage.
+const SOURCE_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const CACHE_FILENAME = "community-pricing.json";
+// Only these two — whydid is a BYOK, direct-to-provider tool (Anthropic or
+// OpenAI's own APIs), never Bedrock/Vertex/Azure. The source file carries
+// separate, differently-priced entries for those routed variants under
+// different keys (e.g. "anthropic.claude-opus-5" for Bedrock); pulling
+// every entry in indiscriminately would risk matching the wrong one.
+const RELEVANT_PROVIDERS = new Set(["anthropic", "openai"]);
+function cachePath(whydidDir) {
+    return join(whydidDir, CACHE_FILENAME);
+}
+/** Reads the last successfully-fetched snapshot, or null if one has never been fetched (or the file is unreadable). Never throws. */
+export function loadCommunityPricingCache(whydidDir) {
+    const path = cachePath(whydidDir);
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (typeof parsed?.fetchedAt === "string" && parsed?.models && typeof parsed.models === "object")
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalize(raw) {
+    const models = {};
+    if (!raw || typeof raw !== "object")
+        return models;
+    for (const [key, value] of Object.entries(raw)) {
+        if (!value || typeof value !== "object")
+            continue;
+        if (!RELEVANT_PROVIDERS.has(value.litellm_provider))
+            continue;
+        const inputPerToken = value.input_cost_per_token;
+        const outputPerToken = value.output_cost_per_token;
+        if (typeof inputPerToken !== "number" || typeof outputPerToken !== "number")
+            continue;
+        models[key] = { inputPerMillion: inputPerToken * 1_000_000, outputPerMillion: outputPerToken * 1_000_000 };
+    }
+    return models;
+}
+/**
+ * Fetches the source file, normalizes it to whydid's own per-million-token
+ * shape, and persists the result — only on explicit request (Settings has
+ * a "Refresh" button), never silently in the background, matching whydid's
+ * own local-first, nothing-happens-without-you-asking posture even though
+ * this particular call sends nothing of yours anywhere. Throws (leaving
+ * any previous cache on disk untouched) rather than overwrite a good cache
+ * with an empty one if the fetch fails or the source's schema changes
+ * enough that nothing recognizable comes back.
+ */
+export async function refreshCommunityPricing(whydidDir, fetchImpl = fetch) {
+    const res = await fetchImpl(SOURCE_URL);
+    if (!res.ok)
+        throw new Error(`Fetching community pricing failed: HTTP ${res.status}`);
+    const raw = await res.json();
+    const models = normalize(raw);
+    if (Object.keys(models).length === 0) {
+        throw new Error("Community pricing source returned no recognizable Anthropic/OpenAI entries — its format may have changed.");
+    }
+    const cache = { fetchedAt: new Date().toISOString(), models };
+    writeFileSync(cachePath(whydidDir), JSON.stringify(cache, null, 2) + "\n", "utf-8");
+    return cache;
+}
+//# sourceMappingURL=community-pricing.js.map

package/dist/llm/factory.js

@@ -0,0 +1,17 @@
+import { AnthropicProvider } from "./anthropic-provider.js";
+import { OpenAIProvider } from "./openai-provider.js";
+import { NoopProvider } from "./noop-provider.js";
+export async function createLLMProvider(config, secretStore) {
+    if (config.provider === "anthropic") {
+        const key = await secretStore.get("anthropic");
+        if (key)
+            return new AnthropicProvider(key, config.model);
+    }
+    else if (config.provider === "openai") {
+        const key = await secretStore.get("openai");
+        if (key)
+            return new OpenAIProvider(key, config.model);
+    }
+    return new NoopProvider();
+}
+//# sourceMappingURL=factory.js.map

package/dist/llm/http-error.js

@@ -0,0 +1,25 @@
+/**
+ * Turns a non-OK HTTP response from an LLM provider into a clear,
+ * actionable message instead of dumping whatever the server sent back
+ * (which, for infrastructure-level failures like a Cloudflare 5xx, is a
+ * full HTML error page — confusing and unhelpful shown raw to the user).
+ * Recognizable categories get a plain-language explanation; anything else
+ * still shows the real body, just not blindly for HTML.
+ */
+export function describeHttpError(providerName, apiKeyEnvVar, status, body) {
+    const looksLikeHtml = /^\s*<(!doctype|html)/i.test(body);
+    if (status >= 500) {
+        return `${providerName}'s API is temporarily unavailable (HTTP ${status}) — this is on their end, not a whydid problem. Try again in a moment.`;
+    }
+    if (status === 429) {
+        return `${providerName} API rate limit reached — wait a bit and try again, or check your usage limits in your ${providerName} account.`;
+    }
+    if (status === 401 || status === 403) {
+        return `${providerName} API rejected the request (HTTP ${status}) — check that ${apiKeyEnvVar} is set correctly and hasn't expired or been revoked.`;
+    }
+    if (looksLikeHtml) {
+        return `${providerName} API error ${status} (received an HTML error page instead of a normal API response — likely a temporary issue on their end, not a whydid problem). Try again in a moment.`;
+    }
+    return `${providerName} API error ${status}: ${body.slice(0, 500)}`;
+}
+//# sourceMappingURL=http-error.js.map

package/dist/llm/noop-provider.js

@@ -0,0 +1,19 @@
+export class NoopProvider {
+    id = "noop";
+    async models() {
+        return [];
+    }
+    async generateAnnotation(_input) {
+        return { summary: "", reason: "", decisions: [], riskLevel: "low", status: "unavailable" };
+    }
+    async answerQuestion(_question, _context) {
+        return "AI explanation unavailable: no LLM provider is configured yet.";
+    }
+    async generateSocialPost(_input) {
+        return { worthSharing: false, content: "" };
+    }
+    async answerProjectQuestion(_input) {
+        return { answer: "AI explanation unavailable: no LLM provider is configured yet.", citedStateIds: [] };
+    }
+}
+//# sourceMappingURL=noop-provider.js.map

package/dist/llm/openai-provider.js

@@ -0,0 +1,85 @@
+import { buildAnnotationPrompt, buildQuestionPrompt, buildSocialPostPrompt, buildChatPrompt } from "./prompt.js";
+import { parseAnnotationJson, parseSocialPostJson, parseChatAnswerJson } from "./schema.js";
+import { describeHttpError } from "./http-error.js";
+const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions";
+const DEFAULT_MODEL = "gpt-4o";
+const KNOWN_MODELS = ["gpt-4o", "gpt-4o-mini", "gpt-4.1"];
+export class OpenAIProvider {
+    apiKey;
+    id = "openai";
+    model;
+    constructor(apiKey, model) {
+        this.apiKey = apiKey;
+        this.model = model && model.length > 0 ? model : DEFAULT_MODEL;
+    }
+    async models() {
+        return KNOWN_MODELS;
+    }
+    async complete(system, user, jsonMode) {
+        const res = await fetch(OPENAI_API_URL, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.apiKey}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    { role: "system", content: system },
+                    { role: "user", content: user },
+                ],
+                ...(jsonMode ? { response_format: { type: "json_object" } } : {}),
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(describeHttpError("OpenAI", "OPENAI_API_KEY", res.status, body));
+        }
+        const data = (await res.json());
+        const text = data.choices[0]?.message.content;
+        if (!text)
+            throw new Error("OpenAI API returned no message content");
+        return { text, usage: { inputTokens: data.usage.prompt_tokens, outputTokens: data.usage.completion_tokens } };
+    }
+    async generateAnnotation(input) {
+        const { system, user } = buildAnnotationPrompt(input);
+        const { text, usage } = await this.complete(system, user, true);
+        const parsed = parseAnnotationJson(text);
+        if (!parsed) {
+            return { summary: "", reason: "", decisions: [], riskLevel: "low", status: "failed", usage, model: this.model };
+        }
+        return {
+            summary: parsed.summary,
+            reason: parsed.reason,
+            decisions: parsed.decisions,
+            riskLevel: parsed.risk_level,
+            status: "generated",
+            usage,
+            model: this.model,
+        };
+    }
+    async answerQuestion(question, context) {
+        const { system, user } = buildQuestionPrompt(question, context);
+        const { text } = await this.complete(system, user, false);
+        return text;
+    }
+    async generateSocialPost(input) {
+        const { system, user } = buildSocialPostPrompt(input);
+        const { text, usage } = await this.complete(system, user, true);
+        const parsed = parseSocialPostJson(text);
+        if (!parsed) {
+            return { worthSharing: false, content: "", usage, model: this.model };
+        }
+        return { worthSharing: parsed.worth_sharing, content: parsed.content, usage, model: this.model };
+    }
+    async answerProjectQuestion(input) {
+        const { system, user } = buildChatPrompt(input);
+        const { text, usage } = await this.complete(system, user, true);
+        const parsed = parseChatAnswerJson(text);
+        if (!parsed) {
+            return { answer: "Something went wrong generating an answer — try asking again.", citedStateIds: [], usage, model: this.model };
+        }
+        return { answer: parsed.answer, citedStateIds: parsed.cited_state_ids, usage, model: this.model };
+    }
+}
+//# sourceMappingURL=openai-provider.js.map

package/dist/llm/pricing.js

@@ -0,0 +1,55 @@
+// Published list pricing, verified via live web search on 2026-09-23 (not
+// from training data, which can be stale) — see the commit that introduced
+// this file for sources. Prices genuinely change; this is deliberately a
+// small, easy-to-audit table rather than baked into a bigger structure, so
+// it's easy to spot-check and update. Never guess a price for a model not
+// listed here — estimateCostUsd returns null instead, and callers must
+// treat that as "unknown," not zero.
+export const MODEL_PRICING = {
+    "claude-opus-5": { inputPerMillion: 5, outputPerMillion: 25 },
+    "claude-sonnet-5": { inputPerMillion: 2, outputPerMillion: 10 },
+    "claude-haiku-4-5-20251001": { inputPerMillion: 1, outputPerMillion: 5 },
+    "gpt-4o": { inputPerMillion: 2.5, outputPerMillion: 10 },
+    "gpt-4o-mini": { inputPerMillion: 0.15, outputPerMillion: 0.6 },
+    "gpt-4.1": { inputPerMillion: 2, outputPerMillion: 8 },
+};
+export const PRICING_DISCLAIMER = "Estimated from published list pricing verified September 2026. Your actual bill may differ — volume discounts, prompt caching, batch pricing, or price changes since this was checked aren't reflected here. Check your provider's dashboard for your real invoice.";
+/** Resolves a model's rate and its provenance — override, then whydid's own verified table, then the community-sourced cache — or null if nothing has it. */
+export function resolveModelPricing(model, lookup = {}) {
+    const override = lookup.overrides?.[model];
+    if (override)
+        return { ...override, source: "override" };
+    const verified = MODEL_PRICING[model];
+    if (verified)
+        return { ...verified, source: "verified" };
+    const community = lookup.community?.[model];
+    if (community)
+        return { ...community, source: "community" };
+    return null;
+}
+/** Null means "no pricing on file for this model" — never fabricate a number for an unrecognized or future model. */
+export function estimateCostUsd(model, inputTokens, outputTokens, lookup = {}) {
+    const pricing = resolveModelPricing(model, lookup);
+    if (!pricing)
+        return null;
+    return (inputTokens / 1_000_000) * pricing.inputPerMillion + (outputTokens / 1_000_000) * pricing.outputPerMillion;
+}
+/**
+ * Compares month-to-date estimated spend against a founder-set monthly
+ * limit. `spentUsd` is null when every model used this month is unpriced
+ * (estimateCostUsd returned null for all of it) — that's reported as
+ * "unknown" rather than silently treated as $0 spent, since a real budget
+ * could quietly be blown past on an unpriced model otherwise.
+ */
+export function computeBudgetStatus(monthlyLimitUsd, alertThresholdPercent, spentUsd) {
+    if (monthlyLimitUsd == null) {
+        return { status: "disabled", limitUsd: null, spentUsd, percentUsed: null };
+    }
+    if (spentUsd == null) {
+        return { status: "disabled", limitUsd: monthlyLimitUsd, spentUsd: null, percentUsed: null };
+    }
+    const percentUsed = monthlyLimitUsd > 0 ? (spentUsd / monthlyLimitUsd) * 100 : spentUsd > 0 ? Infinity : 0;
+    const status = percentUsed >= 100 ? "exceeded" : percentUsed >= alertThresholdPercent ? "warning" : "ok";
+    return { status, limitUsd: monthlyLimitUsd, spentUsd, percentUsed };
+}
+//# sourceMappingURL=pricing.js.map

package/dist/llm/prompt.js

@@ -0,0 +1,103 @@
+const ANNOTATION_SYSTEM_PROMPT = `You are analyzing a code change for a developer tool called whydid, which \
+tracks AI-assisted coding history. Given a diff and context, explain what changed and why, as a developer \
+would explain it in a commit message or PR description. When the user's actual instruction is provided, treat \
+it as ground truth for "why" — reserve inference for "what" and "decisions". Never invent intent you cannot \
+support from the instruction or the diff — if the reason is genuinely unclear, say so plainly instead of \
+guessing.
+
+Respond with ONLY a JSON object, no prose before or after, matching exactly this shape:
+{
+  "summary": "one-line summary of what changed",
+  "reason": "why this change was likely made, grounded in the user's instruction when given, else the diff",
+  "decisions": ["notable implementation decisions visible in the diff"],
+  "risk_level": "low" | "medium" | "high"
+}`;
+export function buildAnnotationPrompt(input) {
+    const instructionLine = input.userInstruction ? `The user's actual instruction to the AI agent was:\n"${input.userInstruction}"\n\n` : "";
+    const filesLine = input.filesOfInterest.length > 0 ? `Files of interest: ${input.filesOfInterest.join(", ")}\n\n` : "";
+    const user = `${instructionLine}${filesLine}Context:\n${input.summaryContext || "(no prior context)"}\n\nDiff:\n${input.diffText || "(no diff text)"}`;
+    return { system: ANNOTATION_SYSTEM_PROMPT, user };
+}
+const QUESTION_SYSTEM_PROMPT = `You are answering a developer's question about why a piece of their code \
+changed, using whydid's recorded history as context. Be concise and concrete. If the recorded context does \
+not actually answer the question, say so rather than speculating.`;
+export function buildQuestionPrompt(question, context) {
+    return { system: QUESTION_SYSTEM_PROMPT, user: `Context:\n${context}\n\nQuestion:\n${question}` };
+}
+const SOCIAL_POST_BASE_PROMPT = `You are drafting a "build in public" social media post for a solo/indie \
+founder, based on a real coding session recorded by whydid — a local tool that tracks AI-assisted coding \
+history. You're given the real prompts they gave their AI coding agent and whydid's own summary of what \
+actually happened in each resulting change.
+
+First, judge honestly whether this session is actually worth a public post. A session that shipped a real, \
+describable piece of work — a feature, a fix users would notice, a meaningful decision — is worth sharing. \
+Trivial, in-progress, or purely mechanical work (a typo fix, a lint pass, an aborted experiment with nothing \
+to show) is not — set worth_sharing to false and leave content empty rather than manufacturing hype from \
+nothing. Never fabricate outcomes, numbers, or user impact that aren't actually supported by the session data.
+
+Write in first person, like a builder sharing genuine progress — not marketing copy, no corporate voice, no \
+excessive emoji, no engagement-bait phrasing ("You won't believe..."). Specific beats vague: name what was \
+actually built, not just "made progress."
+
+Respond with ONLY a JSON object, no prose before or after, matching exactly this shape:
+{
+  "worth_sharing": true | false,
+  "content": "the drafted post text, or \\"\\" when worth_sharing is false"
+}`;
+const PLATFORM_INSTRUCTIONS = {
+    x: `Platform: X (Twitter). Stay under 260 characters total (leaves room to paste without trimming). Punchy, \
+one clear idea, no hashtag spam (zero or one relevant hashtag at most). A short thread is fine only if the \
+work genuinely has two distinct beats — otherwise one tight post.`,
+    linkedin: `Platform: LinkedIn. 3-6 short paragraphs, more narrative and reflective than X — the "why", not \
+just the "what". Professional but personable, like a founder update to people who'd genuinely want to follow \
+along, not a press release.`,
+};
+export function buildSocialPostPrompt(input) {
+    const system = `${SOCIAL_POST_BASE_PROMPT}\n\n${PLATFORM_INSTRUCTIONS[input.platform]}`;
+    const promptsBlock = input.sessionPrompts.length > 0
+        ? input.sessionPrompts.map((p) => `- ${p}`).join("\n")
+        : "(no recorded prompts for this session)";
+    const summariesBlock = input.checkpointSummaries.length > 0
+        ? input.checkpointSummaries
+            .map((c) => {
+            const decisions = c.decisions.length > 0 ? ` Decisions: ${c.decisions.join("; ")}.` : "";
+            const risk = c.riskLevel ? ` (${c.riskLevel} risk)` : "";
+            return `- ${c.summary}${risk} — ${c.reason}${decisions}`;
+        })
+            .join("\n")
+        : "(no annotated checkpoints for this session)";
+    const user = `What the founder actually asked for during this session:\n${promptsBlock}\n\nWhat whydid recorded actually happened:\n${summariesBlock}`;
+    return { system, user };
+}
+const CHAT_SYSTEM_PROMPT = `You are whydid's project assistant. You help a founder understand their own \
+project's real history — what changed, why, what was decided, and what they actually did — using ONLY the \
+real checkpoint history provided below as your source of truth. Never invent facts, dates, or outcomes not \
+grounded in that context. If the provided context doesn't actually answer the question, say so plainly \
+instead of guessing or padding the answer. Be concise and concrete — this is a founder who wants a real \
+answer, not an essay. Each piece of context is labeled with a state id in brackets like [state abc123] —
+whenever your answer draws on one, include its id in cited_state_ids so it can be linked back to.
+
+Respond with ONLY a JSON object, no prose before or after, matching exactly this shape:
+{
+  "answer": "your answer, in plain text (light markdown is fine)",
+  "cited_state_ids": ["state ids from the provided context that your answer actually draws from"]
+}`;
+export function buildChatPrompt(input) {
+    const contextBlock = input.groundingContext.length > 0
+        ? input.groundingContext
+            .map((c) => {
+            const risk = c.riskLevel ? ` (${c.riskLevel} risk)` : "";
+            const decisions = c.decisions.length > 0 ? `\n  Decisions: ${c.decisions.join("; ")}` : "";
+            const prompt = c.prompt ? `\n  Prompt: "${c.prompt}"` : "";
+            const files = c.filesTouched.length > 0 ? `\n  Files: ${c.filesTouched.join(", ")}` : "";
+            return `[state ${c.stateId}] ${new Date(c.createdAt).toLocaleString()} — ${c.summary}${risk}\n  Reason: ${c.reason}${decisions}${prompt}${files}`;
+        })
+            .join("\n\n")
+        : "(no relevant recorded history found for this question)";
+    const historyBlock = input.conversationHistory.length > 0
+        ? input.conversationHistory.map((m) => `${m.role}: ${m.content}`).join("\n")
+        : "(this is the first message in the conversation)";
+    const user = `Conversation so far:\n${historyBlock}\n\nRelevant project history:\n${contextBlock}\n\nQuestion:\n${input.question}`;
+    return { system: CHAT_SYSTEM_PROMPT, user };
+}
+//# sourceMappingURL=prompt.js.map

package/dist/llm/provider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider.js.map