@haaaiawd/second-nature 0.1.50 → 0.2.0

package/dist/tests/integration/dream/v7c-rhythm-loop.test.js

@@ -1,185 +0,0 @@
-/**
- * T-V7C.C.3 集成测试 — Rhythm Loop Closure
- *
- * 验收标准:
- *  - Quiet 后 Dream 自动触发或写 explicit skip reason
- *  - accepted Dream projection 可通过 DiaryDreamStore 读取（state already wired via assembler）
- *  - digest delivery target 可用时写 deliveredAt + proof
- *  - digest delivery target 不可用时写 fallbackReason
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { runSourceBackedQuiet, } from "../../../src/core/second-nature/quiet/run-source-backed-quiet.js";
-import { generateHeartbeatDigest, } from "../../../src/observability/services/heartbeat-digest-assembler.js";
-import { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-const TEST_DAY = "2026-05-25";
-const TEST_TIMESTAMP = `${TEST_DAY}T10:00:00.000Z`;
-/**
- * Minimal HeartbeatRuntimeSnapshot for Quiet tests.
- * Evidence refs are pre-filled so Quiet can produce a real artifact.
- */
-function makeRuntimeWithEvidence() {
-    return {
-        continuity: {
-            mode: "active",
-            currentWindowId: "w1",
-            pendingObligations: [],
-            recentOutreachHashes: [],
-            deniedIntents: [],
-            budgets: { socialUsed: 0, socialLimit: 5 },
-            awaitingUserInput: false,
-            riskSuppressed: false,
-        },
-        lifeEvidence: {
-            evidenceRefs: [
-                {
-                    id: "ev:moltbook:feed:1",
-                    kind: "connector_result",
-                    uri: "platform://moltbook/feed.read",
-                    observedAt: TEST_TIMESTAMP,
-                },
-            ],
-            platformEventCount: 1,
-            workEventCount: 0,
-        },
-        rhythmWindow: {
-            windowId: "w1",
-            allowedIntentKinds: [
-                "work",
-                "exploration",
-                "social",
-                "quiet",
-                "reflection",
-                "outreach",
-                "maintenance",
-            ],
-            quietBias: true,
-        },
-        hardGuards: {
-            hasDuplicateIntent: () => false,
-            isOutreachCooldownClear: () => true,
-        },
-    };
-}
-function makeQuietIntent() {
-    return {
-        id: "intent-quiet",
-        kind: "quiet",
-        summary: "quiet window bookkeeping",
-        effectClass: "no_effect",
-        sourceRefs: [],
-        idempotencyKey: "quiet:bookkeeping",
-        goalInfluenceRefs: [],
-        priority: 55,
-        source: "quiet_plan",
-    };
-}
-// ─── Tests ────────────────────────────────────────────────────────────────────
-describe("T-V7C.C.3 — Rhythm Loop Closure", () => {
-    it("Quiet auto-triggers Dream (quiet_completion) after successful artifact write", async () => {
-        const scheduled = [];
-        const mockDreamPort = {
-            async scheduleDream(params) {
-                scheduled.push({ triggerKind: params.triggerKind, runId: params.runId });
-                return { status: "started" };
-            },
-        };
-        const result = await runSourceBackedQuiet({
-            candidate: makeQuietIntent(),
-            runtime: makeRuntimeWithEvidence(),
-            day: TEST_DAY,
-            dreamSchedulePort: mockDreamPort,
-        });
-        assert.strictEqual(result.result.status, "intent_selected", `expected intent_selected, got ${result.result.status}`);
-        assert.ok(result.result.reasons.includes("quiet_artifact_written"), `expected quiet_artifact_written in reasons: ${result.result.reasons.join(", ")}`);
-        assert.strictEqual(scheduled.length, 1, "expected Dream to be scheduled once");
-        assert.strictEqual(scheduled[0].triggerKind, "quiet_completion");
-        assert.ok(result.result.reasons.some((r) => r === "quiet_dream_scheduled"), `expected quiet_dream_scheduled in reasons: ${result.result.reasons.join(", ")}`);
-    });
-    it("Quiet writes explicit skip reason when Dream scheduler returns skipped (lock held)", async () => {
-        const mockDreamPort = {
-            async scheduleDream() {
-                return { status: "skipped", reason: "lock_held" };
-            },
-        };
-        const result = await runSourceBackedQuiet({
-            candidate: makeQuietIntent(),
-            runtime: makeRuntimeWithEvidence(),
-            day: TEST_DAY,
-            dreamSchedulePort: mockDreamPort,
-        });
-        assert.strictEqual(result.result.status, "intent_selected");
-        assert.ok(result.result.reasons.some((r) => r.startsWith("quiet_dream_skip:")), `expected quiet_dream_skip:* in reasons: ${result.result.reasons.join(", ")}`);
-        assert.ok(result.result.reasons.some((r) => r.includes("lock_held")), `expected lock_held in skip reason: ${result.result.reasons.join(", ")}`);
-    });
-    it("Quiet artifact is written without Dream when no dreamSchedulePort provided", async () => {
-        const result = await runSourceBackedQuiet({
-            candidate: makeQuietIntent(),
-            runtime: makeRuntimeWithEvidence(),
-            day: TEST_DAY,
-            // No dreamSchedulePort
-        });
-        assert.strictEqual(result.result.status, "intent_selected");
-        assert.ok(result.result.reasons.includes("quiet_artifact_written"), `expected quiet_artifact_written: ${result.result.reasons.join(", ")}`);
-        // No dream-related reason emitted
-        assert.ok(!result.result.reasons.some((r) => r.startsWith("quiet_dream")), `unexpected dream reason: ${result.result.reasons.join(", ")}`);
-    });
-    it("digest generates with delivery proof when adapter returns sent", async () => {
-        const auditStore = new AppendOnlyAuditStore();
-        const mockAdapter = {
-            async deliver(_digest) {
-                return {
-                    status: "sent",
-                    proof: { channelId: "test-channel", messageHash: "abc123" },
-                    deliveredAt: TEST_TIMESTAMP,
-                };
-            },
-        };
-        const deps = {
-            auditStore,
-            deliveryAdapter: mockAdapter,
-            now: () => TEST_TIMESTAMP,
-        };
-        const digest = await generateHeartbeatDigest(TEST_DAY, deps);
-        assert.strictEqual(digest.date, TEST_DAY);
-        assert.ok(digest.deliveredAt, "expected deliveredAt to be set on successful delivery");
-        assert.ok(digest.deliveryProof, "expected deliveryProof to be set");
-        assert.strictEqual(digest.deliveryProof.channelId, "test-channel");
-        assert.strictEqual(digest.deliveryProof.messageHash, "abc123");
-        assert.strictEqual(digest.deliveryFallbackReason, undefined);
-    });
-    it("digest writes fallbackReason when delivery adapter returns not_sent", async () => {
-        const auditStore = new AppendOnlyAuditStore();
-        const mockAdapter = {
-            async deliver(_digest) {
-                return {
-                    status: "not_sent",
-                    fallbackReason: "channel_unavailable",
-                };
-            },
-        };
-        const deps = {
-            auditStore,
-            deliveryAdapter: mockAdapter,
-            now: () => TEST_TIMESTAMP,
-        };
-        const digest = await generateHeartbeatDigest(TEST_DAY, deps);
-        assert.strictEqual(digest.date, TEST_DAY);
-        assert.strictEqual(digest.deliveryFallbackReason, "channel_unavailable", `expected channel_unavailable fallback, got: ${digest.deliveryFallbackReason}`);
-        assert.strictEqual(digest.deliveredAt, undefined);
-        assert.strictEqual(digest.deliveryProof, undefined);
-    });
-    it("digest generates without delivery adapter (no delivery attempted)", async () => {
-        const auditStore = new AppendOnlyAuditStore();
-        const deps = {
-            auditStore,
-            now: () => TEST_TIMESTAMP,
-        };
-        const digest = await generateHeartbeatDigest(TEST_DAY, deps);
-        assert.strictEqual(digest.date, TEST_DAY);
-        assert.strictEqual(digest.deliveredAt, undefined);
-        assert.strictEqual(digest.deliveryFallbackReason, undefined);
-        assert.strictEqual(digest.isNothingSignificant, true);
-    });
-});

