@haaaiawd/second-nature 0.1.20 → 0.1.21

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "OpenClaw native plugin with synchronous surface registration and bundled runtime spine. Set SECOND_NATURE_WORKSPACE_ROOT or tool workspaceRoot to the same path as the agent workspace (see README / T1.1.4 ops norm).",
   "activation": {
     "onStartup": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",

package/runtime/cli/index.js

@@ -7,6 +7,7 @@ import { createOpsRouter } from "./ops/ops-router.js";
 import { createCliReadModels, } from "./read-models/index.js";
 import { resolvePackagedRuntime } from "./runtime/runtime-artifact-boundary.js";
 import { createRuntimeDecisionRecorder, } from "../observability/services/runtime-decision-recorder.js";
+import { createConnectorExecutorAdapter } from "../connectors/services/connector-executor-adapter.js";
 export function createCliRuntimeDeps(overrides = {}) {
     const stateDb = overrides.stateDb ?? createStateDatabase();
     const observabilityDb = overrides.observabilityDb ?? createObservabilityDatabase();
@@ -32,6 +33,10 @@ export function createCliRuntimeDeps(overrides = {}) {
 export function createCommandRouter(options = {}) {
     const runtime = createCliRuntimeDeps(options.deps);
     const pluginRoot = path.join(process.cwd(), "plugin");
+    const connectorExecutor = createConnectorExecutorAdapter({
+        stateDb: runtime.stateDb,
+        observabilityDb: runtime.observabilityDb,
+    });
     const opsRouter = createOpsRouter({
         runtimeAvailable: resolvePackagedRuntime(pluginRoot).ok,
         readModels: runtime.readModels,
@@ -39,6 +44,7 @@ export function createCommandRouter(options = {}) {
         state: runtime.stateDb,
         workspaceRoot: process.cwd(),
         observabilityDb: runtime.observabilityDb,
+        connectorExecutor,
     });
     const commands = createCliCommands({
         readModels: runtime.readModels,

package/runtime/cli/ops/heartbeat-surface.d.ts

@@ -9,6 +9,7 @@ import type { HeartbeatSignal } from "../../core/second-nature/heartbeat/signal.
 import type { CliReadModels } from "../read-models/index.js";
 import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
 import type { StateDatabase } from "../../storage/db/index.js";
+import type { ConnectorExecutor } from "../../core/second-nature/orchestrator/effect-dispatcher.js";
 export type HeartbeatSurfaceStatus = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
 export interface HeartbeatSurfaceResult {
     ok: boolean;
@@ -41,5 +42,10 @@ export interface HeartbeatCheckInput {
     timestamp?: string;
     sessionContext?: string;
     scopeHint?: HeartbeatSignal["scopeHint"];
+    /**
+     * When present, guard-allowed connector_action intents are dispatched through the
+     * connector-system instead of returning connector_dispatch_unwired.
+     */
+    connectorExecutor?: ConnectorExecutor;
 }
 export declare function heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;

package/runtime/cli/ops/heartbeat-surface.js

@@ -73,6 +73,7 @@ export async function heartbeatCheck(input) {
         runtimeRecorder: input.runtimeRecorder,
         state: input.state,
         workspaceRoot: input.workspaceRoot ?? process.cwd(),
+        connectorExecutor: input.connectorExecutor,
     });
     const cycle = await run(signal);
     return mapCycleToSurface(cycle, "workspace_full_runtime");

package/runtime/cli/ops/ops-router.d.ts

@@ -6,6 +6,7 @@ import type { CliReadModels } from "../read-models/index.js";
 import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
 import type { StateDatabase } from "../../storage/db/index.js";
 import type { ObservabilityDatabase } from "../../observability/db/index.js";
+import type { ConnectorExecutor } from "../../core/second-nature/orchestrator/effect-dispatcher.js";
 export interface OpsRouterDeps {
     /** When true, packaged runtime artifacts resolved and full graph is loadable */
     runtimeAvailable: boolean;
@@ -24,6 +25,11 @@ export interface OpsRouterDeps {
      * When absent, `capability_probe` still runs but skips persistence.
      */
     observabilityDb?: ObservabilityDatabase;
+    /**
+     * When present, guard-allowed connector_action intents are dispatched through the
+     * connector-system instead of returning connector_dispatch_unwired.
+     */
+    connectorExecutor?: ConnectorExecutor;
 }
 export interface OpsRouter {
     heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;

package/runtime/cli/ops/ops-router.js

@@ -41,6 +41,7 @@ export function createOpsRouter(deps) {
             runtimeRecorder: input.runtimeRecorder ?? deps.runtimeRecorder,
             state: input.state ?? deps.state,
             workspaceRoot: input.workspaceRoot ?? deps.workspaceRoot,
+            connectorExecutor: input.connectorExecutor ?? deps.connectorExecutor,
         }),
         dispatch(command, input) {
             if (command === "heartbeat_check") {
@@ -67,6 +68,8 @@ export function createOpsRouter(deps) {
                         ? input.sessionContext
                         : undefined,
                     scopeHint: input?.scopeHint,
+                    connectorExecutor: input
+                        ?.connectorExecutor ?? deps.connectorExecutor,
                 });
             }
             if (command === "fallback") {

package/runtime/cli/ops/workspace-heartbeat-runner.d.ts

@@ -17,6 +17,7 @@ import type { SnapshotInputs } from "../../core/second-nature/heartbeat/snapshot
 import type { CliReadModels } from "../read-models/index.js";
 import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
 import type { StateDatabase } from "../../storage/db/index.js";
+import type { ConnectorExecutor } from "../../core/second-nature/orchestrator/effect-dispatcher.js";
 export interface WorkspaceHeartbeatRunnerOptions {
     /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
     runtimeRecorder?: RuntimeDecisionRecorder;
@@ -32,6 +33,11 @@ export interface WorkspaceHeartbeatRunnerOptions {
      * Defaults to true when workspaceRoot is provided, since this is the host-safe workspace path.
      */
     enableQuietWorkflow?: boolean;
+    /**
+     * When present, guard-allowed connector_action intents are dispatched through the
+     * connector-system instead of returning connector_dispatch_unwired.
+     */
+    connectorExecutor?: ConnectorExecutor;
 }
 export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels, options?: {
     state?: StateDatabase;

package/runtime/cli/ops/workspace-heartbeat-runner.js

@@ -76,6 +76,7 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                 quietWorkflow: quietEnabled
                     ? { workspaceRoot: options.workspaceRoot }
                     : undefined,
+                connectorExecutor: options.connectorExecutor,
             },
         });
         if (options.runtimeRecorder) {

package/runtime/connectors/base/contract.d.ts

@@ -78,6 +78,16 @@ export interface ExecutionRunner {
 export interface ConnectorExecutionPort {
     executeCapability(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
 }
+export interface ConnectorExecutor {
+    executeEffect(input: {
+        platformId: string;
+        intent: CapabilityIntent;
+        payload: Record<string, unknown>;
+        decisionId: string;
+        intentId: string;
+        idempotencyKey: string;
+    }): Promise<ConnectorResult<unknown>>;
+}
 export declare function normalizeOutcome(attempt: RawAttempt): ConnectorResult<unknown>;
 export declare function createConnectorContractCore(input: {
     manifestLoader: ConnectorManifestLoader;

package/runtime/connectors/base/contract.js

@@ -1,6 +1,14 @@
 import { z } from "zod";
-import { classifyFailure, ConnectorPolicyError } from "./failure-taxonomy.js";
-export const CHANNEL_TYPES = ["api_rest", "api_rpc", "a2a", "mcp", "cli", "skill", "browser"];
+import { classifyFailure, ConnectorPolicyError, } from "./failure-taxonomy.js";
+export const CHANNEL_TYPES = [
+    "api_rest",
+    "api_rpc",
+    "a2a",
+    "mcp",
+    "cli",
+    "skill",
+    "browser",
+];
 export const CAPABILITY_INTENTS = [
     "feed.read",
     "post.publish",

package/runtime/connectors/base/failure-taxonomy.js

@@ -40,11 +40,15 @@ export class ConnectorPolicyError extends Error {
 }
 function readRetryAfterMs(input) {
     const retryAfterMs = input.retryAfterMs;
-    if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+    if (typeof retryAfterMs === "number" &&
+        Number.isFinite(retryAfterMs) &&
+        retryAfterMs > 0) {
         return retryAfterMs;
     }
     const retryAfterSeconds = input.retryAfterSeconds;
-    if (typeof retryAfterSeconds === "number" && Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) {
+    if (typeof retryAfterSeconds === "number" &&
+        Number.isFinite(retryAfterSeconds) &&
+        retryAfterSeconds > 0) {
         return retryAfterSeconds * 1000;
     }
     return undefined;
@@ -64,24 +68,56 @@ export function classifyFailure(error) {
         const record = error;
         const code = record.code;
         if (typeof code === "string") {
+            if (code === "auth_failure")
+                return {
+                    class: "auth_failure",
+                    retryable: RETRYABLE_BY_CLASS.auth_failure,
+                };
             if (code === "verification_required")
-                return { class: "verification_required", retryable: RETRYABLE_BY_CLASS.verification_required };
+                return {
+                    class: "verification_required",
+                    retryable: RETRYABLE_BY_CLASS.verification_required,
+                };
             if (code === "credential_expired")
-                return { class: "credential_expired", retryable: RETRYABLE_BY_CLASS.credential_expired };
+                return {
+                    class: "credential_expired",
+                    retryable: RETRYABLE_BY_CLASS.credential_expired,
+                };
             if (code === "cooldown_blocked")
-                return { class: "cooldown_blocked", retryable: RETRYABLE_BY_CLASS.cooldown_blocked };
+                return {
+                    class: "cooldown_blocked",
+                    retryable: RETRYABLE_BY_CLASS.cooldown_blocked,
+                };
             if (code === "idempotency_conflict")
-                return { class: "idempotency_conflict", retryable: RETRYABLE_BY_CLASS.idempotency_conflict };
+                return {
+                    class: "idempotency_conflict",
+                    retryable: RETRYABLE_BY_CLASS.idempotency_conflict,
+                };
             if (code === "concurrency_conflict")
-                return { class: "concurrency_conflict", retryable: RETRYABLE_BY_CLASS.concurrency_conflict };
+                return {
+                    class: "concurrency_conflict",
+                    retryable: RETRYABLE_BY_CLASS.concurrency_conflict,
+                };
             if (code === "protocol_mismatch")
-                return { class: "protocol_mismatch", retryable: RETRYABLE_BY_CLASS.protocol_mismatch };
+                return {
+                    class: "protocol_mismatch",
+                    retryable: RETRYABLE_BY_CLASS.protocol_mismatch,
+                };
             if (code === "semantic_rejection")
-                return { class: "semantic_rejection", retryable: RETRYABLE_BY_CLASS.semantic_rejection };
+                return {
+                    class: "semantic_rejection",
+                    retryable: RETRYABLE_BY_CLASS.semantic_rejection,
+                };
             if (code === "transport_failure")
-                return { class: "transport_failure", retryable: RETRYABLE_BY_CLASS.transport_failure };
+                return {
+                    class: "transport_failure",
+                    retryable: RETRYABLE_BY_CLASS.transport_failure,
+                };
             if (code === "permanent_input_error")
-                return { class: "permanent_input_error", retryable: RETRYABLE_BY_CLASS.permanent_input_error };
+                return {
+                    class: "permanent_input_error",
+                    retryable: RETRYABLE_BY_CLASS.permanent_input_error,
+                };
         }
         const status = record.status;
         if (status === 429) {
@@ -92,14 +128,26 @@ export function classifyFailure(error) {
             };
         }
         if (status === 401 || status === 403) {
-            return { class: "auth_failure", retryable: RETRYABLE_BY_CLASS.auth_failure };
+            return {
+                class: "auth_failure",
+                retryable: RETRYABLE_BY_CLASS.auth_failure,
+            };
         }
         if (status === 400 || status === 404 || status === 422) {
-            return { class: "permanent_input_error", retryable: RETRYABLE_BY_CLASS.permanent_input_error };
+            return {
+                class: "permanent_input_error",
+                retryable: RETRYABLE_BY_CLASS.permanent_input_error,
+            };
         }
         if (status === 500 || status === 502 || status === 503 || status === 504) {
-            return { class: "transport_failure", retryable: RETRYABLE_BY_CLASS.transport_failure };
+            return {
+                class: "transport_failure",
+                retryable: RETRYABLE_BY_CLASS.transport_failure,
+            };
         }
     }
-    return { class: "unknown_platform_change", retryable: RETRYABLE_BY_CLASS.unknown_platform_change };
+    return {
+        class: "unknown_platform_change",
+        retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
+    };
 }

package/runtime/connectors/services/connector-executor-adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adapter: assemble connector-system execution infrastructure into the
+ * ConnectorExecutor interface consumed by EffectDispatcher.
+ *
+ * When credentials / base URLs are missing, returns an honest
+ * terminal_failure instead of throwing so the heartbeat loop stays stable.
+ */
+import type { ConnectorExecutor } from "../base/contract.js";
+export type { ConnectorExecutor } from "../base/contract.js";
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
+import type { StateDatabase } from "../../storage/db/index.js";
+export interface ConnectorExecutorAdapterOptions {
+    stateDb: StateDatabase;
+    observabilityDb: ObservabilityDatabase;
+}
+export declare function createConnectorExecutorAdapter(options: ConnectorExecutorAdapterOptions): ConnectorExecutor;

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

@@ -0,0 +1,118 @@
+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 { createMoltbookApiClient } from "../social-community/moltbook/api-client.js";
+import { createMoltbookRunner } from "../social-community/moltbook/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";
+function createAdaptiveExecutionRunner(vault) {
+    return {
+        async run(_plan, request) {
+            const platformId = request.platformId;
+            const started = Date.now();
+            const credential = await vault.loadCredentialContext(platformId);
+            if (!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",
+                    },
+                };
+            }
+            if (platformId === "moltbook") {
+                const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+                if (!baseUrl) {
+                    return {
+                        platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "configuration_missing",
+                            detail: "SECOND_NATURE_MOLTBOOK_BASE_URL not set",
+                        },
+                    };
+                }
+                const apiClient = createMoltbookApiClient({
+                    baseUrl,
+                    accessToken: credential.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);
+            }
+            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",
+                    },
+                };
+            }
+            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 });
+    const routeContextPort = createCredentialRouteContextPort(vault);
+    const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
+    const telemetry = new ExecutionTelemetry(options.observabilityDb);
+    const executionRunner = createAdaptiveExecutionRunner(vault);
+    const policy = createConnectorPolicyLayer({
+        routePlanner,
+        executionRunner,
+        telemetry,
+        effectCommitLedger: new InMemoryEffectCommitLedger(),
+        retryPolicy: { maxRetries: 2, jitter: true },
+    });
+    return {
+        async executeEffect(input) {
+            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/connectors/services/credential-route-context.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bridge CredentialVault → RouteContextPort for connector route planning.
+ *
+ * Loads decrypted credentials from state DB and maps them to the
+ * CredentialContext shape expected by ConnectorRoutePlanner.
+ * Cooldown is stubbed (always unblocked) until a cooldown ledger is modeled.
+ */
+import type { RouteContextPort } from "../base/contract.js";
+import type { CredentialVault } from "../../storage/services/credential-vault.js";
+export declare function createCredentialRouteContextPort(vault: CredentialVault): RouteContextPort;

package/runtime/connectors/services/credential-route-context.js

@@ -0,0 +1,19 @@
+export function createCredentialRouteContextPort(vault) {
+    return {
+        async loadCredentialState(platformId) {
+            const ctx = await vault.loadCredentialContext(platformId);
+            // Defensive: some ORM findFirst variants return {} instead of null/undefined.
+            if (!ctx || !ctx.platformId || !ctx.status) {
+                return {
+                    platformId,
+                    status: "missing",
+                    credentialType: "api_key",
+                };
+            }
+            return ctx;
+        },
+        async loadCooldownState() {
+            return { blocked: false };
+        },
+    };
+}

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

@@ -19,6 +19,7 @@ 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";
 export interface HeartbeatDecisionTracePayload {
     scope: RuntimeScope;
     status: HeartbeatCycleStatus;
@@ -44,7 +45,7 @@ export interface HeartbeatQuietWorkflowDeps {
  * 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">): Promise<HeartbeatCycleResult>;
+export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow" | "connectorExecutor">): Promise<HeartbeatCycleResult>;
 export interface HeartbeatDeps {
     /** Load snapshot inputs from state-system */
     loadSnapshotInputs: () => Promise<SnapshotInputs>;
@@ -52,6 +53,11 @@ export interface HeartbeatDeps {
     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;
 }
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.

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

@@ -5,6 +5,7 @@ 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";
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
@@ -48,6 +49,28 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
         intent.effectClass === "no_effect" ||
         intent.kind === "maintenance";
     const connectorUnwired = intent.effectClass === "connector_action";
+    if (connectorUnwired && deps.connectorExecutor) {
+        const result = await deps.connectorExecutor.executeEffect({
+            platformId: intent.platformId ?? "unknown",
+            intent: toCapabilityIntent(intent),
+            payload: {},
+            decisionId: `decision:${intent.id}:${Date.now()}`,
+            intentId: intent.id,
+            idempotencyKey: `idem:${intent.id}:${Date.now()}`,
+        });
+        const base = {
+            scope: "rhythm",
+            status: "intent_selected",
+            selectedIntentId: intent.id,
+            decisionId: `decision:${intent.id}:${Date.now()}`,
+            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

package/runtime/core/second-nature/orchestrator/effect-dispatcher.d.ts

@@ -1,4 +1,5 @@
-import type { ConnectorResult, CapabilityIntent } from "../../../connectors/base/contract.js";
+import type { ConnectorResult, CapabilityIntent, ConnectorExecutor } from "../../../connectors/base/contract.js";
+export type { ConnectorExecutor } from "../../../connectors/base/contract.js";
 import { LeaseManager, type EffectClass } from "./lease-manager.js";
 export interface AllowedIntent {
     id: string;
@@ -31,16 +32,6 @@ export interface IntentCommitPort {
     }): Promise<void>;
     abortIntentCommit(id: string, reason: string): Promise<void>;
 }
-export interface ConnectorExecutor {
-    executeEffect(input: {
-        platformId: string;
-        intent: CapabilityIntent;
-        payload: Record<string, unknown>;
-        decisionId: string;
-        intentId: string;
-        idempotencyKey: string;
-    }): Promise<ConnectorResult<unknown>>;
-}
 export interface CheckpointPort {
     saveCheckpoint(input: {
         id: string;
@@ -83,6 +74,7 @@ export type DispatchResult = {
     status: "maintenance_done";
     commitId: string;
 };
+export declare function toCapabilityIntent(intent: Pick<AllowedIntent, "kind">): CapabilityIntent;
 export declare class EffectDispatcher {
     private readonly leaseManager;
     private readonly commitPort;

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

@@ -1,14 +1,17 @@
 import * as crypto from "crypto";
 function needsLease(effectClass) {
-    return effectClass === "external_platform_action" || effectClass === "connector_action" || effectClass === "user_outreach";
+    return (effectClass === "external_platform_action" ||
+        effectClass === "connector_action" ||
+        effectClass === "user_outreach");
 }
 function needsCheckpoint(effectClass) {
     return effectClass !== "maintenance" && effectClass !== "no_effect";
 }
 function isConnectorEffect(effectClass) {
-    return effectClass === "external_platform_action" || effectClass === "connector_action";
+    return (effectClass === "external_platform_action" ||
+        effectClass === "connector_action");
 }
-function toCapabilityIntent(intent) {
+export function toCapabilityIntent(intent) {
     if (intent.kind === "work")
         return "work.discover";
     if (intent.kind === "exploration")
@@ -48,7 +51,9 @@ export class EffectDispatcher {
                 id: decision.checkpointId,
                 tickId: decision.tickId,
                 intentId: decision.intentId,
-                phase: isConnectorEffect(intent.effectClass) ? "before_effect" : "before_quiet_write",
+                phase: isConnectorEffect(intent.effectClass)
+                    ? "before_effect"
+                    : "before_quiet_write",
                 snapshotRef: decision.traceId,
             });
         }

package/runtime/core/second-nature/runtime/service-entry.js

@@ -27,7 +27,7 @@ export function startRuntimeService(ctx) {
     // - control-plane-system (heartbeat bridge preparation)
     const workspaceRoot = ctx?.workspaceRoot ?? process.cwd();
     /** Keep in sync with `plugin/package.json` when cutting releases. */
-    const version = "0.1.19";
+    const version = "0.1.20";
     activeHandle = {
         ready: true,
         version,