@haaaiawd/second-nature 0.1.23 → 0.1.25

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

@@ -21,6 +21,7 @@ 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";
+import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
 export interface HeartbeatDecisionTracePayload {
     scope: RuntimeScope;
     status: HeartbeatCycleStatus;
@@ -61,6 +62,8 @@ 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>;
 }
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.

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

@@ -91,7 +91,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 +103,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
@@ -178,7 +205,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 +223,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 +233,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 +243,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 +252,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/orchestrator/goal-priority.d.ts

@@ -3,7 +3,8 @@
  *
  * `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";

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

@@ -7,14 +7,14 @@
  */
 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
+    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/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);

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

@@ -97,6 +97,46 @@ export declare const sceneGuidanceRequestSchema: z.ZodObject<{
         "zh-CN": "zh-CN";
     }>>;
 }, z.core.$strip>;
+export declare const outreachNarrativeContextSchema: z.ZodObject<{
+    focus: z.ZodOptional<z.ZodString>;
+    progress: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nextIntent: z.ZodOptional<z.ZodString>;
+    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            platform_item: "platform_item";
+            workspace_artifact: "workspace_artifact";
+            decision_record: "decision_record";
+            user_anchor: "user_anchor";
+            connector_result: "connector_result";
+            host_report: "host_report";
+            fallback_artifact: "fallback_artifact";
+        }>;
+        uri: z.ZodString;
+        excerptHash: z.ZodOptional<z.ZodString>;
+        observedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const outreachRelationshipContextSchema: z.ZodObject<{
+    tone: z.ZodOptional<z.ZodString>;
+    topicAffinities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    avgAffinity: z.ZodOptional<z.ZodNumber>;
+    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            platform_item: "platform_item";
+            workspace_artifact: "workspace_artifact";
+            decision_record: "decision_record";
+            user_anchor: "user_anchor";
+            connector_result: "connector_result";
+            host_report: "host_report";
+            fallback_artifact: "fallback_artifact";
+        }>;
+        uri: z.ZodString;
+        excerptHash: z.ZodOptional<z.ZodString>;
+        observedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export declare const outreachDraftRequestSchema: z.ZodObject<{
     requestId: z.ZodString;
     runtimeScope: z.ZodEnum<{
@@ -177,6 +217,46 @@ export declare const outreachDraftRequestSchema: z.ZodObject<{
         excerptHash: z.ZodOptional<z.ZodString>;
         observedAt: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    narrativeContext: z.ZodOptional<z.ZodObject<{
+        focus: z.ZodOptional<z.ZodString>;
+        progress: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        nextIntent: z.ZodOptional<z.ZodString>;
+        sourceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                platform_item: "platform_item";
+                workspace_artifact: "workspace_artifact";
+                decision_record: "decision_record";
+                user_anchor: "user_anchor";
+                connector_result: "connector_result";
+                host_report: "host_report";
+                fallback_artifact: "fallback_artifact";
+            }>;
+            uri: z.ZodString;
+            excerptHash: z.ZodOptional<z.ZodString>;
+            observedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    relationshipContext: z.ZodOptional<z.ZodObject<{
+        tone: z.ZodOptional<z.ZodString>;
+        topicAffinities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        avgAffinity: z.ZodOptional<z.ZodNumber>;
+        sourceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                platform_item: "platform_item";
+                workspace_artifact: "workspace_artifact";
+                decision_record: "decision_record";
+                user_anchor: "user_anchor";
+                connector_result: "connector_result";
+                host_report: "host_report";
+                fallback_artifact: "fallback_artifact";
+            }>;
+            uri: z.ZodString;
+            excerptHash: z.ZodOptional<z.ZodString>;
+            observedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SceneGuidanceRequest = z.infer<typeof sceneGuidanceRequestSchema>;
 export type OutreachDraftRequest = z.infer<typeof outreachDraftRequestSchema>;
@@ -212,6 +292,30 @@ export declare function safeParseOutreachDraftRequest(input: unknown): z.ZodSafe
         fallbackRef?: string | undefined;
     } | undefined;
     language?: "en-US" | "zh-CN" | undefined;
+    narrativeContext?: {
+        focus?: string | undefined;
+        progress?: string[] | undefined;
+        nextIntent?: string | undefined;
+        sourceRefs?: {
+            id: string;
+            kind: "platform_item" | "workspace_artifact" | "decision_record" | "user_anchor" | "connector_result" | "host_report" | "fallback_artifact";
+            uri: string;
+            excerptHash?: string | undefined;
+            observedAt?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    relationshipContext?: {
+        tone?: string | undefined;
+        topicAffinities?: string[] | undefined;
+        avgAffinity?: number | undefined;
+        sourceRefs?: {
+            id: string;
+            kind: "platform_item" | "workspace_artifact" | "decision_record" | "user_anchor" | "connector_result" | "host_report" | "fallback_artifact";
+            uri: string;
+            excerptHash?: string | undefined;
+            observedAt?: string | undefined;
+        }[] | undefined;
+    } | undefined;
 }>;
 /** Async seam for generative outreach copy (implementation lives outside control-plane). */
 export interface GuidanceDraftPort {

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

@@ -54,6 +54,18 @@ export const sceneGuidanceRequestSchema = z.object({
     deliveryContext: deliveryExpressionContextSchema.optional(),
     language: z.enum(["zh-CN", "en-US"]).optional(),
 });
+export const outreachNarrativeContextSchema = z.object({
+    focus: z.string().optional(),
+    progress: z.array(z.string()).optional(),
+    nextIntent: z.string().optional(),
+    sourceRefs: z.array(guidanceSourceRefSchema).optional(),
+});
+export const outreachRelationshipContextSchema = z.object({
+    tone: z.string().optional(),
+    topicAffinities: z.array(z.string()).optional(),
+    avgAffinity: z.number().optional(),
+    sourceRefs: z.array(guidanceSourceRefSchema).optional(),
+});
 export const outreachDraftRequestSchema = sceneGuidanceRequestSchema
     .extend({
     sceneType: z.enum(["outreach", "fallback_candidate"]),
@@ -62,6 +74,8 @@ export const outreachDraftRequestSchema = sceneGuidanceRequestSchema
     judgmentVerdict: z.enum(["allow", "deny", "defer"]),
     valueScore: z.number(),
     interestRefs: z.array(guidanceSourceRefSchema),
+    narrativeContext: outreachNarrativeContextSchema.optional(),
+    relationshipContext: outreachRelationshipContextSchema.optional(),
 })
     .superRefine((val, ctx) => {
     if (!val.deliveryContext) {

package/runtime/observability/audit/audit-envelope.d.ts

@@ -1,6 +1,6 @@
 import { type RedactionManifest as FieldRedactionManifest } from "../redaction/manifest.js";
 export type AuditPlane = "decision" | "delivery" | "source_coverage" | "governance" | "telemetry";
-export type AuditEventFamily = "heartbeat.decision" | "delivery" | "source_coverage" | "guidance.grounding" | "host_capability" | "connector.attempt" | "state.governance";
+export type AuditEventFamily = "heartbeat.decision" | "delivery" | "source_coverage" | "guidance.grounding" | "host_capability" | "connector.attempt" | "state.governance" | "narrative.trace" | "dream.trace";
 export type AuditEnvelopeSensitivity = "public" | "internal" | "private" | "credential" | "sensitive";
 export interface AuditRedactionManifest {
     manifestId: string;

package/runtime/observability/services/lived-experience-audit.d.ts

@@ -1,5 +1,6 @@
 import { AppendOnlyAuditStore } from "../audit/append-only-audit-store.js";
 import type { SourceRef } from "../../storage/life-evidence/types.js";
+import type { DreamTrace } from "../../dream/types.js";
 export type RuntimeScope = "rhythm" | "user_task" | "user_reply";
 export type HeartbeatOutcome = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
 export type DeliveryAuditStatus = "not_requested" | "target_available" | "target_none" | "channel_missing" | "host_unsupported" | "ack_dropped" | "sent" | "failed" | "not_sent_fallback";
@@ -66,6 +67,21 @@ export interface GuidanceGroundingAuditPayload {
     deliveryWording?: "sendable" | "not_sent_fallback_candidate";
     createdAt: string;
 }
+export interface NarrativeTracePayload {
+    traceId: string;
+    narrativeId: string;
+    revision: number;
+    updateSource: "heartbeat" | "dream" | "owner" | "maintenance";
+    sourceRefs: Array<{
+        id: string;
+        kind: string;
+        uri?: string;
+    }>;
+    unsupportedClaims: string[];
+    groundingStatus: GroundingStatus;
+    goalInfluenceRefs: string[];
+    createdAt: string;
+}
 export interface ExplainLinkageSummary {
     decisionId: string;
     summary: string;
@@ -92,6 +108,12 @@ export declare class LivedExperienceAuditRecorder {
     recordGuidanceGrounding(payload: GuidanceGroundingAuditPayload): {
         eventId: string;
     };
+    recordNarrativeTrace(payload: NarrativeTracePayload): {
+        eventId: string;
+    };
+    recordDreamTrace(payload: DreamTrace): {
+        eventId: string;
+    };
     explainLinkageForDecision(decisionId: string): ExplainLinkageSummary;
 }
 export declare function createLivedExperienceAuditRecorder(store?: AppendOnlyAuditStore): LivedExperienceAuditRecorder;

package/runtime/observability/services/lived-experience-audit.js

@@ -133,6 +133,36 @@ export class LivedExperienceAuditRecorder {
         }
         return { eventId: envelope.eventId };
     }
+    recordNarrativeTrace(payload) {
+        const seq = this.bumpSequence();
+        const envelope = buildAuditEnvelope({
+            family: "narrative.trace",
+            plane: "source_coverage",
+            traceId: payload.traceId,
+            sequence: seq,
+            payload,
+            previousHash: this.store.lastRecordHash(),
+            eventId: crypto.randomUUID(),
+            createdAt: payload.createdAt,
+        });
+        this.store.append(envelope);
+        return { eventId: envelope.eventId };
+    }
+    recordDreamTrace(payload) {
+        const seq = this.bumpSequence();
+        const envelope = buildAuditEnvelope({
+            family: "dream.trace",
+            plane: "telemetry",
+            traceId: payload.traceId,
+            sequence: seq,
+            payload,
+            previousHash: this.store.lastRecordHash(),
+            eventId: crypto.randomUUID(),
+            createdAt: payload.finishedAt,
+        });
+        this.store.append(envelope);
+        return { eventId: envelope.eventId };
+    }
     explainLinkageForDecision(decisionId) {
         const entry = this.explainIndex.get(decisionId);
         const warnings = [];

package/runtime/storage/db/schema/narrative-state.d.ts

@@ -99,7 +99,7 @@ export declare const narrativeState: import("drizzle-orm/sqlite-core").SQLiteTab
             name: "confidence";
             tableName: "narrative_state";
             dataType: "number";
-            columnType: "SQLiteInteger";
+            columnType: "SQLiteReal";
             data: number;
             driverParam: number;
             notNull: true;

package/runtime/storage/db/schema/narrative-state.js

@@ -1,11 +1,11 @@
-import { index, sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+import { index, sqliteTable, text, integer, real } from "drizzle-orm/sqlite-core";
 export const narrativeState = sqliteTable("narrative_state", {
     narrativeId: text("narrative_id").primaryKey(),
     revision: integer("revision").notNull().default(1),
     focus: text("focus").notNull(),
     progressJson: text("progress_json").notNull(),
     nextIntent: text("next_intent").notNull(),
-    confidence: integer("confidence").notNull().default(0),
+    confidence: real("confidence").notNull().default(0),
     sourceRefsJson: text("source_refs_json").notNull(),
     unsupportedClaimsJson: text("unsupported_claims_json").notNull(),
     status: text("status").notNull(),

package/workspace-ops-bridge.js

@@ -47,6 +47,7 @@ export async function openWorkspaceOpsBridge(workspaceRoot) {
             state: stateDb,
             workspaceRoot: resolvedRoot,
             connectorExecutor: deps.connectorExecutor,
+            registry: deps.registry,
         });
         const commands = commandsMod.createCliCommands({
             readModels: deps.readModels,