@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/src/core/second-nature/heartbeat/heartbeat-loop.js

@@ -0,0 +1,397 @@
+import { buildContinuitySnapshot, } from "./snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot, } from "./runtime-snapshot.js";
+import { planCandidateIntents } from "../orchestrator/intent-planner.js";
+import { applyGoalPriority } from "../orchestrator/goal-priority.js";
+import { evaluateHardGuards } from "../orchestrator/guard-layer.js";
+import { dispatchUserOutreachIntent, } from "../outreach/dispatch-user-outreach.js";
+import { buildJudgeOutreachInputFromSnapshot } from "../outreach/judge-input-from-snapshot.js";
+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).
+ */
+export async function resolveAllowedIntentResult(intent, runtime, inputs, signal, deps) {
+    const day = typeof signal.payload.timestamp === "string"
+        ? signal.payload.timestamp.slice(0, 10)
+        : "1970-01-01";
+    if (intent.effectClass === "user_outreach" && deps.outreachDispatch) {
+        return dispatchUserOutreachIntent({
+            candidate: intent,
+            snapshot: runtime,
+            judgeInput: buildJudgeOutreachInputFromSnapshot(intent, runtime, inputs),
+            guidance: deps.outreachDispatch.guidance,
+            delivery: deps.outreachDispatch.delivery,
+            state: deps.outreachDispatch.state,
+        });
+    }
+    if (deps.quietWorkflow &&
+        (intent.kind === "quiet" ||
+            (intent.kind === "reflection" &&
+                intent.effectClass === "narrative_reflection"))) {
+        const quietRun = await runSourceBackedQuiet({
+            candidate: intent,
+            runtime,
+            day,
+            userInterestSnapshot: inputs.userInterestSnapshot,
+            workspaceRoot: deps.quietWorkflow.workspaceRoot,
+            // v7 T-V7C.C.3: pass Dream schedule port so Quiet completion triggers Dream.
+            dreamSchedulePort: deps.quietWorkflow.dreamSchedulePort,
+        });
+        return quietRun.result;
+    }
+    // T2.2.3 (CH-14-02/03 / CH-15-01): all intent_selected results must carry at least one
+    // machine-readable reason so operators can distinguish between effect classes:
+    //   - maintenance / no_effect → "internal_tick" (no external side-effects)
+    //   - connector_action without dispatch wired → "connector_dispatch_unwired"
+    //   - external_platform_action / memory_curation → not generated by intent-planner today;
+    //     if a future path produces them, they will reach the fallback [] branch below and
+    //     should have dedicated reason codes added (e.g. "external_platform_action_unwired").
+    //   - other (outreach / quiet) → caught by the early-return branches above
+    const noExternalEffect = intent.effectClass === "maintenance" ||
+        intent.effectClass === "no_effect" ||
+        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()}`;
+        // T-V7C.C.4: inject identity from EmbodiedContext into connector request (readable, no credential)
+        const platformHandle = runtime.identity?.platformHandles.find((h) => h.platformId === intent.platformId)?.handle;
+        const result = await deps.connectorExecutor.executeEffect({
+            platformId: intent.platformId,
+            intent: toCapabilityIntent(intent),
+            payload: {},
+            decisionId,
+            intentId: intent.id,
+            idempotencyKey: `idem:${intent.id}:${Date.now()}`,
+            identity: platformHandle || runtime.identity?.canonicalName
+                ? {
+                    platformHandle,
+                    canonicalName: runtime.identity?.canonicalName,
+                }
+                : undefined,
+        });
+        // 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}`);
+            }
+        }
+        // v7 T-V7C.C.2: record ToolExperience for all connector attempts in heartbeat.
+        if (deps.experienceWriter) {
+            try {
+                await deps.experienceWriter.recordExperience({
+                    connectorId: intent.platformId,
+                    capabilityId: toCapabilityIntent(intent),
+                    result,
+                    triggerSource: "heartbeat",
+                });
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                console.warn(`[heartbeat] ToolExperience record failed for ${intent.platformId ?? "unknown"}: ${errorMessage}`);
+            }
+        }
+        // v7 T-BTS.C.5: update circuit breaker state after connector execution.
+        if (deps.circuitBreakerManager && intent.platformId && intent.capabilityIntent) {
+            try {
+                if (result.status === "success") {
+                    await deps.circuitBreakerManager.evaluateSuccess(intent.platformId, intent.capabilityIntent);
+                }
+                else {
+                    await deps.circuitBreakerManager.evaluateFailure(intent.platformId, intent.capabilityIntent);
+                }
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                console.warn(`[heartbeat] CircuitBreaker update failed for ${intent.platformId ?? "unknown"}: ${errorMessage}`);
+            }
+        }
+        const base = {
+            scope: "rhythm",
+            status: "intent_selected",
+            selectedIntentId: intent.id,
+            decisionId,
+            reasons: result.status === "success"
+                ? ["connector_effect_executed"]
+                : result.status === "retryable_failure"
+                    ? ["connector_retryable_failure", result.failureClass ?? "unknown"]
+                    : ["connector_terminal_failure", result.failureClass ?? "unknown"],
+        };
+        return base;
+    }
+    const reasons = noExternalEffect
+        ? ["internal_tick"]
+        : connectorUnwired
+            ? ["connector_dispatch_unwired"]
+            : [];
+    return {
+        scope: "rhythm",
+        status: "intent_selected",
+        selectedIntentId: intent.id,
+        reasons,
+    };
+}
+/**
+ * T2.1.5: after the cycle result is known, write a narrative revision when
+ * a NarrativeStateStore is wired. Errors are swallowed so the cycle result
+ * is never blocked by a store failure. Store failures are optionally traced
+ * via recordDecisionTrace so operators can monitor store health.
+ */
+async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store, recordTrace, signal, recordNarrativeTrace) {
+    if (!store)
+        return;
+    try {
+        const prior = await store.loadNarrativeState();
+        const update = updateNarrativeAfterEffect({
+            result,
+            selectedIntent,
+            lifeEvidence: runtime.lifeEvidence,
+            priorNarrative: prior,
+        });
+        await store.updateNarrativeState(update);
+        // T5.1.2: record NarrativeTrace on successful state update
+        if (recordNarrativeTrace) {
+            try {
+                await recordNarrativeTrace({
+                    traceId: `narrative_trace:${crypto.randomUUID()}`,
+                    narrativeId: update.narrativeId,
+                    revision: update.revision,
+                    updateSource: "heartbeat",
+                    sourceRefs: update.sourceRefs.map((r) => ({
+                        id: r.sourceId,
+                        kind: r.kind,
+                        uri: r.url,
+                    })),
+                    unsupportedClaims: update.unsupportedClaims,
+                    groundingStatus: update.unsupportedClaims.length > 0
+                        ? "degraded"
+                        : update.status === "insufficient_sources"
+                            ? "blocked"
+                            : "pass",
+                    goalInfluenceRefs: selectedIntent?.goalInfluenceRefs ?? [],
+                    createdAt: update.updatedAt,
+                });
+            }
+            catch {
+                // trace emission must not block the cycle
+            }
+        }
+    }
+    catch {
+        // degrade silently; narrative update is best-effort
+        if (recordTrace && signal) {
+            try {
+                await recordTrace({
+                    scope: result.scope,
+                    status: result.status,
+                    reasons: ["narrative_update_failed"],
+                    selectedIntentId: selectedIntent?.id,
+                    rhythmWindowId: runtime.rhythmWindow.windowId,
+                    allowedIntentKinds: [...runtime.rhythmWindow.allowedIntentKinds],
+                    candidateCount: 0,
+                    lifeEvidenceEmpty: runtime.lifeEvidence.evidenceRefs.length === 0 &&
+                        runtime.lifeEvidence.platformEventCount === 0 &&
+                        runtime.lifeEvidence.workEventCount === 0,
+                    trigger: signal.trigger,
+                });
+            }
+            catch {
+                // trace emission must also not block the cycle
+            }
+        }
+    }
+}
+/**
+ * Ingest a heartbeat rhythm signal and drive one full decision round.
+ */
+export async function ingestRhythmSignal(signal, deps) {
+    const inputs = await deps.loadSnapshotInputs();
+    const snapshot = buildContinuitySnapshot(inputs);
+    const timestamp = signal.payload.timestamp;
+    const runtime = buildHeartbeatRuntimeSnapshot(timestamp, inputs, snapshot);
+    // v7 T-CP.C.3: evaluate goal lifecycle transitions before candidate planning.
+    let goalTransitions = [];
+    if (deps.goalLifecyclePolicy && inputs.acceptedGoals) {
+        try {
+            const policyResult = deps.goalLifecyclePolicy.evaluate(inputs.acceptedGoals);
+            goalTransitions = policyResult.transitionRequests;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[heartbeat] Goal lifecycle evaluation failed: ${msg}`);
+        }
+    }
+    const rawCandidates = planCandidateIntents(runtime, {
+        acceptedGoals: inputs.acceptedGoals,
+        connectorRegistry: deps.connectorRegistry,
+        narrativeState: runtime.narrativeState,
+        relationshipMemory: runtime.relationshipMemory,
+    });
+    // v7 T-CP.C.3: when no active goals and no connector candidates, use idle curiosity.
+    let allCandidates = rawCandidates;
+    if (deps.idleCuriosityPolicy && runtime.affordanceMap) {
+        const hasActiveGoals = (inputs.acceptedGoals ?? []).some((g) => g.status === "accepted");
+        const hasConnectorCandidates = rawCandidates.some((c) => c.effectClass === "connector_action" || c.effectClass === "external_platform_action");
+        if (!hasActiveGoals && !hasConnectorCandidates) {
+            try {
+                const idleResult = deps.idleCuriosityPolicy.select(runtime.affordanceMap, []);
+                if (idleResult.candidate) {
+                    const idleIntent = {
+                        id: `intent-idle-${idleResult.candidate.platformId}-${idleResult.candidate.capabilityId}`,
+                        kind: "exploration",
+                        priority: 30,
+                        source: "tick",
+                        platformId: idleResult.candidate.platformId,
+                        summary: `idle curiosity: ${idleResult.candidate.intent}`,
+                        effectClass: "connector_action",
+                        capabilityIntent: idleResult.candidate.capabilityId,
+                        sourceRefs: [
+                            {
+                                id: "idle_curiosity",
+                                kind: "workspace_artifact",
+                                uri: `idle://${idleResult.candidate.platformId}`,
+                            },
+                        ],
+                        idempotencyKey: `idle:${idleResult.candidate.platformId}:${idleResult.candidate.capabilityId}`,
+                        goalInfluenceRefs: [],
+                    };
+                    allCandidates = [...rawCandidates, idleIntent];
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(`[heartbeat] Idle curiosity selection failed: ${msg}`);
+            }
+        }
+    }
+    const { candidates } = applyGoalPriority(allCandidates, inputs.acceptedGoals);
+    const emitTrace = async (result) => {
+        if (!deps.recordDecisionTrace)
+            return;
+        const traceReasons = [...result.reasons];
+        if (goalTransitions.length > 0) {
+            traceReasons.push(`goal_transitions:${goalTransitions.length}`);
+        }
+        await deps.recordDecisionTrace({
+            scope: result.scope,
+            status: result.status,
+            reasons: traceReasons,
+            selectedIntentId: result.selectedIntentId,
+            rhythmWindowId: runtime.rhythmWindow.windowId,
+            allowedIntentKinds: [...runtime.rhythmWindow.allowedIntentKinds],
+            candidateCount: candidates.length,
+            lifeEvidenceEmpty: runtime.lifeEvidence.evidenceRefs.length === 0 &&
+                runtime.lifeEvidence.platformEventCount === 0 &&
+                runtime.lifeEvidence.workEventCount === 0,
+            trigger: signal.trigger,
+        });
+    };
+    let hasCandidates = false;
+    let anyAllow = false;
+    let anyDefer = false;
+    let anyDeny = false;
+    const denyReasons = [];
+    for (const intent of candidates) {
+        hasCandidates = true;
+        const evaluation = evaluateHardGuards(intent, runtime);
+        if (evaluation.verdict === "allow") {
+            anyAllow = true;
+            const base = {
+                scope: "rhythm",
+                status: "intent_selected",
+                selectedIntentId: intent.id,
+                reasons: evaluation.reasons,
+            };
+            const resolved = await resolveAllowedIntentResult(intent, runtime, inputs, signal, deps);
+            const result = resolved.status === "intent_selected" &&
+                resolved.reasons.length === 0 &&
+                evaluation.reasons.length > 0
+                ? { ...resolved, reasons: evaluation.reasons }
+                : resolved;
+            await emitTrace(result);
+            await maybeUpdateNarrativeState(result, intent, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
+            return result;
+        }
+        if (evaluation.verdict === "defer") {
+            anyDefer = true;
+            denyReasons.push(`${intent.id}:${evaluation.verdict}(${evaluation.reasons.join(",")})`);
+            continue;
+        }
+        anyDeny = true;
+        denyReasons.push(`${intent.id}:${evaluation.verdict}(${evaluation.reasons.join(",")})`);
+    }
+    if (!hasCandidates) {
+        const result = {
+            scope: "rhythm",
+            status: "heartbeat_ok",
+            reasons: ["silent_no_candidates"],
+        };
+        await emitTrace(result);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
+        return result;
+    }
+    if (!anyAllow && anyDefer && !anyDeny) {
+        const result = {
+            scope: "rhythm",
+            status: "deferred",
+            reasons: denyReasons.length > 0 ? denyReasons : ["all_candidates_deferred"],
+        };
+        await emitTrace(result);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
+        return result;
+    }
+    if (!anyAllow && denyReasons.length > 0) {
+        const result = {
+            scope: "rhythm",
+            status: "denied",
+            reasons: denyReasons,
+        };
+        await emitTrace(result);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
+        return result;
+    }
+    const result = {
+        scope: "rhythm",
+        status: "heartbeat_ok",
+        reasons: ["no_allow_verdict"],
+    };
+    await emitTrace(result);
+    await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
+    return result;
+}
+/**
+ * Build a snapshot directly from inputs (for testing or when state-system is unavailable).
+ */
+export function buildSnapshotFromInputs(inputs) {
+    return buildContinuitySnapshot(inputs);
+}

