dsh-continual-evolve 0.7.1 → 0.7.2

package/lib/turn-snapshot.js

@@ -0,0 +1,188 @@
+import { sessionEventsOf } from "./inject.js";
+import { projectKeyOf } from "./project.js";
+/**
+ * Capture the current durable surface and select only rows after `cursor`.
+ * A seq-bearing session uses `seq:<n>`; older/test surfaces fall back to an
+ * event-count cursor so the scheduler still has a deterministic boundary.
+ */
+export async function captureTurnSnapshot(ctx, agent, opts) {
+    const allEvents = await readSurface(ctx, agent);
+    const cursor = boundaryCursor(allEvents);
+    const events = eventsAfterCursor(allEvents, opts.cursor);
+    const eligibility = evaluateSnapshotEligibility(events, isInternalAgent(agent));
+    const projectKey = projectKeyOf(agent);
+    return {
+        sessionId: agent.id,
+        ...(projectKey ? { projectKey } : {}),
+        turn: opts.turn,
+        reason: opts.reason,
+        cursor,
+        events,
+        trajectory: eligibility.eligible ? serializeSnapshotEvents(events, opts.maxChars) : "",
+        userText: eligibility.userText,
+        sourceSeqs: directUserSeqs(events),
+        eligible: eligibility.eligible,
+        ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
+    };
+}
+/**
+ * Decide whether the incremental rows deserve a model call. This intentionally
+ * does not decide whether a fact is valuable; that remains the review model's
+ * job. It only removes mechanical noise before the scheduler spends tokens.
+ */
+export function evaluateSnapshotEligibility(events, internalAgent = false) {
+    if (internalAgent)
+        return { eligible: false, reason: "internal-agent", userText: "" };
+    if (events.length === 0)
+        return { eligible: false, reason: "no-new-events", userText: "" };
+    if (containsDirectMemoryWrite(events))
+        return { eligible: false, reason: "direct-memory-write", userText: "" };
+    const userText = directUserText(events);
+    if (userText.length < 3)
+        return { eligible: false, reason: "no-user-prose", userText };
+    return { eligible: true, userText };
+}
+/** True when an assistant row records an explicit evolve memory mutation. */
+export function containsDirectMemoryWrite(events) {
+    for (const event of events) {
+        if (!event || typeof event !== "object")
+            continue;
+        const row = event;
+        if (row.type === "tool/call" || row.type === "tool-call") {
+            if (isMemoryMutationName(readNestedString(row.data, ["name", "tool", "toolName"])))
+                return true;
+        }
+        if (row.type === "assistant/message" && containsMemoryMutationName(row.data))
+            return true;
+    }
+    return false;
+}
+/** Serialize only user/assistant text, retaining the bounded tail. */
+export function serializeSnapshotEvents(events, maxChars) {
+    const lines = [];
+    for (const raw of events) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const event = raw;
+        if (event.type === "user/message" && !isDirectUserEvent(raw))
+            continue;
+        const role = event.type === "user/message" ? "user" : event.type === "assistant/message" ? "assistant" : null;
+        if (role === null)
+            continue;
+        const text = contentText(event.data?.content).trim();
+        if (text.length > 0)
+            lines.push(`${role}: ${text}`);
+    }
+    const joined = lines.join("\n");
+    return joined.length <= maxChars ? joined : joined.slice(-maxChars);
+}
+/** A DSH subagent header is an internal source when its origin says so. */
+export function isInternalAgent(agent) {
+    const header = agent?.session?.header;
+    return header?.origin === "subagent" || header?.origin === "internal" || header?.isSubagent === true;
+}
+async function readSurface(ctx, agent) {
+    const reader = ctx.sessionQuery;
+    if (reader) {
+        const snapshot = await reader.readSurface(agent.id);
+        return Array.isArray(snapshot.events) ? snapshot.events : [];
+    }
+    return sessionEventsOf(agent);
+}
+function boundaryCursor(events) {
+    const seqs = events.map(eventSeq).filter((seq) => seq !== undefined);
+    return seqs.length > 0 ? `seq:${Math.max(...seqs)}` : `index:${events.length}`;
+}
+function eventsAfterCursor(events, cursor) {
+    if (cursor === undefined)
+        return events;
+    if (cursor.startsWith("seq:")) {
+        const boundary = Number(cursor.slice(4));
+        if (!Number.isFinite(boundary))
+            return events;
+        return events.filter((event) => {
+            const seq = eventSeq(event);
+            return seq === undefined || seq > boundary;
+        });
+    }
+    if (cursor.startsWith("index:")) {
+        const boundary = Number(cursor.slice(6));
+        return Number.isInteger(boundary) && boundary >= 0 ? events.slice(boundary) : events;
+    }
+    return events;
+}
+function directUserText(events) {
+    return events
+        .filter(isDirectUserEvent)
+        .map((event) => contentText(event.data?.content).trim())
+        .filter(Boolean)
+        .join("\n");
+}
+function directUserSeqs(events) {
+    return events
+        .filter(isDirectUserEvent)
+        .map(eventSeq)
+        .filter((seq) => seq !== undefined);
+}
+function isDirectUserEvent(event) {
+    if (!event || typeof event !== "object")
+        return false;
+    const row = event;
+    if (row.type !== "user/message")
+        return false;
+    if (row.data?.visibility === "model-only")
+        return false;
+    if (row.data?.source?.synthetic === true)
+        return false;
+    if (row.data?.source?.kind !== undefined && row.data.source.kind !== "user")
+        return false;
+    return contentText(row.data?.content).trim().length > 0;
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => {
+        if (typeof block === "string")
+            return block;
+        if (!block || typeof block !== "object")
+            return "";
+        const value = block;
+        if (value.synthetic === true || value.ignored === true || (value.type !== undefined && value.type !== "text"))
+            return "";
+        return typeof value.text === "string" ? value.text : "";
+    })
+        .filter(Boolean)
+        .join(" ");
+}
+function eventSeq(event) {
+    if (!event || typeof event !== "object")
+        return undefined;
+    const seq = event.seq;
+    return typeof seq === "number" && Number.isInteger(seq) ? seq : undefined;
+}
+function containsMemoryMutationName(value) {
+    if (typeof value === "string")
+        return isMemoryMutationName(value);
+    if (Array.isArray(value))
+        return value.some(containsMemoryMutationName);
+    if (!value || typeof value !== "object")
+        return false;
+    return Object.values(value).some(containsMemoryMutationName);
+}
+function isMemoryMutationName(value) {
+    return value === "evolve_add" || value === "evolve_update" || value === "evolve_delete";
+}
+function readNestedString(value, keys) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const row = value;
+    for (const key of keys) {
+        if (typeof row[key] === "string")
+            return row[key];
+    }
+    return undefined;
+}
+//# sourceMappingURL=turn-snapshot.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Continual self-evolution plugin for DeepSeek Harness: versioned, auditable, rollback-safe harness state (prompt notes, memories, skills, subagent specs) refined from session trajectories.",
   "license": "MIT",
   "repository": {