@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/s5-exit/int-s5-observability.test.js

@@ -0,0 +1,402 @@
+/**
+ * INT-S5 — S5 Observability 集成冒烟测试
+ *
+ * Exit criteria verification (05A_TASKS.md INT-S5):
+ *
+ * 1. Audit chain integrity verifiable — AppendOnlyAuditStore per-family hash chain
+ *    links correctly; chain corruption is detected and marked degraded.
+ * 2. SelfHealthSnapshot covers dynamic dimensions and minimum dimension set is
+ *    complete; any single probe timeout does not affect overall snapshot.
+ * 3. HeartbeatDigest per-platform counts correct; nothing_significant on empty day.
+ * 4. NarrativeTimeline cursor pagination normal; 90-day range enforced.
+ * 5. RestoreAudit writes on every attempt; partial_restore_error records entity lists.
+ * 6. RuntimeSecretAnchorView returns recoverySteps for all three reason codes.
+ *
+ * Evidence: reports/int-s5-observability-v7.md
+ */
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert";
+// Audit chain (T-OBS.C.1)
+import { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
+import { buildAuditEnvelope } from "../../../src/observability/audit/audit-envelope.js";
+// SelfHealthSnapshot (T-OBS.C.2)
+import { getSelfHealthSnapshot, registerHealthProbe, unregisterHealthProbe, clearHealthProbeRegistry, ensureMinimumProbes, MINIMUM_REQUIRED_DIMENSIONS, } from "../../../src/observability/services/self-health-snapshot.js";
+// HeartbeatDigest (T-OBS.C.3 + T-OBS.C.4)
+import { generateHeartbeatDigest, } from "../../../src/observability/services/heartbeat-digest-assembler.js";
+// NarrativeTimeline (T-OBS.C.5)
+import { queryNarrativeTimeline, queryNarrativeDiff, NarrativeQueryRangeError, } from "../../../src/observability/services/narrative-timeline-query-service.js";
+// RestoreAudit (T-OBS.C.6)
+import { writeRestoreAudit, } from "../../../src/observability/services/restore-audit-service.js";
+// RuntimeSecretAnchorView (T-OBS.C.7)
+import { viewSecretAnchor, } from "../../../src/observability/services/runtime-secret-anchor-view.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function makeAuditEnvelope(family, seq, previousHash) {
+    const payload = { seq, msg: `event-${seq}` };
+    return buildAuditEnvelope({
+        family: family,
+        plane: "governance",
+        traceId: `trace-int-s5-${seq}`,
+        sequence: seq,
+        payload,
+        previousHash,
+    });
+}
+function makeDimHealth(status) {
+    return { status, checkedAt: new Date().toISOString() };
+}
+// ─── 1. Audit chain integrity (T-OBS.C.1) ────────────────────────────────────
+describe("INT-S5 #1: audit chain integrity (T-OBS.C.1)", () => {
+    it("per-family hash chain links correctly across 5 events", () => {
+        const store = new AppendOnlyAuditStore();
+        let prevHash;
+        for (let i = 1; i <= 5; i++) {
+            const env = makeAuditEnvelope("restore.audit", i, prevHash);
+            store.append(env);
+            prevHash = env.integrity.recordHash;
+        }
+        assert.strictEqual(store.list().length, 5);
+        // lastRecordHash returns correct per-family hash
+        assert.strictEqual(store.lastRecordHash("restore.audit"), prevHash);
+    });
+    it("detects chain corruption: previousHash mismatch throws", () => {
+        const store = new AppendOnlyAuditStore();
+        const env1 = makeAuditEnvelope("health.probe", 1, undefined);
+        store.append(env1);
+        // Craft a broken second event with wrong previousHash
+        const brokenEnv = makeAuditEnvelope("health.probe", 2, "wrong-hash-0000");
+        assert.throws(() => store.append(brokenEnv), /audit_previous_hash_mismatch/);
+    });
+    it("seedFamilyHash enables backfill after process restart", () => {
+        const store = new AppendOnlyAuditStore();
+        const simulatedDbHash = "restart-backfill-hash-abc123";
+        store.seedFamilyHash("narrative.snapshot", simulatedDbHash);
+        // Next event must link to the seeded hash
+        const env = makeAuditEnvelope("narrative.snapshot", 1, simulatedDbHash);
+        assert.doesNotThrow(() => store.append(env));
+    });
+    it("two families maintain independent chains", () => {
+        const store = new AppendOnlyAuditStore();
+        const e1 = makeAuditEnvelope("restore.audit", 1, undefined);
+        const e2 = makeAuditEnvelope("health.probe", 1, undefined);
+        store.append(e1);
+        store.append(e2);
+        assert.strictEqual(store.lastRecordHash("restore.audit"), e1.integrity.recordHash);
+        assert.strictEqual(store.lastRecordHash("health.probe"), e2.integrity.recordHash);
+    });
+});
+// ─── 2. SelfHealthSnapshot dimensions (T-OBS.C.2) ────────────────────────────
+describe("INT-S5 #2: SelfHealthSnapshot minimum dimension set + probe isolation (T-OBS.C.2)", () => {
+    beforeEach(() => {
+        clearHealthProbeRegistry();
+    });
+    it("minimum required dimensions all present in snapshot", async () => {
+        ensureMinimumProbes();
+        const snap = await getSelfHealthSnapshot();
+        for (const dimId of MINIMUM_REQUIRED_DIMENSIONS) {
+            assert.ok(dimId in snap.dimensions, `Missing required dimension: ${dimId}`);
+        }
+        assert.ok(snap.generatedAt, "generatedAt must be set");
+        assert.ok(["healthy", "degraded", "unknown"].includes(snap.overall));
+    });
+    it("single probe timeout does not block overall snapshot", async () => {
+        ensureMinimumProbes();
+        // Register a slow probe that would time out
+        const slowProbe = {
+            dimensionId: "slow_test_dim",
+            probe: async () => {
+                await new Promise((r) => setTimeout(r, 3500)); // > 3000ms total cap
+                return makeDimHealth("healthy");
+            },
+            timeoutMs: 100,
+        };
+        registerHealthProbe(slowProbe);
+        const snap = await getSelfHealthSnapshot();
+        // slow_test_dim should be unknown/timeout; other dims should still be present
+        const slowDim = snap.dimensions["slow_test_dim"];
+        assert.ok(slowDim, "slow_test_dim should appear in snapshot");
+        assert.notStrictEqual(slowDim.status, "healthy", "timed-out probe should not be healthy");
+        // Minimum required dims still present
+        for (const dimId of MINIMUM_REQUIRED_DIMENSIONS) {
+            assert.ok(dimId in snap.dimensions, `Required dim ${dimId} missing after slow probe`);
+        }
+        unregisterHealthProbe("slow_test_dim");
+    });
+    it("dynamic probe registration works", async () => {
+        ensureMinimumProbes();
+        registerHealthProbe({ dimensionId: "custom_v7_dim", probe: async () => makeDimHealth("healthy"), timeoutMs: 500 });
+        const snap = await getSelfHealthSnapshot();
+        assert.ok("custom_v7_dim" in snap.dimensions);
+        assert.strictEqual(snap.dimensions["custom_v7_dim"].status, "healthy");
+    });
+});
+// ─── 3. HeartbeatDigest (T-OBS.C.3 + T-OBS.C.4) ─────────────────────────────
+describe("INT-S5 #3: HeartbeatDigest per-platform counts + nothing_significant (T-OBS.C.3)", () => {
+    const DATE = "2026-05-23";
+    /**
+     * Build a deps object with an audit store seeded with connector.attempt events
+     * for the given platform/capability pairs.
+     */
+    function makeDeps(attempts) {
+        const store = new AppendOnlyAuditStore();
+        let previousHash;
+        attempts.forEach((a, idx) => {
+            const env = buildAuditEnvelope({
+                family: "connector.attempt",
+                plane: "governance",
+                traceId: `trace-hb-${idx}`,
+                sequence: idx + 1,
+                createdAt: `${DATE}T00:00:00.000Z`,
+                payload: { platformId: a.platformId, capability: a.capability, outcome: a.outcome },
+                previousHash,
+            });
+            store.append(env);
+            previousHash = env.integrity.recordHash;
+        });
+        return { auditStore: store };
+    }
+    it("per-platform counts correct for connector attempts", async () => {
+        const deps = makeDeps([
+            { platformId: "moltbook", capability: "feed.read", outcome: "success" },
+            { platformId: "moltbook", capability: "feed.read", outcome: "success" },
+            { platformId: "moltbook", capability: "feed.read", outcome: "failure" },
+            { platformId: "moltbook", capability: "feed.read", outcome: "circuit_open" },
+            { platformId: "instreet", capability: "post.publish", outcome: "blocked" },
+        ]);
+        const digest = await generateHeartbeatDigest(DATE, deps);
+        assert.ok(Array.isArray(digest.connectorSummary), "connectorSummary must be array");
+        const mb = digest.connectorSummary.find((s) => s.platformId === "moltbook");
+        assert.ok(mb, "moltbook summary missing");
+        assert.strictEqual(mb.successCount, 2);
+        assert.strictEqual(mb.failureCount, 1);
+        assert.strictEqual(mb.circuitOpenCount, 1);
+        const is = digest.connectorSummary.find((s) => s.platformId === "instreet");
+        assert.ok(is, "instreet summary missing");
+        assert.strictEqual(is.blockedCount, 1);
+    });
+    it("nothing_significant on empty audit store", async () => {
+        const store = new AppendOnlyAuditStore();
+        const digest = await generateHeartbeatDigest(DATE, { auditStore: store });
+        assert.strictEqual(digest.isNothingSignificant, true, "Empty day must set isNothingSignificant = true");
+        assert.strictEqual(digest.connectorSummary.length, 0, "no connector summaries fabricated");
+    });
+    it("digest does not contain credential / raw payload fields", async () => {
+        const store = new AppendOnlyAuditStore();
+        const digest = await generateHeartbeatDigest(DATE, { auditStore: store });
+        const digestStr = JSON.stringify(digest);
+        const forbidden = ["password", "raw_payload", "private_message", "Bearer "];
+        for (const f of forbidden) {
+            assert.ok(!digestStr.includes(f), `Digest must not contain forbidden field: ${f}`);
+        }
+    });
+});
+// ─── 4. NarrativeTimeline cursor pagination (T-OBS.C.5) ──────────────────────
+describe("INT-S5 #4: NarrativeTimeline cursor pagination + 90-day range (T-OBS.C.5)", () => {
+    function makeRows(count) {
+        return Array.from({ length: count }, (_, i) => ({
+            version: `v${i + 1}`,
+            createdAt: new Date(Date.now() - (count - i) * 60000).toISOString(),
+            triggerKind: "heartbeat.decision",
+            sourceRefs: [`ref-${i}`],
+            reasonCode: "ok",
+            summaryText: `event ${i + 1}`,
+        }));
+    }
+    function makeDeps(rows) {
+        return {
+            stateMemoryPort: {
+                listNarrativeTimeline: async (_from, _to, opts) => {
+                    let filtered = rows;
+                    if (opts?.afterTimestamp) {
+                        filtered = rows.filter((r) => r.createdAt > opts.afterTimestamp);
+                    }
+                    return filtered.slice(0, opts?.limit ?? 20);
+                },
+                getNarrativeSnapshot: async (version) => {
+                    const idx = rows.findIndex((r) => r.version === version);
+                    if (idx === -1)
+                        return null;
+                    return {
+                        version,
+                        focus: `focus-${version}`,
+                        progress: `progress-${version}`,
+                        nextIntent: `intent-${version}`,
+                        sourceRefs: [`ref-${idx}`],
+                        lastChangeReasonCode: "ok",
+                    };
+                },
+            },
+        };
+    }
+    it("cursor pagination returns correct pages", async () => {
+        const rows = makeRows(25);
+        const deps = makeDeps(rows);
+        const from = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString();
+        const to = new Date().toISOString();
+        const page1 = await queryNarrativeTimeline(from, to, { limit: 10 }, deps);
+        assert.strictEqual(page1.entries.length, 10);
+        assert.ok(page1.nextCursor, "page1 must have nextCursor");
+        const page2 = await queryNarrativeTimeline(from, to, { limit: 10, cursor: page1.nextCursor }, deps);
+        assert.ok(page2.entries.length > 0, "page2 must have entries");
+        // No overlap
+        const page1Versions = new Set(page1.entries.map((e) => e.version));
+        for (const entry of page2.entries) {
+            assert.ok(!page1Versions.has(entry.version), "Page overlap detected");
+        }
+    });
+    it("90-day range exceeded throws NarrativeQueryRangeError", async () => {
+        const rows = makeRows(5);
+        const deps = makeDeps(rows);
+        const from = new Date(Date.now() - 91 * 24 * 60 * 60 * 1000).toISOString();
+        const to = new Date().toISOString();
+        await assert.rejects(() => queryNarrativeTimeline(from, to, {}, deps), NarrativeQueryRangeError);
+    });
+    it("narrativeDiff returns field-level changes between two versions", async () => {
+        const rows = makeRows(5);
+        const deps = makeDeps(rows);
+        const diff = await queryNarrativeDiff("v1", "v3", deps);
+        assert.ok(diff, "diff result must be present");
+        assert.ok("changes" in diff, "diff must have changes array");
+    });
+});
+// ─── 5. RestoreAudit (T-OBS.C.6) ─────────────────────────────────────────────
+describe("INT-S5 #5: RestoreAudit writes on every attempt + partial_restore_error (T-OBS.C.6)", () => {
+    function makeEvent(overrides = {}) {
+        return {
+            id: `evt-${Date.now()}`,
+            restoreTarget: "goal",
+            fromVersion: "v1",
+            toVersion: "v2",
+            triggeredBy: "operator",
+            reason: "manual_rollback",
+            completedEntities: ["goal", "narrative"],
+            failedEntities: [],
+            excludedFields: ["credential"],
+            restoredFieldCount: 8,
+            createdAt: new Date().toISOString(),
+            traceId: `trace-${Date.now()}`,
+            ...overrides,
+        };
+    }
+    it("successful restore writes audit with from/to/reason", async () => {
+        const store = new AppendOnlyAuditStore();
+        const result = await writeRestoreAudit(makeEvent(), store);
+        assert.strictEqual(result.ok, true);
+        assert.strictEqual(store.list().length, 1);
+        const env = store.list()[0];
+        assert.strictEqual(env.payload.fromVersion, "v1");
+        assert.strictEqual(env.payload.toVersion, "v2");
+        assert.strictEqual(env.payload.reason, "manual_rollback");
+    });
+    it("partial_restore_error records completed and failed entity lists", async () => {
+        const store = new AppendOnlyAuditStore();
+        const result = await writeRestoreAudit(makeEvent({
+            restoreTarget: "narrative",
+            fromVersion: "v5",
+            toVersion: "v4",
+            triggeredBy: "agent",
+            reason: "partial_restore_error",
+            completedEntities: ["goal"],
+            failedEntities: ["evidence", "relationship"],
+            excludedFields: ["encryption_key"],
+            restoredFieldCount: 3,
+        }), store);
+        assert.strictEqual(result.ok, true);
+        const env = store.list()[0];
+        assert.deepStrictEqual(env.payload.completedEntities, ["goal"]);
+        assert.deepStrictEqual(env.payload.failedEntities, ["evidence", "relationship"]);
+        // isPartialRestore is computed from failedEntities.length > 0
+        assert.strictEqual(env.payload.isPartialRestore, true);
+    });
+    it("credential field value never written to audit (only field name in excludedFields)", async () => {
+        const store = new AppendOnlyAuditStore();
+        await writeRestoreAudit(makeEvent({
+            reason: "credential_excluded_test",
+            excludedFields: ["credential", "session_token"],
+        }), store);
+        const rawAudit = JSON.stringify(store.list());
+        assert.ok(rawAudit.includes("credential"), "excludedFields must list 'credential'");
+        assert.ok(!rawAudit.includes("Bearer "), "credential values must not appear");
+        assert.ok(!rawAudit.includes("sk-"), "credential values must not appear");
+    });
+    it("audit write failure is fire-and-forget (returns ok:true + warning)", async () => {
+        // Simulate a store whose append() always throws (simulates DB write failure)
+        const throwingStore = new AppendOnlyAuditStore();
+        // Monkey-patch append to always throw after store is constructed
+        throwingStore["append"] = () => {
+            throw new Error("simulated_db_write_failure");
+        };
+        const result = await writeRestoreAudit(makeEvent({ reason: "fire_and_forget_test" }), throwingStore);
+        assert.strictEqual(result.ok, true);
+        assert.ok(result.warnings && result.warnings.length > 0, "warnings must be populated on audit failure");
+        assert.ok(result.warnings[0].includes("simulated_db_write_failure"), "warning message should include original error");
+    });
+});
+// ─── 6. RuntimeSecretAnchorView (T-OBS.C.7) ──────────────────────────────────
+describe("INT-S5 #6: RuntimeSecretAnchorView three reason codes + recoverySteps (T-OBS.C.7)", () => {
+    function makeOpsPort(overrides = {}) {
+        return {
+            getEncryptionKeyPath: () => overrides.keyPath ?? "SECOND_NATURE_ENCRYPTION_KEY",
+            checkKeyPathExists: async (_kp) => overrides.keyExists ?? true,
+        };
+    }
+    function makeCredPort(sampleDecrypt) {
+        return {
+            verifySampleDecrypt: async () => {
+                if (sampleDecrypt === "ok")
+                    return { status: "ok", checkedIds: ["cred-1"] };
+                if (sampleDecrypt === "wrong_key")
+                    return { status: "wrong_key", checkedIds: ["cred-1"] };
+                return { status: "error", checkedIds: [] };
+            },
+        };
+    }
+    it("healthy anchor returns verified status", async () => {
+        const deps = {
+            runtimeOpsPort: makeOpsPort(),
+            credentialPort: makeCredPort("ok"),
+        };
+        const view = await viewSecretAnchor(deps);
+        assert.strictEqual(view.status, "verified");
+        assert.ok(!view.reasonCode, "verified status should have no reasonCode");
+        assert.ok(Array.isArray(view.recoverySteps));
+    });
+    it("wrong key returns credential_recovery_required + recoverySteps", async () => {
+        const deps = {
+            runtimeOpsPort: makeOpsPort(),
+            credentialPort: makeCredPort("wrong_key"),
+        };
+        const view = await viewSecretAnchor(deps);
+        assert.strictEqual(view.status, "wrong_key");
+        assert.strictEqual(view.reasonCode, "credential_recovery_required");
+        assert.ok(Array.isArray(view.recoverySteps) && view.recoverySteps.length > 0, "recoverySteps must be populated for credential_recovery_required");
+    });
+    it("decrypt error returns runtime_secret_unavailable + recoverySteps", async () => {
+        const deps = {
+            runtimeOpsPort: makeOpsPort(),
+            credentialPort: makeCredPort("error"),
+        };
+        const view = await viewSecretAnchor(deps);
+        assert.strictEqual(view.reasonCode, "runtime_secret_unavailable");
+        assert.ok(Array.isArray(view.recoverySteps) && view.recoverySteps.length > 0, "recoverySteps must be populated");
+    });
+    it("missing key path returns runtime_secret_anchor_missing", async () => {
+        const deps = {
+            runtimeOpsPort: makeOpsPort({ keyExists: false }),
+            credentialPort: makeCredPort("ok"),
+        };
+        const view = await viewSecretAnchor(deps);
+        assert.strictEqual(view.status, "missing");
+        assert.strictEqual(view.reasonCode, "runtime_secret_anchor_missing");
+        assert.ok(Array.isArray(view.recoverySteps) && view.recoverySteps.length > 0);
+    });
+    it("anchor view never contains encryption key plaintext", async () => {
+        const deps = {
+            runtimeOpsPort: makeOpsPort(),
+            credentialPort: makeCredPort("wrong_key"),
+        };
+        const view = await viewSecretAnchor(deps);
+        const viewStr = JSON.stringify(view);
+        assert.ok(!viewStr.includes("sk-"), "key plaintext must not appear");
+        assert.ok(!viewStr.includes("Bearer "), "credential value must not appear");
+    });
+});

