@haaaiawd/second-nature 0.1.33 → 0.1.38

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;

package/runtime/storage/goal/agent-goal-store.js

@@ -12,6 +12,7 @@ function rowToGoal(row) {
     return {
         goalId: row.goalId,
         kind: row.kind,
+        scope: row.scope ?? undefined,
         status: row.status,
         origin: row.origin,
         description: row.description,
@@ -28,6 +29,21 @@ export function createAgentGoalStore(database) {
     const db = database.db;
     return {
         async upsertAgentGoal(goal) {
+            // T-V7C.C.4: dedupe — same kind+scope accepted goals → mark old as replaced
+            if (goal.status === "accepted") {
+                const oldGoals = await db
+                    .select()
+                    .from(agentGoal)
+                    .where(and(eq(agentGoal.kind, goal.kind), eq(agentGoal.scope, goal.scope ?? "global"), eq(agentGoal.status, "accepted")));
+                for (const old of oldGoals) {
+                    if (old.goalId !== goal.goalId) {
+                        await db
+                            .update(agentGoal)
+                            .set({ status: "replaced", updatedAt: goal.updatedAt })
+                            .where(eq(agentGoal.goalId, old.goalId));
+                    }
+                }
+            }
             const existing = await db
                 .select()
                 .from(agentGoal)
@@ -38,6 +54,7 @@ export function createAgentGoalStore(database) {
                     .update(agentGoal)
                     .set({
                     kind: goal.kind,
+                    scope: goal.scope ?? "global",
                     status: goal.status,
                     origin: goal.origin,
                     description: goal.description,
@@ -54,6 +71,7 @@ export function createAgentGoalStore(database) {
                 await db.insert(agentGoal).values({
                     goalId: goal.goalId,
                     kind: goal.kind,
+                    scope: goal.scope ?? "global",
                     status: goal.status,
                     origin: goal.origin,
                     description: goal.description,
@@ -82,7 +100,16 @@ export function createAgentGoalStore(database) {
                 .where(conditions.length > 0 ? and(...conditions) : undefined)
                 .orderBy(desc(agentGoal.updatedAt))
                 .limit(query.limit ?? 100);
-            return rows.map(rowToGoal);
+            // T-V7C.C.4: dedupe by kind+scope — keep newest (rows already sorted by updatedAt desc)
+            const seen = new Map();
+            for (const row of rows) {
+                const goal = rowToGoal(row);
+                const key = `${goal.kind}:${goal.scope ?? "global"}`;
+                if (!seen.has(key)) {
+                    seen.set(key, goal);
+                }
+            }
+            return Array.from(seen.values());
         },
         async transitionGoalStatus(input) {
             await db

package/runtime/storage/services/tool-experience-store.js

@@ -81,7 +81,15 @@ export function createCapabilityProbeResultStore(database) {
             sqlite.run(`INSERT INTO capability_probe_result
          (probe_result_id, capability_id, connector_id, actual_status,
           http_status, sample_response_ref, probe_config_ref, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(probe_result_id) DO UPDATE SET
+           capability_id = excluded.capability_id,
+           connector_id = excluded.connector_id,
+           actual_status = excluded.actual_status,
+           http_status = excluded.http_status,
+           sample_response_ref = excluded.sample_response_ref,
+           probe_config_ref = excluded.probe_config_ref,
+           created_at = excluded.created_at`, [
                 result.probeResultId,
                 result.capabilityId,
                 result.connectorId,