@haaaiawd/second-nature 0.1.8 → 0.1.10

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

@@ -0,0 +1,63 @@
+/**
+ * Maps control-plane judgment + delivery resolution into guidance OutreachDraftRequest (T6.2.1).
+ * Aligns with control-plane-system.detail §3.9 buildOutreachDraftRequest.
+ */
+import * as crypto from "node:crypto";
+function inferRhythmWindowKind(windowId) {
+    const id = windowId.toLowerCase();
+    if (id.includes("work"))
+        return "work";
+    if (id.includes("social"))
+        return "social";
+    if (id.includes("quiet"))
+        return "quiet";
+    if (id.includes("reflect"))
+        return "reflection";
+    if (id.includes("explore"))
+        return "exploration";
+    return undefined;
+}
+function toGuidanceRefs(refs) {
+    return refs.map((r) => ({
+        id: r.id,
+        kind: r.kind,
+        uri: r.uri,
+        excerptHash: r.excerptHash,
+        observedAt: r.observedAt,
+    }));
+}
+function mapDeliveryVerdict(verdict) {
+    switch (verdict) {
+        case "target_available":
+            return "target_available";
+        case "target_none":
+            return "target_none";
+        case "channel_missing":
+            return "channel_missing";
+        case "host_unsupported":
+            return "host_unsupported";
+        default:
+            return "host_unsupported";
+    }
+}
+export function buildOutreachDraftRequest(candidate, judgment, snapshot, delivery) {
+    const sceneType = delivery.verdict === "target_available" ? "outreach" : "fallback_candidate";
+    const riskLevel = delivery.verdict === "target_available" ? "medium" : "low";
+    return {
+        requestId: `outreach_draft_request:${crypto.randomUUID()}`,
+        sceneType,
+        runtimeScope: "rhythm",
+        rhythmWindowKind: inferRhythmWindowKind(snapshot.rhythmWindow.windowId),
+        riskLevel,
+        sourceRefs: toGuidanceRefs(judgment.sourceRefs),
+        decisionId: judgment.decisionId,
+        candidateId: candidate.id,
+        judgmentVerdict: judgment.verdict,
+        valueScore: judgment.valueScore,
+        interestRefs: toGuidanceRefs(judgment.interestRefs),
+        deliveryContext: {
+            deliveryVerdict: mapDeliveryVerdict(delivery.verdict),
+            wordingMode: delivery.verdict === "target_available" ? "sendable" : "not_sent_fallback_candidate",
+        },
+    };
+}

package/runtime/core/second-nature/outreach/delivery-target.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Resolves OpenClaw-visible delivery target from host capability snapshot (T2.3.1 / ADR-007).
+ *
+ * Core logic: explicit/last targets require channel materialization; `none` is a first-class verdict.
+ * Test coverage: tests/unit/core/outreach-judgment.test.ts
+ */
+export type DeliveryHostTarget = "none" | "last" | "explicit";
+export interface DeliveryCapabilitySnapshot {
+    /** Raw host value; may be empty string before normalization. */
+    target?: DeliveryHostTarget | string | null;
+    channel?: string | null;
+    recipient?: string | null;
+    lastKnownVisibleChannel?: string | null;
+    /** When true, host reports unsupported delivery surface (maps to host_unsupported verdict). */
+    hostUnsupported?: boolean;
+}
+export type DeliveryTargetVerdict = "target_none" | "channel_missing" | "target_available" | "host_unsupported";
+export interface DeliveryTargetResolution {
+    verdict: DeliveryTargetVerdict;
+    target?: DeliveryHostTarget;
+    channel?: string;
+    recipient?: string;
+    reason: string;
+}
+export declare function resolveDeliveryTarget(snapshot: DeliveryCapabilitySnapshot): DeliveryTargetResolution;
+export declare function isDeliveryUnavailableReason(reason: string): boolean;

package/runtime/core/second-nature/outreach/delivery-target.js

