@haaaiawd/second-nature 0.1.42 → 0.1.50

package/runtime/connectors/services/connector-executor-adapter.js

@@ -1,424 +0,0 @@
-import { CapabilityContractRegistry } from "../base/manifest.js";
-import { ConnectorRoutePlanner } from "../base/route-planner.js";
-import { ChannelHealthStore } from "../base/channel-health.js";
-import { createConnectorPolicyLayer } from "../base/policy-layer.js";
-import { InMemoryEffectCommitLedger } from "../base/execution-policy.js";
-import { moltbookManifest } from "../social-community/moltbook/manifest.js";
-import { evomapManifest } from "../agent-network/evomap/manifest.js";
-import { agentWorldManifest } from "../agent-network/agent-world/manifest.js";
-import { createMoltbookApiClient } from "../social-community/moltbook/api-client.js";
-import { createMoltbookRunner } from "../social-community/moltbook/adapter.js";
-import { createAgentWorldRunner } from "../agent-network/agent-world/adapter.js";
-import { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
-import { createCredentialVault } from "../../storage/services/credential-vault.js";
-import { createCredentialRouteContextPort } from "./credential-route-context.js";
-import { scanConnectorManifests } from "../registry/manifest-scanner.js";
-import { parseConnectorManifestV6 } from "../manifest/manifest-parser.js";
-import fs from "node:fs";
-import path from "node:path";
-const DEFAULT_AGENT_WORLD_USERNAME = "nyx_ha";
-const DEFAULT_AGENT_WORLD_PROFILE_PATH_TEMPLATE = "/api/agents/profile/{username}";
-function readString(value) {
-    return typeof value === "string" && value.trim().length > 0
-        ? value.trim()
-        : undefined;
-}
-function channelPriorityForRunner(manifest) {
-    const declared = manifest.capabilities
-        .map((capability) => capability.channel)
-        .filter((channel) => channel === "api_rest" ||
-        channel === "api_rpc" ||
-        channel === "a2a" ||
-        channel === "mcp" ||
-        channel === "cli" ||
-        channel === "skill" ||
-        channel === "browser");
-    if (declared.length > 0)
-        return [...new Set(declared)];
-    if (manifest.runner.kind === "declarative_a2a")
-        return ["a2a"];
-    if (manifest.runner.kind === "declarative_mcp")
-        return ["mcp"];
-    if (manifest.runner.kind === "cli_descriptor")
-        return ["cli"];
-    if (manifest.runner.kind === "skill")
-        return ["skill"];
-    if (manifest.runner.kind === "browser")
-        return ["browser"];
-    return ["api_rest"];
-}
-function registerWorkspaceManifests(registry, workspaceRoot) {
-    if (!workspaceRoot)
-        return;
-    for (const file of scanConnectorManifests(workspaceRoot)) {
-        const parsed = parseConnectorManifestV6(file.content, file.path);
-        if (!parsed.ok)
-            continue;
-        const manifest = parsed.manifest;
-        try {
-            registry.register({
-                platformId: manifest.platformId,
-                supportedCapabilities: manifest.capabilities.map((capability) => capability.id),
-                channelPriority: channelPriorityForRunner(manifest),
-                credentialTypes: manifest.credentials.map((credential) => credential.type),
-                sourceRefPolicy: manifest.sourceRefPolicy,
-            });
-        }
-        catch {
-            // Invalid workspace manifests remain visible through connector_status validation.
-            // Execution side keeps fail-closed behavior by not registering them here.
-        }
-    }
-}
-function resolveAgentWorldUsername(payload, purpose) {
-    const payloadUsername = (purpose === "discover" ? readString(payload.targetUsername) : undefined) ??
-        readString(payload.username) ??
-        readString(payload.agentUsername);
-    return (payloadUsername ??
-        readString(process.env.SECOND_NATURE_AGENT_WORLD_USERNAME) ??
-        DEFAULT_AGENT_WORLD_USERNAME);
-}
-function resolveAgentWorldProfilePath(payload, username) {
-    const template = readString(payload.profilePathTemplate) ??
-        readString(process.env.SECOND_NATURE_AGENT_WORLD_PROFILE_PATH_TEMPLATE) ??
-        DEFAULT_AGENT_WORLD_PROFILE_PATH_TEMPLATE;
-    return template.replaceAll("{username}", encodeURIComponent(username));
-}
-function joinAgentWorldUrl(baseUrl, path) {
-    if (/^https?:\/\//i.test(path))
-        return path;
-    return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
-}
-async function fetchAgentWorldJson(input) {
-    const resp = await fetch(joinAgentWorldUrl(input.baseUrl, input.path), {
-        method: input.method ?? "GET",
-        headers: {
-            "Authorization": `Bearer ${input.apiKey}`,
-            "Content-Type": "application/json",
-        },
-        body: input.body === undefined ? undefined : JSON.stringify(input.body),
-    });
-    if (!resp.ok) {
-        throw { code: "api_error", detail: `agent-world ${input.label}: ${resp.status}` };
-    }
-    return resp.json();
-}
-function createMoltbookMockRunner(workspaceRoot) {
-    return {
-        async run(_plan, request) {
-            const started = Date.now();
-            const mockPath = workspaceRoot
-                ? path.join(workspaceRoot, ".second-nature", "mock", "moltbook-feed.json")
-                : undefined;
-            if (!mockPath || !fs.existsSync(mockPath)) {
-                return {
-                    platformId: request.platformId,
-                    channel: request.preferredChannel ?? "api_rest",
-                    latencyMs: Date.now() - started,
-                    success: false,
-                    error: {
-                        code: "configuration_missing",
-                        detail: "SECOND_NATURE_MOLTBOOK_BASE_URL not set and no mock data found",
-                    },
-                };
-            }
-            try {
-                const raw = fs.readFileSync(mockPath, "utf-8");
-                const data = JSON.parse(raw);
-                return {
-                    platformId: request.platformId,
-                    channel: request.preferredChannel ?? "api_rest",
-                    latencyMs: Date.now() - started,
-                    degraded: true,
-                    success: true,
-                    payload: {
-                        capability: request.intent,
-                        channel: request.preferredChannel ?? "api_rest",
-                        data: {
-                            source: "mock",
-                            items: Array.isArray(data.items) ? data.items : [],
-                        },
-                    },
-                };
-            }
-            catch (err) {
-                return {
-                    platformId: request.platformId,
-                    channel: request.preferredChannel ?? "api_rest",
-                    latencyMs: Date.now() - started,
-                    success: false,
-                    error: {
-                        code: "mock_read_error",
-                        detail: String(err),
-                    },
-                };
-            }
-        },
-    };
-}
-function findWorkspaceManifest(platformId, workspaceRoot) {
-    if (!workspaceRoot)
-        return undefined;
-    for (const file of scanConnectorManifests(workspaceRoot)) {
-        const parsed = parseConnectorManifestV6(file.content, file.path);
-        if (parsed.ok && parsed.manifest.platformId === platformId) {
-            return parsed.manifest;
-        }
-    }
-    return undefined;
-}
-function resolveDeclarativeHttpPath(capabilityId) {
-    return `/${capabilityId.replace(/\./g, "/")}`;
-}
-function resolveDeclarativeHttpMethod(capabilityId) {
-    const readOps = ["read", "list", "discover", "get", "heartbeat", "fetch"];
-    if (readOps.some((op) => capabilityId.includes(op)))
-        return "GET";
-    return "POST";
-}
-function createDeclarativeHttpRunner(manifest, credential) {
-    return {
-        async run(plan, request) {
-            const started = Date.now();
-            const baseUrl = manifest.runner.config?.baseUrl ?? "";
-            if (!baseUrl) {
-                return {
-                    platformId: request.platformId,
-                    channel: plan.channel,
-                    latencyMs: Date.now() - started,
-                    success: false,
-                    error: {
-                        code: "configuration_missing",
-                        detail: "runner.config.baseUrl not set for declarative_http connector",
-                    },
-                };
-            }
-            const httpPath = resolveDeclarativeHttpPath(request.intent);
-            const method = resolveDeclarativeHttpMethod(request.intent);
-            try {
-                const headers = {
-                    "Content-Type": "application/json",
-                };
-                if (credential?.encryptedValue) {
-                    headers.Authorization = `Bearer ${credential.encryptedValue}`;
-                }
-                const resp = await fetch(`${baseUrl.replace(/\/+$/, "")}${httpPath}`, {
-                    method,
-                    headers,
-                    body: method !== "GET" && request.payload ? JSON.stringify(request.payload) : undefined,
-                });
-                if (!resp.ok) {
-                    return {
-                        platformId: request.platformId,
-                        channel: plan.channel,
-                        latencyMs: Date.now() - started,
-                        success: false,
-                        error: {
-                            code: "api_error",
-                            detail: `HTTP ${resp.status}: ${await resp.text().catch(() => "")}`,
-                        },
-                    };
-                }
-                const data = await resp.json();
-                return {
-                    platformId: request.platformId,
-                    channel: plan.channel,
-                    latencyMs: Date.now() - started,
-                    success: true,
-                    payload: {
-                        capability: request.intent,
-                        channel: plan.channel,
-                        data,
-                    },
-                };
-            }
-            catch (err) {
-                return {
-                    platformId: request.platformId,
-                    channel: plan.channel,
-                    latencyMs: Date.now() - started,
-                    success: false,
-                    error: {
-                        code: "network_error",
-                        detail: String(err),
-                    },
-                };
-            }
-        },
-    };
-}
-function createAdaptiveExecutionRunner(vault, workspaceRoot) {
-    return {
-        async run(_plan, request) {
-            const platformId = request.platformId;
-            const started = Date.now();
-            const workspaceManifest = findWorkspaceManifest(platformId, workspaceRoot);
-            const isBuiltInPlatform = platformId === "moltbook" ||
-                platformId === "evomap" ||
-                platformId === "agent-world";
-            const requiresCredential = isBuiltInPlatform ||
-                Boolean(workspaceManifest?.credentials.some((credential) => credential.required !== false));
-            const credential = requiresCredential
-                ? await vault.loadCredentialContext(platformId)
-                : undefined;
-            if (requiresCredential &&
-                (!credential ||
-                    credential.status !== "active" ||
-                    !credential.encryptedValue)) {
-                return {
-                    platformId,
-                    channel: request.preferredChannel ?? "api_rest",
-                    latencyMs: Date.now() - started,
-                    success: false,
-                    error: {
-                        code: "auth_failure",
-                        detail: "credential_unavailable_for_execution",
-                    },
-                };
-            }
-            const activeCredential = credential?.status === "active" && credential.encryptedValue
-                ? { encryptedValue: credential.encryptedValue }
-                : undefined;
-            if (platformId === "moltbook") {
-                const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-                if (baseUrl) {
-                    const apiClient = createMoltbookApiClient({
-                        baseUrl,
-                        accessToken: activeCredential.encryptedValue,
-                        timeoutMs: 10000,
-                    });
-                    const runner = createMoltbookRunner({
-                        apiClient,
-                        skillRunner: {
-                            run: async () => {
-                                throw {
-                                    code: "protocol_mismatch",
-                                    detail: "moltbook_skill_runner_not_configured",
-                                };
-                            },
-                        },
-                    });
-                    return runner.run(_plan, request);
-                }
-                // Mock fallback when real API is not configured
-                const mockRunner = createMoltbookMockRunner(workspaceRoot);
-                return mockRunner.run(_plan, request);
-            }
-            if (platformId === "evomap") {
-                return {
-                    platformId,
-                    channel: request.preferredChannel ?? "api_rest",
-                    latencyMs: Date.now() - started,
-                    success: false,
-                    error: {
-                        code: "not_implemented",
-                        detail: "evomap_execution_runner_not_yet_implemented",
-                    },
-                };
-            }
-            if (platformId === "agent-world") {
-                const baseUrl = process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL;
-                if (!baseUrl) {
-                    return {
-                        platformId,
-                        channel: request.preferredChannel ?? "api_rest",
-                        latencyMs: Date.now() - started,
-                        success: false,
-                        error: {
-                            code: "configuration_missing",
-                            detail: "SECOND_NATURE_AGENT_WORLD_BASE_URL not set",
-                        },
-                    };
-                }
-                const runner = createAgentWorldRunner({
-                    apiKey: activeCredential.encryptedValue,
-                    apiClient: {
-                        async readFeed(payload, _apiKey) {
-                            const username = resolveAgentWorldUsername(payload, "feed");
-                            return fetchAgentWorldJson({
-                                baseUrl,
-                                path: resolveAgentWorldProfilePath(payload, username),
-                                apiKey: _apiKey,
-                                label: "profile feed",
-                            });
-                        },
-                        async discoverWork(payload, _apiKey) {
-                            const username = resolveAgentWorldUsername(payload, "discover");
-                            return fetchAgentWorldJson({
-                                baseUrl,
-                                path: resolveAgentWorldProfilePath(payload, username),
-                                apiKey: _apiKey,
-                                label: "profile discover",
-                            });
-                        },
-                        async claimTask(payload, _apiKey) {
-                            const claimPath = readString(payload.claimEndpointPath);
-                            if (!claimPath) {
-                                throw {
-                                    code: "protocol_mismatch",
-                                    detail: "agent_world_task_claim_endpoint_not_configured",
-                                };
-                            }
-                            return fetchAgentWorldJson({
-                                baseUrl,
-                                path: claimPath,
-                                apiKey: _apiKey,
-                                method: "POST",
-                                body: payload,
-                                label: "task claim",
-                            });
-                        },
-                    },
-                });
-                return runner.run(_plan, request);
-            }
-            // Wave 83: workspace declarative_http connector fallback
-            if (workspaceManifest && workspaceManifest.runner.kind === "declarative_http") {
-                const httpRunner = createDeclarativeHttpRunner(workspaceManifest, activeCredential);
-                return httpRunner.run(_plan, request);
-            }
-            return {
-                platformId,
-                channel: request.preferredChannel ?? "api_rest",
-                latencyMs: Date.now() - started,
-                success: false,
-                error: {
-                    code: "unknown_platform",
-                    detail: `no execution runner for ${platformId}`,
-                },
-            };
-        },
-    };
-}
-export function createConnectorExecutorAdapter(options) {
-    const vault = createCredentialVault(options.stateDb.db);
-    const registry = new CapabilityContractRegistry();
-    registry.register({ ...moltbookManifest });
-    registry.register({ ...evomapManifest });
-    registry.register({ ...agentWorldManifest });
-    registerWorkspaceManifests(registry, options.workspaceRoot);
-    const routeContextPort = createCredentialRouteContextPort(vault);
-    const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
-    const telemetry = new ExecutionTelemetry(options.observabilityDb);
-    const executionRunner = createAdaptiveExecutionRunner(vault, options.workspaceRoot);
-    const policy = createConnectorPolicyLayer({
-        routePlanner,
-        executionRunner,
-        telemetry,
-        effectCommitLedger: new InMemoryEffectCommitLedger(),
-        retryPolicy: { maxRetries: 2, jitter: true },
-    });
-    return {
-        async executeEffect(input) {
-            registerWorkspaceManifests(registry, options.workspaceRoot);
-            return policy.executeWithPolicy(input.intent, {
-                platformId: input.platformId,
-                intent: input.intent,
-                payload: input.payload,
-                decisionId: input.decisionId,
-                intentId: input.intentId,
-                idempotencyKey: input.idempotencyKey,
-            });
-        },
-    };
-}

package/runtime/core/second-nature/heartbeat/goal-lifecycle-policy.d.ts

@@ -1,37 +0,0 @@
-/**
- * GoalLifecyclePolicy — T-CP.C.3
- *
- * Core logic: Evaluates active goals, detects replace/expire
- * conditions, and emits typed GoalTransitionRequest.
- *
- * Responsibility separation (DR-012):
- * - control-plane evaluates and emits transition requests.
- * - state-memory executes transitions via GoalLifecycleStore.
- * - This module does NOT write goal state directly.
- *
- * Rules:
- * - Same kind+scope: newest accepted goal stays active; older ones → replaced.
- * - Expired goals (expiresAt < now) → expired transition request.
- *
- * Boundary:
- * - Consumes AgentGoal[] from EmbodiedContext.goals slice.
- * - Returns GoalTransitionRequest[] for state-memory to execute.
- *
- * Test coverage: tests/unit/control-plane/goal-lifecycle-policy.test.ts
- */
-import type { AgentGoal } from "../../../shared/types/goal.js";
-export interface GoalTransitionRequest {
-    goalId: string;
-    newStatus: "completed" | "expired" | "replaced" | "paused" | "accepted";
-    reason: string;
-    updatedAt: string;
-}
-export interface GoalLifecyclePolicyResult {
-    activeGoals: AgentGoal[];
-    transitionRequests: GoalTransitionRequest[];
-    evaluatedAt: string;
-}
-export interface GoalLifecyclePolicy {
-    evaluate(goals: AgentGoal[]): GoalLifecyclePolicyResult;
-}
-export declare function createGoalLifecyclePolicy(): GoalLifecyclePolicy;

package/runtime/core/second-nature/heartbeat/goal-lifecycle-policy.js

@@ -1,61 +0,0 @@
-export function createGoalLifecyclePolicy() {
-    return {
-        evaluate(goals) {
-            const now = new Date().toISOString();
-            const activeGoals = [];
-            const transitionRequests = [];
-            // Group by kind+scope to detect duplicates among accepted goals
-            const groups = new Map();
-            for (const goal of goals) {
-                if (goal.status !== "accepted")
-                    continue;
-                const key = `${goal.kind}:${goal.scope ?? "global"}`;
-                const list = groups.get(key) ?? [];
-                list.push(goal);
-                groups.set(key, list);
-            }
-            for (const [key, list] of groups) {
-                // Sort by updatedAt desc, keep newest as active
-                const sorted = [...list].sort((a, b) => {
-                    const aTime = new Date(a.updatedAt).getTime();
-                    const bTime = new Date(b.updatedAt).getTime();
-                    if (isNaN(aTime) || isNaN(bTime))
-                        return 0;
-                    return bTime - aTime;
-                });
-                const [newest, ...older] = sorted;
-                if (newest) {
-                    activeGoals.push(newest);
-                    // Older same kind+scope goals → replace
-                    for (const old of older) {
-                        transitionRequests.push({
-                            goalId: old.goalId,
-                            newStatus: "replaced",
-                            reason: `same_kind_scope_replace:${key}`,
-                            updatedAt: now,
-                        });
-                    }
-                }
-            }
-            // Detect expired goals among active
-            for (const goal of activeGoals) {
-                if (goal.expiresAt) {
-                    const expiresTime = new Date(goal.expiresAt).getTime();
-                    if (!isNaN(expiresTime) && expiresTime < new Date(now).getTime()) {
-                        transitionRequests.push({
-                            goalId: goal.goalId,
-                            newStatus: "expired",
-                            reason: "expires_at_reached",
-                            updatedAt: now,
-                        });
-                    }
-                }
-            }
-            return {
-                activeGoals,
-                transitionRequests,
-                evaluatedAt: now,
-            };
-        },
-    };
-}

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

@@ -1,88 +0,0 @@
-/**
- * Heartbeat Decision Loop
- *
- * Main entry point for the heartbeat runtime. Accepts a HeartbeatSignal,
- * builds runtime snapshot, plans candidate intents, evaluates hard guards,
- * and returns a HeartbeatCycleResult.
- *
- * Per design doc §4.3: heartbeat round follows the sequence:
- * signal → snapshot → plan → guard → result (HEARTBEAT_OK or intent_selected)
- *
- * Per ADR-005: heartbeat is the free-rhythm main entry; this loop
- * implements the default conservative path where HEARTBEAT_OK is
- * the first-class result when no action is warranted.
- */
-import type { HeartbeatSignal, HeartbeatCycleResult, HeartbeatCycleStatus, RuntimeScope, RuntimeTrigger } from "./signal.js";
-import type { CandidateIntent, ContinuitySnapshot, IntentKind } from "../types.js";
-import { type SnapshotInputs } from "./snapshot-builder.js";
-import { type HeartbeatRuntimeSnapshot } from "./runtime-snapshot.js";
-import type { GuidanceDraftPort } from "../../../guidance/outreach-draft-schema.js";
-import type { StateDatabase } from "../../../storage/db/index.js";
-import { type OpenClawDeliveryPort } from "../outreach/dispatch-user-outreach.js";
-import type { ConnectorExecutor } from "../../../connectors/base/contract.js";
-import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
-import type { NarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
-import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
-import type { ExperienceWriter } from "../body/tool-experience/experience-writer.js";
-import type { QuietDreamSchedulePort } from "../quiet/run-source-backed-quiet.js";
-export interface HeartbeatDecisionTracePayload {
-    scope: RuntimeScope;
-    status: HeartbeatCycleStatus;
-    reasons: string[];
-    selectedIntentId?: string;
-    rhythmWindowId: string;
-    allowedIntentKinds: IntentKind[];
-    candidateCount: number;
-    lifeEvidenceEmpty: boolean;
-    trigger: RuntimeTrigger;
-}
-/** Optional outreach delivery chain: when set, first allowed `user_outreach` runs dispatch (CR-M1). */
-export interface HeartbeatOutreachDispatchDeps {
-    state: StateDatabase;
-    guidance: GuidanceDraftPort;
-    delivery: OpenClawDeliveryPort;
-}
-/** Optional Quiet orchestration: when set, quiet/reflection allows run source-backed Quiet writer (T2.3.3). */
-export interface HeartbeatQuietWorkflowDeps {
-    workspaceRoot: string;
-    /** v7 T-V7C.C.3: when present, a successful Quiet write auto-triggers Dream scheduling. */
-    dreamSchedulePort?: QuietDreamSchedulePort;
-}
-/**
- * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
- * Exported for unit tests (CR-M1 wiring).
- */
-export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow" | "connectorExecutor" | "state" | "workspaceRoot" | "experienceWriter">): Promise<HeartbeatCycleResult>;
-export interface HeartbeatDeps {
-    /** Load snapshot inputs from state-system */
-    loadSnapshotInputs: () => Promise<SnapshotInputs>;
-    /** Optional observability hook (T2.2.1): one record per completed cycle. */
-    recordDecisionTrace?: (payload: HeartbeatDecisionTracePayload) => Promise<void>;
-    outreachDispatch?: HeartbeatOutreachDispatchDeps;
-    quietWorkflow?: HeartbeatQuietWorkflowDeps;
-    /**
-     * When present, guard-allowed connector_action intents are dispatched
-     * through the connector-system instead of returning connector_dispatch_unwired.
-     */
-    connectorExecutor?: ConnectorExecutor;
-    /** T2.1.5: when present, heartbeat writes a source-backed NarrativeState revision after each cycle. */
-    narrativeStateStore?: NarrativeStateStore;
-    /** T5.1.2: when present, heartbeat records a NarrativeTrace after successful narrative state update. */
-    recordNarrativeTrace?: (payload: NarrativeTracePayload) => Promise<void>;
-    /** T3.3.1: when present, successful connector effects write LifeEvidence artifacts. */
-    state?: StateDatabase;
-    /** T3.3.1: workspace root for evidence artifact paths. */
-    workspaceRoot?: string;
-    /** T2.4.1: when present, planner resolves platform-specific intents. */
-    connectorRegistry?: CapabilityContractRegistry;
-    /** v7 T-V7C.C.2: when present, connector attempts write ToolExperience with triggerSource="heartbeat". */
-    experienceWriter?: ExperienceWriter;
-}
-/**
- * Ingest a heartbeat rhythm signal and drive one full decision round.
- */
-export declare function ingestRhythmSignal(signal: HeartbeatSignal, deps: HeartbeatDeps): Promise<HeartbeatCycleResult>;
-/**
- * Build a snapshot directly from inputs (for testing or when state-system is unavailable).
- */
-export declare function buildSnapshotFromInputs(inputs: SnapshotInputs): ContinuitySnapshot;