@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/knowledge/packet.js

@@ -0,0 +1,278 @@
+import { emitKnowledgePacketBuilt } from '../runtime/emitters/index.js';
+import { DEFAULT_PACKET_BUDGET, DEFAULT_PACKET_LIMIT, estimateTokens, isSourcePastRefreshWindow, renderPacket, scoreHaystack, summarizeCompact, tokenize, trimForDetail, } from './internal.js';
+export function searchKnowledge(context, query, limit = 10) {
+    const taskTokens = tokenize(query);
+    if (taskTokens.length === 0)
+        return [];
+    const sourceResults = context.store.listSources(10_000).map((source) => {
+        const extraction = context.store.getExtractionBySourceId(source.id);
+        const haystack = [
+            source.title ?? '',
+            source.summary ?? '',
+            source.description ?? '',
+            source.sourceUri ?? '',
+            source.canonicalUri ?? '',
+            source.folderPath ?? '',
+            source.tags.join(' '),
+            extraction?.summary ?? '',
+            extraction?.excerpt ?? '',
+            extraction?.sections.join(' ') ?? '',
+        ].join(' ').toLowerCase();
+        const { score, reason } = scoreHaystack(haystack, taskTokens, []);
+        return {
+            kind: 'source',
+            id: source.id,
+            score: score + (source.status === 'indexed' ? 10 : 0) + (extraction ? 8 : 0),
+            reason,
+            source,
+        };
+    });
+    const nodeResults = context.store.listNodes(10_000).map((node) => {
+        const haystack = [
+            node.title,
+            node.summary ?? '',
+            node.aliases.join(' '),
+            JSON.stringify(node.metadata),
+        ].join(' ').toLowerCase();
+        const { score, reason } = scoreHaystack(haystack, taskTokens, []);
+        return {
+            kind: 'node',
+            id: node.id,
+            score,
+            reason,
+            node,
+        };
+    });
+    const results = [...sourceResults, ...nodeResults]
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
+        .slice(0, Math.max(1, limit));
+    for (const result of results.slice(0, Math.min(results.length, 6))) {
+        context.deferUsage({
+            targetKind: result.kind,
+            targetId: result.id,
+            usageKind: 'search-hit',
+            task: query,
+            score: result.score,
+            metadata: { reason: result.reason },
+        });
+    }
+    return results;
+}
+export async function buildKnowledgePacket(context, task, writeScope = [], limit = DEFAULT_PACKET_LIMIT, options = {}) {
+    return buildKnowledgePacketFromCurrentState(context, task, writeScope, limit, options);
+}
+export function buildKnowledgePacketSync(context, task, writeScope = [], limit = DEFAULT_PACKET_LIMIT, options = {}) {
+    return buildKnowledgePacketFromCurrentState(context, task, writeScope, limit, options);
+}
+export function buildKnowledgePromptPacketSync(context, task, writeScope = [], limit = DEFAULT_PACKET_LIMIT, options = {}) {
+    const packet = buildKnowledgePacketSync(context, task, writeScope, limit, options);
+    return packet ? renderPacket(packet.items, packet) : null;
+}
+export async function buildKnowledgePromptPacket(context, task, writeScope = [], limit = DEFAULT_PACKET_LIMIT, options = {}) {
+    const packet = await buildKnowledgePacket(context, task, writeScope, limit, options);
+    return renderPacket(packet.items, packet);
+}
+function buildKnowledgePacketFromCurrentState(context, task, writeScope, limit, options) {
+    const detail = options.detail ?? 'standard';
+    const budgetLimit = Math.max(80, options.budgetLimit ?? DEFAULT_PACKET_BUDGET[detail]);
+    const taskTokens = tokenize(task);
+    const scopeTokens = writeScope.flatMap((entry) => tokenize(entry));
+    const usageStats = buildUsageStats(context);
+    const candidates = [];
+    for (const source of context.store.listSources(10_000)) {
+        const extraction = context.store.getExtractionBySourceId(source.id);
+        const haystack = [
+            source.title ?? '',
+            source.summary ?? '',
+            source.description ?? '',
+            source.sourceUri ?? '',
+            source.canonicalUri ?? '',
+            source.folderPath ?? '',
+            source.tags.join(' '),
+            extraction?.summary ?? '',
+            extraction?.excerpt ?? '',
+            extraction?.sections.join(' ') ?? '',
+        ].join(' ').toLowerCase();
+        const scored = scoreHaystack(haystack, taskTokens, scopeTokens);
+        if (scored.score <= 0)
+            continue;
+        const evidence = detail === 'compact'
+            ? []
+            : (extraction?.sections.slice(0, detail === 'detailed' ? 4 : 2) ?? []);
+        const summary = trimForDetail(extraction?.summary ?? source.summary ?? source.description, detail);
+        const relationLabels = collectRelatedLabels(context, 'source', source.id);
+        const usageBoost = scoreUsageBoost(usageStats.get(`source:${source.id}`));
+        const relationBoost = Math.min(18, relationLabels.length * 3);
+        const freshnessBoost = isSourcePastRefreshWindow(source) ? -8 : 6;
+        const item = {
+            kind: 'source',
+            id: source.id,
+            title: source.title ?? source.canonicalUri ?? source.sourceUri ?? source.id,
+            summary,
+            uri: source.canonicalUri ?? source.sourceUri,
+            reason: scored.reason,
+            score: scored.score + (source.status === 'indexed' ? 8 : 0) + (extraction ? 6 : 0) + usageBoost + relationBoost + freshnessBoost,
+            estimatedTokens: estimateTokens(summary, extraction?.excerpt, evidence.join(' ')),
+            related: relationLabels,
+            evidence,
+            metadata: {
+                sourceType: source.sourceType,
+                status: source.status,
+                extractionFormat: extraction?.format,
+                usageCount: usageStats.get(`source:${source.id}`)?.count ?? 0,
+            },
+        };
+        candidates.push({ score: item.score, item });
+    }
+    for (const node of context.store.listNodes(10_000)) {
+        const haystack = [
+            node.title,
+            node.summary ?? '',
+            node.aliases.join(' '),
+            JSON.stringify(node.metadata),
+        ].join(' ').toLowerCase();
+        const scored = scoreHaystack(haystack, taskTokens, scopeTokens);
+        if (scored.score <= 0)
+            continue;
+        const related = collectRelatedLabels(context, 'node', node.id);
+        const usageBoost = scoreUsageBoost(usageStats.get(`node:${node.id}`));
+        const relationBoost = Math.min(20, context.store.edgesFor('node', node.id).length * 2);
+        const kindBoost = nodeKindBoost(node.kind);
+        const evidence = detail === 'compact' ? related.slice(0, 1) : related.slice(0, detail === 'detailed' ? 4 : 2);
+        const summary = trimForDetail(node.summary, detail);
+        const item = {
+            kind: 'node',
+            id: node.id,
+            title: node.title,
+            summary,
+            reason: scored.reason,
+            score: scored.score + usageBoost + relationBoost + kindBoost,
+            estimatedTokens: estimateTokens(summary, evidence.join(' ')),
+            related,
+            evidence,
+            metadata: {
+                kind: node.kind,
+                status: node.status,
+                usageCount: usageStats.get(`node:${node.id}`)?.count ?? 0,
+            },
+        };
+        candidates.push({ score: item.score, item });
+    }
+    const items = [];
+    let estimatedTokens = 0;
+    for (const candidate of candidates
+        .sort((a, b) => b.score - a.score || a.item.id.localeCompare(b.item.id))
+        .slice(0, Math.max(1, limit * 4))) {
+        if (items.length >= Math.max(1, limit))
+            break;
+        if (estimatedTokens + candidate.item.estimatedTokens > budgetLimit && items.length > 0)
+            continue;
+        items.push(candidate.item);
+        estimatedTokens += candidate.item.estimatedTokens;
+    }
+    const packet = {
+        task,
+        writeScope: [...writeScope],
+        generatedAt: Date.now(),
+        detail,
+        strategy: 'graph-ranked extraction-aware packet',
+        budgetLimit,
+        estimatedTokens,
+        items,
+    };
+    for (const item of items) {
+        context.deferUsage({
+            targetKind: item.kind,
+            targetId: item.id,
+            usageKind: 'packet-item',
+            task,
+            score: item.score,
+            metadata: {
+                detail,
+                writeScope: [...writeScope],
+            },
+        });
+    }
+    context.emitIfReady((bus, ctx) => emitKnowledgePacketBuilt(bus, ctx, {
+        task,
+        itemCount: items.length,
+        estimatedTokens,
+        detail,
+    }));
+    return packet;
+}
+function collectRelatedLabels(context, kind, id) {
+    const related = context.store.edgesFor(kind, id);
+    const labels = [];
+    for (const edge of related) {
+        const otherKind = edge.fromKind === kind && edge.fromId === id ? edge.toKind : edge.fromKind;
+        const otherId = edge.fromKind === kind && edge.fromId === id ? edge.toId : edge.fromId;
+        if (otherKind === 'node') {
+            const node = context.store.getNode(otherId);
+            if (node)
+                labels.push(node.title);
+        }
+        else if (otherKind === 'source') {
+            const source = context.store.getSource(otherId);
+            if (source)
+                labels.push(source.title ?? source.canonicalUri ?? source.id);
+        }
+    }
+    return [...new Set(labels)].slice(0, 8);
+}
+function buildUsageStats(context, limit = 10_000) {
+    const stats = new Map();
+    const cutoff = Date.now() - (30 * 24 * 60 * 60 * 1000);
+    for (const record of context.store.listUsageRecords(limit)) {
+        if (record.createdAt < cutoff)
+            continue;
+        const key = `${record.targetKind}:${record.targetId}`;
+        const current = stats.get(key) ?? {
+            count: 0,
+            scoreTotal: 0,
+            lastUsedAt: 0,
+            usageKinds: new Set(),
+            sessionIds: new Set(),
+        };
+        current.count += 1;
+        current.scoreTotal += Number(record.score ?? 0);
+        current.lastUsedAt = Math.max(current.lastUsedAt, record.createdAt);
+        current.usageKinds.add(record.usageKind);
+        if (record.sessionId)
+            current.sessionIds.add(record.sessionId);
+        stats.set(key, current);
+    }
+    return stats;
+}
+function scoreUsageBoost(stats) {
+    if (!stats)
+        return 0;
+    const frequency = Math.min(28, stats.count * 4);
+    const diversity = Math.min(14, stats.usageKinds.size * 3 + stats.sessionIds.size * 2);
+    const averageScore = stats.count > 0 ? stats.scoreTotal / stats.count : 0;
+    const scoreBoost = Math.min(12, Math.max(0, averageScore / 12));
+    const ageMs = Math.max(0, Date.now() - stats.lastUsedAt);
+    const recency = ageMs <= (24 * 60 * 60 * 1000) ? 10 : ageMs <= 7 * (24 * 60 * 60 * 1000) ? 6 : ageMs <= 14 * (24 * 60 * 60 * 1000) ? 3 : 0;
+    return frequency + diversity + scoreBoost + recency;
+}
+function nodeKindBoost(kind) {
+    switch (kind) {
+        case 'project':
+        case 'capability':
+        case 'repo':
+        case 'service':
+        case 'provider':
+        case 'environment':
+            return 12;
+        case 'memory':
+            return 10;
+        case 'user':
+            return 8;
+        case 'domain':
+        case 'bookmark_folder':
+            return 4;
+        default:
+            return 0;
+    }
+}

