@haaaiawd/second-nature 0.1.39 → 0.1.40

package/runtime/dream/narrative-update-proposal.d.ts

@@ -1,34 +1,34 @@
-/**
- * Narrative Update Proposal
- *
- * Core logic: generate a narrative update proposal based on evidence and
- * extracted insights. Claims must be source-backed; unsupported claims are
- * flagged and the proposal is degraded or blocked.
- *
- * - Focus: most prominent theme from insights or evidence.
- * - Progress: learning and observation insights mapped to progress entries.
- * - NextIntent: inferred from unresolved conflicts or high-priority patterns.
- * Test coverage: tests/unit/dream/t7-1-4-narrative-update.test.ts
- */
-import type { DreamNarrativeUpdate } from "./types.js";
-export interface NarrativeProposalInput {
-    evidenceSummaries: Array<{
-        id: string;
-        summary: string;
-        createdAt: string;
-    }>;
-    insights: Array<{
-        id: string;
-        type: "pattern" | "learning" | "observation" | "conflict";
-        summary: string;
-        sourceRefs: string[];
-        confidence: number;
-    }>;
-    priorFocus?: string;
-}
-export interface NarrativeProposalResult {
-    proposal?: DreamNarrativeUpdate;
-    unsupportedClaims: string[];
-    blocked: boolean;
-}
-export declare function draftNarrativeFromDream(input: NarrativeProposalInput): NarrativeProposalResult;
+/**
+ * Narrative Update Proposal
+ *
+ * Core logic: generate a narrative update proposal based on evidence and
+ * extracted insights. Claims must be source-backed; unsupported claims are
+ * flagged and the proposal is degraded or blocked.
+ *
+ * - Focus: most prominent theme from insights or evidence.
+ * - Progress: learning and observation insights mapped to progress entries.
+ * - NextIntent: inferred from unresolved conflicts or high-priority patterns.
+ * Test coverage: tests/unit/dream/t7-1-4-narrative-update.test.ts
+ */
+import type { DreamNarrativeUpdate } from "./types.js";
+export interface NarrativeProposalInput {
+    evidenceSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+    }>;
+    insights: Array<{
+        id: string;
+        type: "pattern" | "learning" | "observation" | "conflict";
+        summary: string;
+        sourceRefs: string[];
+        confidence: number;
+    }>;
+    priorFocus?: string;
+}
+export interface NarrativeProposalResult {
+    proposal?: DreamNarrativeUpdate;
+    unsupportedClaims: string[];
+    blocked: boolean;
+}
+export declare function draftNarrativeFromDream(input: NarrativeProposalInput): NarrativeProposalResult;

package/runtime/dream/narrative-update-proposal.js

