@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/integration/guidance/v7c-guidance-chain.test.js

@@ -0,0 +1,190 @@
+/**
+ * v7c-guidance-chain.test.ts — T-V7C.C.4R
+ *
+ * Integration tests for the full guidance chain:
+ * 1. assembleGuidance with capabilityIntent — dual-axis impulse selection
+ * 2. guidance_payload ops command — returns impulseText + atmosphereText
+ * 3. generateGuidanceDraft — buildDraftText returns Chinese content
+ * 4. agent.* exclusion through full assembleGuidance path
+ *
+ * Dependencies: guidance-assembler, impulse-assembler, template-registry, ops-router
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { assembleGuidance } from "../../../src/guidance/guidance-assembler.js";
+import { generateGuidanceDraft } from "../../../src/guidance/guidance-draft-service.js";
+import { createOpsRouter } from "../../../src/cli/ops/ops-router.js";
+// ─── assembleGuidance: capabilityIntent integration ──────────────────────────
+describe("assembleGuidance with capabilityIntent (T-V7C.C.4R)", () => {
+    it("post.publish + social → impulse is not null (social or broadcast-derived)", async () => {
+        const result = await assembleGuidance({
+            sceneContext: {
+                sceneType: "social",
+                mode: "active",
+                capabilityIntent: "post.publish",
+            },
+        });
+        assert.ok(!("available" in result), "expected GuidancePayload, got GuidanceUnavailable");
+        const payload = result;
+        assert.ok("impulses" in payload);
+        // social scene with broadcast capability should have an impulse
+        assert.ok(payload.impulses.length > 0, "expected at least one impulse for post.publish social scene");
+    });
+    it("feed.read + social → explore impulse via capabilityClass (approved)", async () => {
+        const result = await assembleGuidance({
+            sceneContext: {
+                sceneType: "social",
+                mode: "active",
+                capabilityIntent: "feed.read",
+            },
+        });
+        assert.ok(!("available" in result));
+        const payload = result;
+        // explore is approved → capability_class impulse returned
+        assert.ok(payload.impulses.length > 0, "should have explore capability_class impulse");
+        assert.strictEqual(payload.impulses[0].reviewStatus, "approved");
+    });
+    it("agent.heartbeat → no impulse injected", async () => {
+        const result = await assembleGuidance({
+            sceneContext: {
+                sceneType: "social",
+                mode: "active",
+                capabilityIntent: "agent.heartbeat",
+            },
+        });
+        assert.ok(!("available" in result));
+        const payload = result;
+        // agent.* excluded → impulse assembler returns null → empty impulses array
+        assert.strictEqual(payload.impulses.length, 0, "agent.heartbeat must not inject impulse");
+    });
+    it("explain scene → no impulse regardless of capability", async () => {
+        const result = await assembleGuidance({
+            sceneContext: {
+                sceneType: "explain",
+                mode: "active",
+                capabilityIntent: "post.publish",
+            },
+        });
+        assert.ok(!("available" in result));
+        const payload = result;
+        assert.strictEqual(payload.impulses.length, 0);
+    });
+    it("atmosphere text is Chinese and non-empty for any scene", async () => {
+        const result = await assembleGuidance({
+            sceneContext: { sceneType: "social", mode: "active" },
+        });
+        assert.ok(!("available" in result));
+        const payload = result;
+        assert.ok(payload.atmosphere?.text.length, "atmosphere text must be non-empty");
+        // Basic sanity: contains Chinese characters (not English placeholder)
+        const hasChinese = /[\u4e00-\u9fff]/.test(payload.atmosphere.text);
+        assert.ok(hasChinese, "atmosphere text must contain Chinese content");
+    });
+});
+// ─── generateGuidanceDraft: Chinese text ─────────────────────────────────────
+describe("generateGuidanceDraft — Chinese buildDraftText (T-V7C.C.4R)", () => {
+    const mockClaim = {
+        id: "c1",
+        text: "有趣的技术分享",
+        sourceRefs: [{ id: "sr:1", kind: "workspace_artifact", uri: "artifact://exp:1" }],
+    };
+    it("outreach scene → Chinese prefix text", async () => {
+        const result = await generateGuidanceDraft({
+            requestId: "req:1",
+            sceneKind: "outreach",
+            evidencePackRef: "pack:1",
+            relationshipContextRef: "rel:1",
+            requestedAt: new Date().toISOString(),
+        }, {
+            evidencePort: {
+                loadEvidencePack: async () => ({ claims: [mockClaim] }),
+            },
+        });
+        assert.ok(result.draft, "should produce a draft");
+        const hasChinese = /[\u4e00-\u9fff]/.test(result.draft.text);
+        assert.ok(hasChinese, `outreach draft text must be Chinese, got: ${result.draft.text}`);
+        assert.ok(result.draft.text.includes("想跟你分享") || result.draft.text.includes("正好碰到了"), `expected Chinese outreach text, got: ${result.draft.text}`);
+    });
+    it("follow_up scene → Chinese prefix text", async () => {
+        const result = await generateGuidanceDraft({
+            requestId: "req:2",
+            sceneKind: "follow_up",
+            evidencePackRef: "pack:2",
+            relationshipContextRef: "rel:2",
+            requestedAt: new Date().toISOString(),
+        }, {
+            evidencePort: {
+                loadEvidencePack: async () => ({ claims: [mockClaim] }),
+            },
+        });
+        assert.ok(result.draft);
+        assert.ok(result.draft.text.includes("接着上次聊的"), `expected follow_up text, got: ${result.draft.text}`);
+    });
+    it("reconnect scene → Chinese prefix text", async () => {
+        const result = await generateGuidanceDraft({
+            requestId: "req:3",
+            sceneKind: "reconnect",
+            evidencePackRef: "pack:3",
+            relationshipContextRef: "rel:3",
+            requestedAt: new Date().toISOString(),
+        }, {
+            evidencePort: {
+                loadEvidencePack: async () => ({ claims: [mockClaim] }),
+            },
+        });
+        assert.ok(result.draft);
+        assert.ok(result.draft.text.includes("好久不见"), `expected reconnect text, got: ${result.draft.text}`);
+    });
+});
+// ─── guidance_payload ops command ────────────────────────────────────────────
+describe("ops command: guidance_payload (T-V7C.C.4R)", () => {
+    function makeRouter() {
+        return createOpsRouter({ runtimeAvailable: false });
+    }
+    it("social + post.publish → returns impulseText + atmosphereText", async () => {
+        const router = makeRouter();
+        const result = await router.dispatch("guidance_payload", {
+            sceneType: "social",
+            capabilityIntent: "post.publish",
+        });
+        assert.ok(typeof result === "object" && result !== null);
+        const envelope = result;
+        assert.ok(envelope.ok, `expected ok=true, got: ${JSON.stringify(result)}`);
+        assert.ok(envelope.data?.atmosphereText.length, "atmosphereText must be non-empty");
+        assert.ok(envelope.data?.impulseText !== undefined, "impulseText field must exist");
+        assert.strictEqual(envelope.data?.capabilityClass, "broadcast");
+    });
+    it("agent.heartbeat → impulseText=null, source=none", async () => {
+        const router = makeRouter();
+        const result = await router.dispatch("guidance_payload", {
+            sceneType: "social",
+            capabilityIntent: "agent.heartbeat",
+        });
+        const envelope = result;
+        assert.ok(envelope.ok);
+        assert.strictEqual(envelope.data?.impulseText, null);
+        assert.strictEqual(envelope.data?.impulseSource, "none");
+    });
+    it("feed.read → capabilityClass=consume, returns explore impulse (capability_class)", async () => {
+        const router = makeRouter();
+        const result = await router.dispatch("guidance_payload", {
+            sceneType: "social",
+            capabilityIntent: "feed.read",
+        });
+        const envelope = result;
+        assert.ok(envelope.ok);
+        assert.strictEqual(envelope.data?.capabilityClass, "consume");
+        // explore is approved → capability_class impulse
+        assert.strictEqual(envelope.data?.impulseSource, "capability_class");
+        assert.ok(envelope.data?.impulseText !== null, "should have explore impulse text");
+    });
+    it("invalid sceneType → ok=false with INVALID_SCENE_TYPE error", async () => {
+        const router = makeRouter();
+        const result = await router.dispatch("guidance_payload", {
+            sceneType: "nonexistent_scene",
+        });
+        const envelope = result;
+        assert.strictEqual(envelope.ok, false);
+        assert.strictEqual(envelope.error?.code, "INVALID_SCENE_TYPE");
+    });
+});

package/dist/tests/integration/guidance/v7c-guidance-semantics.test.d.ts

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

package/dist/tests/integration/guidance/v7c-guidance-semantics.test.js

@@ -0,0 +1,146 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { assembleGuidance, buildMinimalGuidanceFallback, buildOutputGuard, buildExpressionBoundary, getOutputGuardDefinition, getShortAtmosphereTemplate, assembleImpulseSync, } from "../../../src/guidance/index.js";
+const quietScene = {
+    sceneType: "quiet",
+    mode: "quiet",
+    riskLevel: "low",
+    sceneSummary: "night reflection",
+};
+const activeHighRiskScene = {
+    sceneType: "social",
+    mode: "active",
+    riskLevel: "high",
+    sceneSummary: "hot topic",
+};
+const maintenanceScene = {
+    sceneType: "explain",
+    mode: "maintenance_only",
+    riskLevel: "medium",
+    sceneSummary: "system check",
+};
+const candidates = [
+    {
+        id: "user-1",
+        source: "USER",
+        text: "当事情和用户真的有关时，我不该总把话咽回去。",
+        tags: ["outreach", "user", "trust"],
+    },
+];
+// ─── T-V7C.C.7: Expression Boundary Semantics ────────────────────────────────
+test("buildExpressionBoundary returns expression_boundary kind with avoid_prefer style", () => {
+    const boundary = buildExpressionBoundary("social");
+    assert.equal(boundary.kind, "expression_boundary");
+    assert.equal(boundary.style, "avoid_prefer");
+    assert.equal(boundary.ownership, "behavioral_guidance_system");
+    assert.ok(boundary.constraints.length > 0);
+    assert.ok(boundary.constraints.every((c) => !c.includes("JSON") && !c.includes("Markdown") && !c.includes("格式")), "expression boundary must not prescribe fixed format");
+    assert.ok(boundary.constraints.some((c) => c.includes("避免") || c.includes("不要")), "constraints should be avoid/prefer style");
+});
+test("buildOutputGuard remains backward compatible and marks expression-only semantics", () => {
+    const block = buildOutputGuard("reply");
+    assert.equal(block.kind, "output_guard");
+    assert.equal(block.hardGuardPriority, true);
+    assert.equal(block._semanticNote, "output_guard_only_shapes_expression");
+    assert.ok(block.constraints.length > 0);
+});
+test("getOutputGuardDefinition documents expression-only intent", () => {
+    const definition = getOutputGuardDefinition("outreach");
+    assert.equal(definition.note, "output_guard_only_shapes_expression");
+    assert.equal(definition.hardGuardPriority, true);
+});
+test("assembleGuidance returns both outputGuard (compat) and expressionBoundary (new semantic)", async () => {
+    const payload = await assembleGuidance({
+        sceneContext: quietScene,
+        personaCandidates: candidates,
+    });
+    if ("available" in payload) {
+        assert.fail("expected guidance payload");
+    }
+    assert.ok(payload.outputGuard, "backward-compatible outputGuard must exist");
+    assert.ok(payload.expressionBoundary, "new expressionBoundary must exist");
+    assert.equal(payload.expressionBoundary.kind, "expression_boundary");
+    assert.equal(payload.expressionBoundary.style, "avoid_prefer");
+    assert.equal(payload.expressionBoundary.ownership, "behavioral_guidance_system");
+});
+test("minimal fallback carries expressionBoundary", () => {
+    const fallback = buildMinimalGuidanceFallback(activeHighRiskScene);
+    assert.equal(fallback.minimal, true);
+    assert.ok(fallback.outputGuard);
+    assert.ok(fallback.expressionBoundary);
+    assert.equal(fallback.expressionBoundary.kind, "expression_boundary");
+});
+// ─── T-V7C.C.7: Atmosphere Short Constraint ──────────────────────────────────
+test("getShortAtmosphereTemplate returns short constraint text under 120 chars", () => {
+    const modes = ["active", "quiet", "maintenance_only", "paused_for_interrupt"];
+    const risks = ["low", "medium", "high", undefined];
+    for (const mode of modes) {
+        for (const risk of risks) {
+            const tmpl = getShortAtmosphereTemplate(mode, risk);
+            assert.ok(tmpl.text.length <= 120, `atmosphere for ${mode}/${risk ?? "unknown"} too long: ${tmpl.text.length}`);
+            assert.equal(tmpl.reviewStatus, "approved");
+        }
+    }
+});
+test("getShortAtmosphereTemplate varies by mode and risk", () => {
+    const activeLow = getShortAtmosphereTemplate("active", "low").text;
+    const activeHigh = getShortAtmosphereTemplate("active", "high").text;
+    const quietLow = getShortAtmosphereTemplate("quiet", "low").text;
+    assert.notEqual(activeLow, activeHigh, "active low and high should differ");
+    assert.notEqual(activeLow, quietLow, "active and quiet should differ");
+});
+test("assembleGuidance uses short atmosphere instead of long baseline", async () => {
+    const payload = await assembleGuidance({
+        sceneContext: activeHighRiskScene,
+        personaCandidates: [],
+    });
+    if ("available" in payload) {
+        assert.fail("expected guidance payload");
+    }
+    assert.ok(payload.atmosphere);
+    assert.ok(payload.atmosphere.text.length <= 120, `atmosphere text too long: ${payload.atmosphere.text.length}`);
+});
+// ─── T-V7C.C.7: agent.* exclusion ────────────────────────────────────────────
+test("assembleImpulseSync excludes agent.* capabilities from impulse injection", () => {
+    const result = assembleImpulseSync({
+        sceneType: "social",
+        capabilityIntent: "agent.heartbeat",
+    });
+    assert.equal(result.impulse, null);
+    assert.equal(result.source, "none");
+    assert.equal(result.capabilityClass, null);
+});
+test("assembleImpulseSync excludes agent.internal from impulse injection", () => {
+    const result = assembleImpulseSync({
+        sceneType: "social",
+        capabilityIntent: "agent.internal.probe",
+    });
+    assert.equal(result.impulse, null);
+    assert.equal(result.source, "none");
+});
+// ─── T-V7C.C.7: Hard guard boundary separation ───────────────────────────────
+test("expressionBoundary ownership is behavioral_guidance_system, not hard-guard-layer", async () => {
+    const payload = await assembleGuidance({
+        sceneContext: maintenanceScene,
+        personaCandidates: [],
+    });
+    if ("available" in payload) {
+        assert.fail("expected guidance payload");
+    }
+    assert.ok(payload.expressionBoundary);
+    assert.equal(payload.expressionBoundary.ownership, "behavioral_guidance_system");
+});
+// ─── T-V7C.C.7: Legacy consumer compatibility ────────────────────────────────
+test("GuidancePayload still allows reading outputGuard without field missing", async () => {
+    const payload = await assembleGuidance({
+        sceneContext: quietScene,
+        personaCandidates: candidates,
+    });
+    if ("available" in payload) {
+        assert.fail("expected guidance payload");
+    }
+    // Legacy consumer pattern
+    const constraints = payload.outputGuard?.constraints ?? [];
+    assert.ok(Array.isArray(constraints));
+    assert.ok(constraints.length > 0);
+});

package/dist/tests/integration/observability/digest-delivery.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Integration tests for HeartbeatDigest delivery hook — T-OBS.C.4
+ *
+ * Verification plan §t-obs-c-4:
+ *   1. Feishu-like adapter succeeds → deliveredAt + deliveryProof set; no fallbackReason
+ *   2. Adapter fails → deliveryFallbackReason set; status not_sent; deliveredAt NOT set
+ *   3. Adapter declares "sent" without proof → treated as not_sent; fallbackReason = "delivery_proof_missing"
+ *   4. Adapter throws → error absorbed; deliveryFallbackReason set; digest still returned
+ *   5. No adapter injected → digest returned without delivery fields
+ *   6. Adapter not_sent → fallbackReason propagated verbatim
+ *   7. Digest content is never outreach (no "reach out", "I miss you" style phrasing)
+ *   8. deliveryProof contains channelId + messageHash only (no raw content)
+ */
+export {};

