@haaaiawd/second-nature 0.1.26 → 0.1.29

package/runtime/core/second-nature/orchestrator/effect-dispatcher.js

@@ -12,6 +12,8 @@ function isConnectorEffect(effectClass) {
         effectClass === "connector_action");
 }
 export function toCapabilityIntent(intent) {
+    if (intent.capabilityIntent?.trim())
+        return intent.capabilityIntent.trim();
     if (intent.kind === "work")
         return "work.discover";
     if (intent.kind === "exploration")

package/runtime/core/second-nature/orchestrator/hard-guard-evaluator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * HardGuardEvaluator — T-CP.C.2
+ *
+ * Core logic: Applies source, affordance, circuit-breaker, dedupe, cooldown,
+ * quiet, budget, risk, and privacy guards to candidate intents.
+ *
+ * v7 extensions over guard-layer.ts:
+ * - Affordance guard: connector_action intents must map to a healthy affordance
+ *   item (safe/exploratory/needs_auth). painful → connector_circuit_open defer;
+ *   unavailable → affordance_unavailable defer.
+ * - Source refs guard remains mandatory for all non-maintenance intents.
+ *
+ * Boundary:
+ * - Consumes AffordanceMap from EmbodiedContext; does NOT read breaker state
+ *   directly (DR-002: breaker posture flows through affordance).
+ * - Guard result is final for control-plane.
+ *
+ * Test coverage: tests/unit/control-plane/hard-guard-evaluator.test.ts
+ */
+import type { CandidateIntent, GuardEvaluation } from "../types.js";
+import type { AffordanceMap } from "../../../shared/types/v7-entities.js";
+export interface HardGuardEvaluatorDeps {
+    hasDuplicateIntent: (idempotencyKey: string) => boolean;
+    isOutreachCooldownClear: (idempotencyKey: string) => boolean;
+    affordanceMap?: AffordanceMap;
+    quietBias?: boolean;
+    budgetExceeded?: boolean;
+    awaitingUser?: boolean;
+    riskSuppressed?: boolean;
+}
+export declare function evaluateHardGuards(intent: CandidateIntent, deps: HardGuardEvaluatorDeps): GuardEvaluation;

package/runtime/core/second-nature/orchestrator/hard-guard-evaluator.js

@@ -0,0 +1,102 @@
+const QUIET_DENY_KINDS = ["outreach", "social"];
+export function evaluateHardGuards(intent, deps) {
+    const reasons = [];
+    // 1. Source refs guard
+    if (intent.sourceRefs.length === 0 &&
+        intent.effectClass !== "maintenance" &&
+        intent.effectClass !== "no_effect") {
+        reasons.push("missing_source_refs");
+    }
+    // 2. Affordance / breaker guard (v7)
+    if ((intent.effectClass === "connector_action" ||
+        intent.effectClass === "external_platform_action") &&
+        deps.affordanceMap &&
+        intent.platformId) {
+        const platformItems = deps.affordanceMap[intent.platformId] ?? [];
+        const match = intent.capabilityIntent
+            ? platformItems.find((i) => i.capabilityId === intent.capabilityIntent)
+            : platformItems.find((i) => i.intent === intent.summary);
+        if (match) {
+            if (match.status === "painful") {
+                reasons.push("connector_circuit_open");
+            }
+            else if (match.status === "unavailable") {
+                reasons.push("affordance_unavailable");
+            }
+        }
+        else {
+            reasons.push("affordance_unavailable");
+        }
+    }
+    // 3. Dedupe guard
+    const key = intent.idempotencyKey ?? `${intent.kind}:${intent.summary}`;
+    if (deps.hasDuplicateIntent(key)) {
+        reasons.push("duplicate_intent");
+    }
+    // 4. Outreach cooldown
+    if (intent.effectClass === "user_outreach" &&
+        !deps.isOutreachCooldownClear(key)) {
+        reasons.push("outreach_cooldown");
+    }
+    // 5. Quiet suppression
+    if (deps.quietBias) {
+        if (QUIET_DENY_KINDS.includes(intent.kind)) {
+            reasons.push("quiet_window_suppression");
+        }
+        if (intent.effectClass === "connector_action" ||
+            intent.effectClass === "external_platform_action") {
+            reasons.push("quiet_window_suppression");
+        }
+    }
+    // 6. Budget
+    if (deps.budgetExceeded) {
+        reasons.push("budget_exceeded");
+    }
+    // 7. Awaiting user
+    if (deps.awaitingUser) {
+        reasons.push("awaiting_user");
+    }
+    // 8. Risk
+    if (deps.riskSuppressed) {
+        if (intent.kind === "exploration" ||
+            intent.kind === "social" ||
+            intent.kind === "outreach") {
+            reasons.push("risk_suppressed");
+        }
+    }
+    // Verdict resolution
+    if (reasons.length === 0) {
+        return {
+            verdict: "allow",
+            reasons: [],
+            quietSuppressed: false,
+            leaseRequired: intent.effectClass === "external_platform_action" ||
+                intent.effectClass === "connector_action" ||
+                intent.effectClass === "user_outreach",
+            requiresCheckpoint: intent.effectClass !== "maintenance" &&
+                intent.effectClass !== "no_effect",
+        };
+    }
+    const deferOnlyReasons = reasons.every((r) => r === "duplicate_intent" ||
+        r === "outreach_cooldown" ||
+        r === "connector_circuit_open" ||
+        r === "quiet_window_suppression" ||
+        r === "affordance_unavailable");
+    if (deferOnlyReasons) {
+        return {
+            verdict: "defer",
+            reasons,
+            quietSuppressed: reasons.includes("quiet_window_suppression"),
+            leaseRequired: false,
+            requiresCheckpoint: false,
+        };
+    }
+    const escalated = reasons.includes("awaiting_user") && intent.kind === "outreach";
+    return {
+        verdict: escalated ? "escalate" : "deny",
+        reasons,
+        quietSuppressed: reasons.includes("quiet_window_suppression"),
+        leaseRequired: false,
+        requiresCheckpoint: false,
+    };
+}

package/runtime/core/second-nature/orchestrator/index.d.ts

@@ -0,0 +1,5 @@
+export { evaluateHardGuards, type HardGuardEvaluatorDeps, } from "./hard-guard-evaluator.js";
+export { createDownstreamIntentOrchestrator, type DownstreamIntentOrchestrator, type DownstreamRequest, type ConnectorIntentRequest, type QuietRunRequest, type DreamScheduleRequest, type GuidanceDraftRequest, } from "./downstream-intent-orchestrator.js";
+export { planCandidateIntents, planIntent, planIntentWithKind, decideDecisionBasis } from "./intent-planner.js";
+export { applyGoalPriority } from "./goal-priority.js";
+export { evaluateGuards } from "./guard-layer.js";

package/runtime/core/second-nature/orchestrator/index.js

@@ -0,0 +1,7 @@
+/* Wave 57 — v7 control-plane orchestration components */
+export { evaluateHardGuards, } from "./hard-guard-evaluator.js";
+export { createDownstreamIntentOrchestrator, } from "./downstream-intent-orchestrator.js";
+/* v6 legacy exports (preserved for backward compatibility) */
+export { planCandidateIntents, planIntent, planIntentWithKind, decideDecisionBasis } from "./intent-planner.js";
+export { applyGoalPriority } from "./goal-priority.js";
+export { evaluateGuards } from "./guard-layer.js";

package/runtime/core/second-nature/quiet/claim-synthesizer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ClaimSynthesizer — T-DQS.C.1
+ *
+ * Core logic: Transform aggregated life evidence into source-backed QuietClaims.
+ * - EvidenceAggregator: group and summarize raw evidence candidates
+ * - ClaimDeduplicator: remove duplicate claims by sourceRef key
+ * - ClaimSynthesizer: map evidence -> claim kind (observation/fact/pattern)
+ * - SourceValidator: reject fact claims with empty sourceRefs (DR-025)
+ *
+ * Rules:
+ * - Single weak evidence (confidence < 0.5, count == 1) → observation only
+ * - Multiple evidence or confidence >= 0.5 → fact
+ * - Pattern requires >= 3 related evidence with confidence >= 0.7
+ * - Fact claim sourceRefs must be non-empty tuple (DR-025)
+ * - SourceValidator returns claim_source_missing for empty sourceRefs
+ *
+ * Dependencies:
+ * - `QuietClaim`, `QuietClaimKind` from `../../../shared/types/v7-entities.js`
+ * - `LifeEvidenceCandidate` from `../../../storage/life-evidence/types.js`
+ *
+ * Test coverage: tests/unit/quiet/claim-synthesizer.test.ts
+ */
+import type { QuietClaim } from "../../../shared/types/v7-entities.js";
+import type { LifeEvidenceCandidate } from "../../../storage/life-evidence/types.js";
+export interface EvidenceSlice {
+    items: LifeEvidenceCandidate[];
+    summary: string;
+}
+export interface ClaimSynthesisResult {
+    claims: QuietClaim[];
+    errors: string[];
+}
+export interface EvidenceAggregator {
+    aggregate(candidates: LifeEvidenceCandidate[]): EvidenceSlice;
+}
+export interface ClaimDeduplicator {
+    deduplicate(claims: QuietClaim[]): QuietClaim[];
+}
+export interface ClaimSynthesizer {
+    synthesize(slice: EvidenceSlice): ClaimSynthesisResult;
+}
+export interface SourceValidator {
+    validate(claim: QuietClaim): {
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    };
+}
+export declare function createEvidenceAggregator(): EvidenceAggregator;
+export declare function createClaimDeduplicator(): ClaimDeduplicator;
+export declare function createClaimSynthesizer(): ClaimSynthesizer;
+export declare function createSourceValidator(): SourceValidator;

package/runtime/core/second-nature/quiet/claim-synthesizer.js

@@ -0,0 +1,153 @@
+/**
+ * ClaimSynthesizer — T-DQS.C.1
+ *
+ * Core logic: Transform aggregated life evidence into source-backed QuietClaims.
+ * - EvidenceAggregator: group and summarize raw evidence candidates
+ * - ClaimDeduplicator: remove duplicate claims by sourceRef key
+ * - ClaimSynthesizer: map evidence -> claim kind (observation/fact/pattern)
+ * - SourceValidator: reject fact claims with empty sourceRefs (DR-025)
+ *
+ * Rules:
+ * - Single weak evidence (confidence < 0.5, count == 1) → observation only
+ * - Multiple evidence or confidence >= 0.5 → fact
+ * - Pattern requires >= 3 related evidence with confidence >= 0.7
+ * - Fact claim sourceRefs must be non-empty tuple (DR-025)
+ * - SourceValidator returns claim_source_missing for empty sourceRefs
+ *
+ * Dependencies:
+ * - `QuietClaim`, `QuietClaimKind` from `../../../shared/types/v7-entities.js`
+ * - `LifeEvidenceCandidate` from `../../../storage/life-evidence/types.js`
+ *
+ * Test coverage: tests/unit/quiet/claim-synthesizer.test.ts
+ */
+// ── EvidenceAggregator ───────────────────────────────────────
+export function createEvidenceAggregator() {
+    return {
+        aggregate(candidates) {
+            // Group by evidenceType for summary
+            const byType = new Map();
+            for (const c of candidates) {
+                const list = byType.get(c.evidenceType) ?? [];
+                list.push(c);
+                byType.set(c.evidenceType, list);
+            }
+            const parts = [];
+            for (const [type, list] of byType) {
+                parts.push(`${list.length} ${type}`);
+            }
+            return {
+                items: candidates,
+                summary: parts.join("; ") || "empty",
+            };
+        },
+    };
+}
+// ── ClaimDeduplicator ────────────────────────────────────────
+function sourceRefKey(claim) {
+    return [...claim.sourceRefs].sort().join("|");
+}
+export function createClaimDeduplicator() {
+    return {
+        deduplicate(claims) {
+            const seen = new Set();
+            const result = [];
+            for (const claim of claims) {
+                const key = sourceRefKey(claim);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                result.push(claim);
+            }
+            return result;
+        },
+    };
+}
+// ── ClaimSynthesizer ─────────────────────────────────────────
+function determineKind(items, avgConfidence) {
+    if (items.length >= 3 && avgConfidence >= 0.7) {
+        return "pattern";
+    }
+    return "fact";
+}
+function buildText(kind, summary, count) {
+    switch (kind) {
+        case "observation":
+            return `Observed: ${summary}`;
+        case "fact":
+            return `Noted ${count} evidence(s): ${summary}`;
+        case "pattern":
+            return `Pattern detected across ${count} sources: ${summary}`;
+    }
+}
+function toSourceRefTuple(refs) {
+    const ids = refs.map((r) => r.id).filter((id) => id && id.trim().length > 0);
+    if (ids.length === 0) {
+        // This should not happen if validation is correct, but type-safety requires it
+        return ["synthetic://missing"];
+    }
+    return ids;
+}
+export function createClaimSynthesizer() {
+    return {
+        synthesize(slice) {
+            const claims = [];
+            const errors = [];
+            const now = new Date().toISOString();
+            if (slice.items.length === 0) {
+                return { claims: [], errors: [] };
+            }
+            // Group by evidenceType for per-group synthesis
+            const byType = new Map();
+            for (const item of slice.items) {
+                const list = byType.get(item.evidenceType) ?? [];
+                list.push(item);
+                byType.set(item.evidenceType, list);
+            }
+            for (const [evidenceType, items] of byType) {
+                const avgConfidence = items.reduce((sum, i) => sum + (i.confidence ?? 0), 0) /
+                    items.length;
+                let kind = determineKind(items, avgConfidence);
+                // Single weak evidence → observation only (no fact/pattern)
+                if (items.length === 1 && (items[0].confidence ?? 0) < 0.5) {
+                    if (kind !== "observation") {
+                        errors.push(`weak_evidence_downgrade:${evidenceType}:${kind}_to_observation`);
+                    }
+                    kind = "observation";
+                }
+                const summary = items.map((i) => i.summary).join("; ");
+                const text = buildText(kind, summary, items.length);
+                const sourceRefs = toSourceRefTuple(items.map((i) => ({ id: i.id ?? i.summary, uri: i.sourceRefs[0]?.uri ?? "" })));
+                claims.push({
+                    claimId: `claim:${evidenceType}:${Date.now()}:${items.length}`,
+                    kind,
+                    text,
+                    sourceRefs,
+                    confidence: Math.min(avgConfidence, 1),
+                    createdAt: now,
+                });
+            }
+            return { claims, errors };
+        },
+    };
+}
+// ── SourceValidator ──────────────────────────────────────────
+export function createSourceValidator() {
+    return {
+        validate(claim) {
+            // All claim kinds require non-empty sourceRefs (DR-025)
+            if (claim.sourceRefs.length === 0) {
+                return { ok: false, reason: "claim_source_missing" };
+            }
+            for (const ref of claim.sourceRefs) {
+                if (!ref || ref.trim().length === 0) {
+                    return { ok: false, reason: "claim_source_missing" };
+                }
+                // Reject synthetic fallback refs (defensive: should not reach here)
+                if (ref.startsWith("synthetic://")) {
+                    return { ok: false, reason: "claim_source_missing" };
+                }
+            }
+            return { ok: true };
+        },
+    };
+}

package/runtime/core/second-nature/quiet/daily-diary-writer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * DailyDiaryWriter — T-DQS.C.1
+ *
+ * Core logic: Convert QuietClaims into a three-section DailyDiary artifact.
+ * - observedToday: from observation claims (what was seen)
+ * - notableSignals: from fact claims (what matters)
+ * - tomorrowDirection: from pattern claims or best-guess from facts
+ *
+ * Rules:
+ * - Each section gets at most 5 entries (bounded, non-bloat)
+ * - Empty claims → empty sections (no fabricated content)
+ * - sourceRefs aggregated from all contributing claims
+ * - sensitive refs filtered by WriteValidationGate upstream (not here)
+ *
+ * Dependencies:
+ * - `DailyDiary` from `../../../shared/types/v7-entities.js`
+ * - `QuietClaim` from `../../../shared/types/v7-entities.js`
+ *
+ * Test coverage: tests/unit/quiet/daily-diary-writer.test.ts
+ */
+import type { DailyDiary, QuietClaim } from "../../../shared/types/v7-entities.js";
+export interface DailyDiaryResult {
+    diary: DailyDiary;
+    errors: string[];
+}
+export interface DailyDiaryWriter {
+    write(claims: QuietClaim[], day: string): DailyDiaryResult;
+}
+export declare function createDailyDiaryWriter(): DailyDiaryWriter;

package/runtime/core/second-nature/quiet/daily-diary-writer.js

@@ -0,0 +1,92 @@
+/**
+ * DailyDiaryWriter — T-DQS.C.1
+ *
+ * Core logic: Convert QuietClaims into a three-section DailyDiary artifact.
+ * - observedToday: from observation claims (what was seen)
+ * - notableSignals: from fact claims (what matters)
+ * - tomorrowDirection: from pattern claims or best-guess from facts
+ *
+ * Rules:
+ * - Each section gets at most 5 entries (bounded, non-bloat)
+ * - Empty claims → empty sections (no fabricated content)
+ * - sourceRefs aggregated from all contributing claims
+ * - sensitive refs filtered by WriteValidationGate upstream (not here)
+ *
+ * Dependencies:
+ * - `DailyDiary` from `../../../shared/types/v7-entities.js`
+ * - `QuietClaim` from `../../../shared/types/v7-entities.js`
+ *
+ * Test coverage: tests/unit/quiet/daily-diary-writer.test.ts
+ */
+const SECTION_LIMIT = 5;
+function pickObservations(claims) {
+    return claims
+        .filter((c) => c.kind === "observation")
+        .map((c) => c.text)
+        .slice(0, SECTION_LIMIT);
+}
+function pickNotableSignals(claims) {
+    return claims
+        .filter((c) => c.kind === "fact")
+        .map((c) => c.text)
+        .slice(0, SECTION_LIMIT);
+}
+function pickTomorrowDirection(claims) {
+    const patterns = claims.filter((c) => c.kind === "pattern");
+    if (patterns.length > 0) {
+        return `Continue watching: ${patterns
+            .map((p) => p.text)
+            .join("; ")
+            .slice(0, 200)}`;
+    }
+    const facts = claims.filter((c) => c.kind === "fact");
+    if (facts.length > 0) {
+        return `Follow up on ${facts.length} note(s) tomorrow.`;
+    }
+    const observations = claims.filter((c) => c.kind === "observation");
+    if (observations.length > 0) {
+        return `Keep observing; no strong signals yet.`;
+    }
+    return "Nothing significant today.";
+}
+function aggregateSourceRefs(claims) {
+    const seen = new Set();
+    for (const claim of claims) {
+        for (const ref of claim.sourceRefs) {
+            if (!ref.startsWith("synthetic://")) {
+                seen.add(ref);
+            }
+        }
+    }
+    const arr = [...seen];
+    if (arr.length === 0) {
+        return ["synthetic://empty"];
+    }
+    return arr;
+}
+export function createDailyDiaryWriter() {
+    return {
+        write(claims, day) {
+            const errors = [];
+            const now = new Date().toISOString();
+            const observedToday = pickObservations(claims);
+            const notableSignals = pickNotableSignals(claims);
+            const tomorrowDirection = pickTomorrowDirection(claims);
+            if (observedToday.length === 0 &&
+                notableSignals.length === 0 &&
+                tomorrowDirection === "Nothing significant today.") {
+                errors.push("diary_empty:no_claims");
+            }
+            const diary = {
+                diaryId: `diary:${day}:${Date.now()}`,
+                day,
+                observedToday,
+                notableSignals,
+                tomorrowDirection,
+                sourceRefs: aggregateSourceRefs(claims),
+                createdAt: now,
+            };
+            return { diary, errors };
+        },
+    };
+}

package/runtime/core/second-nature/quiet/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Quiet system barrel — T-DQS.C.1 exports
+ */
+export { createEvidenceAggregator, createClaimDeduplicator, createClaimSynthesizer, createSourceValidator, type EvidenceSlice, type ClaimSynthesisResult, type EvidenceAggregator, type ClaimDeduplicator, type ClaimSynthesizer, type SourceValidator, } from "./claim-synthesizer.js";
+export { createDailyDiaryWriter, type DailyDiaryResult, type DailyDiaryWriter, } from "./daily-diary-writer.js";

package/runtime/core/second-nature/quiet/index.js

@@ -0,0 +1,5 @@
+/**
+ * Quiet system barrel — T-DQS.C.1 exports
+ */
+export { createEvidenceAggregator, createClaimDeduplicator, createClaimSynthesizer, createSourceValidator, } from "./claim-synthesizer.js";
+export { createDailyDiaryWriter, } from "./daily-diary-writer.js";

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

@@ -2,15 +2,6 @@ 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,
@@ -49,7 +40,6 @@ export async function runSourceBackedQuiet(params) {
             persistedRelativePath,
         };
     }
