@jungjaehoon/mama-core 1.5.0 → 1.7.0

package/dist/agent-situation/packet-store.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFreshAgentSituationPacket = getFreshAgentSituationPacket;
+exports.insertAgentSituationPacket = insertAgentSituationPacket;
+exports.acquireAgentSituationLease = acquireAgentSituationLease;
+exports.releaseAgentSituationLease = releaseAgentSituationLease;
+exports.getOrRefreshAgentSituationPacket = getOrRefreshAgentSituationPacket;
+const inProcessRefreshesByAdapter = new WeakMap();
+function parseJson(row, field) {
+    const value = row[field];
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid agent situation packet JSON field ${field}: expected string`);
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid agent situation packet JSON field ${field}: ${message}`);
+    }
+}
+function inProcessRefreshesForAdapter(adapter) {
+    const existing = inProcessRefreshesByAdapter.get(adapter);
+    if (existing) {
+        return existing;
+    }
+    const scoped = new Map();
+    inProcessRefreshesByAdapter.set(adapter, scoped);
+    return scoped;
+}
+function mapPacketRow(row) {
+    return {
+        packet_id: String(row.packet_id),
+        cache_key: String(row.cache_key),
+        scope_json: String(row.scope_json),
+        scope: parseJson(row, 'scope_json'),
+        scope_hash: String(row.scope_hash),
+        range_start_ms: Number(row.range_start_ms),
+        range_end_ms: Number(row.range_end_ms),
+        focus_json: String(row.focus_json),
+        focus: parseJson(row, 'focus_json'),
+        envelope_hash: String(row.envelope_hash),
+        envelope_effective_filters_json: String(row.envelope_effective_filters_json),
+        envelope_effective_filters: parseJson(row, 'envelope_effective_filters_json'),
+        envelope_effective_filters_hash: String(row.envelope_effective_filters_hash),
+        ranking_policy_version: String(row.ranking_policy_version),
+        generated_at: Number(row.generated_at),
+        expires_at: Number(row.expires_at),
+        ttl_seconds: Number(row.ttl_seconds),
+        freshness_json: String(row.freshness_json),
+        freshness: parseJson(row, 'freshness_json'),
+        source_coverage_json: String(row.source_coverage_json),
+        source_coverage: parseJson(row, 'source_coverage_json'),
+        briefing_json: String(row.briefing_json),
+        briefing: parseJson(row, 'briefing_json'),
+        ranked_items_json: String(row.ranked_items_json),
+        ranked_items: parseJson(row, 'ranked_items_json'),
+        top_memory_refs_json: String(row.top_memory_refs_json),
+        top_memory_refs: parseJson(row, 'top_memory_refs_json'),
+        pending_human_questions_json: String(row.pending_human_questions_json),
+        pending_human_questions: parseJson(row, 'pending_human_questions_json'),
+        entity_clusters_json: String(row.entity_clusters_json),
+        entity_clusters: parseJson(row, 'entity_clusters_json'),
+        recommended_next_tools_json: String(row.recommended_next_tools_json),
+        recommended_next_tools: parseJson(row, 'recommended_next_tools_json'),
+        generated_from_slice_ids_json: String(row.generated_from_slice_ids_json),
+        generated_from_slice_ids: parseJson(row, 'generated_from_slice_ids_json'),
+        caveats_json: String(row.caveats_json),
+        caveats: parseJson(row, 'caveats_json'),
+        agent_id: String(row.agent_id),
+        model_run_id: String(row.model_run_id),
+        input_snapshot_ref: String(row.input_snapshot_ref),
+        source_refs_json: String(row.source_refs_json),
+        source_refs: parseJson(row, 'source_refs_json'),
+        tenant_id: String(row.tenant_id),
+        project_id: String(row.project_id),
+        memory_scope_kind: String(row.memory_scope_kind),
+        memory_scope_id: String(row.memory_scope_id),
+        created_at: Number(row.created_at),
+    };
+}
+function isDuplicateLeaseError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /UNIQUE constraint failed: agent_situation_refresh_leases\.cache_key|PRIMARY KEY constraint failed|SQLITE_CONSTRAINT_(PRIMARYKEY|UNIQUE)/i.test(error.message);
+}
+function mapLeaseRow(row) {
+    return {
+        cache_key: String(row.cache_key),
+        ranking_policy_version: String(row.ranking_policy_version),
+        lease_owner: String(row.lease_owner),
+        lease_expires_at: Number(row.lease_expires_at),
+        created_at: Number(row.created_at),
+    };
+}
+function getFreshAgentSituationPacket(adapter, cacheKey, rankingPolicyVersion, nowMs) {
+    const row = adapter
+        .prepare(`
+        SELECT *
+        FROM agent_situation_packets
+        WHERE cache_key = ?
+          AND ranking_policy_version = ?
+          AND expires_at > ?
+        ORDER BY expires_at DESC, generated_at DESC
+        LIMIT 1
+      `)
+        .get(cacheKey, rankingPolicyVersion, nowMs);
+    return row ? mapPacketRow(row) : null;
+}
+function insertAgentSituationPacket(adapter, packet) {
+    adapter
+        .prepare(`
+        INSERT INTO agent_situation_packets (
+          packet_id, cache_key, scope_json, scope_hash, range_start_ms, range_end_ms,
+          focus_json, envelope_hash, envelope_effective_filters_json,
+          envelope_effective_filters_hash, ranking_policy_version, generated_at, expires_at,
+          ttl_seconds, freshness_json, source_coverage_json, briefing_json, ranked_items_json,
+          top_memory_refs_json, pending_human_questions_json, entity_clusters_json,
+          recommended_next_tools_json, generated_from_slice_ids_json, caveats_json,
+          agent_id, model_run_id, input_snapshot_ref, source_refs_json, tenant_id, project_id,
+          memory_scope_kind, memory_scope_id, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+        .run(packet.packet_id, packet.cache_key, packet.scope_json, packet.scope_hash, packet.range_start_ms, packet.range_end_ms, packet.focus_json, packet.envelope_hash, packet.envelope_effective_filters_json, packet.envelope_effective_filters_hash, packet.ranking_policy_version, packet.generated_at, packet.expires_at, packet.ttl_seconds, packet.freshness_json, packet.source_coverage_json, packet.briefing_json, packet.ranked_items_json, packet.top_memory_refs_json, packet.pending_human_questions_json, packet.entity_clusters_json, packet.recommended_next_tools_json, packet.generated_from_slice_ids_json, packet.caveats_json, packet.agent_id, packet.model_run_id, packet.input_snapshot_ref, packet.source_refs_json, packet.tenant_id, packet.project_id, packet.memory_scope_kind, packet.memory_scope_id, packet.created_at);
+    const inserted = adapter
+        .prepare('SELECT * FROM agent_situation_packets WHERE packet_id = ?')
+        .get(packet.packet_id);
+    if (!inserted) {
+        throw new Error(`Agent situation packet insert failed: ${packet.packet_id}`);
+    }
+    return mapPacketRow(inserted);
+}
+function acquireAgentSituationLease(adapter, input) {
+    adapter
+        .prepare('DELETE FROM agent_situation_refresh_leases WHERE lease_expires_at <= ?')
+        .run(input.nowMs);
+    try {
+        adapter
+            .prepare(`
+          INSERT INTO agent_situation_refresh_leases (
+            cache_key, ranking_policy_version, lease_owner, lease_expires_at, created_at
+          )
+          VALUES (?, ?, ?, ?, ?)
+        `)
+            .run(input.cacheKey, input.rankingPolicyVersion, input.leaseOwner, input.nowMs + input.leaseSeconds * 1000, input.nowMs);
+    }
+    catch (error) {
+        if (isDuplicateLeaseError(error)) {
+            return null;
+        }
+        throw error;
+    }
+    const row = adapter
+        .prepare('SELECT * FROM agent_situation_refresh_leases WHERE cache_key = ?')
+        .get(input.cacheKey);
+    return row ? mapLeaseRow(row) : null;
+}
+function releaseAgentSituationLease(adapter, cacheKey, leaseOwner) {
+    adapter
+        .prepare('DELETE FROM agent_situation_refresh_leases WHERE cache_key = ? AND lease_owner = ?')
+        .run(cacheKey, leaseOwner);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForFreshPacket(adapter, input) {
+    const pollIntervalMs = input.pollIntervalMs ?? 50;
+    const maxPollMs = input.maxPollMs ?? 30_000;
+    const started = Date.now();
+    while (Date.now() - started < maxPollMs) {
+        const fresh = getFreshAgentSituationPacket(adapter, input.cacheKey, input.rankingPolicyVersion, input.nowMs);
+        if (fresh) {
+            return fresh;
+        }
+        await delay(pollIntervalMs);
+    }
+    return null;
+}
+async function getOrRefreshAgentSituationPacket(adapter, input, builder) {
+    if (!input.refresh) {
+        const fresh = getFreshAgentSituationPacket(adapter, input.cacheKey, input.rankingPolicyVersion, input.nowMs);
+        if (fresh) {
+            return fresh;
+        }
+    }
+    const refreshes = inProcessRefreshesForAdapter(adapter);
+    const key = `${input.cacheKey}:${input.rankingPolicyVersion}`;
+    const existing = refreshes.get(key);
+    if (existing) {
+        return existing;
+    }
+    const task = (async () => {
+        const lease = acquireAgentSituationLease(adapter, {
+            cacheKey: input.cacheKey,
+            rankingPolicyVersion: input.rankingPolicyVersion,
+            leaseOwner: input.leaseOwner,
+            nowMs: input.nowMs,
+            leaseSeconds: input.leaseSeconds ?? 30,
+        });
+        if (!lease) {
+            const fresh = await waitForFreshPacket(adapter, input);
+            if (fresh) {
+                return fresh;
+            }
+            throw new Error(`Timed out waiting for agent situation refresh lease for cache key ${input.cacheKey} and ranking policy ${input.rankingPolicyVersion}`);
+        }
+        try {
+            const built = await builder();
+            return insertAgentSituationPacket(adapter, built);
+        }
+        finally {
+            releaseAgentSituationLease(adapter, input.cacheKey, input.leaseOwner);
+        }
+    })();
+    refreshes.set(key, task);
+    try {
+        return await task;
+    }
+    finally {
+        refreshes.delete(key);
+        if (refreshes.size === 0) {
+            inProcessRefreshesByAdapter.delete(adapter);
+        }
+    }
+}
+//# sourceMappingURL=packet-store.js.map

package/dist/agent-situation/ranking-policy.d.ts

@@ -0,0 +1,18 @@
+import type { AgentSituationCandidate, SituationScore } from './types.js';
+export declare const AGENT_SITUATION_V0_POLICY_VERSION = "agent_situation.v0";
+export declare const AGENT_SITUATION_V0_WEIGHTS: {
+    readonly urgency: 0.35;
+    readonly confidence_gap: 0.2;
+    readonly debate_edge: 0.2;
+    readonly source_freshness: 0.2;
+    readonly cross_channel_signal: 0.15;
+    readonly pending_human_question: 0.1;
+    readonly open_question_urgency_boost: 0.2;
+};
+export interface AgentSituationRankingPolicy {
+    version: string;
+    weights: typeof AGENT_SITUATION_V0_WEIGHTS;
+}
+export declare function getAgentSituationRankingPolicy(version?: string): AgentSituationRankingPolicy;
+export declare function scoreAgentSituationCandidate(candidate: AgentSituationCandidate, policy: AgentSituationRankingPolicy): SituationScore;
+//# sourceMappingURL=ranking-policy.d.ts.map

package/dist/agent-situation/ranking-policy.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_SITUATION_V0_WEIGHTS = exports.AGENT_SITUATION_V0_POLICY_VERSION = void 0;
+exports.getAgentSituationRankingPolicy = getAgentSituationRankingPolicy;
+exports.scoreAgentSituationCandidate = scoreAgentSituationCandidate;
+exports.AGENT_SITUATION_V0_POLICY_VERSION = 'agent_situation.v0';
+exports.AGENT_SITUATION_V0_WEIGHTS = {
+    urgency: 0.35,
+    confidence_gap: 0.2,
+    debate_edge: 0.2,
+    source_freshness: 0.2,
+    cross_channel_signal: 0.15,
+    pending_human_question: 0.1,
+    open_question_urgency_boost: 0.2,
+};
+const V0_POLICY = {
+    version: exports.AGENT_SITUATION_V0_POLICY_VERSION,
+    weights: exports.AGENT_SITUATION_V0_WEIGHTS,
+};
+function textHasUrgency(candidate) {
+    const text = `${candidate.title} ${candidate.summary}`.toLowerCase();
+    return /\b(blocked|urgent|risk|deploy|release|needs?|review|failed|failing)\b/.test(text);
+}
+function freshnessScore(candidate) {
+    if (!Number.isFinite(candidate.timestamp_ms) || candidate.timestamp_ms <= 0) {
+        return 0;
+    }
+    const ageMs = Math.max(0, Date.now() - candidate.timestamp_ms);
+    const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+    return Math.max(0, 1 - Math.min(ageMs, sevenDaysMs) / sevenDaysMs);
+}
+function getAgentSituationRankingPolicy(version = exports.AGENT_SITUATION_V0_POLICY_VERSION) {
+    if (version !== exports.AGENT_SITUATION_V0_POLICY_VERSION) {
+        throw new Error(`Unknown agent situation ranking policy: ${version}`);
+    }
+    return V0_POLICY;
+}
+function scoreAgentSituationCandidate(candidate, policy) {
+    const reasons = [];
+    const caveats = [];
+    let score = 0;
+    if (textHasUrgency(candidate)) {
+        score += policy.weights.urgency;
+        reasons.push('urgent_visible_signal');
+    }
+    const confidence = typeof candidate.confidence === 'number' ? candidate.confidence : 1;
+    if (confidence < 0.6) {
+        score += policy.weights.confidence_gap;
+        reasons.push('low_confidence_memory');
+        caveats.push('low_confidence_visible_memory');
+    }
+    if (candidate.has_debate_edge) {
+        score += policy.weights.debate_edge;
+        reasons.push('debated_visible_memory');
+    }
+    const freshness = freshnessScore(candidate);
+    if (freshness > 0) {
+        score += freshness * policy.weights.source_freshness;
+        reasons.push('recent_visible_source');
+    }
+    if (candidate.connector && candidate.channel_id) {
+        score += policy.weights.cross_channel_signal / 2;
+        reasons.push('visible_connector_context');
+    }
+    if (candidate.is_open_question) {
+        score += policy.weights.pending_human_question + policy.weights.open_question_urgency_boost;
+        reasons.push('pending_open_question');
+    }
+    return {
+        score: Number(score.toFixed(6)),
+        reasons: [...new Set(reasons)],
+        caveats: [...new Set(caveats)],
+    };
+}
+//# sourceMappingURL=ranking-policy.js.map

package/dist/agent-situation/source-readers.d.ts

@@ -0,0 +1,52 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { AgentSituationCandidate, AgentSituationEffectiveFilters, SituationRef } from './types.js';
+type SituationReaderAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export interface AgentSituationSourceReadInput {
+    effective_filters: AgentSituationEffectiveFilters;
+    range_start_ms: number;
+    range_end_ms: number;
+    limit: number;
+}
+export interface VisibleRawCandidate extends AgentSituationCandidate {
+    ref: {
+        kind: 'raw';
+        id: string;
+    };
+    connector: string;
+    channel_id: string | null;
+    content: string;
+}
+export interface VisibleMemoryCandidate extends AgentSituationCandidate {
+    ref: {
+        kind: 'memory';
+        id: string;
+    };
+    topic: string;
+}
+export interface VisibleCaseCandidate extends AgentSituationCandidate {
+    ref: {
+        kind: 'case';
+        id: string;
+    };
+}
+export interface VisibleEdgeCandidate extends AgentSituationCandidate {
+    ref: {
+        kind: 'edge';
+        id: string;
+    };
+    subject_ref: SituationRef;
+    object_ref: SituationRef;
+}
+export interface VisibleAgentSituationSources {
+    raw: VisibleRawCandidate[];
+    memories: VisibleMemoryCandidate[];
+    cases: VisibleCaseCandidate[];
+    edges: VisibleEdgeCandidate[];
+}
+export declare function listVisibleRawCandidates(adapter: SituationReaderAdapter, input: AgentSituationSourceReadInput): VisibleRawCandidate[];
+export declare function listVisibleMemoryCandidates(adapter: SituationReaderAdapter, input: AgentSituationSourceReadInput): VisibleMemoryCandidate[];
+export declare function listVisibleCaseCandidates(adapter: SituationReaderAdapter, input: AgentSituationSourceReadInput): VisibleCaseCandidate[];
+export declare function listVisibleEdgeCandidates(adapter: SituationReaderAdapter, input: AgentSituationSourceReadInput, visibleRefs: SituationRef[]): VisibleEdgeCandidate[];
+export declare function listVisibleAgentSituationSources(adapter: SituationReaderAdapter, input: AgentSituationSourceReadInput): VisibleAgentSituationSources;
+export {};
+//# sourceMappingURL=source-readers.d.ts.map

package/dist/agent-situation/source-readers.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listVisibleRawCandidates = listVisibleRawCandidates;
+exports.listVisibleMemoryCandidates = listVisibleMemoryCandidates;
+exports.listVisibleCaseCandidates = listVisibleCaseCandidates;
+exports.listVisibleEdgeCandidates = listVisibleEdgeCandidates;
+exports.listVisibleAgentSituationSources = listVisibleAgentSituationSources;
+const types_js_1 = require("../memory/types.js");
+function placeholders(values) {
+    return values.map(() => '?').join(', ');
+}
+function scopeKey(scope) {
+    return `${scope.kind}:${scope.id}`;
+}
+function refKey(ref) {
+    return `${ref.kind}:${ref.id}`;
+}
+function tableExists(adapter, table) {
+    const row = adapter
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?")
+        .get(table);
+    return Boolean(row?.name);
+}
+function normalizeLimit(limit) {
+    return Math.max(0, Math.min(100, Math.floor(limit)));
+}
+function visibilityEndMs(input) {
+    const asOf = input.effective_filters.as_of;
+    if (!asOf) {
+        return input.range_end_ms;
+    }
+    const parsed = Date.parse(asOf);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid agent situation as_of: ${asOf}`);
+    }
+    return Math.min(input.range_end_ms, parsed);
+}
+function parseCaseScopeRefs(row) {
+    const caseId = String(row.case_id ?? '<unknown>');
+    if (typeof row.scope_refs !== 'string' || row.scope_refs.length === 0) {
+        throw new Error(`Invalid case_truth.scope_refs for case ${caseId}: expected a JSON array string.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(row.scope_refs);
+    }
+    catch {
+        throw new Error(`Invalid case_truth.scope_refs for case ${caseId}: malformed JSON.`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error(`Invalid case_truth.scope_refs for case ${caseId}: expected a JSON array.`);
+    }
+    return parsed.map((scope, index) => {
+        if (!scope || typeof scope !== 'object') {
+            throw new Error(`Invalid case_truth.scope_refs for case ${caseId}: entry ${index} must be an object.`);
+        }
+        const record = scope;
+        if (typeof record.kind !== 'string' ||
+            typeof record.id !== 'string' ||
+            !types_js_1.MEMORY_SCOPE_KINDS.includes(record.kind)) {
+            throw new Error(`Invalid case_truth.scope_refs for case ${caseId}: entry ${index} must include a valid kind and id.`);
+        }
+        return { kind: record.kind, id: record.id };
+    });
+}
+function isScopeVisible(scope, effective) {
+    const visible = new Set(effective.scopes.map(scopeKey));
+    return visible.has(scopeKey(scope));
+}
+function caseTimestampMs(row) {
+    const caseId = String(row.case_id ?? 'unknown');
+    const timestampFields = [
+        ['last_activity_at', row.last_activity_at],
+        ['updated_at', row.updated_at],
+        ['created_at', row.created_at],
+    ];
+    for (const [field, value] of timestampFields) {
+        if (value === null || value === undefined || value === '') {
+            continue;
+        }
+        if (typeof value !== 'string') {
+            throw new Error(`Invalid case_truth timestamp for case ${caseId}: ${field} must be an ISO timestamp string.`);
+        }
+        if (typeof value === 'string') {
+            const parsed = Date.parse(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    throw new Error(`Invalid case_truth timestamp for case ${caseId}: expected last_activity_at, updated_at, or created_at to contain a valid ISO timestamp.`);
+}
+function isOpenQuestion(row) {
+    const text = `${String(row.topic ?? '')} ${String(row.decision ?? '')} ${String(row.summary ?? '')}`;
+    return row.kind === 'task' || text.includes('?') || /\b(question|decide|answer)\b/i.test(text);
+}
+function listVisibleRawCandidates(adapter, input) {
+    if (!tableExists(adapter, 'connector_event_index')) {
+        return [];
+    }
+    const connectors = input.effective_filters.connectors;
+    const scopes = input.effective_filters.scopes;
+    const projectIds = input.effective_filters.project_refs.map((project) => project.id);
+    if (connectors.length === 0 || scopes.length === 0 || projectIds.length === 0) {
+        return [];
+    }
+    const endMs = visibilityEndMs(input);
+    const scopeClauses = scopes
+        .map(() => '(memory_scope_kind = ? AND memory_scope_id = ?)')
+        .join(' OR ');
+    const params = [input.effective_filters.tenant_id, ...projectIds, ...connectors];
+    for (const scope of scopes) {
+        params.push(scope.kind, scope.id);
+    }
+    params.push(input.range_start_ms, endMs, normalizeLimit(input.limit));
+    const rows = adapter
+        .prepare(`
+        SELECT event_index_id, source_connector, channel, title, content, event_datetime,
+               memory_scope_kind, memory_scope_id
+        FROM connector_event_index
+        WHERE tenant_id = ?
+          AND project_id IN (${placeholders(projectIds)})
+          AND source_connector IN (${placeholders(connectors)})
+          AND (${scopeClauses})
+          AND event_datetime BETWEEN ? AND ?
+        ORDER BY event_datetime DESC, event_index_id ASC
+        LIMIT ?
+      `)
+        .all(...params);
+    return rows.map((row) => ({
+        ref: { kind: 'raw', id: String(row.event_index_id) },
+        kind: 'raw',
+        title: String(row.title ?? 'Untitled raw event'),
+        summary: String(row.content ?? '').slice(0, 240),
+        content: String(row.content ?? ''),
+        timestamp_ms: Number(row.event_datetime),
+        connector: String(row.source_connector),
+        channel_id: typeof row.channel === 'string' ? row.channel : null,
+        scope: typeof row.memory_scope_kind === 'string' && typeof row.memory_scope_id === 'string'
+            ? { kind: row.memory_scope_kind, id: row.memory_scope_id }
+            : null,
+    }));
+}
+function listVisibleMemoryCandidates(adapter, input) {
+    if (!tableExists(adapter, 'decisions')) {
+        return [];
+    }
+    const scopes = input.effective_filters.scopes;
+    if (scopes.length === 0) {
+        return [];
+    }
+    const endMs = visibilityEndMs(input);
+    const scopeClauses = scopes.map(() => '(ms.kind = ? AND ms.external_id = ?)').join(' OR ');
+    const params = [];
+    for (const scope of scopes) {
+        params.push(scope.kind, scope.id);
+    }
+    params.push(input.range_start_ms, endMs, normalizeLimit(input.limit));
+    const rows = adapter
+        .prepare(`
+        SELECT DISTINCT d.id, d.topic, d.decision, d.reasoning, d.kind, d.status, d.summary,
+               d.confidence, d.event_datetime, d.created_at, ms.kind AS scope_kind,
+               ms.external_id AS scope_id
+        FROM decisions d
+        JOIN memory_scope_bindings msb ON msb.memory_id = d.id
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE (${scopeClauses})
+          AND COALESCE(d.event_datetime, d.created_at) BETWEEN ? AND ?
+        ORDER BY COALESCE(d.event_datetime, d.created_at) DESC, d.id ASC
+        LIMIT ?
+      `)
+        .all(...params);
+    return rows.map((row) => ({
+        ref: { kind: 'memory', id: String(row.id) },
+        kind: 'memory',
+        title: String(row.topic ?? row.decision ?? 'Memory'),
+        summary: String(row.summary ?? row.decision ?? row.reasoning ?? ''),
+        topic: String(row.topic ?? ''),
+        timestamp_ms: Number(row.event_datetime ?? row.created_at ?? 0),
+        confidence: typeof row.confidence === 'number' ? row.confidence : Number(row.confidence ?? 1),
+        status: typeof row.status === 'string' ? row.status : null,
+        is_open_question: isOpenQuestion(row),
+        has_debate_edge: false,
+        scope: typeof row.scope_kind === 'string' && typeof row.scope_id === 'string'
+            ? { kind: row.scope_kind, id: row.scope_id }
+            : null,
+    }));
+}
+function listVisibleCaseCandidates(adapter, input) {
+    if (!tableExists(adapter, 'case_truth')) {
+        return [];
+    }
+    const endMs = visibilityEndMs(input);
+    const rows = adapter
+        .prepare(`
+        SELECT case_id, title, status, confidence, scope_refs, last_activity_at, updated_at, created_at
+        FROM case_truth
+        ORDER BY COALESCE(last_activity_at, updated_at, created_at) DESC, case_id ASC
+      `)
+        .all();
+    return rows
+        .map((row) => {
+        const timestamp = caseTimestampMs(row);
+        if (timestamp < input.range_start_ms || timestamp > endMs) {
+            return null;
+        }
+        const visibleScope = parseCaseScopeRefs(row).find((scope) => isScopeVisible(scope, input.effective_filters));
+        if (!visibleScope) {
+            return null;
+        }
+        return {
+            ref: { kind: 'case', id: String(row.case_id) },
+            kind: 'case',
+            title: String(row.title ?? 'Case'),
+            summary: String(row.status ?? ''),
+            timestamp_ms: timestamp,
+            confidence: row.confidence === 'low' ? 0.4 : row.confidence === 'medium' ? 0.7 : 1,
+            status: typeof row.status === 'string' ? row.status : null,
+            scope: visibleScope,
+        };
+    })
+        .filter((row) => Boolean(row))
+        .slice(0, normalizeLimit(input.limit));
+}
+function listVisibleEdgeCandidates(adapter, input, visibleRefs) {
+    if (!tableExists(adapter, 'twin_edges')) {
+        return [];
+    }
+    const visible = new Set(visibleRefs.map(refKey));
+    if (visible.size === 0) {
+        return [];
+    }
+    const uniqueVisibleRefs = [...new Map(visibleRefs.map((ref) => [refKey(ref), ref])).values()];
+    const subjectClauses = uniqueVisibleRefs
+        .map(() => '(subject_kind = ? AND subject_id = ?)')
+        .join(' OR ');
+    const objectClauses = uniqueVisibleRefs
+        .map(() => '(object_kind = ? AND object_id = ?)')
+        .join(' OR ');
+    const params = [input.range_start_ms, visibilityEndMs(input)];
+    for (const ref of uniqueVisibleRefs) {
+        params.push(ref.kind, ref.id);
+    }
+    for (const ref of uniqueVisibleRefs) {
+        params.push(ref.kind, ref.id);
+    }
+    params.push(normalizeLimit(input.limit));
+    const rows = adapter
+        .prepare(`
+        SELECT edge_id, edge_type, subject_kind, subject_id, object_kind, object_id,
+               confidence, reason_text, created_at
+        FROM twin_edges
+        WHERE created_at BETWEEN ? AND ?
+          AND (${subjectClauses})
+          AND (${objectClauses})
+        ORDER BY created_at DESC, edge_id ASC
+        LIMIT ?
+      `)
+        .all(...params);
+    return rows
+        .map((row) => {
+        const subject = {
+            kind: String(row.subject_kind),
+            id: String(row.subject_id),
+        };
+        const object = {
+            kind: String(row.object_kind),
+            id: String(row.object_id),
+        };
+        if (!visible.has(refKey(subject)) || !visible.has(refKey(object))) {
+            return null;
+        }
+        return {
+            ref: { kind: 'edge', id: String(row.edge_id) },
+            kind: String(row.edge_type),
+            title: String(row.edge_type),
+            summary: String(row.reason_text ?? ''),
+            timestamp_ms: Number(row.created_at),
+            confidence: typeof row.confidence === 'number' ? row.confidence : Number(row.confidence ?? 1),
+            status: null,
+            subject_ref: subject,
+            object_ref: object,
+        };
+    })
+        .filter((row) => Boolean(row))
+        .slice(0, normalizeLimit(input.limit));
+}
+function listVisibleAgentSituationSources(adapter, input) {
+    const raw = listVisibleRawCandidates(adapter, input);
+    const memories = listVisibleMemoryCandidates(adapter, input);
+    const cases = listVisibleCaseCandidates(adapter, input);
+    const visibleRefs = [
+        ...raw.map((item) => item.ref),
+        ...memories.map((item) => item.ref),
+        ...cases.map((item) => item.ref),
+    ];
+    const edges = listVisibleEdgeCandidates(adapter, input, visibleRefs);
+    return { raw, memories, cases, edges };
+}
+//# sourceMappingURL=source-readers.js.map