@haaaiawd/second-nature 0.1.41 → 0.1.43

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "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. Agent inner guide is packaged as agent-inner-guide.md. v7 ops surface: self_health, tool_affordance, heartbeat_digest, snapshot:capture, narrative:diff, timeline, restore, runtime_secret_bootstrap, connector:run, guidance_payload.",
   "activation": {
     "onStartup": true,

package/package.json

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

package/runtime/cli/commands/index.js

@@ -285,6 +285,7 @@ export function createCliCommands(deps) {
         opsCommand("timeline", "T-ROS.C.1 — query v7 narrative timeline with cursor pagination"),
         opsCommand("restore", "T-ROS.C.1 — apply bounded restore and write restore audit"),
         opsCommand("runtime_secret_bootstrap", "T-ROS.C.1 — inspect runtime secret anchor health without exposing plaintext"),
+        opsCommand("guidance_payload", "T-V7C.C.4R — assemble impulse + atmosphere for a scene context"),
         {
             name: "goal",
             description: "T1.2.4 — owner-governed goal operations: set, list, accept, reject",

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

@@ -13,6 +13,8 @@ import { showOperatorFallback, OperatorFallbackNotFoundError, } from "./show-ope
 import { probeHostCapability } from "../host-capability/probe-host-capability.js";
 import { recordHostCapability } from "../host-capability/record-host-capability.js";
 import { runNearRealConnectorSmoke } from "../../connectors/near-real/near-real-connector-smoke.js";
+import { scanConnectorManifests } from "../../connectors/registry/manifest-scanner.js";
+import { parseConnectorManifestV6 } from "../../connectors/manifest/manifest-parser.js";
 import { connectorInit } from "../commands/connector-init.js";
 import { connectorBehaviorAdd } from "../commands/connector-behavior.js";
 import { connectorStatus, connectorTest } from "../commands/connector-status.js";
@@ -292,7 +294,7 @@ async function captureRuntimeSnapshot(deps, input) {
  * T1.2.8 — static local adapter: all checks return `unknown` when no real host is available.
  * Allows `capability_probe` to be called from CLI / workspace bridge without requiring a live host.
  */
-function createStaticUnknownAdapter() {
+function createStaticUnknownAdapter(workspaceRoot) {
     const now = new Date().toISOString();
     const unknownResult = (name) => ({
         name,
@@ -301,11 +303,35 @@ function createStaticUnknownAdapter() {
         reason: "static_local_probe_no_host_context",
         evidenceRefs: [],
     });
+    function checkDeliveryTarget() {
+        if (!workspaceRoot) {
+            return { status: "target_none", evidenceRefs: [], reason: "no_workspace_root_provided" };
+        }
+        const deliveryCapabilities = ["message.send", "comment.reply"];
+        const scanned = scanConnectorManifests(workspaceRoot);
+        for (const manifestFile of scanned) {
+            const parsed = parseConnectorManifestV6(manifestFile.content, manifestFile.path);
+            if (parsed.ok && parsed.manifest.capabilities.some((cap) => deliveryCapabilities.includes(cap.id))) {
+                return {
+                    status: "target_available",
+                    evidenceRefs: [
+                        {
+                            id: `delivery:${parsed.manifest.platformId}`,
+                            kind: "workspace_artifact",
+                            uri: `workspace://connectors/${parsed.manifest.platformId}/manifest.yaml`,
+                            observedAt: now,
+                        },
+                    ],
+                };
+            }
+        }
+        return { status: "target_none", evidenceRefs: [], reason: "no_delivery_connector_found_in_workspace" };
+    }
     return {
         checkPluginLoad: () => unknownResult("plugin_load"),
         checkHeartbeatBridge: () => unknownResult("heartbeat_bridge"),
         checkHeartbeatToolInvocation: () => unknownResult("heartbeat_tool_invocation"),
-        checkDeliveryTarget: () => ({ status: "unknown", evidenceRefs: [] }),
+        checkDeliveryTarget,
         checkAckDropBehavior: () => unknownResult("ack_drop"),
         checkHookSupport: () => [],
     };
@@ -487,7 +513,7 @@ export function createOpsRouter(deps) {
                 // T1.2.8 (SN-CODE-03): run host capability probe with static unknown adapter (CLI context).
                 // Persists report when observabilityDb is available; returns safe JSON subset.
                 return (async () => {
-                    const adapter = createStaticUnknownAdapter();
+                    const adapter = createStaticUnknownAdapter(deps.workspaceRoot);
                     const docCheckedAt = new Date().toISOString();
                     const report = probeHostCapability({
                         adapter,

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

@@ -44,6 +44,7 @@ export interface ConnectorResult<T> {
         channel: ChannelType;
         latencyMs: number;
         degraded?: boolean;
+        detail?: string;
     };
 }
 export interface RawAttempt {

package/runtime/connectors/base/failure-taxonomy.d.ts

@@ -1,4 +1,4 @@
-export declare const FAILURE_CLASSES: readonly ["transport_failure", "auth_failure", "credential_expired", "verification_required", "rate_limited", "cooldown_blocked", "parse_failure", "protocol_mismatch", "semantic_rejection", "idempotency_conflict", "concurrency_conflict", "permanent_input_error", "unknown_platform_change"];
+export declare const FAILURE_CLASSES: readonly ["transport_failure", "auth_failure", "credential_expired", "verification_required", "rate_limited", "cooldown_blocked", "parse_failure", "protocol_mismatch", "semantic_rejection", "idempotency_conflict", "concurrency_conflict", "permanent_input_error", "platform_unavailable", "configuration_missing", "script_error", "timeout", "unknown_platform_change"];
 export type FailureClass = (typeof FAILURE_CLASSES)[number];
 export interface FailureClassification {
     class: FailureClass;

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

@@ -11,6 +11,10 @@ export const FAILURE_CLASSES = [
     "idempotency_conflict",
     "concurrency_conflict",
     "permanent_input_error",
+    "platform_unavailable",
+    "configuration_missing",
+    "script_error",
+    "timeout",
     "unknown_platform_change",
 ];
 const RETRYABLE_BY_CLASS = {
@@ -26,6 +30,10 @@ const RETRYABLE_BY_CLASS = {
     idempotency_conflict: false,
     concurrency_conflict: true,
     permanent_input_error: false,
+    platform_unavailable: false,
+    configuration_missing: false,
+    script_error: false,
+    timeout: true,
     unknown_platform_change: false,
 };
 export class ConnectorPolicyError extends Error {
@@ -118,6 +126,26 @@ export function classifyFailure(error) {
                     class: "permanent_input_error",
                     retryable: RETRYABLE_BY_CLASS.permanent_input_error,
                 };
+            if (code === "platform_unavailable")
+                return {
+                    class: "platform_unavailable",
+                    retryable: RETRYABLE_BY_CLASS.platform_unavailable,
+                };
+            if (code === "configuration_missing")
+                return {
+                    class: "configuration_missing",
+                    retryable: RETRYABLE_BY_CLASS.configuration_missing,
+                };
+            if (code === "script_error")
+                return {
+                    class: "script_error",
+                    retryable: RETRYABLE_BY_CLASS.script_error,
+                };
+            if (code === "timeout")
+                return {
+                    class: "timeout",
+                    retryable: RETRYABLE_BY_CLASS.timeout,
+                };
             if (code === "unknown_platform" || code === "unknown_platform_change")
                 return {
                     class: "unknown_platform_change",

package/runtime/connectors/base/map-life-evidence.js

@@ -1,3 +1,53 @@
+const PLATFORM_ARRAY_KEYS = [
+    "posts",
+    "nodes",
+    "agents",
+    "edges",
+    "results",
+    "entries",
+];
+function tryExtractId(item) {
+    if (item && typeof item === "object" && "id" in item) {
+        const id = item.id;
+        if (id !== undefined && id !== null)
+            return String(id);
+    }
+    return undefined;
+}
+function tryExtractUri(item, platformId, fallbackId) {
+    if (item && typeof item === "object") {
+        const record = item;
+        for (const key of ["url", "uri", "link"]) {
+            const value = record[key];
+            if (typeof value === "string" && value.trim().length > 0) {
+                return value;
+            }
+        }
+    }
+    return `platform://${platformId}/item/${encodeURIComponent(fallbackId)}`;
+}
+function extractFromPlatformArray(platformId, record, observedAt) {
+    for (const key of PLATFORM_ARRAY_KEYS) {
+        const arr = record[key];
+        if (Array.isArray(arr) && arr.length > 0) {
+            const out = [];
+            for (let index = 0; index < arr.length; index += 1) {
+                const item = arr[index];
+                const id = tryExtractId(item) ?? `${platformId}-${key}-${index}`;
+                const uri = tryExtractUri(item, platformId, id);
+                out.push({
+                    id,
+                    kind: "platform_item",
+                    uri,
+                    observedAt,
+                });
+            }
+            if (out.length > 0)
+                return out;
+        }
+    }
+    return undefined;
+}
 function extractSourceRefs(platformId, data, observedAt) {
     if (data && typeof data === "object") {
         const record = data;
@@ -36,6 +86,9 @@ function extractSourceRefs(platformId, data, observedAt) {
                 };
             });
         }
+        const platformRefs = extractFromPlatformArray(platformId, record, observedAt);
+        if (platformRefs)
+            return platformRefs;
     }
     return [];
 }

package/runtime/connectors/base/policy-layer.js

@@ -166,6 +166,9 @@ export function createConnectorPolicyLayer(ctx) {
                     await ctx.cooldownPort.markFailure(request.platformId, intent, classified.class, classified.retryAfterMs);
                 }
                 const isRetryable = classified.retryable;
+                const errorDetail = raw.error && typeof raw.error === "object" && "detail" in raw.error
+                    ? String(raw.error.detail)
+                    : undefined;
                 if (!isRetryable || attempt >= retryPolicy.maxRetries) {
                     return {
                         status: "terminal_failure",
@@ -176,6 +179,7 @@ export function createConnectorPolicyLayer(ctx) {
                             channel: raw.channel,
                             latencyMs: raw.latencyMs,
                             degraded: raw.degraded,
+                            detail: errorDetail,
                         },
                     };
                 }

package/runtime/connectors/manifest/manifest-schema.d.ts

@@ -7,6 +7,7 @@ export declare const connectorRunnerKindSchema: z.ZodEnum<{
     declarative_mcp: "declarative_mcp";
     cli_descriptor: "cli_descriptor";
     custom_adapter: "custom_adapter";
+    scriptable_node: "scriptable_node";
 }>;
 export type ConnectorRunnerKind = z.infer<typeof connectorRunnerKindSchema>;
 export declare const connectorTrustStatusSchema: z.ZodEnum<{
@@ -33,6 +34,7 @@ export declare const runnerDeclarationSchema: z.ZodObject<{
         declarative_mcp: "declarative_mcp";
         cli_descriptor: "cli_descriptor";
         custom_adapter: "custom_adapter";
+        scriptable_node: "scriptable_node";
     }>;
     entrypoint: z.ZodOptional<z.ZodString>;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -86,6 +88,7 @@ export declare const connectorManifestV6Schema: z.ZodObject<{
             declarative_mcp: "declarative_mcp";
             cli_descriptor: "cli_descriptor";
             custom_adapter: "custom_adapter";
+            scriptable_node: "scriptable_node";
         }>;
         entrypoint: z.ZodOptional<z.ZodString>;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

package/runtime/connectors/manifest/manifest-schema.js

@@ -7,6 +7,7 @@ export const connectorRunnerKindSchema = z.enum([
     "custom_adapter",
     "skill",
     "browser",
+    "scriptable_node",
 ]);
 export const connectorTrustStatusSchema = z.enum([
     "declarative_trusted",

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

@@ -7,11 +7,14 @@
  */
 import type { ConnectorExecutor } from "../base/contract.js";
 export type { ConnectorExecutor } from "../base/contract.js";
+import { type EvoMapSecretPort } from "../agent-network/evomap/adapter.js";
 import type { ObservabilityDatabase } from "../../observability/db/index.js";
 import type { StateDatabase } from "../../storage/db/index.js";
+import { createCredentialVault } from "../../storage/services/credential-vault.js";
 export interface ConnectorExecutorAdapterOptions {
     stateDb: StateDatabase;
     observabilityDb: ObservabilityDatabase;
     workspaceRoot?: string;
 }
+export declare function createEvoMapSecretPort(vault: ReturnType<typeof createCredentialVault>): EvoMapSecretPort;
 export declare function createConnectorExecutorAdapter(options: ConnectorExecutorAdapterOptions): ConnectorExecutor;

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

@@ -4,11 +4,13 @@ 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 { instreetManifest } from "../social-community/instreet/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 { createEvoMapRunner } from "../agent-network/evomap/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";
@@ -16,6 +18,7 @@ import { scanConnectorManifests } from "../registry/manifest-scanner.js";
 import { parseConnectorManifestV6 } from "../manifest/manifest-parser.js";
 import fs from "node:fs";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 const DEFAULT_AGENT_WORLD_USERNAME = "nyx_ha";
 const DEFAULT_AGENT_WORLD_PROFILE_PATH_TEMPLATE = "/api/agents/profile/{username}";
 function readString(value) {
@@ -60,7 +63,9 @@ function registerWorkspaceManifests(registry, workspaceRoot) {
                 platformId: manifest.platformId,
                 supportedCapabilities: manifest.capabilities.map((capability) => capability.id),
                 channelPriority: channelPriorityForRunner(manifest),
-                credentialTypes: manifest.credentials.map((credential) => credential.type),
+                credentialTypes: manifest.credentials
+                    .filter((credential) => credential.required !== false)
+                    .map((credential) => credential.type),
                 sourceRefPolicy: manifest.sourceRefPolicy,
             });
         }
@@ -103,6 +108,49 @@ async function fetchAgentWorldJson(input) {
     }
     return resp.json();
 }
+export function createEvoMapSecretPort(vault) {
+    const NODE_SECRET_KEY = "evomap_node_secret";
+    return {
+        async loadNodeSecret(_platformId) {
+            const ctx = await vault.loadCredentialContext(NODE_SECRET_KEY);
+            if (!ctx || ctx.status !== "active" || !ctx.encryptedValue)
+                return null;
+            // CredentialVault.loadCredentialContext already decrypts at rest;
+            // encryptedValue here is the plaintext.
+            return ctx.encryptedValue;
+        },
+        async saveNodeSecret(_platformId, nodeSecret) {
+            await vault.saveCredentialContext({
+                platformId: NODE_SECRET_KEY,
+                credentialType: "node_secret",
+                encryptedValue: nodeSecret,
+                status: "active",
+            });
+        },
+    };
+}
+function joinEvoMapUrl(baseUrl, path) {
+    if (/^https?:\/\//i.test(path))
+        return path;
+    return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+async function fetchEvoMapJson(input) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (input.nodeSecret) {
+        headers["Authorization"] = `Bearer ${input.nodeSecret}`;
+    }
+    const resp = await fetch(joinEvoMapUrl(input.baseUrl, input.path), {
+        method: input.method ?? "GET",
+        headers,
+        body: input.body === undefined ? undefined : JSON.stringify(input.body),
+    });
+    if (!resp.ok) {
+        throw { code: "api_error", detail: `evomap ${input.label}: ${resp.status}` };
+    }
+    return resp.json();
+}
 function createMoltbookMockRunner(workspaceRoot) {
     return {
         async run(_plan, request) {
@@ -162,7 +210,7 @@ function findWorkspaceManifest(platformId, workspaceRoot) {
     for (const file of scanConnectorManifests(workspaceRoot)) {
         const parsed = parseConnectorManifestV6(file.content, file.path);
         if (parsed.ok && parsed.manifest.platformId === platformId) {
-            return parsed.manifest;
+            return { manifest: parsed.manifest, manifestDir: path.dirname(file.path) };
         }
     }
     return undefined;
@@ -247,12 +295,125 @@ function createDeclarativeHttpRunner(manifest, credential) {
         },
     };
 }
+/**
+ * Scriptable Node Runner — workspace connector execution via dynamic ES Module import.
+ *
+ * Contract (runner.mjs default export):
+ *   Input:  { intent: string, payload: unknown, credential?: string }
+ *   Output: { success: boolean, data?: unknown, error?: { code: string, detail: string } }
+ *
+ * Timeout: default 10s, overridable via manifest.runner.config.timeoutMs.
+ * Credential: passed as plain string when manifest.credentials required and vault has active entry.
+ * Error mapping:
+ *   - missing entrypoint file        → configuration_missing
+ *   - default export is not function → script_error
+ *   - runner throws                  → script_error (detail includes error message)
+ *   - Promise.race timeout           → timeout
+ */
+function createScriptableNodeRunner(manifest, manifestDir, activeCredential) {
+    const entryPath = manifest.runner.entrypoint ?? "runner.mjs";
+    const absoluteEntryPath = path.resolve(manifestDir, entryPath);
+    const DEFAULT_TIMEOUT_MS = 10000;
+    const timeoutMs = typeof manifest.runner.config?.timeoutMs === "number" &&
+        Number.isFinite(manifest.runner.config.timeoutMs) &&
+        manifest.runner.config.timeoutMs > 0
+        ? manifest.runner.config.timeoutMs
+        : DEFAULT_TIMEOUT_MS;
+    return {
+        async run(_plan, request) {
+            const started = Date.now();
+            if (!fs.existsSync(absoluteEntryPath)) {
+                return {
+                    platformId: request.platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "configuration_missing",
+                        detail: `scriptable_node runner not found: ${absoluteEntryPath}`,
+                    },
+                };
+            }
+            try {
+                const module = await import(pathToFileURL(absoluteEntryPath).href);
+                const handler = module.default;
+                if (typeof handler !== "function") {
+                    return {
+                        platformId: request.platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "script_error",
+                            detail: `scriptable_node runner must export a default function from ${absoluteEntryPath}`,
+                        },
+                    };
+                }
+                const result = await Promise.race([
+                    handler({
+                        intent: request.intent,
+                        payload: request.payload,
+                        credential: activeCredential?.encryptedValue,
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("scriptable_node_timeout")), timeoutMs)),
+                ]);
+                if (result && typeof result === "object" && "success" in result) {
+                    return {
+                        platformId: request.platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: Boolean(result.success),
+                        payload: result.success
+                            ? {
+                                capability: request.intent,
+                                channel: request.preferredChannel ?? "api_rest",
+                                data: result.data,
+                            }
+                            : undefined,
+                        error: !result.success
+                            ? {
+                                code: result.error?.code ?? "script_error",
+                                detail: result.error?.detail ?? "scriptable_node_runner_returned_failure",
+                            }
+                            : undefined,
+                    };
+                }
+                return {
+                    platformId: request.platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "script_error",
+                        detail: `scriptable_node runner returned invalid shape from ${absoluteEntryPath}`,
+                    },
+                };
+            }
+            catch (err) {
+                const isTimeout = err instanceof Error && err.message === "scriptable_node_timeout";
+                return {
+                    platformId: request.platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: isTimeout ? "timeout" : "script_error",
+                        detail: isTimeout
+                            ? `scriptable_node runner exceeded ${timeoutMs}ms timeout`
+                            : 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 workspaceManifestResult = findWorkspaceManifest(platformId, workspaceRoot);
+            const workspaceManifest = workspaceManifestResult?.manifest;
             const isBuiltInPlatform = platformId === "moltbook" ||
                 platformId === "evomap" ||
                 platformId === "agent-world";
@@ -305,16 +466,44 @@ function createAdaptiveExecutionRunner(vault, 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",
+                const baseUrl = process.env.SECOND_NATURE_EVOMAP_BASE_URL;
+                if (!baseUrl) {
+                    return {
+                        platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "configuration_missing",
+                            detail: "SECOND_NATURE_EVOMAP_BASE_URL not set. This connector requires the evomap node base URL to be configured via environment variable.",
+                        },
+                    };
+                }
+                const secretPort = createEvoMapSecretPort(vault);
+                const runner = createEvoMapRunner({
+                    apiClient: {
+                        async heartbeat(payload, nodeSecret) {
+                            const path = readString(payload.heartbeatPath) ?? "/api/heartbeat";
+                            return fetchEvoMapJson({ baseUrl, path, nodeSecret, method: "POST", body: payload, label: "heartbeat" });
+                        },
+                        async claimTask(payload, nodeSecret) {
+                            const path = readString(payload.claimPath) ?? "/api/tasks/claim";
+                            return fetchEvoMapJson({ baseUrl, path, nodeSecret, method: "POST", body: payload, label: "claim" });
+                        },
                     },
-                };
+                    a2aClient: {
+                        async helloOrRegister(payload) {
+                            const path = readString(payload.registerPath) ?? "/a2a/hello";
+                            return fetchEvoMapJson({ baseUrl, path, method: "POST", body: payload, label: "register" });
+                        },
+                        async discoverWork(payload, nodeSecret) {
+                            const path = readString(payload.discoverPath) ?? "/a2a/discover";
+                            return fetchEvoMapJson({ baseUrl, path, nodeSecret, method: "POST", body: payload, label: "discover" });
+                        },
+                    },
+                    secretPort,
+                });
+                return runner.run(_plan, request);
             }
             if (platformId === "agent-world") {
                 const baseUrl = process.env.SECOND_NATURE_AGENT_WORLD_BASE_URL;
@@ -326,7 +515,7 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
                         success: false,
                         error: {
                             code: "configuration_missing",
-                            detail: "SECOND_NATURE_AGENT_WORLD_BASE_URL not set",
+                            detail: "SECOND_NATURE_AGENT_WORLD_BASE_URL not set. This connector requires the agent-world node base URL to be configured via environment variable.",
                         },
                     };
                 }
@@ -372,11 +561,42 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
                 });
                 return runner.run(_plan, request);
             }
+            // T-CS.C.9: instreet is registered but requires skill/browser channel;
+            // pure api_rest execution returns platform_unavailable.
+            if (platformId === "instreet") {
+                return {
+                    platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "platform_unavailable",
+                        detail: "instreet_requires_skill_browser_channel",
+                    },
+                };
+            }
             // Wave 83: workspace declarative_http connector fallback
             if (workspaceManifest && workspaceManifest.runner.kind === "declarative_http") {
                 const httpRunner = createDeclarativeHttpRunner(workspaceManifest, activeCredential);
                 return httpRunner.run(_plan, request);
             }
+            // Wave 90: workspace scriptable_node connector
+            if (workspaceManifest && workspaceManifest.runner.kind === "scriptable_node") {
+                if (!workspaceManifestResult) {
+                    return {
+                        platformId,
+                        channel: request.preferredChannel ?? "api_rest",
+                        latencyMs: Date.now() - started,
+                        success: false,
+                        error: {
+                            code: "configuration_missing",
+                            detail: "scriptable_node requires workspace manifest with manifestDir",
+                        },
+                    };
+                }
+                const scriptRunner = createScriptableNodeRunner(workspaceManifest, workspaceManifestResult.manifestDir, activeCredential);
+                return scriptRunner.run(_plan, request);
+            }
             return {
                 platformId,
                 channel: request.preferredChannel ?? "api_rest",
@@ -396,6 +616,7 @@ export function createConnectorExecutorAdapter(options) {
     registry.register({ ...moltbookManifest });
     registry.register({ ...evomapManifest });
     registry.register({ ...agentWorldManifest });
+    registry.register({ ...instreetManifest });
     registerWorkspaceManifests(registry, options.workspaceRoot);
     const routeContextPort = createCredentialRouteContextPort(vault);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());