@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/unit/guidance/outreach-draft-schema.test.js

@@ -0,0 +1,56 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseOutreachDraftRequest, safeParseOutreachDraftRequest, } from "../../../src/guidance/outreach-draft-schema.js";
+const validBase = {
+    requestId: "req-1",
+    sceneType: "outreach",
+    runtimeScope: "rhythm",
+    riskLevel: "medium",
+    sourceRefs: [{ id: "s1", kind: "platform_item", uri: "https://x/y" }],
+    decisionId: "dec-1",
+    candidateId: "cand-1",
+    judgmentVerdict: "allow",
+    valueScore: 0.82,
+    interestRefs: [{ id: "i1", kind: "user_anchor", uri: "file:///USER.md" }],
+    deliveryContext: {
+        deliveryVerdict: "target_available",
+        wordingMode: "sendable",
+    },
+};
+test("T6.1.1 parseOutreachDraftRequest accepts full contract", () => {
+    const p = parseOutreachDraftRequest(validBase);
+    assert.equal(p.decisionId, "dec-1");
+    assert.equal(p.judgmentVerdict, "allow");
+    assert.equal(p.valueScore, 0.82);
+    assert.equal(p.deliveryContext?.wordingMode, "sendable");
+});
+test("T6.1.1 fallback_candidate with not_sent wording", () => {
+    const p = parseOutreachDraftRequest({
+        ...validBase,
+        sceneType: "fallback_candidate",
+        deliveryContext: {
+            deliveryVerdict: "target_none",
+            wordingMode: "not_sent_fallback_candidate",
+        },
+    });
+    assert.equal(p.sceneType, "fallback_candidate");
+    assert.equal(p.deliveryContext?.wordingMode, "not_sent_fallback_candidate");
+});
+test("T6.1.1 missing decisionId fails", () => {
+    const bad = { ...validBase, decisionId: "" };
+    assert.throws(() => parseOutreachDraftRequest(bad), /Too small/);
+});
+test("T6.1.1 missing deliveryContext fails", () => {
+    const { deliveryContext: _d, ...rest } = validBase;
+    assert.throws(() => parseOutreachDraftRequest(rest), /outreach_draft_requires_delivery_context/);
+});
+test("T6.1.1 missing deliveryContext optional but wording invalid enum fails when present", () => {
+    const r = safeParseOutreachDraftRequest({
+        ...validBase,
+        deliveryContext: {
+            deliveryVerdict: "target_available",
+            wordingMode: "invalid",
+        },
+    });
+    assert.equal(r.success, false);
+});

package/dist/tests/unit/guidance/outreach-strategy-selector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/guidance/outreach-strategy-selector.test.js

