@haaaiawd/second-nature 0.1.24 → 0.1.26

package/runtime/core/second-nature/orchestrator/intent-planner.js

@@ -1,5 +1,7 @@
 import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
 import { buildHeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import { resolvePlatformForIntent, } from "./platform-capability-router.js";
+import { isGoalRelatedToCandidate } from "./goal-priority.js";
 const MAX_CANDIDATE_INTENTS = 6;
 const OBLIGATION_SOURCE = [
     { id: "obligation-anchor", kind: "workspace_artifact", uri: "workspace://obligations/pending" },
@@ -8,72 +10,131 @@ function evidenceRefsForConnector(runtime) {
     if (!isLifeEvidenceSliceEmpty(runtime.lifeEvidence) && runtime.lifeEvidence.evidenceRefs.length > 0) {
         return runtime.lifeEvidence.evidenceRefs.slice(0, 8);
     }
-    if (!isLifeEvidenceSliceEmpty(runtime.lifeEvidence)) {
-        return [
-            {
-                id: "life-evidence-summary",
-                kind: "connector_result",
-                uri: `workspace://life-evidence/counts/${runtime.lifeEvidence.platformEventCount}/${runtime.lifeEvidence.workEventCount}`,
-            },
-        ];
-    }
     return [];
 }
 function isAllowedKind(kind, runtime) {
     return runtime.rhythmWindow.allowedIntentKinds.includes(kind);
 }
-function planWorkIntents(runtime) {
-    if (!isAllowedKind("work", runtime))
-        return [];
-    return runtime.continuity.pendingObligations.map((obligation, index) => ({
-        id: `intent-obligation-${index}`,
-        kind: "work",
-        priority: 100 - index,
+function focusMatchesKind(focus, kind) {
+    const lower = focus.toLowerCase();
+    switch (kind) {
+        case "work":
+            return lower.includes("work") || lower.includes("obligation") || lower.includes("task");
+        case "exploration":
+            return lower.includes("explor") || lower.includes("opportunit") || lower.includes("scan") || lower.includes("discover");
+        case "social":
+            return lower.includes("social") || lower.includes("engage") || lower.includes("community");
+        case "outreach":
+            return lower.includes("outreach") || lower.includes("user") || lower.includes("proactive") || lower.includes("contact");
+        case "quiet":
+            return lower.includes("quiet") || lower.includes("bookkeep") || lower.includes("pause");
+        case "reflection":
+            return lower.includes("reflect") || lower.includes("narrative") || lower.includes("review");
+        case "maintenance":
+            return lower.includes("maintenance") || lower.includes("check") || lower.includes("upkeep");
+        default:
+            return false;
+    }
+}
+const INTENT_CONFIGS = {
+    work: {
+        basePriority: 100,
+        effectClass: "connector_action",
+        summary: (platformId, detail) => platformId ? `fulfill obligation on ${platformId}: ${detail}` : `fulfill obligation: ${detail}`,
         source: "obligation",
-        summary: `fulfill obligation: ${obligation}`,
+        idPrefix: "intent-obligation",
+        idempotencyPrefix: "obligation",
+    },
+    exploration: {
+        basePriority: 70,
         effectClass: "connector_action",
-        sourceRefs: [...OBLIGATION_SOURCE],
-        idempotencyKey: `obligation:${obligation}:${index}`,
-        goalInfluenceRefs: [],
-    }));
-}
-function planExplorationIntents(runtime) {
-    if (!isAllowedKind("exploration", runtime))
+        summary: (platformId) => platformId ? `scan platform opportunities on ${platformId}` : "scan platform opportunities",
+        source: "tick",
+        idPrefix: "intent-exploration",
+        idempotencyPrefix: "exploration",
+    },
+    social: {
+        basePriority: 60,
+        effectClass: "connector_action",
+        summary: (platformId) => platformId ? `engage social platforms on ${platformId}` : "engage social platforms",
+        source: "tick",
+        idPrefix: "intent-social",
+        idempotencyPrefix: "social",
+    },
+    outreach: {
+        basePriority: 40,
+        effectClass: "user_outreach",
+        summary: (platformId) => platformId ? `consider proactive user outreach on ${platformId}` : "consider proactive user outreach",
+        source: "tick",
+        idPrefix: "intent-outreach",
+        idempotencyPrefix: "outreach",
+    },
+};
+/**
+ * Factory for planning a candidate intent of a given kind.
+ * M-04: consolidates the previously separate plan{Work,Exploration,Social,Outreach}Intents.
+ */
+export function planIntentWithKind(kind, basePriority, runtime, context, registry, options) {
+    if (!isAllowedKind(kind, runtime))
         return [];
-    const refs = evidenceRefsForConnector(runtime);
-    return [
-        {
-            id: "intent-exploration",
-            kind: "exploration",
-            priority: 70,
-            source: "tick",
-            summary: "scan platform opportunities",
-            effectClass: "connector_action",
-            sourceRefs: refs,
-            idempotencyKey: "exploration:scan platform opportunities",
+    const config = INTENT_CONFIGS[kind];
+    const platformId = resolvePlatformForIntent(kind, context ?? {}, registry);
+    let priority = basePriority;
+    // Social budget exhaustion → cap priority.
+    if (kind === "social" &&
+        runtime.continuity.budgets &&
+        runtime.continuity.budgets.socialUsed >= runtime.continuity.budgets.socialLimit) {
+        priority = 10;
+    }
+    // Narrative focus bias (preserved from original per-kind functions).
+    if (options?.narrativeState?.focus && focusMatchesKind(options.narrativeState.focus, kind)) {
+        priority += 15;
+    }
+    // Outreach suppression checks.
+    if (kind === "outreach") {
+        if (runtime.continuity.recentOutreachHashes.length > 3) {
+            return [];
+        }
+        if (options?.relationshipMemory && options.relationshipMemory.noReplyCount > 3) {
+            return [];
+        }
+    }
+    // Work special case: multi-source from pending obligations.
+    if (kind === "work" && options?.multiSource) {
+        return options.multiSource.map((source, index) => ({
+            id: platformId ? `${config.idPrefix}-${platformId}-${index}` : `${config.idPrefix}-${index}`,
+            kind: "work",
+            priority: basePriority - index,
+            source: "obligation",
+            platformId,
+            summary: config.summary(platformId, source),
+            effectClass: config.effectClass,
+            sourceRefs: [...OBLIGATION_SOURCE],
+            idempotencyKey: platformId
+                ? `${config.idempotencyPrefix}:${platformId}:${source}:${index}`
+                : `${config.idempotencyPrefix}:${source}:${index}`,
             goalInfluenceRefs: [],
-        },
-    ];
-}
-function planSocialIntents(runtime) {
-    if (!isAllowedKind("social", runtime))
-        return [];
-    const refs = evidenceRefsForConnector(runtime);
+        }));
+    }
+    const refs = kind === "work" ? [...OBLIGATION_SOURCE] : evidenceRefsForConnector(runtime);
     return [
         {
-            id: "intent-social",
-            kind: "social",
-            priority: runtime.continuity.budgets && runtime.continuity.budgets.socialUsed >= runtime.continuity.budgets.socialLimit ? 10 : 60,
-            source: "tick",
-            summary: "engage social platforms",
-            effectClass: "connector_action",
+            id: platformId ? `${config.idPrefix}-${platformId}` : config.idPrefix,
+            kind,
+            priority,
+            source: config.source,
+            platformId,
+            summary: config.summary(platformId),
+            effectClass: config.effectClass,
             sourceRefs: refs,
-            idempotencyKey: "social:engage social platforms",
+            idempotencyKey: platformId
+                ? `${config.idempotencyPrefix}:${platformId}`
+                : `${config.idempotencyPrefix}:${config.summary(undefined)}`,
             goalInfluenceRefs: [],
         },
     ];
 }
-function planQuietReflectionIntents(runtime) {
+function planQuietReflectionIntents(runtime, _context, _registry) {
     if (!runtime.rhythmWindow.quietBias && runtime.continuity.mode !== "quiet") {
         return [];
     }
@@ -120,31 +181,17 @@ function planQuietReflectionIntents(runtime) {
     }
     return out;
 }
-function planOutreachIntents(runtime) {
-    if (!isAllowedKind("outreach", runtime))
-        return [];
-    if (runtime.continuity.recentOutreachHashes.length > 3) {
-        return [];
-    }
-    const refs = evidenceRefsForConnector(runtime);
-    return [
-        {
-            id: "intent-outreach",
-            kind: "outreach",
-            priority: 40,
-            source: "tick",
-            summary: "consider proactive user outreach",
-            effectClass: "user_outreach",
-            sourceRefs: refs,
-            idempotencyKey: "outreach:consider proactive user outreach",
-            goalInfluenceRefs: [],
-        },
-    ];
-}
 /**
  * Plan ordered candidates for one heartbeat turn using rhythm window + life evidence slice.
  */
-export function planCandidateIntents(runtime) {
+export function planCandidateIntents(runtime, options) {
+    const context = {
+        acceptedGoals: options?.acceptedGoals,
+        evidenceRefs: runtime.lifeEvidence.evidenceRefs,
+    };
+    const registry = options?.connectorRegistry;
+    const narrativeState = options?.narrativeState ?? runtime.narrativeState;
+    const relationshipMemory = options?.relationshipMemory ?? runtime.relationshipMemory;
     if (runtime.continuity.mode === "paused_for_interrupt") {
         const pausedMaintenance = [
             {
@@ -164,16 +211,44 @@ export function planCandidateIntents(runtime) {
             .slice(0, MAX_CANDIDATE_INTENTS);
     }
     if (runtime.continuity.mode === "maintenance_only") {
-        return planWorkIntents(runtime).sort((a, b) => b.priority - a.priority).slice(0, MAX_CANDIDATE_INTENTS);
+        return planIntentWithKind("work", INTENT_CONFIGS.work.basePriority, runtime, context, registry, { multiSource: runtime.continuity.pendingObligations })
+            .sort((a, b) => b.priority - a.priority)
+            .slice(0, MAX_CANDIDATE_INTENTS);
     }
     const intents = [
-        ...planWorkIntents(runtime),
-        ...planExplorationIntents(runtime),
-        ...planSocialIntents(runtime),
-        ...planQuietReflectionIntents(runtime),
-        ...planOutreachIntents(runtime),
+        ...planIntentWithKind("work", INTENT_CONFIGS.work.basePriority, runtime, context, registry, { multiSource: runtime.continuity.pendingObligations }),
+        ...planIntentWithKind("exploration", INTENT_CONFIGS.exploration.basePriority, runtime, context, registry),
+        ...planIntentWithKind("social", INTENT_CONFIGS.social.basePriority, runtime, context, registry, {
+            narrativeState,
+            budgetCheck: true,
+        }),
+        ...planQuietReflectionIntents(runtime, context, registry),
+        ...planIntentWithKind("outreach", INTENT_CONFIGS.outreach.basePriority, runtime, context, registry, {
+            narrativeState,
+            relationshipMemory,
+        }),
     ];
-    return intents
+    // Pre-fill goalInfluenceRefs for non-obligation intents before returning.
+    // applyGoalPriority will later refine/override with the same logic.
+    const acceptedGoals = options?.acceptedGoals?.filter((g) => g.status === "accepted" &&
+        (g.origin !== "agent_proposed" || g.acceptedBy === "policy_allowlist")) ?? [];
+    for (const intent of intents) {
+        if (intent.source === "obligation")
+            continue;
+        const related = acceptedGoals.filter((g) => isGoalRelatedToCandidate(g, intent));
+        if (related.length > 0) {
+            intent.goalInfluenceRefs = related.map((g) => g.goalId);
+        }
+    }
+    // CR-02: apply narrative-focus bias globally across all candidate kinds.
+    const adjusted = intents.map((intent) => {
+        let priority = intent.priority;
+        if (narrativeState?.focus && focusMatchesKind(narrativeState.focus, intent.kind)) {
+            priority += 15;
+        }
+        return { ...intent, priority };
+    });
+    return adjusted
         .filter((intent) => runtime.rhythmWindow.allowedIntentKinds.includes(intent.kind))
         .sort((a, b) => b.priority - a.priority)
         .slice(0, MAX_CANDIDATE_INTENTS);

package/runtime/core/second-nature/orchestrator/narrative-update.js

@@ -11,19 +11,32 @@ function mapControlPlaneRefToSourceRef(ref) {
 /**
  * Compute narrative confidence based on source evidence.
  *
- * Formula: min(intentSources / 3, 1) + (lifeEvidenceSources > 0 ? 0.1 : 0)
+ * Formula: smooth sigmoid-like growth:
+ *   - 0 sources → 0
+ *   - 1 source → 0.35 (not 0.43; single-source is weak but non-zero)
+ *   - 2 sources → 0.60 (beginning to be trustworthy)
+ *   - 3 sources → 0.80 (strong confidence, not 1.0)
+ *   - 4+ sources → 0.90 (cap below 1.0 to avoid false certainty)
+ *   - Boost: +0.05 if corroborating life evidence exists
+ *   - Hard cap at 0.95 (never claim 100% certainty from evidence count alone)
  *
- * Rationale:
- * - Base: 1/3 per intent source (3 sources = 100% confidence)
- * - Boost: +0.1 if any life evidence exists (signals corroboration)
- * - Capped at 1.0 (100%)
+ * Rationale: linear 1/3 per source produces unnatural jumps.
+ * Logarithmic growth better models diminishing returns per extra source.
  */
 function computeConfidence(intentSources, lifeEvidenceSources) {
     if (intentSources === 0 && lifeEvidenceSources === 0)
         return 0;
-    const base = Math.min(intentSources / 3, 1);
-    const boost = lifeEvidenceSources > 0 ? 0.1 : 0;
-    return Math.min(base + boost, 1);
+    const base = intentSources === 0
+        ? 0
+        : intentSources === 1
+            ? 0.35
+            : intentSources === 2
+                ? 0.60
+                : intentSources === 3
+                    ? 0.80
+                    : 0.90;
+    const boost = lifeEvidenceSources > 0 ? 0.05 : 0;
+    return Math.min(base + boost, 0.95);
 }
 /**
  * Build the next NarrativeState revision from a completed heartbeat cycle.
@@ -48,7 +61,8 @@ export function updateNarrativeAfterEffect(input) {
         const sourceRefs = selectedIntent.sourceRefs.map(mapControlPlaneRefToSourceRef);
         if (hasIntentSources || hasLifeEvidence) {
             // Source-backed revision
-            const progressEntry = `${selectedIntent.effectClass}: ${selectedIntent.summary}`;
+            // L-03: Use effectClass + id as dedup key instead of full summary text.
+            const progressEntry = `${selectedIntent.effectClass}: ${selectedIntent.id}`;
             const progress = [...(prior?.progress ?? [])];
             if (!progress.includes(progressEntry)) {
                 progress.push(progressEntry);

package/runtime/core/second-nature/orchestrator/platform-capability-router.d.ts

@@ -0,0 +1,34 @@
+/**
+ * T2.4.1 — Platform-specific intent resolution.
+ *
+ * When accepted goals, narrative, or connector evidence point to a specific
+ * platform, the planner emits a `CandidateIntent` with an explicit
+ * `platformId`.  If the platform cannot be inferred, the caller falls
+ * back to the generic connector_action path (platformId undefined).
+ *
+ * Boundaries:
+ * - Does NOT execute connectors; only resolves platform + capability.
+ * - Does NOT validate credentials; that is the guard layer's job.
+ * - Optional registry: when absent, resolution is best-effort from goals/evidence.
+ */
+import type { IntentKind } from "../types.js";
+import type { ControlPlaneSourceRef } from "../types.js";
+import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
+/** Minimal goal shape accepted by the router to avoid coupling to AgentGoal. M-03 decoupling. */
+interface GoalRouterContext {
+    goalId: string;
+    description: string;
+    completionCriteria?: string;
+}
+export interface PlatformResolutionContext {
+    /** Accepted goals that may name a platform or capability. */
+    acceptedGoals?: GoalRouterContext[];
+    /** Evidence refs that may embed platform identity. */
+    evidenceRefs?: ControlPlaneSourceRef[];
+}
+/**
+ * Resolve an explicit platformId for a candidate intent kind.
+ * Returns `undefined` when no unambiguous platform can be inferred.
+ */
+export declare function resolvePlatformForIntent(kind: IntentKind, context: PlatformResolutionContext, registry?: CapabilityContractRegistry): string | undefined;
+export {};

package/runtime/core/second-nature/orchestrator/platform-capability-router.js

@@ -0,0 +1,115 @@
+function kindToCapability(kind) {
+    if (kind === "exploration")
+        return "feed.read";
+    if (kind === "social")
+        return "comment.reply";
+    if (kind === "work")
+        return "work.discover";
+    if (kind === "outreach")
+        return "message.send";
+    return null;
+}
+function getPlatformIds(registry) {
+    if (registry) {
+        return registry.listRegisteredPlatformIds();
+    }
+    // Fallback: built-in platforms when registry is absent (backward compat)
+    return ["moltbook", "instreet", "evomap"];
+}
+function extractPlatformIdsFromGoals(goals, kind, platformIds) {
+    const capability = kindToCapability(kind);
+    const results = new Set();
+    for (const goal of goals) {
+        const text = `${goal.description} ${goal.completionCriteria ?? ""}`.toLowerCase();
+        for (const pid of platformIds) {
+            if (text.includes(pid)) {
+                results.add(pid);
+            }
+        }
+        // Also match if goal text contains the capability name (e.g. "feed.read")
+        if (capability && text.includes(capability.toLowerCase())) {
+            // capability alone doesn't tell us platform; keep for later
+        }
+    }
+    return [...results];
+}
+function extractPlatformIdsFromEvidence(refs, platformIds) {
+    const results = new Set();
+    for (const ref of refs) {
+        if (ref.kind === "connector_result" && ref.id) {
+            for (const pid of platformIds) {
+                if (ref.id.includes(pid)) {
+                    results.add(pid);
+                }
+            }
+        }
+        // Parse platform:// URIs (e.g. platform://moltbook/feed.read)
+        if (ref.uri && ref.uri.startsWith("platform://")) {
+            const afterScheme = ref.uri.slice("platform://".length);
+            const platformPart = afterScheme.split("/")[0];
+            if (platformPart && platformIds.includes(platformPart)) {
+                results.add(platformPart);
+            }
+        }
+        // L-02: Also support namespace format moltbook:feed.read (connector-system §5.3)
+        if (ref.uri && !ref.uri.includes("://") && ref.uri.includes(":")) {
+            const nsPart = ref.uri.split(":")[0];
+            if (nsPart && platformIds.includes(nsPart)) {
+                results.add(nsPart);
+            }
+        }
+    }
+    return [...results];
+}
+function validatePlatformCapability(platformId, kind, registry) {
+    const capability = kindToCapability(kind);
+    if (!capability)
+        return false;
+    try {
+        return registry.hasCapability(platformId, capability);
+    }
+    catch (err) {
+        // H-08: Log registry validation failures for observability.
+        console.warn(`[platform-capability-router] Registry validation failed for ${platformId}:${capability}`, err);
+        return false;
+    }
+}
+/**
+ * Resolve an explicit platformId for a candidate intent kind.
+ * Returns `undefined` when no unambiguous platform can be inferred.
+ */
+export function resolvePlatformForIntent(kind, context, registry) {
+    const capability = kindToCapability(kind);
+    if (!capability) {
+        // Quiet, reflection, maintenance have no connector capability mapping.
+        return undefined;
+    }
+    const platformIds = getPlatformIds(registry);
+    const candidates = [];
+    if (context.acceptedGoals && context.acceptedGoals.length > 0) {
+        candidates.push(...extractPlatformIdsFromGoals(context.acceptedGoals, kind, platformIds));
+    }
+    if (context.evidenceRefs && context.evidenceRefs.length > 0) {
+        candidates.push(...extractPlatformIdsFromEvidence(context.evidenceRefs, platformIds));
+    }
+    // Deduplicate while preserving order
+    const ordered = [...new Set(candidates)];
+    if (ordered.length === 0) {
+        return undefined;
+    }
+    if (ordered.length > 1) {
+        // Ambiguous: multiple platforms inferred → do not guess, return undefined.
+        // Guard layer will deny with "ambiguous_platform" reason.
+        return undefined;
+    }
+    const single = ordered[0];
+    if (registry) {
+        if (validatePlatformCapability(single, kind, registry)) {
+            return single;
+        }
+        // Registry says unsupported → undefined (guard layer will deny)
+        return undefined;
+    }
+    // No registry: best-effort return the single candidate (backward compat)
+    return single;
+}

package/runtime/core/second-nature/outreach/build-outreach-draft-request.d.ts

@@ -3,4 +3,6 @@ import type { CandidateIntent } from "../types.js";
 import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
 import type { OutreachJudgment } from "./judge-outreach.js";
 import type { DeliveryTargetResolution } from "./delivery-target.js";
-export declare function buildOutreachDraftRequest(candidate: CandidateIntent, judgment: OutreachJudgment, snapshot: HeartbeatRuntimeSnapshot, delivery: DeliveryTargetResolution): OutreachDraftRequest;
+import type { NarrativeState } from "../../../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../../../storage/relationship/relationship-memory-store.js";
+export declare function buildOutreachDraftRequest(candidate: CandidateIntent, judgment: OutreachJudgment, snapshot: HeartbeatRuntimeSnapshot, delivery: DeliveryTargetResolution, narrativeState?: NarrativeState, relationshipMemory?: RelationshipMemory): OutreachDraftRequest;

package/runtime/core/second-nature/outreach/build-outreach-draft-request.js

@@ -40,7 +40,43 @@ function mapDeliveryVerdict(verdict) {
             return "host_unsupported";
     }
 }
-export function buildOutreachDraftRequest(candidate, judgment, snapshot, delivery) {
+function buildNarrativeContext(state) {
+    if (!state)
+        return undefined;
+    return {
+        focus: state.focus || undefined,
+        progress: state.progress.length > 0 ? state.progress : undefined,
+        nextIntent: state.nextIntent || undefined,
+        sourceRefs: state.sourceRefs.map((r) => ({
+            id: r.sourceId,
+            kind: "user_anchor",
+            uri: r.url || "",
+            excerptHash: r.snippet,
+            observedAt: undefined,
+        })),
+    };
+}
+function buildRelationshipContext(memory) {
+    if (!memory)
+        return undefined;
+    const avgAffinity = memory.topicAffinities.length > 0
+        ? memory.topicAffinities.reduce((s, t) => s + t.affinity, 0) /
+            memory.topicAffinities.length
+        : 0;
+    return {
+        tone: memory.tonePreference,
+        topicAffinities: memory.topicAffinities.map((t) => t.topic),
+        avgAffinity,
+        sourceRefs: memory.sourceRefs?.map((r) => ({
+            id: r.sourceId,
+            kind: "user_anchor",
+            uri: r.url || "",
+            excerptHash: r.snippet,
+            observedAt: undefined,
+        })),
+    };
+}
+export function buildOutreachDraftRequest(candidate, judgment, snapshot, delivery, narrativeState, relationshipMemory) {
     const sceneType = delivery.verdict === "target_available" ? "outreach" : "fallback_candidate";
     const riskLevel = delivery.verdict === "target_available" ? "medium" : "low";
     return {
@@ -55,6 +91,8 @@ export function buildOutreachDraftRequest(candidate, judgment, snapshot, deliver
         judgmentVerdict: judgment.verdict,
         valueScore: judgment.valueScore,
         interestRefs: toGuidanceRefs(judgment.interestRefs),
+        narrativeContext: buildNarrativeContext(narrativeState),
+        relationshipContext: buildRelationshipContext(relationshipMemory),
         deliveryContext: {
             deliveryVerdict: mapDeliveryVerdict(delivery.verdict),
             wordingMode: delivery.verdict === "target_available" ? "sendable" : "not_sent_fallback_candidate",

package/runtime/core/second-nature/outreach/dispatch-user-outreach.js

@@ -3,6 +3,8 @@ import { writeOperatorFallback } from "../../../storage/fallback/write-operator-
 import { judgeOutreach } from "./judge-outreach.js";
 import { resolveDeliveryTarget } from "./delivery-target.js";
 import { buildOutreachDraftRequest } from "./build-outreach-draft-request.js";
+import { createNarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../../storage/relationship/relationship-memory-store.js";
 function toSourceRefs(refs) {
     return refs.map((r) => ({ ...r }));
 }
@@ -29,8 +31,25 @@ export async function dispatchUserOutreachIntent(input) {
         };
     }
     const deliveryResolution = resolveDeliveryTarget(judgeInput.delivery);
+    // T2.3.1: load narrative/relationship context for source-backed draft
+    let narrativeState;
+    let relationshipMemory;
+    try {
+        const narrativeStore = createNarrativeStateStore(state);
+        narrativeState = (await narrativeStore.loadNarrativeState()) ?? undefined;
+    }
+    catch {
+        // degrade silently; draft proceeds without narrative context
+    }
+    try {
+        const relStore = createRelationshipMemoryStore(state);
+        relationshipMemory = (await relStore.loadRelationshipMemory()) ?? undefined;
+    }
+    catch {
+        // degrade silently; draft proceeds without relationship context
+    }
     if (deliveryResolution.verdict !== "target_available") {
-        const req = buildOutreachDraftRequest(candidate, judgment, snapshot, deliveryResolution);
+        const req = buildOutreachDraftRequest(candidate, judgment, snapshot, deliveryResolution, narrativeState, relationshipMemory);
         const draft = await guidance.draftOutreachMessage(req);
         const fb = await writeOperatorFallback(state, {
             reason: operatorReasonForUnavailable(deliveryResolution.verdict),
@@ -48,7 +67,7 @@ export async function dispatchUserOutreachIntent(input) {
             fallbackRef: fb.fallbackRef,
         };
     }
-    const req = buildOutreachDraftRequest(candidate, judgment, snapshot, deliveryResolution);
+    const req = buildOutreachDraftRequest(candidate, judgment, snapshot, deliveryResolution, narrativeState, relationshipMemory);
     const draft = await guidance.draftOutreachMessage(req);
     if (draft.status !== "ready") {
         return {

package/runtime/guidance/draft-outreach-message.js

@@ -3,9 +3,22 @@
  * Does not claim user-visible delivery when wordingMode is not_sent_fallback_candidate (T6.2.1 / ADR-004).
  */
 import { safeParseOutreachDraftRequest } from "./outreach-draft-schema.js";
+function buildContextSummary(r) {
+    const parts = [];
+    if (r.narrativeContext?.focus) {
+        parts.push(`what=${r.narrativeContext.focus}`);
+    }
+    if (r.relationshipContext?.tone) {
+        parts.push(`tone=${r.relationshipContext.tone}`);
+    }
+    if (r.relationshipContext?.topicAffinities && r.relationshipContext.topicAffinities.length > 0) {
+        parts.push(`interests=${r.relationshipContext.topicAffinities.join(",")}`);
+    }
+    return parts.length > 0 ? `;context=${parts.join(";")}` : "";
+}
 function baseDraftText(request) {
     const ids = request.sourceRefs.map((s) => s.id).join(",");
-    return `draft:${request.candidateId}:grounded:${ids}`;
+    return `draft:${request.candidateId}:grounded:${ids}${buildContextSummary(request)}`;
 }
 export async function draftOutreachMessage(request) {
     const parsed = safeParseOutreachDraftRequest(request);