package/dist/_internal/platform/knowledge/scheduling.d.ts

@@ -0,0 +1,48 @@
+import { type AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation/schedules';
+import type { KnowledgeStore } from '@pellux/goodvibes-sdk/platform/knowledge/store';
+import type { KnowledgeJobMode, KnowledgeJobRecord, KnowledgeJobRunRecord, KnowledgeScheduleRecord } from '@pellux/goodvibes-sdk/platform/knowledge/types';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+export interface KnowledgeSchedulingContext {
+    readonly store: KnowledgeStore;
+    readonly emitIfReady: (fn: (bus: RuntimeEventBus, ctx: {
+        readonly traceId: string;
+        readonly sessionId: string;
+        readonly source: string;
+    }) => void, sessionId?: string) => void;
+    readonly runJobByKind: (kind: KnowledgeJobRecord['kind'], input: {
+        readonly sourceIds?: readonly string[];
+        readonly limit?: number;
+    }) => Promise<Record<string, unknown>>;
+}
+export declare class KnowledgeScheduleService {
+    private readonly context;
+    private readonly jobs;
+    private readonly scheduleTimers;
+    private schedulesInitialized;
+    constructor(context: KnowledgeSchedulingContext);
+    listJobs(): readonly KnowledgeJobRecord[];
+    getJob(id: string): KnowledgeJobRecord | null;
+    saveSchedule(input: {
+        readonly id?: string;
+        readonly jobId: string;
+        readonly label?: string;
+        readonly enabled?: boolean;
+        readonly schedule: AutomationScheduleDefinition;
+        readonly metadata?: Record<string, unknown>;
+    }): Promise<KnowledgeScheduleRecord>;
+    deleteSchedule(id: string): Promise<boolean>;
+    setScheduleEnabled(id: string, enabled: boolean): Promise<KnowledgeScheduleRecord | null>;
+    listJobRuns(limit?: number, jobId?: string): readonly KnowledgeJobRunRecord[];
+    runJob(id: string, input?: {
+        readonly mode?: KnowledgeJobMode;
+        readonly sourceIds?: readonly string[];
+        readonly limit?: number;
+    }): Promise<KnowledgeJobRunRecord>;
+    dispose(): void;
+    private initializeSchedules;
+    private clearScheduleTimer;
+    private reconcileSchedules;
+    private runScheduledJob;
+    private executeJobRun;
+}
+//# sourceMappingURL=scheduling.d.ts.map

package/dist/_internal/platform/knowledge/scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/knowledge/scheduling.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8E,KAAK,4BAA4B,EAAE,MAAM,qDAAqD,CAAC;AACpL,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AAE3J,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAGlE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,CACpB,EAAE,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,EAC1H,SAAS,CAAC,EAAE,MAAM,KACf,IAAI,CAAC;IACV,QAAQ,CAAC,YAAY,EAAE,CACrB,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,EAChC,KAAK,EAAE;QAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KACvE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvC;AAED,qBAAa,wBAAwB;IAKvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgC;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoD;IACnF,OAAO,CAAC,oBAAoB,CAAS;gBAER,OAAO,EAAE,0BAA0B;IAahE,QAAQ,IAAI,SAAS,kBAAkB,EAAE;IAIzC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAIvC,YAAY,CAAC,KAAK,EAAE;QACxB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,QAAQ,EAAE,4BAA4B,CAAC;QAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC7C,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAqB9B,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM5C,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;IAiB/F,WAAW,CAAC,KAAK,SAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,qBAAqB,EAAE;IAIpE,MAAM,CACV,EAAE,EAAE,MAAM,EACV,KAAK,GAAE;QACL,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;QACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KACpB,GACL,OAAO,CAAC,qBAAqB,CAAC;IA6BjC,OAAO,IAAI,IAAI;YAOD,mBAAmB;IAyBjC,OAAO,CAAC,kBAAkB;YAQZ,kBAAkB;YA6BlB,eAAe;YAmBf,aAAa;CA0D5B"}

package/dist/_internal/platform/knowledge/scheduling.js

@@ -0,0 +1,246 @@
+import { getNextAutomationOccurrence, normalizeCronSchedule, normalizeEverySchedule } from '@pellux/goodvibes-sdk/platform/automation/schedules';
+import { emitKnowledgeJobCompleted, emitKnowledgeJobFailed, emitKnowledgeJobQueued, emitKnowledgeJobStarted } from '../runtime/emitters/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export class KnowledgeScheduleService {
+    context;
+    jobs;
+    scheduleTimers = new Map();
+    schedulesInitialized = false;
+    constructor(context) {
+        this.context = context;
+        this.jobs = [
+            { id: 'knowledge-lint', kind: 'lint', title: 'Lint Knowledge Store', description: 'Run knowledge health checks and refresh the issue queue.', defaultMode: 'inline', metadata: { category: 'quality' } },
+            { id: 'knowledge-reindex', kind: 'reindex', title: 'Reindex Knowledge', description: 'Re-run compile and memory mirroring across the current store.', defaultMode: 'background', metadata: { category: 'maintenance' } },
+            { id: 'knowledge-refresh-stale', kind: 'refresh-stale', title: 'Refresh Stale Sources', description: 'Recrawl stale, failed, or aging remote sources.', defaultMode: 'background', metadata: { category: 'maintenance' } },
+            { id: 'knowledge-refresh-bookmarks', kind: 'refresh-bookmarks', title: 'Refresh Bookmarks', description: 'Recrawl bookmark and URL-list sources to refresh summaries and links.', defaultMode: 'background', metadata: { category: 'maintenance' } },
+            { id: 'knowledge-rebuild-projections', kind: 'rebuild-projections', title: 'Rebuild Projections', description: 'Render and materialize the major derived markdown/wiki projections.', defaultMode: 'background', metadata: { category: 'projection' } },
+            { id: 'knowledge-light-consolidation', kind: 'light-consolidation', title: 'Light Consolidation', description: 'Score recent usage, refresh candidate promotions, and write a deterministic consolidation report.', defaultMode: 'background', metadata: { category: 'consolidation' } },
+            { id: 'knowledge-deep-consolidation', kind: 'deep-consolidation', title: 'Deep Consolidation', description: 'Run the full consolidation loop, including high-confidence memory promotion and deterministic reporting.', defaultMode: 'background', metadata: { category: 'consolidation' } },
+        ];
+        void this.initializeSchedules();
+    }
+    listJobs() {
+        return this.jobs;
+    }
+    getJob(id) {
+        return this.jobs.find((job) => job.id === id) ?? null;
+    }
+    async saveSchedule(input) {
+        const job = this.getJob(input.jobId);
+        if (!job)
+            throw new Error(`Unknown knowledge job: ${input.jobId}`);
+        const nextRunAt = (input.enabled ?? true)
+            ? getNextAutomationOccurrence(input.schedule, Date.now(), input.id ?? input.jobId)
+            : undefined;
+        const record = await this.context.store.upsertSchedule({
+            id: input.id,
+            jobId: input.jobId,
+            label: input.label?.trim() || job.title,
+            enabled: input.enabled ?? true,
+            schedule: input.schedule,
+            nextRunAt,
+            metadata: {
+                ...(input.metadata ?? {}),
+            },
+        });
+        await this.reconcileSchedules();
+        return record;
+    }
+    async deleteSchedule(id) {
+        const deleted = await this.context.store.deleteSchedule(id);
+        this.clearScheduleTimer(id);
+        return deleted;
+    }
+    async setScheduleEnabled(id, enabled) {
+        const schedule = this.context.store.getSchedule(id);
+        if (!schedule)
+            return null;
+        const updated = await this.context.store.upsertSchedule({
+            id: schedule.id,
+            jobId: schedule.jobId,
+            label: schedule.label,
+            enabled,
+            schedule: schedule.schedule,
+            lastRunAt: schedule.lastRunAt,
+            nextRunAt: enabled ? getNextAutomationOccurrence(schedule.schedule, Date.now(), schedule.id) : undefined,
+            metadata: schedule.metadata,
+        });
+        await this.reconcileSchedules();
+        return updated;
+    }
+    listJobRuns(limit = 100, jobId) {
+        return this.context.store.listJobRuns(limit, jobId);
+    }
+    async runJob(id, input = {}) {
+        const job = this.getJob(id);
+        if (!job)
+            throw new Error(`Unknown knowledge job: ${id}`);
+        const mode = input.mode ?? job.defaultMode;
+        const run = await this.context.store.upsertJobRun({
+            jobId: job.id,
+            status: 'queued',
+            mode,
+            requestedAt: Date.now(),
+            result: {},
+            metadata: {
+                ...(input.sourceIds?.length ? { sourceIds: [...input.sourceIds] } : {}),
+                ...(typeof input.limit === 'number' ? { limit: input.limit } : {}),
+            },
+        });
+        this.context.emitIfReady((bus, ctx) => emitKnowledgeJobQueued(bus, ctx, {
+            jobId: job.id,
+            runId: run.id,
+            mode,
+        }));
+        if (mode === 'inline') {
+            return this.executeJobRun(job, run.id, input);
+        }
+        queueMicrotask(() => {
+            void this.executeJobRun(job, run.id, input);
+        });
+        return run;
+    }
+    dispose() {
+        for (const timer of this.scheduleTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.scheduleTimers.clear();
+    }
+    async initializeSchedules() {
+        if (this.schedulesInitialized)
+            return;
+        this.schedulesInitialized = true;
+        await this.context.store.init();
+        if (this.context.store.listSchedules(10_000).length === 0) {
+            await this.context.store.upsertSchedule({
+                jobId: 'knowledge-light-consolidation',
+                label: 'Daily Light Consolidation',
+                enabled: true,
+                schedule: normalizeEverySchedule('24h'),
+                nextRunAt: getNextAutomationOccurrence(normalizeEverySchedule('24h'), Date.now(), 'knowledge-light-consolidation'),
+                metadata: { bootstrap: true },
+            });
+            await this.context.store.upsertSchedule({
+                jobId: 'knowledge-deep-consolidation',
+                label: 'Weekly Deep Consolidation',
+                enabled: true,
+                schedule: normalizeCronSchedule('15 4 * * 0'),
+                nextRunAt: getNextAutomationOccurrence(normalizeCronSchedule('15 4 * * 0'), Date.now(), 'knowledge-deep-consolidation'),
+                metadata: { bootstrap: true },
+            });
+        }
+        await this.reconcileSchedules();
+    }
+    clearScheduleTimer(id) {
+        const timer = this.scheduleTimers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.scheduleTimers.delete(id);
+        }
+    }
+    async reconcileSchedules() {
+        await this.context.store.init();
+        const schedules = this.context.store.listSchedules(10_000);
+        const activeIds = new Set(schedules.map((schedule) => schedule.id));
+        for (const existing of [...this.scheduleTimers.keys()]) {
+            if (!activeIds.has(existing))
+                this.clearScheduleTimer(existing);
+        }
+        for (const schedule of schedules) {
+            this.clearScheduleTimer(schedule.id);
+            if (!schedule.enabled)
+                continue;
+            const dueAt = schedule.nextRunAt ?? getNextAutomationOccurrence(schedule.schedule, Date.now(), schedule.id);
+            const normalized = await this.context.store.upsertSchedule({
+                id: schedule.id,
+                jobId: schedule.jobId,
+                label: schedule.label,
+                enabled: schedule.enabled,
+                schedule: schedule.schedule,
+                lastRunAt: schedule.lastRunAt,
+                nextRunAt: dueAt,
+                metadata: schedule.metadata,
+            });
+            if (!normalized.nextRunAt)
+                continue;
+            const delay = Math.max(250, Math.min(2_147_483_647, normalized.nextRunAt - Date.now()));
+            this.scheduleTimers.set(normalized.id, setTimeout(() => {
+                void this.runScheduledJob(normalized.id);
+            }, delay));
+        }
+    }
+    async runScheduledJob(scheduleId) {
+        this.clearScheduleTimer(scheduleId);
+        const schedule = this.context.store.getSchedule(scheduleId);
+        if (!schedule?.enabled)
+            return;
+        const now = Date.now();
+        await this.runJob(schedule.jobId, { mode: 'background' });
+        await this.context.store.upsertSchedule({
+            id: schedule.id,
+            jobId: schedule.jobId,
+            label: schedule.label,
+            enabled: schedule.enabled,
+            schedule: schedule.schedule,
+            lastRunAt: now,
+            nextRunAt: getNextAutomationOccurrence(schedule.schedule, now, schedule.id),
+            metadata: schedule.metadata,
+        });
+        await this.reconcileSchedules();
+    }
+    async executeJobRun(job, runId, input) {
+        const startedAt = Date.now();
+        let run = await this.context.store.upsertJobRun({
+            id: runId,
+            jobId: job.id,
+            status: 'running',
+            mode: input.mode ?? job.defaultMode,
+            startedAt,
+        });
+        this.context.emitIfReady((bus, ctx) => emitKnowledgeJobStarted(bus, ctx, {
+            jobId: job.id,
+            runId: run.id,
+            mode: run.mode,
+        }));
+        try {
+            const result = await this.context.runJobByKind(job.kind, input);
+            const completedAt = Date.now();
+            run = await this.context.store.upsertJobRun({
+                id: run.id,
+                jobId: run.jobId,
+                status: 'completed',
+                mode: run.mode,
+                requestedAt: run.requestedAt,
+                startedAt,
+                completedAt,
+                result,
+            });
+            this.context.emitIfReady((bus, ctx) => emitKnowledgeJobCompleted(bus, ctx, {
+                jobId: job.id,
+                runId: run.id,
+                durationMs: completedAt - startedAt,
+            }));
+            return run;
+        }
+        catch (error) {
+            const completedAt = Date.now();
+            run = await this.context.store.upsertJobRun({
+                id: run.id,
+                jobId: run.jobId,
+                status: 'failed',
+                mode: run.mode,
+                requestedAt: run.requestedAt,
+                startedAt,
+                completedAt,
+                error: summarizeError(error),
+            });
+            this.context.emitIfReady((bus, ctx) => emitKnowledgeJobFailed(bus, ctx, {
+                jobId: job.id,
+                runId: run.id,
+                error: run.error ?? 'Knowledge job failed.',
+                durationMs: completedAt - startedAt,
+            }));
+            return run;
+        }
+    }
+}