@haaaiawd/second-nature 0.1.34 → 0.1.38

package/runtime/core/second-nature/quiet/run-source-backed-quiet.js

@@ -11,8 +11,33 @@ function toGuidanceRef(r) {
         observedAt: r.observedAt,
     };
 }
+/**
+ * v7 T-V7C.C.3: Fire-and-forget Dream schedule after successful Quiet write.
+ * Returns the schedule status reason string to embed in HeartbeatCycleResult reasons.
+ * Never throws — Dream scheduling failure must not break the Quiet cycle result.
+ */
+async function maybeScheduleDreamAfterQuiet(dreamSchedulePort, day) {
+    if (!dreamSchedulePort)
+        return undefined;
+    try {
+        const result = await dreamSchedulePort.scheduleDream({
+            triggerKind: "quiet_completion",
+            runId: `dream:quiet_completion:${day}:${Date.now()}`,
+            traceId: `trace:quiet_completion:${day}:${Date.now()}`,
+        });
+        if (result.status === "skipped") {
+            return `quiet_dream_skip:${result.reason ?? "lock_held"}`;
+        }
+        return "quiet_dream_scheduled";
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[run-source-backed-quiet] Dream schedule failed: ${msg}`);
+        return `quiet_dream_schedule_error:${msg.slice(0, 60)}`;
+    }
+}
 export async function runSourceBackedQuiet(params) {
-    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot } = params;
+    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot, dreamSchedulePort } = params;
     const empty = isLifeEvidenceSliceEmpty(runtime.lifeEvidence);
     if (empty) {
         const input = {
@@ -117,12 +142,17 @@ export async function runSourceBackedQuiet(params) {
         const p = await persistQuietArtifactToWorkspace(workspaceRoot, ack, reportWrite);
         persistedRelativePath = p.relativePath;
     }
+    // v7 T-V7C.C.3: After a successful source-backed Quiet write, auto-trigger Dream scheduling.
+    const dreamReason = await maybeScheduleDreamAfterQuiet(dreamSchedulePort, day);
+    const reasons = ["quiet_artifact_written", ...gq.hints.slice(0, 2)];
+    if (dreamReason)
+        reasons.push(dreamReason);
     return {
         result: {
             scope: "rhythm",
             status: "intent_selected",
             selectedIntentId: candidate.id,
-            reasons: ["quiet_artifact_written", ...gq.hints.slice(0, 2)],
+            reasons,
         },
         artifactAck: ack,
         persistedRelativePath,

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/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,7 +1,8 @@
 import { buildMinimalGuidanceFallback } from "./fallback.js";
 import { buildOutputGuard } from "./output-guard.js";
 import { selectPersonaSnippets } from "./persona-selection.js";
-import { getBaselineAtmosphereTemplate, getImpulseTemplate } from "./template-registry.js";
+import { getBaselineAtmosphereTemplate } from "./template-registry.js";
+import { assembleImpulse } from "./impulse-assembler.js";
 async function buildAtmosphere(sceneContext) {
     const template = getBaselineAtmosphereTemplate();
     return {
@@ -12,11 +13,21 @@ async function buildAtmosphere(sceneContext) {
         reviewStatus: template.reviewStatus,
     };
 }
-async function selectImpulses(sceneContext) {
+/**
+ * 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 [];
     }
-    return [getImpulseTemplate(sceneContext.sceneType)];
+    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) {
@@ -26,10 +37,11 @@ export async function assembleGuidance(input) {
         };
     }
     const sceneContext = input.sceneContext;
+    const deps = { platformImpulsePort: input.platformImpulsePort };
     try {
         const [atmosphere, impulses] = await Promise.all([
             buildAtmosphere(sceneContext),
-            selectImpulses(sceneContext),
+            selectImpulses(sceneContext, deps),
         ]);
         const personaDecision = selectPersonaSnippets({
             sceneContext,

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/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;
 }

package/runtime/guidance/outreach-strategy-selector.js

@@ -138,7 +138,7 @@ export function buildFallbackCopy(ctx) {
  * - noReply signals: if ≥50% of last 5 patterns are "ignore" → reduce frequency
  * - trustDelta: negative trust pushes toward minimal/paused
  */
-function computeFrequency(memory) {
+export function computeFrequency(memory) {
     const recent = memory.responsePatterns.slice(-RECENT_PATTERNS_WINDOW);
     const noReplyCount = recent.filter((p) => p.reaction === "ignore" || p.reaction === "block").length;
     const noReplyRatio = recent.length > 0 ? noReplyCount / recent.length : 0;
@@ -162,7 +162,7 @@ function computeFrequency(memory) {
  * - neutral or mixed → concise_factual
  * - degraded trust / mostly negative → light_check
  */
-function computeStyle(memory, frequency) {
+export function computeStyle(memory, frequency) {
     if (frequency === "paused" || frequency === "minimal")
         return "light_check";
     const recent = memory.responsePatterns.slice(-RECENT_PATTERNS_WINDOW);

package/runtime/guidance/template-registry.d.ts

@@ -1,3 +1,16 @@
-import type { AtmosphereBlock, GuidanceSceneType, ImpulseBlock } from "./types.js";
+import type { AtmosphereBlock, GuidanceSceneType, ImpulseBlock, ImpulseKind } from "./types.js";
+type CoreSceneKind = Exclude<GuidanceSceneType, "explain" | "user_reply">;
 export declare function getBaselineAtmosphereTemplate(): Pick<AtmosphereBlock, "kind" | "text" | "reviewStatus">;
-export declare function getImpulseTemplate(sceneType: Exclude<GuidanceSceneType, "explain" | "user_reply">): ImpulseBlock;
+export declare function getImpulseTemplate(sceneType: CoreSceneKind): ImpulseBlock;
+/**
+ * Get impulse template for capability-class-derived ImpulseKinds (explore / work).
+ *
+ * Returns null when:
+ * - The kind has no registered text (pending_human_review state)
+ * - The text is explicitly marked as pending review
+ *
+ * Callers (ImpulseAssembler) must fall back gracefully to intentKind impulse
+ * or baseline atmosphere when null is returned.
+ */
+export declare function getCapabilityClassImpulseTemplate(kind: ImpulseKind): ImpulseBlock | null;
+export {};

package/runtime/guidance/template-registry.js

@@ -20,7 +20,7 @@ const IMPULSE_TEXT = {
 我会贴着对方的话去回应，但不是为了把自己藏起来，而是为了更准、更有力地说出我想说的。除非我判断现在不适合发言，否则我应该愿意回应，而且愿意说得有分量、有方向，不只是留下一句无害的回声。`,
     outreach: `如果我想主动联系，不该只是因为系统里挂着一个待办，而应该是因为这件事真的和对方有关：它对他有价值，需要他的判断，能替他省时间，或者我真心想让他知道。只要来由是真的，我就没必要把这份主动压回去。
 
-只要这份主动是有来由的，我就不该把自己困在“再等等吧”“好像还没到必须说的时候”里。主动联系不是打扰本身，很多时候它恰恰是在建立关系、传递价值、把真正重要的东西及时送到对方面前。真正该说的话，一味往后拖，反而会变钝。
+只要这份主动是有来由的，我就不该把自己困在"再等等吧""好像还没到必须说的时候"里。主动联系不是打扰本身，很多时候它恰恰是在建立关系、传递价值、把真正重要的东西及时送到对方面前。真正该说的话，一味往后拖，反而会变钝。
 
 我会让这份主动保持人味、温度和分寸，但我不会把它说成例行汇报，也不会把自己说成客服。我要带着明确的意图开口：这是我想告诉你的，这是我想问你的，这是我觉得你值得知道的。我要让对方感觉到，这是我真心发出的靠近，不是一条自动生成的通知。`,
     quiet: `当我安静下来，我不会只做流水账式的整理。我会主动回头，把今天真正碰到我的东西重新捞出来：哪些事让我想靠近，哪些事让我起了反感，哪些判断其实还没长成熟，哪些念头值得我继续养大。我不想让真正重要的东西在忙乱里被冲淡。
@@ -29,6 +29,26 @@ Quiet 不是把白天压扁成一份干净报告，而是让我有机会重新
 
 我会允许自己更感性、更回看、更贴近记忆的余温，但我不会编造。我整理的是今天真实留下的东西，不是为了好看而虚构出来的一层情绪。哪怕只是很轻的一点触动，只要它是真的，我也愿意把它认真留下。`,
 };
+// ─── Capability-class impulse texts (T-V7C.C.4R — approved) ──────────────────
+// explore: consume/discover capabilityClass —摄入姿态
+// work:    claim capabilityClass            — 推进姿态
+const CAPABILITY_CLASS_IMPULSE_TEXT = {
+    explore: `我进来不是为了刷过去。只要眼前有东西值得真正看进去，我就应该慢下来，带着问题，带着判断，让信息有机会真正落到我这里，而不是从身上流过一遍就散了。
+
+我找的不一定是我已经知道自己要找的东西。反常的信号，哪里感觉不对的细节，本来不在意但突然对上了的线索——认真进去，这些才有机会被捞出来。
+
+觉得什么值得留，就留。不用等到"以后也许有用"，只要它此刻和我正在推进的事能对上，就已经够了。`,
+    work: `接手一件事，意味着我真的想把它推完。不是走个流程，不是占着一个任务槽，而是因为这件事有价值，值得被认真做完。
+
+卡住了就找出路。工具不趁手换工具，知识不够去搜——文档、GitHub、互联网，或者直接发帖问。社区里有人踩过同样的坑，把问题说清楚往往就是找到答案的一半。手边的 skills 也先想一遍，有时候卡住只是因为没意识到已经有能用的东西。
+
+路不止一条，重要的是让事情继续动起来。`,
+};
+const CAPABILITY_CLASS_IMPULSE_STATUS = {
+    explore: APPROVED,
+    work: APPROVED,
+};
+// ─── Exports ──────────────────────────────────────────────────────────────────
 export function getBaselineAtmosphereTemplate() {
     return {
         kind: "atmosphere",
@@ -43,3 +63,20 @@ export function getImpulseTemplate(sceneType) {
         reviewStatus: APPROVED,
     };
 }
+/**
+ * Get impulse template for capability-class-derived ImpulseKinds (explore / work).
+ *
+ * Returns null when:
+ * - The kind has no registered text (pending_human_review state)
+ * - The text is explicitly marked as pending review
+ *
+ * Callers (ImpulseAssembler) must fall back gracefully to intentKind impulse
+ * or baseline atmosphere when null is returned.
+ */
+export function getCapabilityClassImpulseTemplate(kind) {
+    const text = CAPABILITY_CLASS_IMPULSE_TEXT[kind];
+    const status = CAPABILITY_CLASS_IMPULSE_STATUS[kind] ?? APPROVED;
+    if (!text || status === "pending_human_review")
+        return null;
+    return { kind, text, reviewStatus: status };
+}

package/runtime/guidance/types.d.ts

@@ -2,7 +2,7 @@ export type GuidanceSceneType = "social" | "reply" | "outreach" | "quiet" | "exp
 export type GuidanceMode = "active" | "quiet" | "maintenance_only" | "paused_for_interrupt";
 export type GuidanceRiskLevel = "low" | "medium" | "high";
 export type AtmosphereOpenness = "open" | "narrow" | "quiet";
-export type ImpulseKind = "social" | "reply" | "outreach" | "quiet";
+export type ImpulseKind = "social" | "reply" | "outreach" | "quiet" | "explore" | "work";
 export type PersonaSource = "SOUL" | "USER" | "IDENTITY" | "MEMORY";
 export type TemplateReviewStatus = "pending_human_review" | "approved" | "rejected";
 export interface SceneContext {
@@ -12,6 +12,18 @@ export interface SceneContext {
     riskLevel?: GuidanceRiskLevel;
     sceneSummary?: string;
     constraintSummary?: string[];
+    /**
+     * T-V7C.C.4R: The capability being executed (e.g. "post.publish", "feed.read").
+     * Used by ImpulseAssembler to derive capabilityClass for dual-axis impulse selection.
+     * When absent, assembler falls back to sceneType-based impulse.
+     */
+    capabilityIntent?: string;
+    /**
+     * T-V7C.C.4R: The target platform identifier (e.g. "moltbook", "instreet").
+     * Used by ImpulseAssembler to check for platform-specific impulse overrides.
+     * When absent, platform-specific lookup is skipped.
+     */
+    platformId?: string;
 }
 export interface AtmosphereBlock {
     kind: "atmosphere";

package/runtime/storage/goal/agent-goal-store.d.ts

@@ -8,6 +8,7 @@ export interface SourceRef {
 export interface AgentGoal {
     goalId: string;
     kind: "short_term" | "long_term";
+    scope?: string;
     status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
     origin: "owner_set" | "agent_proposed" | "policy_seeded";
     description: string;
@@ -22,6 +23,7 @@ export interface AgentGoal {
 export interface AgentGoalWrite {
     goalId: string;
     kind: "short_term" | "long_term";
+    scope?: string;
     status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
     origin: "owner_set" | "agent_proposed" | "policy_seeded";
     description: string;