@haaaiawd/second-nature 0.1.22 → 0.1.24

package/runtime/connectors/services/connector-executor-adapter.js

@@ -5,8 +5,10 @@ import { createConnectorPolicyLayer } from "../base/policy-layer.js";
 import { InMemoryEffectCommitLedger } from "../base/execution-policy.js";
 import { moltbookManifest } from "../social-community/moltbook/manifest.js";
 import { evomapManifest } from "../agent-network/evomap/manifest.js";
+import { agentWorldManifest } from "../agent-network/agent-world/manifest.js";
 import { createMoltbookApiClient } from "../social-community/moltbook/api-client.js";
 import { createMoltbookRunner } from "../social-community/moltbook/adapter.js";
+import { createAgentWorldRunner } from "../agent-network/agent-world/adapter.js";
 import { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
 import { createCredentialVault } from "../../storage/services/credential-vault.js";
 import { createCredentialRouteContextPort } from "./credential-route-context.js";
@@ -74,6 +76,52 @@ function createAdaptiveExecutionRunner(vault) {
                     },
                 };
             }
+            if (platformId === "agent-world") {
+                const baseUrl = process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL;
+                if (!baseUrl) {
+                    return {
+                        platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "configuration_missing",
+                            detail: "SECOND_NATURE_AGENT_WORLD_BASE_URL not set",
+                        },
+                    };
+                }
+                const runner = createAgentWorldRunner({
+                    apiClient: {
+                        async readFeed(payload, _apiKey) {
+                            const resp = await fetch(`${baseUrl}/api/v1/feed`, {
+                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                            });
+                            if (!resp.ok)
+                                throw { code: "api_error", detail: `agent-world feed: ${resp.status}` };
+                            return resp.json();
+                        },
+                        async discoverWork(payload, _apiKey) {
+                            const resp = await fetch(`${baseUrl}/api/v1/work`, {
+                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                            });
+                            if (!resp.ok)
+                                throw { code: "api_error", detail: `agent-world work: ${resp.status}` };
+                            return resp.json();
+                        },
+                        async claimTask(payload, _apiKey) {
+                            const resp = await fetch(`${baseUrl}/api/v1/tasks/${payload.taskId ?? "unknown"}/claim`, {
+                                method: "POST",
+                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                                body: JSON.stringify(payload),
+                            });
+                            if (!resp.ok)
+                                throw { code: "api_error", detail: `agent-world claim: ${resp.status}` };
+                            return resp.json();
+                        },
+                    },
+                });
+                return runner.run(_plan, request);
+            }
             return {
                 platformId,
                 channel: request.preferredChannel ?? "api_rest",
@@ -92,6 +140,7 @@ export function createConnectorExecutorAdapter(options) {
     const registry = new CapabilityContractRegistry();
     registry.register({ ...moltbookManifest });
     registry.register({ ...evomapManifest });
+    registry.register({ ...agentWorldManifest });
     const routeContextPort = createCredentialRouteContextPort(vault);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
     const telemetry = new ExecutionTelemetry(options.observabilityDb);

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 { NarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
 export interface HeartbeatDecisionTracePayload {
     scope: RuntimeScope;
     status: HeartbeatCycleStatus;
@@ -58,6 +59,8 @@ export interface HeartbeatDeps {
      * through the connector-system instead of returning connector_dispatch_unwired.
      */
     connectorExecutor?: ConnectorExecutor;
+    /** T2.1.5: when present, heartbeat writes a source-backed NarrativeState revision after each cycle. */
+    narrativeStateStore?: NarrativeStateStore;
 }
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.

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

@@ -1,11 +1,13 @@
 import { buildContinuitySnapshot, } from "./snapshot-builder.js";
 import { buildHeartbeatRuntimeSnapshot, } from "./runtime-snapshot.js";
 import { planCandidateIntents } from "../orchestrator/intent-planner.js";
+import { applyGoalPriority } from "../orchestrator/goal-priority.js";
 import { evaluateHardGuards } from "../orchestrator/guard-layer.js";
 import { dispatchUserOutreachIntent, } from "../outreach/dispatch-user-outreach.js";
 import { buildJudgeOutreachInputFromSnapshot } from "../outreach/judge-input-from-snapshot.js";
 import { runSourceBackedQuiet } from "../quiet/run-source-backed-quiet.js";
 import { toCapabilityIntent } from "../orchestrator/effect-dispatcher.js";
+import { updateNarrativeAfterEffect } from "../orchestrator/narrative-update.js";
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
@@ -83,6 +85,49 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
         reasons,
     };
 }
+/**
+ * T2.1.5: after the cycle result is known, write a narrative revision when
+ * a NarrativeStateStore is wired. Errors are swallowed so the cycle result
+ * 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) {
+    if (!store)
+        return;
+    try {
+        const prior = await store.loadNarrativeState();
+        const update = updateNarrativeAfterEffect({
+            result,
+            selectedIntent,
+            lifeEvidence: runtime.lifeEvidence,
+            priorNarrative: prior,
+        });
+        await store.updateNarrativeState(update);
+    }
+    catch {
+        // degrade silently; narrative update is best-effort
+        if (recordTrace && signal) {
+            try {
+                await recordTrace({
+                    scope: result.scope,
+                    status: result.status,
+                    reasons: ["narrative_update_failed"],
+                    selectedIntentId: selectedIntent?.id,
+                    rhythmWindowId: runtime.rhythmWindow.windowId,
+                    allowedIntentKinds: [...runtime.rhythmWindow.allowedIntentKinds],
+                    candidateCount: 0,
+                    lifeEvidenceEmpty: runtime.lifeEvidence.evidenceRefs.length === 0 &&
+                        runtime.lifeEvidence.platformEventCount === 0 &&
+                        runtime.lifeEvidence.workEventCount === 0,
+                    trigger: signal.trigger,
+                });
+            }
+            catch {
+                // trace emission must also not block the cycle
+            }
+        }
+    }
+}
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.
  */
@@ -91,7 +136,8 @@ export async function ingestRhythmSignal(signal, deps) {
     const snapshot = buildContinuitySnapshot(inputs);
     const timestamp = signal.payload.timestamp;
     const runtime = buildHeartbeatRuntimeSnapshot(timestamp, inputs, snapshot);
-    const candidates = planCandidateIntents(runtime);
+    const rawCandidates = planCandidateIntents(runtime);
+    const { candidates } = applyGoalPriority(rawCandidates, inputs.acceptedGoals);
     const emitTrace = async (result) => {
         if (!deps.recordDecisionTrace)
             return;
@@ -132,6 +178,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);
             return result;
         }
         if (evaluation.verdict === "defer") {
@@ -149,6 +196,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: ["silent_no_candidates"],
         };
         await emitTrace(result);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
         return result;
     }
     if (!anyAllow && anyDefer && !anyDeny) {
@@ -158,6 +206,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);
         return result;
     }
     if (!anyAllow && denyReasons.length > 0) {
@@ -167,6 +216,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: denyReasons,
         };
         await emitTrace(result);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
         return result;
     }
     const result = {
@@ -175,6 +225,7 @@ export async function ingestRhythmSignal(signal, deps) {
         reasons: ["no_allow_verdict"],
     };
     await emitTrace(result);
+    await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
     return result;
 }
 /**

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

@@ -10,6 +10,7 @@ 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";
 export interface SnapshotInputs {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -41,6 +42,8 @@ export interface SnapshotInputs {
     deliveryCapability?: DeliveryCapabilitySnapshot;
     /** 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[];
 }
 /**
  * Build a ContinuitySnapshot from loaded inputs.

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

@@ -0,0 +1,19 @@
+/**
+ * T2.1.4 — Goal-Directed Intent Priority.
+ *
+ * `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.
+ * 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";
+export interface ApplyGoalPriorityResult {
+    candidates: CandidateIntent[];
+    goalInfluences: Array<{
+        candidateId: string;
+        goalIds: string[];
+        boost: number;
+    }>;
+}
+export declare function applyGoalPriority(candidates: CandidateIntent[], goals: AgentGoal[] | undefined): ApplyGoalPriorityResult;

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

@@ -0,0 +1,67 @@
+/**
+ * Per-goal priority boost applied when an accepted goal matches a candidate.
+ *
+ * Rationale: +20 per goal keeps a priority-50 candidate under 200
+ * even with 7 matching goals (50 + 140 = 190). Planner baselines
+ * 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();
+    // Direct platformId mention in goal text
+    if (goalText.includes(platformId))
+        return true;
+    // 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))
+            return true;
+    }
+    return false;
+}
+export function applyGoalPriority(candidates, goals) {
+    const acceptedGoals = (goals ?? []).filter((g) => g.status === "accepted" && g.origin !== "agent_proposed");
+    if (acceptedGoals.length === 0) {
+        return {
+            candidates: candidates.map((c) => ({
+                ...c,
+                priorityReasons: c.priorityReasons ?? ["rhythm"],
+            })),
+            goalInfluences: [],
+        };
+    }
+    const influences = [];
+    const adjusted = candidates.map((candidate) => {
+        const relatedGoals = acceptedGoals.filter((g) => isGoalRelatedToCandidate(g, candidate));
+        if (relatedGoals.length === 0) {
+            return {
+                ...candidate,
+                priorityReasons: candidate.priorityReasons ?? ["rhythm"],
+            };
+        }
+        const boost = GOAL_PRIORITY_BOOST * relatedGoals.length;
+        const goalIds = relatedGoals.map((g) => g.goalId);
+        influences.push({
+            candidateId: candidate.id,
+            goalIds,
+            boost,
+        });
+        const reasons = [
+            ...(candidate.priorityReasons ?? ["rhythm"]),
+            ...relatedGoals.map((g) => `goal_boost:${g.goalId}`),
+        ];
+        return {
+            ...candidate,
+            priority: candidate.priority + boost,
+            goalInfluenceRefs: goalIds,
+            priorityReasons: reasons,
+        };
+    });
+    return {
+        candidates: adjusted.sort((a, b) => b.priority - a.priority),
+        goalInfluences: influences,
+    };
+}

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

@@ -34,6 +34,7 @@ function planWorkIntents(runtime) {
         effectClass: "connector_action",
         sourceRefs: [...OBLIGATION_SOURCE],
         idempotencyKey: `obligation:${obligation}:${index}`,
+        goalInfluenceRefs: [],
     }));
 }
 function planExplorationIntents(runtime) {
@@ -50,6 +51,7 @@ function planExplorationIntents(runtime) {
             effectClass: "connector_action",
             sourceRefs: refs,
             idempotencyKey: "exploration:scan platform opportunities",
+            goalInfluenceRefs: [],
         },
     ];
 }
@@ -67,6 +69,7 @@ function planSocialIntents(runtime) {
             effectClass: "connector_action",
             sourceRefs: refs,
             idempotencyKey: "social:engage social platforms",
+            goalInfluenceRefs: [],
         },
     ];
 }
@@ -85,6 +88,7 @@ function planQuietReflectionIntents(runtime) {
             effectClass: "no_effect",
             sourceRefs: [],
             idempotencyKey: "quiet:bookkeeping",
+            goalInfluenceRefs: [],
         });
     }
     if (isAllowedKind("maintenance", runtime)) {
@@ -97,6 +101,7 @@ function planQuietReflectionIntents(runtime) {
             effectClass: "maintenance",
             sourceRefs: [],
             idempotencyKey: "maintenance:checks",
+            goalInfluenceRefs: [],
         });
     }
     if (isAllowedKind("reflection", runtime)) {
@@ -110,6 +115,7 @@ function planQuietReflectionIntents(runtime) {
             effectClass: "narrative_reflection",
             sourceRefs: refs,
             idempotencyKey: "reflection:narrative",
+            goalInfluenceRefs: [],
         });
     }
     return out;
@@ -131,6 +137,7 @@ function planOutreachIntents(runtime) {
             effectClass: "user_outreach",
             sourceRefs: refs,
             idempotencyKey: "outreach:consider proactive user outreach",
+            goalInfluenceRefs: [],
         },
     ];
 }
@@ -149,6 +156,7 @@ export function planCandidateIntents(runtime) {
                 effectClass: "maintenance",
                 sourceRefs: [],
                 idempotencyKey: "maintenance:checks",
+                goalInfluenceRefs: [],
             },
         ];
         return pausedMaintenance

package/runtime/core/second-nature/orchestrator/narrative-update.d.ts

@@ -0,0 +1,27 @@
+/**
+ * T2.1.5 — NarrativeState update after heartbeat effect/fallback.
+ *
+ * Produces a source-backed narrative revision or an honest empty-state
+ * (`awaiting_sources` / `insufficient_sources`) based on the cycle result.
+ *
+ * Rules-only implementation; no live LLM.
+ */
+import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
+import type { CandidateIntent } from "../types.js";
+import type { PlannerLifeEvidenceSlice } from "../heartbeat/runtime-snapshot.js";
+import type { NarrativeState, NarrativeStateUpdate } from "../../../storage/narrative/narrative-state-store.js";
+export interface UpdateNarrativeAfterEffectInput {
+    result: HeartbeatCycleResult;
+    selectedIntent?: CandidateIntent;
+    lifeEvidence: PlannerLifeEvidenceSlice;
+    priorNarrative?: NarrativeState | null;
+}
+/**
+ * Build the next NarrativeState revision from a completed heartbeat cycle.
+ *
+ * - `intent_selected` + sources → `active`, focus/progress updated.
+ * - `intent_selected` without sources → `awaiting_sources`, claim recorded as unsupported.
+ * - No action (heartbeat_ok / denied / deferred / etc.) → preserve prior state or
+ *   seed an empty `awaiting_sources` state when no prior exists.
+ */
+export declare function updateNarrativeAfterEffect(input: UpdateNarrativeAfterEffectInput): NarrativeStateUpdate;

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

