@haaaiawd/second-nature 0.1.51 → 0.2.0

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,
+    };
+}

package/runtime/core/second-nature/quiet-dream/dream-consolidation-runner.d.ts

@@ -0,0 +1,44 @@
+/**
+ * DreamConsolidationRunner — Generate memory candidates from Quiet review.
+ *
+ * Core logic: Read DreamConsolidationRun and associated QuietDailyReview,
+ * apply rules-only candidate generation, redaction gate, validation,
+ * and update run status to completed/failed/blocked.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4.2`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readDreamConsolidationRunById, readQuietDailyReviewById, writeLongTermMemoryProjection)
+ * - `src/shared/types/v8-contracts.js` (SourceRef, DegradedOperationResult, V8ReasonCode)
+ *
+ * Boundary:
+ * - Rules-only candidate generation; no model assist in this version.
+ * - Does not accept/reject projections; only creates candidates.
+ * - Redaction gate blocks sensitive private content, preserves public technical.
+ *
+ * Test coverage: tests/unit/dream/dream-consolidation-runner.test.ts
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { SourceRef, DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+export interface DreamMemoryCandidate {
+    id: string;
+    runId: string;
+    reviewId: string;
+    candidateText: string;
+    sourceRefs: SourceRef[];
+    confidence: number;
+    validationStatus: "valid" | "rejected" | "blocked";
+    validationReason?: string;
+}
+export interface RunDreamConsolidationResult {
+    runId: string;
+    status: "completed" | "failed" | "blocked";
+    candidates: DreamMemoryCandidate[];
+    reason?: V8ReasonCode;
+}
+export interface RunDreamConsolidationOptions {
+    now?: string;
+}
+export declare function runDreamConsolidation(db: StateDatabase, runId: string, options?: RunDreamConsolidationOptions): Promise<RunDreamConsolidationResult | DegradedOperationResult>;

package/runtime/core/second-nature/quiet-dream/dream-consolidation-runner.js

@@ -0,0 +1,180 @@
+/**
+ * DreamConsolidationRunner — Generate memory candidates from Quiet review.
+ *
+ * Core logic: Read DreamConsolidationRun and associated QuietDailyReview,
+ * apply rules-only candidate generation, redaction gate, validation,
+ * and update run status to completed/failed/blocked.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4.2`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readDreamConsolidationRunById, readQuietDailyReviewById, writeLongTermMemoryProjection)
+ * - `src/shared/types/v8-contracts.js` (SourceRef, DegradedOperationResult, V8ReasonCode)
+ *
+ * Boundary:
+ * - Rules-only candidate generation; no model assist in this version.
+ * - Does not accept/reject projections; only creates candidates.
+ * - Redaction gate blocks sensitive private content, preserves public technical.
+ *
+ * Test coverage: tests/unit/dream/dream-consolidation-runner.test.ts
+ */
+import { readDreamConsolidationRunById, readQuietDailyReviewById, writeLongTermMemoryProjection, } from "../../../storage/v8-state-stores.js";
+// ───────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────
+function parsePayloadJson(json) {
+    if (!json)
+        return {};
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return {};
+    }
+}
+function buildSourceRefsFromReview(review) {
+    return [
+        {
+            uri: `sn://quiet/${review.id}`,
+            family: "quiet_review",
+            id: review.id,
+            redactionClass: "none",
+            resolveStatus: "resolvable",
+        },
+    ];
+}
+function redactSensitive(input) {
+    // Simple redaction: block credential-shaped patterns
+    if (/\b(?:Bearer|token|secret|password|key)\s*[:=]\s*[a-zA-Z0-9+/=]{8,}\b/i.test(input)) {
+        return { text: "[redacted: credential shape detected]", blocked: true };
+    }
+    return { text: input, blocked: false };
+}
+function generateCandidatesFromReview(runId, reviewId, reviewPayload) {
+    const candidates = [];
+    const summary = String(reviewPayload.reviewSummary ?? "");
+    if (summary.length > 0) {
+        const { text, blocked } = redactSensitive(summary);
+        if (blocked) {
+            candidates.push({
+                id: `cand_${runId}_summary`,
+                runId,
+                reviewId,
+                candidateText: text,
+                sourceRefs: buildSourceRefsFromReview({ id: reviewId, day: "" }),
+                confidence: 0.3,
+                validationStatus: "blocked",
+                validationReason: "redaction_blocked",
+            });
+        }
+        else {
+            candidates.push({
+                id: `cand_${runId}_summary`,
+                runId,
+                reviewId,
+                candidateText: `Daily review: ${text}`,
+                sourceRefs: buildSourceRefsFromReview({ id: reviewId, day: "" }),
+                confidence: 0.6,
+                validationStatus: "valid",
+            });
+        }
+    }
+    const importanceSignals = reviewPayload.importanceSignals;
+    if (importanceSignals && importanceSignals.length > 0) {
+        const { text, blocked } = redactSensitive(importanceSignals.join("; "));
+        if (!blocked) {
+            candidates.push({
+                id: `cand_${runId}_signals`,
+                runId,
+                reviewId,
+                candidateText: `Important signals: ${text}`,
+                sourceRefs: buildSourceRefsFromReview({ id: reviewId, day: "" }),
+                confidence: 0.5,
+                validationStatus: "valid",
+            });
+        }
+    }
+    return candidates;
+}
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export async function runDreamConsolidation(db, runId, options) {
+    const now = options?.now ?? new Date().toISOString();
+    const runRead = await readDreamConsolidationRunById(db, runId);
+    if (runRead.degraded) {
+        return runRead.degraded;
+    }
+    const run = runRead.row;
+    if (!run) {
+        return {
+            status: "degraded",
+            reason: "state_unreadable",
+            ownerStage: "dream",
+            sourceRefs: [],
+            operatorNextAction: `DreamConsolidationRun ${runId} not found`,
+            retryable: false,
+        };
+    }
+    const reviewRead = await readQuietDailyReviewById(db, run.quietReviewId);
+    if (reviewRead.degraded) {
+        return reviewRead.degraded;
+    }
+    const review = reviewRead.row;
+    if (!review) {
+        return {
+            status: "degraded",
+            reason: "state_unreadable",
+            ownerStage: "dream",
+            sourceRefs: [],
+            operatorNextAction: `QuietDailyReview ${run.quietReviewId} not found`,
+            retryable: false,
+        };
+    }
+    const reviewPayload = parsePayloadJson(review.payloadJson);
+    const candidates = generateCandidatesFromReview(runId, run.quietReviewId, reviewPayload);
+    // If all candidates blocked → run blocked
+    if (candidates.length > 0 && candidates.every((c) => c.validationStatus === "blocked")) {
+        return {
+            runId,
+            status: "blocked",
+            candidates,
+            reason: "dream_blocked_redaction",
+        };
+    }
+    // Write valid candidates as projections (candidate status)
+    const validCandidates = candidates.filter((c) => c.validationStatus === "valid");
+    for (const candidate of validCandidates) {
+        const projectionResult = await writeLongTermMemoryProjection(db, {
+            id: `proj_${candidate.id}`,
+            createdAt: now,
+            candidateId: candidate.id,
+            topicKey: `topic_${review.day}`,
+            status: "candidate",
+            sourceRefs: candidate.sourceRefs,
+            redactionClass: "none",
+            lifecycleStatus: "candidate",
+            payloadJson: JSON.stringify({
+                candidateText: candidate.candidateText,
+                confidence: candidate.confidence,
+                runId,
+            }),
+        });
+        if ("reason" in projectionResult) {
+            return {
+                runId,
+                status: "failed",
+                candidates,
+                reason: projectionResult.reason,
+            };
+        }
+    }
+    return {
+        runId,
+        status: "completed",
+        candidates,
+        reason: "dream_completed",
+    };
+}