@@ -0,0 +1,70 @@
+/**
+ * Resolves OpenClaw-visible delivery target from host capability snapshot (T2.3.1 / ADR-007).
+ *
+ * Core logic: explicit/last targets require channel materialization; `none` is a first-class verdict.
+ * Test coverage: tests/unit/core/outreach-judgment.test.ts
+ */
+export function resolveDeliveryTarget(snapshot) {
+    if (snapshot.hostUnsupported) {
+        return {
+            verdict: "host_unsupported",
+            target: snapshot.target && String(snapshot.target).trim() !== "" && snapshot.target !== "none"
+                ? snapshot.target
+                : "none",
+            reason: "host_delivery_surface_unsupported",
+        };
+    }
+    const raw = snapshot.target;
+    if (raw === undefined || raw === null || String(raw).trim() === "" || raw === "none") {
+        return {
+            verdict: "target_none",
+            target: "none",
+            reason: "heartbeat_run_without_user_visible_delivery",
+        };
+    }
+    if (raw === "explicit") {
+        const ch = (snapshot.channel ?? "").trim();
+        const rec = (snapshot.recipient ?? "").trim();
+        if (!ch || !rec) {
+            return {
+                verdict: "channel_missing",
+                target: "explicit",
+                reason: "explicit_delivery_requires_channel_and_recipient",
+            };
+        }
+        return {
+            verdict: "target_available",
+            target: "explicit",
+            channel: ch,
+            recipient: rec,
+            reason: "delivery_target_available",
+        };
+    }
+    if (raw === "last") {
+        const lastCh = (snapshot.lastKnownVisibleChannel ?? "").trim();
+        if (!lastCh) {
+            return {
+                verdict: "channel_missing",
+                target: "last",
+                reason: "last_target_has_no_known_visible_channel",
+            };
+        }
+        return {
+            verdict: "target_available",
+            target: "last",
+            channel: lastCh,
+            recipient: snapshot.recipient?.trim() || undefined,
+            reason: "delivery_target_available",
+        };
+    }
+    return {
+        verdict: "target_available",
+        target: raw,
+        channel: snapshot.channel?.trim() || snapshot.lastKnownVisibleChannel?.trim() || undefined,
+        recipient: snapshot.recipient?.trim() || undefined,
+        reason: "delivery_target_available",
+    };
+}
+export function isDeliveryUnavailableReason(reason) {
+    return reason === "target_none" || reason === "channel_missing" || reason === "host_unsupported";
+}

package/runtime/core/second-nature/outreach/dispatch-user-outreach.d.ts

@@ -0,0 +1,38 @@
+/**
+ * User outreach dispatch path: judgment → draft → host delivery → attempt + operator fallback (T2.3.2).
+ * Mirrors control-plane-system.detail §3.9 dispatchAllowedIntent user_outreach branch.
+ */
+import type { GuidanceDraftPort } from "../../../guidance/outreach-draft-schema.js";
+import type { CandidateIntent } from "../types.js";
+import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { SourceRef } from "../../../storage/life-evidence/types.js";
+import { type JudgeOutreachInput } from "./judge-outreach.js";
+import { type DeliveryTargetResolution } from "./delivery-target.js";
+export interface OpenClawDeliverySendResult {
+    id: string;
+    status: "sent" | "failed" | "dropped_by_host_policy";
+    errorClass?: string;
+    messageId?: string;
+    /** Host-reported delivery proof when messageId is absent (T4.3.1). */
+    hostProofRef?: SourceRef;
+}
+export interface OpenClawDeliveryPort {
+    sendDeliveryRequest(input: {
+        decisionId: string;
+        target: NonNullable<DeliveryTargetResolution["target"]>;
+        channel: string;
+        recipient?: string;
+        message: string;
+        sourceRefs: CandidateIntent["sourceRefs"];
+    }): Promise<OpenClawDeliverySendResult>;
+}
+export declare function dispatchUserOutreachIntent(input: {
+    candidate: CandidateIntent;
+    snapshot: HeartbeatRuntimeSnapshot;
+    judgeInput: Omit<JudgeOutreachInput, "candidate">;
+    guidance: GuidanceDraftPort;
+    delivery: OpenClawDeliveryPort;
+    state: StateDatabase;
+}): Promise<HeartbeatCycleResult>;

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