-    const bundleRefs = runtime.lifeEvidence.evidenceRefs.map(toSourceRefFromControlPlane);
     const guidanceRefs = runtime.lifeEvidence.evidenceRefs.map(toGuidanceRef);
     const ep = buildEvidencePack(guidanceRefs);
     if (!ep.ok) {
@@ -62,11 +52,28 @@ export async function runSourceBackedQuiet(params) {
             },
         };
     }
+    if (ep.pack.sensitiveBlocked) {
+        return {
+            result: {
+                scope: "rhythm",
+                status: "denied",
+                selectedIntentId: candidate.id,
+                reasons: ["quiet_guidance_sensitive_source_blocked"],
+            },
+        };
+    }
     const basis = selectInterestBasis({
         staleness: userInterestSnapshot?.staleness ?? "insufficient",
         confidence: userInterestSnapshot?.confidence ?? 0,
         signalCount: userInterestSnapshot?.signals.length ?? 0,
     });
+    const groundedSourceRefs = ep.pack.groundedRefs.map((g) => ({
+        id: g.id,
+        kind: g.kind,
+        uri: g.uri,
+        excerptHash: g.excerptHash,
+        observedAt: g.observedAt,
+    }));
     const claims = ep.pack.groundedRefs.map((g, i) => ({
         id: `fact:${g.id}`,
         text: `Evidence-backed note ${i + 1}`,
@@ -85,9 +92,9 @@ export async function runSourceBackedQuiet(params) {
         day,
         kind: "daily_report",
         title: "Quiet daily report",
-        body: `Source-backed quiet summary (${bundleRefs.length} refs).`,
+        body: `Source-backed quiet summary (${groundedSourceRefs.length} refs).`,
         claims,
-        sourceRefs: bundleRefs,
+        sourceRefs: groundedSourceRefs,
     };
     const ack = writeQuietArtifact(reportWrite);
     const gq = buildQuietNarrativeGuidance({

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

@@ -32,6 +32,8 @@ export type CandidateEffectClass = "external_platform_action" | "connector_actio
 export interface CandidateIntent {
     id: string;
     kind: IntentKind;
+    /** Optional connector capability override, including workspace-defined behavior IDs. */
+    capabilityIntent?: string;
     priority: number;
     source: "tick" | "interrupt" | "obligation" | "quiet_plan";
     platformId?: string;

package/runtime/guidance/channel-feedback-ingestion-service.d.ts

@@ -0,0 +1,88 @@
+/**
+ * ChannelFeedbackIngestionService — T-GVS.C.2
+ *
+ * Core logic: process delivery result and owner reaction into RelationshipMemory;
+ * retry with exponential backoff on persistence failure; audit on exhaustion.
+ * Implements DR-029 (retry + audit; no silent loss) and ADR-006 (delivery truth).
+ *
+ * Boundary:
+ * - Consumes ChannelFeedback from runtime-ops-system.
+ * - Writes to state-memory-system via port (no direct DB access).
+ * - On 3 failed retries, emits observability audit event (family: guidance.feedback_ingestion_failed)
+ *   with feedback summary hash — never raw reaction content.
+ * - Missing deliveryProof → deliveryResult coerced to "not_sent".
+ *
+ * Test coverage: tests/unit/guidance/channel-feedback-ingestion.test.ts
+ */
+export type DeliveryResult = "sent" | "failed" | "not_sent";
+export type OwnerReaction = "reply" | "ignore" | "block" | "react";
+export interface DeliveryProof {
+    messageId?: string;
+    hostProofRef?: string;
+}
+export interface ChannelFeedback {
+    messageId?: string;
+    deliveryResult: DeliveryResult;
+    deliveryProof?: DeliveryProof;
+    ownerReaction: OwnerReaction;
+    reactionContent?: string;
+    timestamp: string;
+    channelId: string;
+}
+export interface RelationshipUpdate {
+    channelId: string;
+    timestamp: string;
+    trustDelta: number;
+    responsePattern: {
+        reaction: OwnerReaction;
+        timing: "immediate" | "delayed" | "very_delayed";
+        tone: "positive" | "neutral" | "negative";
+    };
+    deliverySuccess: boolean;
+}
+export interface ResponsePatternEntry {
+    reaction: OwnerReaction;
+    timing: "immediate" | "delayed" | "very_delayed";
+    tone: "positive" | "neutral" | "negative";
+    observedAt: string;
+}
+export interface ChannelPreference {
+    channelId: string;
+    successRate: number;
+    lastUsedAt?: string;
+}
+export interface RelationshipMemory {
+    channelPreferences: ChannelPreference[];
+    responsePatterns: ResponsePatternEntry[];
+    trustDelta: number;
+    lastUpdated?: string;
+}
+export interface StrategyAdjustment {
+    type: "frequency" | "tone" | "timing";
+    adjustment: string;
+    reason: string;
+    value?: number;
+}
+export interface FeedbackIngestionResult {
+    status: "ingested" | "rejected" | "failed_after_retries";
+    errors?: string[];
+    relationshipUpdate?: RelationshipUpdate;
+    strategyAdjustments?: StrategyAdjustment[];
+    updatedTrust?: number;
+}
+export interface RelationshipMemoryPort {
+    loadRelationshipMemory(): Promise<RelationshipMemory>;
+    updateRelationshipMemory(update: RelationshipMemory): Promise<void>;
+}
+export interface FeedbackAuditPort {
+    recordFeedbackIngestionFailed(summary: {
+        feedbackId: string;
+        channelId: string;
+        summaryHash: string;
+        retryCount: number;
+    }): Promise<void>;
+}
+export declare function ingestChannelFeedback(feedback: ChannelFeedback, deps: {
+    relationshipPort: RelationshipMemoryPort;
+    auditPort: FeedbackAuditPort;
+}): Promise<FeedbackIngestionResult>;