package/dist/tests/integration/guidance/assembler-and-fallback.test.d.ts

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

package/dist/tests/integration/guidance/assembler-and-fallback.test.js

@@ -1,86 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { assembleGuidance, buildMinimalGuidanceFallback, buildOutputGuard, getOutputGuardDefinition, } from "../../../src/guidance/index.js";
-const quietScene = {
-    sceneType: "quiet",
-    mode: "quiet",
-    riskLevel: "low",
-    sceneSummary: "night reflection",
-};
-const outreachScene = {
-    sceneType: "outreach",
-    mode: "active",
-    riskLevel: "medium",
-    sceneSummary: "need user direction",
-};
-const candidates = [
-    {
-        id: "user-1",
-        source: "USER",
-        text: "当事情和用户真的有关时，我不该总把话咽回去。",
-        tags: ["outreach", "user", "trust"],
-    },
-    {
-        id: "soul-1",
-        source: "SOUL",
-        text: "我想保留有呼吸感的表达，不把自己说成客服。",
-        tags: ["outreach", "voice", "care"],
-    },
-];
-test("output guard keeps expression-only constraints and hard guard priority", () => {
-    const definition = getOutputGuardDefinition("reply");
-    const block = buildOutputGuard("reply");
-    assert.equal(definition.note, "output_guard_only_shapes_expression");
-    assert.equal(definition.hardGuardPriority, true);
-    assert.equal(block.hardGuardPriority, true);
-    assert.ok(block.constraints.some((item) => item.includes("客服")));
-    assert.ok(block.constraints.some((item) => item.includes("教程") || item.includes("步骤") || item.includes("培训")));
-});
-test("minimal fallback keeps guidance path alive without persona injection", () => {
-    const fallback = buildMinimalGuidanceFallback(quietScene);
-    assert.equal(fallback.minimal, true);
-    assert.equal(fallback.scene.sceneType, "quiet");
-    assert.deepEqual(fallback.personaReinforcement, []);
-    assert.deepEqual(fallback.impulses, []);
-    assert.equal(fallback.outputGuard.hardGuardPriority, true);
-});
-test("assembler returns four-part payload for supported scene without changing decision semantics", async () => {
-    const payload = await assembleGuidance({
-        sceneContext: outreachScene,
-        personaCandidates: candidates,
-    });
-    if ("available" in payload) {
-        assert.fail("expected guidance payload");
-    }
-    assert.equal(payload.scene.sceneType, "outreach");
-    assert.equal(payload.impulses.length, 1);
-    assert.ok(payload.atmosphere);
-    assert.ok(payload.outputGuard);
-    assert.ok(payload.personaReinforcement.length > 0);
-});
-test("assembler allows explain scene to omit impulses while keeping payload shape stable", async () => {
-    const payload = await assembleGuidance({
-        sceneContext: {
-            sceneType: "explain",
-            mode: "active",
-            riskLevel: "low",
-        },
-        personaCandidates: candidates,
-    });
-    if ("available" in payload) {
-        assert.fail("expected guidance payload");
-    }
-    assert.deepEqual(payload.impulses, []);
-    assert.ok(payload.outputGuard);
-});
-test("assembler returns unavailable when scene context is missing", async () => {
-    const result = await assembleGuidance({
-        sceneContext: null,
-        personaCandidates: candidates,
-    });
-    if (!("available" in result)) {
-        assert.fail("expected guidance unavailable result");
-    }
-    assert.equal(result.available, false);
-    assert.equal(result.reason, "missing_scene_context");
-});

