@haaaiawd/second-nature 0.2.4 → 0.2.6

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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.2.4",
+  "version": "0.2.6",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",

package/runtime/cli/commands/index.d.ts

@@ -1,5 +1,7 @@
 import type { ActionBridge } from "../action-bridge.js";
 import type { OpsRouter } from "../ops/ops-router.js";
+import type { StateDatabase } from "../../storage/db/index.js";
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
 import type { CliReadModels } from "../read-models/index.js";
 export interface CliCommandDefinition {
     name: string;
@@ -10,5 +12,7 @@ export interface CliCommandDeps {
     readModels: CliReadModels;
     actionBridge: ActionBridge;
     opsRouter: OpsRouter;
+    stateDb?: StateDatabase;
+    observabilityDb?: ObservabilityDatabase;
 }
 export declare function createCliCommands(deps: CliCommandDeps): CliCommandDefinition[];

package/runtime/cli/commands/index.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import { credentialVerify } from "./credential.js";
 import { connectorInit } from "./connector-init.js";
 import { formatExplanation } from "../explain/format-explanation.js";
@@ -5,6 +7,139 @@ import { explainSurfaceSubject } from "../explain/explain-surface-subject.js";
 import { showOperatorFallback, OperatorFallbackNotFoundError, } from "../ops/show-operator-fallback.js";
 import { runStorageModeSmoke } from "../../storage/bootstrap/storage-mode-smoke.js";
 import { policySet } from "./policy.js";
+const SETUP_MARKER_RELATIVE_PATH = path.join(".second-nature", "setup", "agent-inner-guide-ack.json");
+function safeShortText(value, maxLen) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    return trimmed.slice(0, maxLen);
+}
+function resolveWorkspaceRoot(input) {
+    if (typeof input?.workspaceRoot === "string" && input.workspaceRoot.trim().length > 0) {
+        return path.resolve(input.workspaceRoot);
+    }
+    if (typeof process.env.SECOND_NATURE_WORKSPACE_ROOT === "string" && process.env.SECOND_NATURE_WORKSPACE_ROOT.trim().length > 0) {
+        return path.resolve(process.env.SECOND_NATURE_WORKSPACE_ROOT);
+    }
+    return process.cwd();
+}
+function readSetupText(fileName) {
+    const candidates = fileName === "SKILL.md"
+        ? [path.resolve(process.cwd(), "SKILL.md"), path.resolve(process.cwd(), "..", "SKILL.md")]
+        : [path.resolve(process.cwd(), "plugin", "agent-inner-guide.md"), path.resolve(process.cwd(), "..", "plugin", "agent-inner-guide.md")];
+    for (const candidate of candidates) {
+        try {
+            const content = fs.readFileSync(candidate, "utf-8");
+            return { ok: true, path: candidate, content };
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return { ok: false, path: candidates[0] ?? fileName, error: `Could not read ${fileName}` };
+}
+function summarizeSetupText(content) {
+    const lines = content.split("\n");
+    const nonEmpty = lines.filter((line) => line.trim().length > 0);
+    const first = nonEmpty.slice(0, 3).join("\n");
+    const marker = content.length > first.length ? "\n\n[...]" : "";
+    return `${first}${marker}`;
+}
+function readSetupAckMarker(workspaceRoot) {
+    const markerPath = path.join(workspaceRoot, SETUP_MARKER_RELATIVE_PATH);
+    try {
+        const raw = fs.readFileSync(markerPath, "utf-8");
+        const marker = JSON.parse(raw);
+        if (marker.status === "acknowledged") {
+            return {
+                status: "acknowledged",
+                markerPath,
+                acknowledgedAt: typeof marker.acknowledgedAt === "string" ? marker.acknowledgedAt : undefined,
+                placedIn: typeof marker.placedIn === "string" ? marker.placedIn : undefined,
+            };
+        }
+    }
+    catch {
+        // marker missing or unreadable
+    }
+    return { status: "pending", markerPath };
+}
+async function buildSetupHintPayload(input) {
+    const format = input?.format === "full" ? "full" : "summary";
+    const includeSkill = input?.includeSkill !== false;
+    const includeGuide = input?.includeGuide !== false;
+    const workspaceRoot = resolveWorkspaceRoot(input);
+    const ack = readSetupAckMarker(workspaceRoot);
+    const data = {
+        status: ack.status,
+        workspaceRoot,
+        markerPath: ack.markerPath,
+        acknowledgedAt: ack.acknowledgedAt,
+        placedIn: ack.placedIn,
+        recommendedPlacement: [
+            "agent prompt",
+            "workspace/IDENTITY.md",
+            "workspace/USER.md",
+        ],
+        nextStep: ack.status === "acknowledged"
+            ? "setup_already_acknowledged"
+            : "read_returned_guidance_then_run_setup_ack",
+    };
+    if (includeSkill) {
+        const skill = readSetupText("SKILL.md");
+        data.skill = skill.ok
+            ? {
+                path: skill.path,
+                content: format === "full" ? skill.content : summarizeSetupText(skill.content),
+            }
+            : skill;
+    }
+    if (includeGuide) {
+        const guide = readSetupText("agent-inner-guide.md");
+        data.guide = guide.ok
+            ? {
+                path: guide.path,
+                content: format === "full" ? guide.content : summarizeSetupText(guide.content),
+            }
+            : guide;
+    }
+    return {
+        ok: true,
+        command: "setup_hint",
+        surfaceMode: "workspace_full_runtime",
+        message: "Read the SKILL and guide as a friendly setup note, then place the guidance where the agent naturally checks its working anchors.",
+        data,
+    };
+}
+async function buildSetupAckPayload(input) {
+    const workspaceRoot = resolveWorkspaceRoot(input);
+    const markerPath = path.join(workspaceRoot, SETUP_MARKER_RELATIVE_PATH);
+    const marker = {
+        acknowledgedAt: new Date().toISOString(),
+        acceptedBy: safeShortText(input?.acceptedBy, 80) ?? "agent",
+        placedIn: safeShortText(input?.placedIn, 160) ?? "unspecified",
+        note: safeShortText(input?.note, 240),
+        guideVersion: "0.2.5",
+        source: "second-nature-cli",
+        skillPath: "SKILL.md",
+        guidePath: "plugin/agent-inner-guide.md",
+        status: "acknowledged",
+    };
+    fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+    fs.writeFileSync(markerPath, `${JSON.stringify(marker, null, 2)}\n`, "utf-8");
+    return {
+        ok: true,
+        command: "setup_ack",
+        surfaceMode: "workspace_full_runtime",
+        message: "Setup guide acknowledgement persisted; setup nudge is now silent for this workspace.",
+        data: {
+            markerPath,
+            ...marker,
+        },
+    };
+}
 const notImplemented = async (command) => ({
     ok: false,
     command,
@@ -22,16 +157,45 @@ function explainSubjectError(code, message) {
     };
 }
 export function createCliCommands(deps) {
-    const { readModels, actionBridge, opsRouter } = deps;
+    const { readModels, actionBridge, opsRouter, stateDb, observabilityDb } = deps;
+    const flush = () => {
+        try {
+            stateDb?.flush();
+        }
+        catch {
+            // ignore flush errors to avoid masking command results
+        }
+        try {
+            observabilityDb?.flush();
+        }
+        catch {
+            // ignore flush errors to avoid masking command results
+        }
+    };
     const opsCommand = (name, description) => ({
         name,
         description,
         execute: async (input) => {
             const surface = await Promise.resolve(opsRouter.dispatch(name, input));
+            flush();
             return surface;
         },
     });
     return [
+        {
+            name: "setup_hint",
+            description: "Return the packaged setup SKILL and agent inner guide for first-run onboarding",
+            execute: async (input) => buildSetupHintPayload(input),
+        },
+        {
+            name: "setup_ack",
+            description: "Persist that the packaged setup guide was read and placed into working anchors",
+            execute: async (input) => {
+                const result = await buildSetupAckPayload(input);
+                flush();
+                return result;
+            },
+        },
         {
             name: "status",
             description: "T1.2.6 — Show v6 aggregated Second Nature status (narrative + dream + cycles + runtime)",
@@ -47,7 +211,9 @@ export function createCliCommands(deps) {
             execute: async (input) => {
                 const action = typeof input?.action === "string" ? input.action : "show";
                 if (action === "set") {
-                    return policySet(actionBridge, input);
+                    const result = await policySet(actionBridge, input);
+                    flush();
+                    return result;
                 }
                 // T1.2.6 (SN-CODE-01): `policy show` (default) returns the current rhythm policy
                 // snapshot. Returns workspace defaults when no policy row has been persisted yet.
@@ -159,6 +325,7 @@ export function createCliCommands(deps) {
             description: "Workspace heartbeat_check ops surface (v5 HeartbeatSurfaceResult)",
             execute: async (input) => {
                 const surface = await Promise.resolve(opsRouter.dispatch("heartbeat_check", input));
+                flush();
                 return surface;
             },
         },
@@ -174,6 +341,7 @@ export function createCliCommands(deps) {
                     runRepairFixture,
                     workspaceRoot,
                 });
+                flush();
                 return { ok: true, data };
             },
         },
@@ -218,6 +386,7 @@ export function createCliCommands(deps) {
             description: "T1.2.8 — probe host capabilities and persist report (static unknown adapter in CLI context)",
             execute: async (input) => {
                 const surface = await Promise.resolve(opsRouter.dispatch("capability_probe", input));
+                flush();
                 return surface;
             },
         },
@@ -226,6 +395,7 @@ export function createCliCommands(deps) {
             description: "T3.3.2 — run near-real connector smoke (sentinel Moltbook + EvoMap, no live HTTP)",
             execute: async (input) => {
                 const surface = await Promise.resolve(opsRouter.dispatch("near_real_smoke", input));
+                flush();
                 return surface;
             },
         },
@@ -249,6 +419,7 @@ export function createCliCommands(deps) {
                         ? input.workspaceRoot
                         : undefined,
                 });
+                flush();
                 return result;
             },
         },
@@ -261,10 +432,11 @@ export function createCliCommands(deps) {
             },
         },
         {
-            name: "connector_status",
-            description: "T1.2.3 — show connector inventory, trust/executable/conflict summary",
+            name: "credential",
+            description: "T1.4.1 — inspect or verify credential health without exposing plaintext",
             execute: async (input) => {
-                const surface = await Promise.resolve(opsRouter.dispatch("connector_status", input));
+                const surface = await Promise.resolve(opsRouter.dispatch("credential", input));
+                flush();
                 return surface;
             },
         },
@@ -273,6 +445,7 @@ export function createCliCommands(deps) {
             description: "T1.2.3 — dry-run test a connector by platformId (default dry-run)",
             execute: async (input) => {
                 const surface = await Promise.resolve(opsRouter.dispatch("connector_test", input));
+                flush();
                 return surface;
             },
         },
@@ -292,6 +465,7 @@ export function createCliCommands(deps) {
             description: "T1.2.4 — owner-governed goal operations: set, list, accept, reject",
             execute: async (input) => {
                 const surface = await Promise.resolve(opsRouter.dispatch("goal", input));
+                flush();
                 return surface;
             },
         },

package/runtime/cli/index.js

@@ -290,6 +290,8 @@ export function createCommandRouter(options = {}) {
         readModels: runtime.readModels,
         actionBridge: runtime.actionBridge,
         opsRouter,
+        stateDb: runtime.stateDb,
+        observabilityDb: runtime.observabilityDb,
     });
     return {
         commands,

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

@@ -1067,6 +1067,8 @@ export function createOpsRouter(deps) {
                                 hasRealClosure: realRunResult.gate.hasRealClosure,
                                 hasQuietArtifact: realRunResult.gate.hasQuietArtifact,
                                 hasDreamArtifact: realRunResult.gate.hasDreamArtifact,
+                                hasFreshImpulseContext: realRunResult.gate.hasFreshImpulseContext,
+                                hasProjectionFeedback: realRunResult.gate.hasProjectionFeedback,
                                 missingStage: realRunResult.gate.missingStage,
                                 missingReason: realRunResult.gate.missingReason,
                             };
@@ -1079,6 +1081,8 @@ export function createOpsRouter(deps) {
                                 hasRealClosure: false,
                                 hasQuietArtifact: false,
                                 hasDreamArtifact: false,
+                                hasFreshImpulseContext: false,
+                                hasProjectionFeedback: false,
                                 missingReason: "Real-run health check degraded: " + realRunResult.degraded.reason,
                             };
                         }