package/runtime/core/second-nature/quiet-dream/dream-scheduler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * DreamScheduler — Schedule Dream consolidation after Quiet completion.
+ *
+ * Core logic: Read a QuietDailyReview, create a DreamConsolidationRun
+ * with lifecycle trace, and write it to state. Handles unavailable
+ * scheduler by recording degraded state.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.2`
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4.2`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readQuietDailyReviewById, writeDreamConsolidationRun)
+ * - `src/shared/types/v8-contracts.js` (SourceRef, DegradedOperationResult, V8ReasonCode)
+ *
+ * Boundary:
+ * - Does not run consolidation; only schedules and records lifecycle.
+ * - Does not form long-term memory; Dream runner does that.
+ * - Degrades gracefully on missing review or unreadable state.
+ *
+ * Test coverage: tests/unit/dream/dream-scheduler-lifecycle.test.ts
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+export interface DreamScheduleResult {
+    id: string;
+    quietReviewId: string;
+    status: "scheduled" | "started" | "completed" | "failed" | "blocked";
+    reason?: V8ReasonCode;
+    createdAt: string;
+}
+export interface ScheduleDreamAfterQuietOptions {
+    now?: string;
+    schedulerAvailable?: boolean;
+}
+export declare function scheduleDreamAfterQuiet(db: StateDatabase, quietReviewId: string, options?: ScheduleDreamAfterQuietOptions): Promise<DreamScheduleResult | DegradedOperationResult>;