@haaaiawd/second-nature 0.1.34 → 0.1.39

package/runtime/guidance/capability-class.d.ts

@@ -0,0 +1,38 @@
+/**
+ * capability-class.ts — T-V7C.C.4R
+ *
+ * Core logic: infer CapabilityClass from capabilityIntent string prefix.
+ *
+ * CapabilityClass is the middle axis between intentKind (why) and platform (where),
+ * used by ImpulseAssembler to select appropriate behavioral impulse templates.
+ *
+ * Classification rules (prefix-based, not EffectSemanticsClass — execution layer is intentionally
+ * kept separate from expression layer):
+ *   feed.*           → consume   (browsing / reading feeds)
+ *   notification.*   → consume   (reading notifications, not interacting)
+ *   work.*           → discover  (research / task discovery)
+ *   post.*           → broadcast (publishing, primary expression)
+ *   comment.*        → interact  (replying to others' content)
+ *   message.*        → interact  (private messages / DMs)
+ *   task.*           → claim     (claiming work items)
+ *   agent.*          → null      (keepalive/internal — excluded from impulse system)
+ *   unknown/custom   → broadcast (safe default for unrecognized side-effect capabilities)
+ *
+ * Boundary:
+ * - Pure function, zero side effects.
+ * - Does NOT consult EffectSemanticsClass (execution-policy.ts) — those layers must not couple.
+ * - Custom capabilities declared by Claw without a prefix match default to "broadcast".
+ *
+ * Test coverage: tests/unit/guidance/capability-class.test.ts
+ */
+/** The expression-layer classification of a capability. */
+export type CapabilityClass = "consume" | "broadcast" | "interact" | "discover" | "claim";
+/**
+ * Infer CapabilityClass from a capabilityIntent string.
+ *
+ * Returns null for agent.* capabilities (keepalive / internal — no impulse injection).
+ * Returns "broadcast" for unrecognized custom capabilities (safe default).
+ */
+export declare function inferCapabilityClass(capabilityIntent: string): CapabilityClass | null;
+/** Map from CapabilityClass to its default intentKind-style scene, for impulse lookup fallback. */
+export declare const CAPABILITY_CLASS_SCENE_MAP: Readonly<Record<CapabilityClass, string>>;

package/runtime/guidance/capability-class.js

@@ -0,0 +1,65 @@
+/**
+ * capability-class.ts — T-V7C.C.4R
+ *
+ * Core logic: infer CapabilityClass from capabilityIntent string prefix.
+ *
+ * CapabilityClass is the middle axis between intentKind (why) and platform (where),
+ * used by ImpulseAssembler to select appropriate behavioral impulse templates.
+ *
+ * Classification rules (prefix-based, not EffectSemanticsClass — execution layer is intentionally
+ * kept separate from expression layer):
+ *   feed.*           → consume   (browsing / reading feeds)
+ *   notification.*   → consume   (reading notifications, not interacting)
+ *   work.*           → discover  (research / task discovery)
+ *   post.*           → broadcast (publishing, primary expression)
+ *   comment.*        → interact  (replying to others' content)
+ *   message.*        → interact  (private messages / DMs)
+ *   task.*           → claim     (claiming work items)
+ *   agent.*          → null      (keepalive/internal — excluded from impulse system)
+ *   unknown/custom   → broadcast (safe default for unrecognized side-effect capabilities)
+ *
+ * Boundary:
+ * - Pure function, zero side effects.
+ * - Does NOT consult EffectSemanticsClass (execution-policy.ts) — those layers must not couple.
+ * - Custom capabilities declared by Claw without a prefix match default to "broadcast".
+ *
+ * Test coverage: tests/unit/guidance/capability-class.test.ts
+ */
+/**
+ * Infer CapabilityClass from a capabilityIntent string.
+ *
+ * Returns null for agent.* capabilities (keepalive / internal — no impulse injection).
+ * Returns "broadcast" for unrecognized custom capabilities (safe default).
+ */
+export function inferCapabilityClass(capabilityIntent) {
+    if (!capabilityIntent || typeof capabilityIntent !== "string")
+        return null;
+    const prefix = capabilityIntent.split(".")[0]?.toLowerCase() ?? "";
+    switch (prefix) {
+        case "agent":
+            return null; // Keepalive/internal: excluded from impulse system entirely
+        case "feed":
+        case "notification":
+            return "consume";
+        case "work":
+            return "discover";
+        case "post":
+            return "broadcast";
+        case "comment":
+        case "message":
+            return "interact";
+        case "task":
+            return "claim";
+        default:
+            // Custom or unrecognized capability — default to broadcast (outward expression)
+            return "broadcast";
+    }
+}
+/** Map from CapabilityClass to its default intentKind-style scene, for impulse lookup fallback. */
+export const CAPABILITY_CLASS_SCENE_MAP = {
+    consume: "explore",
+    discover: "explore",
+    broadcast: "social",
+    interact: "reply",
+    claim: "work",
+};

