@haaaiawd/second-nature 0.1.43 → 0.1.50

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

@@ -1,329 +0,0 @@
-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}`);
-            }
-        }
-        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);
-    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)
-            return;
-        await deps.recordDecisionTrace({
-            scope: result.scope,
-            status: result.status,
-            reasons: result.reasons,
-            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/runtime/core/second-nature/orchestrator/platform-capability-router.js

@@ -1,131 +0,0 @@
-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 === 0) {
-        return undefined;
-    }
-    if (ordered.length > 1) {
-        // Ambiguous: multiple platforms inferred → do not guess, return undefined.
-        // Guard layer will deny with "ambiguous_platform" reason.
-        return undefined;
-    }
-    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;
-}