@@ -1,83 +1,83 @@
-/**
- * Narrative Update Proposal
- *
- * Core logic: generate a narrative update proposal based on evidence and
- * extracted insights. Claims must be source-backed; unsupported claims are
- * flagged and the proposal is degraded or blocked.
- *
- * - Focus: most prominent theme from insights or evidence.
- * - Progress: learning and observation insights mapped to progress entries.
- * - NextIntent: inferred from unresolved conflicts or high-priority patterns.
- * Test coverage: tests/unit/dream/t7-1-4-narrative-update.test.ts
- */
-export function draftNarrativeFromDream(input) {
-    const unsupportedClaims = [];
-    if (input.evidenceSummaries.length === 0 && input.insights.length === 0) {
-        return {
-            unsupportedClaims: ["no_evidence_for_narrative"],
-            blocked: true,
-        };
-    }
-    // Focus: highest-confidence insight summary, or first evidence if no insights
-    let focus = input.priorFocus ?? "continue exploration";
-    const highConfidenceInsights = input.insights.filter((i) => i.confidence >= 0.6);
-    if (highConfidenceInsights.length > 0) {
-        // Pick the insight with highest confidence
-        const top = highConfidenceInsights.sort((a, b) => b.confidence - a.confidence)[0];
-        focus = top.summary.slice(0, 120);
-    }
-    else if (input.evidenceSummaries.length > 0) {
-        focus = input.evidenceSummaries[0].summary.slice(0, 120);
-    }
-    // Progress: learning + observation insights become progress entries
-    const progressAdditions = [];
-    for (const insight of input.insights) {
-        if (insight.type === "learning" || insight.type === "observation") {
-            progressAdditions.push(insight.summary.slice(0, 200));
-        }
-    }
-    if (progressAdditions.length === 0 && input.evidenceSummaries.length > 0) {
-        // Fallback: use most recent evidence as progress
-        const recent = [...input.evidenceSummaries].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
-        if (recent) {
-            progressAdditions.push(recent.summary.slice(0, 200));
-        }
-    }
-    // NextIntent: if conflicts exist, intent is to resolve; otherwise continue
-    const hasConflict = input.insights.some((i) => i.type === "conflict");
-    const nextIntent = hasConflict
-        ? "resolve_conflicts_and_validate"
-        : "continue_current_focus";
-    // Source refs: collect all insight source refs + evidence ids
-    const sourceRefs = new Set();
-    for (const insight of input.insights) {
-        for (const ref of insight.sourceRefs) {
-            sourceRefs.add(ref);
-        }
-    }
-    for (const ev of input.evidenceSummaries) {
-        sourceRefs.add(ev.id);
-    }
-    // Confidence: average of insight confidences, or 0.5 fallback
-    const avgConfidence = input.insights.length > 0
-        ? input.insights.reduce((sum, i) => sum + i.confidence, 0) /
-            input.insights.length
-        : 0.5;
-    // Degrade if confidence too low
-    if (avgConfidence < 0.3) {
-        unsupportedClaims.push("low_average_confidence_for_narrative");
-    }
-    const blocked = unsupportedClaims.length > 0 && avgConfidence < 0.2;
-    return {
-        proposal: {
-            focus,
-            progressAdditions: progressAdditions.slice(0, 20),
-            nextIntent,
-            confidenceDelta: Number(avgConfidence.toFixed(2)),
-            sourceRefs: Array.from(sourceRefs).slice(0, 50),
-            unsupportedClaims,
-        },
-        unsupportedClaims,
-        blocked,
-    };
-}
+/**
+ * Narrative Update Proposal
+ *
+ * Core logic: generate a narrative update proposal based on evidence and
+ * extracted insights. Claims must be source-backed; unsupported claims are
+ * flagged and the proposal is degraded or blocked.
+ *
+ * - Focus: most prominent theme from insights or evidence.
+ * - Progress: learning and observation insights mapped to progress entries.
+ * - NextIntent: inferred from unresolved conflicts or high-priority patterns.
+ * Test coverage: tests/unit/dream/t7-1-4-narrative-update.test.ts
+ */
+export function draftNarrativeFromDream(input) {
+    const unsupportedClaims = [];
+    if (input.evidenceSummaries.length === 0 && input.insights.length === 0) {
+        return {
+            unsupportedClaims: ["no_evidence_for_narrative"],
+            blocked: true,
+        };
+    }
+    // Focus: highest-confidence insight summary, or first evidence if no insights
+    let focus = input.priorFocus ?? "continue exploration";
+    const highConfidenceInsights = input.insights.filter((i) => i.confidence >= 0.6);
+    if (highConfidenceInsights.length > 0) {
+        // Pick the insight with highest confidence
+        const top = highConfidenceInsights.sort((a, b) => b.confidence - a.confidence)[0];
+        focus = top.summary.slice(0, 120);
+    }
+    else if (input.evidenceSummaries.length > 0) {
+        focus = input.evidenceSummaries[0].summary.slice(0, 120);
+    }
+    // Progress: learning + observation insights become progress entries
+    const progressAdditions = [];
+    for (const insight of input.insights) {
+        if (insight.type === "learning" || insight.type === "observation") {
+            progressAdditions.push(insight.summary.slice(0, 200));
+        }
+    }
+    if (progressAdditions.length === 0 && input.evidenceSummaries.length > 0) {
+        // Fallback: use most recent evidence as progress
+        const recent = [...input.evidenceSummaries].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+        if (recent) {
+            progressAdditions.push(recent.summary.slice(0, 200));
+        }
+    }
+    // NextIntent: if conflicts exist, intent is to resolve; otherwise continue
+    const hasConflict = input.insights.some((i) => i.type === "conflict");
+    const nextIntent = hasConflict
+        ? "resolve_conflicts_and_validate"
+        : "continue_current_focus";
+    // Source refs: collect all insight source refs + evidence ids
+    const sourceRefs = new Set();
+    for (const insight of input.insights) {
+        for (const ref of insight.sourceRefs) {
+            sourceRefs.add(ref);
+        }
+    }
+    for (const ev of input.evidenceSummaries) {
+        sourceRefs.add(ev.id);
+    }
+    // Confidence: average of insight confidences, or 0.5 fallback
+    const avgConfidence = input.insights.length > 0
+        ? input.insights.reduce((sum, i) => sum + i.confidence, 0) /
+            input.insights.length
+        : 0.5;
+    // Degrade if confidence too low
+    if (avgConfidence < 0.3) {
+        unsupportedClaims.push("low_average_confidence_for_narrative");
+    }
+    const blocked = unsupportedClaims.length > 0 && avgConfidence < 0.2;
+    return {
+        proposal: {
+            focus,
+            progressAdditions: progressAdditions.slice(0, 20),
+            nextIntent,
+            confidenceDelta: Number(avgConfidence.toFixed(2)),
+            sourceRefs: Array.from(sourceRefs).slice(0, 50),
+            unsupportedClaims,
+        },
+        unsupportedClaims,
+        blocked,
+    };
+}