@@ -0,0 +1,208 @@
+/**
+ * Tests for OutreachStrategySelector — T-GVS.C.3
+ *
+ * Covers:
+ * - selectOutreachStrategy: frequency selection from no-reply signals, trust delta, block
+ * - selectOutreachStrategy: style selection from tone patterns
+ * - selectOutreachStrategy: fallback copy information value
+ * - runStyleLint: DR-031 rules (no_dry_filler, anchored, no_over_explain)
+ * - buildFallbackCopy: channel-safe, non-empty, contains anchor when available
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { selectOutreachStrategy, runStyleLint, buildFallbackCopy, } from "../../../src/guidance/outreach-strategy-selector.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function makeMemory(overrides = {}) {
+    return {
+        channelPreferences: [],
+        responsePatterns: [],
+        trustDelta: 0,
+        ...overrides,
+    };
+}
+function makePattern(reaction, tone = "neutral") {
+    return {
+        reaction,
+        timing: "delayed",
+        tone,
+        observedAt: new Date().toISOString(),
+    };
+}
+// ─── selectOutreachStrategy: frequency ───────────────────────────────────────
+describe("selectOutreachStrategy — frequency", () => {
+    it("returns standard when trust is positive and no signals", () => {
+        const result = selectOutreachStrategy(makeMemory({ trustDelta: 0.3 }));
+        assert.equal(result.frequency, "standard");
+    });
+    it("returns reduced when ≥50% of recent 5 patterns are ignore", () => {
+        const patterns = [
+            makePattern("ignore"),
+            makePattern("ignore"),
+            makePattern("ignore"),
+            makePattern("reply", "positive"),
+            makePattern("reply", "positive"),
+        ];
+        const result = selectOutreachStrategy(makeMemory({ responsePatterns: patterns }));
+        assert.equal(result.frequency, "reduced");
+    });
+    it("returns minimal when trustDelta <= -0.4", () => {
+        const result = selectOutreachStrategy(makeMemory({ trustDelta: -0.5 }));
+        assert.equal(result.frequency, "minimal");
+    });
+    it("returns paused when any block reaction exists", () => {
+        const patterns = [
+            makePattern("reply", "positive"),
+            makePattern("block", "negative"),
+        ];
+        const result = selectOutreachStrategy(makeMemory({ trustDelta: 0.5, responsePatterns: patterns }));
+        assert.equal(result.frequency, "paused");
+    });
+    it("returns reduced for trustDelta between -0.4 and -0.1", () => {
+        const result = selectOutreachStrategy(makeMemory({ trustDelta: -0.2 }));
+        assert.equal(result.frequency, "reduced");
+    });
+});
+// ─── selectOutreachStrategy: style ───────────────────────────────────────────
+describe("selectOutreachStrategy — style", () => {
+    it("returns warm_anchored for mostly positive recent patterns", () => {
+        const patterns = [
+            makePattern("reply", "positive"),
+            makePattern("react", "positive"),
+            makePattern("reply", "positive"),
+        ];
+        const result = selectOutreachStrategy(makeMemory({ responsePatterns: patterns, trustDelta: 0.3 }));
+        assert.equal(result.style, "warm_anchored");
+    });
+    it("returns concise_factual for mixed/neutral patterns", () => {
+        const patterns = [
+            makePattern("reply", "neutral"),
+            makePattern("ignore", "neutral"),
+        ];
+        const result = selectOutreachStrategy(makeMemory({ responsePatterns: patterns }));
+        assert.equal(result.style, "concise_factual");
+    });
+    it("returns light_check when paused", () => {
+        const patterns = [makePattern("block", "negative")];
+        const result = selectOutreachStrategy(makeMemory({ responsePatterns: patterns }));
+        assert.equal(result.style, "light_check");
+    });
+    it("returns light_check when mostly negative tone", () => {
+        const patterns = [
+            makePattern("ignore", "negative"),
+            makePattern("ignore", "negative"),
+            makePattern("reply", "positive"),
+        ];
+        const result = selectOutreachStrategy(makeMemory({ responsePatterns: patterns }));
+        assert.equal(result.style, "light_check");
+    });
+});
+// ─── selectOutreachStrategy: fallback copy ───────────────────────────────────
+describe("selectOutreachStrategy — fallback copy", () => {
+    it("fallback copy has information value and non-empty text", () => {
+        const result = selectOutreachStrategy(makeMemory());
+        assert.ok(result.fallbackCopy.hasInformationValue);
+        assert.ok(result.fallbackCopy.text.length > 0);
+        assert.ok(result.fallbackCopy.channelSafeReason.length > 0);
+    });
+    it("fallback copy contains source anchor when provided", () => {
+        const result = selectOutreachStrategy(makeMemory(), {
+            fallbackContext: {
+                sourceRefs: ["evidence:abc123"],
+                reason: "Delivery unavailable.",
+                channelId: "moltbook",
+            },
+        });
+        assert.ok(result.fallbackCopy.sourceAnchor === "evidence:abc123");
+        assert.ok(result.fallbackCopy.text.includes("evidence:abc123"));
+    });
+    it("fallback copy with sourceRefs and reason contains anchor in text", () => {
+        const result = selectOutreachStrategy(makeMemory(), {
+            fallbackContext: {
+                sourceRefs: ["ref:my-observation"],
+                reason: "Channel not available right now.",
+                channelId: "instreet",
+            },
+        });
+        assert.ok(result.fallbackCopy.text.includes("ref:my-observation"));
+        assert.ok(result.fallbackCopy.channelSafeReason.includes("instreet"));
+    });
+});
+// ─── runStyleLint ─────────────────────────────────────────────────────────────
+describe("runStyleLint — DR-031 language quality checklist", () => {
+    it("passes for anchored, concise draft with no filler", () => {
+        const draft = "Based on your last message about project deadlines, wanted to share an observation.";
+        const result = runStyleLint(draft);
+        assert.equal(result.lintStatus, "passed");
+        assert.equal(result.passed, true);
+        assert.deepEqual(result.violations, []);
+    });
+    it("flags no_dry_filler for 'just checking in'", () => {
+        const draft = "Hey, just checking in to see how things are going.";
+        const result = runStyleLint(draft);
+        assert.equal(result.lintStatus, "style_lint_failed");
+        assert.ok(result.hitRules.includes("no_dry_filler"));
+    });
+    it("flags anchored when no concrete reference present", () => {
+        const draft = "Wanted to say hello and see how you are doing today.";
+        const result = runStyleLint(draft);
+        assert.equal(result.lintStatus, "style_lint_failed");
+        assert.ok(result.hitRules.includes("anchored"));
+    });
+    it("flags no_over_explain when ≥3 hedge phrases present", () => {
+        const draft = "Based on what you said, maybe it could possibly work, not sure if perhaps this helps.";
+        const result = runStyleLint(draft);
+        assert.equal(result.lintStatus, "style_lint_failed");
+        assert.ok(result.hitRules.includes("no_over_explain"));
+    });
+    it("style_lint_failed does not throw — degraded marker only", () => {
+        // DR-031: lint failure is a marker, never an exception
+        const draft = "Just following up to touch base.";
+        assert.doesNotThrow(() => runStyleLint(draft));
+        const result = runStyleLint(draft);
+        assert.equal(result.lintStatus, "style_lint_failed");
+    });
+    it("returns specific rules hit in hitRules array", () => {
+        const draft = "Just reaching out, maybe, possibly, not sure if this helps, perhaps.";
+        const result = runStyleLint(draft);
+        assert.ok(result.hitRules.includes("no_dry_filler"));
+        assert.ok(result.hitRules.includes("anchored"));
+        assert.ok(result.hitRules.includes("no_over_explain"));
+    });
+});
+// ─── buildFallbackCopy ───────────────────────────────────────────────────────
+describe("buildFallbackCopy", () => {
+    it("always sets hasInformationValue = true", () => {
+        const result = buildFallbackCopy({ sourceRefs: [], reason: "Unavailable." });
+        assert.equal(result.hasInformationValue, true);
+    });
+    it("text is never empty string", () => {
+        const result = buildFallbackCopy({ sourceRefs: [], reason: "Unavailable." });
+        assert.ok(result.text.length > 0);
+    });
+    it("includes sourceRef anchor in text when refs provided", () => {
+        const result = buildFallbackCopy({
+            sourceRefs: ["claim:xyz"],
+            reason: "Channel offline.",
+            channelId: "moltbook",
+        });
+        assert.ok(result.text.includes("claim:xyz"));
+        assert.equal(result.sourceAnchor, "claim:xyz");
+    });
+    it("channelSafeReason includes channelId when provided", () => {
+        const result = buildFallbackCopy({
+            sourceRefs: [],
+            reason: "Platform maintenance.",
+            channelId: "instreet",
+        });
+        assert.ok(result.channelSafeReason.includes("instreet"));
+    });
+    it("fallback copy text does not contain unsupported claims", () => {
+        const result = buildFallbackCopy({
+            sourceRefs: ["ref:real-data"],
+            reason: "User is unavailable.",
+        });
+        // Must not contain fabricated claims — only the anchor and reason
+        assert.ok(!result.text.includes("you definitely"));
+        assert.ok(!result.text.includes("I know for sure"));
+    });
+});

package/dist/tests/unit/guidance/outreach-style-fixtures.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/guidance/outreach-style-fixtures.test.js

@@ -0,0 +1,81 @@
+/**
+ * Fixture-based style lint tests — T-GVS.C.3 (DR-031)
+ *
+ * Covers:
+ * - dry/plain draft → style_lint_failed with specific rule list
+ * - anchored + concise draft → passed, no degraded marker
+ * - fallback copy with sourceRefs + reason → concrete anchor, channel-safe reason, no unsupported claim
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { runStyleLint, buildFallbackCopy } from "../../../src/guidance/outreach-strategy-selector.js";
+// ─── Fixture: dry/plain draft ─────────────────────────────────────────────────
+const DRY_PLAIN_FIXTURE = "Hey, just checking in! Reaching out to touch base — hope you're well.";
+// ─── Fixture: anchored + concise draft ───────────────────────────────────────
+const ANCHORED_CONCISE_FIXTURE = "After reading your update last week about the workshop [ref:workshop-2026-05], noticed a connection to the project thread you mentioned.";
+// ─── Fixture: fallback context ────────────────────────────────────────────────
+const FALLBACK_FIXTURE_CTX = {
+    sourceRefs: ["ref:observation-2026-05-23", "ref:goal-completion"],
+    reason: "Delivery channel currently unavailable due to platform maintenance.",
+    channelId: "moltbook",
+    ownerPreferenceRef: "pref:moltbook-timing",
+};
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe("outreach-style-fixtures: dry/plain draft", () => {
+    it("dry/plain draft returns style_lint_failed", () => {
+        const result = runStyleLint(DRY_PLAIN_FIXTURE);
+        assert.equal(result.lintStatus, "style_lint_failed");
+    });
+    it("dry/plain draft lists no_dry_filler in hitRules", () => {
+        const result = runStyleLint(DRY_PLAIN_FIXTURE);
+        assert.ok(result.hitRules.includes("no_dry_filler"), `hitRules: ${JSON.stringify(result.hitRules)}`);
+    });
+    it("dry/plain draft lists anchored in hitRules (no concrete reference)", () => {
+        const result = runStyleLint(DRY_PLAIN_FIXTURE);
+        assert.ok(result.hitRules.includes("anchored"), `hitRules: ${JSON.stringify(result.hitRules)}`);
+    });
+    it("violations array is non-empty for dry/plain draft", () => {
+        const result = runStyleLint(DRY_PLAIN_FIXTURE);
+        assert.ok(result.violations.length > 0);
+    });
+});
+describe("outreach-style-fixtures: anchored + concise draft", () => {
+    it("anchored + concise draft passes lint", () => {
+        const result = runStyleLint(ANCHORED_CONCISE_FIXTURE);
+        assert.equal(result.lintStatus, "passed");
+    });
+    it("anchored + concise draft produces no violations", () => {
+        const result = runStyleLint(ANCHORED_CONCISE_FIXTURE);
+        assert.deepEqual(result.violations, []);
+    });
+    it("anchored + concise draft has empty hitRules", () => {
+        const result = runStyleLint(ANCHORED_CONCISE_FIXTURE);
+        assert.deepEqual(result.hitRules, []);
+    });
+});
+describe("outreach-style-fixtures: fallback copy with sourceRefs + reason", () => {
+    it("fallback copy text contains first sourceRef as anchor", () => {
+        const fc = buildFallbackCopy(FALLBACK_FIXTURE_CTX);
+        assert.ok(fc.text.includes("ref:observation-2026-05-23"), `text: ${fc.text}`);
+    });
+    it("fallback copy channelSafeReason contains channelId", () => {
+        const fc = buildFallbackCopy(FALLBACK_FIXTURE_CTX);
+        assert.ok(fc.channelSafeReason.includes("moltbook"), `channelSafeReason: ${fc.channelSafeReason}`);
+    });
+    it("fallback copy does not contain unsupported claims", () => {
+        const fc = buildFallbackCopy(FALLBACK_FIXTURE_CTX);
+        const unsupportedClaims = ["you definitely", "I know for sure", "guaranteed", "certainly will"];
+        for (const claim of unsupportedClaims) {
+            assert.ok(!fc.text.includes(claim), `Found unsupported claim "${claim}" in: ${fc.text}`);
+        }
+    });
+    it("fallback copy hasInformationValue is always true", () => {
+        const fc = buildFallbackCopy(FALLBACK_FIXTURE_CTX);
+        assert.equal(fc.hasInformationValue, true);
+    });
+    it("fallback copy text is non-empty even with no sourceRefs", () => {
+        const fc = buildFallbackCopy({ sourceRefs: [], reason: "Platform offline.", channelId: "instreet" });
+        assert.ok(fc.text.length > 0);
+        assert.equal(fc.hasInformationValue, true);
+    });
+});

package/dist/tests/unit/guidance/t6-1-1-narrative-outreach.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/guidance/t6-1-1-narrative-outreach.test.js

@@ -0,0 +1,256 @@
+/**
+ * Unit coverage for `draftNarrativeOutreach` (T6.1.1).
+ *
+ * Verifies source-backed draft generation, missing source blocking,
+ * insufficient source degradation, and insufficient_history tone.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { draftNarrativeOutreach } from "../../../src/guidance/draft-narrative-outreach.js";
+function makeRef(id) {
+    return { sourceId: id, kind: "platform_item", url: `https://example.com/${id}` };
+}
+test("T6.1.1 draft includes what happened, why it matters, and source refs", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1"), makeRef("ev-2")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "EvoMap profile updated",
+            progress: ["connected node"],
+            nextIntent: "verify task claim",
+            confidence: 0.8,
+            sourceRefs: [makeRef("ev-1")],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+        relationshipMemory: {
+            relationshipId: "r1",
+            revision: 1,
+            tonePreference: "casual",
+            noReplyCount: 0,
+            topicAffinities: [{ topic: "work", affinity: 0.5 }],
+            updatedAt: "2026-05-16T00:00:00.000Z",
+            sourceRefs: [],
+        },
+    });
+    assert.equal(result.groundingReport.status, "grounded");
+    assert.equal(result.draft.whatHappened, "EvoMap profile updated");
+    assert.ok(result.draft.whyItMatters.includes("verify task claim"));
+    assert.equal(result.draft.sourceRefs.length, 2);
+    assert.equal(result.draft.tone, "friend");
+    assert.equal(result.promptVersion, "v6-rules-only-1.0");
+});
+test("T6.1.1 blocked when source refs missing", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "something happened",
+            progress: [],
+            nextIntent: "",
+            confidence: 0.5,
+            sourceRefs: [],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+    });
+    assert.equal(result.groundingReport.status, "blocked");
+    assert.equal(result.draft.tone, "blocked");
+    assert.equal(result.draft.whatHappened, "");
+    assert.ok(result.groundingReport.unsupportedClaims.includes("missing_evidence_refs"));
+});
+test("T6.1.1 degraded when source coverage is low", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "unrelated focus A",
+            progress: ["unrelated progress B"],
+            nextIntent: "",
+            confidence: 0.5,
+            sourceRefs: [],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+    });
+    assert.equal(result.groundingReport.status, "degraded");
+    assert.equal(result.draft.tone, "insufficient_history");
+    assert.ok(result.groundingReport.sourceCoverage < 0.5);
+});
+test("T6.1.1 insufficient_history tone when relationship depth is low", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "EvoMap profile updated",
+            progress: ["connected node"],
+            nextIntent: "verify task claim",
+            confidence: 0.8,
+            sourceRefs: [makeRef("ev-1")],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+        relationshipMemory: {
+            relationshipId: "r1",
+            revision: 1,
+            tonePreference: "quiet",
+            noReplyCount: 5,
+            topicAffinities: [],
+            updatedAt: "2026-05-16T00:00:00.000Z",
+            sourceRefs: [],
+        },
+    });
+    assert.equal(result.groundingReport.status, "grounded");
+    assert.equal(result.draft.tone, "insufficient_history");
+});
+test("T6.1.1 friend tone when relationship depth is adequate", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "EvoMap profile updated",
+            progress: ["connected node"],
+            nextIntent: "verify task claim",
+            confidence: 0.8,
+            sourceRefs: [makeRef("ev-1")],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+        relationshipMemory: {
+            relationshipId: "r1",
+            revision: 1,
+            tonePreference: "casual",
+            noReplyCount: 0,
+            topicAffinities: [{ topic: "work", affinity: 0.5 }],
+            updatedAt: "2026-05-16T00:00:00.000Z",
+            sourceRefs: [],
+        },
+    });
+    assert.equal(result.draft.tone, "friend");
+});
+// Boundary tests for Wave 26 fix
+test("T6.1.1 boundary: empty narrative state fields with evidence", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "",
+            progress: [],
+            nextIntent: "",
+            confidence: 0.0,
+            sourceRefs: [],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+        relationshipMemory: {
+            relationshipId: "r1",
+            revision: 1,
+            tonePreference: "casual",
+            noReplyCount: 0,
+            topicAffinities: [],
+            updatedAt: "2026-05-16T00:00:00.000Z",
+            sourceRefs: [],
+        },
+    });
+    // With evidence refs present but empty fields, function returns grounded
+    // because evidence exists; tone is insufficient_history due to empty content
+    assert.equal(result.groundingReport.status, "grounded");
+    assert.equal(result.draft.tone, "insufficient_history");
+    assert.equal(result.draft.whatHappened, "");
+    // whyItMatters gets a default fallback when empty
+    assert.ok(result.draft.whyItMatters.length > 0);
+});
+test("T6.1.1 boundary: undefined relationship memory", () => {
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "EvoMap profile updated",
+            progress: ["connected node"],
+            nextIntent: "verify task claim",
+            confidence: 0.8,
+            sourceRefs: [makeRef("ev-1")],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+    });
+    assert.equal(result.groundingReport.status, "grounded");
+    assert.equal(result.draft.tone, "insufficient_history");
+    assert.equal(result.draft.whatHappened, "EvoMap profile updated");
+});
+test("T6.1.1 boundary: maximum evidence refs", () => {
+    const maxRefs = Array.from({ length: 1000 }, (_, i) => makeRef(`ev-${i}`));
+    const result = draftNarrativeOutreach({
+        evidenceRefs: maxRefs,
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: "bulk activity",
+            progress: ["many actions"],
+            nextIntent: "continue",
+            confidence: 0.9,
+            sourceRefs: maxRefs.slice(0, 100),
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+        relationshipMemory: {
+            relationshipId: "r1",
+            revision: 1,
+            tonePreference: "casual",
+            noReplyCount: 0,
+            topicAffinities: [{ topic: "work", affinity: 0.8 }],
+            updatedAt: "2026-05-16T00:00:00.000Z",
+            sourceRefs: [],
+        },
+    });
+    assert.equal(result.groundingReport.status, "grounded");
+    assert.equal(result.draft.tone, "friend");
+    assert.equal(result.draft.sourceRefs.length, 1000);
+    assert.ok(result.groundingReport.sourceCoverage > 0.1);
+});
+test("T6.1.1 boundary: very long focus and progress strings", () => {
+    const longString = "a".repeat(10000);
+    const result = draftNarrativeOutreach({
+        evidenceRefs: [makeRef("ev-1")],
+        narrativeState: {
+            narrativeId: "n1",
+            revision: 1,
+            focus: longString,
+            progress: [longString, longString],
+            nextIntent: longString,
+            confidence: 0.8,
+            sourceRefs: [makeRef("ev-1")],
+            unsupportedClaims: [],
+            status: "active",
+            updatedAt: "2026-05-16T00:00:00.000Z",
+        },
+        relationshipMemory: {
+            relationshipId: "r1",
+            revision: 1,
+            tonePreference: "casual",
+            noReplyCount: 0,
+            topicAffinities: [{ topic: "work", affinity: 0.5 }],
+            updatedAt: "2026-05-16T00:00:00.000Z",
+            sourceRefs: [],
+        },
+    });
+    // Very long strings trigger degraded status due to content length limits
+    assert.equal(result.groundingReport.status, "degraded");
+    assert.equal(result.draft.tone, "insufficient_history");
+    assert.equal(result.draft.whatHappened, longString);
+});

package/dist/tests/unit/observability/audit-envelope.test.d.ts

@@ -0,0 +1 @@
+export {};