@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/runtime/harness/system/runtime-memory-policy.js

@@ -8,6 +8,16 @@ function asString(value) {
 function asPositiveInteger(value) {
     return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
 }
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    return items.length > 0 ? Array.from(new Set(items)) : undefined;
+}
 export function normalizeLangMemMemoryKind(kind) {
     const normalized = kind?.trim().toLowerCase();
     if (!normalized) {
@@ -26,14 +36,23 @@ export function readRuntimeMemoryPolicyConfig(runtimeMemory, workspaceRoot) {
         return undefined;
     }
     const retrieval = asRecord(runtimeMemory.retrieval);
+    const writePolicy = asRecord(runtimeMemory.writePolicy);
     const namespaces = asRecord(runtimeMemory.namespaces);
     const workspaceId = path.basename(workspaceRoot) || "default";
+    const writePolicyMode = writePolicy?.mode === "all" || writePolicy?.mode === "selective" || writePolicy?.mode === "disabled"
+        ? writePolicy.mode
+        : "all";
     return {
         enabled: true,
         retrieval: {
             defaultTopK: asPositiveInteger(retrieval?.defaultTopK) ?? 5,
             maxPromptMemories: asPositiveInteger(retrieval?.maxPromptMemories) ?? 8,
         },
+        writePolicy: {
+            mode: writePolicyMode,
+            allow: asStringArray(writePolicy?.allow) ?? [],
+            deny: asStringArray(writePolicy?.deny) ?? [],
+        },
         namespaces: {
             session: asString(namespaces?.sessions) ?? "memories/sessions/{sessionId}",
             workspace: asString(namespaces?.workspaces) ?? `memories/workspaces/${workspaceId}`,
@@ -65,24 +84,53 @@ export function resolveMemoryNamespace(template, values) {
         .map((part) => part.trim())
         .filter((part) => part.length > 0);
 }
-function tokenize(text) {
-    return text
-        .toLowerCase()
-        .split(/[^a-z0-9_]+/i)
-        .map((token) => token.trim())
-        .filter((token) => token.length > 2);
+export function hasExplicitResourceReference(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return false;
+    }
+    return /(https?:\/\/|www\.)/iu.test(normalized);
+}
+export function extractExplicitResourceReferences(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return [];
+    }
+    const matches = normalized.match(/https?:\/\/\S+/giu) ?? [];
+    return Array.from(new Set(matches.map((item) => item.trim().replace(/[),.;:!?]+$/u, ""))))
+        .filter((item) => item.length > 0);
+}
+export function shouldRecallDurableMemory(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return false;
+    }
+    return !hasExplicitResourceReference(normalized);
+}
+function normalizePolicyLabel(value) {
+    return value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
+export function collectMemoryCandidateLabels(candidate) {
+    return Array.from(new Set([
+        ...(candidate.kind ? [normalizePolicyLabel(candidate.kind)] : []),
+        ...(candidate.scope ? [normalizePolicyLabel(candidate.scope)] : []),
+        ...(candidate.sourceType ? [normalizePolicyLabel(candidate.sourceType)] : []),
+        ...((candidate.tags ?? []).map((tag) => normalizePolicyLabel(tag))),
+    ]));
 }
-export function scoreMemoryText(query, content, scopeBoost = 0) {
-    const queryTokens = new Set(tokenize(query));
-    if (queryTokens.size === 0) {
-        return scopeBoost;
+export function shouldStoreMemoryCandidate(policy, candidate) {
+    if (!policy || policy.writePolicy.mode === "all") {
+        return true;
+    }
+    if (policy.writePolicy.mode === "disabled") {
+        return false;
+    }
+    const labels = new Set(collectMemoryCandidateLabels(candidate));
+    if (policy.writePolicy.deny.some((label) => labels.has(normalizePolicyLabel(label)))) {
+        return false;
     }
-    const contentTokens = tokenize(content);
-    let overlap = 0;
-    for (const token of contentTokens) {
-        if (queryTokens.has(token)) {
-            overlap += 1;
-        }
+    if (policy.writePolicy.allow.length === 0) {
+        return true;
     }
-    return overlap + scopeBoost;
+    return policy.writePolicy.allow.some((label) => labels.has(normalizePolicyLabel(label)));
 }

package/dist/runtime/harness/system/runtime-memory-records.js

@@ -23,7 +23,57 @@ function normalizeConfidence(value) {
 function normalizeSourceRef(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+function normalizeOperationalRule(rule) {
+    if (!rule) {
+        return undefined;
+    }
+    const trigger = typeof rule.trigger === "string" ? rule.trigger.trim() : "";
+    const action = typeof rule.action === "string" ? rule.action.trim() : "";
+    const target = typeof rule.target === "string" ? rule.target.trim() : "";
+    if (!trigger || !action || !target) {
+        return undefined;
+    }
+    return {
+        trigger,
+        action,
+        target,
+        ...(rule.effect === "apply" || rule.effect === "invalidate" ? { effect: rule.effect } : {}),
+    };
+}
+function normalizeKnowledgeMutation(mutation) {
+    if (!mutation || typeof mutation !== "object") {
+        return undefined;
+    }
+    const identity = typeof mutation.identity === "string" ? mutation.identity.trim() : "";
+    if (!identity) {
+        return undefined;
+    }
+    const operation = mutation.operation === "update" || mutation.operation === "delete" ? mutation.operation : "create";
+    return { identity, operation };
+}
+function inferKnowledgeMutation(candidate) {
+    const explicit = normalizeKnowledgeMutation(candidate.knowledgeMutation);
+    if (explicit) {
+        return explicit;
+    }
+    const operationalRule = normalizeOperationalRule(candidate.operationalRule);
+    if (operationalRule) {
+        return {
+            identity: `rule:${createFingerprint([operationalRule.trigger, operationalRule.action, operationalRule.target].join("\n"))}`,
+            operation: operationalRule.effect === "invalidate" ? "delete" : "create",
+        };
+    }
+    return undefined;
+}
 function createCanonicalKey(candidate, kind, scope) {
+    const knowledgeMutation = normalizeKnowledgeMutation(candidate.knowledgeMutation);
+    if (knowledgeMutation) {
+        return `${kind}:${scope}:knowledge:${createFingerprint(knowledgeMutation.identity)}`;
+    }
+    const operationalRule = normalizeOperationalRule(candidate.operationalRule);
+    if (operationalRule) {
+        return `${kind}:${scope}:rule:${createFingerprint([operationalRule.trigger, operationalRule.action, operationalRule.target].join("\n"))}`;
+    }
     const sourceRef = normalizeSourceRef(candidate.sourceRef);
     if (sourceRef) {
         return `${kind}:${scope}:source:${createFingerprint(sourceRef)}`;
@@ -105,6 +155,8 @@ function createMemoryRecord(candidate, options) {
         options.recordedAt,
     ].join("\n"));
     const sourceRef = normalizeSourceRef(candidate.sourceRef);
+    const operationalRule = normalizeOperationalRule(candidate.operationalRule);
+    const knowledgeMutation = inferKnowledgeMutation(candidate);
     return {
         id,
         canonicalKey,
@@ -120,6 +172,13 @@ function createMemoryRecord(candidate, options) {
         sourceType: candidate.sourceType?.trim() || "tool-output",
         sourceRefs: sourceRef ? [sourceRef] : [],
         tags: candidate.tags ?? [],
+        ...(knowledgeMutation
+            ? {
+                knowledgeIdentity: knowledgeMutation.identity,
+                knowledgeOperation: knowledgeMutation.operation,
+            }
+            : {}),
+        ...(operationalRule ? { operationalRule } : {}),
         provenance: {
             sessionId: options.sessionId,
             requestId: options.requestId,
@@ -191,6 +250,15 @@ function createReviewRecord(existing, incoming, recordedAt) {
         lastConfirmedAt: recordedAt,
     };
 }
+function archiveRecord(record, incomingRecordId, recordedAt) {
+    return {
+        ...record,
+        status: "archived",
+        lastConfirmedAt: recordedAt,
+        supersedes: mergeUniqueStrings(record.supersedes, [incomingRecordId]),
+        revision: record.revision + 1,
+    };
+}
 async function listStoredRecords(store, scope) {
     const scopes = scope ? [scope] : MEMORY_SCOPES;
     const docs = await Promise.all(scopes.map((currentScope) => store.search(buildScopeNamespace(currentScope))));
@@ -247,6 +315,31 @@ function evaluateDecision(existing, incoming, recordedAt) {
     }
     if (existing.canonicalKey === incoming.canonicalKey ||
         incoming.sourceRefs.some((sourceRef) => existing.sourceRefs.includes(sourceRef))) {
+        if (existing.knowledgeIdentity && incoming.knowledgeIdentity && existing.knowledgeIdentity === incoming.knowledgeIdentity) {
+            const existingOperation = existing.knowledgeOperation ?? "create";
+            const incomingOperation = incoming.knowledgeOperation ?? "create";
+            if (existingOperation !== incomingOperation || !isSameRecordContent(existing, incoming)) {
+                const archivedExisting = archiveRecord(existing, incoming.id, recordedAt);
+                const activeIncoming = {
+                    ...incoming,
+                    supersedes: mergeUniqueStrings(incoming.supersedes, [existing.id]),
+                };
+                return {
+                    decision: {
+                        action: "supersede",
+                        reason: "Stored a newer knowledge mutation that supersedes the previous active state.",
+                        recordId: activeIncoming.id,
+                        kind: activeIncoming.kind,
+                        scope: activeIncoming.scope,
+                        confidence: activeIncoming.confidence,
+                        maintenance: "merge",
+                        reviewRequired: false,
+                    },
+                    primaryRecord: archivedExisting,
+                    additionalRecords: [activeIncoming],
+                };
+            }
+        }
         if (hasNegationSignal(existing.content) !== hasNegationSignal(incoming.content)) {
             const conflictedExisting = markConflicted(existing, incoming.id, recordedAt);
             const pendingReview = createReviewRecord(conflictedExisting, incoming, recordedAt);
@@ -348,6 +441,13 @@ export function renderMemoryRecordsMarkdown(title, records) {
         lines.push(`- scope: ${record.scope}`);
         lines.push(`- status: ${record.status}`);
         lines.push(`- confidence: ${record.confidence.toFixed(2)}`);
+        if (record.knowledgeIdentity) {
+            lines.push(`- knowledge_identity: ${record.knowledgeIdentity}`);
+            lines.push(`- knowledge_operation: ${record.knowledgeOperation ?? "create"}`);
+        }
+        if (record.operationalRule) {
+            lines.push(`- operational_rule: ${record.operationalRule.trigger} -> ${record.operationalRule.action}(${record.operationalRule.target}) [${record.operationalRule.effect ?? "apply"}]`);
+        }
         if (record.tags.length > 0) {
             lines.push(`- tags: ${record.tags.join(", ")}`);
         }

package/dist/runtime/harness/system/runtime-memory-sync.js

@@ -88,8 +88,8 @@ export function readRuntimeMemorySyncConfig(runtimeMemory) {
         return undefined;
     }
     const ingestion = asRecord(runtimeMemory.ingestion);
-    const writeOnApprovalResolution = asBoolean(ingestion?.writeOnApprovalResolution) ?? true;
-    const writeOnRequestCompletion = asBoolean(ingestion?.writeOnRequestCompletion) ?? true;
+    const writeOnApprovalResolution = asBoolean(ingestion?.writeOnApprovalResolution) ?? false;
+    const writeOnRequestCompletion = asBoolean(ingestion?.writeOnRequestCompletion) ?? false;
     if (!writeOnApprovalResolution && !writeOnRequestCompletion) {
         return undefined;
     }

package/dist/runtime/harness/system/store.d.ts

@@ -57,6 +57,10 @@ export declare class SqliteBackedStore {
     constructor(filePath: string);
     private getClient;
     private ensureInitialized;
+    private ensureKnowledgeRecordEntryColumns;
+    private backfillKnowledgeRecordEntries;
+    private upsertKnowledgeRecordEntry;
+    private deleteKnowledgeRecordEntry;
     private selectAll;
     batch(operations: Array<Record<string, unknown>>): Promise<readonly unknown[]>;
     get(namespace: string[], key: string): Promise<{

package/dist/runtime/harness/system/store.js

@@ -65,6 +65,45 @@ function parseRow(row) {
         updatedAt: new Date(row.updated_at),
     };
 }
+function isKnowledgeRecordNamespace(namespace) {
+    return namespace.length === 3 && namespace[0] === "memories" && namespace[1] === "records";
+}
+function extractKnowledgeRecordEntry(namespace, key, value, createdAt, updatedAt) {
+    if (!isKnowledgeRecordNamespace(namespace) || typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const typed = value;
+    const recordId = typeof typed.id === "string" ? typed.id : undefined;
+    const scope = typeof typed.scope === "string" ? typed.scope : undefined;
+    const kind = typeof typed.kind === "string" ? typed.kind : undefined;
+    const status = typeof typed.status === "string" ? typed.status : undefined;
+    const canonicalKey = typeof typed.canonicalKey === "string" ? typed.canonicalKey : undefined;
+    const sourceType = typeof typed.sourceType === "string" ? typed.sourceType : undefined;
+    const summary = typeof typed.summary === "string" ? typed.summary : undefined;
+    const content = typeof typed.content === "string" ? typed.content : undefined;
+    if (!recordId || !scope || !kind || !status || !canonicalKey || !sourceType || !summary || !content) {
+        return null;
+    }
+    return {
+        namespace: serializeNamespace(namespace),
+        key,
+        record_id: recordId,
+        scope,
+        kind,
+        status,
+        canonical_key: canonicalKey,
+        source_type: sourceType,
+        knowledge_identity: typeof typed.knowledgeIdentity === "string" ? typed.knowledgeIdentity : null,
+        knowledge_operation: typeof typed.knowledgeOperation === "string" ? typed.knowledgeOperation : null,
+        summary_text: summary,
+        content_text: content,
+        confidence: typeof typed.confidence === "number" ? typed.confidence : null,
+        observed_at: typeof typed.observedAt === "string" ? typed.observedAt : null,
+        last_confirmed_at: typeof typed.lastConfirmedAt === "string" ? typed.lastConfirmedAt : null,
+        created_at: createdAt,
+        updated_at: updatedAt,
+    };
+}
 export class FileBackedStore {
     filePath;
     delegate = new InMemoryStore();
@@ -186,11 +225,117 @@ export class SqliteBackedStore {
         )
       `);
             await client.execute("CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace)");
+            await client.execute(`
+        CREATE TABLE IF NOT EXISTS knowledge_record_entries (
+          namespace TEXT NOT NULL,
+          key TEXT NOT NULL,
+          record_id TEXT NOT NULL,
+          scope TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          status TEXT NOT NULL,
+          canonical_key TEXT NOT NULL,
+          source_type TEXT NOT NULL,
+          knowledge_identity TEXT,
+          knowledge_operation TEXT,
+          summary_text TEXT NOT NULL,
+          content_text TEXT NOT NULL,
+          confidence REAL,
+          observed_at TEXT,
+          last_confirmed_at TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (namespace, key)
+        )
+      `);
+            await this.ensureKnowledgeRecordEntryColumns(client);
+            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_scope_status ON knowledge_record_entries(scope, status)");
+            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_canonical_key ON knowledge_record_entries(canonical_key)");
+            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_knowledge_identity ON knowledge_record_entries(knowledge_identity)");
+            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_record_id ON knowledge_record_entries(record_id)");
+            await this.backfillKnowledgeRecordEntries(client);
             this.initialized = true;
             this.initialization = null;
         })();
         await this.initialization;
     }
+    async ensureKnowledgeRecordEntryColumns(client) {
+        const result = await client.execute("PRAGMA table_info(knowledge_record_entries)");
+        const existing = new Set(result.rows.map((row) => String(row.name ?? "")));
+        if (!existing.has("knowledge_identity")) {
+            await client.execute("ALTER TABLE knowledge_record_entries ADD COLUMN knowledge_identity TEXT");
+        }
+        if (!existing.has("knowledge_operation")) {
+            await client.execute("ALTER TABLE knowledge_record_entries ADD COLUMN knowledge_operation TEXT");
+        }
+    }
+    async backfillKnowledgeRecordEntries(client) {
+        const countResult = await client.execute("SELECT COUNT(*) AS count FROM knowledge_record_entries");
+        const count = Number(countResult.rows?.[0]?.count ?? 0);
+        if (count > 0) {
+            return;
+        }
+        const result = await client.execute({
+            sql: `SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+            FROM store_entries
+            WHERE namespace LIKE ?`,
+            args: [`memories${NAMESPACE_SEPARATOR}records${NAMESPACE_SEPARATOR}%`],
+        });
+        for (const row of result.rows) {
+            const namespace = JSON.parse(row.namespace_json);
+            const entry = extractKnowledgeRecordEntry(namespace, row.key, decodeValue(JSON.parse(row.value_json)), row.created_at, row.updated_at);
+            if (entry) {
+                await this.upsertKnowledgeRecordEntry(client, entry);
+            }
+        }
+    }
+    async upsertKnowledgeRecordEntry(client, entry) {
+        await client.execute({
+            sql: `INSERT INTO knowledge_record_entries (
+         namespace, key, record_id, scope, kind, status, canonical_key, source_type,
+         knowledge_identity, knowledge_operation, summary_text, content_text, confidence, observed_at, last_confirmed_at, created_at, updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(namespace, key) DO UPDATE SET
+         record_id = excluded.record_id,
+         scope = excluded.scope,
+         kind = excluded.kind,
+         status = excluded.status,
+         canonical_key = excluded.canonical_key,
+         source_type = excluded.source_type,
+         knowledge_identity = excluded.knowledge_identity,
+         knowledge_operation = excluded.knowledge_operation,
+         summary_text = excluded.summary_text,
+         content_text = excluded.content_text,
+         confidence = excluded.confidence,
+         observed_at = excluded.observed_at,
+         last_confirmed_at = excluded.last_confirmed_at,
+         updated_at = excluded.updated_at`,
+            args: [
+                entry.namespace,
+                entry.key,
+                entry.record_id,
+                entry.scope,
+                entry.kind,
+                entry.status,
+                entry.canonical_key,
+                entry.source_type,
+                entry.knowledge_identity,
+                entry.knowledge_operation,
+                entry.summary_text,
+                entry.content_text,
+                entry.confidence,
+                entry.observed_at,
+                entry.last_confirmed_at,
+                entry.created_at,
+                entry.updated_at,
+            ],
+        });
+    }
+    async deleteKnowledgeRecordEntry(client, namespace, key) {
+        await client.execute({
+            sql: `DELETE FROM knowledge_record_entries WHERE namespace = ? AND key = ?`,
+            args: [serializeNamespace(namespace), key],
+        });
+    }
     async selectAll(sql, args = []) {
         await this.ensureInitialized();
         const client = await this.getClient();
@@ -246,6 +391,13 @@ export class SqliteBackedStore {
          updated_at = excluded.updated_at`,
             args: [serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now],
         });
+        const knowledgeEntry = extractKnowledgeRecordEntry(namespace, key, value, now, now);
+        if (knowledgeEntry) {
+            await this.upsertKnowledgeRecordEntry(client, knowledgeEntry);
+        }
+        else {
+            await this.deleteKnowledgeRecordEntry(client, namespace, key);
+        }
     }
     async delete(namespace, key) {
         await this.ensureInitialized();
@@ -254,6 +406,7 @@ export class SqliteBackedStore {
             sql: `DELETE FROM store_entries WHERE namespace = ? AND key = ?`,
             args: [serializeNamespace(namespace), key],
         });
+        await this.deleteKnowledgeRecordEntry(client, namespace, key);
     }
     async listNamespaces() {
         const rows = await this.selectAll(`SELECT DISTINCT namespace_json

package/dist/runtime/harness.d.ts

@@ -1,7 +1,8 @@
-import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, RuntimeOperatorOverview, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RequestOptions, RequestRecord, RequestResult, RequestSummary, RequestStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeArtifactWriteInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRequestPackage, RuntimeRequestPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, SessionSummary, SessionRecord, SessionListSummary, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, RuntimeOperatorOverview, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RequestPlanState, RequestOptions, RequestRecord, RequestResult, RequestSummary, RequestStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeArtifactWriteInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRequestPackage, RuntimeRequestPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, SessionSummary, SessionRecord, SessionListSummary, WorkspaceBundle } from "../contracts/types.js";
 import { type RuntimeMcpServerOptions, type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
+import { SystemScheduleManager } from "./scheduling/system-schedule-manager.js";
 export declare class AgentHarnessRuntime {
     private readonly workspace;
     private readonly runtimeAdapterOptions;
@@ -36,6 +37,7 @@ export declare class AgentHarnessRuntime {
     private readonly runtimeMemoryFormationSync;
     private readonly unregisterRuntimeMemoryFormationSync;
     private readonly resolvedRuntimeAdapterOptions;
+    private readonly scheduleManager;
     private readonly healthMonitor;
     private readonly recoveryConfig;
     private readonly concurrencyConfig;
@@ -54,7 +56,11 @@ export declare class AgentHarnessRuntime {
     private getDefaultRuntimeEntryAgentId;
     private resolveSelectedAgentId;
     private createPrepareRunStartRuntime;
+    private buildFunctionToolContext;
     constructor(workspace: WorkspaceBundle, runtimeAdapterOptions?: RuntimeAdapterOptions);
+    manageSchedule(input: Parameters<SystemScheduleManager["manageSchedule"]>[0]): Promise<import("../contracts/runtime.js").RuntimeScheduleManageResult>;
+    getSchedule(scheduleId: string): Promise<import("../contracts/runtime.js").RuntimeScheduleRecord | null>;
+    runScheduledTask(scheduleId: string): Promise<RequestResult>;
     private createHealthMonitor;
     private recordLlmSuccess;
     private recordLlmFailure;
@@ -81,6 +87,7 @@ export declare class AgentHarnessRuntime {
     updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
     removeMemory(input: RemoveMemoryInput): Promise<MemoryRecord>;
     getRequest(requestId: string): Promise<RequestRecord | null>;
+    getRequestPlanState(sessionId: string, requestId: string): Promise<RequestPlanState | null>;
     private getSessionSummary;
     private getSessionSummaryRecord;
     getSession(sessionId: string): Promise<SessionRecord | null>;
@@ -128,6 +135,7 @@ export declare class AgentHarnessRuntime {
     private getWorkspaceId;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
+    private persistRequestPlanState;
     private resolvePersistedRequestPriority;
     private enqueuePendingRequestSlot;
     private executeQueuedRequest;