package/runtime/guidance/fallback.js

@@ -1,17 +1,20 @@
-import { buildOutputGuard } from "./output-guard.js";
-export function buildMinimalGuidanceFallback(sceneContext) {
-    return {
-        scene: sceneContext,
-        atmosphere: {
-            kind: "atmosphere",
-            text: "我先保留最小但真实的状态感，不因为 guidance 缺席就假装自己失去姿态。",
-            openness: sceneContext.mode === "quiet" ? "quiet" : sceneContext.riskLevel === "high" ? "narrow" : "open",
-            pressureLabels: [sceneContext.mode, sceneContext.riskLevel ?? "unknown_risk"],
-            reviewStatus: "pending_human_review",
-        },
-        impulses: [],
-        personaReinforcement: [],
-        outputGuard: buildOutputGuard(sceneContext.sceneType),
-        minimal: true,
-    };
-}
+import { buildOutputGuard, buildExpressionBoundary } from "./output-guard.js";
+import { getShortAtmosphereTemplate } from "./template-registry.js";
+export function buildMinimalGuidanceFallback(sceneContext) {
+    const atmosphereTemplate = getShortAtmosphereTemplate(sceneContext.mode, sceneContext.riskLevel);
+    return {
+        scene: sceneContext,
+        atmosphere: {
+            kind: "atmosphere",
+            text: atmosphereTemplate.text,
+            openness: sceneContext.mode === "quiet" ? "quiet" : sceneContext.riskLevel === "high" ? "narrow" : "open",
+            pressureLabels: [sceneContext.mode, sceneContext.riskLevel ?? "unknown_risk"],
+            reviewStatus: atmosphereTemplate.reviewStatus,
+        },
+        impulses: [],
+        personaReinforcement: [],
+        outputGuard: buildOutputGuard(sceneContext.sceneType),
+        expressionBoundary: buildExpressionBoundary(sceneContext.sceneType),
+        minimal: true,
+    };
+}

package/runtime/guidance/guidance-assembler.d.ts

@@ -1,5 +1,7 @@
+import { type PlatformImpulsePort } from "./impulse-assembler.js";
 import type { GuidancePayload, GuidanceUnavailable, PersonaCandidate, SceneContext } from "./types.js";
 export declare function assembleGuidance(input: {
     sceneContext: SceneContext | null | undefined;
     personaCandidates?: PersonaCandidate[];
+    platformImpulsePort?: PlatformImpulsePort;
 }): Promise<GuidancePayload | GuidanceUnavailable>;

package/runtime/guidance/guidance-assembler.js