@@ -1140,24 +1144,30 @@ export function createOpsRouter(deps) {
                     };
                     return envelope;
                 }
-                const fromVersion = typeof input?.from === "string" ? input.from : "";
-                const toVersion = typeof input?.to === "string" ? input.to : "";
+                let fromVersion = typeof input?.from === "string" ? input.from : "";
+                let toVersion = typeof input?.to === "string" ? input.to : "";
                 if (!fromVersion || !toVersion) {
-                    const envelope = {
-                        ok: false,
-                        command: "narrative:diff",
-                        runtimeMode: "workspace_full_runtime",
-                        surfaceMode: "cli",
-                        generatedAt,
-                        error: {
-                            code: "MISSING_VERSIONS",
-                            message: "narrative:diff requires 'from' and 'to' version arguments",
-                            nextStep: "reinvoke_with_from_and_to",
-                        },
-                        warnings: [],
-                        sourceRefs: [],
-                    };
-                    return envelope;
+                    // Auto-resolve the two most recent narrative timeline versions when not provided.
+                    const recent = await deps.narrativeTimelineDeps.stateMemoryPort.listNarrativeTimeline(new Date(0).toISOString(), new Date().toISOString(), { limit: 2 });
+                    if (recent.length < 2) {
+                        const envelope = {
+                            ok: false,
+                            command: "narrative:diff",
+                            runtimeMode: "workspace_full_runtime",
+                            surfaceMode: "cli",
+                            generatedAt,
+                            error: {
+                                code: "NARRATIVE_DIFF_REQUIRES_TWO_VERSIONS",
+                                message: `narrative:diff requires at least two timeline versions; found ${recent.length}. Pass explicit 'from' and 'to', or run snapshot:capture twice.`,
+                                nextStep: "run_snapshot_capture_twice_or_pass_from_and_to",
+                            },
+                            warnings: [],
+                            sourceRefs: [],
+                        };
+                        return envelope;
+                    }
+                    fromVersion = recent[1].version;
+                    toVersion = recent[0].version;
                 }
                 try {
                     const diff = await queryNarrativeDiff(fromVersion, toVersion, deps.narrativeTimelineDeps);

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

@@ -73,6 +73,7 @@ export interface CooldownLedgerPort {
     loadCooldownState(platformId: string, intent: CapabilityIntent): Promise<{
         blocked: boolean;
         retryAfterMs?: number;
+        reason?: string;
     }>;
 }
 export interface RouteContextPort extends CredentialContextPort, CooldownLedgerPort {

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

@@ -61,6 +61,23 @@ function readRetryAfterMs(input) {
     }
     return undefined;
 }
+function readStatusCode(record) {
+    if (typeof record.status === "number")
+        return record.status;
+    if (typeof record.statusCode === "number")
+        return record.statusCode;
+    if (typeof record.status === "string") {
+        const parsed = Number.parseInt(record.status, 10);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    if (typeof record.statusCode === "string") {
+        const parsed = Number.parseInt(record.statusCode, 10);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
 export function classifyFailure(error) {
     if (error instanceof ConnectorPolicyError) {
         return {
@@ -74,6 +91,34 @@ export function classifyFailure(error) {
     }
     if (error && typeof error === "object") {
         const record = error;
+        const status = readStatusCode(record);
+        if (status !== undefined) {
+            if (status === 429) {
+                return {
+                    class: "rate_limited",
+                    retryable: RETRYABLE_BY_CLASS.rate_limited,
+                    retryAfterMs: readRetryAfterMs(record),
+                };
+            }
+            if (status === 401 || status === 403) {
+                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,
+                };
+            }
+            if (status >= 500 && status <= 599) {
+                return {
+                    class: "transport_failure",
+                    retryable: RETRYABLE_BY_CLASS.transport_failure,
+                };
+            }
+        }
         const code = record.code;
         if (typeof code === "string") {
             if (code === "auth_failure")
@@ -152,32 +197,6 @@ export function classifyFailure(error) {
                     retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
                 };
         }
-        const status = record.status;
-        if (status === 429) {
-            return {
-                class: "rate_limited",
-                retryable: RETRYABLE_BY_CLASS.rate_limited,
-                retryAfterMs: readRetryAfterMs(record),
-            };
-        }
-        if (status === 401 || status === 403) {
-            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,
-            };
-        }
-        if (status === 500 || status === 502 || status === 503 || status === 504) {
-            return {
-                class: "transport_failure",
-                retryable: RETRYABLE_BY_CLASS.transport_failure,
-            };
-        }
     }
     return {
         class: "unknown_platform_change",

package/runtime/connectors/services/connector-cooldown-port.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ConnectorCooldownPort — Durable cooldown ledger for repeated terminal failures.
+ *
+ * Core logic: Track terminal failures per platform/capability and block replay
+ * for a bounded window after repeated failures. Successful recovery is allowed
+ * to bypass stale cooldown.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/connector-system.md §6`
+ * - `.anws/v8/04_SYSTEM_DESIGN/body-tool-system.md §4`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (read/write connector cooldown state)
+ * - `src/connectors/base/failure-taxonomy.js` (FailureClass, retryable lookup)
+ *
+ * Boundary:
+ * - Does not execute connectors; only records/read cooldown state.
+ * - Does not permanently blacklist platforms; cooldown expires.
+ */
+import type { StateDatabase } from "../../storage/db/index.js";
+import type { CooldownPort } from "../base/policy-layer.js";
+export declare function createConnectorCooldownPort(db: StateDatabase): CooldownPort;

package/runtime/connectors/services/connector-cooldown-port.js

@@ -0,0 +1,123 @@
+/**
+ * ConnectorCooldownPort — Durable cooldown ledger for repeated terminal failures.
+ *
+ * Core logic: Track terminal failures per platform/capability and block replay
+ * for a bounded window after repeated failures. Successful recovery is allowed
+ * to bypass stale cooldown.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/connector-system.md §6`
+ * - `.anws/v8/04_SYSTEM_DESIGN/body-tool-system.md §4`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (read/write connector cooldown state)
+ * - `src/connectors/base/failure-taxonomy.js` (FailureClass, retryable lookup)
+ *
+ * Boundary:
+ * - Does not execute connectors; only records/read cooldown state.
+ * - Does not permanently blacklist platforms; cooldown expires.
+ */
+import { readConnectorCooldownState, writeConnectorCooldownState, } from "../../storage/v8-state-stores.js";
+// ───────────────────────────────────────────────────────────────
+// Config
+// ───────────────────────────────────────────────────────────────
+const DEFAULT_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+const TERMINAL_FAILURE_THRESHOLD = 2;
+const RETRYABLE_FAILURE_CLASSES = new Set([
+    "transport_failure",
+    "rate_limited",
+    "timeout",
+    "concurrency_conflict",
+]);
+// ───────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────
+function makeCooldownId(platformId, capabilityId) {
+    return `cooldown_${platformId}_${capabilityId}`;
+}
+function addMs(iso, ms) {
+    return new Date(new Date(iso).getTime() + ms).toISOString();
+}
+function isAfter(a, b) {
+    return new Date(a).getTime() > new Date(b).getTime();
+}
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export function createConnectorCooldownPort(db) {
+    return {
+        async isBlocked(platformId, intent) {
+            const read = await readConnectorCooldownState(db, platformId, intent);
+            if (read.degraded) {
+                // Fail-closed: if we cannot read cooldown state, prevent replay to avoid hammering
+                return {
+                    blocked: true,
+                    reason: "cooldown_state_unreadable",
+                };
+            }
+            if (!read.row) {
+                return { blocked: false };
+            }
+            const now = new Date().toISOString();
+            const blocked = isAfter(read.row.blockedUntil, now);
+            return {
+                blocked,
+                retryAfterMs: blocked
+                    ? Math.max(0, new Date(read.row.blockedUntil).getTime() - new Date(now).getTime())
+                    : undefined,
+            };
+        },
+        async markFailure(platformId, intent, failureClass, retryAfterMs) {
+            const id = makeCooldownId(platformId, intent);
+            const now = new Date().toISOString();
+            const existing = await readConnectorCooldownState(db, platformId, intent);
+            const isRetryable = RETRYABLE_FAILURE_CLASSES.has(failureClass);
+            let failureCount = 1;
+            let terminalCount = isRetryable ? 0 : 1;
+            let blockedUntil = now;
+            if (!existing.degraded && existing.row) {
+                failureCount = existing.row.failureCount + 1;
+                terminalCount = (existing.row.terminalCount ?? 0) + (isRetryable ? 0 : 1);
+                // Extend blocked window if already blocked
+                if (isAfter(existing.row.blockedUntil, now)) {
+                    blockedUntil = existing.row.blockedUntil;
+                }
+            }
+            if (retryAfterMs && retryAfterMs > 0) {
+                // Rate-limit or explicit retry-after takes precedence
+                blockedUntil = addMs(now, retryAfterMs);
+            }
+            else if (!isRetryable && terminalCount >= TERMINAL_FAILURE_THRESHOLD) {
+                // Repeated terminal failures enter bounded cooldown
+                blockedUntil = addMs(now, DEFAULT_COOLDOWN_MS);
+            }
+            else if (isRetryable) {
+                // Retryable failures do not accumulate terminal cooldown
+                blockedUntil = now;
+            }
+            await writeConnectorCooldownState(db, {
+                id,
+                platformId,
+                capabilityId: intent,
+                failureClass,
+                retryAfterMs: retryAfterMs ?? null,
+                blockedUntil,
+                failureCount,
+                terminalCount,
+                sourceRefs: [
+                    {
+                        uri: `sn://cooldown/${platformId}/${intent}`,
+                        family: "audit",
+                        id,
+                        redactionClass: "none",
+                        resolveStatus: "resolvable",
+                    },
+                ],
+                payloadJson: JSON.stringify({ markedAt: now, failureCount, terminalCount, isRetryable }),
+                createdAt: existing.row?.createdAt ?? now,
+                updatedAt: now,
+                redactionClass: "none",
+            });
+        },
+    };
+}