package/dist/src/core/second-nature/orchestrator/platform-capability-router.js

@@ -0,0 +1,149 @@
+function kindToCapability(kind) {
+    if (kind === "exploration")
+        return "feed.read";
+    if (kind === "social")
+        return "comment.reply";
+    if (kind === "work")
+        return "work.discover";
+    if (kind === "outreach")
+        return "message.send";
+    return null;
+}
+function getPlatformIds(registry) {
+    if (registry) {
+        return registry.listRegisteredPlatformIds();
+    }
+    // Fallback: built-in platforms when registry is absent (backward compat)
+    return ["moltbook", "instreet", "evomap", "agent-world"];
+}
+const FALLBACK_PLATFORM_CAPABILITIES = {
+    "moltbook": ["feed.read", "post.publish", "comment.reply", "message.send"],
+    "instreet": ["notification.list", "message.send", "comment.reply", "agent.heartbeat"],
+    "evomap": ["agent.register", "agent.heartbeat", "work.discover", "task.claim"],
+    "agent-world": ["feed.read", "work.discover", "task.claim"],
+};
+function fallbackPlatformSupportsCapability(platformId, kind) {
+    const capability = kindToCapability(kind);
+    if (!capability)
+        return false;
+    return (FALLBACK_PLATFORM_CAPABILITIES[platformId] ?? []).includes(capability);
+}
+function extractPlatformIdsFromGoals(goals, kind, platformIds) {
+    const capability = kindToCapability(kind);
+    const results = new Set();
+    for (const goal of goals) {
+        const text = `${goal.description} ${goal.completionCriteria ?? ""}`.toLowerCase();
+        for (const pid of platformIds) {
+            if (text.includes(pid)) {
+                results.add(pid);
+            }
+        }
+        // Also match if goal text contains the capability name (e.g. "feed.read")
+        if (capability && text.includes(capability.toLowerCase())) {
+            // capability alone doesn't tell us platform; keep for later
+        }
+    }
+    return [...results];
+}
+function extractPlatformIdsFromEvidence(refs, platformIds) {
+    const results = new Set();
+    for (const ref of refs) {
+        if (ref.kind === "connector_result" && ref.id) {
+            for (const pid of platformIds) {
+                if (ref.id.includes(pid)) {
+                    results.add(pid);
+                }
+            }
+        }
+        // Parse platform:// URIs (e.g. platform://moltbook/feed.read)
+        if (ref.uri && ref.uri.startsWith("platform://")) {
+            const afterScheme = ref.uri.slice("platform://".length);
+            const platformPart = afterScheme.split("/")[0];
+            if (platformPart && platformIds.includes(platformPart)) {
+                results.add(platformPart);
+            }
+        }
+        // L-02: Also support namespace format moltbook:feed.read (connector-system §5.3)
+        if (ref.uri && !ref.uri.includes("://") && ref.uri.includes(":")) {
+            const nsPart = ref.uri.split(":")[0];
+            if (nsPart && platformIds.includes(nsPart)) {
+                results.add(nsPart);
+            }
+        }
+    }
+    return [...results];
+}
+function validatePlatformCapability(platformId, kind, registry) {
+    const capability = kindToCapability(kind);
+    if (!capability)
+        return false;
+    try {
+        return registry.hasCapability(platformId, capability);
+    }
+    catch (err) {
+        // H-08: Log registry validation failures for observability.
+        console.warn(`[platform-capability-router] Registry validation failed for ${platformId}:${capability}`, err);
+        return false;
+    }
+}
+/**
+ * Resolve an explicit platformId for a candidate intent kind.
+ * Returns `undefined` when no unambiguous platform can be inferred.
+ */
+export function resolvePlatformForIntent(kind, context, registry) {
+    const capability = kindToCapability(kind);
+    if (!capability) {
+        // Quiet, reflection, maintenance have no connector capability mapping.
+        return undefined;
+    }
+    const platformIds = getPlatformIds(registry);
+    const candidates = [];
+    if (context.acceptedGoals && context.acceptedGoals.length > 0) {
+        candidates.push(...extractPlatformIdsFromGoals(context.acceptedGoals, kind, platformIds));
+    }
+    if (context.evidenceRefs && context.evidenceRefs.length > 0) {
+        candidates.push(...extractPlatformIdsFromEvidence(context.evidenceRefs, platformIds));
+    }
+    // Deduplicate while preserving order
+    const ordered = [...new Set(candidates)];
+    if (ordered.length > 1) {
+        // Ambiguous: multiple platforms inferred → do not guess, return undefined.
+        // Guard layer will deny with "ambiguous_platform" reason.
+        return undefined;
+    }
+    if (ordered.length === 1) {
+        const single = ordered[0];
+        if (registry) {
+            if (validatePlatformCapability(single, kind, registry)) {
+                return single;
+            }
+            // Registry says unsupported → undefined (guard layer will deny)
+            return undefined;
+        }
+        // No registry: keep legacy platform-name fallback, but do not invent an
+        // unsupported platform/capability pair that later fails as protocol_mismatch.
+        if (!fallbackPlatformSupportsCapability(single, kind)) {
+            return undefined;
+        }
+        return single;
+    }
+    // No candidates inferred from goals/evidence → fallback to a supported platform.
+    // Sort alphabetically so different capabilities map to different platforms over time,
+    // preventing a single platform (e.g. moltbook) from monopolising all connector traffic.
+    if (registry) {
+        const supported = platformIds
+            .filter((pid) => validatePlatformCapability(pid, kind, registry))
+            .sort();
+        if (supported.length > 0) {
+            return supported[0];
+        }
+    }
+    // No registry: use fallback capability mapping
+    const supportedFallback = platformIds
+        .filter((pid) => fallbackPlatformSupportsCapability(pid, kind))
+        .sort();
+    if (supportedFallback.length > 0) {
+        return supportedFallback[0];
+    }
+    return undefined;
+}

package/dist/src/storage/snapshots/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/storage/user-interest/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tests/integration/cli/cli-ops-surface.test.d.ts

@@ -0,0 +1 @@
+export {};