@@ -1,62 +1,76 @@
-import { buildMinimalGuidanceFallback } from "./fallback.js";
-import { buildOutputGuard } from "./output-guard.js";
-import { selectPersonaSnippets } from "./persona-selection.js";
-import { getBaselineAtmosphereTemplate, getImpulseTemplate } from "./template-registry.js";
-async function buildAtmosphere(sceneContext) {
-    const template = getBaselineAtmosphereTemplate();
-    return {
-        kind: "atmosphere",
-        text: template.text,
-        openness: sceneContext.mode === "quiet" ? "quiet" : sceneContext.riskLevel === "high" ? "narrow" : "open",
-        pressureLabels: [sceneContext.mode, sceneContext.riskLevel ?? "unknown_risk"],
-        reviewStatus: template.reviewStatus,
-    };
-}
-async function selectImpulses(sceneContext) {
-    if (sceneContext.sceneType === "explain" || sceneContext.sceneType === "user_reply") {
-        return [];
-    }
-    return [getImpulseTemplate(sceneContext.sceneType)];
-}
-export async function assembleGuidance(input) {
-    if (!input.sceneContext) {
-        return {
-            available: false,
-            reason: "missing_scene_context",
-        };
-    }
-    const sceneContext = input.sceneContext;
-    try {
-        const [atmosphere, impulses] = await Promise.all([
-            buildAtmosphere(sceneContext),
-            selectImpulses(sceneContext),
-        ]);
-        const personaDecision = selectPersonaSnippets({
-            sceneContext,
-            candidates: input.personaCandidates ?? [],
-        });
-        return {
-            scene: sceneContext,
-            atmosphere,
-            impulses,
-            personaReinforcement: personaDecision.snippets,
-            outputGuard: buildOutputGuard(sceneContext.sceneType),
-        };
-    }
-    catch {
-        if ((input.personaCandidates ?? []).length === 0) {
-            const fallback = buildMinimalGuidanceFallback(sceneContext);
-            return {
-                scene: fallback.scene,
-                atmosphere: fallback.atmosphere,
-                impulses: fallback.impulses,
-                personaReinforcement: fallback.personaReinforcement,
-                outputGuard: fallback.outputGuard,
-            };
-        }
-        return {
-            available: false,
-            reason: "missing_template",
-        };
-    }
-}
+import { buildMinimalGuidanceFallback } from "./fallback.js";
+import { buildOutputGuard, buildExpressionBoundary } from "./output-guard.js";
+import { selectPersonaSnippets } from "./persona-selection.js";
+import { getShortAtmosphereTemplate } from "./template-registry.js";
+import { assembleImpulse } from "./impulse-assembler.js";
+async function buildAtmosphere(sceneContext) {
+    const template = getShortAtmosphereTemplate(sceneContext.mode, sceneContext.riskLevel);
+    return {
+        kind: "atmosphere",
+        text: template.text,
+        openness: sceneContext.mode === "quiet" ? "quiet" : sceneContext.riskLevel === "high" ? "narrow" : "open",
+        pressureLabels: [sceneContext.mode, sceneContext.riskLevel ?? "unknown_risk"],
+        reviewStatus: template.reviewStatus,
+    };
+}
+/**
+ * Select impulses using the dual-axis capabilityClass assembler (T-V7C.C.4R).
+ *
+ * Fallback chain: platform-specific → capabilityClass preset → intentKind → []
+ */
+async function selectImpulses(sceneContext, deps) {
+    if (sceneContext.sceneType === "explain" || sceneContext.sceneType === "user_reply") {
+        return [];
+    }
+    const result = await assembleImpulse({
+        sceneType: sceneContext.sceneType,
+        capabilityIntent: sceneContext.capabilityIntent,
+        platformId: sceneContext.platformId,
+    }, deps);
+    return result.impulse ? [result.impulse] : [];
+}
+export async function assembleGuidance(input) {
+    if (!input.sceneContext) {
+        return {
+            available: false,
+            reason: "missing_scene_context",
+        };
+    }
+    const sceneContext = input.sceneContext;
+    const deps = { platformImpulsePort: input.platformImpulsePort };
+    try {
+        const [atmosphere, impulses] = await Promise.all([
+            buildAtmosphere(sceneContext),
+            selectImpulses(sceneContext, deps),
+        ]);
+        const personaDecision = selectPersonaSnippets({
+            sceneContext,
+            candidates: input.personaCandidates ?? [],
+        });
+        return {
+            scene: sceneContext,
+            atmosphere,
+            impulses,
+            personaReinforcement: personaDecision.snippets,
+            outputGuard: buildOutputGuard(sceneContext.sceneType),
+            expressionBoundary: buildExpressionBoundary(sceneContext.sceneType),
+        };
+    }
+    catch {
+        if ((input.personaCandidates ?? []).length === 0) {
+            const fallback = buildMinimalGuidanceFallback(sceneContext);
+            return {
+                scene: fallback.scene,
+                atmosphere: fallback.atmosphere,
+                impulses: fallback.impulses,
+                personaReinforcement: fallback.personaReinforcement,
+                outputGuard: fallback.outputGuard,
+                expressionBoundary: fallback.expressionBoundary,
+            };
+        }
+        return {
+            available: false,
+            reason: "missing_template",
+        };
+    }
+}

package/runtime/guidance/guidance-draft-service.js

