@agenr/openclaw-plugin 1.5.0 → 2026.6.2

package/dist/lifecycle-checkpoint-IAC5FCQU.js

@@ -0,0 +1,154 @@
+import {
+  normalizeOptionalString
+} from "./chunk-OJSIZDZD.js";
+
+// src/app/working-memory/lifecycle-checkpoint.ts
+async function attachWorkingCheckpointRefresh(event, result, workingMemory) {
+  const refreshRequest = resolveWorkingCheckpointRefreshRequest(event, result);
+  if (!refreshRequest) {
+    return result;
+  }
+  const workingCheckpointRefresh = workingMemory ? await mergeWorkingCheckpoint(refreshRequest, workingMemory) : skippedRefreshWithoutWorkingMemory(refreshRequest.attachLabel);
+  return {
+    ...result,
+    workingCheckpointRefresh
+  };
+}
+async function mergeWorkingCheckpoint(request, workingMemory) {
+  const scope = resolveWorkingRefreshScope(request.event);
+  if (!scope) {
+    return {
+      ok: false,
+      reason: "missing_scope",
+      message: `${request.lifecycleLabel} requires working-scope facts.`
+    };
+  }
+  const result = await workingMemory.run({
+    action: "update",
+    scope,
+    operation: {
+      type: "merge_checkpoint",
+      checkpoint: {
+        summary: request.summary,
+        recordedAt: request.event.observedAt
+      }
+    },
+    updateReason: request.updateReason,
+    actor: "runtime",
+    source: "lifecycle_hook"
+  });
+  if (!result.ok) {
+    return mapWorkingMemoryRefreshFailure(result.code, result.message, request.lifecycleLabel);
+  }
+  if (result.action !== "update") {
+    return {
+      ok: false,
+      reason: "working_memory_unavailable",
+      message: `Expected working-memory update result, received ${result.action}.`
+    };
+  }
+  return {
+    ok: true,
+    action: "working_checkpoint_refreshed",
+    workingSetId: result.workingSet.id,
+    revision: result.workingSet.revision
+  };
+}
+function resolveWorkingCheckpointRefreshRequest(event, result) {
+  const compactionEvent = resolveCompactionCheckpointRefreshEvent(event, result);
+  if (compactionEvent) {
+    const summary = normalizeOptionalString(compactionEvent.artifact.summary);
+    if (!summary) {
+      return void 0;
+    }
+    const sourceId = normalizeOptionalString(compactionEvent.artifact.sourceId) ?? "unknown";
+    return {
+      event: compactionEvent,
+      summary,
+      updateReason: `Refreshed working checkpoint from session compaction ${sourceId}.`,
+      lifecycleLabel: "compaction checkpoint refresh",
+      attachLabel: "Compaction checkpoint refresh"
+    };
+  }
+  const shutdownEvent = resolveShutdownCheckpointRefreshEvent(event, result);
+  if (!shutdownEvent) {
+    return void 0;
+  }
+  const reason = normalizeShutdownReason(shutdownEvent.shutdownReason);
+  return {
+    event: shutdownEvent,
+    summary: `Session shutdown (${reason}) recorded. Resume from the latest working-set snapshot; no implicit close was performed.`,
+    updateReason: `Recorded working checkpoint from session shutdown (${reason}).`,
+    lifecycleLabel: "shutdown checkpoint refresh",
+    attachLabel: "Shutdown checkpoint refresh"
+  };
+}
+function resolveCompactionCheckpointRefreshEvent(event, result) {
+  if (event.type !== "session_compact" || result.artifact?.kind !== "compaction_checkpoint") {
+    return void 0;
+  }
+  const artifact = event.artifact;
+  if (!isCompactionCheckpointArtifact(artifact)) {
+    return void 0;
+  }
+  return {
+    ...event,
+    type: "session_compact",
+    artifact
+  };
+}
+function resolveShutdownCheckpointRefreshEvent(event, result) {
+  if (event.type !== "session_shutdown" || result.accepted !== true) {
+    return void 0;
+  }
+  return {
+    ...event,
+    type: "session_shutdown"
+  };
+}
+function isCompactionCheckpointArtifact(artifact) {
+  return artifact?.kind === "compaction_checkpoint";
+}
+function resolveWorkingRefreshScope(event) {
+  if (event.workingScope && Object.keys(event.workingScope).length > 0) {
+    return event.workingScope;
+  }
+  return void 0;
+}
+function mapWorkingMemoryRefreshFailure(code, message, lifecycleLabel) {
+  if (code === "feature_disabled") {
+    return {
+      ok: false,
+      reason: "not_applicable",
+      message: `Working memory is disabled; ${lifecycleLabel} was skipped.`
+    };
+  }
+  if (code === "missing_active_set") {
+    return {
+      ok: false,
+      reason: "no_active_working_set",
+      code,
+      message
+    };
+  }
+  return {
+    ok: false,
+    reason: "working_memory_unavailable",
+    code,
+    message
+  };
+}
+function normalizeShutdownReason(shutdownReason) {
+  const trimmed = shutdownReason?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : "unknown";
+}
+function skippedRefreshWithoutWorkingMemory(label) {
+  return {
+    ok: false,
+    reason: "not_applicable",
+    message: `${label} requires a working-memory service, but none was wired into the runtime.`
+  };
+}
+export {
+  attachWorkingCheckpointRefresh
+};

package/dist/scan-6JKPOQHD.js

@@ -0,0 +1,6 @@
+import {
+  runDreamScan
+} from "./chunk-GKZQ5AG5.js";
+export {
+  runDreamScan
+};

package/dist/service-EKFACEN6.js

@@ -0,0 +1,15 @@
+import {
+  backupDatabaseFile,
+  runDream,
+  runDreamWithHeldLock
+} from "./chunk-5AYIXQRF.js";
+import "./chunk-GF3PX3VM.js";
+import "./chunk-SOQW7356.js";
+import "./chunk-VTHBPXDQ.js";
+import "./chunk-VBPYU7GO.js";
+import "./chunk-GKZQ5AG5.js";
+export {
+  backupDatabaseFile,
+  runDream,
+  runDreamWithHeldLock
+};