package/dist/tests/integration/guidance/outreach-draft-contract.test.d.ts

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

package/dist/tests/integration/guidance/outreach-draft-contract.test.js

@@ -1,106 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { buildOutreachDraftRequest } from "../../../src/core/second-nature/outreach/build-outreach-draft-request.js";
-import { draftOutreachMessage } from "../../../src/guidance/draft-outreach-message.js";
-import { judgeOutreach } from "../../../src/core/second-nature/outreach/judge-outreach.js";
-import { resolveDeliveryTarget } from "../../../src/core/second-nature/outreach/delivery-target.js";
-import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
-import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
-const ref = (id) => ({
-    id,
-    kind: "platform_item",
-    uri: `https://example.test/${id}`,
-});
-function makeSnapshot(ts) {
-    const inputs = {
-        mode: "active",
-        currentWindowId: "win_work_morning",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        lifeEvidenceRefs: [ref("ev-1")],
-        duplicateIntentKeys: [],
-        outreachCooldownKeys: [],
-    };
-    const continuity = buildContinuitySnapshot(inputs);
-    return buildHeartbeatRuntimeSnapshot(ts, inputs, continuity);
-}
-const baseCandidate = {
-    id: "c-outreach-1",
-    kind: "outreach",
-    priority: 5,
-    source: "tick",
-    summary: "platform direction check-in",
-    effectClass: "user_outreach",
-    sourceRefs: [ref("src-1")],
-};
-test("T6.2.1 allow + target_available → sendable draft", async () => {
-    const snapshot = makeSnapshot("2026-05-02T12:00:00.000Z");
-    const judgment = judgeOutreach({
-        candidate: baseCandidate,
-        userInterest: {
-            staleness: "fresh",
-            confidence: 0.9,
-            signals: [{ topic: "platform", confidence: 0.8, sourceRefs: [ref("int-1")] }],
-            sourceRefs: [ref("int-1")],
-        },
-        lifeEvidence: { empty: false, evidenceRefCount: 2 },
-        delivery: { target: "explicit", channel: "dm", recipient: "user-1" },
-    });
-    assert.equal(judgment.verdict, "allow");
-    const delivery = resolveDeliveryTarget({ target: "explicit", channel: "dm", recipient: "user-1" });
-    const req = buildOutreachDraftRequest(baseCandidate, judgment, snapshot, delivery);
-    const draft = await draftOutreachMessage(req);
-    assert.equal(draft.status, "ready");
-    if (draft.status === "ready") {
-        assert.equal(draft.draft.deliveryWording, "sendable");
-        assert.ok(!draft.draft.text.toLowerCase().includes("not sent to the user"));
-    }
-});
-test("T6.2.1 allow + target_none → fallback_candidate wording, never claims sent", async () => {
-    const snapshot = makeSnapshot("2026-05-02T12:00:00.000Z");
-    const judgment = judgeOutreach({
-        candidate: baseCandidate,
-        userInterest: {
-            staleness: "fresh",
-            confidence: 0.9,
-            signals: [{ topic: "platform", confidence: 0.8, sourceRefs: [ref("int-1")] }],
-            sourceRefs: [ref("int-1")],
-        },
-        lifeEvidence: { empty: false, evidenceRefCount: 2 },
-        delivery: { target: "none" },
-    });
-    assert.equal(judgment.verdict, "allow");
-    const delivery = resolveDeliveryTarget({ target: "none" });
-    const req = buildOutreachDraftRequest(baseCandidate, judgment, snapshot, delivery);
-    assert.equal(req.sceneType, "fallback_candidate");
-    const draft = await draftOutreachMessage(req);
-    assert.equal(draft.status, "ready");
-    if (draft.status === "ready") {
-        assert.equal(draft.draft.deliveryWording, "not_sent_fallback_candidate");
-        assert.ok(draft.draft.text.toLowerCase().includes("not sent"));
-    }
-});
-test("T6.2.1 deny judgment → hard_decision_not_allow", async () => {
-    const snapshot = makeSnapshot("2026-05-02T12:00:00.000Z");
-    const badCandidate = { ...baseCandidate, id: "c-bad", sourceRefs: [] };
-    const judgment = judgeOutreach({
-        candidate: badCandidate,
-        userInterest: {
-            staleness: "insufficient",
-            confidence: 0,
-            signals: [],
-            sourceRefs: [],
-        },
-        lifeEvidence: { empty: true, evidenceRefCount: 0 },
-        delivery: { target: "explicit", channel: "dm", recipient: "u" },
-    });
-    assert.notEqual(judgment.verdict, "allow");
-    const delivery = resolveDeliveryTarget({ target: "explicit", channel: "dm", recipient: "u" });
-    const req = buildOutreachDraftRequest(badCandidate, judgment, snapshot, delivery);
-    const draft = await draftOutreachMessage(req);
-    assert.equal(draft.status, "unavailable");
-    if (draft.status === "unavailable") {
-        assert.ok(draft.reasons.includes("hard_decision_not_allow"));
-    }
-});

