@haaaiawd/second-nature 0.1.25 → 0.1.26

package/index.js

@@ -7,6 +7,7 @@
  *   runtime graph currently contains async sql.js bootstrap that breaks vm sandbox loading
  * - expose a minimal in-memory activation spine so status/lifecycle stay truthful even when
  *   the full workspace runtime is not loaded inside the host
+ * - T4.2.1: owner reply ingestion → RelationshipMemory feedback (full runtime only)
  *
  * Dependencies:
  * - only imports runtime lifecycle/service modules that are synchronous at load time

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "description": "OpenClaw native plugin with synchronous surface registration and bundled runtime spine. Set SECOND_NATURE_WORKSPACE_ROOT or tool workspaceRoot to the same path as the agent workspace (see README / T1.1.4 ops norm).",
   "activation": {
     "onStartup": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",

package/runtime/cli/commands/goal.d.ts

@@ -4,6 +4,8 @@ export interface GoalCommandInput {
     goalId?: string;
     description?: string;
     completionCriteria?: string;
+    /** T1.4.2 — alias for `completionCriteria`. */
+    criteria?: string;
     risk?: "low" | "medium" | "high";
     kind?: "short_term" | "long_term";
     statusFilter?: string;

package/runtime/cli/commands/goal.js

@@ -43,13 +43,17 @@ export async function goalCommand(stateDb, input) {
             }
             const goalId = input.goalId?.trim() || randomUUID();
             const now = new Date().toISOString();
+            // T1.4.2: `criteria` is an alias for `completionCriteria`.
+            const completionCriteria = input.completionCriteria?.trim() ||
+                input.criteria?.trim() ||
+                "";
             await store.upsertAgentGoal({
                 goalId,
                 kind: input.kind ?? "short_term",
                 status: "accepted",
                 origin: "owner_set",
                 description,
-                completionCriteria: input.completionCriteria?.trim() || "",
+                completionCriteria,
                 risk: input.risk ?? "low",
                 priorityHint: 0,
                 sourceRefs: [],

package/runtime/cli/commands/index.js

@@ -136,7 +136,7 @@ export function createCliCommands(deps) {
                         return explainSubjectError("EXPLAIN_SUBJECT_REQUIRES_ID", "subject must include identifier");
                     }
                     if (code === "explain_subject_unsupported") {
-                        return explainSubjectError("EXPLAIN_SUBJECT_UNSUPPORTED", "supported subjects include decision:, platform:, outreach:, soul:, fallback:, delivery:, probe:, report:, source:");
+                        return explainSubjectError("EXPLAIN_SUBJECT_UNSUPPORTED", "supported subjects include decision:, platform:, outreach:, soul:, fallback:, delivery:, probe:, report:, source:, relationship:");
                     }
                     return explainSubjectError("EXPLAIN_SUBJECT_INVALID", "invalid explain subject");
                 }

package/runtime/cli/explain/resolve-subject.js

@@ -37,5 +37,8 @@ export function resolveExplainSubject(raw) {
     if (prefix === "source" || prefix === "source_ref") {
         return { kind: "source_ref", id };
     }
+    if (prefix === "relationship") {
+        return { kind: "relationship", id };
+    }
     throw new Error("explain_subject_unsupported");
 }

package/runtime/cli/ops/ops-router.js

@@ -219,13 +219,21 @@ export function createOpsRouter(deps) {
                 const action = ["set", "list", "accept", "reject"].includes(rawAction)
                     ? rawAction
                     : "list";
+                const sanitizeText = (v, maxLen = 1000) => {
+                    if (typeof v !== "string")
+                        return undefined;
+                    const trimmed = v.trim();
+                    if (trimmed.length === 0)
+                        return undefined;
+                    return trimmed.slice(0, maxLen);
+                };
                 return goalCommand(deps.state, {
                     action,
-                    goalId: typeof input?.goalId === "string" ? input.goalId : undefined,
-                    description: typeof input?.description === "string" ? input.description : undefined,
-                    completionCriteria: typeof input?.completionCriteria === "string"
-                        ? input.completionCriteria
-                        : undefined,
+                    goalId: typeof input?.goalId === "string" ? input.goalId.trim().slice(0, 128) : undefined,
+                    description: sanitizeText(input?.description),
+                    completionCriteria: sanitizeText(input?.completionCriteria),
+                    // T1.4.2: criteria alias for completionCriteria
+                    criteria: sanitizeText(input?.criteria),
                     risk: typeof input?.risk === "string"
                         ? input.risk
                         : undefined,

package/runtime/cli/ops/workspace-heartbeat-runner.d.ts

@@ -18,6 +18,7 @@ import type { CliReadModels } from "../read-models/index.js";
 import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
 import type { StateDatabase } from "../../storage/db/index.js";
 import type { ConnectorExecutor } from "../../core/second-nature/orchestrator/effect-dispatcher.js";
+import type { CapabilityContractRegistry } from "../../connectors/base/manifest.js";
 export interface WorkspaceHeartbeatRunnerOptions {
     /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
     runtimeRecorder?: RuntimeDecisionRecorder;
@@ -38,6 +39,11 @@ export interface WorkspaceHeartbeatRunnerOptions {
      * connector-system instead of returning connector_dispatch_unwired.
      */
     connectorExecutor?: ConnectorExecutor;
+    /**
+     * T2.4.1: when present, planner resolves platform-specific intents from accepted goals
+     * and connector evidence.
+     */
+    connectorRegistry?: CapabilityContractRegistry;
 }
 export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels, options?: {
     state?: StateDatabase;

package/runtime/cli/ops/workspace-heartbeat-runner.js

@@ -2,6 +2,7 @@ import { runHeartbeatCycle } from "../../core/second-nature/heartbeat/run-heartb
 import { loadLifeEvidenceSnapshot } from "../../storage/snapshots/life-evidence-snapshot.js";
 import { createAgentGoalStore } from "../../storage/goal/agent-goal-store.js";
 import { createNarrativeStateStore } from "../../storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../storage/relationship/relationship-memory-store.js";
 export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, options = {}) {
     const status = await readModels.loadStatus();
     const mode = status.rhythm.mode === "unknown" ? "active" : status.rhythm.mode;
@@ -30,6 +31,8 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
             platformEventCount = snapshot.platformEvents.length;
             workEventCount = snapshot.workEvents.length;
             if (snapshot.empty) {
+                // L-01: Currently snapshot only exposes `empty` boolean.
+                // Future: if snapshot adds `emptyReason` (e.g. "redacted_only"), map it here.
                 lifeEvidenceEmptyReason = "no_sources";
             }
         }
@@ -46,7 +49,9 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
         lifeEvidenceEmptyReason = "state_unavailable";
     }
     // T2.1.4: Load accepted goals from state DB when available.
+    // M-03: typed as GoalContext to avoid coupling to the full AgentGoal schema.
     let acceptedGoals;
+    let acceptedGoalsLoadError;
     if (options.state) {
         try {
             const goalStore = createAgentGoalStore(options.state);
@@ -55,8 +60,29 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
                 limit: 20,
             });
         }
+        catch (err) {
+            acceptedGoals = [];
+            acceptedGoalsLoadError = err instanceof Error ? err.message : String(err);
+            // H-05: Distinguish "load failed" from "no goals" for observability.
+        }
+    }
+    // CR-02: Load narrative state and relationship memory when state is available.
+    let narrativeState;
+    let relationshipMemory;
+    if (options.state) {
+        try {
+            const narrativeStore = createNarrativeStateStore(options.state);
+            narrativeState = (await narrativeStore.loadNarrativeState()) ?? undefined;
+        }
+        catch {
+            // Narrative state is optional; failure should not block the cycle.
+        }
+        try {
+            const relationshipStore = createRelationshipMemoryStore(options.state);
+            relationshipMemory = (await relationshipStore.loadRelationshipMemory()) ?? undefined;
+        }
         catch {
-            acceptedGoals = undefined;
+            // Relationship memory is optional; failure should not block the cycle.
         }
     }
     return {
@@ -74,6 +100,9 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
         workEventCount,
         lifeEvidenceEmptyReason,
         acceptedGoals,
+        acceptedGoalsLoadError,
+        narrativeState,
+        relationshipMemory,
     };
 }
 export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
@@ -99,6 +128,11 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                     : undefined,
                 connectorExecutor: options.connectorExecutor,
                 narrativeStateStore,
+                // T3.3.1: pass state + workspaceRoot so connector effects can write life evidence.
+                state: options.state,
+                workspaceRoot: options.workspaceRoot,
+                // T2.4.1: pass registry so planner resolves platform-specific intents.
+                connectorRegistry: options.connectorRegistry,
             },
         });
         if (options.runtimeRecorder) {

package/runtime/cli/read-models/index.js

@@ -12,6 +12,8 @@ import { mapOperatorExplainToReadModel } from "./operator-explain-map.js";
 import { loadOperatorFallbackRow, toOperatorFallbackView, } from "../../storage/fallback/load-operator-fallback.js";
 import { loadRhythmPolicySnapshot, } from "../../storage/rhythm/rhythm-policy-snapshot.js";
 import { createNarrativeStateStore } from "../../storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../storage/relationship/relationship-memory-store.js";
+import { probeCredentialHealth } from "../../storage/services/credential-vault.js";
 const INTERNAL_RUNTIME_PLATFORM_ID = "second-nature-runtime";
 const INTERNAL_RUNTIME_TRACE_PREFIX = "sn-runtime-";
 function toExplainQuery(subject) {
@@ -31,6 +33,8 @@ function toExplainQuery(subject) {
             return { kind: "delivery", auditId: subject.id };
         case "source_ref":
             return { kind: "source_ref", sourceRefId: subject.id };
+        case "relationship":
+            return { kind: "relationship", relationshipId: subject.id };
         default:
             return undefined;
     }
@@ -47,6 +51,8 @@ function buildCredentialNextStep(status) {
         return "submit_verification_answer";
     if (status === "expired" || status === "revoked" || status === "failed")
         return "refresh_credential_context";
+    if (status === "decrypt_failed")
+        return "verify_or_re_create_credential_then_re_import";
     return undefined;
 }
 /**
@@ -207,12 +213,28 @@ async function buildBaseStatus(deps) {
                 : undefined,
         },
         connectors: connectorSummary,
-        credentials: credentials.map((item) => ({
-            platformId: item.platformId ??
-                item.platform_id,
-            status: item.status,
-            nextStep: buildCredentialNextStep(item.status),
-        })),
+        credentials: credentials.map((item) => {
+            const platformId = item.platformId ??
+                item.platform_id;
+            const encryptedValue = item.encryptedValue ??
+                item.encrypted_value;
+            const baseUrl = item.baseUrl ??
+                item.base_url;
+            const health = probeCredentialHealth(platformId, encryptedValue, baseUrl);
+            const effectiveStatus = health.state === "decrypt_failed"
+                ? "decrypt_failed"
+                : item.status;
+            return {
+                platformId,
+                status: effectiveStatus,
+                nextStep: health.diagnosticCode === "missing_runtime_secret"
+                    ? "set_SECOND_NATURE_ENCRYPTION_KEY_then_re_probe"
+                    : health.diagnosticCode === "credential_recovery_required"
+                        ? "verify_or_re_create_credential_then_re_import"
+                        : buildCredentialNextStep(effectiveStatus),
+                keyHealth: health.keyHealth,
+            };
+        }),
         risk: {
             level: riskFlags.length > 0 ? "medium" : "low",
             flags: riskFlags,
@@ -325,19 +347,40 @@ export function createCliReadModels(deps) {
                 record = undefined;
             }
             if (!record) {
+                // T1.4.1: even when no row exists, probe key health so status can surface
+                // missing_runtime_secret rather than a generic "missing".
+                const health = probeCredentialHealth(platformId, null, null);
                 return {
                     platformId,
-                    status: "missing",
-                    nextStep: "provide_credential_context",
+                    status: health.state,
+                    nextStep: health.diagnosticCode === "missing_runtime_secret"
+                        ? "set_SECOND_NATURE_ENCRYPTION_KEY_then_re_probe"
+                        : "provide_credential_context",
+                    keyHealth: health.keyHealth,
                 };
             }
+            // T1.4.1: attempt decryption to detect decrypt_failed / wrong_key.
+            const encryptedValue = record.encryptedValue ??
+                record.encrypted_value;
+            const baseUrl = record.baseUrl ??
+                record.base_url;
+            const health = probeCredentialHealth(platformId, encryptedValue, baseUrl);
+            // If decryption failed, surface the honest diagnostic; otherwise surface DB status.
+            const effectiveStatus = health.state === "decrypt_failed"
+                ? "decrypt_failed"
+                : record.status;
             return {
                 platformId: record.platformId ??
                     record.platform_id,
-                status: record.status,
+                status: effectiveStatus,
                 verificationDeadline: record.expiresAt ?? undefined,
                 attemptsRemaining: record.attemptsRemaining ?? undefined,
-                nextStep: buildCredentialNextStep(record.status),
+                nextStep: health.diagnosticCode === "missing_runtime_secret"
+                    ? "set_SECOND_NATURE_ENCRYPTION_KEY_then_re_probe"
+                    : health.diagnosticCode === "credential_recovery_required"
+                        ? "verify_or_re_create_credential_then_re_import"
+                        : buildCredentialNextStep(effectiveStatus),
+                keyHealth: health.keyHealth,
             };
         },
         async loadFallbackView(ref) {
@@ -390,6 +433,34 @@ export function createCliReadModels(deps) {
                     evidenceRefs: [],
                 };
             }
+            // T1.4.2: relationship explain reads RelationshipMemory store directly.
+            if (subject.kind === "relationship") {
+                const relationshipStore = createRelationshipMemoryStore(deps.stateDb);
+                const memory = await relationshipStore.loadRelationshipMemory(subject.id);
+                if (!memory) {
+                    return {
+                        subjectType: "relationship",
+                        conclusion: "nothing_yet",
+                        keyFactors: ["no_relationship_memory_recorded"],
+                        evidenceRefs: [],
+                        nextStep: "interact_with_agent_then_re_check",
+                    };
+                }
+                return {
+                    subjectType: "relationship",
+                    conclusion: `tone:${memory.tonePreference} replies:${memory.noReplyCount === 0 ? "responsive" : "cooldown"}`,
+                    keyFactors: [
+                        `tone_preference:${memory.tonePreference}`,
+                        ...(memory.averageReplyDelayMinutes
+                            ? [`avg_reply_delay_minutes:${memory.averageReplyDelayMinutes}`]
+                            : []),
+                        ...(memory.topicAffinities.length > 0
+                            ? [`topics:${memory.topicAffinities.map((t) => t.topic).join(",")}`]
+                            : ["insufficient_history"]),
+                    ],
+                    evidenceRefs: memory.sourceRefs.map((s) => s.sourceId),
+                };
+            }
             const query = subject.kind === "decision" ||
                 subject.kind === "platform-selection" ||
                 subject.kind === "outreach"

package/runtime/cli/read-models/types.d.ts

@@ -25,8 +25,10 @@ export interface ConnectorSummary {
 }
 export interface CredentialSummary {
     platformId: string;
-    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed";
+    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed" | "decrypt_failed";
     nextStep?: string;
+    /** T1.4.1 — diagnostic key health without leaking raw secret. */
+    keyHealth?: "missing_key" | "wrong_key" | "ok";
 }
 export interface RiskSummary {
     level: "low" | "medium" | "high";
@@ -129,12 +131,17 @@ export interface SessionDetailReadModel {
 }
 export interface CredentialReadModel {
     platformId: string;
-    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed";
+    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed" | "decrypt_failed";
     verificationDeadline?: string;
     attemptsRemaining?: number;
     nextStep?: string;
+    /**
+     * T1.4.1 — redacted diagnostic: when true, the raw encrypted value could not be
+     * decrypted because SECOND_NATURE_ENCRYPTION_KEY is missing or wrong.
+     */
+    keyHealth?: "missing_key" | "wrong_key" | "ok";
 }
-export type ExplainSubjectKind = "decision" | "platform-selection" | "outreach" | "soul-change" | "fallback" | "probe" | "delivery" | "report" | "source_ref";
+export type ExplainSubjectKind = "decision" | "platform-selection" | "outreach" | "soul-change" | "fallback" | "probe" | "delivery" | "report" | "source_ref" | "relationship";
 export interface ExplainReadModel {
     subjectType: ExplainSubjectKind;
     conclusion: string;

package/runtime/core/second-nature/feedback/owner-reply-feedback.d.ts

@@ -0,0 +1,46 @@
+/**
+ * T4.2.1 — Owner reply ingestion and RelationshipMemory feedback loop.
+ *
+ * When an owner replies to an outreach, this function:
+ * 1. Appends a `SessionChronicle` entry with the reply context.
+ * 2. Loads the current `RelationshipMemory`.
+ * 3. Infers tone/timing/topic from the reply text and updates the memory.
+ * 4. Persists the updated `RelationshipMemory` with source refs pointing to the chronicle entry.
+ *
+ * Boundaries:
+ * - Does NOT generate outreach drafts; that is the guidance layer's job.
+ * - Does NOT execute connectors; this is a pure state update path.
+ * - Errors in relationship update must not break chronicle write (chronicle is source of truth).
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import { type OwnerReplySignal } from "../../../storage/chronicle/session-chronicle-store.js";
+import { type RelationshipMemory, type TopicAffinity } from "../../../storage/relationship/relationship-memory-store.js";
+export interface ReplyInferenceConfig {
+    positiveKeywords?: string[];
+    negativeKeywords?: string[];
+    busyKeywords?: string[];
+    topicPatterns?: Record<string, string[]>;
+}
+export declare function inferTone(text: string, config?: ReplyInferenceConfig): "casual" | "direct" | "quiet" | "unknown";
+export declare function inferTiming(text: string, config?: ReplyInferenceConfig): "responsive" | "busy" | undefined;
+export declare function inferTopics(text: string, config?: ReplyInferenceConfig): string[];
+export declare function mergeTopicAffinities(existing: TopicAffinity[], newTopics: string[]): TopicAffinity[];
+export interface ProcessOwnerReplyInput {
+    /** The raw reply text from the owner. */
+    replyText: string;
+    /** The decisionId of the outreach this reply is responding to. */
+    relatedDecisionId: string;
+    /** Optional explicit owner signal (parsed by host or explicit UI). */
+    explicitSignal?: OwnerReplySignal;
+}
+export interface ProcessOwnerReplyResult {
+    chronicleEntryId: string;
+    relationshipUpdated: boolean;
+    priorMemory?: RelationshipMemory;
+    updatedMemory?: RelationshipMemory;
+    relationshipUpdateError?: string;
+}
+/**
+ * Process an owner reply: write chronicle, update RelationshipMemory.
+ */
+export declare function processOwnerReply(input: ProcessOwnerReplyInput, state: StateDatabase): Promise<ProcessOwnerReplyResult>;

package/runtime/core/second-nature/feedback/owner-reply-feedback.js

@@ -0,0 +1,159 @@
+import { createSessionChronicleStore, } from "../../../storage/chronicle/session-chronicle-store.js";
+import { createRelationshipMemoryStore, } from "../../../storage/relationship/relationship-memory-store.js";
+const DEFAULT_POSITIVE_KEYWORDS = [
+    "agree", "thanks", "appreciate", "helpful", "good", "great", "love", "like", "enjoy",
+    "excited", "happy", "nice", "wonderful", "awesome", "perfect", "cool", "ok", "yes",
+];
+const DEFAULT_NEGATIVE_KEYWORDS = [
+    "disagree", "frustrated", "annoying", "bad", "hate", "dislike", "angry", "upset",
+    "disappointed", "concerned", "no", "not", "never", "wrong", "terrible", "awful",
+    "useless", "stop", "don't",
+];
+const DEFAULT_BUSY_KEYWORDS = [
+    "busy", "swamped", "occupied", "tight schedule", "no time", "later",
+    "overloaded", "overwhelmed", "backlog", "not now", "another time", "schedule tight",
+];
+const DEFAULT_TOPIC_PATTERNS = {
+    work: ["work", "project", "task", "job", "delivery", "deadline"],
+    personal: ["family", "life", "health", "weekend", "trip"],
+    tech: ["code", "system", "bug", "feature", "architecture", "design"],
+    social: ["friend", "community", "meetup", "event", "collaboration"],
+};
+export function inferTone(text, config) {
+    const lower = text.toLowerCase();
+    const positiveKeywords = config?.positiveKeywords ?? DEFAULT_POSITIVE_KEYWORDS;
+    const negativeKeywords = config?.negativeKeywords ?? DEFAULT_NEGATIVE_KEYWORDS;
+    const pos = positiveKeywords.filter((w) => lower.includes(w)).length;
+    const neg = negativeKeywords.filter((w) => lower.includes(w)).length;
+    if (neg >= pos && neg > 0)
+        return "quiet"; // owner is negative → agent should be more reserved
+    if (pos > 0)
+        return "casual"; // positive → casual is fine
+    return "unknown";
+}
+export function inferTiming(text, config) {
+    const lower = text.toLowerCase();
+    const busyKeywords = config?.busyKeywords ?? DEFAULT_BUSY_KEYWORDS;
+    if (busyKeywords.some((w) => lower.includes(w)))
+        return "busy";
+    if (lower.includes("quick") || lower.includes("prompt"))
+        return "responsive";
+    return undefined;
+}
+export function inferTopics(text, config) {
+    const lower = text.toLowerCase();
+    const topicPatterns = config?.topicPatterns ?? DEFAULT_TOPIC_PATTERNS;
+    const topics = [];
+    for (const [topic, patterns] of Object.entries(topicPatterns)) {
+        if (patterns.some((p) => lower.includes(p))) {
+            topics.push(topic);
+        }
+    }
+    return topics;
+}
+export function mergeTopicAffinities(existing, newTopics) {
+    const map = new Map(existing.map((t) => [t.topic, t.affinity]));
+    for (const topic of newTopics) {
+        map.set(topic, Math.min(1, (map.get(topic) ?? 0) + 0.1));
+    }
+    return Array.from(map.entries())
+        .map(([topic, affinity]) => ({ topic, affinity }))
+        .sort((a, b) => b.affinity - a.affinity);
+}
+function redactSensitive(text) {
+    return text
+        .replace(/\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g, "[REDACTED_CARD]")
+        .replace(/password[:\s=]+\S+/gi, "[REDACTED_PASSWORD]")
+        .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, "[REDACTED_EMAIL]")
+        .replace(/\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b/g, "[REDACTED_PHONE]")
+        .replace(/\b\d{3}-\d{2}-\d{4}\b/g, "[REDACTED_SSN]")
+        .replace(/\b(?:sk-|pk-|Bearer\s+|api[_-]?key[:\s=]+)[A-Za-z0-9_\-\/+=]{20,}\b/gi, "[REDACTED_TOKEN]");
+}
+/**
+ * Process an owner reply: write chronicle, update RelationshipMemory.
+ */
+export async function processOwnerReply(input, state) {
+    const chronicleStore = createSessionChronicleStore(state);
+    const relStore = createRelationshipMemoryStore(state);
+    const now = new Date().toISOString();
+    // 1. Write chronicle entry (source of truth)
+    const entryId = `owner_reply:${input.relatedDecisionId}:${Date.now()}`;
+    const replyText = input.replyText?.trim() ?? "";
+    const isEmpty = replyText.length === 0;
+    const tone = isEmpty ? "unknown" : inferTone(replyText);
+    const timing = isEmpty ? undefined : inferTiming(replyText);
+    const topics = isEmpty ? [] : inferTopics(replyText);
+    const chronicleEntry = {
+        entryId,
+        eventKind: "owner_reply",
+        actor: "owner",
+        occurredAt: now,
+        summary: redactSensitive(isEmpty ? "(empty reply)" : replyText.slice(0, 500)),
+        result: "succeeded",
+        sourceRefs: [{ sourceId: entryId, kind: "owner_reply", url: `chronicle://${entryId}` }],
+        relatedDecisionId: input.relatedDecisionId,
+        ownerReply: {
+            tone,
+            delayMinutes: input.explicitSignal?.delayMinutes,
+            topics: topics.length > 0 ? topics : input.explicitSignal?.topics,
+            explicitPreference: input.explicitSignal?.explicitPreference,
+        },
+    };
+    await chronicleStore.appendSessionChronicle(chronicleEntry);
+    // 2. Load and update RelationshipMemory (best-effort)
+    let relationshipUpdated = false;
+    let priorMemory;
+    let updatedMemory;
+    try {
+        priorMemory = (await relStore.loadRelationshipMemory()) ?? undefined;
+        const nextRevision = (priorMemory?.revision ?? 0) + 1;
+        const topicAffinities = mergeTopicAffinities(priorMemory?.topicAffinities ?? [], topics);
+        const update = {
+            relationshipId: priorMemory?.relationshipId ?? "default",
+            revision: nextRevision,
+            tonePreference: tone !== "unknown" ? tone : (priorMemory?.tonePreference ?? "unknown"),
+            averageReplyDelayMinutes: input.explicitSignal?.delayMinutes ?? priorMemory?.averageReplyDelayMinutes,
+            noReplyCount: 0, // owner replied → reset counter
+            topicAffinities: topicAffinities.length > 0 ? topicAffinities : (priorMemory?.topicAffinities ?? []),
+            lastInteractionAt: now,
+            sourceRefs: [
+                ...(priorMemory?.sourceRefs ?? []),
+                { sourceId: entryId, kind: "owner_reply_feedback", url: `chronicle://${entryId}` },
+            ],
+            updatedAt: now,
+        };
+        await relStore.upsertRelationshipMemory(update);
+        updatedMemory = (await relStore.loadRelationshipMemory()) ?? undefined;
+        relationshipUpdated = true;
+    }
+    catch (err) {
+        // Relationship update is best-effort; chronicle is the source of truth.
+        // Missing memory update will be reflected in the next `explain relationship` query.
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        console.warn(`[owner-reply-feedback] RelationshipMemory update failed: ${errorMessage}`);
+        // Write a diagnostic chronicle entry so operators can trace the failure.
+        await chronicleStore.appendSessionChronicle({
+            entryId: `${entryId}:diagnostic`,
+            eventKind: "system_notice",
+            actor: "system",
+            occurredAt: new Date().toISOString(),
+            summary: `RelationshipMemory update failed: ${errorMessage}`,
+            result: "failed",
+            sourceRefs: [{ sourceId: entryId, kind: "owner_reply_feedback", url: `chronicle://${entryId}` }],
+            relatedDecisionId: input.relatedDecisionId,
+        });
+        return {
+            chronicleEntryId: entryId,
+            relationshipUpdated: false,
+            priorMemory,
+            updatedMemory,
+            relationshipUpdateError: errorMessage,
+        };
+    }
+    return {
+        chronicleEntryId: entryId,
+        relationshipUpdated,
+        priorMemory,
+        updatedMemory,
+    };
+}

package/runtime/core/second-nature/heartbeat/heartbeat-loop.d.ts

@@ -20,6 +20,7 @@ import type { GuidanceDraftPort } from "../../../guidance/outreach-draft-schema.
 import type { StateDatabase } from "../../../storage/db/index.js";
 import { type OpenClawDeliveryPort } from "../outreach/dispatch-user-outreach.js";
 import type { ConnectorExecutor } from "../../../connectors/base/contract.js";
+import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
 import type { NarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
 import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
 export interface HeartbeatDecisionTracePayload {
@@ -47,7 +48,7 @@ export interface HeartbeatQuietWorkflowDeps {
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
  */
-export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow" | "connectorExecutor">): Promise<HeartbeatCycleResult>;
+export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow" | "connectorExecutor" | "state" | "workspaceRoot">): Promise<HeartbeatCycleResult>;
 export interface HeartbeatDeps {
     /** Load snapshot inputs from state-system */
     loadSnapshotInputs: () => Promise<SnapshotInputs>;
@@ -64,6 +65,12 @@ export interface HeartbeatDeps {
     narrativeStateStore?: NarrativeStateStore;
     /** T5.1.2: when present, heartbeat records a NarrativeTrace after successful narrative state update. */
     recordNarrativeTrace?: (payload: NarrativeTracePayload) => Promise<void>;
+    /** T3.3.1: when present, successful connector effects write LifeEvidence artifacts. */
+    state?: StateDatabase;
+    /** T3.3.1: workspace root for evidence artifact paths. */
+    workspaceRoot?: string;
+    /** T2.4.1: when present, planner resolves platform-specific intents. */
+    connectorRegistry?: CapabilityContractRegistry;
 }
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.