package/runtime/dream/output-validator.d.ts

@@ -1,20 +1,20 @@
-/**
- * Dream output validator.
- *
- * Core logic: schema, source grounding, sensitivity, and unsupported claim
- * checks on candidate DreamOutput. Decides accepted eligibility or archive reason.
- * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
- */
-import type { DreamOutput, DreamOutputValidation } from "./types.js";
-export interface ValidationInput {
-    output: DreamOutput;
-    inputEvidenceIds: string[];
-    inputChronicleIds: string[];
-    inputToolExperienceIds?: string[];
-}
-export interface ValidationResult {
-    eligible: boolean;
-    validation: DreamOutputValidation;
-    archiveReasons: string[];
-}
-export declare function validateDreamOutput(input: ValidationInput): ValidationResult;
+/**
+ * Dream output validator.
+ *
+ * Core logic: schema, source grounding, sensitivity, and unsupported claim
+ * checks on candidate DreamOutput. Decides accepted eligibility or archive reason.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { DreamOutput, DreamOutputValidation } from "./types.js";
+export interface ValidationInput {
+    output: DreamOutput;
+    inputEvidenceIds: string[];
+    inputChronicleIds: string[];
+    inputToolExperienceIds?: string[];
+}
+export interface ValidationResult {
+    eligible: boolean;
+    validation: DreamOutputValidation;
+    archiveReasons: string[];
+}
+export declare function validateDreamOutput(input: ValidationInput): ValidationResult;

package/runtime/dream/output-validator.js

@@ -1,110 +1,110 @@
-/**
- * Dream output validator.
- *
- * Core logic: schema, source grounding, sensitivity, and unsupported claim
- * checks on candidate DreamOutput. Decides accepted eligibility or archive reason.
- * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
- */
-function hasUnsupportedClaims(output) {
-    const claims = [];
-    for (const insight of output.insights) {
-        if (insight.confidence < 0.3) {
-            claims.push(`insight_low_confidence:${insight.id}`);
-        }
-        if (insight.sourceRefs.length === 0) {
-            claims.push(`insight_no_source:${insight.id}`);
-        }
-    }
-    if (output.narrativeUpdate) {
-        if (output.narrativeUpdate.unsupportedClaims.length > 0) {
-            claims.push(...output.narrativeUpdate.unsupportedClaims);
-        }
-        if (output.narrativeUpdate.sourceRefs.length === 0) {
-            claims.push("narrative_update_no_source");
-        }
-    }
-    if (output.relationshipUpdate) {
-        if (output.relationshipUpdate.sourceRefs.length === 0) {
-            claims.push("relationship_update_no_source");
-        }
-    }
-    return claims;
-}
-function isSourceGrounded(output, inputEvidenceIds, inputChronicleIds, inputToolExperienceIds) {
-    const validSourceIds = new Set([
-        ...inputEvidenceIds,
-        ...inputChronicleIds,
-        ...(inputToolExperienceIds ?? []),
-    ]);
-    for (const entry of output.canonicalEntries) {
-        for (const ref of entry.sourceRefs) {
-            if (!validSourceIds.has(ref.sourceId)) {
-                return false;
-            }
-        }
-    }
-    for (const insight of output.insights) {
-        for (const refId of insight.sourceRefs) {
-            if (!validSourceIds.has(refId)) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-function hasSensitivityIssues(output) {
-    const issues = [];
-    for (const entry of output.canonicalEntries) {
-        const text = JSON.stringify(entry).toLowerCase();
-        if (text.includes("password") || text.includes("token") || text.includes("secret")) {
-            issues.push(`sensitivity_in_entry:${entry.entryId}`);
-        }
-    }
-    return issues;
-}
-export function validateDreamOutput(input) {
-    const errors = [];
-    const archiveReasons = [];
-    // Schema: basic structural checks
-    const schemaValid = typeof input.output.outputId === "string" &&
-        input.output.outputId.length > 0 &&
-        typeof input.output.runId === "string" &&
-        Array.isArray(input.output.canonicalEntries) &&
-        Array.isArray(input.output.insights);
-    if (!schemaValid) {
-        errors.push("schema_invalid");
-        archiveReasons.push("schema_invalid");
-    }
-    // Source grounding
-    const sourceGrounded = isSourceGrounded(input.output, input.inputEvidenceIds, input.inputChronicleIds, input.inputToolExperienceIds);
-    if (!sourceGrounded) {
-        errors.push("source_not_grounded");
-        archiveReasons.push("source_not_grounded");
-    }
-    // Sensitivity
-    const sensitivityIssues = hasSensitivityIssues(input.output);
-    const sensitivityClean = sensitivityIssues.length === 0;
-    if (!sensitivityClean) {
-        errors.push(...sensitivityIssues);
-        archiveReasons.push(...sensitivityIssues);
-    }
-    // Unsupported claims
-    const unsupportedClaims = hasUnsupportedClaims(input.output);
-    if (unsupportedClaims.length > 0) {
-        errors.push(...unsupportedClaims);
-        archiveReasons.push("unsupported_claims_present");
-    }
-    const eligible = schemaValid && sourceGrounded && sensitivityClean && unsupportedClaims.length === 0;
-    return {
-        eligible,
-        validation: {
-            schemaValid,
-            sourceGrounded,
-            sensitivityClean,
-            unsupportedClaims,
-            errors,
-            checkedAt: new Date().toISOString(),
-        },
-        archiveReasons,
-    };
-}
+/**
+ * Dream output validator.
+ *
+ * Core logic: schema, source grounding, sensitivity, and unsupported claim
+ * checks on candidate DreamOutput. Decides accepted eligibility or archive reason.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+function hasUnsupportedClaims(output) {
+    const claims = [];
+    for (const insight of output.insights) {
+        if (insight.confidence < 0.3) {
+            claims.push(`insight_low_confidence:${insight.id}`);
+        }
+        if (insight.sourceRefs.length === 0) {
+            claims.push(`insight_no_source:${insight.id}`);
+        }
+    }
+    if (output.narrativeUpdate) {
+        if (output.narrativeUpdate.unsupportedClaims.length > 0) {
+            claims.push(...output.narrativeUpdate.unsupportedClaims);
+        }
+        if (output.narrativeUpdate.sourceRefs.length === 0) {
+            claims.push("narrative_update_no_source");
+        }
+    }
+    if (output.relationshipUpdate) {
+        if (output.relationshipUpdate.sourceRefs.length === 0) {
+            claims.push("relationship_update_no_source");
+        }
+    }
+    return claims;
+}
+function isSourceGrounded(output, inputEvidenceIds, inputChronicleIds, inputToolExperienceIds) {
+    const validSourceIds = new Set([
+        ...inputEvidenceIds,
+        ...inputChronicleIds,
+        ...(inputToolExperienceIds ?? []),
+    ]);
+    for (const entry of output.canonicalEntries) {
+        for (const ref of entry.sourceRefs) {
+            if (!validSourceIds.has(ref.sourceId)) {
+                return false;
+            }
+        }
+    }
+    for (const insight of output.insights) {
+        for (const refId of insight.sourceRefs) {
+            if (!validSourceIds.has(refId)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function hasSensitivityIssues(output) {
+    const issues = [];
+    for (const entry of output.canonicalEntries) {
+        const text = JSON.stringify(entry).toLowerCase();
+        if (text.includes("password") || text.includes("token") || text.includes("secret")) {
+            issues.push(`sensitivity_in_entry:${entry.entryId}`);
+        }
+    }
+    return issues;
+}
+export function validateDreamOutput(input) {
+    const errors = [];
+    const archiveReasons = [];
+    // Schema: basic structural checks
+    const schemaValid = typeof input.output.outputId === "string" &&
+        input.output.outputId.length > 0 &&
+        typeof input.output.runId === "string" &&
+        Array.isArray(input.output.canonicalEntries) &&
+        Array.isArray(input.output.insights);
+    if (!schemaValid) {
+        errors.push("schema_invalid");
+        archiveReasons.push("schema_invalid");
+    }
+    // Source grounding
+    const sourceGrounded = isSourceGrounded(input.output, input.inputEvidenceIds, input.inputChronicleIds, input.inputToolExperienceIds);
+    if (!sourceGrounded) {
+        errors.push("source_not_grounded");
+        archiveReasons.push("source_not_grounded");
+    }
+    // Sensitivity
+    const sensitivityIssues = hasSensitivityIssues(input.output);
+    const sensitivityClean = sensitivityIssues.length === 0;
+    if (!sensitivityClean) {
+        errors.push(...sensitivityIssues);
+        archiveReasons.push(...sensitivityIssues);
+    }
+    // Unsupported claims
+    const unsupportedClaims = hasUnsupportedClaims(input.output);
+    if (unsupportedClaims.length > 0) {
+        errors.push(...unsupportedClaims);
+        archiveReasons.push("unsupported_claims_present");
+    }
+    const eligible = schemaValid && sourceGrounded && sensitivityClean && unsupportedClaims.length === 0;
+    return {
+        eligible,
+        validation: {
+            schemaValid,
+            sourceGrounded,
+            sensitivityClean,
+            unsupportedClaims,
+            errors,
+            checkedAt: new Date().toISOString(),
+        },
+        archiveReasons,
+    };
+}

package/runtime/dream/redaction-gate.d.ts

@@ -1,31 +1,31 @@
-/**
- * Dream redaction gate.
- *
- * Core logic: before sending evidence to LLM, strip credential-like fields,
- * PII patterns, and sensitive platform payload. If redaction fails or
- * sensitivity is too high, block the LLM stage and record reason.
- * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
- */
-import type { RedactedEvidenceBundle } from "./types.js";
-export interface RedactionInput {
-    evidenceSummaries: string[];
-    chronicleSummaries: string[];
-    activeMemorySummaries?: string[];
-    sensitivityFlags?: string[];
-}
-export interface RedactionResult {
-    allowed: boolean;
-    redactedEvidence: string[];
-    redactedChronicle: string[];
-    redactedMemory: string[];
-    blockedReason?: string;
-    credentialHits: number;
-    piiHits: number;
-}
-/**
- * Produce a RedactedEvidenceBundle brand type (DR-027).
- * Must be called before passing evidence to ModelAssistPort.
- * Returns null if redaction gate blocks the bundle.
- */
-export declare function redactBundle(evidence: string[], chronicle: string[], memory?: string[]): RedactedEvidenceBundle | null;
-export declare function redactDreamInput(input: RedactionInput): RedactionResult;
+/**
+ * Dream redaction gate.
+ *
+ * Core logic: before sending evidence to LLM, strip credential-like fields,
+ * PII patterns, and sensitive platform payload. If redaction fails or
+ * sensitivity is too high, block the LLM stage and record reason.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { RedactedEvidenceBundle } from "./types.js";
+export interface RedactionInput {
+    evidenceSummaries: string[];
+    chronicleSummaries: string[];
+    activeMemorySummaries?: string[];
+    sensitivityFlags?: string[];
+}
+export interface RedactionResult {
+    allowed: boolean;
+    redactedEvidence: string[];
+    redactedChronicle: string[];
+    redactedMemory: string[];
+    blockedReason?: string;
+    credentialHits: number;
+    piiHits: number;
+}
+/**
+ * Produce a RedactedEvidenceBundle brand type (DR-027).
+ * Must be called before passing evidence to ModelAssistPort.
+ * Returns null if redaction gate blocks the bundle.
+ */
+export declare function redactBundle(evidence: string[], chronicle: string[], memory?: string[]): RedactedEvidenceBundle | null;
+export declare function redactDreamInput(input: RedactionInput): RedactionResult;