@haaaiawd/second-nature 0.1.24 → 0.1.26

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,7 +20,9 @@ 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 {
     scope: RuntimeScope;
     status: HeartbeatCycleStatus;
@@ -46,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>;
@@ -61,6 +63,14 @@ export interface HeartbeatDeps {
     connectorExecutor?: ConnectorExecutor;
     /** T2.1.5: when present, heartbeat writes a source-backed NarrativeState revision after each cycle. */
     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.

package/runtime/core/second-nature/heartbeat/heartbeat-loop.js

@@ -8,6 +8,8 @@ import { buildJudgeOutreachInputFromSnapshot } from "../outreach/judge-input-fro
 import { runSourceBackedQuiet } from "../quiet/run-source-backed-quiet.js";
 import { toCapabilityIntent } from "../orchestrator/effect-dispatcher.js";
 import { updateNarrativeAfterEffect } from "../orchestrator/narrative-update.js";
+import { mapLifeEvidence } from "../../../connectors/base/map-life-evidence.js";
+import { appendLifeEvidence } from "../../../storage/life-evidence/append-life-evidence.js";
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
@@ -52,19 +54,53 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
         intent.kind === "maintenance";
     const connectorUnwired = intent.effectClass === "connector_action";
     if (connectorUnwired && deps.connectorExecutor) {
+        if (!intent.platformId || intent.platformId === "unknown") {
+            return {
+                scope: "rhythm",
+                status: "intent_selected",
+                selectedIntentId: intent.id,
+                decisionId: `decision:${intent.id}:${Date.now()}`,
+                reasons: ["connector_dispatch_unavailable"],
+            };
+        }
+        const decisionId = `decision:${intent.id}:${Date.now()}`;
         const result = await deps.connectorExecutor.executeEffect({
-            platformId: intent.platformId ?? "unknown",
+            platformId: intent.platformId,
             intent: toCapabilityIntent(intent),
             payload: {},
-            decisionId: `decision:${intent.id}:${Date.now()}`,
+            decisionId,
             intentId: intent.id,
             idempotencyKey: `idem:${intent.id}:${Date.now()}`,
         });
+        // T3.3.1: on success, map connector result to life evidence and append.
+        // On failure or empty result, no evidence is fabricated — attempt audit
+        // is already recorded by the connector policy layer telemetry.
+        if (result.status === "success" &&
+            deps.state &&
+            deps.workspaceRoot) {
+            try {
+                const candidate = mapLifeEvidence({
+                    platformId: intent.platformId,
+                    intent: toCapabilityIntent(intent),
+                    result,
+                    observedAt: new Date().toISOString(),
+                });
+                if (candidate) {
+                    await appendLifeEvidence(deps.state, deps.workspaceRoot, candidate);
+                }
+            }
+            catch (err) {
+                // Evidence append must not break the heartbeat cycle.
+                // Missing evidence will be reflected in the next snapshot load.
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                console.warn(`[heartbeat] evidence append failed for ${intent.platformId ?? "unknown"}: ${errorMessage}`);
+            }
+        }
         const base = {
             scope: "rhythm",
             status: "intent_selected",
             selectedIntentId: intent.id,
-            decisionId: `decision:${intent.id}:${Date.now()}`,
+            decisionId,
             reasons: result.status === "success"
                 ? ["connector_effect_executed"]
                 : result.status === "retryable_failure"
@@ -91,7 +127,7 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
  * is never blocked by a store failure. Store failures are optionally traced
  * via recordDecisionTrace so operators can monitor store health.
  */
-async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store, recordTrace, signal) {
+async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store, recordTrace, signal, recordNarrativeTrace) {
     if (!store)
         return;
     try {
@@ -103,6 +139,33 @@ async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store,
             priorNarrative: prior,
         });
         await store.updateNarrativeState(update);
+        // T5.1.2: record NarrativeTrace on successful state update
+        if (recordNarrativeTrace) {
+            try {
+                await recordNarrativeTrace({
+                    traceId: `narrative_trace:${crypto.randomUUID()}`,
+                    narrativeId: update.narrativeId,
+                    revision: update.revision,
+                    updateSource: "heartbeat",
+                    sourceRefs: update.sourceRefs.map((r) => ({
+                        id: r.sourceId,
+                        kind: r.kind,
+                        uri: r.url,
+                    })),
+                    unsupportedClaims: update.unsupportedClaims,
+                    groundingStatus: update.unsupportedClaims.length > 0
+                        ? "degraded"
+                        : update.status === "insufficient_sources"
+                            ? "blocked"
+                            : "pass",
+                    goalInfluenceRefs: selectedIntent?.goalInfluenceRefs ?? [],
+                    createdAt: update.updatedAt,
+                });
+            }
+            catch {
+                // trace emission must not block the cycle
+            }
+        }
     }
     catch {
         // degrade silently; narrative update is best-effort
@@ -136,7 +199,12 @@ export async function ingestRhythmSignal(signal, deps) {
     const snapshot = buildContinuitySnapshot(inputs);
     const timestamp = signal.payload.timestamp;
     const runtime = buildHeartbeatRuntimeSnapshot(timestamp, inputs, snapshot);
-    const rawCandidates = planCandidateIntents(runtime);
+    const rawCandidates = planCandidateIntents(runtime, {
+        acceptedGoals: inputs.acceptedGoals,
+        connectorRegistry: deps.connectorRegistry,
+        narrativeState: runtime.narrativeState,
+        relationshipMemory: runtime.relationshipMemory,
+    });
     const { candidates } = applyGoalPriority(rawCandidates, inputs.acceptedGoals);
     const emitTrace = async (result) => {
         if (!deps.recordDecisionTrace)
@@ -178,7 +246,7 @@ export async function ingestRhythmSignal(signal, deps) {
                 ? { ...resolved, reasons: evaluation.reasons }
                 : resolved;
             await emitTrace(result);
-            await maybeUpdateNarrativeState(result, intent, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+            await maybeUpdateNarrativeState(result, intent, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
             return result;
         }
         if (evaluation.verdict === "defer") {
@@ -196,7 +264,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: ["silent_no_candidates"],
         };
         await emitTrace(result);
-        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
         return result;
     }
     if (!anyAllow && anyDefer && !anyDeny) {
@@ -206,7 +274,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: denyReasons.length > 0 ? denyReasons : ["all_candidates_deferred"],
         };
         await emitTrace(result);
-        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
         return result;
     }
     if (!anyAllow && denyReasons.length > 0) {
@@ -216,7 +284,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: denyReasons,
         };
         await emitTrace(result);
-        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
         return result;
     }
     const result = {
@@ -225,7 +293,7 @@ export async function ingestRhythmSignal(signal, deps) {
         reasons: ["no_allow_verdict"],
     };
     await emitTrace(result);
-    await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+    await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
     return result;
 }
 /**

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

@@ -21,6 +21,8 @@ export interface HeartbeatRuntimeSnapshot {
     lifeEvidence: PlannerLifeEvidenceSlice;
     rhythmWindow: PlannerRhythmWindowSlice;
     hardGuards: HardGuardDeps;
+    narrativeState?: import("../../../storage/narrative/narrative-state-store.js").NarrativeState;
+    relationshipMemory?: import("../../../storage/relationship/relationship-memory-store.js").RelationshipMemory;
 }
 export declare function buildLifeEvidenceSliceFromInputs(inputs: SnapshotInputs): PlannerLifeEvidenceSlice;
 export declare function buildHardGuardDeps(continuity: ContinuitySnapshot, inputs: SnapshotInputs): HardGuardDeps;

package/runtime/core/second-nature/heartbeat/runtime-snapshot.js

@@ -31,5 +31,5 @@ export function buildHeartbeatRuntimeSnapshot(timestamp, inputs, continuity) {
     const rhythmWindow = buildPlannerRhythmWindow(timestamp, continuity, policy);
     const lifeEvidence = buildLifeEvidenceSliceFromInputs(inputs);
     const hardGuards = buildHardGuardDeps(continuity, inputs);
-    return { continuity, lifeEvidence, rhythmWindow, hardGuards };
+    return { continuity, lifeEvidence, rhythmWindow, hardGuards, narrativeState: inputs.narrativeState, relationshipMemory: inputs.relationshipMemory };
 }

package/runtime/core/second-nature/heartbeat/snapshot-builder.d.ts

@@ -10,7 +10,8 @@ import type { ContinuitySnapshot, ControlPlaneSourceRef, TopLevelMode } from "..
 import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
 import type { DeliveryCapabilitySnapshot } from "../outreach/delivery-target.js";
 import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
-import type { AgentGoal } from "../../../storage/goal/agent-goal-store.js";
+import type { NarrativeState } from "../../../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../../../storage/relationship/relationship-memory-store.js";
 export interface SnapshotInputs {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -43,7 +44,20 @@ export interface SnapshotInputs {
     /** When present, outreach judgment uses this user-interest read model (T4.2.2). */
     userInterestSnapshot?: UserInterestSnapshot;
     /** T2.1.4: accepted goals to influence candidate intent priority. */
-    acceptedGoals?: AgentGoal[];
+    acceptedGoals?: Array<{
+        goalId: string;
+        description: string;
+        completionCriteria?: string;
+        status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+        origin: "owner_set" | "agent_proposed" | "policy_seeded";
+        acceptedBy?: "owner" | "policy_allowlist";
+    }>;
+    /** When present, signals that acceptedGoals load failed (distinguishes from empty). */
+    acceptedGoalsLoadError?: string;
+    /** When present, planner uses narrative focus to influence candidate priority. */
+    narrativeState?: NarrativeState;
+    /** When present, planner uses relationship memory to influence outreach timing. */
+    relationshipMemory?: RelationshipMemory;
 }
 /**
  * Build a ContinuitySnapshot from loaded inputs.

package/runtime/core/second-nature/index.d.ts

@@ -20,3 +20,4 @@ export * from "./outreach/judge-input-from-snapshot.js";
 export * from "./quiet/run-source-backed-quiet.js";
 export * from "./guidance/request-guidance.js";
 export * from "./guidance/apply-guidance.js";
+export * from "./feedback/owner-reply-feedback.js";

package/runtime/core/second-nature/index.js

@@ -20,3 +20,4 @@ export * from "./outreach/judge-input-from-snapshot.js";
 export * from "./quiet/run-source-backed-quiet.js";
 export * from "./guidance/request-guidance.js";
 export * from "./guidance/apply-guidance.js";
+export * from "./feedback/owner-reply-feedback.js";

package/runtime/core/second-nature/orchestrator/goal-priority.d.ts

@@ -3,11 +3,24 @@
  *
  * `applyGoalPriority` adjusts candidate intent priorities based on accepted AgentGoals.
  * Priority order: user_task > accepted_goal > rhythm.
- * Only goals with status === "accepted" and origin !== "agent_proposed" are considered.
+ * Only goals with status === "accepted" are considered.
+ * Agent-proposed goals are included ONLY if policy-accepted (acceptedBy === "policy_allowlist").
  * All other statuses (proposal / rejected / completed / paused) are implicitly excluded.
  */
 import type { CandidateIntent } from "../types.js";
-import type { AgentGoal } from "../../../storage/goal/agent-goal-store.js";
+/**
+ * Minimal goal context used by the priority module to avoid coupling
+ * to the full AgentGoal schema. M-03 decoupling.
+ */
+export interface GoalPriorityContext {
+    goalId: string;
+    description: string;
+    completionCriteria?: string;
+    status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+    origin: "owner_set" | "agent_proposed" | "policy_seeded";
+    acceptedBy?: "owner" | "policy_allowlist";
+}
+export declare function isGoalRelatedToCandidate(goal: GoalPriorityContext, candidate: CandidateIntent): boolean;
 export interface ApplyGoalPriorityResult {
     candidates: CandidateIntent[];
     goalInfluences: Array<{
@@ -16,4 +29,4 @@ export interface ApplyGoalPriorityResult {
         boost: number;
     }>;
 }
-export declare function applyGoalPriority(candidates: CandidateIntent[], goals: AgentGoal[] | undefined): ApplyGoalPriorityResult;
+export declare function applyGoalPriority(candidates: CandidateIntent[], goals: GoalPriorityContext[] | undefined): ApplyGoalPriorityResult;

package/runtime/core/second-nature/orchestrator/goal-priority.js

@@ -6,15 +6,15 @@
  * range from 40–100, so 200 provides ample headroom without overflow.
  */
 const GOAL_PRIORITY_BOOST = 20;
-function isGoalRelatedToCandidate(goal, candidate) {
-    if (!candidate.platformId)
-        return false;
-    const goalText = `${goal.description} ${goal.completionCriteria}`.toLowerCase();
-    const platformId = candidate.platformId.toLowerCase();
+export function isGoalRelatedToCandidate(goal, candidate) {
+    const goalText = `${goal.description} ${goal.completionCriteria ?? ""}`.toLowerCase();
     // Direct platformId mention in goal text
-    if (goalText.includes(platformId))
-        return true;
-    // Goal description contains candidate summary keywords
+    if (candidate.platformId) {
+        const platformId = candidate.platformId.toLowerCase();
+        if (goalText.includes(platformId))
+            return true;
+    }
+    // Fallback: Goal description contains candidate summary keywords
     const summaryWords = candidate.summary.toLowerCase().split(/\s+/);
     for (const word of summaryWords) {
         if (word.length > 3 && goalText.includes(word))
@@ -23,7 +23,8 @@ function isGoalRelatedToCandidate(goal, candidate) {
     return false;
 }
 export function applyGoalPriority(candidates, goals) {
-    const acceptedGoals = (goals ?? []).filter((g) => g.status === "accepted" && g.origin !== "agent_proposed");
+    const acceptedGoals = (goals ?? []).filter((g) => g.status === "accepted" &&
+        (g.origin !== "agent_proposed" || g.acceptedBy === "policy_allowlist"));
     if (acceptedGoals.length === 0) {
         return {
             candidates: candidates.map((c) => ({

package/runtime/core/second-nature/orchestrator/intent-planner.d.ts

@@ -4,10 +4,38 @@
  */
 import type { CandidateIntent, ContinuitySnapshot, DecisionBasis } from "../types.js";
 import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
+import type { NarrativeState } from "../../../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../../../storage/relationship/relationship-memory-store.js";
+import { type PlatformResolutionContext } from "./platform-capability-router.js";
+import { type GoalPriorityContext } from "./goal-priority.js";
+/** Alias for GoalPriorityContext to keep intent-planner local naming consistent. M-03 decoupling. */
+export type GoalContext = GoalPriorityContext;
+export interface PlanIntentOptions {
+    narrativeState?: NarrativeState;
+    relationshipMemory?: RelationshipMemory;
+    budgetCheck?: boolean;
+    multiSource?: string[];
+}
+/**
+ * Factory for planning a candidate intent of a given kind.
+ * M-04: consolidates the previously separate plan{Work,Exploration,Social,Outreach}Intents.
+ */
+export declare function planIntentWithKind(kind: "work" | "exploration" | "social" | "outreach", basePriority: number, runtime: HeartbeatRuntimeSnapshot, context: PlatformResolutionContext, registry?: CapabilityContractRegistry, options?: PlanIntentOptions): CandidateIntent[];
+export interface PlanCandidateIntentsOptions {
+    /** T2.4.1: accepted goals for platform-specific resolution. */
+    acceptedGoals?: GoalContext[];
+    /** T2.4.1: optional connector registry for capability validation. */
+    connectorRegistry?: CapabilityContractRegistry;
+    /** CR-02: optional narrative state to influence candidate priority. */
+    narrativeState?: NarrativeState;
+    /** CR-02: optional relationship memory to influence outreach timing. */
+    relationshipMemory?: RelationshipMemory;
+}
 /**
  * Plan ordered candidates for one heartbeat turn using rhythm window + life evidence slice.
  */
-export declare function planCandidateIntents(runtime: HeartbeatRuntimeSnapshot): CandidateIntent[];
+export declare function planCandidateIntents(runtime: HeartbeatRuntimeSnapshot, options?: PlanCandidateIntentsOptions): CandidateIntent[];
 /** @deprecated Continuity-only helper for tests; prefer `planCandidateIntents` + `buildHeartbeatRuntimeSnapshot`. */
 export declare function planIntent(snapshot: ContinuitySnapshot): CandidateIntent[];
 export declare function decideDecisionBasis(intent: CandidateIntent): DecisionBasis;