@haaaiawd/second-nature 0.1.50 → 0.2.0

package/runtime/core/second-nature/perception/judgment-engine.d.ts

@@ -0,0 +1,53 @@
+/**
+ * JudgmentEngine — Produce JudgmentVerdict records from PerceptionCard.
+ *
+ * Core logic: Read a PerceptionCard, apply rules-only decision tree, and
+ * write a source-backed JudgmentVerdict. No model assist; deterministic
+ * verdict based on relevance, risk flags, source refs, and confidence.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §3.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readPerceptionCardById, writeJudgmentVerdict)
+ * - `src/shared/types/v8-contracts.js` (PlatformNeutralActionKind, SourceRef,
+ *   DegradedOperationResult, V8ReasonCode, ACTION_KIND_REGISTRY)
+ *
+ * Boundary:
+ * - Does not execute actions; produces verdict only.
+ * - Does not write long-term memory; only emits review intent.
+ * - Degrades gracefully on missing card or unreadable state.
+ *
+ * Test coverage: tests/unit/judgment/judgment-engine.test.ts
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { SourceRef, DegradedOperationResult, PlatformNeutralActionKind, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+export interface JudgmentVerdictResult {
+    id: string;
+    cycleId: string;
+    perceptionCardId: string;
+    actionKind: PlatformNeutralActionKind;
+    confidence: number;
+    reason: V8ReasonCode;
+    riskPosture: "low" | "medium" | "high" | "blocked";
+    sourceRefs: SourceRef[];
+    createdAt: string;
+}
+export interface RunAgentJudgmentResult {
+    status: "completed" | "blocked" | "degraded";
+    verdicts: JudgmentVerdictResult[];
+    reason?: V8ReasonCode;
+}
+export interface RunAgentJudgmentOptions {
+    now?: string;
+}
+export declare function runAgentJudgment(db: StateDatabase, perceptionCardId: string, options?: RunAgentJudgmentOptions): Promise<RunAgentJudgmentResult | DegradedOperationResult>;
+export interface BatchJudgmentResult {
+    succeeded: JudgmentVerdictResult[];
+    failed: {
+        perceptionCardId: string;
+        degraded: DegradedOperationResult;
+    }[];
+}
+export declare function runAgentJudgments(db: StateDatabase, perceptionCardIds: string[], options?: RunAgentJudgmentOptions): Promise<BatchJudgmentResult>;

package/runtime/core/second-nature/perception/judgment-engine.js

@@ -0,0 +1,239 @@
+/**
+ * JudgmentEngine — Produce JudgmentVerdict records from PerceptionCard.
+ *
+ * Core logic: Read a PerceptionCard, apply rules-only decision tree, and
+ * write a source-backed JudgmentVerdict. No model assist; deterministic
+ * verdict based on relevance, risk flags, source refs, and confidence.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §3.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readPerceptionCardById, writeJudgmentVerdict)
+ * - `src/shared/types/v8-contracts.js` (PlatformNeutralActionKind, SourceRef,
+ *   DegradedOperationResult, V8ReasonCode, ACTION_KIND_REGISTRY)
+ *
+ * Boundary:
+ * - Does not execute actions; produces verdict only.
+ * - Does not write long-term memory; only emits review intent.
+ * - Degrades gracefully on missing card or unreadable state.
+ *
+ * Test coverage: tests/unit/judgment/judgment-engine.test.ts
+ */
+import { readPerceptionCardById, writeJudgmentVerdict, } from "../../../storage/v8-state-stores.js";
+import { ACTION_KIND_REGISTRY } from "../../../shared/types/v8-contracts.js";
+// ───────────────────────────────────────────────────────────────
+// Config
+// ───────────────────────────────────────────────────────────────
+const MIN_EXTERNAL_ACTION_CONFIDENCE = 0.70;
+// ───────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────
+function inferRiskPosture(sensitivityClass, riskFlags) {
+    if (sensitivityClass === "sensitive" || riskFlags.includes("credential_shape_detected")) {
+        return "blocked";
+    }
+    if (sensitivityClass === "private_context" || riskFlags.includes("private_context")) {
+        return "high";
+    }
+    if (sensitivityClass === "public_technical") {
+        return "medium";
+    }
+    return "low";
+}
+function parseCardSourceRefs(json) {
+    if (!json)
+        return [];
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function selectVerdict(relevance, confidence, riskPosture, hasSourceRefs, possibleIntents) {
+    // Missing source refs → ignore/watch only
+    if (!hasSourceRefs) {
+        return {
+            actionKind: relevance > 0.5 ? "watch" : "ignore",
+            reason: "judgment_missing_source_refs",
+            finalConfidence: 0.5,
+        };
+    }
+    // Risk blocked → watch or notify_owner only, no external write
+    if (riskPosture === "blocked") {
+        return {
+            actionKind: relevance > 0.5 ? "notify_owner" : "watch",
+            reason: "proposal_risk_blocked",
+            finalConfidence: 0.6,
+        };
+    }
+    // Low confidence → no auto/draft external write
+    const canExternalWrite = confidence >= MIN_EXTERNAL_ACTION_CONFIDENCE;
+    // Low relevance → ignore/watch
+    if (relevance <= 0.3) {
+        return {
+            actionKind: relevance > 0.15 ? "watch" : "ignore",
+            reason: "judgment_low_confidence",
+            finalConfidence: 0.4,
+        };
+    }
+    // Medium/high relevance + low risk → actionable
+    const preferredIntent = possibleIntents.find((intent) => {
+        const meta = ACTION_KIND_REGISTRY[intent];
+        if (!meta)
+            return false;
+        if (meta.sideEffectClass === "external_write" && !canExternalWrite)
+            return false;
+        if (meta.sideEffectClass === "external_write" && riskPosture === "high")
+            return false;
+        return true;
+    });
+    if (preferredIntent) {
+        return {
+            actionKind: preferredIntent,
+            reason: "proposal_created",
+            finalConfidence: confidence,
+        };
+    }
+    // Fallback to watch if no actionable intent allowed
+    return {
+        actionKind: "watch",
+        reason: "judgment_low_confidence",
+        finalConfidence: 0.5,
+    };
+}
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export async function runAgentJudgment(db, perceptionCardId, options) {
+    const now = options?.now ?? new Date().toISOString();
+    const readResult = await readPerceptionCardById(db, perceptionCardId);
+    if (readResult.degraded) {
+        return readResult.degraded;
+    }
+    const card = readResult.row;
+    if (!card) {
+        return {
+            status: "degraded",
+            reason: "state_unreadable",
+            ownerStage: "judgment",
+            sourceRefs: [],
+            operatorNextAction: `PerceptionCard ${perceptionCardId} not found`,
+            retryable: false,
+        };
+    }
+    const sourceRefs = parseCardSourceRefs(card.sourceRefsJson);
+    const hasSourceRefs = sourceRefs.length > 0;
+    // Parse sensitivity class from payload (stored there by perception-builder)
+    let sensitivityClass = "public_general";
+    if (card.payloadJson) {
+        try {
+            const payload = JSON.parse(card.payloadJson);
+            if (payload.sensitivityClass)
+                sensitivityClass = String(payload.sensitivityClass);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const riskPosture = inferRiskPosture(sensitivityClass, card.riskFlagsJson ? JSON.parse(card.riskFlagsJson) : []);
+    // Parse possible intents from payload
+    let possibleIntents = ["watch"];
+    if (card.payloadJson) {
+        try {
+            const payload = JSON.parse(card.payloadJson);
+            if (payload.possibleIntents && Array.isArray(payload.possibleIntents)) {
+                possibleIntents = payload.possibleIntents;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const { actionKind, reason, finalConfidence } = selectVerdict(card.relevance ?? 0.3, card.confidence ?? 0.6, riskPosture, hasSourceRefs, possibleIntents);
+    const verdict = {
+        id: `jud_${perceptionCardId}_${now.replace(/[:.]/g, "")}`,
+        cycleId: card.cycleId,
+        perceptionCardId,
+        actionKind,
+        confidence: finalConfidence,
+        reason,
+        riskPosture,
+        sourceRefs: hasSourceRefs
+            ? sourceRefs
+            : [
+                {
+                    uri: `sn://judgment/missing_source_refs/${perceptionCardId}`,
+                    family: "judgment",
+                    id: perceptionCardId,
+                    redactionClass: "none",
+                    resolveStatus: "missing",
+                },
+            ],
+        createdAt: now,
+    };
+    const writeResult = await writeJudgmentVerdict(db, {
+        id: verdict.id,
+        createdAt: now,
+        cycleId: verdict.cycleId,
+        perceptionCardId: verdict.perceptionCardId,
+        actionKind: verdict.actionKind,
+        confidence: verdict.confidence,
+        reason: verdict.reason,
+        riskPosture: verdict.riskPosture,
+        sourceRefs: verdict.sourceRefs,
+        redactionClass: riskPosture === "blocked" ? "blocked" : "none",
+        lifecycleStatus: "pending",
+        payloadJson: JSON.stringify({
+            possibleIntents,
+            sensitivityClass,
+        }),
+    });
+    if ("reason" in writeResult) {
+        return {
+            status: "degraded",
+            verdicts: [],
+            reason: writeResult.reason,
+        };
+    }
+    return {
+        status: riskPosture === "blocked" ? "blocked" : "completed",
+        verdicts: [verdict],
+        reason,
+    };
+}
+export async function runAgentJudgments(db, perceptionCardIds, options) {
+    const succeeded = [];
+    const failed = [];
+    for (const perceptionCardId of perceptionCardIds) {
+        const result = await runAgentJudgment(db, perceptionCardId, options);
+        if ("verdicts" in result) {
+            if (result.status === "completed" || result.status === "blocked") {
+                succeeded.push(...result.verdicts);
+            }
+            else {
+                failed.push({
+                    perceptionCardId,
+                    degraded: {
+                        status: "degraded",
+                        reason: result.reason ?? "judgment_low_confidence",
+                        ownerStage: "judgment",
+                        sourceRefs: [],
+                        operatorNextAction: `Judgment failed for ${perceptionCardId}`,
+                        retryable: true,
+                    },
+                });
+            }
+        }
+        else {
+            failed.push({
+                perceptionCardId,
+                degraded: result,
+            });
+        }
+    }
+    return { succeeded, failed };
+}

package/runtime/core/second-nature/perception/perception-builder.d.ts

@@ -0,0 +1,62 @@
+/**
+ * PerceptionBuilder — Generate PerceptionCard records from EvidenceItem batches.
+ *
+ * Core logic: Read pending evidence, deduplicate by content hash, build
+ * PerceptionCard with topic, entities, novelty, relevance, summary, risk
+ * flags, confidence, and reviewPriority. Rules-only fallback when model
+ * assist is unavailable.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §3.1`
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readEvidenceItemsByStatus, writePerceptionCard)
+ * - `src/shared/types/v8-contracts.js` (PerceptionCard fields)
+ *
+ * Boundary:
+ * - Does not judge actionability; that is judgment's job.
+ * - Does not fabricate perception on empty input.
+ * - Rules-only path is deterministic and source-backed.
+ *
+ * Test coverage: tests/unit/perception/perception-builder.test.ts
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { SourceRef, DegradedOperationResult, PlatformNeutralActionKind, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+export interface EvidenceItemInput {
+    id: string;
+    platformId: string;
+    contentHash: string;
+    observedAt: string;
+    sensitivityHint?: string;
+    sourceRefsJson: string;
+    payloadJson?: string | null;
+}
+export interface PerceptionCardResult {
+    id: string;
+    cycleId: string;
+    topic: string;
+    entities: string[];
+    novelty: "new" | "recurring" | "update";
+    relevance: number;
+    summary: string;
+    possibleIntents: PlatformNeutralActionKind[];
+    reviewPriority: "low" | "medium" | "high";
+    sensitivityClass: string;
+    riskFlags: string[];
+    confidence: number;
+    evidenceRefs: SourceRef[];
+    createdAt: string;
+}
+export interface BuildPerceptionCardsResult {
+    status: "completed" | "rules_only" | "blocked" | "empty" | "degraded";
+    cards: PerceptionCardResult[];
+    reason?: V8ReasonCode;
+    truncated?: boolean;
+}
+export interface BuildPerceptionCardsOptions {
+    cycleId: string;
+    maxEvidence?: number;
+    now?: string;
+}
+export declare function buildPerceptionCards(db: StateDatabase, options: BuildPerceptionCardsOptions): Promise<BuildPerceptionCardsResult | DegradedOperationResult>;

package/runtime/core/second-nature/perception/perception-builder.js

@@ -0,0 +1,208 @@
+/**
+ * PerceptionBuilder — Generate PerceptionCard records from EvidenceItem batches.
+ *
+ * Core logic: Read pending evidence, deduplicate by content hash, build
+ * PerceptionCard with topic, entities, novelty, relevance, summary, risk
+ * flags, confidence, and reviewPriority. Rules-only fallback when model
+ * assist is unavailable.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §3.1`
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readEvidenceItemsByStatus, writePerceptionCard)
+ * - `src/shared/types/v8-contracts.js` (PerceptionCard fields)
+ *
+ * Boundary:
+ * - Does not judge actionability; that is judgment's job.
+ * - Does not fabricate perception on empty input.
+ * - Rules-only path is deterministic and source-backed.
+ *
+ * Test coverage: tests/unit/perception/perception-builder.test.ts
+ */
+import { readEvidenceItemsByStatus, writePerceptionCard, } from "../../../storage/v8-state-stores.js";
+// ───────────────────────────────────────────────────────────────
+// Config
+// ───────────────────────────────────────────────────────────────
+const PERCEPTION_MAX_EVIDENCE_PER_CYCLE = 50;
+// ───────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────
+function parseSourceRefs(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function extractTopic(evidence) {
+    if (evidence.payloadJson) {
+        try {
+            const payload = JSON.parse(evidence.payloadJson);
+            if (payload.topic)
+                return String(payload.topic);
+            if (payload.title)
+                return String(payload.title);
+            if (payload.subject)
+                return String(payload.subject);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return `${evidence.platformId}_observation`;
+}
+function extractEntities(evidence) {
+    const entities = [evidence.platformId];
+    if (evidence.payloadJson) {
+        try {
+            const payload = JSON.parse(evidence.payloadJson);
+            if (payload.entities && Array.isArray(payload.entities)) {
+                entities.push(...payload.entities.map(String));
+            }
+            if (payload.tags && Array.isArray(payload.tags)) {
+                entities.push(...payload.tags.map(String));
+            }
+            if (payload.mentions && Array.isArray(payload.mentions)) {
+                entities.push(...payload.mentions.map(String));
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return [...new Set(entities)];
+}
+function inferNovelty(evidence) {
+    if (evidence.sensitivityHint === "public_technical")
+        return "recurring";
+    return "new";
+}
+function inferRelevance(evidence) {
+    if (evidence.sensitivityHint === "sensitive")
+        return 0.9;
+    if (evidence.sensitivityHint === "public_technical")
+        return 0.7;
+    if (evidence.sensitivityHint === "private_context")
+        return 0.5;
+    return 0.3;
+}
+function inferSummary(evidence) {
+    const platform = evidence.platformId;
+    const topic = extractTopic(evidence);
+    return `Observation from ${platform}: ${topic}`;
+}
+function inferPossibleIntents(evidence) {
+    const intents = ["watch"];
+    if (evidence.sensitivityHint !== "sensitive") {
+        intents.push("remember");
+    }
+    if (evidence.sensitivityHint === "public_technical") {
+        intents.push("notify_owner");
+    }
+    return intents;
+}
+function inferReviewPriority(evidence) {
+    if (evidence.sensitivityHint === "sensitive")
+        return "high";
+    if (evidence.sensitivityHint === "public_technical")
+        return "medium";
+    return "low";
+}
+function inferRiskFlags(evidence) {
+    const flags = [];
+    if (evidence.sensitivityHint === "sensitive") {
+        flags.push("credential_shape_detected");
+    }
+    if (evidence.sensitivityHint === "private_context") {
+        flags.push("private_context");
+    }
+    return flags;
+}
+function buildCardFromEvidence(evidence, cycleId, now) {
+    const sourceRefs = parseSourceRefs(evidence.sourceRefsJson);
+    return {
+        id: `per_${evidence.id}`,
+        cycleId,
+        topic: extractTopic(evidence),
+        entities: extractEntities(evidence),
+        novelty: inferNovelty(evidence),
+        relevance: inferRelevance(evidence),
+        summary: inferSummary(evidence),
+        possibleIntents: inferPossibleIntents(evidence),
+        reviewPriority: inferReviewPriority(evidence),
+        sensitivityClass: evidence.sensitivityHint || "public_general",
+        riskFlags: inferRiskFlags(evidence),
+        confidence: 0.6,
+        evidenceRefs: sourceRefs,
+        createdAt: now,
+    };
+}
+export async function buildPerceptionCards(db, options) {
+    const now = options.now ?? new Date().toISOString();
+    const maxEvidence = options.maxEvidence ?? PERCEPTION_MAX_EVIDENCE_PER_CYCLE;
+    const readResult = await readEvidenceItemsByStatus(db, "pending");
+    if (readResult.degraded) {
+        return readResult.degraded;
+    }
+    const evidenceItems = readResult.rows;
+    if (evidenceItems.length === 0) {
+        return {
+            status: "empty",
+            cards: [],
+            reason: "evidence_batch_empty",
+        };
+    }
+    const truncated = evidenceItems.length > maxEvidence;
+    const selectedEvidence = evidenceItems.slice(0, maxEvidence);
+    const cards = [];
+    for (const evidence of selectedEvidence) {
+        const card = buildCardFromEvidence({
+            id: evidence.id,
+            platformId: evidence.platformId,
+            contentHash: evidence.contentHash,
+            observedAt: evidence.observedAt,
+            sensitivityHint: evidence.sensitivityHint ?? undefined,
+            sourceRefsJson: evidence.sourceRefsJson,
+            payloadJson: evidence.payloadJson,
+        }, options.cycleId, now);
+        cards.push(card);
+        // Write card to state
+        const writeResult = await writePerceptionCard(db, {
+            id: card.id,
+            createdAt: now,
+            cycleId: card.cycleId,
+            topic: card.topic,
+            entitiesJson: JSON.stringify(card.entities),
+            novelty: card.novelty,
+            relevance: card.relevance,
+            summary: card.summary,
+            riskFlagsJson: JSON.stringify(card.riskFlags),
+            confidence: card.confidence,
+            reviewPriority: card.reviewPriority,
+            sourceRefs: card.evidenceRefs,
+            redactionClass: card.sensitivityClass === "sensitive" ? "blocked" : "none",
+            lifecycleStatus: "pending",
+            payloadJson: JSON.stringify({
+                possibleIntents: card.possibleIntents,
+                sensitivityClass: card.sensitivityClass,
+            }),
+        });
+        if ("reason" in writeResult) {
+            return {
+                status: "degraded",
+                cards,
+                reason: writeResult.reason,
+            };
+        }
+    }
+    return {
+        status: "completed",
+        cards,
+        truncated,
+        reason: truncated ? "evidence_batch_truncated" : undefined,
+    };
+}

package/runtime/core/second-nature/perception/sensitivity-classifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * SensitivityClassifier — v8 context-aware sensitivity classifier.
+ *
+ * Core logic: Classify evidence text as public_technical, public_general,
+ * private_context, or sensitive using field context, source context,
+ * value shape, and entropy signals.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §3.2`
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §4.1`
+ *
+ * Dependencies:
+ * - `src/shared/types/v8-contracts.js` (SensitivityClass)
+ *
+ * Boundary:
+ * - Pure function; no DB access, no side effects.
+ * - Does not block on classification; returns degraded only on malformed input.
+ * - Technical vocabulary alone does not trigger sensitive.
+ *
+ * Test coverage: tests/unit/perception/sensitivity-classifier.test.ts
+ */
+import type { SensitivityClass } from "../../../shared/types/v8-contracts.js";
+export interface SensitivityClassification {
+    sensitivityClass: SensitivityClass;
+    confidence: number;
+    reason: string;
+    flags: string[];
+}
+export declare function classifyEvidenceSensitivity(text: string, sourceContext?: string): SensitivityClassification;
+export interface BatchClassificationResult {
+    classifications: SensitivityClassification[];
+    sensitiveCount: number;
+    privateCount: number;
+    publicTechnicalCount: number;
+    publicGeneralCount: number;
+}
+export declare function classifyEvidenceBatch(texts: string[], sourceContexts?: string[]): BatchClassificationResult;

package/runtime/core/second-nature/perception/sensitivity-classifier.js

@@ -0,0 +1,87 @@
+/**
+ * SensitivityClassifier — v8 context-aware sensitivity classifier.
+ *
+ * Core logic: Classify evidence text as public_technical, public_general,
+ * private_context, or sensitive using field context, source context,
+ * value shape, and entropy signals.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §3.2`
+ * - `.anws/v8/04_SYSTEM_DESIGN/perception-judgment-system.detail.md §4.1`
+ *
+ * Dependencies:
+ * - `src/shared/types/v8-contracts.js` (SensitivityClass)
+ *
+ * Boundary:
+ * - Pure function; no DB access, no side effects.
+ * - Does not block on classification; returns degraded only on malformed input.
+ * - Technical vocabulary alone does not trigger sensitive.
+ *
+ * Test coverage: tests/unit/perception/sensitivity-classifier.test.ts
+ */
+// ───────────────────────────────────────────────────────────────
+// Detection patterns
+// ───────────────────────────────────────────────────────────────
+const TECHNICAL_VOCABULARY = /\b(token|secret|credential|api.key|auth|oauth|jwt|bearer|ssh|rsa|ecdsa|pem|key.pair)s?\b/i;
+const VALUE_LIKE_SECRET = /\b[a-zA-Z0-9_]+\s*[:=]\s*['"][a-zA-Z0-9+/=\-_]{20,}['"]/i;
+const BEARER_TOKEN = /\bBearer\s+[a-zA-Z0-9_\-\.]{20,}/i;
+const PRIVATE_KEY_HEADER = /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/i;
+const PRIVATE_CONTEXT_MARKERS = /\b(DM|私信|private message|confidential|internal only|not for distribution|restricted)\b/i;
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export function classifyEvidenceSensitivity(text, sourceContext) {
+    if (!text || text.trim().length === 0) {
+        return {
+            sensitivityClass: "public_general",
+            confidence: 0.1,
+            reason: "empty_input",
+            flags: ["classification_low_confidence"],
+        };
+    }
+    const flags = [];
+    // 1. Credential value shape — highest priority
+    if (VALUE_LIKE_SECRET.test(text) || BEARER_TOKEN.test(text) || PRIVATE_KEY_HEADER.test(text)) {
+        return {
+            sensitivityClass: "sensitive",
+            confidence: 0.95,
+            reason: "credential_shape_detected",
+            flags: ["value_like_secret"],
+        };
+    }
+    // 2. Private source context
+    if (PRIVATE_CONTEXT_MARKERS.test(text) || (sourceContext && PRIVATE_CONTEXT_MARKERS.test(sourceContext))) {
+        return {
+            sensitivityClass: "private_context",
+            confidence: 0.8,
+            reason: "private_context_detected",
+            flags: ["private_source_markers"],
+        };
+    }
+    // 3. Technical vocabulary only
+    if (TECHNICAL_VOCABULARY.test(text)) {
+        return {
+            sensitivityClass: "public_technical",
+            confidence: 0.75,
+            reason: "technical_vocabulary_only",
+            flags: ["no_value_shape"],
+        };
+    }
+    // 4. Default — public general
+    return {
+        sensitivityClass: "public_general",
+        confidence: 0.5,
+        reason: "no_distinctive_signals",
+        flags: ["classification_low_confidence"],
+    };
+}
+export function classifyEvidenceBatch(texts, sourceContexts) {
+    const classifications = texts.map((text, i) => classifyEvidenceSensitivity(text, sourceContexts?.[i]));
+    return {
+        classifications,
+        sensitiveCount: classifications.filter((c) => c.sensitivityClass === "sensitive").length,
+        privateCount: classifications.filter((c) => c.sensitivityClass === "private_context").length,
+        publicTechnicalCount: classifications.filter((c) => c.sensitivityClass === "public_technical").length,
+        publicGeneralCount: classifications.filter((c) => c.sensitivityClass === "public_general").length,
+    };
+}