@@ -0,0 +1,107 @@
+const MAX_PROGRESS_ENTRIES = 10;
+const DEFAULT_NARRATIVE_ID = "default";
+function mapControlPlaneRefToSourceRef(ref) {
+    return {
+        sourceId: ref.id,
+        kind: ref.kind,
+        url: ref.uri,
+        snippet: ref.excerptHash,
+    };
+}
+/**
+ * Compute narrative confidence based on source evidence.
+ *
+ * Formula: min(intentSources / 3, 1) + (lifeEvidenceSources > 0 ? 0.1 : 0)
+ *
+ * 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%)
+ */
+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);
+}
+/**
+ * Build the next NarrativeState revision from a completed heartbeat cycle.
+ *
+ * - `intent_selected` + sources → `active`, focus/progress updated.
+ * - `intent_selected` without sources → `awaiting_sources`, claim recorded as unsupported.
+ * - No action (heartbeat_ok / denied / deferred / etc.) → preserve prior state or
+ *   seed an empty `awaiting_sources` state when no prior exists.
+ */
+export function updateNarrativeAfterEffect(input) {
+    const { result, selectedIntent, lifeEvidence, priorNarrative } = input;
+    const now = new Date().toISOString();
+    const prior = priorNarrative ?? null;
+    const narrativeId = prior?.narrativeId ?? DEFAULT_NARRATIVE_ID;
+    const nextRevision = (prior?.revision ?? 0) + 1;
+    // --- intent_selected branch ------------------------------------------------
+    if (result.status === "intent_selected" && selectedIntent) {
+        const hasIntentSources = selectedIntent.sourceRefs.length > 0;
+        const hasLifeEvidence = !(lifeEvidence.evidenceRefs.length === 0 &&
+            lifeEvidence.platformEventCount === 0 &&
+            lifeEvidence.workEventCount === 0);
+        const sourceRefs = selectedIntent.sourceRefs.map(mapControlPlaneRefToSourceRef);
+        if (hasIntentSources || hasLifeEvidence) {
+            // Source-backed revision
+            const progressEntry = `${selectedIntent.effectClass}: ${selectedIntent.summary}`;
+            const progress = [...(prior?.progress ?? [])];
+            if (!progress.includes(progressEntry)) {
+                progress.push(progressEntry);
+            }
+            const boundedProgress = progress.slice(-MAX_PROGRESS_ENTRIES);
+            return {
+                narrativeId,
+                revision: nextRevision,
+                focus: selectedIntent.summary,
+                progress: boundedProgress,
+                nextIntent: "continue",
+                confidence: computeConfidence(selectedIntent.sourceRefs.length, lifeEvidence.evidenceRefs.length),
+                sourceRefs,
+                unsupportedClaims: [],
+                status: "active",
+                updatedAt: now,
+            };
+        }
+        // No sources → awaiting_sources
+        return {
+            narrativeId,
+            revision: nextRevision,
+            focus: prior?.focus ?? "awaiting_evidence",
+            progress: prior?.progress ?? [],
+            nextIntent: "await_sources",
+            confidence: 0,
+            sourceRefs: [],
+            unsupportedClaims: [selectedIntent.summary],
+            status: "awaiting_sources",
+            updatedAt: now,
+        };
+    }
+    // --- No action / fallback branches -----------------------------------------
+    if (prior) {
+        // Preserve existing state, bump revision and timestamp so observers
+        // know the heartbeat cycle ran even when no intent was selected.
+        return {
+            ...prior,
+            revision: nextRevision,
+            updatedAt: now,
+        };
+    }
+    // No prior state and no action → seed empty awaiting_sources state
+    return {
+        narrativeId,
+        revision: nextRevision,
+        focus: "awaiting_evidence",
+        progress: [],
+        nextIntent: "await_sources",
+        confidence: 0,
+        sourceRefs: [],
+        unsupportedClaims: [],
+        status: "awaiting_sources",
+        updatedAt: now,
+    };
+}

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