package/dist/tests/integration/observability/digest-delivery.test.js

@@ -0,0 +1,160 @@
+/**
+ * Integration tests for HeartbeatDigest delivery hook — T-OBS.C.4
+ *
+ * Verification plan §t-obs-c-4:
+ *   1. Feishu-like adapter succeeds → deliveredAt + deliveryProof set; no fallbackReason
+ *   2. Adapter fails → deliveryFallbackReason set; status not_sent; deliveredAt NOT set
+ *   3. Adapter declares "sent" without proof → treated as not_sent; fallbackReason = "delivery_proof_missing"
+ *   4. Adapter throws → error absorbed; deliveryFallbackReason set; digest still returned
+ *   5. No adapter injected → digest returned without delivery fields
+ *   6. Adapter not_sent → fallbackReason propagated verbatim
+ *   7. Digest content is never outreach (no "reach out", "I miss you" style phrasing)
+ *   8. deliveryProof contains channelId + messageHash only (no raw content)
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { generateHeartbeatDigest, } from "../../../src/observability/services/heartbeat-digest-assembler.js";
+import { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function makeEmptyStore() {
+    return new AppendOnlyAuditStore();
+}
+function makeFeishuAdapter(opts) {
+    return {
+        deliver: async (_digest) => {
+            if (opts?.shouldThrow) {
+                throw new Error("feishu_api_timeout");
+            }
+            if (opts?.shouldFail) {
+                return {
+                    status: "not_sent",
+                    fallbackReason: "feishu_channel_unavailable",
+                };
+            }
+            if (opts?.omitProof) {
+                return {
+                    status: "sent",
+                    // Intentionally omit proof to trigger honesty guard
+                };
+            }
+            return {
+                status: "sent",
+                proof: {
+                    channelId: "feishu:dm:user-123",
+                    messageHash: "sha256:abc123def456",
+                },
+                deliveredAt: "2026-01-15T10:00:00.000Z",
+            };
+        },
+    };
+}
+const DATE = "2026-01-15";
+const FIXED_NOW = "2026-01-15T09:00:00.000Z";
+// ─── Tests ───────────────────────────────────────────────────────────────────
+describe("HeartbeatDigest delivery — T-OBS.C.4", () => {
+    it("Feishu adapter succeeds → deliveredAt + deliveryProof set; no fallbackReason", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            deliveryAdapter: makeFeishuAdapter(),
+            now: () => FIXED_NOW,
+        });
+        assert.ok(digest.deliveredAt, "deliveredAt should be set");
+        assert.ok(digest.deliveryProof, "deliveryProof should be set");
+        assert.equal(digest.deliveryProof.channelId, "feishu:dm:user-123");
+        assert.equal(digest.deliveryProof.messageHash, "sha256:abc123def456");
+        assert.equal(digest.deliveryFallbackReason, undefined);
+    });
+    it("Adapter fails → deliveryFallbackReason set; deliveredAt NOT set", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            deliveryAdapter: makeFeishuAdapter({ shouldFail: true }),
+            now: () => FIXED_NOW,
+        });
+        assert.equal(digest.deliveredAt, undefined, "deliveredAt must not be set on failure");
+        assert.equal(digest.deliveryProof, undefined, "deliveryProof must not be set on failure");
+        assert.equal(digest.deliveryFallbackReason, "feishu_channel_unavailable");
+    });
+    it("Adapter declares 'sent' without proof → treated as not_sent", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            deliveryAdapter: makeFeishuAdapter({ omitProof: true }),
+            now: () => FIXED_NOW,
+        });
+        assert.equal(digest.deliveredAt, undefined, "deliveredAt must not be set without proof");
+        assert.equal(digest.deliveryProof, undefined);
+        assert.equal(digest.deliveryFallbackReason, "delivery_proof_missing");
+    });
+    it("Adapter throws → error absorbed; deliveryFallbackReason set; digest returned", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            deliveryAdapter: makeFeishuAdapter({ shouldThrow: true }),
+            now: () => FIXED_NOW,
+        });
+        // Must not throw — digest must be returned
+        assert.ok(digest, "digest must be returned even when adapter throws");
+        assert.equal(digest.deliveredAt, undefined);
+        assert.ok(digest.deliveryFallbackReason?.startsWith("delivery_error:"), `fallbackReason should start with 'delivery_error:', got: ${digest.deliveryFallbackReason}`);
+        assert.ok(digest.deliveryFallbackReason?.includes("feishu_api_timeout"), "fallbackReason should include the original error message");
+    });
+    it("No adapter injected → digest returned without delivery fields", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            now: () => FIXED_NOW,
+        });
+        assert.equal(digest.deliveredAt, undefined);
+        assert.equal(digest.deliveryProof, undefined);
+        assert.equal(digest.deliveryFallbackReason, undefined);
+    });
+    it("Adapter not_sent → fallbackReason propagated verbatim", async () => {
+        const adapter = {
+            deliver: async () => ({
+                status: "not_sent",
+                fallbackReason: "dashboard_mock_disabled",
+            }),
+        };
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            deliveryAdapter: adapter,
+            now: () => FIXED_NOW,
+        });
+        assert.equal(digest.deliveryFallbackReason, "dashboard_mock_disabled");
+        assert.equal(digest.deliveredAt, undefined);
+    });
+    it("deliveryProof contains channelId + messageHash (no raw content fields)", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            deliveryAdapter: makeFeishuAdapter(),
+            now: () => FIXED_NOW,
+        });
+        assert.ok(digest.deliveryProof);
+        const proofKeys = Object.keys(digest.deliveryProof);
+        // Only allowed fields: channelId + messageHash
+        assert.ok(proofKeys.includes("channelId"), "proof must have channelId");
+        assert.ok(proofKeys.includes("messageHash"), "proof must have messageHash");
+        // Must NOT contain raw content
+        const forbidden = ["content", "body", "text", "message", "payload", "raw"];
+        for (const f of forbidden) {
+            assert.ok(!proofKeys.includes(f), `proof must not contain field "${f}"`);
+        }
+    });
+    it("Digest content contains no outreach language (NG2)", async () => {
+        const store = makeEmptyStore();
+        const digest = await generateHeartbeatDigest(DATE, {
+            auditStore: store,
+            now: () => FIXED_NOW,
+        });
+        // Digest is a structured object — no string fields should contain outreach phrases
+        const jsonStr = JSON.stringify(digest).toLowerCase();
+        const outreachPhrases = ["reach out", "i miss you", "hey there", "how are you", "checking in"];
+        for (const phrase of outreachPhrases) {
+            assert.ok(!jsonStr.includes(phrase), `Digest must not contain outreach phrase "${phrase}" (NG2)`);
+        }
+    });
+});

package/dist/tests/integration/observability/evidence-query-engine.test.d.ts

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