@haaaiawd/second-nature 0.1.8 → 0.1.9

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,
+    };
+}

package/runtime/core/second-nature/rhythm/planner-rhythm-window.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Maps calendar rhythm policy + continuity into planner-facing window slice (T2.1.3).
+ * Control-plane owns allowedIntentKinds; state never emits them (T2.1.2 boundary).
+ */
+import type { ContinuitySnapshot, IntentKind } from "../types.js";
+import type { RhythmPolicy } from "./rhythm-policy.js";
+export interface PlannerRhythmWindowSlice {
+    windowId: string;
+    allowedIntentKinds: IntentKind[];
+    quietBias: boolean;
+}
+/**
+ * Derive allowed intent kinds and quiet bias for candidate planning.
+ */
+export declare function buildPlannerRhythmWindow(now: string, continuity: ContinuitySnapshot, policy: RhythmPolicy): PlannerRhythmWindowSlice;

package/runtime/core/second-nature/rhythm/planner-rhythm-window.js

@@ -0,0 +1,52 @@
+import { selectRhythmWindow } from "./select-window.js";
+const ALL_INTENT_KINDS = [
+    "work",
+    "exploration",
+    "social",
+    "quiet",
+    "reflection",
+    "outreach",
+    "maintenance",
+];
+function allowedForPaused() {
+    return ["maintenance"];
+}
+function allowedForMaintenanceOnly() {
+    return ["work", "maintenance"];
+}
+function allowedForActiveWindow(windowId) {
+    if (windowId.includes("work")) {
+        return ["work", "exploration", "maintenance", "reflection", "outreach", "social", "quiet"];
+    }
+    if (windowId.includes("social")) {
+        return ["social", "exploration", "work", "maintenance", "reflection", "outreach", "quiet"];
+    }
+    if (windowId.includes("reflection")) {
+        return ["reflection", "work", "maintenance", "exploration", "social", "outreach", "quiet"];
+    }
+    return ALL_INTENT_KINDS;
+}
+function mergeQuietBias(decision, continuity, windowIsQuiet) {
+    return windowIsQuiet || decision.topLevelMode === "quiet" || continuity.mode === "quiet";
+}
+/**
+ * Derive allowed intent kinds and quiet bias for candidate planning.
+ */
+export function buildPlannerRhythmWindow(now, continuity, policy) {
+    const decision = selectRhythmWindow(now, continuity, policy);
+    const window = policy.windows.find((w) => w.id === decision.windowId) ?? policy.windows[0];
+    const windowIsQuiet = window.mode === "quiet";
+    const quietBias = mergeQuietBias(decision, continuity, windowIsQuiet);
+    let allowed;
+    if (decision.topLevelMode === "paused_for_interrupt") {
+        allowed = allowedForPaused();
+    }
+    else if (decision.topLevelMode === "maintenance_only") {
+        allowed = allowedForMaintenanceOnly();
+    }
+    else {
+        /** Calendar quiet sets `quietBias` only; candidate kinds stay window-biased (guards enforce quiet suppression). */
+        allowed = allowedForActiveWindow(window.id);
+    }
+    return { windowId: decision.windowId, allowedIntentKinds: allowed, quietBias };
+}

package/runtime/core/second-nature/rhythm/policy-bridge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Bridges state-system RhythmPolicySnapshot fields into control-plane RhythmPolicy (T2.1.2).
+ *
+ * State never emits window decisions or allowedIntentKinds; control-plane owns
+ * window geometry used by selectRhythmWindow(). Callers pass a pick of the DB read model.
+ */
+import type { RhythmPolicy } from "./rhythm-policy.js";
+/** Subset of `RhythmPolicySnapshot` used for window derivation (no storage import from core). */
+export interface RhythmPolicySnapshotBridgeInput {
+    quietEnabled: boolean;
+}
+/**
+ * Reject drifted snapshot shapes that smuggle control-plane decision fields.
+ */
+export declare function assertRhythmPolicySnapshotContract(snapshot: Record<string, unknown>): void;
+/**
+ * Deterministic default windows from policy knobs (quiet hour tail when quietEnabled).
+ */
+export declare function rhythmPolicySnapshotToRhythmPolicy(snapshot: RhythmPolicySnapshotBridgeInput): RhythmPolicy;

package/runtime/core/second-nature/rhythm/policy-bridge.js