@@ -41,6 +41,10 @@ export interface CandidateIntent {
     sourceRefs: ControlPlaneSourceRef[];
     /** Dedupe / cooldown key; defaults to stable fingerprint in guard layer when omitted. */
     idempotencyKey?: string;
+    /** T2.1.4: IDs of accepted AgentGoals that influenced this candidate's priority. */
+    goalInfluenceRefs?: string[];
+    /** T2.1.4: Human-readable reasons for the priority value (goal influence, user task, rhythm). */
+    priorityReasons?: string[];
 }
 export interface GuardEvaluation {
     verdict: GuardVerdict;

package/runtime/guidance/draft-narrative-outreach.d.ts

@@ -0,0 +1,36 @@
+/**
+ * T6.1.1 — Narrative Outreach Draft generator.
+ *
+ * Produces source-backed outreach drafts from evidence + narrative + relationship.
+ * Rules-only implementation (no live LLM); honors grounding, redaction, and insufficient_history.
+ *
+ * NOTE: This function assumes narrativeState.focus / nextIntent and
+ * relationshipMemory fields are pre-redacted by upstream state-system.
+ * No additional PII filtering is applied here — defense-in-depth is
+ * the responsibility of the NarrativeState / RelationshipMemory stores.
+ */
+import type { NarrativeState, SourceRef } from "../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../storage/relationship/relationship-memory-store.js";
+export interface NarrativeOutreachDraftRequest {
+    evidenceRefs: SourceRef[];
+    narrativeState?: NarrativeState;
+    relationshipMemory?: RelationshipMemory;
+    platformId?: string;
+}
+export interface GroundingReport {
+    status: "grounded" | "degraded" | "blocked";
+    sourceCoverage: number;
+    unsupportedClaims: string[];
+    reason: string;
+}
+export interface NarrativeOutreachDraftResult {
+    draft: {
+        whatHappened: string;
+        whyItMatters: string;
+        sourceRefs: SourceRef[];
+        tone: "friend" | "insufficient_history" | "blocked";
+    };
+    groundingReport: GroundingReport;
+    promptVersion: string;
+}
+export declare function draftNarrativeOutreach(request: NarrativeOutreachDraftRequest): NarrativeOutreachDraftResult;

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

@@ -0,0 +1,84 @@
+function computeSourceCoverage(claims, _evidenceRefs, narrativeSourceRefs) {
+    if (claims.length === 0)
+        return { coverage: 1, unsupported: [] };
+    // Only narrative-level source refs count toward coverage.
+    const count = narrativeSourceRefs?.length ?? 0;
+    const coverage = Math.min(count / claims.length, 1);
+    return {
+        coverage,
+        unsupported: coverage >= 1 ? [] : claims,
+    };
+}
+export function draftNarrativeOutreach(request) {
+    const { evidenceRefs, narrativeState, relationshipMemory, platformId } = request;
+    // T6.1.1 — Block when source refs are missing
+    if (!evidenceRefs || evidenceRefs.length === 0) {
+        return {
+            draft: {
+                whatHappened: "",
+                whyItMatters: "",
+                sourceRefs: [],
+                tone: "blocked",
+            },
+            groundingReport: {
+                status: "blocked",
+                sourceCoverage: 0,
+                unsupportedClaims: ["missing_evidence_refs"],
+                reason: "no_source_refs_provided",
+            },
+            promptVersion: "v6-rules-only-1.0",
+        };
+    }
+    // Build claims from narrative state
+    const claims = [];
+    if (narrativeState?.focus) {
+        claims.push(narrativeState.focus);
+    }
+    if (narrativeState?.progress && narrativeState.progress.length > 0) {
+        claims.push(...narrativeState.progress);
+    }
+    const { coverage, unsupported } = computeSourceCoverage(claims, evidenceRefs, narrativeState?.sourceRefs);
+    // T6.1.1 — Degrade when source coverage is low
+    if (coverage < 0.5) {
+        return {
+            draft: {
+                whatHappened: narrativeState?.focus ?? "",
+                whyItMatters: "",
+                sourceRefs: evidenceRefs,
+                tone: "insufficient_history",
+            },
+            groundingReport: {
+                status: "degraded",
+                sourceCoverage: coverage,
+                unsupportedClaims: unsupported,
+                reason: "insufficient_source_coverage",
+            },
+            promptVersion: "v6-rules-only-1.0",
+        };
+    }
+    // T6.1.1 — insufficient_history tone when relationship is weak
+    const avgAffinity = relationshipMemory && relationshipMemory.topicAffinities.length > 0
+        ? relationshipMemory.topicAffinities.reduce((s, t) => s + t.affinity, 0) /
+            relationshipMemory.topicAffinities.length
+        : 0;
+    const tone = avgAffinity < 0.3 ? "insufficient_history" : "friend";
+    const whatHappened = narrativeState?.focus ?? "Recent activity observed.";
+    const whyItMatters = narrativeState?.nextIntent
+        ? `This relates to the current focus: ${narrativeState.nextIntent}.`
+        : "This may be relevant to your interests.";
+    return {
+        draft: {
+            whatHappened,
+            whyItMatters,
+            sourceRefs: evidenceRefs,
+            tone,
+        },
+        groundingReport: {
+            status: "grounded",
+            sourceCoverage: coverage,
+            unsupportedClaims: unsupported,
+            reason: "source_backed",
+        },
+        promptVersion: "v6-rules-only-1.0",
+    };
+}

package/runtime/guidance/index.d.ts

@@ -9,3 +9,4 @@ export * from "./guidance-assembler.js";
 export * from "./outreach-draft-schema.js";
 export * from "./draft-outreach-message.js";
 export * from "./evidence-guidance.js";
+export * from "./draft-narrative-outreach.js";

package/runtime/guidance/index.js

@@ -9,3 +9,4 @@ export * from "./guidance-assembler.js";
 export * from "./outreach-draft-schema.js";
 export * from "./draft-outreach-message.js";
 export * from "./evidence-guidance.js";
+export * from "./draft-narrative-outreach.js";