@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/knowledge/module.js

@@ -2,7 +2,7 @@ import { createPersistentId } from "../utils/id.js";
 import { findMemoryRecordById, getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, removeMemoryRecord, updateMemoryRecord, } from "../runtime/harness/system/runtime-memory-records.js";
 import { consolidateStructuredMemoryScope } from "../runtime/harness/system/runtime-memory-consolidation.js";
 import { renderMemoryCandidatesMarkdown } from "../runtime/harness/system/runtime-memory-candidates.js";
-import { normalizeLangMemMemoryKind, scoreMemoryText, } from "../runtime/harness/system/runtime-memory-policy.js";
+import { shouldRecallDurableMemory, normalizeLangMemMemoryKind, shouldStoreMemoryCandidate, } from "../runtime/harness/system/runtime-memory-policy.js";
 const ALL_SCOPES = ["session", "agent", "workspace", "user", "project"];
 const TITLE_BY_SCOPE = {
     session: "Session Structured Memory",
@@ -25,6 +25,24 @@ function normalizeRuntimeContext(context) {
 function summarizeMemoryContent(content) {
     return (content.trim().split("\n")[0] || content.trim()).slice(0, 240);
 }
+function normalizeMemoryScope(scope) {
+    if (scope === "agent" || scope === "workspace" || scope === "user" || scope === "project") {
+        return scope;
+    }
+    return "session";
+}
+function extractCandidateScopeOptions(candidate) {
+    if (candidate.scope) {
+        return [normalizeMemoryScope(candidate.scope)];
+    }
+    const provenance = typeof candidate.provenance === "object" && candidate.provenance !== null && !Array.isArray(candidate.provenance)
+        ? candidate.provenance
+        : undefined;
+    const scopeOptions = Array.isArray(provenance?.scopeOptions)
+        ? provenance.scopeOptions.filter((item) => item === "session" || item === "agent" || item === "workspace" || item === "user" || item === "project")
+        : [];
+    return scopeOptions.length > 0 ? Array.from(new Set(scopeOptions)) : ["session"];
+}
 function resolveRecallScopes(input, context) {
     if (Array.isArray(input.scopes) && input.scopes.length > 0) {
         return Array.from(new Set(input.scopes));
@@ -88,14 +106,268 @@ function getMemoryScopeBoost(scope) {
 function memoryFreshnessBoost(value) {
     return Math.max(0, 1 - ((Date.now() - Date.parse(value)) / (1000 * 60 * 60 * 24 * 365)));
 }
-function scoreStructuredRecord(query, record) {
-    return (scoreMemoryText(query, `${record.summary}\n${record.content}`, getMemoryScopeBoost(record.scope)) +
+function scoreStructuredRecord(record) {
+    return (getMemoryScopeBoost(record.scope) +
         memoryFreshnessBoost(record.lastConfirmedAt) +
         record.confidence);
 }
+function characterGramSet(value) {
+    const normalized = normalizeCompareText(value).replace(/\s+/g, "");
+    const grams = new Set();
+    if (normalized.length < 2) {
+        if (normalized.length > 0) {
+            grams.add(normalized);
+        }
+        return grams;
+    }
+    for (let index = 0; index < normalized.length - 1; index += 1) {
+        grams.add(normalized.slice(index, index + 2));
+    }
+    return grams;
+}
+function characterGramSimilarity(left, right) {
+    const leftGrams = characterGramSet(left);
+    const rightGrams = characterGramSet(right);
+    if (leftGrams.size === 0 || rightGrams.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    for (const gram of leftGrams) {
+        if (rightGrams.has(gram)) {
+            intersection += 1;
+        }
+    }
+    const union = new Set([...leftGrams, ...rightGrams]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+function textSimilarity(left, right) {
+    return Math.max(jaccardTextSimilarity(left, right), characterGramSimilarity(left, right));
+}
+function scoreStructuredRecordForQuery(record, query) {
+    let score = scoreStructuredRecord(record);
+    score += textSimilarity(record.summary, query) * 5;
+    score += textSimilarity(record.content, query) * 4;
+    if (record.knowledgeIdentity) {
+        score += textSimilarity(record.knowledgeIdentity, query) * 2;
+    }
+    if (record.operationalRule) {
+        score += textSimilarity(record.operationalRule.trigger, query) * 3;
+        score += textSimilarity(record.operationalRule.target, query) * 2;
+        if (record.operationalRule.effect === "invalidate" || record.knowledgeOperation === "delete") {
+            score += 0.5;
+        }
+    }
+    return score;
+}
 function normalizeMemoryDedupKey(record) {
     return `${record.scope}::${record.summary.toLowerCase().replace(/\s+/g, " ").trim()}::${record.content.toLowerCase().replace(/\s+/g, " ").trim()}`;
 }
+function normalizeCompareText(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function tokenizeText(value) {
+    return new Set(value
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/i)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2));
+}
+function jaccardTextSimilarity(left, right) {
+    const leftTokens = tokenizeText(left);
+    const rightTokens = tokenizeText(right);
+    if (leftTokens.size === 0 || rightTokens.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    for (const token of leftTokens) {
+        if (rightTokens.has(token)) {
+            intersection += 1;
+        }
+    }
+    const union = new Set([...leftTokens, ...rightTokens]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+function containsDeletionSignal(value) {
+    const normalized = normalizeCompareText(value);
+    if (!normalized) {
+        return false;
+    }
+    return [
+        "delete",
+        "deleted",
+        "remove",
+        "removed",
+        "revoked",
+        "forbidden",
+        "not allowed",
+        "no longer",
+        "unavailable",
+        "disabled",
+        "deprecated",
+        "取消",
+        "撤销",
+        "删除",
+        "已删除",
+        "删掉",
+        "移除",
+        "不再",
+        "不可用",
+        "不能",
+        "无法",
+        "禁用",
+        "废弃",
+    ].some((signal) => normalized.includes(signal));
+}
+function extractSalientLiterals(value) {
+    const results = new Set();
+    const normalized = value.trim();
+    if (!normalized) {
+        return results;
+    }
+    for (const match of normalized.matchAll(/[`'"]([^`'"]{1,64})[`'"]/g)) {
+        const literal = match[1]?.trim().toLowerCase();
+        if (literal && literal.length >= 2) {
+            results.add(literal);
+        }
+    }
+    for (const match of normalized.matchAll(/\b[a-z][a-z0-9._/-]{1,63}\b/gi)) {
+        const token = match[0]?.trim().toLowerCase();
+        if (token && !["system", "startup", "command", "memory", "instruction", "user", "deleted"].includes(token)) {
+            results.add(token);
+        }
+    }
+    return results;
+}
+function sharesSalientLiteral(left, right) {
+    const leftLiterals = extractSalientLiterals(left);
+    const rightLiterals = extractSalientLiterals(right);
+    if (leftLiterals.size === 0 || rightLiterals.size === 0) {
+        return false;
+    }
+    for (const literal of leftLiterals) {
+        if (rightLiterals.has(literal)) {
+            return true;
+        }
+    }
+    return false;
+}
+function mergeScoredRecords(...groups) {
+    const merged = new Map();
+    for (const group of groups) {
+        for (const item of group) {
+            const existing = merged.get(item.record.id);
+            if (!existing || item.score > existing.score) {
+                merged.set(item.record.id, item);
+            }
+        }
+    }
+    return Array.from(merged.values())
+        .sort((left, right) => right.score - left.score || right.record.lastConfirmedAt.localeCompare(left.record.lastConfirmedAt))
+        .map((item) => item.record);
+}
+function selectRelevantExistingRecords(candidates, existingRecords) {
+    const scored = new Map();
+    for (const candidate of candidates) {
+        const candidateScopes = new Set(extractCandidateScopeOptions(candidate));
+        const content = normalizeCompareText(candidate.content);
+        const summary = normalizeCompareText(candidate.summary ?? summarizeMemoryContent(candidate.content));
+        const sourceRef = typeof candidate.sourceRef === "string" ? candidate.sourceRef.trim() : "";
+        const candidateText = `${candidate.summary ?? ""}\n${candidate.content}`;
+        const deletionSignal = containsDeletionSignal(candidateText);
+        for (const record of existingRecords) {
+            if (!candidateScopes.has(record.scope)) {
+                continue;
+            }
+            let score = 0;
+            let deterministicMatch = false;
+            if (sourceRef && record.sourceRefs.includes(sourceRef)) {
+                score += 10;
+                deterministicMatch = true;
+            }
+            if (normalizeCompareText(record.content) === content) {
+                score += 9;
+                deterministicMatch = true;
+            }
+            if (normalizeCompareText(record.summary) === summary) {
+                score += 8;
+                deterministicMatch = true;
+            }
+            const similarityScore = textSimilarity(record.summary, candidate.summary ?? candidate.content) * 4
+                + textSimilarity(record.content, candidate.content) * 3;
+            score += similarityScore;
+            if (deletionSignal) {
+                const ruleTarget = record.operationalRule?.target?.trim().toLowerCase();
+                if (ruleTarget && candidateText.toLowerCase().includes(ruleTarget)) {
+                    score += 12;
+                    deterministicMatch = true;
+                }
+                if (sharesSalientLiteral(candidateText, `${record.summary}\n${record.content}`)) {
+                    score += 8;
+                    deterministicMatch = true;
+                }
+            }
+            if (!deterministicMatch && similarityScore < 1) {
+                continue;
+            }
+            if (score <= 0) {
+                continue;
+            }
+            const existing = scored.get(record.id);
+            if (!existing || score > existing.score) {
+                scored.set(record.id, { record, score });
+            }
+        }
+    }
+    return Array.from(scored.values())
+        .sort((left, right) => right.score - left.score || right.record.lastConfirmedAt.localeCompare(left.record.lastConfirmedAt))
+        .map((item) => item.record);
+}
+async function selectVectorRelevantExistingRecords(input) {
+    const vectorStore = await input.resolveVectorStore();
+    if (!vectorStore) {
+        return [];
+    }
+    const existingById = new Map(input.existingRecords.map((record) => [record.id, record]));
+    const scored = new Map();
+    try {
+        for (const candidate of input.candidates) {
+            const candidateScopes = new Set(extractCandidateScopeOptions(candidate));
+            const query = [candidate.summary?.trim(), candidate.content.trim()].filter((value) => !!value && value.length > 0).join("\n");
+            if (!query) {
+                continue;
+            }
+            const hits = await vectorStore.similaritySearch(query, 8);
+            for (const hit of hits) {
+                const metadata = typeof hit.metadata === "object" && hit.metadata !== null && !Array.isArray(hit.metadata)
+                    ? hit.metadata
+                    : {};
+                const recordId = typeof metadata.recordId === "string" ? metadata.recordId : undefined;
+                if (!recordId) {
+                    continue;
+                }
+                const record = existingById.get(recordId);
+                if (!record || record.status !== "active" || !candidateScopes.has(record.scope)) {
+                    continue;
+                }
+                const score = (typeof hit.score === "number" ? hit.score : 0) + scoreStructuredRecordForQuery(record, query);
+                const existing = scored.get(record.id);
+                if (!existing || score > existing.score) {
+                    scored.set(record.id, { record, score });
+                }
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return Array.from(scored.values())
+        .sort((left, right) => right.score - left.score || right.record.lastConfirmedAt.localeCompare(left.record.lastConfirmedAt));
+}
+function sortPromptRecallRecords(items) {
+    return [...items].sort((left, right) => left.record.observedAt.localeCompare(right.record.observedAt)
+        || left.record.createdAt.localeCompare(right.record.createdAt)
+        || left.record.id.localeCompare(right.record.id));
+}
 function inferMem0MemoryKind(hit) {
     const candidates = [
         ...hit.categories,
@@ -187,7 +459,10 @@ export class DefaultKnowledgeModule {
             requestId,
             sessionId,
             recordedAt,
-        }, { storeCandidateLog: input.storeCandidateLog !== false });
+        }, {
+            storeCandidateLog: input.storeCandidateLog !== false,
+            forceStore: input.forceStore === true,
+        });
     }
     async recall(input, context) {
         if (typeof input.query !== "string" || input.query.trim().length === 0) {
@@ -211,7 +486,10 @@ export class DefaultKnowledgeModule {
             .map(({ record }) => record);
         return { items };
     }
-    async buildPromptContext(input, context) {
+    async buildPromptRecall(input, context) {
+        if (!shouldRecallDurableMemory(input.query)) {
+            return { items: [] };
+        }
         const normalizedContext = normalizeRuntimeContext(context);
         const ranked = (await this.rankRecallCandidates({
             query: input.query,
@@ -230,6 +508,8 @@ export class DefaultKnowledgeModule {
                         ? 2
                         : 1;
             return {
+                record: item.record,
+                scope: item.record.scope,
                 content: [
                     `# Durable ${item.record.scope[0].toUpperCase()}${item.record.scope.slice(1)} Memory`,
                     "",
@@ -237,20 +517,38 @@ export class DefaultKnowledgeModule {
                     `- kind: ${item.record.kind}`,
                     `- scope: ${item.record.scope}`,
                     `- confidence: ${item.record.confidence.toFixed(2)}`,
+                    ...(item.record.knowledgeIdentity
+                        ? [
+                            `- knowledge_identity: ${item.record.knowledgeIdentity}`,
+                            `- knowledge_operation: ${item.record.knowledgeOperation ?? "create"}`,
+                        ]
+                        : []),
                     "",
                     item.record.content,
                 ].join("\n"),
-                score: scoreMemoryText(input.query, `${item.record.summary}\n${item.record.content}`, scopeBoost) +
+                score: scopeBoost +
                     memoryFreshnessBoost(item.record.lastConfirmedAt) +
                     item.record.confidence,
             };
         })
-            .sort((left, right) => right.score - left.score)
-            .slice(0, this.deps.policy?.retrieval.maxPromptMemories ?? 8);
+            .sort((left, right) => right.score - left.score);
         if (ranked.length === 0) {
-            return undefined;
+            return { items: [] };
         }
-        return ranked.map((entry) => entry.content).join("\n\n");
+        const maxPromptMemories = this.deps.policy?.retrieval.maxPromptMemories ?? 8;
+        const selected = ranked.slice(0, maxPromptMemories);
+        if (selected.length === 0) {
+            return { items: [] };
+        }
+        const orderedSelected = sortPromptRecallRecords(selected);
+        return {
+            items: orderedSelected.map((entry) => entry.record),
+            context: orderedSelected.map((entry) => entry.content).join("\n\n"),
+        };
+    }
+    async buildPromptContext(input, context) {
+        const promptRecall = await this.buildPromptRecall(input, context);
+        return promptRecall.context;
     }
     async list(input = {}, context) {
         const normalizedContext = { ...context };
@@ -305,6 +603,12 @@ export class DefaultKnowledgeModule {
             tags: Array.isArray(input.tags)
                 ? Array.from(new Set(input.tags.map((item) => item.trim()).filter((item) => item.length > 0)))
                 : existing.tags,
+            knowledgeIdentity: typeof input.knowledgeIdentity === "string" && input.knowledgeIdentity.trim().length > 0
+                ? input.knowledgeIdentity.trim()
+                : existing.knowledgeIdentity,
+            knowledgeOperation: input.knowledgeOperation === "create" || input.knowledgeOperation === "update" || input.knowledgeOperation === "delete"
+                ? input.knowledgeOperation
+                : existing.knowledgeOperation,
             observedAt: typeof input.observedAt === "string" && input.observedAt.trim().length > 0 ? input.observedAt : existing.observedAt,
             lastConfirmedAt: typeof input.lastConfirmedAt === "string" && input.lastConfirmedAt.trim().length > 0
                 ? input.lastConfirmedAt
@@ -339,21 +643,39 @@ export class DefaultKnowledgeModule {
         if (validCandidates.length === 0) {
             return { records: [], decisions: [] };
         }
-        const existingRecords = await listMemoryRecordsForScopes(this.deps.store, ALL_SCOPES);
+        const relevantScopes = Array.from(new Set(validCandidates.flatMap((candidate) => extractCandidateScopeOptions(candidate))));
+        const existingRecords = await listMemoryRecordsForScopes(this.deps.store, relevantScopes);
+        const vectorRelatedExistingRecords = await selectVectorRelevantExistingRecords({
+            candidates: validCandidates,
+            existingRecords,
+            resolveVectorStore: this.deps.resolveVectorStore,
+        });
+        const deterministicRelatedExistingRecords = selectRelevantExistingRecords(validCandidates, existingRecords)
+            .map((record) => ({
+            record,
+            score: scoreStructuredRecord(record),
+        }));
+        const relatedExistingRecords = mergeScoredRecords(vectorRelatedExistingRecords, deterministicRelatedExistingRecords);
         const transformedCandidates = this.deps.transformCandidates
-            ? await this.deps.transformCandidates({ candidates: validCandidates, context: normalizedContext, existingRecords })
+            ? await this.deps.transformCandidates({ candidates: validCandidates, context: normalizedContext, existingRecords: relatedExistingRecords })
             : validCandidates;
+        const storedCandidates = options.forceStore === true
+            ? transformedCandidates
+            : transformedCandidates.filter((candidate) => shouldStoreMemoryCandidate(this.deps.policy, candidate));
+        if (storedCandidates.length === 0) {
+            return { records: [], decisions: [] };
+        }
         if (options.storeCandidateLog) {
             await this.deps.store.put(["memories", "candidates", normalizedContext.sessionId ?? `memory-api-${normalizedContext.requestId ?? "unknown"}`], `${normalizedContext.requestId}.json`, {
                 requestId: normalizedContext.requestId,
                 sessionId: normalizedContext.sessionId,
                 storedAt: normalizedContext.recordedAt,
-                candidates: transformedCandidates,
+                candidates: storedCandidates,
             });
         }
         const persisted = await persistStructuredMemoryRecords({
             store: this.deps.store,
-            candidates: transformedCandidates,
+            candidates: storedCandidates,
             sessionId: normalizedContext.sessionId ?? `memory-api-${normalizedContext.requestId ?? "unknown"}`,
             requestId: normalizedContext.requestId ?? createPersistentId(new Date(normalizedContext.recordedAt ?? new Date().toISOString())),
             agentId: normalizedContext.agentId,
@@ -363,7 +685,7 @@ export class DefaultKnowledgeModule {
             recordedAt: normalizedContext.recordedAt ?? new Date().toISOString(),
         });
         await this.rebuildVectorIndex();
-        await this.refreshAfterWrite(transformedCandidates, normalizedContext);
+        await this.refreshAfterWrite(storedCandidates, normalizedContext);
         return persisted;
     }
     async refreshAfterWrite(candidates, context) {
@@ -489,7 +811,7 @@ export class DefaultKnowledgeModule {
             .filter((record) => (input.kinds ? input.kinds.has(record.kind) : true))
             .map((record) => ({
             record,
-            score: scoreStructuredRecord(input.query, record),
+            score: scoreStructuredRecordForQuery(record, input.query),
         }));
         const deduped = new Map();
         for (const item of ranked) {
@@ -528,7 +850,7 @@ export class DefaultKnowledgeModule {
                         continue;
                     }
                     const key = normalizeMemoryDedupKey(canonical);
-                    const score = scoreStructuredRecord(input.query, canonical) + (typeof hit.score === "number" ? hit.score : 0);
+                    const score = scoreStructuredRecordForQuery(canonical, input.query) + (typeof hit.score === "number" ? hit.score : 0);
                     const existing = deduped.get(key);
                     if (!existing || score > existing.score) {
                         deduped.set(key, { record: canonical, score });
@@ -571,7 +893,7 @@ export class DefaultKnowledgeModule {
                 }
                 deduped.set(key, {
                     record,
-                    score: scoreStructuredRecord(input.query, record) + Math.max(0, Math.min(1, hit.score)) * 4,
+                    score: scoreStructuredRecordForQuery(record, input.query) + Math.max(0, Math.min(1, hit.score)) * 4,
                 });
             }
             return Array.from(deduped.values()).sort((left, right) => right.score - left.score);

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.297";
+export declare const AGENT_HARNESS_VERSION = "0.0.299";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.297";
+export const AGENT_HARNESS_VERSION = "0.0.299";

package/dist/persistence/file-store.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RequestSummary, RequestState, SessionRequestRecord, SessionSummary, TranscriptMessage } from "../contracts/types.js";
+import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RequestPlanState, RequestSummary, RequestState, SessionRequestRecord, SessionSummary, TranscriptMessage } from "../contracts/types.js";
 import type { ApprovalFilter, PersistedSessionListSummary, PersistedRequestInput, PersistedRequestControlRecord, PersistedRunInspection, PersistedRequestQueueRecord, PersistenceLifecycle as Lifecycle, PersistenceRequestMeta as RequestMeta, RuntimePersistence, RecoveryIntent, PersistenceSessionMeta as SessionMeta, RequestSummaryFilter, SessionSummaryFilter } from "./types.js";
 type RequestIndexRecord = {
     requestId: string;
@@ -17,6 +17,7 @@ export declare class FilePersistence implements RuntimePersistence {
     private requestQueuePath;
     private requestControlPath;
     private traceItemsPath;
+    private requestPlanStatePath;
     private writeSessionHead;
     initialize(): Promise<void>;
     sessionDir(sessionId: string): string;
@@ -73,6 +74,9 @@ export declare class FilePersistence implements RuntimePersistence {
     clearRequestInput(sessionId: string, requestId: string): Promise<void>;
     createApproval(record: InternalApprovalRecord): Promise<void>;
     resolveApproval(sessionId: string, requestId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
+    saveRequestPlanState(sessionId: string, requestId: string, planState: RequestPlanState): Promise<void>;
+    getRequestPlanState(sessionId: string, requestId: string): Promise<RequestPlanState | null>;
+    clearRequestPlanState(sessionId: string, requestId: string): Promise<void>;
     createRequestArtifact(sessionId: string, requestId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
     listRequestArtifacts(sessionId: string, requestId: string): Promise<ArtifactListing>;
     readRequestArtifact(sessionId: string, requestId: string, artifactPath: string): Promise<unknown>;

package/dist/persistence/file-store.js

@@ -31,6 +31,9 @@ export class FilePersistence {
     traceItemsPath(sessionId, requestId) {
         return path.join(this.requestDir(sessionId, requestId), "trace-items.ndjson");
     }
+    requestPlanStatePath(sessionId, requestId) {
+        return path.join(this.requestDir(sessionId, requestId), "plan-state.json");
+    }
     async writeSessionHead(sessionId, input) {
         const sessionMetaPath = path.join(this.sessionDir(sessionId), "meta.json");
         const sessionMeta = await readJson(sessionMetaPath);
@@ -540,6 +543,19 @@ export class FilePersistence {
         ]);
         return updated;
     }
+    async saveRequestPlanState(sessionId, requestId, planState) {
+        await writeJson(this.requestPlanStatePath(sessionId, requestId), planState);
+    }
+    async getRequestPlanState(sessionId, requestId) {
+        const planStatePath = this.requestPlanStatePath(sessionId, requestId);
+        if (!(await fileExists(planStatePath))) {
+            return null;
+        }
+        return readJson(planStatePath);
+    }
+    async clearRequestPlanState(sessionId, requestId) {
+        await rm(this.requestPlanStatePath(sessionId, requestId), { force: true });
+    }
     async createRequestArtifact(sessionId, requestId, artifact, content) {
         const requestDir = this.requestDir(sessionId, requestId);
         await writeJson(path.join(requestDir, artifact.path), content);

package/dist/persistence/sqlite-store.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RequestSummary, RequestState, SessionRequestRecord, SessionSummary, TranscriptMessage } from "../contracts/types.js";
+import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RequestPlanState, RequestSummary, RequestState, SessionRequestRecord, SessionSummary, TranscriptMessage } from "../contracts/types.js";
 import type { PersistedSessionListSummary, PersistenceSessionMeta, PersistedRequestInput, PersistedRequestControlRecord, PersistedRunInspection, PersistedRequestQueueRecord, PersistenceLifecycle, PersistenceRequestMeta, RecoveryIntent, RuntimePersistence, ApprovalFilter, RequestSummaryFilter, SessionSummaryFilter } from "./types.js";
 export declare function listProtectedCheckpointSessionIds(dbPath: string): Promise<Set<string>>;
 export declare class SqlitePersistence implements RuntimePersistence {
@@ -92,6 +92,9 @@ export declare class SqlitePersistence implements RuntimePersistence {
     clearRequestInput(sessionId: string, requestId: string): Promise<void>;
     createApproval(record: InternalApprovalRecord): Promise<void>;
     resolveApproval(sessionId: string, requestId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
+    saveRequestPlanState(sessionId: string, requestId: string, planState: RequestPlanState): Promise<void>;
+    getRequestPlanState(sessionId: string, requestId: string): Promise<RequestPlanState | null>;
+    clearRequestPlanState(sessionId: string, requestId: string): Promise<void>;
     createRequestArtifact(sessionId: string, requestId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
     listRequestArtifacts(sessionId: string, requestId: string): Promise<ArtifactListing>;
     appendSessionMessage(sessionId: string, message: TranscriptMessage): Promise<void>;