@@ -0,0 +1,119 @@
+import { writeDeliveryAttempt } from "../../../storage/delivery/write-delivery-attempt.js";
+import { writeOperatorFallback } from "../../../storage/fallback/write-operator-fallback.js";
+import { judgeOutreach } from "./judge-outreach.js";
+import { resolveDeliveryTarget } from "./delivery-target.js";
+import { buildOutreachDraftRequest } from "./build-outreach-draft-request.js";
+function toSourceRefs(refs) {
+    return refs.map((r) => ({ ...r }));
+}
+function hasDeliveryProof(attempt) {
+    return Boolean(attempt.messageId?.trim()) || Boolean(attempt.hostProofRef);
+}
+function operatorReasonForUnavailable(verdict) {
+    if (verdict === "target_none")
+        return "target_none";
+    if (verdict === "channel_missing")
+        return "channel_missing";
+    return "host_unsupported";
+}
+export async function dispatchUserOutreachIntent(input) {
+    const { candidate, snapshot, judgeInput, guidance, delivery, state } = input;
+    const judgment = judgeOutreach({ ...judgeInput, candidate });
+    if (judgment.verdict !== "allow") {
+        return {
+            scope: "rhythm",
+            status: judgment.verdict === "defer" ? "deferred" : "denied",
+            selectedIntentId: candidate.id,
+            reasons: judgment.reasons,
+            decisionId: judgment.decisionId,
+        };
+    }
+    const deliveryResolution = resolveDeliveryTarget(judgeInput.delivery);
+    if (deliveryResolution.verdict !== "target_available") {
+        const req = buildOutreachDraftRequest(candidate, judgment, snapshot, deliveryResolution);
+        const draft = await guidance.draftOutreachMessage(req);
+        const fb = await writeOperatorFallback(state, {
+            reason: operatorReasonForUnavailable(deliveryResolution.verdict),
+            decisionId: judgment.decisionId,
+            sourceRefs: toSourceRefs(judgment.sourceRefs),
+            candidateMessage: draft.status === "ready" ? draft.draft.text : undefined,
+            nextStep: "resolve_delivery_target_or_retry_after_host_update",
+        });
+        return {
+            scope: "rhythm",
+            status: "delivery_unavailable",
+            selectedIntentId: candidate.id,
+            reasons: [deliveryResolution.reason],
+            decisionId: judgment.decisionId,
+            fallbackRef: fb.fallbackRef,
+        };
+    }
+    const req = buildOutreachDraftRequest(candidate, judgment, snapshot, deliveryResolution);
+    const draft = await guidance.draftOutreachMessage(req);
+    if (draft.status !== "ready") {
+        return {
+            scope: "rhythm",
+            status: "denied",
+            selectedIntentId: candidate.id,
+            reasons: draft.reasons,
+            decisionId: judgment.decisionId,
+        };
+    }
+    const attempt = await delivery.sendDeliveryRequest({
+        decisionId: judgment.decisionId,
+        target: deliveryResolution.target,
+        channel: deliveryResolution.channel,
+        recipient: deliveryResolution.recipient,
+        message: draft.draft.text,
+        sourceRefs: judgment.sourceRefs,
+    });
+    if (attempt.status !== "sent" || !hasDeliveryProof(attempt)) {
+        const fb = await writeOperatorFallback(state, {
+            reason: "delivery_failed",
+            decisionId: judgment.decisionId,
+            sourceRefs: toSourceRefs(judgment.sourceRefs),
+            candidateMessage: draft.draft.text,
+            nextStep: "review_delivery_audit_and_host_capability",
+        });
+        const hostReportedSentWithoutProof = attempt.status === "sent" && !hasDeliveryProof(attempt);
+        await writeDeliveryAttempt(state, {
+            attemptId: attempt.id,
+            decisionId: judgment.decisionId,
+            target: deliveryResolution.target,
+            channel: deliveryResolution.channel,
+            status: attempt.status === "dropped_by_host_policy" ? "dropped_by_host_policy" : "failed",
+            errorClass: hostReportedSentWithoutProof
+                ? "delivery_proof_missing"
+                : attempt.errorClass ?? attempt.status,
+            fallbackRef: fb.fallbackRef,
+        });
+        return {
+            scope: "rhythm",
+            status: "delivery_unavailable",
+            selectedIntentId: candidate.id,
+            reasons: hostReportedSentWithoutProof
+                ? ["delivery_failed", "delivery_proof_missing"]
+                : ["delivery_failed", attempt.status],
+            decisionId: judgment.decisionId,
+            deliveryAttemptId: attempt.id,
+            fallbackRef: fb.fallbackRef,
+        };
+    }
+    await writeDeliveryAttempt(state, {
+        attemptId: attempt.id,
+        decisionId: judgment.decisionId,
+        target: deliveryResolution.target,
+        channel: deliveryResolution.channel,
+        status: "sent",
+        messageId: attempt.messageId?.trim(),
+        hostProofRef: attempt.hostProofRef,
+    });
+    return {
+        scope: "rhythm",
+        status: "intent_selected",
+        selectedIntentId: candidate.id,
+        reasons: ["outreach_sent"],
+        decisionId: judgment.decisionId,
+        deliveryAttemptId: attempt.id,
+    };
+}