@@ -0,0 +1,34 @@
+const FORBIDDEN_SNAPSHOT_KEYS = ["allowedIntentKinds", "windowDecision", "rhythmWindow"];
+/**
+ * Reject drifted snapshot shapes that smuggle control-plane decision fields.
+ */
+export function assertRhythmPolicySnapshotContract(snapshot) {
+    for (const key of FORBIDDEN_SNAPSHOT_KEYS) {
+        if (key in snapshot) {
+            throw new Error(`rhythm_policy_snapshot_field_drift:${key}`);
+        }
+    }
+}
+/**
+ * Deterministic default windows from policy knobs (quiet hour tail when quietEnabled).
+ */
+export function rhythmPolicySnapshotToRhythmPolicy(snapshot) {
+    assertRhythmPolicySnapshotContract(snapshot);
+    if (snapshot.quietEnabled) {
+        return {
+            timezone: "UTC",
+            quietSuppressionEnabled: true,
+            windows: [
+                { id: "w-work", startMinute: 0, endMinute: 480, mode: "active" },
+                { id: "w-social", startMinute: 480, endMinute: 960, mode: "active" },
+                { id: "w-reflection", startMinute: 960, endMinute: 1200, mode: "active" },
+                { id: "w-quiet", startMinute: 1200, endMinute: 1440, mode: "quiet" },
+            ],
+        };
+    }
+    return {
+        timezone: "UTC",
+        quietSuppressionEnabled: false,
+        windows: [{ id: "w-open", startMinute: 0, endMinute: 1440, mode: "active" }],
+    };
+}

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

@@ -1,7 +1,16 @@
 export type TopLevelMode = "active" | "quiet" | "maintenance_only" | "paused_for_interrupt";
-export type IntentKind = "work" | "exploration" | "social" | "reflection" | "outreach" | "maintenance";
+/** Control-plane candidate kinds; includes `quiet` for quiet-window–biased intents (L0 alignment). */
+export type IntentKind = "work" | "exploration" | "social" | "quiet" | "reflection" | "outreach" | "maintenance";
 export type DecisionBasis = "rule_only" | "score_based" | "model_assisted";
 export type GuardVerdict = "allow" | "defer" | "deny" | "escalate";