package/dist/tests/integration/guidance/persona-selection.test.d.ts

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

package/dist/tests/integration/guidance/persona-selection.test.js

@@ -1,70 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { getPersonaSelectionPolicy, selectPersonaSnippets, } from "../../../src/guidance/persona-selection.js";
-const candidates = [
-    {
-        id: "soul-1",
-        source: "SOUL",
-        text: "我希望自己的表达有呼吸感，不想变成机械的总结器。",
-        tags: ["quiet", "reflection", "voice"],
-    },
-    {
-        id: "user-1",
-        source: "USER",
-        text: "和用户沟通时，我更珍惜清楚、节制但真诚的靠近。",
-        tags: ["outreach", "user", "trust"],
-    },
-    {
-        id: "memory-1",
-        source: "MEMORY",
-        text: "上一次主动联系是在真的需要方向确认时，对方更愿意接住简短但具体的消息。",
-        tags: ["outreach", "memory", "care"],
-    },
-    {
-        id: "identity-1",
-        source: "IDENTITY",
-        text: "我倾向于把原则讲清楚，但不会让解释压过正在发生的关系。",
-        tags: ["explain", "principle", "clarity"],
-    },
-];
-test("persona selection policy keeps scene-specific priority and snippet cap", () => {
-    const sceneContext = {
-        sceneType: "outreach",
-        mode: "active",
-        riskLevel: "low",
-    };
-    const decision = selectPersonaSnippets({ sceneContext, candidates });
-    assert.equal(decision.budget.maxSnippets, 2);
-    assert.ok(decision.snippets.length <= 2);
-    assert.equal(decision.snippets[0]?.source, "USER");
-    assert.ok(decision.snippets.every((snippet) => snippet.rationale.length > 0));
-});
-test("quiet scene allows slightly larger budget without full-document injection", () => {
-    const sceneContext = {
-        sceneType: "quiet",
-        mode: "quiet",
-        riskLevel: "low",
-    };
-    const longCandidate = {
-        id: "memory-long",
-        source: "MEMORY",
-        text: "quiet ".repeat(300),
-        tags: ["quiet", "reflection", "memory"],
-    };
-    const decision = selectPersonaSnippets({
-        sceneContext,
-        candidates: [longCandidate, ...candidates],
-    });
-    assert.equal(decision.budget.maxSnippets, 3);
-    assert.ok(decision.snippets.length <= 3);
-    const totalCharacters = decision.snippets.reduce((sum, snippet) => sum + snippet.text.length, 0);
-    assert.ok(totalCharacters <= decision.budget.maxTotalCharacters);
-    assert.ok(decision.snippets[0]?.text.length < longCandidate.text.length);
-});
-test("policy lookup stays explicit for every guidance scene", () => {
-    assert.deepEqual(getPersonaSelectionPolicy("social").sourcePriority, ["SOUL", "IDENTITY", "MEMORY", "USER"]);
-    assert.deepEqual(getPersonaSelectionPolicy("reply").sourcePriority, ["USER", "IDENTITY", "SOUL", "MEMORY"]);
-    assert.deepEqual(getPersonaSelectionPolicy("outreach").sourcePriority, ["USER", "SOUL", "MEMORY", "IDENTITY"]);
-    assert.deepEqual(getPersonaSelectionPolicy("quiet").sourcePriority, ["SOUL", "MEMORY", "IDENTITY", "USER"]);
-    assert.deepEqual(getPersonaSelectionPolicy("explain").sourcePriority, ["IDENTITY", "USER", "SOUL", "MEMORY"]);
-});