package/runtime/core/second-nature/outreach/judge-input-from-snapshot.d.ts

@@ -0,0 +1,7 @@
+import type { SnapshotInputs } from "../heartbeat/snapshot-builder.js";
+import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import type { CandidateIntent } from "../types.js";
+import type { JudgeOutreachInput, JudgeOutreachUserInterest } from "./judge-outreach.js";
+import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
+export declare function userInterestSnapshotToJudge(snapshot?: UserInterestSnapshot): JudgeOutreachUserInterest;
+export declare function buildJudgeOutreachInputFromSnapshot(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs): Omit<JudgeOutreachInput, "candidate">;

package/runtime/core/second-nature/outreach/judge-input-from-snapshot.js

@@ -0,0 +1,45 @@
+import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
+function toControlPlaneRefs(refs) {
+    return refs.map((r) => ({
+        id: r.id,
+        kind: r.kind,
+        uri: r.uri,
+        excerptHash: r.excerptHash,
+        observedAt: r.observedAt,
+    }));
+}
+export function userInterestSnapshotToJudge(snapshot) {
+    if (!snapshot) {
+        return { staleness: "insufficient", confidence: 0, signals: [], sourceRefs: [] };
+    }
+    return {
+        staleness: snapshot.staleness,
+        confidence: snapshot.confidence,
+        signals: snapshot.signals.map((s) => ({
+            topic: s.topic,
+            confidence: s.confidence,
+            sourceRefs: s.sourceRefs.map((r) => ({
+                id: r.id,
+                kind: r.kind,
+                uri: r.uri,
+                excerptHash: r.excerptHash,
+                observedAt: r.observedAt,
+            })),
+        })),
+        sourceRefs: toControlPlaneRefs(snapshot.sourceRefs),
+    };
+}
+export function buildJudgeOutreachInputFromSnapshot(intent, runtime, inputs) {
+    const delivery = inputs.deliveryCapability ?? { target: "none" };
+    const key = intent.idempotencyKey ?? intent.id;
+    return {
+        userInterest: userInterestSnapshotToJudge(inputs.userInterestSnapshot),
+        lifeEvidence: {
+            empty: isLifeEvidenceSliceEmpty(runtime.lifeEvidence),
+            evidenceRefCount: runtime.lifeEvidence.evidenceRefs.length,
+        },
+        delivery,
+        duplicateBlocked: runtime.hardGuards.hasDuplicateIntent(key),
+        cooldownBlocked: !runtime.hardGuards.isOutreachCooldownClear(key),
+    };
+}

package/runtime/core/second-nature/outreach/judge-outreach.d.ts