package/dist/tests/integration/state/t4-2-1-owner-reply-relationship-loop.test.d.ts

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

package/dist/tests/integration/state/t4-2-1-owner-reply-relationship-loop.test.js

@@ -0,0 +1,132 @@
+/**
+ * T4.2.1 — Owner reply → RelationshipMemory feedback loop integration.
+ *
+ * Acceptance:
+ * A. owner reply → SessionChronicle entry written with owner_reply kind.
+ * B. positive reply → RelationshipMemory tone updated to casual, noReplyCount reset.
+ * C. negative reply → RelationshipMemory tone updated to quiet (reserved).
+ * D. busy reply → timing observed as busy, topics extracted.
+ * E. no existing memory → creates default relationship with inferred traits.
+ * F. next outreach draft can load updated relationship and trace to sourceRef.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { processOwnerReply } from "../../../src/core/second-nature/feedback/owner-reply-feedback.js";
+import { createSessionChronicleStore } from "../../../src/storage/chronicle/session-chronicle-store.js";
+import { createRelationshipMemoryStore } from "../../../src/storage/relationship/relationship-memory-store.js";
+async function seedRelationshipMemory(state) {
+    const store = createRelationshipMemoryStore(state);
+    await store.upsertRelationshipMemory({
+        relationshipId: "default",
+        revision: 1,
+        tonePreference: "casual",
+        averageReplyDelayMinutes: 30,
+        noReplyCount: 2,
+        topicAffinities: [
+            { topic: "platform", affinity: 0.8 },
+            { topic: "work", affinity: 0.6 },
+        ],
+        lastInteractionAt: new Date(Date.now() - 86400000).toISOString(),
+        sourceRefs: [{ sourceId: "seed-1", kind: "decision_record", url: "https://example.test/seed" }],
+        updatedAt: new Date().toISOString(),
+    });
+}
+test("T4.2.1-A: owner reply → chronicle entry written with owner_reply kind", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedRelationshipMemory(state);
+    const result = await processOwnerReply({
+        replyText: "Thanks for the update, that's helpful!",
+        relatedDecisionId: "decision-001",
+    }, state);
+    assert.ok(result.chronicleEntryId.startsWith("owner_reply:"));
+    assert.equal(result.relationshipUpdated, true);
+    const chronicle = createSessionChronicleStore(state);
+    const entries = await chronicle.loadSessionChronicle({ eventKinds: ["owner_reply"], limit: 10 });
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].actor, "owner");
+    assert.equal(entries[0].relatedDecisionId, "decision-001");
+    assert.ok(entries[0].ownerReply);
+});
+test("T4.2.1-B: positive reply → tone casual, noReplyCount reset to 0", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedRelationshipMemory(state);
+    const result = await processOwnerReply({
+        replyText: "Great work! I really appreciate the quick follow-up.",
+        relatedDecisionId: "decision-002",
+    }, state);
+    assert.equal(result.relationshipUpdated, true);
+    assert.equal(result.updatedMemory.tonePreference, "casual");
+    assert.equal(result.updatedMemory.noReplyCount, 0);
+    assert.ok(result.updatedMemory.lastInteractionAt);
+    assert.ok(result.updatedMemory.sourceRefs.some((r) => r.kind === "owner_reply_feedback"), "sourceRefs must contain owner_reply_feedback ref");
+});
+test("T4.2.1-C: negative reply → tone quiet (reserved), noReplyCount reset", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedRelationshipMemory(state);
+    const result = await processOwnerReply({
+        replyText: "I'm frustrated that you keep bothering me with these updates.",
+        relatedDecisionId: "decision-003",
+    }, state);
+    assert.equal(result.relationshipUpdated, true);
+    assert.equal(result.updatedMemory.tonePreference, "quiet");
+    assert.equal(result.updatedMemory.noReplyCount, 0);
+});
+test("T4.2.1-D: busy reply → timing busy, topics extracted, affinities updated", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedRelationshipMemory(state);
+    const result = await processOwnerReply({
+        replyText: "I'm busy with a deadline. Let's talk about the project later.",
+        relatedDecisionId: "decision-004",
+    }, state);
+    assert.equal(result.relationshipUpdated, true);
+    // Timing inference is stored in ownerReply signal, not directly on memory field
+    const chronicle = createSessionChronicleStore(state);
+    const entries = await chronicle.loadSessionChronicle({ eventKinds: ["owner_reply"], limit: 1 });
+    assert.equal(entries[0].ownerReply.topics.includes("work"), true);
+    // Affinities should be updated
+    // L-04: baseline affinity = 0.5 (default), mergeTopicAffinities adds +0.1 per mention → expected >= 0.6
+    const workAffinity = result.updatedMemory.topicAffinities.find((t) => t.topic === "work");
+    assert.ok(workAffinity);
+    const EXPECTED_MIN_AFFINITY = 0.6;
+    assert.ok(workAffinity.affinity >= EXPECTED_MIN_AFFINITY, `work affinity should be boosted after reply mentioning deadline/project (expected >= ${EXPECTED_MIN_AFFINITY})`);
+});
+test("T4.2.1-E: no existing memory → creates default relationship with inferred traits", async () => {
+    const state = createStateDatabase(":memory:");
+    // Do NOT seed relationship memory
+    const result = await processOwnerReply({
+        replyText: "Sounds good, thanks for keeping me in the loop!",
+        relatedDecisionId: "decision-005",
+    }, state);
+    assert.equal(result.relationshipUpdated, true);
+    assert.equal(result.updatedMemory.relationshipId, "default");
+    assert.equal(result.updatedMemory.tonePreference, "casual");
+    assert.equal(result.updatedMemory.noReplyCount, 0);
+    assert.equal(result.updatedMemory.revision, 1);
+});
+test("T4.2.1-F: memory update includes sourceRef traceable to chronicle entry", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedRelationshipMemory(state);
+    const result = await processOwnerReply({
+        replyText: "Love the new feature! Great work on the architecture design.",
+        relatedDecisionId: "decision-006",
+    }, state);
+    const chronicleEntryId = result.chronicleEntryId;
+    const memory = result.updatedMemory;
+    // Source refs must include trace to chronicle entry
+    const feedbackRef = memory.sourceRefs.find((r) => r.sourceId === chronicleEntryId);
+    assert.ok(feedbackRef, "memory sourceRefs must contain trace to chronicle entry");
+    assert.equal(feedbackRef.kind, "owner_reply_feedback");
+    // Topics should include "tech" (architecture, design, feature)
+    const techAffinity = memory.topicAffinities.find((t) => t.topic === "tech");
+    assert.ok(techAffinity, "tech topic should be inferred from reply text");
+});
+test("T4.2.1-G: conflicting tone (positive + negative) → quiet wins", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedRelationshipMemory(state);
+    const result = await processOwnerReply({
+        replyText: "I love this feature but I'm frustrated with the timing",
+        relatedDecisionId: "decision-007",
+    }, state);
+    assert.equal(result.updatedMemory.tonePreference, "quiet");
+});

package/dist/tests/integration/state/v7c-identity-goal-hygiene.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * T-V7C.C.4 — Identity / Goal Hygiene Closure Integration Tests
+ *
+ * Coverage:
+ * 1. Goal dedupe: same kind+scope → only latest accepted remains active
+ * 2. IdentityProfile → Connector: connector request carries platform handle (readable, no credential)
+ * 3. RelationshipMemory → Guidance: feedback affects frequency/tone selection
+ */
+export {};