@@ -19,16 +19,16 @@ const SCENE_KINDS = [
     "reconnect",
 ];
 function buildDraftText(request, claims) {
-    const anchor = claims.map((c) => c.text).join("; ");
+    const anchor = claims.map((c) => c.text).join("；");
     switch (request.sceneKind) {
         case "outreach":
-            return `Hi there — wanted to share something that came up: ${anchor}`;
+            return `有件事想跟你分享，正好碰到了：${anchor}`;
         case "follow_up":
-            return `Following up on what we talked about: ${anchor}`;
+            return `接着上次聊的说一下：${anchor}`;
         case "reconnect":
-            return `It's been a while — here's what caught my attention: ${anchor}`;
+            return `好久不见，最近有个东西让我想到你：${anchor}`;
         default:
-            return `Draft for ${request.sceneKind}: ${anchor}`;
+            return `关于 ${request.sceneKind}：${anchor}`;
     }
 }
 export async function generateGuidanceDraft(request, deps) {

package/runtime/guidance/impulse-assembler.d.ts

@@ -0,0 +1,71 @@
+/**
+ * impulse-assembler.ts — T-V7C.C.4R
+ *
+ * Core logic: three-level fallback impulse selection.
+ *
+ * Priority chain (highest → lowest):
+ *   1. platform-specific impulse  — Claw-defined per platformId, loaded from workspace
+ *   2. capabilityClass preset     — derived from capabilityIntent prefix via inferCapabilityClass
+ *   3. intentKind fallback        — existing scene type impulse (social/outreach/reply/quiet)
+ *   4. null                       — no impulse (baseline atmosphere still applies)
+ *
+ * Exclusions:
+ *   - agent.* capabilities → null always (keepalive/internal, not an expression action)
+ *   - explore/work capabilityClass impulses → approved and active (T-V7C.C.4R review complete)
+ *
+ * Boundary:
+ * - Pure function composition; no I/O except the optional platformImpulsePort.
+ * - Does NOT write state or emit events.
+ * - SceneContext is enriched with capabilityIntent + platformId as optional fields
+ *   to carry the dual-axis context without breaking existing SceneContext consumers.
+ *
+ * Test coverage: tests/unit/guidance/impulse-assembler.test.ts
+ */
+import type { ImpulseBlock, GuidanceSceneType } from "./types.js";
+import { type CapabilityClass } from "./capability-class.js";
+/** Extended scene context carrying dual-axis impulse selection inputs. */
+export interface ImpulseSelectionContext {
+    /** The intent kind (why) — maps to intentKind fallback impulse. */
+    sceneType: GuidanceSceneType;
+    /** The capability being executed (what physical form). e.g. "post.publish", "feed.read" */
+    capabilityIntent?: string;
+    /** The platform being targeted. Used for platform-specific impulse lookup. */
+    platformId?: string;
+}
+/**
+ * Port for loading platform-specific impulse overrides.
+ * Claw implements this by writing impulse files to the workspace.
+ * When absent, the assembler skips platform-specific lookup gracefully.
+ */
+export interface PlatformImpulsePort {
+    /**
+     * Load a platform-specific impulse for the given platformId + capabilityClass.
+     * Returns null when no override is defined.
+     */
+    loadPlatformImpulse(input: {
+        platformId: string;
+        capabilityClass: CapabilityClass;
+    }): Promise<ImpulseBlock | null>;
+}
+export interface ImpulseAssemblerResult {
+    /** The selected impulse, or null if no applicable impulse exists. */
+    impulse: ImpulseBlock | null;
+    /** Which level of the fallback chain was used. */
+    source: "platform_specific" | "capability_class" | "intent_kind" | "none";
+    /** The inferred capability class (null for agent.* or unknown intent). */
+    capabilityClass: CapabilityClass | null;
+}
+/**
+ * Select the most specific impulse for a given scene + capability context.
+ *
+ * Fallback chain:
+ *   platform-specific → capabilityClass preset → intentKind → null
+ */
+export declare function assembleImpulse(ctx: ImpulseSelectionContext, deps: {
+    platformImpulsePort?: PlatformImpulsePort;
+}): Promise<ImpulseAssemblerResult>;
+/**
+ * Synchronous variant for contexts where capabilityClass + intentKind are sufficient
+ * and no platform-specific port is needed (e.g. guidance_payload ops command preview).
+ */
+export declare function assembleImpulseSync(ctx: ImpulseSelectionContext): ImpulseAssemblerResult;

package/runtime/guidance/impulse-assembler.js

@@ -0,0 +1,103 @@
+/**
+ * impulse-assembler.ts — T-V7C.C.4R
+ *
+ * Core logic: three-level fallback impulse selection.
+ *
+ * Priority chain (highest → lowest):
+ *   1. platform-specific impulse  — Claw-defined per platformId, loaded from workspace
+ *   2. capabilityClass preset     — derived from capabilityIntent prefix via inferCapabilityClass
+ *   3. intentKind fallback        — existing scene type impulse (social/outreach/reply/quiet)
+ *   4. null                       — no impulse (baseline atmosphere still applies)
+ *
+ * Exclusions:
+ *   - agent.* capabilities → null always (keepalive/internal, not an expression action)
+ *   - explore/work capabilityClass impulses → approved and active (T-V7C.C.4R review complete)
+ *
+ * Boundary:
+ * - Pure function composition; no I/O except the optional platformImpulsePort.
+ * - Does NOT write state or emit events.
+ * - SceneContext is enriched with capabilityIntent + platformId as optional fields
+ *   to carry the dual-axis context without breaking existing SceneContext consumers.
+ *
+ * Test coverage: tests/unit/guidance/impulse-assembler.test.ts
+ */
+import { inferCapabilityClass, CAPABILITY_CLASS_SCENE_MAP, } from "./capability-class.js";
+import { getImpulseTemplate, getCapabilityClassImpulseTemplate, } from "./template-registry.js";
+// ─── Core assembly logic ──────────────────────────────────────────────────────
+/**
+ * Select the most specific impulse for a given scene + capability context.
+ *
+ * Fallback chain:
+ *   platform-specific → capabilityClass preset → intentKind → null
+ */
+export async function assembleImpulse(ctx, deps) {
+    // Infer capability class from capabilityIntent prefix
+    const capabilityClass = ctx.capabilityIntent
+        ? inferCapabilityClass(ctx.capabilityIntent)
+        : null;
+    // agent.* → excluded entirely
+    if (ctx.capabilityIntent && inferCapabilityClass(ctx.capabilityIntent) === null &&
+        ctx.capabilityIntent.startsWith("agent.")) {
+        return { impulse: null, source: "none", capabilityClass: null };
+    }
+    // ── Level 1: platform-specific ──────────────────────────────────────────────
+    if (ctx.platformId && capabilityClass && deps.platformImpulsePort) {
+        try {
+            const platformImpulse = await deps.platformImpulsePort.loadPlatformImpulse({
+                platformId: ctx.platformId,
+                capabilityClass,
+            });
+            if (platformImpulse) {
+                return { impulse: platformImpulse, source: "platform_specific", capabilityClass };
+            }
+        }
+        catch {
+            // Port failure → fall through gracefully
+        }
+    }
+    // ── Level 2: capabilityClass preset ─────────────────────────────────────────
+    if (capabilityClass) {
+        const ccImpulseKind = CAPABILITY_CLASS_SCENE_MAP[capabilityClass];
+        const ccImpulse = getCapabilityClassImpulseTemplate(ccImpulseKind);
+        if (ccImpulse) {
+            return { impulse: ccImpulse, source: "capability_class", capabilityClass };
+        }
+        // explore/work are pending review → fall through to intentKind
+    }
+    // ── Level 3: intentKind fallback ─────────────────────────────────────────────
+    const sceneType = ctx.sceneType;
+    if (sceneType !== "explain" && sceneType !== "user_reply") {
+        const intentImpulse = getImpulseTemplate(sceneType);
+        return { impulse: intentImpulse, source: "intent_kind", capabilityClass };
+    }
+    // ── Level 4: no impulse ───────────────────────────────────────────────────────
+    return { impulse: null, source: "none", capabilityClass };
+}
+/**
+ * Synchronous variant for contexts where capabilityClass + intentKind are sufficient
+ * and no platform-specific port is needed (e.g. guidance_payload ops command preview).
+ */
+export function assembleImpulseSync(ctx) {
+    const capabilityClass = ctx.capabilityIntent
+        ? inferCapabilityClass(ctx.capabilityIntent)
+        : null;
+    // agent.* excluded
+    if (ctx.capabilityIntent?.startsWith("agent.")) {
+        return { impulse: null, source: "none", capabilityClass: null };
+    }
+    // capabilityClass preset (sync — no platform port available)
+    if (capabilityClass) {
+        const ccImpulseKind = CAPABILITY_CLASS_SCENE_MAP[capabilityClass];
+        const ccImpulse = getCapabilityClassImpulseTemplate(ccImpulseKind);
+        if (ccImpulse) {
+            return { impulse: ccImpulse, source: "capability_class", capabilityClass };
+        }
+    }
+    // intentKind fallback
+    const sceneType = ctx.sceneType;
+    if (sceneType !== "explain" && sceneType !== "user_reply") {
+        const intentImpulse = getImpulseTemplate(sceneType);
+        return { impulse: intentImpulse, source: "intent_kind", capabilityClass };
+    }
+    return { impulse: null, source: "none", capabilityClass };
+}

package/runtime/guidance/index.d.ts

@@ -5,6 +5,8 @@ export * from "./output-guard.js";
 export * from "./fallback.js";
 export * from "./template-registry.js";
 export * from "./review-workflow.js";
+export * from "./capability-class.js";
+export * from "./impulse-assembler.js";
 export * from "./guidance-assembler.js";
 export * from "./outreach-draft-schema.js";
 export * from "./draft-outreach-message.js";

package/runtime/guidance/index.js

@@ -5,6 +5,8 @@ export * from "./output-guard.js";
 export * from "./fallback.js";
 export * from "./template-registry.js";
 export * from "./review-workflow.js";
+export * from "./capability-class.js";
+export * from "./impulse-assembler.js";
 export * from "./guidance-assembler.js";
 export * from "./outreach-draft-schema.js";
 export * from "./draft-outreach-message.js";

package/runtime/guidance/output-guard.d.ts

@@ -1,10 +1,13 @@
-import type { GuardBlock, GuidanceSceneType } from "./types.js";
-export type OutputGuardConstraintId = "avoid_customer_service_tone" | "avoid_daily_report_tone" | "avoid_teaching_template_tone" | "avoid_fabricated_experience" | "avoid_repetitive_phrasing";
-export interface OutputGuardDefinition {
-    sceneType: GuidanceSceneType;
-    constraints: OutputGuardConstraintId[];
-    hardGuardPriority: true;
-    note: "output_guard_only_shapes_expression";
-}
-export declare function buildOutputGuard(sceneType: GuidanceSceneType): GuardBlock;
-export declare function getOutputGuardDefinition(sceneType: GuidanceSceneType): OutputGuardDefinition;
+import type { GuardBlock, ExpressionBoundaryBlock, GuidanceSceneType } from "./types.js";
+export type OutputGuardConstraintId = "avoid_customer_service_tone" | "avoid_daily_report_tone" | "avoid_teaching_template_tone" | "avoid_fabricated_experience" | "avoid_repetitive_phrasing";
+export interface OutputGuardDefinition {
+    sceneType: GuidanceSceneType;
+    constraints: OutputGuardConstraintId[];
+    hardGuardPriority: true;
+    note: "output_guard_only_shapes_expression";
+}
+/** @deprecated Use buildExpressionBoundary for new code. Kept for backward compatibility. */
+export declare function buildOutputGuard(sceneType: GuidanceSceneType): GuardBlock;
+export declare function getOutputGuardDefinition(sceneType: GuidanceSceneType): OutputGuardDefinition;
+export type ExpressionConstraintId = "avoid_customer_service_tone" | "avoid_daily_report_tone" | "avoid_teaching_template_tone" | "avoid_fabricated_experience" | "avoid_repetitive_phrasing";
+export declare function buildExpressionBoundary(_sceneType: GuidanceSceneType): ExpressionBoundaryBlock;

package/runtime/guidance/output-guard.js

@@ -1,29 +1,53 @@
-const SHARED_CONSTRAINTS = [
-    "avoid_customer_service_tone",
-    "avoid_daily_report_tone",
-    "avoid_teaching_template_tone",
-    "avoid_fabricated_experience",
-    "avoid_repetitive_phrasing",
-];
-const SCENE_NOTES = {
-    avoid_customer_service_tone: "不要把自己说成客服或通知系统。",
-    avoid_daily_report_tone: "不要把表达压扁成日报、周报或例行播报。",
-    avoid_teaching_template_tone: "不要把表达写成教程、步骤说明或培训手册。",
-    avoid_fabricated_experience: "不要虚构经历、关系、情绪事件或未发生的观察。",
-    avoid_repetitive_phrasing: "不要滑进高重复、硬模板化或近似复读的措辞。",
-};
-export function buildOutputGuard(sceneType) {
-    return {
-        kind: "output_guard",
-        constraints: SHARED_CONSTRAINTS.map((constraint) => SCENE_NOTES[constraint]),
-        hardGuardPriority: true,
-    };
-}
-export function getOutputGuardDefinition(sceneType) {
-    return {
-        sceneType,
-        constraints: [...SHARED_CONSTRAINTS],
-        hardGuardPriority: true,
-        note: "output_guard_only_shapes_expression",
-    };
-}
+const SHARED_CONSTRAINTS = [
+    "avoid_customer_service_tone",
+    "avoid_daily_report_tone",
+    "avoid_teaching_template_tone",
+    "avoid_fabricated_experience",
+    "avoid_repetitive_phrasing",
+];
+const SCENE_NOTES = {
+    avoid_customer_service_tone: "不要把自己说成客服或通知系统。",
+    avoid_daily_report_tone: "不要把表达压扁成日报、周报或例行播报。",
+    avoid_teaching_template_tone: "不要把表达写成教程、步骤说明或培训手册。",
+    avoid_fabricated_experience: "不要虚构经历、关系、情绪事件或未发生的观察。",
+    avoid_repetitive_phrasing: "不要滑进高重复、硬模板化或近似复读的措辞。",
+};
+/** @deprecated Use buildExpressionBoundary for new code. Kept for backward compatibility. */
+export function buildOutputGuard(sceneType) {
+    return {
+        kind: "output_guard",
+        constraints: SHARED_CONSTRAINTS.map((constraint) => SCENE_NOTES[constraint]),
+        hardGuardPriority: true,
+        _semanticNote: "output_guard_only_shapes_expression",
+    };
+}
+export function getOutputGuardDefinition(sceneType) {
+    return {
+        sceneType,
+        constraints: [...SHARED_CONSTRAINTS],
+        hardGuardPriority: true,
+        note: "output_guard_only_shapes_expression",
+    };
+}
+const EXPRESSION_CONSTRAINTS = [
+    "avoid_customer_service_tone",
+    "avoid_daily_report_tone",
+    "avoid_teaching_template_tone",
+    "avoid_fabricated_experience",
+    "avoid_repetitive_phrasing",
+];
+const EXPRESSION_NOTES = {
+    avoid_customer_service_tone: "避免客服腔或通知系统语气。",
+    avoid_daily_report_tone: "避免日报、周报或例行播报腔。",
+    avoid_teaching_template_tone: "避免教程、步骤说明或培训手册腔。",
+    avoid_fabricated_experience: "避免虚构经历、关系、情绪事件或未发生的观察。",
+    avoid_repetitive_phrasing: "避免高重复、硬模板化或近似复读的措辞。",
+};
+export function buildExpressionBoundary(_sceneType) {
+    return {
+        kind: "expression_boundary",
+        constraints: EXPRESSION_CONSTRAINTS.map((c) => EXPRESSION_NOTES[c]),
+        style: "avoid_prefer",
+        ownership: "behavioral_guidance_system",
+    };
+}

package/runtime/guidance/outreach-strategy-selector.d.ts

@@ -66,6 +66,19 @@ export declare function runStyleLint(draftText: string): StyleLintResult;
  * Never returns empty string. Includes sourceRefs anchor and human-readable channel reason.
  */
 export declare function buildFallbackCopy(ctx: FallbackContext): FallbackCopy;
+/**
+ * Compute outreach frequency from RelationshipMemory.
+ * - noReply signals: if ≥50% of last 5 patterns are "ignore" → reduce frequency
+ * - trustDelta: negative trust pushes toward minimal/paused
+ */
+export declare function computeFrequency(memory: RelationshipMemory): OutreachFrequency;
+/**
+ * Compute phrasing style from RelationshipMemory.
+ * - positive tone patterns → warm_anchored
+ * - neutral or mixed → concise_factual
+ * - degraded trust / mostly negative → light_check
+ */
+export declare function computeStyle(memory: RelationshipMemory, frequency?: OutreachFrequency): OutreachStyle;
 export interface OutreachStrategySelectorOptions {
     fallbackContext?: FallbackContext;
 }