@@ -0,0 +1,40 @@
+import type { CandidateIntent, ControlPlaneSourceRef } from "../types.js";
+import { type DeliveryCapabilitySnapshot, type DeliveryTargetResolution } from "./delivery-target.js";
+export type OutreachJudgmentVerdict = "allow" | "deny" | "defer";
+export type CooldownState = "clear" | "cooling_down" | "duplicate";
+export interface JudgeOutreachUserInterest {
+    staleness: "fresh" | "stale" | "insufficient";
+    confidence: number;
+    signals: Array<{
+        topic: string;
+        confidence: number;
+        sourceRefs: ControlPlaneSourceRef[];
+    }>;
+    sourceRefs: ControlPlaneSourceRef[];
+}
+export interface JudgeOutreachLifeEvidence {
+    empty: boolean;
+    evidenceRefCount: number;
+}
+export interface JudgeOutreachInput {
+    candidate: CandidateIntent;
+    userInterest: JudgeOutreachUserInterest;
+    lifeEvidence: JudgeOutreachLifeEvidence;
+    delivery: DeliveryCapabilitySnapshot;
+    duplicateBlocked?: boolean;
+    cooldownBlocked?: boolean;
+}
+export interface OutreachJudgment {
+    decisionId: string;
+    candidateId: string;
+    verdict: OutreachJudgmentVerdict;
+    valueScore: number;
+    userRelevance: number;
+    actionability: number;
+    interestRefs: ControlPlaneSourceRef[];
+    sourceRefs: ControlPlaneSourceRef[];
+    cooldownState: CooldownState;
+    deliveryVerdict: DeliveryTargetResolution["verdict"];
+    reasons: string[];
+}
+export declare function judgeOutreach(input: JudgeOutreachInput): OutreachJudgment;

package/runtime/core/second-nature/outreach/judge-outreach.js