+/** Minimal source ref for planner / guards (matches state-system `SourceRef` subset). */
+export interface ControlPlaneSourceRef {
+    id: string;
+    kind: "platform_item" | "workspace_artifact" | "decision_record" | "user_anchor" | "connector_result" | "host_report" | "fallback_artifact";
+    uri: string;
+    excerptHash?: string;
+    observedAt?: string;
+}
 export interface ContinuitySnapshot {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -19,6 +28,7 @@ export interface ContinuitySnapshot {
     awaitingUserInput?: boolean;
     riskSuppressed?: boolean;
 }
+export type CandidateEffectClass = "external_platform_action" | "connector_action" | "memory_curation" | "narrative_reflection" | "user_outreach" | "maintenance" | "no_effect";
 export interface CandidateIntent {
     id: string;
     kind: IntentKind;
@@ -26,7 +36,11 @@ export interface CandidateIntent {
     source: "tick" | "interrupt" | "obligation" | "quiet_plan";
     platformId?: string;
     summary: string;
-    effectClass: "external_platform_action" | "memory_curation" | "narrative_reflection" | "user_outreach" | "maintenance";
+    effectClass: CandidateEffectClass;
+    /** Required for source-backed guard; may be empty when planner expects hard-guard deny. */
+    sourceRefs: ControlPlaneSourceRef[];
+    /** Dedupe / cooldown key; defaults to stable fingerprint in guard layer when omitted. */
+    idempotencyKey?: string;
 }
 export interface GuardEvaluation {
     verdict: GuardVerdict;

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

@@ -0,0 +1,7 @@
+/**
+ * Deterministic GuidanceDraftPort implementation for contract tests and packaged runtime.
+ * Does not claim user-visible delivery when wordingMode is not_sent_fallback_candidate (T6.2.1 / ADR-004).
+ */
+import { type GuidanceDraftPort, type OutreachDraftRequest } from "./outreach-draft-schema.js";
+export declare function draftOutreachMessage(request: OutreachDraftRequest): ReturnType<GuidanceDraftPort["draftOutreachMessage"]>;
+export declare function createDraftOutreachMessagePort(): GuidanceDraftPort;

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

@@ -0,0 +1,42 @@
+/**
+ * Deterministic GuidanceDraftPort implementation for contract tests and packaged runtime.
+ * 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 baseDraftText(request) {
+    const ids = request.sourceRefs.map((s) => s.id).join(",");
+    return `draft:${request.candidateId}:grounded:${ids}`;
+}
+export async function draftOutreachMessage(request) {
+    const parsed = safeParseOutreachDraftRequest(request);
+    if (!parsed.success) {
+        return { status: "unavailable", reasons: ["outreach_draft_schema_invalid"] };
+    }
+    const r = parsed.data;
+    if (r.judgmentVerdict !== "allow") {
+        return { status: "unavailable", reasons: ["hard_decision_not_allow"] };
+    }
+    if (r.sourceRefs.length === 0) {
+        return { status: "unavailable", reasons: ["missing_resolved_source_refs"] };
+    }
+    const wording = r.deliveryContext.wordingMode;
+    if (wording === "sendable") {
+        return {
+            status: "ready",
+            draft: {
+                text: `${baseDraftText(r)};wording=sendable`,
+                deliveryWording: "sendable",
+            },
+        };
+    }
+    return {
+        status: "ready",
+        draft: {
+            text: `Not sent to the user (candidate only). Delivery state: ${r.deliveryContext.deliveryVerdict}. ${baseDraftText(r)}`,
+            deliveryWording: "not_sent_fallback_candidate",
+        },
+    };
+}
+export function createDraftOutreachMessagePort() {
+    return { draftOutreachMessage };
+}

package/runtime/guidance/evidence-guidance.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Evidence pack assembly, interest-basis selection, and Quiet narrative gate (T6.1.2 / ADR-004).
+ * Guidance does not own delivery or judgment; callers pass already-resolved refs.
+ */
+import type { GuidanceSourceRef } from "./outreach-draft-schema.js";
+import type { UserInterestStaleness } from "../storage/user-interest/types.js";
+import type { SourceCoverage } from "../storage/snapshots/types.js";
+export type SourceCoveragePolicy = "strict" | "lenient";
+export interface EvidencePack {
+    groundedRefs: GuidanceSourceRef[];
+    unresolvedIds: string[];
+    sensitiveBlocked: boolean;
+    policy: SourceCoveragePolicy;
+}
+export declare function buildEvidencePack(refs: GuidanceSourceRef[], opts?: {
+    policy?: SourceCoveragePolicy;
+}): {
+    ok: true;
+    pack: EvidencePack;
+} | {
+    ok: false;
+    reasons: string[];
+};
+export type InterestBasisMode = "evidence_only" | "interest_augmented" | "unavailable";
+export declare function selectInterestBasis(input: {
+    staleness: UserInterestStaleness;
+    confidence: number;
+    signalCount: number;
+}): InterestBasisMode;
+export declare function buildQuietNarrativeGuidance(input: {
+    interestBasis: InterestBasisMode;
+    sourceCoverage: Pick<SourceCoverage, "coverageRatio" | "unsupportedClaims">;
+    outline: string[];
+}): {
+    status: "ready";
+    hints: string[];
+} | {
+    status: "unavailable";
+    reasons: string[];
+};

package/runtime/guidance/evidence-guidance.js

@@ -0,0 +1,52 @@
+export function buildEvidencePack(refs, opts) {
+    const policy = opts?.policy ?? "strict";
+    const unresolvedIds = [];
+    let sensitiveBlocked = false;
+    const grounded = [];
+    for (const r of refs) {
+        if (!r.uri?.trim()) {
+            unresolvedIds.push(r.id);
+            continue;
+        }
+        if (r.uri.includes("credential") || r.uri.includes("secret")) {
+            sensitiveBlocked = true;
+            continue;
+        }
+        grounded.push(r);
+    }
+    if (policy === "strict" && unresolvedIds.length > 0) {
+        return { ok: false, reasons: ["unresolved_source_refs", ...unresolvedIds.slice(0, 3)] };
+    }
+    return {
+        ok: true,
+        pack: {
+            groundedRefs: grounded,
+            unresolvedIds,
+            sensitiveBlocked,
+            policy,
+        },
+    };
+}
+export function selectInterestBasis(input) {
+    if (input.staleness === "insufficient" || input.confidence < 0.15) {
+        return input.signalCount > 0 ? "evidence_only" : "unavailable";
+    }
+    if (input.staleness === "stale") {
+        return "evidence_only";
+    }
+    return "interest_augmented";
+}
+export function buildQuietNarrativeGuidance(input) {
+    if (input.interestBasis === "unavailable" && input.sourceCoverage.coverageRatio < 0.25) {
+        return { status: "unavailable", reasons: ["quiet_guidance_insufficient_interest_and_coverage"] };
+    }
+    if (input.sourceCoverage.unsupportedClaims.length > 0) {
+        return { status: "unavailable", reasons: ["quiet_guidance_unsupported_claims"] };
+    }
+    const hints = [
+        ...input.outline.slice(0, 3).map((line) => `hint:${line}`),
+        `basis:${input.interestBasis}`,
+        `coverage:${input.sourceCoverage.coverageRatio.toFixed(2)}`,
+    ];
+    return { status: "ready", hints };
+}

package/runtime/guidance/index.d.ts

@@ -6,3 +6,6 @@ export * from "./fallback.js";
 export * from "./template-registry.js";
 export * from "./review-workflow.js";
 export * from "./guidance-assembler.js";
+export * from "./outreach-draft-schema.js";
+export * from "./draft-outreach-message.js";
+export * from "./evidence-guidance.js";

package/runtime/guidance/index.js

@@ -6,3 +6,6 @@ export * from "./fallback.js";
 export * from "./template-registry.js";
 export * from "./review-workflow.js";
 export * from "./guidance-assembler.js";
+export * from "./outreach-draft-schema.js";
+export * from "./draft-outreach-message.js";
+export * from "./evidence-guidance.js";