@haaaiawd/second-nature 0.1.27 → 0.1.29

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

@@ -12,11 +12,114 @@ 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";
+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 createAdaptiveExecutionRunner(vault) {
     return {
         async run(_plan, request) {
             const platformId = request.platformId;
             const started = Date.now();
+            if (platformId !== "moltbook" &&
+                platformId !== "evomap" &&
+                platformId !== "agent-world") {
+                return {
+                    platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "unknown_platform",
+                        detail: `no execution runner for ${platformId}`,
+                    },
+                };
+            }
             const credential = await vault.loadCredentialContext(platformId);
             if (!credential ||
                 credential.status !== "active" ||
@@ -91,47 +194,48 @@ function createAdaptiveExecutionRunner(vault) {
                     };
                 }
                 const runner = createAgentWorldRunner({
+                    apiKey: credential.encryptedValue,
                     apiClient: {
                         async readFeed(payload, _apiKey) {
-                            const resp = await fetch(`${baseUrl}/api/v1/feed`, {
-                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                            const username = resolveAgentWorldUsername(payload, "feed");
+                            return fetchAgentWorldJson({
+                                baseUrl,
+                                path: resolveAgentWorldProfilePath(payload, username),
+                                apiKey: _apiKey,
+                                label: "profile feed",
                             });
-                            if (!resp.ok)
-                                throw { code: "api_error", detail: `agent-world feed: ${resp.status}` };
-                            return resp.json();
                         },
                         async discoverWork(payload, _apiKey) {
-                            const resp = await fetch(`${baseUrl}/api/v1/work`, {
-                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
+                            const username = resolveAgentWorldUsername(payload, "discover");
+                            return fetchAgentWorldJson({
+                                baseUrl,
+                                path: resolveAgentWorldProfilePath(payload, username),
+                                apiKey: _apiKey,
+                                label: "profile discover",
                             });
-                            if (!resp.ok)
-                                throw { code: "api_error", detail: `agent-world work: ${resp.status}` };
-                            return resp.json();
                         },
                         async claimTask(payload, _apiKey) {
-                            const resp = await fetch(`${baseUrl}/api/v1/tasks/${payload.taskId ?? "unknown"}/claim`, {
+                            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",
-                                headers: { "Authorization": `Bearer ${_apiKey}`, "Content-Type": "application/json" },
-                                body: JSON.stringify(payload),
+                                body: payload,
+                                label: "task claim",
                             });
-                            if (!resp.ok)
-                                throw { code: "api_error", detail: `agent-world claim: ${resp.status}` };
-                            return resp.json();
                         },
                     },
                 });
                 return runner.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}`,
-                },
-            };
+            throw new Error(`unreachable_connector_platform:${platformId}`);
         },
     };
 }
@@ -141,6 +245,7 @@ export function createConnectorExecutorAdapter(options) {
     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);
@@ -154,6 +259,7 @@ export function createConnectorExecutorAdapter(options) {
     });
     return {
         async executeEffect(input) {
+            registerWorkspaceManifests(registry, options.workspaceRoot);
             return policy.executeWithPolicy(input.intent, {
                 platformId: input.platformId,
                 intent: input.intent,

package/runtime/core/second-nature/body/behavior-promotion/behavior-promotion-loop.d.ts

@@ -0,0 +1,45 @@
+/**
+ * BehaviorPromotionLoop — T-BTS.C.3
+ *
+ * Core logic: Operator-authorized behavior suggestion lifecycle.
+ * - candidate → approved (idempotent: repeated approve returns existing)
+ * - candidate → rejected (with reason)
+ * - candidate → expired (7 days TTL from submission)
+ * - rejected/expired are read-only; new submit creates a fresh candidate
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../../../../storage/db/index.js`
+ *
+ * Boundary:
+ * - Does NOT grant execution authorization; approval is a bookkeeping signal.
+ * - Only accepts operator-authorized suggestions, not connector auto-probe results.
+ *
+ * Test coverage: tests/unit/body/behavior-promotion-loop.test.ts
+ */
+import type { StateDatabase } from "../../../../storage/db/index.js";
+export type PromotionStatus = "candidate" | "approved" | "rejected" | "expired";
+export interface BehaviorPromotion {
+    promotionId: string;
+    behaviorKind: string;
+    description: string;
+    status: PromotionStatus;
+    operatorId?: string;
+    rejectReason?: string;
+    submittedAt: string;
+    decidedAt?: string;
+    expiresAt: string;
+}
+export interface BehaviorPromotionLoop {
+    submitPromotion(input: {
+        promotionId: string;
+        behaviorKind: string;
+        description: string;
+        operatorId?: string;
+    }): Promise<BehaviorPromotion>;
+    approvePromotion(promotionId: string): Promise<BehaviorPromotion>;
+    rejectPromotion(promotionId: string, reason: string): Promise<BehaviorPromotion>;
+    loadPromotion(promotionId: string): Promise<BehaviorPromotion | undefined>;
+    listPromotions(status?: PromotionStatus): Promise<BehaviorPromotion[]>;
+    expireStaleCandidates(): Promise<number>;
+}
+export declare function createBehaviorPromotionLoop(database: StateDatabase): BehaviorPromotionLoop;

package/runtime/core/second-nature/body/behavior-promotion/behavior-promotion-loop.js

@@ -0,0 +1,132 @@
+/**
+ * BehaviorPromotionLoop — T-BTS.C.3
+ *
+ * Core logic: Operator-authorized behavior suggestion lifecycle.
+ * - candidate → approved (idempotent: repeated approve returns existing)
+ * - candidate → rejected (with reason)
+ * - candidate → expired (7 days TTL from submission)
+ * - rejected/expired are read-only; new submit creates a fresh candidate
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../../../../storage/db/index.js`
+ *
+ * Boundary:
+ * - Does NOT grant execution authorization; approval is a bookkeeping signal.
+ * - Only accepts operator-authorized suggestions, not connector auto-probe results.
+ *
+ * Test coverage: tests/unit/body/behavior-promotion-loop.test.ts
+ */
+const DEFAULT_TTL_DAYS = 7;
+function rowToPromotion(row, cols) {
+    const get = (name) => row[cols.indexOf(name)];
+    return {
+        promotionId: get("promotion_id"),
+        behaviorKind: get("behavior_kind"),
+        description: get("description"),
+        status: get("status"),
+        operatorId: get("operator_id") ?? undefined,
+        rejectReason: get("reject_reason") ?? undefined,
+        submittedAt: get("submitted_at"),
+        decidedAt: get("decided_at") ?? undefined,
+        expiresAt: get("expires_at"),
+    };
+}
+export function createBehaviorPromotionLoop(database) {
+    const { sqlite } = database;
+    function loadRecord(promotionId) {
+        const result = sqlite.exec(`SELECT * FROM behavior_promotion WHERE promotion_id = ?`, [promotionId]);
+        if (result.length === 0 || result[0].values.length === 0) {
+            return undefined;
+        }
+        return rowToPromotion(result[0].values[0], result[0].columns);
+    }
+    function saveStatus(promotionId, status, decidedAt, rejectReason) {
+        sqlite.run(`UPDATE behavior_promotion
+       SET status = ?, decided_at = ?, reject_reason = ?
+       WHERE promotion_id = ?`, [status, decidedAt, rejectReason ?? null, promotionId]);
+    }
+    return {
+        async submitPromotion(input) {
+            const now = new Date().toISOString();
+            const expiresAt = new Date(Date.now() + DEFAULT_TTL_DAYS * 24 * 60 * 60 * 1000).toISOString();
+            sqlite.run(`INSERT INTO behavior_promotion
+         (promotion_id, behavior_kind, description, status,
+          operator_id, submitted_at, expires_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                input.promotionId,
+                input.behaviorKind,
+                input.description,
+                "candidate",
+                input.operatorId ?? null,
+                now,
+                expiresAt,
+            ]);
+            return {
+                promotionId: input.promotionId,
+                behaviorKind: input.behaviorKind,
+                description: input.description,
+                status: "candidate",
+                operatorId: input.operatorId,
+                submittedAt: now,
+                expiresAt,
+            };
+        },
+        async approvePromotion(promotionId) {
+            const rec = loadRecord(promotionId);
+            if (!rec) {
+                throw new Error(`promotion_not_found:${promotionId}`);
+            }
+            if (rec.status === "approved") {
+                return rec; // idempotent
+            }
+            if (rec.status === "rejected" || rec.status === "expired") {
+                throw new Error(`promotion_immutable:${promotionId}:${rec.status}`);
+            }
+            const now = new Date().toISOString();
+            saveStatus(promotionId, "approved", now);
+            return { ...rec, status: "approved", decidedAt: now };
+        },
+        async rejectPromotion(promotionId, reason) {
+            const rec = loadRecord(promotionId);
+            if (!rec) {
+                throw new Error(`promotion_not_found:${promotionId}`);
+            }
+            if (rec.status === "rejected") {
+                return rec; // idempotent
+            }
+            if (rec.status === "approved" || rec.status === "expired") {
+                throw new Error(`promotion_immutable:${promotionId}:${rec.status}`);
+            }
+            const now = new Date().toISOString();
+            saveStatus(promotionId, "rejected", now, reason);
+            return { ...rec, status: "rejected", decidedAt: now, rejectReason: reason };
+        },
+        async loadPromotion(promotionId) {
+            return loadRecord(promotionId);
+        },
+        async listPromotions(status) {
+            let sql = `SELECT * FROM behavior_promotion`;
+            const params = [];
+            if (status) {
+                sql += ` WHERE status = ?`;
+                params.push(status);
+            }
+            sql += ` ORDER BY submitted_at DESC`;
+            const result = sqlite.exec(sql, params);
+            if (result.length === 0 || result[0].values.length === 0) {
+                return [];
+            }
+            return result[0].values.map((row) => rowToPromotion(row, result[0].columns));
+        },
+        async expireStaleCandidates() {
+            const now = new Date().toISOString();
+            sqlite.run(`UPDATE behavior_promotion
+         SET status = 'expired', decided_at = ?
+         WHERE status = 'candidate' AND expires_at < ?`, [now, now]);
+            // sql.js does not provide changes count easily; approximate via re-query
+            const result = sqlite.exec(`SELECT COUNT(*) as cnt FROM behavior_promotion
+         WHERE status = 'expired' AND decided_at = ?`, [now]);
+            return result[0]?.values[0]?.[0] ?? 0;
+        },
+    };
+}

package/runtime/core/second-nature/body/circuit-breaker/circuit-breaker-manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * CircuitBreakerManager — T-BTS.C.5
+ *
+ * Core logic: State machine (Closed → Open → HalfOpen → Closed/Open).
+ * - Closed: counts consecutive failures; threshold hit → Open.
+ * - Open: rejects execution; cooldown elapsed → HalfOpen.
+ * - HalfOpen: initiates runWetProbe via ProbeSignalAdapter.
+ *   - strict side-effect → probe_policy_denied, stays HalfOpen.
+ *   - probe success → Closed + invalidate affordance cache (DR-003).
+ *   - probe failure → Open.
+ *
+ * Persistence:
+ * - State stored in SQLite `circuit_breaker_state` table (v7-003).
+ * - Loads previous state on first access.
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../../../../storage/db/index.js`
+ * - `WetProbeRunner` from `../../../../connectors/base/wet-probe-runner.js`
+ * - `CapabilityContractRegistryV7` from `../../../../connectors/base/manifest-v7.js`
+ * - `ProbeSignalAdapter` from `../probe-signal-adapter.js`
+ *
+ * Boundary:
+ * - Manager decides WHEN to probe (DR-002); connector-system executes it.
+ * - Does NOT execute HTTP directly — delegates to ProbeSignalAdapter.
+ *
+ * Test coverage: tests/unit/body/circuit-breaker-manager.test.ts
+ */
+import type { StateDatabase } from "../../../../storage/db/index.js";
+import type { CapabilityContractRegistryV7 } from "../../../../connectors/base/manifest-v7.js";
+import type { ProbeSignalAdapter } from "../probe-signal-adapter.js";
+export type BreakerState = "closed" | "open" | "half_open";
+export interface BreakerRecord {
+    platformId: string;
+    capabilityId: string;
+    state: BreakerState;
+    failureCount: number;
+    consecutiveFailures: number;
+    lastFailureAt?: string;
+    openedAt?: string;
+    lastProbeAt?: string;
+}
+export interface CircuitBreakerManager {
+    evaluateFailure(platformId: string, capabilityId: string): Promise<BreakerState>;
+    evaluateSuccess(platformId: string, capabilityId: string): Promise<BreakerState>;
+    canExecute(platformId: string, capabilityId: string): Promise<boolean>;
+    getState(platformId: string, capabilityId: string): Promise<BreakerState>;
+    attemptReset(platformId: string, capabilityId: string): Promise<BreakerState>;
+}
+export interface CircuitBreakerManagerOptions {
+    database: StateDatabase;
+    probeAdapter: ProbeSignalAdapter;
+    registry: CapabilityContractRegistryV7;
+    /** Consecutive failures before opening. Default 3. */
+    failureThreshold?: number;
+    /** Cooldown in ms before HalfOpen. Default 30_000. */
+    cooldownMs?: number;
+    /** Callback when breaker transitions to Closed (for affordance cache invalidation). */
+    onClosed?: (platformId: string, capabilityId: string) => void;
+}
+export declare function createCircuitBreakerManager(options: CircuitBreakerManagerOptions): CircuitBreakerManager;

package/runtime/core/second-nature/body/circuit-breaker/circuit-breaker-manager.js

@@ -0,0 +1,174 @@
+/**
+ * CircuitBreakerManager — T-BTS.C.5
+ *
+ * Core logic: State machine (Closed → Open → HalfOpen → Closed/Open).
+ * - Closed: counts consecutive failures; threshold hit → Open.
+ * - Open: rejects execution; cooldown elapsed → HalfOpen.
+ * - HalfOpen: initiates runWetProbe via ProbeSignalAdapter.
+ *   - strict side-effect → probe_policy_denied, stays HalfOpen.
+ *   - probe success → Closed + invalidate affordance cache (DR-003).
+ *   - probe failure → Open.
+ *
+ * Persistence:
+ * - State stored in SQLite `circuit_breaker_state` table (v7-003).
+ * - Loads previous state on first access.
+ *
+ * Dependencies:
+ * - `StateDatabase` from `../../../../storage/db/index.js`
+ * - `WetProbeRunner` from `../../../../connectors/base/wet-probe-runner.js`
+ * - `CapabilityContractRegistryV7` from `../../../../connectors/base/manifest-v7.js`
+ * - `ProbeSignalAdapter` from `../probe-signal-adapter.js`
+ *
+ * Boundary:
+ * - Manager decides WHEN to probe (DR-002); connector-system executes it.
+ * - Does NOT execute HTTP directly — delegates to ProbeSignalAdapter.
+ *
+ * Test coverage: tests/unit/body/circuit-breaker-manager.test.ts
+ */
+export function createCircuitBreakerManager(options) {
+    const { database: { sqlite }, probeAdapter, failureThreshold = 3, cooldownMs = 30_000, onClosed, } = options;
+    function loadRecord(platformId, capabilityId) {
+        const result = sqlite.exec(`SELECT * FROM circuit_breaker_state
+       WHERE platform_id = ? AND capability_id = ?`, [platformId, capabilityId]);
+        if (result.length === 0 || result[0].values.length === 0) {
+            return {
+                platformId,
+                capabilityId,
+                state: "closed",
+                failureCount: 0,
+                consecutiveFailures: 0,
+            };
+        }
+        const cols = result[0].columns;
+        const get = (name) => result[0].values[0][cols.indexOf(name)];
+        return {
+            platformId,
+            capabilityId,
+            state: get("state"),
+            failureCount: get("failure_count") ?? 0,
+            consecutiveFailures: get("consecutive_failures") ?? 0,
+            lastFailureAt: get("last_failure_at") ?? undefined,
+            openedAt: get("opened_at") ?? undefined,
+            lastProbeAt: get("last_probe_at") ?? undefined,
+        };
+    }
+    function saveRecord(rec) {
+        const now = new Date().toISOString();
+        sqlite.run(`INSERT INTO circuit_breaker_state
+       (platform_id, capability_id, state, failure_count, consecutive_failures,
+        last_failure_at, opened_at, last_probe_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(platform_id, capability_id) DO UPDATE SET
+         state = excluded.state,
+         failure_count = excluded.failure_count,
+         consecutive_failures = excluded.consecutive_failures,
+         last_failure_at = excluded.last_failure_at,
+         opened_at = excluded.opened_at,
+         last_probe_at = excluded.last_probe_at,
+         updated_at = excluded.updated_at`, [
+            rec.platformId,
+            rec.capabilityId,
+            rec.state,
+            rec.failureCount,
+            rec.consecutiveFailures,
+            rec.lastFailureAt ?? null,
+            rec.openedAt ?? null,
+            rec.lastProbeAt ?? null,
+            now,
+        ]);
+    }
+    return {
+        async evaluateFailure(platformId, capabilityId) {
+            const rec = loadRecord(platformId, capabilityId);
+            rec.consecutiveFailures += 1;
+            rec.failureCount += 1;
+            rec.lastFailureAt = new Date().toISOString();
+            if (rec.state === "closed" && rec.consecutiveFailures >= failureThreshold) {
+                rec.state = "open";
+                rec.openedAt = rec.lastFailureAt;
+            }
+            else if (rec.state === "half_open") {
+                // HalfOpen + failure → back to Open
+                rec.state = "open";
+                rec.openedAt = rec.lastFailureAt;
+            }
+            // open + failure stays open
+            saveRecord(rec);
+            return rec.state;
+        },
+        async evaluateSuccess(platformId, capabilityId) {
+            const rec = loadRecord(platformId, capabilityId);
+            if (rec.state === "half_open") {
+                rec.state = "closed";
+                rec.consecutiveFailures = 0;
+                rec.openedAt = undefined;
+                if (onClosed) {
+                    onClosed(platformId, capabilityId);
+                }
+            }
+            else if (rec.state === "closed") {
+                rec.consecutiveFailures = 0;
+            }
+            // open + success stays open (should not happen via normal path)
+            saveRecord(rec);
+            return rec.state;
+        },
+        async canExecute(platformId, capabilityId) {
+            const rec = loadRecord(platformId, capabilityId);
+            if (rec.state === "closed")
+                return true;
+            if (rec.state === "half_open")
+                return true; // allow limited probe traffic
+            if (rec.state === "open") {
+                if (rec.openedAt) {
+                    const elapsed = Date.now() - new Date(rec.openedAt).getTime();
+                    if (elapsed >= cooldownMs) {
+                        return true; // let caller attempt, will transition to HalfOpen
+                    }
+                }
+                return false;
+            }
+            return true;
+        },
+        async getState(platformId, capabilityId) {
+            return loadRecord(platformId, capabilityId).state;
+        },
+        async attemptReset(platformId, capabilityId) {
+            const rec = loadRecord(platformId, capabilityId);
+            if (rec.state !== "half_open" && rec.state !== "open") {
+                return rec.state;
+            }
+            // If cooldown has elapsed from Open, transition to HalfOpen and probe
+            if (rec.state === "open" && rec.openedAt) {
+                const elapsed = Date.now() - new Date(rec.openedAt).getTime();
+                if (elapsed < cooldownMs) {
+                    return rec.state; // still cooling
+                }
+                rec.state = "half_open";
+                saveRecord(rec);
+            }
+            // HalfOpen: run wet probe
+            const probeResult = await probeAdapter.runAndRecordProbe(platformId, capabilityId, options.registry);
+            rec.lastProbeAt = new Date().toISOString();
+            if (probeResult.httpStatus === 0 && probeResult.actualStatus === "unavailable") {
+                // probe_policy_denied or network failure → stay HalfOpen
+                saveRecord(rec);
+                return rec.state;
+            }
+            if (probeResult.actualStatus === "available") {
+                rec.state = "closed";
+                rec.consecutiveFailures = 0;
+                rec.openedAt = undefined;
+                if (onClosed) {
+                    onClosed(platformId, capabilityId);
+                }
+            }
+            else {
+                rec.state = "open";
+                rec.openedAt = new Date().toISOString();
+            }
+            saveRecord(rec);
+            return rec.state;
+        },
+    };
+}

package/runtime/core/second-nature/body/probe-signal-adapter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ProbeSignalAdapter — T-BTS.C.4
+ *
+ * Core logic: Bridge between WetProbeRunner and state-memory.
+ * 1. Runs a wet probe for a capability.
+ * 2. Persists the CapabilityProbeResult to state-memory.
+ * 3. If the probe indicates degradation/unavailability, records a
+ *    corresponding ToolExperience row with triggerSource="probe".
+ *
+ * Dependencies:
+ * - `WetProbeRunner` from `../../../connectors/base/wet-probe-runner.js`
+ * - `CapabilityContractRegistryV7` from `../../../connectors/base/manifest-v7.js`
+ * - `CapabilityProbeResultStore` from `../../../storage/services/tool-experience-store.js`
+ * - `ToolExperienceStore` from `../../../storage/services/tool-experience-store.js`
+ * - `ExperienceWriter` from `./tool-experience/experience-writer.js`
+ *
+ * Boundary:
+ * - Does NOT modify breaker state — caller (CircuitBreakerManager) decides.
+ * - probePolicyDenied is treated as a valid result, not an error.
+ *
+ * Test coverage: tests/unit/body/probe-signal-adapter.test.ts
+ */
+import type { WetProbeRunner } from "../../../connectors/base/wet-probe-runner.js";
+import type { CapabilityContractRegistryV7 } from "../../../connectors/base/manifest-v7.js";
+import type { CapabilityProbeResultStore, ToolExperienceStore } from "../../../storage/services/tool-experience-store.js";
+export interface ProbeSignalAdapter {
+    runAndRecordProbe(platformId: string, capabilityId: string, registry: CapabilityContractRegistryV7): Promise<{
+        actualStatus: string;
+        httpStatus: number;
+        recorded: boolean;
+        experienceRecorded: boolean;
+    }>;
+}
+export declare function createProbeSignalAdapter(deps: {
+    wetProbeRunner: WetProbeRunner;
+    probeResultStore: CapabilityProbeResultStore;
+    toolExperienceStore: ToolExperienceStore;
+}): ProbeSignalAdapter;