@@ -0,0 +1,121 @@
+/**
+ * Control-plane outreach judgment (T2.3.1): value / interest / actionability / delivery / dedupe.
+ *
+ * Does not call guidance or perform delivery; callers supply guard-derived cooldown/duplicate flags.
+ * Test coverage: tests/unit/core/outreach-judgment.test.ts
+ */
+import * as crypto from "node:crypto";
+import { isDeliveryUnavailableReason, resolveDeliveryTarget, } from "./delivery-target.js";
+const OUTREACH_POLICY = {
+    minValueScore: 0.35,
+    minUserRelevance: 0.4,
+    minActionabilityWhenInterestLow: 0.7,
+};
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9\u4e00-\u9fff]+/g)
+        .filter((t) => t.length > 1);
+}
+function signalMatchesSummary(sig, summary) {
+    const s = summary.toLowerCase();
+    const t = sig.topic.toLowerCase();
+    if (t.length > 0 && s.includes(t))
+        return true;
+    const wt = tokenize(sig.topic);
+    const ws = new Set(tokenize(summary));
+    return wt.some((x) => ws.has(x));
+}
+function matchInterestRefs(candidate, interest) {
+    const matched = [];
+    for (const sig of interest.signals) {
+        if (signalMatchesSummary(sig, candidate.summary)) {
+            matched.push(...sig.sourceRefs);
+        }
+    }
+    const byId = new Map();
+    for (const ref of matched) {
+        byId.set(ref.id, ref);
+    }
+    return [...byId.values()];
+}
+function scoreOutreachValue(candidate, life) {
+    if (candidate.sourceRefs.length === 0)
+        return 0;
+    const base = 0.35 + Math.min(0.35, candidate.sourceRefs.length * 0.06) + Math.min(0.2, candidate.priority * 0.02);
+    if (life.empty)
+        return Math.max(0, base - 0.15);
+    return Math.min(1, base + Math.min(0.1, life.evidenceRefCount * 0.01));
+}
+function scoreUserRelevance(candidate, interest) {
+    if (interest.staleness === "insufficient") {
+        return Math.min(0.35, interest.confidence);
+    }
+    const refs = matchInterestRefs(candidate, interest);
+    if (refs.length === 0)
+        return interest.confidence * 0.45;
+    return Math.min(1, interest.confidence * 0.65 + refs.length * 0.08);
+}
+function scoreActionability(candidate, interest, matchedInterestRefCount) {
+    if (candidate.effectClass !== "user_outreach")
+        return 0.5;
+    if (interest.staleness === "insufficient" && matchedInterestRefCount === 0)
+        return 0.55;
+    return 0.78;
+}
+function resolveCooldownState(input) {
+    if (input.duplicateBlocked)
+        return "duplicate";
+    if (input.cooldownBlocked)
+        return "cooling_down";
+    return "clear";
+}
+export function judgeOutreach(input) {
+    const decisionId = `outreach_judgment:${crypto.randomUUID()}`;
+    const deliveryResolution = resolveDeliveryTarget(input.delivery);
+    const interestRefs = matchInterestRefs(input.candidate, input.userInterest);
+    const valueScore = scoreOutreachValue(input.candidate, input.lifeEvidence);
+    const userRelevance = scoreUserRelevance(input.candidate, input.userInterest);
+    const actionability = scoreActionability(input.candidate, input.userInterest, interestRefs.length);
+    const cooldownState = resolveCooldownState(input);
+    const reasons = [];
+    if (input.candidate.sourceRefs.length === 0)
+        reasons.push("missing_source_refs");
+    if (valueScore < OUTREACH_POLICY.minValueScore)
+        reasons.push("value_score_too_low");
+    if (userRelevance < OUTREACH_POLICY.minUserRelevance &&
+        actionability < OUTREACH_POLICY.minActionabilityWhenInterestLow) {
+        reasons.push("not_interest_relevant_or_actionable");
+    }
+    if (cooldownState === "cooling_down")
+        reasons.push("cooling_down");
+    if (cooldownState === "duplicate")
+        reasons.push("duplicate");
+    if (deliveryResolution.verdict !== "target_available") {
+        reasons.push(deliveryResolution.verdict);
+    }
+    const blockingReasons = reasons.filter((r) => !isDeliveryUnavailableReason(r));
+    let verdict;
+    if (blockingReasons.length === 0) {
+        verdict = "allow";
+    }
+    else if (blockingReasons.includes("cooling_down") || blockingReasons.includes("duplicate")) {
+        verdict = "defer";
+    }
+    else {
+        verdict = "deny";
+    }
+    return {
+        decisionId,
+        candidateId: input.candidate.id,
+        verdict,
+        valueScore,
+        userRelevance,
+        actionability,
+        interestRefs,
+        sourceRefs: input.candidate.sourceRefs,
+        cooldownState,
+        deliveryVerdict: deliveryResolution.verdict,
+        reasons: reasons.length === 0 ? ["outreach_allowed"] : reasons,
+    };
+}

package/runtime/core/second-nature/quiet/run-source-backed-quiet.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Quiet / reflection orchestration: empty evidence → empty_state; otherwise coverage-gated artifact (T2.3.3).
+ */
+import type { CandidateIntent } from "../types.js";
+import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
+import { type QuietArtifactAck } from "../../../storage/quiet/quiet-artifact-writer.js";
+import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
+export interface RunSourceBackedQuietParams {
+    candidate: CandidateIntent;
+    runtime: HeartbeatRuntimeSnapshot;
+    day: string;
+    userInterestSnapshot?: UserInterestSnapshot;
+    workspaceRoot?: string;
+}
+export interface RunSourceBackedQuietResult {
+    result: HeartbeatCycleResult;
+    artifactAck?: QuietArtifactAck;
+    persistedRelativePath?: string;
+}
+export declare function runSourceBackedQuiet(params: RunSourceBackedQuietParams): Promise<RunSourceBackedQuietResult>;

package/runtime/core/second-nature/quiet/run-source-backed-quiet.js