package/dist/tests/integration/guidance/template-review.test.d.ts

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

package/dist/tests/integration/guidance/template-review.test.js

@@ -1,26 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { collectGuidanceReviewChecklist } from "../../../src/guidance/review-workflow.js";
-test("guidance review workflow includes every required template in one checklist", async () => {
-    const checklist = await collectGuidanceReviewChecklist();
-    assert.equal(checklist.items.length, 6);
-    assert.ok(checklist.items.every((item) => item.reviewRequired));
-    assert.ok(checklist.items.every((item) => item.relativePath.startsWith("src/guidance/templates/")));
-    assert.ok(checklist.items.every((item) => ["pending_human_review", "approved", "rejected"].includes(item.reviewStatus)));
-    assert.doesNotThrow(() => JSON.stringify(checklist));
-});
-test("review workflow maps approved templates to ready_for_runtime_use", async () => {
-    const checklist = await collectGuidanceReviewChecklist();
-    const personaPolicy = checklist.items.find((item) => item.templateId === "persona.selection");
-    assert.ok(personaPolicy);
-    assert.equal(personaPolicy?.scope, "persona_reinforcement_policy");
-    assert.equal(personaPolicy?.reviewStatus, "approved");
-    assert.equal(personaPolicy?.nextAction, "ready_for_runtime_use");
-});
-test("review workflow marks approved outreach template as ready_for_runtime_use", async () => {
-    const checklist = await collectGuidanceReviewChecklist();
-    const outreach = checklist.items.find((item) => item.templateId === "impulse.outreach");
-    assert.ok(outreach);
-    assert.equal(outreach?.reviewStatus, "approved");
-    assert.equal(outreach?.nextAction, "ready_for_runtime_use");
-});

