praana 0.5.0

package/dist/context-engine/engine-compiler.js

@@ -0,0 +1,297 @@
+import { buildActiveState, buildCrossSessionMemory, buildPeripheralStubs, buildSystemFrame, buildStateSummary, trimAgentsContext, trimSectionToTokenBudget, } from "../compiler.js";
+import { buildArtifactCard } from "./summarize.js";
+import { getAppLogger } from "../logger.js";
+import { estimateTokens } from "./summarize.js";
+import { rankContextUnits, recencyScore, scoreContextUnit, selectUnitsWithinBudget, unitTokens, } from "./scoring.js";
+const BAND_VERBATIM_TOKENS = 3000;
+const BAND_SCORED_RECENT_TOKENS = 3000;
+const BAND_SCORED_OLDER_TOKENS = 2000;
+function estTokens(text) {
+    return estimateTokens(text);
+}
+function renderVerbatimTurn(record) {
+    const lines = [
+        `### Turn ${record.turn}`,
+        `User: ${record.userMessage}`,
+        `PRAANA: ${record.assistantMessage}`,
+    ];
+    for (const tc of record.toolCalls) {
+        lines.push(`Tool call: ${tc.tool}(${JSON.stringify(tc.args)})`);
+        if (tc.resultArtifactId) {
+            lines.push(`Result: [artifact: ${tc.resultArtifactId}]`);
+        }
+        else if (tc.resultText) {
+            lines.push(`Result: ${tc.resultText}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderTurnDigest(record) {
+    const toolSummary = record.toolCalls.length === 0
+        ? "no tools"
+        : [...new Set(record.toolCalls.map((tc) => tc.tool))].join(", ");
+    return [
+        `### Turn ${record.turn} digest`,
+        `User: ${record.userMessage}`,
+        `Assistant: ${record.assistantMessage.slice(0, 400)}`,
+        `Tools: ${toolSummary}`,
+        record.filesWritten.length
+            ? `Files: ${record.filesWritten.join(", ")}`
+            : null,
+        record.errors.length ? `Errors: ${record.errors.join("; ")}` : null,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function buildArtifactUnit(tc, turn) {
+    if (!tc.resultArtifactId)
+        return null;
+    const command = typeof tc.args.command === "string"
+        ? tc.args.command
+        : typeof tc.args.path === "string"
+            ? tc.args.path
+            : undefined;
+    const summary = tc.resultText?.slice(0, 600) ?? "(stored artifact)";
+    const content = buildArtifactCard(tc.resultArtifactId, tc.tool, command, unitTokens(summary), summary);
+    return {
+        id: tc.resultArtifactId,
+        type: "artifact_card",
+        content,
+        tokens: unitTokens(content),
+        sourceTurn: turn,
+        score: 0,
+        pinned: false,
+        artifactRefs: [tc.resultArtifactId],
+    };
+}
+function buildScoredUnits(records, currentTurn, activityEntries, pressureMode) {
+    const units = [];
+    for (const record of records) {
+        const age = currentTurn - record.turn;
+        if (age <= 2)
+            continue;
+        if (age >= 7)
+            continue;
+        if (pressureMode === "emergency") {
+            if (age > 0)
+                continue;
+            for (const tc of record.toolCalls) {
+                const unit = buildArtifactUnit(tc, record.turn);
+                if (unit)
+                    units.push(unit);
+            }
+            continue;
+        }
+        if (pressureMode === "compact" && age > 6) {
+            continue;
+        }
+        if (age >= 3 && age <= 6) {
+            const digest = renderTurnDigest(record);
+            units.push({
+                id: `turn_${record.turn}`,
+                type: "turn_digest",
+                content: digest,
+                tokens: unitTokens(digest),
+                sourceTurn: record.turn,
+                score: 0,
+                pinned: false,
+                artifactRefs: record.artifactIds,
+            });
+        }
+        for (const tc of record.toolCalls) {
+            const unit = buildArtifactUnit(tc, record.turn);
+            if (unit)
+                units.push(unit);
+        }
+    }
+    for (const entry of activityEntries) {
+        const content = `[turn ${entry.turn}] ${entry.summary}`;
+        units.push({
+            id: `activity_${entry.turn}_${entry.type}_${entry.summary.slice(0, 24)}`,
+            type: "activity_entry",
+            content,
+            tokens: unitTokens(content),
+            sourceTurn: entry.turn,
+            score: 0,
+            pinned: false,
+            artifactRefs: entry.artifactRef ? [entry.artifactRef] : [],
+        });
+    }
+    return units;
+}
+function buildVerbatimSection(records, currentTurn) {
+    const recent = records
+        .filter((r) => currentTurn - r.turn <= 2 && currentTurn - r.turn >= 0)
+        .sort((a, b) => a.turn - b.turn);
+    if (recent.length === 0) {
+        return { text: "# Recent Turns\n\n(no recent turns)", tokens: estTokens("# Recent Turns") };
+    }
+    let body = recent.map(renderVerbatimTurn).join("\n\n");
+    let tokens = estTokens(body);
+    if (tokens > BAND_VERBATIM_TOKENS) {
+        const last = recent[recent.length - 1];
+        body = renderVerbatimTurn(last);
+        tokens = estTokens(body);
+    }
+    const text = ["# Recent Turns (verbatim)", "", body].join("\n");
+    return { text, tokens: estTokens(text) };
+}
+function resolvePressureMode(pressureRatio, config) {
+    if (pressureRatio > config.pressure.emergency_at)
+        return "emergency";
+    if (pressureRatio > config.pressure.compact_at)
+        return "compact";
+    return "normal";
+}
+export function compileEngineWithMetrics(input) {
+    const sections = [];
+    const metrics = {};
+    const compileTurn = input.currentTurn + 1;
+    const scoreRecords = [];
+    const reservedOutput = input.reservedOutputTokens ?? 0;
+    const contextWindow = input.contextWindowTokens ?? input.tokenBudget;
+    const usable = Math.max(0, Math.min(input.tokenBudget, contextWindow) - reservedOutput);
+    const pressureDenominator = Math.max(1, contextWindow - reservedOutput);
+    const maxMemoryTokens = Math.floor(usable * (input.memoriesBudgetRatio ?? 0.2));
+    const maxAgentsTokens = Math.floor(usable * (input.agentsBudgetRatio ?? 0.3));
+    const maxSkillsSectionTokens = Math.floor(usable * (input.skillsSectionBudgetRatio ?? 0.2));
+    const stateSummary = buildStateSummary(input.stateGraph);
+    const { text: agentsContext, truncated: agentsTruncated } = trimAgentsContext(input.agentsContext, maxAgentsTokens);
+    metrics.agentsContextTruncated = agentsTruncated;
+    const frame = buildSystemFrame(input.cwd, input.sessionId, input.toolSchemas, stateSummary, agentsContext);
+    sections.push(frame);
+    metrics.systemFrameTokens = estTokens(frame);
+    metrics.agentsContextTokens = agentsContext ? estTokens(agentsContext) : 0;
+    let skillsSection = "";
+    if (input.skillsPromptSection) {
+        const { text, truncated } = trimSectionToTokenBudget(input.skillsPromptSection, maxSkillsSectionTokens, "skills section truncated to token budget");
+        skillsSection = text;
+        metrics.skillsTruncated = truncated;
+        sections.push(skillsSection);
+    }
+    else {
+        metrics.skillsTruncated = false;
+    }
+    metrics.skillsCatalogTokens = skillsSection ? estTokens(skillsSection) : 0;
+    let checkpointSection = "";
+    if (input.checkpointSection?.trim()) {
+        checkpointSection = input.checkpointSection.trim();
+        sections.push(checkpointSection);
+    }
+    metrics.checkpointTokens = checkpointSection ? estTokens(checkpointSection) : 0;
+    const verbatim = buildVerbatimSection(input.turnRecords, input.currentTurn);
+    sections.push(verbatim.text);
+    metrics.recentTurnsTokens = verbatim.tokens;
+    metrics.recentTurnsTruncated = false;
+    const pinnedTokens = estTokens(sections.join("\n\n")) +
+        (input.userInput ? estTokens(`## Current Input\n\nUser: ${input.userInput}`) : 0);
+    let pressureRatio = pinnedTokens / pressureDenominator;
+    let pressureMode = resolvePressureMode(pressureRatio, input.engineConfig);
+    const activityEntries = input.activityEntries ?? [];
+    let scoredUnits = buildScoredUnits(input.turnRecords, input.currentTurn, activityEntries, pressureMode);
+    const weights = input.engineConfig.scoring;
+    const userInput = input.userInput ?? "";
+    const recentUnits = scoredUnits.filter((u) => input.currentTurn - u.sourceTurn >= 3 && input.currentTurn - u.sourceTurn <= 6);
+    const olderUnits = scoredUnits.filter((u) => input.currentTurn - u.sourceTurn > 6);
+    const rankedRecent = rankContextUnits(recentUnits, input.currentTurn, userInput, weights);
+    const rankedOlder = rankContextUnits(olderUnits, input.currentTurn, userInput, weights);
+    const recentPick = selectUnitsWithinBudget(rankedRecent, BAND_SCORED_RECENT_TOKENS);
+    const olderPick = selectUnitsWithinBudget(rankedOlder, BAND_SCORED_OLDER_TOKENS);
+    const recordScore = (unit, included, band) => {
+        scoreRecords.push({
+            turn: compileTurn,
+            unitId: unit.id,
+            type: unit.type,
+            score: Number(unit.score.toFixed(4)),
+            included,
+            band,
+            tokens: unit.tokens,
+            breakdown: {
+                pin: Number(unit.breakdown.pin.toFixed(4)),
+                recency: Number(unit.breakdown.recency.toFixed(4)),
+                relevance: Number(unit.breakdown.relevance.toFixed(4)),
+            },
+        });
+    };
+    for (const unit of rankedRecent) {
+        recordScore(unit, recentPick.included.some((u) => u.id === unit.id), 4);
+    }
+    for (const unit of rankedOlder) {
+        recordScore(unit, olderPick.included.some((u) => u.id === unit.id), 5);
+    }
+    const scoredSections = [];
+    const includedScored = [...recentPick.included, ...olderPick.included];
+    if (includedScored.length > 0) {
+        scoredSections.push("# Scored Context", "", ...includedScored.map((u) => u.content));
+        sections.push(scoredSections.join("\n"));
+    }
+    let crossSection = "";
+    if (input.memoryDigest && input.memoryDigest.trim()) {
+        const { text, truncated } = trimSectionToTokenBudget(buildCrossSessionMemory(input.memoryDigest), maxMemoryTokens);
+        crossSection = text;
+        metrics.memoryTruncated = truncated;
+        sections.push(crossSection);
+        metrics.crossSessionTokens = estTokens(crossSection);
+    }
+    else {
+        metrics.crossSessionTokens = 0;
+        metrics.memoryTruncated = false;
+    }
+    const active = buildActiveState(input.stateGraph);
+    sections.push(active);
+    metrics.activeStateTokens = estTokens(active);
+    metrics.activeObjectCount = input.stateGraph.getActive().length;
+    const peripheral = buildPeripheralStubs(input.stateGraph);
+    if (peripheral) {
+        sections.push(peripheral);
+        metrics.peripheralStubsTokens = estTokens(peripheral);
+        metrics.peripheralObjectCount = input.stateGraph.getPeripheral().length;
+    }
+    else {
+        metrics.peripheralStubsTokens = 0;
+        metrics.peripheralObjectCount = 0;
+    }
+    let currentSection = "";
+    if (input.userInput) {
+        currentSection = `## Current Input\n\nUser: ${input.userInput}`;
+        sections.push(currentSection);
+    }
+    metrics.currentInputTokens = estTokens(currentSection);
+    const fullPrompt = sections.join("\n\n");
+    metrics.totalTokens = estTokens(fullPrompt);
+    pressureRatio = metrics.totalTokens / pressureDenominator;
+    pressureMode = resolvePressureMode(pressureRatio, input.engineConfig);
+    if (metrics.totalTokens > usable) {
+        getAppLogger().child("compiler").warn(`Prompt estimated at ${metrics.totalTokens} tokens, exceeds usable budget of ${usable} (window ${contextWindow}).`);
+    }
+    const excludedScoredUnits = rankedRecent.length -
+        recentPick.included.length +
+        (rankedOlder.length - olderPick.included.length);
+    return {
+        prompt: fullPrompt,
+        metrics: metrics,
+        scoreRecords,
+        pressureRatio,
+        pressureMode,
+        excludedScoredUnits,
+    };
+}
+export function explainUnitScore(unitId, records, currentTurn, userInput, weights, bandTokenBudget, bandUsedTokens) {
+    const record = records.find((r) => r.unitId === unitId);
+    if (!record) {
+        return [`No score record for unit "${unitId}" on the last compile.`];
+    }
+    const lines = [
+        `Unit ${unitId} (${record.type}, turn ${currentTurn})`,
+        `Score: ${record.score} (${record.included ? "included" : "excluded"} in prompt)`,
+        `  pin:       ${record.breakdown.pin.toFixed(2)}`,
+        `  recency:   ${record.breakdown.recency.toFixed(2)} (weight ${weights.w_recency})`,
+        `  relevance: ${record.breakdown.relevance.toFixed(2)} (weight ${weights.w_relevance})`,
+        `Budget band ${record.band}: ${bandUsedTokens}/${bandTokenBudget} tokens used`,
+    ];
+    if (userInput.trim()) {
+        lines.push(`Relevance query: "${userInput.trim().slice(0, 80)}"`);
+    }
+    return lines;
+}
+export { recencyScore, scoreContextUnit };

package/dist/context-engine/error-tracker.d.ts

@@ -0,0 +1,21 @@
+import type { OpenError, TurnRecord } from "./types.js";
+export declare function toolErrorKey(tool: string, args: Record<string, unknown>): string;
+export declare function isTestCommand(command: string): boolean;
+export declare class ErrorTracker {
+    private openErrors;
+    private testFailed;
+    constructor(initial?: {
+        openErrors?: OpenError[];
+        testFailed?: boolean;
+    });
+    getOpenErrors(): OpenError[];
+    isTestFailed(): boolean;
+    serialize(): {
+        openErrors: OpenError[];
+        testFailed: boolean;
+    };
+    processTurn(turn: number, record: TurnRecord): {
+        errorsNew: string[];
+        errorsFixed: string[];
+    };
+}

package/dist/context-engine/error-tracker.js

@@ -0,0 +1,74 @@
+export function toolErrorKey(tool, args) {
+    const command = typeof args.command === "string"
+        ? args.command
+        : typeof args.path === "string"
+            ? args.path
+            : JSON.stringify(args);
+    return `${tool}:${command}`;
+}
+export function isTestCommand(command) {
+    return /\b(npm test|pnpm test|yarn test|vitest|pytest|cargo test|go test)\b/i.test(command);
+}
+export class ErrorTracker {
+    openErrors = new Map();
+    testFailed = false;
+    constructor(initial) {
+        for (const err of initial?.openErrors ?? []) {
+            this.openErrors.set(err.key, err);
+        }
+        this.testFailed = initial?.testFailed ?? false;
+    }
+    getOpenErrors() {
+        return [...this.openErrors.values()];
+    }
+    isTestFailed() {
+        return this.testFailed;
+    }
+    serialize() {
+        return {
+            openErrors: this.getOpenErrors(),
+            testFailed: this.testFailed,
+        };
+    }
+    processTurn(turn, record) {
+        const errorsNew = [];
+        const errorsFixed = [];
+        for (const tc of record.toolCalls) {
+            const key = toolErrorKey(tc.tool, tc.args);
+            const command = typeof tc.args.command === "string" ? tc.args.command : undefined;
+            if (tc.isError || record.errors.length > 0) {
+                const message = record.errors.find((e) => e.length > 0) ??
+                    tc.resultText?.slice(0, 200) ??
+                    "tool error";
+                if (tc.isError && !this.openErrors.has(key)) {
+                    this.openErrors.set(key, {
+                        key,
+                        message,
+                        turn,
+                        tool: tc.tool,
+                        command,
+                    });
+                    errorsNew.push(message);
+                }
+                if (command && isTestCommand(command)) {
+                    this.testFailed = true;
+                }
+                continue;
+            }
+            if (this.openErrors.has(key)) {
+                const prev = this.openErrors.get(key);
+                this.openErrors.delete(key);
+                const label = prev.command ?? prev.tool;
+                errorsFixed.push(label);
+            }
+            if (command && isTestCommand(command)) {
+                this.testFailed = false;
+            }
+        }
+        for (const err of record.errors) {
+            if (!errorsNew.includes(err))
+                errorsNew.push(err);
+        }
+        return { errorsNew, errorsFixed };
+    }
+}

package/dist/context-engine/event-lineage.d.ts

@@ -0,0 +1,26 @@
+import type { ContextArtifact, SessionCheckpoint, TurnDigest, TurnRecord } from "./types.js";
+export interface RelatedArtifactRef {
+    id: string;
+    label: string;
+    turn: number;
+}
+export interface EventLineage {
+    artifactId: string;
+    sourceTool: string;
+    command?: string;
+    contentType: string;
+    producedTurn: number;
+    producedBy: string;
+    relatedDecisions: string[];
+    relatedArtifacts: RelatedArtifactRef[];
+    relatedFiles: string[];
+}
+export declare function buildEventLineage(input: {
+    artifact: ContextArtifact;
+    turnRecord: TurnRecord | null;
+    turnDigest: TurnDigest | null;
+    checkpoint: SessionCheckpoint | null;
+    sessionArtifacts: ContextArtifact[];
+    turnRecords: TurnRecord[];
+}): EventLineage;
+export declare function formatEventLineage(lineage: EventLineage): string;

package/dist/context-engine/event-lineage.js

@@ -0,0 +1,120 @@
+export function buildEventLineage(input) {
+    const { artifact, turnRecord, turnDigest, checkpoint, sessionArtifacts, turnRecords } = input;
+    const producedTurn = artifact.createdTurn;
+    const producedBy = describeProducer(artifact, turnRecord);
+    const relatedFiles = collectRelatedFiles(turnRecord, turnDigest);
+    const relatedDecisions = collectRelatedDecisions(turnDigest, checkpoint, producedTurn);
+    const relatedArtifacts = collectRelatedArtifacts(artifact, sessionArtifacts, turnRecords, relatedFiles);
+    return {
+        artifactId: artifact.id,
+        sourceTool: artifact.sourceTool,
+        command: artifact.command,
+        contentType: artifact.contentType,
+        producedTurn,
+        producedBy,
+        relatedDecisions,
+        relatedArtifacts,
+        relatedFiles,
+    };
+}
+function describeProducer(artifact, turnRecord) {
+    if (turnRecord) {
+        const toolCall = turnRecord.toolCalls.find((tc) => tc.resultArtifactId === artifact.id);
+        if (toolCall) {
+            const command = typeof toolCall.args.command === "string"
+                ? toolCall.args.command
+                : typeof toolCall.args.path === "string"
+                    ? toolCall.args.path
+                    : undefined;
+            if (command) {
+                return `${toolCall.tool} command "${command}" in turn ${turnRecord.turn}`;
+            }
+            return `${toolCall.tool} in turn ${turnRecord.turn}`;
+        }
+    }
+    if (artifact.command) {
+        return `${artifact.sourceTool} command "${artifact.command}" in turn ${artifact.createdTurn}`;
+    }
+    return `${artifact.sourceTool} in turn ${artifact.createdTurn}`;
+}
+function collectRelatedFiles(turnRecord, turnDigest) {
+    const files = new Set();
+    for (const path of turnRecord?.filesRead ?? [])
+        files.add(path);
+    for (const path of turnRecord?.filesWritten ?? [])
+        files.add(path);
+    for (const path of turnDigest?.filesChanged ?? [])
+        files.add(path);
+    return [...files];
+}
+function collectRelatedDecisions(turnDigest, checkpoint, producedTurn) {
+    const decisions = new Set();
+    for (const decision of turnDigest?.decisions ?? []) {
+        decisions.add(typeof decision === "string" ? decision : decision.summary);
+    }
+    for (const decision of checkpoint?.state.decisions ?? []) {
+        if (decision.turn <= producedTurn) {
+            decisions.add(decision.summary);
+        }
+    }
+    return [...decisions].slice(-10);
+}
+function collectRelatedArtifacts(artifact, sessionArtifacts, turnRecords, relatedFiles) {
+    const refs = [];
+    const seen = new Set([artifact.id]);
+    const fileSet = new Set(relatedFiles);
+    const add = (item) => {
+        if (seen.has(item.id))
+            return;
+        seen.add(item.id);
+        const label = item.command
+            ? `${item.sourceTool}: ${item.command}`
+            : item.sourceTool;
+        refs.push({ id: item.id, label, turn: item.createdTurn });
+    };
+    for (const other of sessionArtifacts) {
+        if (other.createdTurn === artifact.createdTurn) {
+            add(other);
+        }
+    }
+    for (const delta of [-1, 1]) {
+        const neighborTurn = artifact.createdTurn + delta;
+        for (const other of sessionArtifacts) {
+            if (other.createdTurn !== neighborTurn)
+                continue;
+            add(other);
+        }
+    }
+    if (fileSet.size > 0) {
+        for (const record of turnRecords) {
+            const recordFiles = [...record.filesRead, ...record.filesWritten];
+            if (!recordFiles.some((path) => fileSet.has(path)))
+                continue;
+            for (const artifactId of record.artifactIds) {
+                const match = sessionArtifacts.find((a) => a.id === artifactId);
+                if (match)
+                    add(match);
+            }
+        }
+    }
+    return refs.sort((a, b) => a.turn - b.turn || a.id.localeCompare(b.id));
+}
+export function formatEventLineage(lineage) {
+    const header = lineage.command
+        ? `${lineage.artifactId} (${lineage.command}, turn ${lineage.producedTurn})`
+        : `${lineage.artifactId} (${lineage.sourceTool}, turn ${lineage.producedTurn})`;
+    const lines = [
+        `Artifact ${header}`,
+        `Produced by: ${lineage.producedBy}`,
+    ];
+    if (lineage.relatedDecisions.length > 0) {
+        lines.push(`Related decisions: ${lineage.relatedDecisions.join(", ")}`);
+    }
+    if (lineage.relatedArtifacts.length > 0) {
+        lines.push("Related artifacts:", ...lineage.relatedArtifacts.map((ref) => `- ${ref.id} (${ref.label}, turn ${ref.turn})`));
+    }
+    if (lineage.relatedFiles.length > 0) {
+        lines.push(`Related files: ${lineage.relatedFiles.join(", ")}`);
+    }
+    return lines.join("\n");
+}

package/dist/context-engine/extraction.d.ts

@@ -0,0 +1,26 @@
+import type Database from "better-sqlite3";
+import type { StateGraph } from "../state-graph.js";
+import type { ContextEngineConfig } from "../types.js";
+import type { ActivityEntry, CheckpointDraft, StateSnapshot, TurnDigest, TurnRecord } from "./types.js";
+export declare class TurnExtraction {
+    private readonly db;
+    private readonly sessionId;
+    private readonly config;
+    private readonly errorTracker;
+    private readonly activityLog;
+    private recentDecisions;
+    private recentConstraints;
+    private lastUserIntent;
+    private lastDigest;
+    constructor(db: Database.Database, sessionId: string, config: ContextEngineConfig);
+    captureStateSnapshot(stateGraph: StateGraph): StateSnapshot;
+    processTurn(input: {
+        userMessage: string;
+        record: TurnRecord;
+        stateBefore: StateSnapshot;
+        stateGraph: StateGraph;
+    }): TurnDigest;
+    getLatestDigest(): TurnDigest | null;
+    getRecentActivity(): ActivityEntry[];
+    getCheckpointDraft(): CheckpointDraft;
+}

package/dist/context-engine/extraction.js

@@ -0,0 +1,83 @@
+import { ActivityLog, deriveActivityEntries } from "./activity-log.js";
+import { getExtractionState, insertActivityEntries, insertTurnDigest, listActivityEntries, upsertExtractionState, } from "./db.js";
+import { ErrorTracker } from "./error-tracker.js";
+import { snapshotStateGraph } from "./state-snapshot.js";
+import { extractTurnDigest } from "./turn-digest.js";
+export class TurnExtraction {
+    db;
+    sessionId;
+    config;
+    errorTracker;
+    activityLog;
+    recentDecisions = [];
+    recentConstraints = [];
+    lastUserIntent = "";
+    lastDigest = null;
+    constructor(db, sessionId, config) {
+        this.db = db;
+        this.sessionId = sessionId;
+        this.config = config;
+        const saved = getExtractionState(db, sessionId);
+        this.errorTracker = new ErrorTracker({
+            openErrors: saved?.openErrors,
+            testFailed: saved?.testFailed,
+        });
+        this.activityLog = new ActivityLog(config.activity_log_max_entries, listActivityEntries(db, sessionId, config.activity_log_max_entries));
+        if (saved) {
+            this.recentDecisions = saved.recentDecisions;
+            this.recentConstraints = saved.recentConstraints;
+            this.lastUserIntent = saved.lastUserIntent;
+        }
+    }
+    captureStateSnapshot(stateGraph) {
+        return snapshotStateGraph(stateGraph);
+    }
+    processTurn(input) {
+        const turn = input.record.turn;
+        const testWasFailing = this.errorTracker.isTestFailed();
+        const { errorsNew, errorsFixed } = this.errorTracker.processTurn(turn, input.record);
+        const digest = extractTurnDigest({
+            turn,
+            userMessage: input.userMessage,
+            record: input.record,
+            stateBefore: input.stateBefore,
+            stateGraph: input.stateGraph,
+            errorsNew,
+            errorsFixed,
+        });
+        const activityEntries = deriveActivityEntries(turn, digest, input.record, testWasFailing);
+        this.lastDigest = digest;
+        this.lastUserIntent = digest.userIntent;
+        this.recentDecisions.push(...digest.decisions.map((decision) => ({
+            summary: typeof decision === "string" ? decision : decision.summary,
+            turn,
+        })));
+        this.recentConstraints.push(...digest.constraints);
+        this.activityLog.append(activityEntries);
+        insertTurnDigest(this.db, this.sessionId, digest);
+        insertActivityEntries(this.db, this.sessionId, activityEntries);
+        upsertExtractionState(this.db, this.sessionId, {
+            openErrors: this.errorTracker.getOpenErrors(),
+            testFailed: this.errorTracker.isTestFailed(),
+            recentDecisions: this.recentDecisions.slice(-30),
+            recentConstraints: this.recentConstraints.slice(-30),
+            lastUserIntent: this.lastUserIntent,
+        });
+        return digest;
+    }
+    getLatestDigest() {
+        return this.lastDigest;
+    }
+    getRecentActivity() {
+        return this.activityLog.list();
+    }
+    getCheckpointDraft() {
+        return {
+            lastUserIntent: this.lastUserIntent,
+            openErrors: this.errorTracker.getOpenErrors(),
+            recentDecisions: [...this.recentDecisions],
+            recentConstraints: [...this.recentConstraints],
+            recentActivity: this.activityLog.list(),
+        };
+    }
+}