@@ -0,0 +1,123 @@
+import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
+import { writeQuietArtifact } from "../../../storage/quiet/quiet-artifact-writer.js";
+import { persistQuietArtifactToWorkspace } from "../../../storage/quiet/persist-quiet-artifact.js";
+import { buildEvidencePack, buildQuietNarrativeGuidance, selectInterestBasis } from "../../../guidance/evidence-guidance.js";
+function toSourceRefFromControlPlane(r) {
+    return {
+        id: r.id,
+        kind: r.kind,
+        uri: r.uri,
+        excerptHash: r.excerptHash,
+        observedAt: r.observedAt,
+    };
+}
+function toGuidanceRef(r) {
+    return {
+        id: r.id,
+        kind: r.kind,
+        uri: r.uri,
+        excerptHash: r.excerptHash,
+        observedAt: r.observedAt,
+    };
+}
+export async function runSourceBackedQuiet(params) {
+    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot } = params;
+    const empty = isLifeEvidenceSliceEmpty(runtime.lifeEvidence);
+    if (empty) {
+        const input = {
+            day,
+            kind: "empty_state",
+            title: "Quiet — no life evidence",
+            body: "No source-backed life evidence in window; narrative reflection is skipped.",
+            claims: [],
+            sourceRefs: [],
+        };
+        const ack = writeQuietArtifact(input);
+        let persistedRelativePath;
+        if (workspaceRoot) {
+            const p = await persistQuietArtifactToWorkspace(workspaceRoot, ack, input);
+            persistedRelativePath = p.relativePath;
+        }
+        return {
+            result: {
+                scope: "rhythm",
+                status: "intent_selected",
+                selectedIntentId: candidate.id,
+                reasons: ["quiet_empty_state", "no_fictional_narrative"],
+            },
+            artifactAck: ack,
+            persistedRelativePath,
+        };
+    }
+    const bundleRefs = runtime.lifeEvidence.evidenceRefs.map(toSourceRefFromControlPlane);
+    const guidanceRefs = runtime.lifeEvidence.evidenceRefs.map(toGuidanceRef);
+    const ep = buildEvidencePack(guidanceRefs);
+    if (!ep.ok) {
+        return {
+            result: {
+                scope: "rhythm",
+                status: "denied",
+                selectedIntentId: candidate.id,
+                reasons: ep.reasons,
+            },
+        };
+    }
+    const basis = selectInterestBasis({
+        staleness: userInterestSnapshot?.staleness ?? "insufficient",
+        confidence: userInterestSnapshot?.confidence ?? 0,
+        signalCount: userInterestSnapshot?.signals.length ?? 0,
+    });
+    const claims = ep.pack.groundedRefs.map((g, i) => ({
+        id: `fact:${g.id}`,
+        text: `Evidence-backed note ${i + 1}`,
+        claimType: "fact",
+        sourceRefs: [
+            {
+                id: g.id,
+                kind: g.kind,
+                uri: g.uri,
+                excerptHash: g.excerptHash,
+                observedAt: g.observedAt,
+            },
+        ],
+    }));
+    const reportWrite = {
+        day,
+        kind: "daily_report",
+        title: "Quiet daily report",
+        body: `Source-backed quiet summary (${bundleRefs.length} refs).`,
+        claims,
+        sourceRefs: bundleRefs,
+    };
+    const ack = writeQuietArtifact(reportWrite);
+    const gq = buildQuietNarrativeGuidance({
+        interestBasis: basis,
+        sourceCoverage: ack.sourceCoverage,
+        outline: claims.map((c) => c.text),
+    });
+    if (gq.status === "unavailable") {
+        return {
+            result: {
+                scope: "rhythm",
+                status: "denied",
+                selectedIntentId: candidate.id,
+                reasons: gq.reasons,
+            },
+        };
+    }
+    let persistedRelativePath;
+    if (workspaceRoot) {
+        const p = await persistQuietArtifactToWorkspace(workspaceRoot, ack, reportWrite);
+        persistedRelativePath = p.relativePath;
+    }
+    return {
+        result: {
+            scope: "rhythm",
+            status: "intent_selected",
+            selectedIntentId: candidate.id,
+            reasons: ["quiet_artifact_written", ...gq.hints.slice(0, 2)],
+        },
+        artifactAck: ack,
+        persistedRelativePath,
+    };
+}