package/dist/tests/integration/guidance/user-reply-continuity.test.d.ts

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

package/dist/tests/integration/guidance/user-reply-continuity.test.js

@@ -1,96 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { buildLightReplyContinuity, isDirectUserReply, USER_REPLY_SCENE_TYPE, } from "../../../src/core/second-nature/guidance/user-reply-continuity.js";
-// ─── T6.1.1: User Reply Light Continuity Tests ──────────────────────────────
-test("T6.1.1 buildLightReplyContinuity returns guidance without impulses", async () => {
-    const result = await buildLightReplyContinuity({
-        replyContext: {
-            recentTone: "casual and thoughtful",
-        },
-    });
-    assert.ok("scene" in result, "should return guidance payload");
-    assert.ok("impulses" in result, "should have impulses field");
-    assert.equal(result.impulses.length, 0, "should have NO impulses (key difference from platform reply)");
-});
-test("T6.1.1 buildLightReplyContinuity includes light atmosphere", async () => {
-    const result = await buildLightReplyContinuity({
-        replyContext: {
-            recentTone: "casual and thoughtful",
-        },
-    });
-    assert.ok("atmosphere" in result, "should have atmosphere");
-    const atmosphere = result.atmosphere;
-    assert.ok(atmosphere.text.includes("语气"), "atmosphere should mention tone continuity");
-    assert.ok(atmosphere.text.includes("casual and thoughtful"), "atmosphere should include recent tone reference");
-});
-test("T6.1.1 buildLightReplyContinuity includes persona reinforcement when candidates provided", async () => {
-    const candidates = [
-        { id: "soul-1", source: "SOUL", text: "I value authenticity", tags: ["authenticity"] },
-        { id: "user-1", source: "USER", text: "User prefers concise replies", tags: ["preference"] },
-    ];
-    const result = await buildLightReplyContinuity({
-        replyContext: {},
-        personaCandidates: candidates,
-    });
-    assert.ok("personaReinforcement" in result, "should have persona reinforcement");
-    // Note: selectPersonaSnippets may return 0-2 snippets depending on scene matching
-    // The key is that the path was attempted, not the exact count
-});
-test("T6.1.1 buildLightReplyContinuity does NOT include platform reply impulses", async () => {
-    const result = await buildLightReplyContinuity({
-        replyContext: {},
-    });
-    const impulses = result.impulses;
-    assert.equal(impulses.length, 0, "should have no impulses - this is the key difference from platform reply scene");
-    // Verify no reply-specific impulse text
-    const impulseTexts = impulses.map((i) => i.text).join(" ");
-    assert.ok(!impulseTexts.includes("reply"), "should not contain reply impulse text");
-});
-test("T6.1.1 buildLightReplyContinuity output guard focuses on tone consistency", async () => {
-    const result = await buildLightReplyContinuity({
-        replyContext: {},
-    });
-    assert.ok("outputGuard" in result, "should have output guard");
-    const guard = result.outputGuard;
-    assert.ok(guard.constraints.length > 0, "should have constraints");
-    assert.ok(guard.constraints.some((c) => c.includes("语气") || c.includes("连续性")), "guard should focus on tone/continuity");
-});
-test("T6.1.1 isDirectUserReply classifies user_reply trigger correctly", () => {
-    // Direct user reply
-    assert.equal(isDirectUserReply({
-        triggerSource: "user_reply",
-        isPlatformReply: false,
-        isExplicitTask: false,
-    }), true, "should classify as direct user reply");
-    // Platform reply (not direct user reply)
-    assert.equal(isDirectUserReply({
-        triggerSource: "user_reply",
-        isPlatformReply: true,
-        isExplicitTask: false,
-    }), false, "platform reply should not be direct user reply");
-    // Explicit task (not direct user reply)
-    assert.equal(isDirectUserReply({
-        triggerSource: "user_reply",
-        isPlatformReply: false,
-        isExplicitTask: true,
-    }), false, "explicit task should not be direct user reply");
-    // Wrong trigger source
-    assert.equal(isDirectUserReply({
-        triggerSource: "heartbeat_bridge",
-        isPlatformReply: false,
-        isExplicitTask: false,
-    }), false, "heartbeat trigger should not be direct user reply");
-});
-test("T6.1.1 USER_REPLY_SCENE_TYPE is distinct from reply scene", () => {
-    assert.equal(USER_REPLY_SCENE_TYPE, "user_reply");
-    assert.notEqual(USER_REPLY_SCENE_TYPE, "reply");
-});
-test("T6.1.1 light continuity uses user_reply scene type", async () => {
-    const result = await buildLightReplyContinuity({
-        replyContext: {},
-    });
-    // Verify the result is a guidance payload with user_reply scene type
-    assert.ok("scene" in result, "should be guidance payload");
-    assert.equal(result.scene.sceneType, "user_reply", "should use user_reply scene type");
-    assert.equal(result.impulses.length, 0, "should not have impulses for user_reply");
-});

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

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