@haaaiawd/second-nature 0.1.25 → 0.1.26

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

@@ -8,6 +8,8 @@ import { buildJudgeOutreachInputFromSnapshot } from "../outreach/judge-input-fro
 import { runSourceBackedQuiet } from "../quiet/run-source-backed-quiet.js";
 import { toCapabilityIntent } from "../orchestrator/effect-dispatcher.js";
 import { updateNarrativeAfterEffect } from "../orchestrator/narrative-update.js";
+import { mapLifeEvidence } from "../../../connectors/base/map-life-evidence.js";
+import { appendLifeEvidence } from "../../../storage/life-evidence/append-life-evidence.js";
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
@@ -52,19 +54,53 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
         intent.kind === "maintenance";
     const connectorUnwired = intent.effectClass === "connector_action";
     if (connectorUnwired && deps.connectorExecutor) {
+        if (!intent.platformId || intent.platformId === "unknown") {
+            return {
+                scope: "rhythm",
+                status: "intent_selected",
+                selectedIntentId: intent.id,
+                decisionId: `decision:${intent.id}:${Date.now()}`,
+                reasons: ["connector_dispatch_unavailable"],
+            };
+        }
+        const decisionId = `decision:${intent.id}:${Date.now()}`;
         const result = await deps.connectorExecutor.executeEffect({
-            platformId: intent.platformId ?? "unknown",
+            platformId: intent.platformId,
             intent: toCapabilityIntent(intent),
             payload: {},
-            decisionId: `decision:${intent.id}:${Date.now()}`,
+            decisionId,
             intentId: intent.id,
             idempotencyKey: `idem:${intent.id}:${Date.now()}`,
         });
+        // T3.3.1: on success, map connector result to life evidence and append.
+        // On failure or empty result, no evidence is fabricated — attempt audit
+        // is already recorded by the connector policy layer telemetry.
+        if (result.status === "success" &&
+            deps.state &&
+            deps.workspaceRoot) {
+            try {
+                const candidate = mapLifeEvidence({
+                    platformId: intent.platformId,
+                    intent: toCapabilityIntent(intent),
+                    result,
+                    observedAt: new Date().toISOString(),
+                });
+                if (candidate) {
+                    await appendLifeEvidence(deps.state, deps.workspaceRoot, candidate);
+                }
+            }
+            catch (err) {
+                // Evidence append must not break the heartbeat cycle.
+                // Missing evidence will be reflected in the next snapshot load.
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                console.warn(`[heartbeat] evidence append failed for ${intent.platformId ?? "unknown"}: ${errorMessage}`);
+            }
+        }
         const base = {
             scope: "rhythm",
             status: "intent_selected",
             selectedIntentId: intent.id,
-            decisionId: `decision:${intent.id}:${Date.now()}`,
+            decisionId,
             reasons: result.status === "success"
                 ? ["connector_effect_executed"]
                 : result.status === "retryable_failure"
@@ -163,7 +199,12 @@ export async function ingestRhythmSignal(signal, deps) {
     const snapshot = buildContinuitySnapshot(inputs);
     const timestamp = signal.payload.timestamp;
     const runtime = buildHeartbeatRuntimeSnapshot(timestamp, inputs, snapshot);
-    const rawCandidates = planCandidateIntents(runtime);
+    const rawCandidates = planCandidateIntents(runtime, {
+        acceptedGoals: inputs.acceptedGoals,
+        connectorRegistry: deps.connectorRegistry,
+        narrativeState: runtime.narrativeState,
+        relationshipMemory: runtime.relationshipMemory,
+    });
     const { candidates } = applyGoalPriority(rawCandidates, inputs.acceptedGoals);
     const emitTrace = async (result) => {
         if (!deps.recordDecisionTrace)

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

@@ -21,6 +21,8 @@ export interface HeartbeatRuntimeSnapshot {
     lifeEvidence: PlannerLifeEvidenceSlice;
     rhythmWindow: PlannerRhythmWindowSlice;
     hardGuards: HardGuardDeps;
+    narrativeState?: import("../../../storage/narrative/narrative-state-store.js").NarrativeState;
+    relationshipMemory?: import("../../../storage/relationship/relationship-memory-store.js").RelationshipMemory;
 }
 export declare function buildLifeEvidenceSliceFromInputs(inputs: SnapshotInputs): PlannerLifeEvidenceSlice;
 export declare function buildHardGuardDeps(continuity: ContinuitySnapshot, inputs: SnapshotInputs): HardGuardDeps;

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

@@ -31,5 +31,5 @@ export function buildHeartbeatRuntimeSnapshot(timestamp, inputs, continuity) {
     const rhythmWindow = buildPlannerRhythmWindow(timestamp, continuity, policy);
     const lifeEvidence = buildLifeEvidenceSliceFromInputs(inputs);
     const hardGuards = buildHardGuardDeps(continuity, inputs);
-    return { continuity, lifeEvidence, rhythmWindow, hardGuards };
+    return { continuity, lifeEvidence, rhythmWindow, hardGuards, narrativeState: inputs.narrativeState, relationshipMemory: inputs.relationshipMemory };
 }

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

@@ -10,7 +10,8 @@ import type { ContinuitySnapshot, ControlPlaneSourceRef, TopLevelMode } from "..
 import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
 import type { DeliveryCapabilitySnapshot } from "../outreach/delivery-target.js";
 import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
-import type { AgentGoal } from "../../../storage/goal/agent-goal-store.js";
+import type { NarrativeState } from "../../../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../../../storage/relationship/relationship-memory-store.js";
 export interface SnapshotInputs {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -43,7 +44,20 @@ export interface SnapshotInputs {
     /** When present, outreach judgment uses this user-interest read model (T4.2.2). */
     userInterestSnapshot?: UserInterestSnapshot;
     /** T2.1.4: accepted goals to influence candidate intent priority. */
-    acceptedGoals?: AgentGoal[];
+    acceptedGoals?: Array<{
+        goalId: string;
+        description: string;
+        completionCriteria?: string;
+        status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+        origin: "owner_set" | "agent_proposed" | "policy_seeded";
+        acceptedBy?: "owner" | "policy_allowlist";
+    }>;
+    /** When present, signals that acceptedGoals load failed (distinguishes from empty). */
+    acceptedGoalsLoadError?: string;
+    /** When present, planner uses narrative focus to influence candidate priority. */
+    narrativeState?: NarrativeState;
+    /** When present, planner uses relationship memory to influence outreach timing. */
+    relationshipMemory?: RelationshipMemory;
 }
 /**
  * Build a ContinuitySnapshot from loaded inputs.

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

@@ -20,3 +20,4 @@ export * from "./outreach/judge-input-from-snapshot.js";
 export * from "./quiet/run-source-backed-quiet.js";
 export * from "./guidance/request-guidance.js";
 export * from "./guidance/apply-guidance.js";
+export * from "./feedback/owner-reply-feedback.js";

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

@@ -20,3 +20,4 @@ export * from "./outreach/judge-input-from-snapshot.js";
 export * from "./quiet/run-source-backed-quiet.js";
 export * from "./guidance/request-guidance.js";
 export * from "./guidance/apply-guidance.js";
+export * from "./feedback/owner-reply-feedback.js";

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

@@ -8,7 +8,19 @@
  * All other statuses (proposal / rejected / completed / paused) are implicitly excluded.
  */
 import type { CandidateIntent } from "../types.js";
-import type { AgentGoal } from "../../../storage/goal/agent-goal-store.js";
+/**
+ * Minimal goal context used by the priority module to avoid coupling
+ * to the full AgentGoal schema. M-03 decoupling.
+ */
+export interface GoalPriorityContext {
+    goalId: string;
+    description: string;
+    completionCriteria?: string;
+    status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+    origin: "owner_set" | "agent_proposed" | "policy_seeded";
+    acceptedBy?: "owner" | "policy_allowlist";
+}
+export declare function isGoalRelatedToCandidate(goal: GoalPriorityContext, candidate: CandidateIntent): boolean;
 export interface ApplyGoalPriorityResult {
     candidates: CandidateIntent[];
     goalInfluences: Array<{
@@ -17,4 +29,4 @@ export interface ApplyGoalPriorityResult {
         boost: number;
     }>;
 }
-export declare function applyGoalPriority(candidates: CandidateIntent[], goals: AgentGoal[] | undefined): ApplyGoalPriorityResult;
+export declare function applyGoalPriority(candidates: CandidateIntent[], goals: GoalPriorityContext[] | undefined): ApplyGoalPriorityResult;

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

@@ -6,8 +6,8 @@
  * range from 40–100, so 200 provides ample headroom without overflow.
  */
 const GOAL_PRIORITY_BOOST = 20;
-function isGoalRelatedToCandidate(goal, candidate) {
-    const goalText = `${goal.description} ${goal.completionCriteria}`.toLowerCase();
+export function isGoalRelatedToCandidate(goal, candidate) {
+    const goalText = `${goal.description} ${goal.completionCriteria ?? ""}`.toLowerCase();
     // Direct platformId mention in goal text
     if (candidate.platformId) {
         const platformId = candidate.platformId.toLowerCase();

package/runtime/core/second-nature/orchestrator/intent-planner.d.ts

@@ -4,10 +4,38 @@
  */
 import type { CandidateIntent, ContinuitySnapshot, DecisionBasis } from "../types.js";
 import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
+import type { NarrativeState } from "../../../storage/narrative/narrative-state-store.js";
+import type { RelationshipMemory } from "../../../storage/relationship/relationship-memory-store.js";
+import { type PlatformResolutionContext } from "./platform-capability-router.js";
+import { type GoalPriorityContext } from "./goal-priority.js";
+/** Alias for GoalPriorityContext to keep intent-planner local naming consistent. M-03 decoupling. */
+export type GoalContext = GoalPriorityContext;
+export interface PlanIntentOptions {
+    narrativeState?: NarrativeState;
+    relationshipMemory?: RelationshipMemory;
+    budgetCheck?: boolean;
+    multiSource?: string[];
+}
+/**
+ * Factory for planning a candidate intent of a given kind.
+ * M-04: consolidates the previously separate plan{Work,Exploration,Social,Outreach}Intents.
+ */
+export declare function planIntentWithKind(kind: "work" | "exploration" | "social" | "outreach", basePriority: number, runtime: HeartbeatRuntimeSnapshot, context: PlatformResolutionContext, registry?: CapabilityContractRegistry, options?: PlanIntentOptions): CandidateIntent[];
+export interface PlanCandidateIntentsOptions {
+    /** T2.4.1: accepted goals for platform-specific resolution. */
+    acceptedGoals?: GoalContext[];
+    /** T2.4.1: optional connector registry for capability validation. */
+    connectorRegistry?: CapabilityContractRegistry;
+    /** CR-02: optional narrative state to influence candidate priority. */
+    narrativeState?: NarrativeState;
+    /** CR-02: optional relationship memory to influence outreach timing. */
+    relationshipMemory?: RelationshipMemory;
+}
 /**
  * Plan ordered candidates for one heartbeat turn using rhythm window + life evidence slice.
  */
-export declare function planCandidateIntents(runtime: HeartbeatRuntimeSnapshot): CandidateIntent[];
+export declare function planCandidateIntents(runtime: HeartbeatRuntimeSnapshot, options?: PlanCandidateIntentsOptions): CandidateIntent[];
 /** @deprecated Continuity-only helper for tests; prefer `planCandidateIntents` + `buildHeartbeatRuntimeSnapshot`. */
 export declare function planIntent(snapshot: ContinuitySnapshot): CandidateIntent[];
 export declare function decideDecisionBasis(intent: CandidateIntent): DecisionBasis;

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

@@ -1,5 +1,7 @@
 import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
 import { buildHeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+import { resolvePlatformForIntent, } from "./platform-capability-router.js";
+import { isGoalRelatedToCandidate } from "./goal-priority.js";
 const MAX_CANDIDATE_INTENTS = 6;
 const OBLIGATION_SOURCE = [
     { id: "obligation-anchor", kind: "workspace_artifact", uri: "workspace://obligations/pending" },
@@ -8,72 +10,131 @@ function evidenceRefsForConnector(runtime) {
     if (!isLifeEvidenceSliceEmpty(runtime.lifeEvidence) && runtime.lifeEvidence.evidenceRefs.length > 0) {
         return runtime.lifeEvidence.evidenceRefs.slice(0, 8);
     }
-    if (!isLifeEvidenceSliceEmpty(runtime.lifeEvidence)) {
-        return [
-            {
-                id: "life-evidence-summary",
-                kind: "connector_result",
-                uri: `workspace://life-evidence/counts/${runtime.lifeEvidence.platformEventCount}/${runtime.lifeEvidence.workEventCount}`,
-            },
-        ];
-    }
     return [];
 }
 function isAllowedKind(kind, runtime) {
     return runtime.rhythmWindow.allowedIntentKinds.includes(kind);
 }
-function planWorkIntents(runtime) {
-    if (!isAllowedKind("work", runtime))
-        return [];
-    return runtime.continuity.pendingObligations.map((obligation, index) => ({
-        id: `intent-obligation-${index}`,
-        kind: "work",
-        priority: 100 - index,
+function focusMatchesKind(focus, kind) {
+    const lower = focus.toLowerCase();
+    switch (kind) {
+        case "work":
+            return lower.includes("work") || lower.includes("obligation") || lower.includes("task");
+        case "exploration":
+            return lower.includes("explor") || lower.includes("opportunit") || lower.includes("scan") || lower.includes("discover");
+        case "social":
+            return lower.includes("social") || lower.includes("engage") || lower.includes("community");
+        case "outreach":
+            return lower.includes("outreach") || lower.includes("user") || lower.includes("proactive") || lower.includes("contact");
+        case "quiet":
+            return lower.includes("quiet") || lower.includes("bookkeep") || lower.includes("pause");
+        case "reflection":
+            return lower.includes("reflect") || lower.includes("narrative") || lower.includes("review");
+        case "maintenance":
+            return lower.includes("maintenance") || lower.includes("check") || lower.includes("upkeep");
+        default:
+            return false;
+    }
+}
+const INTENT_CONFIGS = {
+    work: {
+        basePriority: 100,
+        effectClass: "connector_action",
+        summary: (platformId, detail) => platformId ? `fulfill obligation on ${platformId}: ${detail}` : `fulfill obligation: ${detail}`,
         source: "obligation",
-        summary: `fulfill obligation: ${obligation}`,
+        idPrefix: "intent-obligation",
+        idempotencyPrefix: "obligation",
+    },
+    exploration: {
+        basePriority: 70,
         effectClass: "connector_action",
-        sourceRefs: [...OBLIGATION_SOURCE],
-        idempotencyKey: `obligation:${obligation}:${index}`,
-        goalInfluenceRefs: [],
-    }));
-}
-function planExplorationIntents(runtime) {
-    if (!isAllowedKind("exploration", runtime))
+        summary: (platformId) => platformId ? `scan platform opportunities on ${platformId}` : "scan platform opportunities",
+        source: "tick",
+        idPrefix: "intent-exploration",
+        idempotencyPrefix: "exploration",
+    },
+    social: {
+        basePriority: 60,
+        effectClass: "connector_action",
+        summary: (platformId) => platformId ? `engage social platforms on ${platformId}` : "engage social platforms",
+        source: "tick",
+        idPrefix: "intent-social",
+        idempotencyPrefix: "social",
+    },
+    outreach: {
+        basePriority: 40,
+        effectClass: "user_outreach",
+        summary: (platformId) => platformId ? `consider proactive user outreach on ${platformId}` : "consider proactive user outreach",
+        source: "tick",
+        idPrefix: "intent-outreach",
+        idempotencyPrefix: "outreach",
+    },
+};
+/**
+ * Factory for planning a candidate intent of a given kind.
+ * M-04: consolidates the previously separate plan{Work,Exploration,Social,Outreach}Intents.
+ */
+export function planIntentWithKind(kind, basePriority, runtime, context, registry, options) {
+    if (!isAllowedKind(kind, runtime))
         return [];
-    const refs = evidenceRefsForConnector(runtime);
-    return [
-        {
-            id: "intent-exploration",
-            kind: "exploration",
-            priority: 70,
-            source: "tick",
-            summary: "scan platform opportunities",
-            effectClass: "connector_action",
-            sourceRefs: refs,
-            idempotencyKey: "exploration:scan platform opportunities",
+    const config = INTENT_CONFIGS[kind];
+    const platformId = resolvePlatformForIntent(kind, context ?? {}, registry);
+    let priority = basePriority;
+    // Social budget exhaustion → cap priority.
+    if (kind === "social" &&
+        runtime.continuity.budgets &&
+        runtime.continuity.budgets.socialUsed >= runtime.continuity.budgets.socialLimit) {
+        priority = 10;
+    }
+    // Narrative focus bias (preserved from original per-kind functions).
+    if (options?.narrativeState?.focus && focusMatchesKind(options.narrativeState.focus, kind)) {
+        priority += 15;
+    }
+    // Outreach suppression checks.
+    if (kind === "outreach") {
+        if (runtime.continuity.recentOutreachHashes.length > 3) {
+            return [];
+        }
+        if (options?.relationshipMemory && options.relationshipMemory.noReplyCount > 3) {
+            return [];
+        }
+    }
+    // Work special case: multi-source from pending obligations.
+    if (kind === "work" && options?.multiSource) {
+        return options.multiSource.map((source, index) => ({
+            id: platformId ? `${config.idPrefix}-${platformId}-${index}` : `${config.idPrefix}-${index}`,
+            kind: "work",
+            priority: basePriority - index,
+            source: "obligation",
+            platformId,
+            summary: config.summary(platformId, source),
+            effectClass: config.effectClass,
+            sourceRefs: [...OBLIGATION_SOURCE],
+            idempotencyKey: platformId
+                ? `${config.idempotencyPrefix}:${platformId}:${source}:${index}`
+                : `${config.idempotencyPrefix}:${source}:${index}`,
             goalInfluenceRefs: [],
-        },
-    ];
-}
-function planSocialIntents(runtime) {
-    if (!isAllowedKind("social", runtime))
-        return [];
-    const refs = evidenceRefsForConnector(runtime);
+        }));
+    }
+    const refs = kind === "work" ? [...OBLIGATION_SOURCE] : evidenceRefsForConnector(runtime);
     return [
         {
-            id: "intent-social",
-            kind: "social",
-            priority: runtime.continuity.budgets && runtime.continuity.budgets.socialUsed >= runtime.continuity.budgets.socialLimit ? 10 : 60,
-            source: "tick",
-            summary: "engage social platforms",
-            effectClass: "connector_action",
+            id: platformId ? `${config.idPrefix}-${platformId}` : config.idPrefix,
+            kind,
+            priority,
+            source: config.source,
+            platformId,
+            summary: config.summary(platformId),
+            effectClass: config.effectClass,
             sourceRefs: refs,
-            idempotencyKey: "social:engage social platforms",
+            idempotencyKey: platformId
+                ? `${config.idempotencyPrefix}:${platformId}`
+                : `${config.idempotencyPrefix}:${config.summary(undefined)}`,
             goalInfluenceRefs: [],
         },
     ];
 }
-function planQuietReflectionIntents(runtime) {
+function planQuietReflectionIntents(runtime, _context, _registry) {
     if (!runtime.rhythmWindow.quietBias && runtime.continuity.mode !== "quiet") {
         return [];
     }
@@ -120,31 +181,17 @@ function planQuietReflectionIntents(runtime) {
     }
     return out;
 }
-function planOutreachIntents(runtime) {
-    if (!isAllowedKind("outreach", runtime))
-        return [];
-    if (runtime.continuity.recentOutreachHashes.length > 3) {
-        return [];
-    }
-    const refs = evidenceRefsForConnector(runtime);
-    return [
-        {
-            id: "intent-outreach",
-            kind: "outreach",
-            priority: 40,
-            source: "tick",
-            summary: "consider proactive user outreach",
-            effectClass: "user_outreach",
-            sourceRefs: refs,
-            idempotencyKey: "outreach:consider proactive user outreach",
-            goalInfluenceRefs: [],
-        },
-    ];
-}
 /**
  * Plan ordered candidates for one heartbeat turn using rhythm window + life evidence slice.
  */
-export function planCandidateIntents(runtime) {
+export function planCandidateIntents(runtime, options) {
+    const context = {
+        acceptedGoals: options?.acceptedGoals,
+        evidenceRefs: runtime.lifeEvidence.evidenceRefs,
+    };
+    const registry = options?.connectorRegistry;
+    const narrativeState = options?.narrativeState ?? runtime.narrativeState;
+    const relationshipMemory = options?.relationshipMemory ?? runtime.relationshipMemory;
     if (runtime.continuity.mode === "paused_for_interrupt") {
         const pausedMaintenance = [
             {
@@ -164,16 +211,44 @@ export function planCandidateIntents(runtime) {
             .slice(0, MAX_CANDIDATE_INTENTS);
     }
     if (runtime.continuity.mode === "maintenance_only") {
-        return planWorkIntents(runtime).sort((a, b) => b.priority - a.priority).slice(0, MAX_CANDIDATE_INTENTS);
+        return planIntentWithKind("work", INTENT_CONFIGS.work.basePriority, runtime, context, registry, { multiSource: runtime.continuity.pendingObligations })
+            .sort((a, b) => b.priority - a.priority)
+            .slice(0, MAX_CANDIDATE_INTENTS);
     }
     const intents = [
-        ...planWorkIntents(runtime),
-        ...planExplorationIntents(runtime),
-        ...planSocialIntents(runtime),
-        ...planQuietReflectionIntents(runtime),
-        ...planOutreachIntents(runtime),
+        ...planIntentWithKind("work", INTENT_CONFIGS.work.basePriority, runtime, context, registry, { multiSource: runtime.continuity.pendingObligations }),
+        ...planIntentWithKind("exploration", INTENT_CONFIGS.exploration.basePriority, runtime, context, registry),
+        ...planIntentWithKind("social", INTENT_CONFIGS.social.basePriority, runtime, context, registry, {
+            narrativeState,
+            budgetCheck: true,
+        }),
+        ...planQuietReflectionIntents(runtime, context, registry),
+        ...planIntentWithKind("outreach", INTENT_CONFIGS.outreach.basePriority, runtime, context, registry, {
+            narrativeState,
+            relationshipMemory,
+        }),
     ];
-    return intents
+    // Pre-fill goalInfluenceRefs for non-obligation intents before returning.
+    // applyGoalPriority will later refine/override with the same logic.
+    const acceptedGoals = options?.acceptedGoals?.filter((g) => g.status === "accepted" &&
+        (g.origin !== "agent_proposed" || g.acceptedBy === "policy_allowlist")) ?? [];
+    for (const intent of intents) {
+        if (intent.source === "obligation")
+            continue;
+        const related = acceptedGoals.filter((g) => isGoalRelatedToCandidate(g, intent));
+        if (related.length > 0) {
+            intent.goalInfluenceRefs = related.map((g) => g.goalId);
+        }
+    }
+    // CR-02: apply narrative-focus bias globally across all candidate kinds.
+    const adjusted = intents.map((intent) => {
+        let priority = intent.priority;
+        if (narrativeState?.focus && focusMatchesKind(narrativeState.focus, intent.kind)) {
+            priority += 15;
+        }
+        return { ...intent, priority };
+    });
+    return adjusted
         .filter((intent) => runtime.rhythmWindow.allowedIntentKinds.includes(intent.kind))
         .sort((a, b) => b.priority - a.priority)
         .slice(0, MAX_CANDIDATE_INTENTS);

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

@@ -11,19 +11,32 @@ function mapControlPlaneRefToSourceRef(ref) {
 /**
  * Compute narrative confidence based on source evidence.
  *
- * Formula: min(intentSources / 3, 1) + (lifeEvidenceSources > 0 ? 0.1 : 0)
+ * Formula: smooth sigmoid-like growth:
+ *   - 0 sources → 0
+ *   - 1 source → 0.35 (not 0.43; single-source is weak but non-zero)
+ *   - 2 sources → 0.60 (beginning to be trustworthy)
+ *   - 3 sources → 0.80 (strong confidence, not 1.0)
+ *   - 4+ sources → 0.90 (cap below 1.0 to avoid false certainty)
+ *   - Boost: +0.05 if corroborating life evidence exists
+ *   - Hard cap at 0.95 (never claim 100% certainty from evidence count alone)
  *
- * Rationale:
- * - Base: 1/3 per intent source (3 sources = 100% confidence)
- * - Boost: +0.1 if any life evidence exists (signals corroboration)
- * - Capped at 1.0 (100%)
+ * Rationale: linear 1/3 per source produces unnatural jumps.
+ * Logarithmic growth better models diminishing returns per extra source.
  */
 function computeConfidence(intentSources, lifeEvidenceSources) {
     if (intentSources === 0 && lifeEvidenceSources === 0)
         return 0;
-    const base = Math.min(intentSources / 3, 1);
-    const boost = lifeEvidenceSources > 0 ? 0.1 : 0;
-    return Math.min(base + boost, 1);
+    const base = intentSources === 0
+        ? 0
+        : intentSources === 1
+            ? 0.35
+            : intentSources === 2
+                ? 0.60
+                : intentSources === 3
+                    ? 0.80
+                    : 0.90;
+    const boost = lifeEvidenceSources > 0 ? 0.05 : 0;
+    return Math.min(base + boost, 0.95);
 }
 /**
  * Build the next NarrativeState revision from a completed heartbeat cycle.
@@ -48,7 +61,8 @@ export function updateNarrativeAfterEffect(input) {
         const sourceRefs = selectedIntent.sourceRefs.map(mapControlPlaneRefToSourceRef);
         if (hasIntentSources || hasLifeEvidence) {
             // Source-backed revision
-            const progressEntry = `${selectedIntent.effectClass}: ${selectedIntent.summary}`;
+            // L-03: Use effectClass + id as dedup key instead of full summary text.
+            const progressEntry = `${selectedIntent.effectClass}: ${selectedIntent.id}`;
             const progress = [...(prior?.progress ?? [])];
             if (!progress.includes(progressEntry)) {
                 progress.push(progressEntry);

package/runtime/core/second-nature/orchestrator/platform-capability-router.d.ts

@@ -0,0 +1,34 @@
+/**
+ * T2.4.1 — Platform-specific intent resolution.
+ *
+ * When accepted goals, narrative, or connector evidence point to a specific
+ * platform, the planner emits a `CandidateIntent` with an explicit
+ * `platformId`.  If the platform cannot be inferred, the caller falls
+ * back to the generic connector_action path (platformId undefined).
+ *
+ * Boundaries:
+ * - Does NOT execute connectors; only resolves platform + capability.
+ * - Does NOT validate credentials; that is the guard layer's job.
+ * - Optional registry: when absent, resolution is best-effort from goals/evidence.
+ */
+import type { IntentKind } from "../types.js";
+import type { ControlPlaneSourceRef } from "../types.js";
+import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
+/** Minimal goal shape accepted by the router to avoid coupling to AgentGoal. M-03 decoupling. */
+interface GoalRouterContext {
+    goalId: string;
+    description: string;
+    completionCriteria?: string;
+}
+export interface PlatformResolutionContext {
+    /** Accepted goals that may name a platform or capability. */
+    acceptedGoals?: GoalRouterContext[];
+    /** Evidence refs that may embed platform identity. */
+    evidenceRefs?: ControlPlaneSourceRef[];
+}
+/**
+ * Resolve an explicit platformId for a candidate intent kind.
+ * Returns `undefined` when no unambiguous platform can be inferred.
+ */
+export declare function resolvePlatformForIntent(kind: IntentKind, context: PlatformResolutionContext, registry?: CapabilityContractRegistry): string | undefined;
+export {};