@haaaiawd/second-nature 0.2.9 → 0.2.13

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

@@ -4,6 +4,7 @@ import { createAgentGoalStore } from "../../storage/goal/agent-goal-store.js";
 import { createNarrativeStateStore } from "../../storage/narrative/narrative-state-store.js";
 import { createRelationshipMemoryStore } from "../../storage/relationship/relationship-memory-store.js";
 import { createIdentityProfileStore } from "../../storage/services/identity-profile-store.js";
+import { toCanonicalSourceRef } from "../../shared/source-ref-compat.js";
 import { generateHeartbeatDigest, } from "../../observability/services/heartbeat-digest-assembler.js";
 import { createHistoryDigestStore } from "../../storage/services/history-digest-store.js";
 export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, options = {}) {
@@ -26,11 +27,7 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
             const snapshot = await loadLifeEvidenceSnapshot(options.state, options.workspaceRoot, { limit: 50 }, 
             // Skip repair gate here — runner is called inside a live cycle; gate ran at startup.
             { runRepairGate: false });
-            lifeEvidenceRefs = snapshot.evidenceRefs.map((ref) => ({
-                id: ref.id,
-                kind: ref.kind,
-                uri: ref.uri,
-            }));
+            lifeEvidenceRefs = snapshot.evidenceRefs.map((ref) => toCanonicalSourceRef(ref));
             platformEventCount = snapshot.platformEvents.length;
             workEventCount = snapshot.workEvents.length;
             if (snapshot.empty) {

package/runtime/connectors/base/normalized-evidence-content.d.ts

@@ -23,6 +23,8 @@
 export declare const NORMALIZED_EVIDENCE_SCHEMA_VERSION = 1;
 export type EvidenceSourceKind = "post" | "comment" | "profile" | "task" | "event" | "game_state" | "notification" | "document" | "unknown";
 export type SummaryProducer = "connector_rules" | "model_assist" | "operator_supplied";
+export type EvidenceContentStatus = "content_present" | "content_missing" | "content_redacted";
+export type EvidenceContentMissingReason = "id_only" | "empty_payload" | "unsupported_shape" | "redacted_private";
 export interface EvidenceActor {
     id?: string;
     displayName?: string;
@@ -36,6 +38,8 @@ export interface NormalizedEvidenceContent {
     externalId?: string;
     title?: string;
     summary: string;
+    contentStatus: EvidenceContentStatus;
+    contentMissingReason?: EvidenceContentMissingReason;
     excerpt?: string;
     canonicalText?: string;
     actor?: EvidenceActor;

package/runtime/connectors/base/normalized-evidence-content.js

@@ -226,8 +226,25 @@ function normalizeSingleItem(item, options) {
     const tags = extractTags(item);
     const entities = extractEntities(item);
     const metrics = extractMetrics(item);
-    const rawText = bodyText ?? title ?? "[no readable content]";
-    const summary = truncate(rawText, 160);
+    const hasReadableContent = isNonEmptyString(bodyText) || isNonEmptyString(title);
+    const hasContentMarkers = isNonEmptyString(url) ||
+        (actor?.displayName && actor.displayName.length > 0) ||
+        tags.length > 0 ||
+        entities.length > 0 ||
+        (metrics && Object.keys(metrics).length > 0);
+    let contentStatus = "content_present";
+    let contentMissingReason;
+    let summary;
+    if (!hasReadableContent && !hasContentMarkers) {
+        contentStatus = "content_missing";
+        contentMissingReason = externalId ? "id_only" : "empty_payload";
+        summary = `Content missing: ${contentMissingReason === "id_only" ? "id-only evidence" : "empty payload"}`;
+    }
+    else {
+        const rawText = bodyText ?? title ?? "[no readable content]";
+        summary = truncate(rawText, 160);
+    }
+    const rawText = bodyText ?? title ?? "";
     const excerpt = rawText.length > summary.length ? truncate(rawText, options.excerptMaxChars ?? 240) : undefined;
     const canonicalText = truncate(rawText, options.canonicalTextMaxChars ?? 2000);
     return {
@@ -238,6 +255,8 @@ function normalizeSingleItem(item, options) {
         externalId,
         title,
         summary,
+        contentStatus,
+        contentMissingReason,
         excerpt,
         canonicalText,
         actor,

package/runtime/connectors/evidence-normalizer.js

@@ -31,6 +31,11 @@ import { extractNormalizedEvidenceItems, computeEvidenceContentHashSync, } from
 function computeLegacyContentHash(content) {
     return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
+function truncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}…`;
+}
 function buildSourceRef(platformId, capabilityId, itemId, observedAt) {
     return {
         uri: `sn://connector_result/${platformId}/${capabilityId}/${itemId}`,
@@ -191,6 +196,32 @@ async function normalizeLegacyConnectorEvidence(db, result, now) {
         const observedAt = result.observedAt ?? now;
         const sourceRef = buildSourceRef(result.platformId, result.capabilityId, itemId, observedAt);
         const sensitivityHint = mergeSensitivityHint(inferSensitivityHint(item.content), item.sensitivityHint);
+        const trimmedContent = item.content.trim();
+        const looksLikeIdOnly = /^[a-z0-9_-]+$/i.test(trimmedContent) && trimmedContent.length < 64;
+        const contentStatus = looksLikeIdOnly || trimmedContent.length === 0
+            ? "content_missing"
+            : "content_present";
+        const contentMissingReason = contentStatus === "content_missing"
+            ? trimmedContent.length === 0
+                ? "empty_payload"
+                : "id_only"
+            : undefined;
+        const normalized = {
+            schemaVersion: 1,
+            sourceKind: "unknown",
+            platformId: result.platformId,
+            capabilityId: result.capabilityId,
+            externalId: item.id,
+            summary: contentStatus === "content_missing"
+                ? `Content missing: ${contentMissingReason === "id_only" ? "id-only evidence" : "empty payload"}`
+                : truncate(trimmedContent, 160),
+            contentStatus,
+            contentMissingReason,
+            excerpt: contentStatus === "content_present" ? truncate(trimmedContent, 240) : undefined,
+            canonicalText: contentStatus === "content_present" ? truncate(trimmedContent, 2000) : undefined,
+            observedAt,
+            summaryProducer: "connector_rules",
+        };
         const writeResult = await writeEvidenceItem(db, {
             id: `ev_${result.platformId}_${itemId}_${observedAt.replace(/[:.]/g, "")}`,
             createdAt: now,
@@ -201,7 +232,7 @@ async function normalizeLegacyConnectorEvidence(db, result, now) {
             sourceRefs: [sourceRef],
             redactionClass: sensitivityHint === "sensitive" ? "blocked" : "none",
             lifecycleStatus: "pending",
-            payloadJson: item.metadata ? JSON.stringify(item.metadata) : null,
+            payloadJson: JSON.stringify(normalized),
         });
         if ("id" in writeResult) {
             evidenceIds.push(writeResult.id);

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

@@ -116,7 +116,7 @@ export declare const connectorManifestV6Schema: z.ZodObject<{
 export type ConnectorManifestV6 = z.infer<typeof connectorManifestV6Schema>;
 export interface ConnectorConflict {
     platformId: string;
-    existingSource: "built_in" | "workspace";
+    existingSource: "built_in" | "workspace" | "workspace_shadow";
     attemptedSource: "built_in" | "workspace";
     reason: string;
 }
@@ -127,7 +127,7 @@ export interface ConnectorManifestValidationError {
 }
 export interface ConnectorInventoryEntry {
     platformId: string;
-    source: "built_in" | "workspace";
+    source: "built_in" | "workspace" | "workspace_shadow";
     manifestPath?: string;
     trustStatus: ConnectorTrustStatus;
     executable: boolean;

package/runtime/connectors/registry/dynamic-connector-registry.js

@@ -41,6 +41,12 @@ function manifestToInventoryEntry(manifest, source, manifestPath) {
         validationErrors: [],
     };
 }
+function isSafeBuiltInShadow(manifest) {
+    const reason = manifest.trust?.reason?.trim();
+    if (!manifest.trust?.override || !reason)
+        return false;
+    return manifest.runner.kind === "declarative_http" || manifest.runner.kind === "scriptable_node";
+}
 /**
  * DynamicConnectorRegistry scans workspace manifests, validates, classifies trust,
  * merges built-in entries, applies fail-closed conflict policy, and publishes
@@ -79,11 +85,20 @@ export class DynamicConnectorRegistry {
             }
             const manifest = parseResult.manifest;
             const manifestPath = path.relative(workspaceRoot, file.path);
-            // Duplicate platformId without override -> fail-closed
+            // Duplicate platformId without explicit safe override -> fail-closed.
+            // Built-ins may be shadowed only by an auditable workspace manifest with
+            // a trusted runner kind, so operators can repair endpoint config without
+            // silently replacing native code.
             if (builtInMap.has(manifest.platformId) || dynamicMap.has(manifest.platformId)) {
                 const existing = builtInMap.get(manifest.platformId) ?? dynamicMap.get(manifest.platformId);
                 const allowOverride = manifest.trust?.override === true;
                 const isTrustedSource = existing.source === "built_in";
+                if (isTrustedSource && isSafeBuiltInShadow(manifest)) {
+                    const entry = manifestToInventoryEntry(manifest, "workspace_shadow", manifestPath);
+                    dynamicMap.set(manifest.platformId, entry);
+                    registered++;
+                    continue;
+                }
                 if (!allowOverride || isTrustedSource) {
                     conflicts.push({
                         platformId: manifest.platformId,

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

@@ -51,7 +51,13 @@ function channelPriorityForRunner(manifest) {
         return ["browser"];
     return ["api_rest"];
 }
-function registerWorkspaceManifests(registry, workspaceRoot) {
+function isSafeBuiltInShadow(manifest) {
+    const reason = manifest.trust?.reason?.trim();
+    if (!manifest.trust?.override || !reason)
+        return false;
+    return manifest.runner.kind === "declarative_http" || manifest.runner.kind === "scriptable_node";
+}
+function registerWorkspaceManifests(registry, builtInPlatformIds, workspaceRoot) {
     if (!workspaceRoot)
         return;
     for (const file of scanConnectorManifests(workspaceRoot)) {
@@ -59,6 +65,12 @@ function registerWorkspaceManifests(registry, workspaceRoot) {
         if (!parsed.ok)
             continue;
         const manifest = parsed.manifest;
+        // Built-in platforms may only be shadowed by auditable, trusted-runner manifests.
+        // Unsafe shadows are ignored by execution registry; they remain visible in
+        // DynamicConnectorRegistry conflicts for diagnostics.
+        if (builtInPlatformIds.has(manifest.platformId) && !isSafeBuiltInShadow(manifest)) {
+            continue;
+        }
         try {
             registry.register({
                 platformId: manifest.platformId,
@@ -201,8 +213,8 @@ function createMoltbookMockRunner(workspaceRoot) {
                     latencyMs: Date.now() - started,
                     success: false,
                     error: {
-                        code: "mock_read_error",
-                        detail: String(err),
+                        code: "configuration_missing",
+                        detail: `moltbook mock unreadable: ${err instanceof Error ? err.message : String(err)}`,
                     },
                 };
             }
@@ -424,9 +436,13 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
             const workspaceManifest = workspaceManifestResult?.manifest;
             const isBuiltInPlatform = platformId === "moltbook" ||
                 platformId === "evomap" ||
-                platformId === "agent-world";
+                platformId === "agent-world" ||
+                platformId === "instreet";
+            const effectiveWorkspaceManifest = workspaceManifest && (!isBuiltInPlatform || isSafeBuiltInShadow(workspaceManifest))
+                ? workspaceManifest
+                : undefined;
             const requiresCredential = isBuiltInPlatform ||
-                Boolean(workspaceManifest?.credentials.some((credential) => credential.required !== false));
+                Boolean(effectiveWorkspaceManifest?.credentials.some((credential) => credential.required !== false));
             const credential = requiresCredential
                 ? await vault.loadCredentialContext(platformId)
                 : undefined;
@@ -448,9 +464,33 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
             const activeCredential = credential?.status === "active" && credential.encryptedValue
                 ? { encryptedValue: credential.encryptedValue }
                 : undefined;
+            // Safe workspace shadows of built-in platforms take precedence over built-in runners.
+            if (effectiveWorkspaceManifest && effectiveWorkspaceManifest.runner.kind === "declarative_http") {
+                const httpRunner = createDeclarativeHttpRunner(effectiveWorkspaceManifest, activeCredential);
+                return httpRunner.run(_plan, request);
+            }
+            if (effectiveWorkspaceManifest && effectiveWorkspaceManifest.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(effectiveWorkspaceManifest, workspaceManifestResult.manifestDir, activeCredential);
+                return scriptRunner.run(_plan, request);
+            }
             if (platformId === "moltbook") {
                 const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
                 if (baseUrl) {
+                    const effectivePlan = request.intent === "feed.read" && _plan.channel !== "api_rest"
+                        ? { ..._plan, channel: "api_rest", endpointMode: "rest_json", degraded: false }
+                        : _plan;
                     const apiClient = createMoltbookApiClient({
                         baseUrl,
                         accessToken: activeCredential.encryptedValue,
@@ -461,13 +501,13 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
                         skillRunner: {
                             run: async () => {
                                 throw {
-                                    code: "protocol_mismatch",
+                                    code: "configuration_missing",
                                     detail: "moltbook_skill_runner_not_configured",
                                 };
                             },
                         },
                     });
-                    return runner.run(_plan, request);
+                    return runner.run(effectivePlan, request);
                 }
                 // Mock fallback when real API is not configured
                 const mockRunner = createMoltbookMockRunner(workspaceRoot);
@@ -583,28 +623,6 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
                     },
                 };
             }
-            // 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",
@@ -621,11 +639,12 @@ function createAdaptiveExecutionRunner(vault, workspaceRoot) {
 export function createConnectorExecutorAdapter(options) {
     const vault = createCredentialVault(options.stateDb.db);
     const registry = new CapabilityContractRegistry();
-    registry.register({ ...moltbookManifest });
-    registry.register({ ...evomapManifest });
-    registry.register({ ...agentWorldManifest });
-    registry.register({ ...instreetManifest });
-    registerWorkspaceManifests(registry, options.workspaceRoot);
+    const builtInManifests = [moltbookManifest, evomapManifest, agentWorldManifest, instreetManifest];
+    const builtInPlatformIds = new Set(builtInManifests.map((m) => m.platformId));
+    for (const manifest of builtInManifests) {
+        registry.register({ ...manifest });
+    }
+    registerWorkspaceManifests(registry, builtInPlatformIds, options.workspaceRoot);
     const cooldownPort = createConnectorCooldownPort(options.stateDb);
     const routeContextPort = createCredentialRouteContextPort(vault, options.stateDb);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
@@ -641,7 +660,7 @@ export function createConnectorExecutorAdapter(options) {
     });
     return {
         async executeEffect(input) {
-            registerWorkspaceManifests(registry, options.workspaceRoot);
+            registerWorkspaceManifests(registry, builtInPlatformIds, options.workspaceRoot);
             return policy.executeWithPolicy(input.intent, {
                 platformId: input.platformId,
                 intent: input.intent,

package/runtime/core/second-nature/action/action-closure-recorder.d.ts

@@ -38,11 +38,15 @@ export interface ActionClosureRecord {
     nextState: string;
     reason: V8ReasonCode;
     sourceRefs: SourceRef[];
+    proofRefs?: SourceRef[];
+    traceRefs?: SourceRef[];
     memoryReviewCandidate?: MemoryReviewCandidateClosure;
     closedAt: string;
 }
 export interface RecordClosureOptions {
     now?: string;
+    platformId?: string;
+    capabilityId?: string;
 }
 export type RecordClosureResult = {
     status: "recorded";

package/runtime/core/second-nature/action/action-closure-recorder.js

@@ -21,6 +21,7 @@
  * Test coverage: tests/unit/action/action-closure-recorder.test.ts
  */
 import { writeActionClosureRecord, readActionClosuresByCycle, } from "../../../storage/v8-state-stores.js";
+import { buildClosureProvenance, cycleTraceRef, closureTraceRef, decisionProofRef, } from "../../../shared/provenance-tier.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -50,7 +51,8 @@ export async function recordNoActionClosure(db, cycleId, noActionReason, options
         status: "no_action",
         reason: noActionReason,
         nextState: "await_next_cycle",
-        sourceRefs: [
+        sourceRefs: [cycleTraceRef(cycleId)],
+        proofRefs: [
             {
                 uri: `sn://closure/no_action/${cycleId}`,
                 family: "action_closure",
@@ -59,9 +61,9 @@ export async function recordNoActionClosure(db, cycleId, noActionReason, options
                 resolveStatus: "resolvable",
             },
         ],
+        traceRefs: [cycleTraceRef(cycleId)],
         redactionClass: "none",
-        lifecycleStatus: "closed",
-        payloadJson: JSON.stringify({ dispatchAttempt: 0, inputSummary: "no-action" }),
+        payload: { dispatchAttempt: 0, inputSummary: "no-action" },
     });
     if ("reason" in result) {
         return result;
@@ -74,21 +76,28 @@ export async function recordNoActionClosure(db, cycleId, noActionReason, options
 export async function recordRememberClosure(db, cycleId, memoryReviewCandidate, options) {
     const now = options?.now ?? new Date().toISOString();
     const closureId = `cls_remember_${cycleId}_${now.replace(/[:.]/g, "")}`;
+    const provenance = buildClosureProvenance({
+        sourceRefs: memoryReviewCandidate.sourceRefs,
+        traceRefs: [cycleTraceRef(cycleId)],
+    });
     const result = await writeActionClosureRecord(db, {
         id: closureId,
         createdAt: now,
         cycleId,
+        platformId: options?.platformId ?? "heartbeat",
+        capabilityId: options?.capabilityId,
         status: "completed",
         reason: "remember_for_review",
         nextState: "pending_daily_review",
-        sourceRefs: memoryReviewCandidate.sourceRefs,
+        sourceRefs: provenance.sourceRefs,
+        proofRefs: provenance.proofRefs,
+        traceRefs: provenance.traceRefs,
         redactionClass: "none",
-        lifecycleStatus: "closed",
-        payloadJson: JSON.stringify({
+        payload: {
             memoryReviewCandidate,
             dispatchAttempt: 1,
             inputSummary: `remember_for_review topic=${memoryReviewCandidate.topicKey}`,
-        }),
+        },
     });
     if ("reason" in result) {
         return result;
@@ -101,24 +110,21 @@ export async function recordRememberClosure(db, cycleId, memoryReviewCandidate,
 export async function recordPolicyOutcomeClosure(db, cycleId, closureStatus, reason, params, options) {
     const now = options?.now ?? new Date().toISOString();
     const closureId = `cls_${closureStatus}_${cycleId}_${now.replace(/[:.]/g, "")}`;
-    const sourceRefs = [
-        {
-            uri: `sn://closure/${closureStatus}/${cycleId}`,
-            family: "action_closure",
-            id: cycleId,
-            redactionClass: "none",
-            resolveStatus: "resolvable",
-        },
+    const sourceRefs = params.proposalId
+        ? [
+            {
+                uri: `sn://proposal/${params.proposalId}`,
+                family: "action_closure",
+                id: params.proposalId,
+                redactionClass: "none",
+                resolveStatus: "resolvable",
+            },
+        ]
+        : [];
+    const proofRefs = [
+        closureTraceRef(closureId),
+        ...(params.decisionId ? [decisionProofRef(params.decisionId)] : []),
     ];
-    if (params.decisionId) {
-        sourceRefs.push({
-            uri: `sn://decision/${params.decisionId}`,
-            family: "action_closure",
-            id: params.decisionId,
-            redactionClass: "none",
-            resolveStatus: "resolvable",
-        });
-    }
     const result = await writeActionClosureRecord(db, {
         id: closureId,
         createdAt: now,
@@ -131,14 +137,15 @@ export async function recordPolicyOutcomeClosure(db, cycleId, closureStatus, rea
         reason,
         nextState: params.nextState ?? "await_next_cycle",
         sourceRefs,
+        proofRefs,
+        traceRefs: [cycleTraceRef(cycleId)],
         redactionClass: "none",
-        lifecycleStatus: "closed",
-        payloadJson: JSON.stringify({
+        payload: {
             dispatchAttempt: 1,
             inputSummary: buildInputSummary(params.proposalId, params.decisionId),
             postProcessing: params.postProcessing ?? [],
             downgradedActionKind: params.downgradedActionKind,
-        }),
+        },
     });
     if ("reason" in result) {
         return result;
@@ -151,14 +158,19 @@ export async function recordPolicyOutcomeClosure(db, cycleId, closureStatus, rea
 export async function recordExecutionClosure(db, cycleId, closureStatus, reason, params, options) {
     const now = options?.now ?? new Date().toISOString();
     const closureId = `cls_exec_${closureStatus}_${cycleId}_${now.replace(/[:.]/g, "")}`;
-    const sourceRefs = [
-        {
-            uri: `sn://closure/${closureStatus}/${cycleId}`,
-            family: "action_closure",
-            id: cycleId,
-            redactionClass: "none",
-            resolveStatus: "resolvable",
-        },
+    const sourceRefs = params.executionResultRef
+        ? [
+            {
+                uri: params.executionResultRef,
+                family: "connector_result",
+                id: params.executionResultRef,
+                redactionClass: "none",
+                resolveStatus: "resolvable",
+            },
+        ]
+        : [];
+    const proofRefs = [
+        closureTraceRef(closureId),
     ];
     const result = await writeActionClosureRecord(db, {
         id: closureId,
@@ -172,15 +184,16 @@ export async function recordExecutionClosure(db, cycleId, closureStatus, reason,
         reason,
         nextState: params.nextState ?? (closureStatus === "completed" ? "await_next_cycle" : "retryable"),
         sourceRefs,
+        proofRefs,
+        traceRefs: [cycleTraceRef(cycleId)],
         redactionClass: "none",
-        lifecycleStatus: "closed",
-        payloadJson: JSON.stringify({
+        payload: {
             dispatchAttempt: 1,
             executionResultRef: params.executionResultRef,
             outputSummary: params.outputSummary,
             inputSummary: buildInputSummary(params.proposalId, params.decisionId),
             retryable: params.retryable ?? closureStatus === "failed",
-        }),
+        },
     });
     if ("reason" in result) {
         return result;

package/runtime/core/second-nature/action/action-proposal-builder.js

@@ -22,22 +22,13 @@
  *
  * Test coverage: tests/unit/action/action-proposal-builder.test.ts
  */
-import { readJudgmentVerdictById, writeActionClosureRecord, } from "../../../storage/v8-state-stores.js";
+import { readJudgmentVerdictById, } from "../../../storage/v8-state-stores.js";
+import { parseSourceRefs } from "../../../shared/serialization.js";
 import { ACTION_KIND_REGISTRY } from "../../../shared/types/v8-contracts.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
-function parseVerdictSourceRefs(json) {
-    if (!json)
-        return [];
-    try {
-        const parsed = JSON.parse(json);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
 function buildExpectedOutput(actionKind) {
     switch (actionKind) {
         case "ignore":
@@ -80,7 +71,7 @@ export async function buildActionProposal(db, judgmentVerdictId, options) {
     const verdict = readResult.row;
     if (!verdict) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "policy",
             sourceRefs: [],
@@ -99,8 +90,8 @@ export async function buildActionProposal(db, judgmentVerdictId, options) {
             judgmentVerdictId,
         };
     }
-    const sourceRefs = parseVerdictSourceRefs(verdict.sourceRefsJson);
-    // remember → memory review candidate closure (no direct projection)
+    const sourceRefs = parseSourceRefs(verdict.sourceRefsJson);
+    // remember → memory review candidate (no direct projection; orchestrator writes closure)
     if (actionKind === "remember") {
         const candidate = {
             closureSubtype: "remember_for_review",
@@ -131,27 +122,10 @@ export async function buildActionProposal(db, judgmentVerdictId, options) {
                 },
             ]),
         };
-        const closureId = `cls_remember_${judgmentVerdictId}_${now.replace(/[:.]/g, "")}`;
-        const writeResult = await writeActionClosureRecord(db, {
-            id: closureId,
-            createdAt: now,
-            cycleId,
-            platformId: "heartbeat",
-            status: "completed",
-            reason: "remember_for_review",
-            nextState: "pending_daily_review",
-            sourceRefs: candidate.sourceRefs,
-            redactionClass: "none",
-            lifecycleStatus: "closed",
-            payloadJson: JSON.stringify({ memoryReviewCandidate: candidate }),
-        });
-        if ("reason" in writeResult) {
-            return writeResult;
-        }
         return {
             status: "remember_for_review",
             memoryReviewCandidate: candidate,
-            closureId,
+            closureId: `cls_remember_${judgmentVerdictId}_${now.replace(/[:.]/g, "")}`,
         };
     }
     // Actionable verdict → build proposal
@@ -201,7 +175,7 @@ export async function buildActionProposals(db, judgmentVerdictIds, options) {
         else if ("status" in result && result.status === "remember_for_review") {
             rememberForReviews.push(result);
         }
-        else if ("status" in result && result.status === "degraded") {
+        else if ("operatorNextAction" in result) {
             failed.push({
                 judgmentVerdictId,
                 degraded: result,

package/runtime/core/second-nature/action/policy-bound-dispatch.d.ts

@@ -33,6 +33,7 @@ export interface ConnectorDispatchRequest {
         decision: string;
     };
     sourceRefs: string;
+    proofRefs: string;
 }
 export interface GuidanceDispatchRequest {
     type: "guidance";
@@ -43,6 +44,7 @@ export interface GuidanceDispatchRequest {
         decision: string;
     };
     sourceRefs: string;
+    proofRefs: string;
 }
 export interface NoDispatchResult {
     type: "none";