dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/tool.js

@@ -1,320 +0,0 @@
-import { defineTool } from "@deepseek-ai/dsh-tools";
-import { MEMORY_TYPE_KEY } from "./types.js";
-import { projectKeyOf } from "./project.js";
-import { formatHarnessStateForPrompt } from "./render.js";
-import { requireGlobalApproval } from "./approval.js";
-import { CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry } from "./promotion.js";
-import { entrySourceOf } from "./source.js";
-import { formatRecallResult, recallMemories } from "./recall.js";
-import { getUsageCount, loadUsage } from "./usage.js";
-import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
-import { DEFAULT_REVIEWS_RETAIN } from "./types.js";
-const SCOPES = ["local", "project", "global"];
-/**
- * Accept the string form (`scope: "project"`) with the legacy boolean tool
- * parameter (`global: true`) as fallback. `scope` wins when both are given.
- */
-export function scopeOf(value, fallback) {
-    if (value === "global" || value === true) {
-        return "global";
-    }
-    if (value === "project") {
-        return "project";
-    }
-    return fallback;
-}
-/** The calling agent's session id; tools always run inside an agent scope. */
-function sessionIdOf(exec) {
-    return exec.agent?.id;
-}
-/**
- * Collect the target ids for an evolve_delete call: legacy single `id`
- * plus the batch `ids` array, de-duplicated in first-seen order. Throws
- * loudly when neither carries an id — a silent no-op delete would look
- * like success while deleting nothing.
- *
- * @throws when both `id` and `ids` are absent or empty.
- */
-export function collectDeleteIds(id, ids) {
-    const collected = [];
-    if (typeof id === "string" && id.length > 0)
-        collected.push(id);
-    if (Array.isArray(ids)) {
-        for (const item of ids) {
-            if (typeof item === "string" && item.length > 0 && !collected.includes(item)) {
-                collected.push(item);
-            }
-        }
-    }
-    if (collected.length === 0) {
-        throw new Error("evolve_delete requires id or a non-empty ids array");
-    }
-    return collected;
-}
-/**
- * The store id a scope reads/writes: session id for local, derived project
- * key for project, undefined for global. Throws for project when the
- * session cwd is unavailable — fail loud instead of writing local-by-mistake.
- */
-function storeIdFor(scope, exec) {
-    if (scope === "local") {
-        return sessionIdOf(exec);
-    }
-    if (scope === "project") {
-        const key = projectKeyOf(exec.agent);
-        if (!key) {
-            throw new Error("project scope needs the session cwd (unavailable for this agent) — use local or global instead");
-        }
-        return key;
-    }
-    return undefined;
-}
-/** Human-approval gate shared by global and project writes (both cross-session). */
-function needsApproval(scope) {
-    return scope === "global" || scope === "project";
-}
-/** Store label used in approval prompts. */
-function storeLabel(scope) {
-    return scope === "project" ? "本项目跨会话 store" : "跨会话全局 store";
-}
-function textResult(text) {
-    return { text };
-}
-export function registerEvolveTools(ctx, engine, opts) {
-    ctx.tools.register(defineTool({
-        name: "evolve_list",
-        description: "List the harness state (prompt notes, memories, skills, subagent specs) for one store.",
-        parameters: {
-            scope: {
-                type: "string",
-                enum: SCOPES,
-                description: "'local' (default), 'project', or 'global'.",
-            },
-        },
-        output: {
-            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
-            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
-        },
-        execute: async (args, exec) => {
-            const scope = scopeOf(args.scope, "local");
-            const state = engine.load(scope, storeIdFor(scope, exec));
-            const text = formatHarnessStateForPrompt(state);
-            // Append injection usage counts (gap B1).
-            const usage = loadUsage(engine.baseDir);
-            const usageLines = [];
-            for (const kind of Object.keys(state.entries)) {
-                for (const entry of Object.values(state.entries[kind])) {
-                    const count = getUsageCount(usage, kind, entry.id);
-                    if (count > 0) {
-                        usageLines.push(`${kind}:${entry.id} — injected ${count}×`);
-                    }
-                }
-            }
-            if (usageLines.length > 0) {
-                return textResult(`${text}\n\n# Injection Usage\n${usageLines.join("\n")}`);
-            }
-            return textResult(text);
-        },
-    }));
-    ctx.tools.register(defineTool({
-        name: "evolve_recall",
-        description: "Read-only targeted recall across the harness stores: filter by query, kind, scope, and memory type; returns full content with version, source, and staleness signals. Prefer this over evolve_list when looking for something specific.",
-        parameters: {
-            query: { type: "string", description: "Free-text relevance query. Empty → most-recently-updated first." },
-            kinds: {
-                type: "array",
-                items: { type: "string" },
-                description: "Entry kinds (default memory only).",
-            },
-            scopes: {
-                type: "array",
-                items: { type: "string" },
-                description: "Stores to search (default all three).",
-            },
-            memoryTypes: {
-                type: "array",
-                items: { type: "string" },
-                description: "Memory types: user, feedback, project, reference.",
-            },
-            limit: { type: "number", description: "Max hits (default 10, max 50)." },
-            includeArchived: { type: "boolean", description: "Include archived entries (default false)." },
-        },
-        output: {
-            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
-            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
-        },
-        execute: async (args, exec) => {
-            const result = recallMemories(engine, { sessionId: sessionIdOf(exec), projectKey: projectKeyOf(exec.agent) ?? undefined }, {
-                ...(typeof args.query === "string" ? { query: args.query } : {}),
-                ...(Array.isArray(args.kinds) ? { kinds: args.kinds } : {}),
-                ...(Array.isArray(args.scopes) ? { scopes: args.scopes } : {}),
-                ...(Array.isArray(args.memoryTypes) ? { memoryTypes: args.memoryTypes } : {}),
-                ...(typeof args.limit === "number" ? { limit: args.limit } : {}),
-                ...(typeof args.includeArchived === "boolean" ? { includeArchived: args.includeArchived } : {}),
-            });
-            return textResult(formatRecallResult(result, typeof args.query === "string" ? args.query : undefined));
-        },
-    }));
-    ctx.tools.register(defineTool({
-        name: "evolve_add",
-        description: "Create one harness entry (prompt/memory/skill/subagent). Snapshots, versioning, and audit are automatic.",
-        parameters: {
-            kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true, description: "Entry kind." },
-            title: { type: "string", required: true, description: "Stable title." },
-            content: { type: "string", required: true, description: "Entry body." },
-            path: { type: "string", description: "Optional grouping path." },
-            skill_kind: { type: "string", enum: ["executable", "guidance"], description: "Skills: executable (default, needs reference) or guidance (SKILL.md, no reference)." },
-            reference: { type: "object", additionalProperties: true, description: "Executable skills: {type:'python', import, callable}." },
-            arguments: { type: "object", additionalProperties: true, description: "Executable skills: accepted input contract." },
-            memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "Required for memory (feedback/project need Why + How to apply)." },
-            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
-            global: { type: "boolean", description: "Shorthand for scope='global' (requires human approval)." },
-        },
-        output: {
-            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
-            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
-        },
-        execute: async (args, exec) => {
-            const scope = scopeOf(args.scope ?? args.global, "local");
-            // Resolve first: a project scope without a session cwd fails
-            // here, before any human approval question is asked.
-            const storeId = storeIdFor(scope, exec);
-            if (needsApproval(scope) && opts.requireGlobalApproval) {
-                // Informed approval: surface a similarity hit against the
-                // target store BEFORE the human decides — the engine's
-                // write-time guard still has the final say.
-                const targetState = engine.load(scope, storeId);
-                const hit = mostSimilarEntry(Object.values(targetState.entries[args.kind]), args.title ?? "", args.content ?? "", CONFLICT_WARN_SCORE);
-                const conflictNote = hit ? ` ⚠️ ${buildConflictNotice(hit)}——建议改用 evolve_update` : "";
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_add ${args.kind} "${args.title}" → ${storeLabel(scope)}${conflictNote}`, opts.recordLanguage);
-            }
-            const edit = {
-                action: "create",
-                kind: args.kind,
-                title: args.title,
-                content: args.content,
-            };
-            if (args.path !== undefined)
-                edit.path = args.path;
-            if (args.skill_kind !== undefined)
-                edit.skill_kind = args.skill_kind;
-            if (args.reference !== undefined)
-                edit.reference = args.reference;
-            if (args.arguments !== undefined)
-                edit.arguments = args.arguments;
-            if (args.kind === "memory" && args.memoryType !== undefined) {
-                edit.metadata = { [MEMORY_TYPE_KEY]: args.memoryType };
-            }
-            return textResult(applyEditsText(engine, scope, storeId, [edit], exec.agent, sessionIdOf(exec)));
-        },
-    }));
-    ctx.tools.register(defineTool({
-        name: "evolve_update",
-        description: "Update one harness entry by id. Pass only the fields that change.",
-        parameters: {
-            kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true },
-            id: { type: "string", required: true, description: "Existing entry id." },
-            title: { type: "string" },
-            content: { type: "string" },
-            memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "Memory: (re)classify the recall type." },
-            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
-            global: { type: "boolean", description: "Shorthand for scope='global' (requires human approval)." },
-        },
-        output: {
-            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
-            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
-        },
-        execute: async (args, exec) => {
-            const scope = scopeOf(args.scope ?? args.global, "local");
-            const storeId = storeIdFor(scope, exec);
-            if (needsApproval(scope) && opts.requireGlobalApproval) {
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_update ${args.kind}:${args.id} → ${storeLabel(scope)}`, opts.recordLanguage);
-            }
-            const edit = { action: "update", kind: args.kind, id: args.id };
-            if (args.title !== undefined)
-                edit.title = args.title;
-            if (args.content !== undefined)
-                edit.content = args.content;
-            if (args.memoryType !== undefined)
-                edit.metadata = { [MEMORY_TYPE_KEY]: args.memoryType };
-            return textResult(applyEditsText(engine, scope, storeId, [edit], exec.agent, sessionIdOf(exec)));
-        },
-    }));
-    ctx.tools.register(defineTool({
-        name: "evolve_delete",
-        description: "Delete harness entries: `id` for one, `ids` for a batch (one refinement, one approval). Ids are addressed verbatim, scope-prefixed or not.",
-        parameters: {
-            kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true },
-            id: { type: "string", description: "One entry id (or use ids for a batch)." },
-            ids: {
-                type: "array",
-                items: { type: "string" },
-                description: "Entry ids for one batch delete.",
-            },
-            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
-            global: { type: "boolean", description: "Shorthand for scope='global' (requires human approval)." },
-        },
-        output: {
-            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
-            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
-        },
-        execute: async (args, exec) => {
-            const scope = scopeOf(args.scope ?? args.global, "local");
-            const storeId = storeIdFor(scope, exec);
-            const ids = collectDeleteIds(args.id, args.ids);
-            if (needsApproval(scope) && opts.requireGlobalApproval) {
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_delete ${args.kind}:${ids.length > 1 ? `${ids.length} entries (${ids.join(", ")})` : ids[0]} → ${storeLabel(scope)}`, opts.recordLanguage);
-            }
-            const edits = ids.map((id) => ({ action: "delete", kind: args.kind, id }));
-            return textResult(applyEditsText(engine, scope, storeId, edits, exec.agent, sessionIdOf(exec)));
-        },
-    }));
-    ctx.tools.register(defineTool({
-        name: "evolve_rollback",
-        description: "Deterministically revert a previous refinement by its id (from evolve_list history or /evolve).",
-        parameters: {
-            refinementId: { type: "string", required: true, description: "Refinement id to roll back." },
-            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
-            global: { type: "boolean", description: "Shorthand for scope='global'." },
-        },
-        output: {
-            schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
-            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
-        },
-        execute: async (args, exec) => {
-            const scope = scopeOf(args.scope ?? args.global, "local");
-            const result = engine.rollback(scope, storeIdFor(scope, exec), args.refinementId);
-            return textResult(`Rolled back ${result.rollbackOf ?? result.id}: ${result.appliedEdits.filter((e) => e.applied).length} edit(s) reverted.`);
-        },
-    }));
-}
-function applyEditsText(engine, scope, storeId, edits, agent, eventSessionId) {
-    const result = engine.apply(scope, storeId, {
-        summary: "Direct tool edit",
-        rationale: "Model-invoked single edit via evolve_* tool.",
-        expectedOutcome: "Entry is created, updated, or deleted as requested.",
-        edits,
-    }, agent
-        ? {
-            scope,
-            ...(entrySourceOf(agent, eventSessionId ?? storeId) ? { source: entrySourceOf(agent, eventSessionId ?? storeId) } : {}),
-        }
-        : { scope });
-    const applied = result.appliedEdits.filter((e) => e.applied);
-    const failed = result.appliedEdits.filter((e) => !e.applied);
-    // Gap C4: emit structured evolve_complete event for third-party consumers.
-    // The event keys on the live session (not the project store key).
-    const eventSession = eventSessionId ?? storeId;
-    if (applied.length > 0 && eventSession) {
-        emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, "manual_tool", eventSession), engine.retention?.reviews ?? DEFAULT_REVIEWS_RETAIN);
-    }
-    const lines = [`refinement ${result.id}: ${applied.length} applied, ${failed.length} failed`];
-    for (const e of applied) {
-        lines.push(`- ${e.action} ${e.kind}:${e.id} (v${(e.after?.version ?? e.before?.version) ?? "?"})`);
-    }
-    for (const e of failed) {
-        lines.push(`- failed ${e.action} ${e.kind}:${e.id ?? "(computed)"} — ${e.error ?? "unknown error"}`);
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=tool.js.map

package/lib/turn-snapshot.d.ts

@@ -1,78 +0,0 @@
-/**
- * Turn-boundary snapshots for the automatic review gate.
- *
- * The scheduler must see a bounded, mechanically filtered slice of the
- * current session, not a fresh full-history LLM request on every turn. This
- * module owns the snapshot boundary, cursor-compatible incremental rows, and
- * the cheap eligibility checks that run before any model call.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-/** Why a scheduler snapshot was captured. */
-export type TurnSnapshotReason = "compact" | "session_close" | "goal_blocked";
-/** Mechanical reasons a snapshot can be skipped without an LLM call. */
-export type SnapshotSkipReason = "no-new-events" | "internal-agent" | "direct-memory-write" | "no-user-prose";
-/** One immutable scheduler input. The cursor is a durable event boundary. */
-export interface TurnSnapshot {
-    readonly sessionId: string;
-    readonly projectKey?: string;
-    readonly turn: number;
-    readonly reason: TurnSnapshotReason;
-    readonly cursor: string;
-    readonly events: readonly unknown[];
-    readonly trajectory: string;
-    readonly userText: string;
-    readonly sourceSeqs: readonly number[];
-    readonly maxChars: number;
-    readonly minUserWords: number;
-    /** Cursor supplied by the shared scheduler before this snapshot selected events. */
-    readonly capturedAfterCursor?: string;
-    readonly eligible: boolean;
-    readonly skipReason?: SnapshotSkipReason;
-}
-/** Eligibility result kept separate so tests and future extractors share it. */
-export interface SnapshotEligibility {
-    readonly eligible: boolean;
-    readonly reason?: SnapshotSkipReason;
-    readonly userText: string;
-}
-/** ZCode's minimum user-prose threshold, counted as lexical words. */
-export declare const MEMORY_MIN_USER_WORDS = 3;
-/**
- * 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 declare function captureTurnSnapshot(ctx: Context, agent: Agent, opts: {
-    turn: number;
-    reason: TurnSnapshotReason;
-    cursor?: string;
-    maxChars: number;
-    minUserWords?: number;
-}): Promise<TurnSnapshot>;
-/**
- * Rebase one captured snapshot onto a phase-specific cursor while preserving
- * its outer boundary. The memory phase uses this after a downstream review or
- * fate failure: already-processed evidence is removed, but newly captured rows
- * remain available without moving the shared scheduler cursor backwards.
- */
-export declare function sliceTurnSnapshot(snapshot: TurnSnapshot, cursor: string): TurnSnapshot;
-/**
- * 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 declare function evaluateSnapshotEligibility(events: readonly unknown[], internalAgent?: boolean, minUserWords?: number): SnapshotEligibility;
-/** True when an assistant row records an explicit evolve memory mutation. */
-export declare function containsDirectMemoryWrite(events: readonly unknown[]): boolean;
-/** Serialize only user/assistant text, retaining the bounded tail. */
-export declare function serializeSnapshotEvents(events: readonly unknown[], maxChars: number): string;
-/** A DSH subagent header is an internal source when its origin says so. */
-export declare function isInternalAgent(agent: Agent | undefined): boolean;
-/**
- * Durable-boundary ordering shared by the scheduler and the extraction
- * phase: returns a positive number when `left` is newer than `right`,
- * negative when older, and undefined when the two shapes are incomparable.
- */
-export declare function compareReviewCursors(left: string, right: string): number | undefined;
-//# sourceMappingURL=turn-snapshot.d.ts.map

package/lib/turn-snapshot.js

@@ -1,252 +0,0 @@
-import { sessionEventsOf } from "./inject.js";
-import { projectKeyOf } from "./project.js";
-/** ZCode's minimum user-prose threshold, counted as lexical words. */
-export const MEMORY_MIN_USER_WORDS = 3;
-const WORD_SEGMENTER = new Intl.Segmenter("und", { granularity: "word" });
-function countUserWords(text) {
-    return [...WORD_SEGMENTER.segment(text)].filter((segment) => segment.isWordLike).length;
-}
-function containsEligibleUserProse(events, minUserWords) {
-    return events.some((event) => {
-        if (!isDirectUserEvent(event))
-            return false;
-        const row = event;
-        return countUserWords(contentText(row.data?.content)) >= minUserWords;
-    });
-}
-/**
- * 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 minUserWords = opts.minUserWords ?? MEMORY_MIN_USER_WORDS;
-    const eligibility = evaluateSnapshotEligibility(events, isInternalAgent(agent), minUserWords);
-    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),
-        maxChars: opts.maxChars,
-        minUserWords,
-        ...(opts.cursor === undefined ? {} : { capturedAfterCursor: opts.cursor }),
-        eligible: eligibility.eligible,
-        ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
-    };
-}
-/**
- * Rebase one captured snapshot onto a phase-specific cursor while preserving
- * its outer boundary. The memory phase uses this after a downstream review or
- * fate failure: already-processed evidence is removed, but newly captured rows
- * remain available without moving the shared scheduler cursor backwards.
- */
-export function sliceTurnSnapshot(snapshot, cursor) {
-    const events = sliceSnapshotEvents(snapshot, cursor);
-    const eligibility = evaluateSnapshotEligibility(events, false, snapshot.minUserWords);
-    return {
-        ...snapshot,
-        events,
-        trajectory: eligibility.eligible ? serializeSnapshotEvents(events, snapshot.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, minUserWords = MEMORY_MIN_USER_WORDS) {
-    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 (!containsEligibleUserProse(events, minUserWords))
-        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 sliceSnapshotEvents(snapshot, cursor) {
-    if (snapshot.cursor.startsWith("index:") && cursor.startsWith("index:") && snapshot.capturedAfterCursor?.startsWith("index:")) {
-        const start = Number(snapshot.capturedAfterCursor.slice("index:".length));
-        const phaseBoundary = Number(cursor.slice("index:".length));
-        if (!Number.isInteger(start) || !Number.isInteger(phaseBoundary))
-            return snapshot.events;
-        const relative = phaseBoundary - start;
-        if (relative <= 0)
-            return snapshot.events;
-        return relative >= snapshot.events.length ? [] : snapshot.events.slice(relative);
-    }
-    return eventsAfterCursor(snapshot.events, cursor);
-}
-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;
-}
-/**
- * Durable-boundary ordering shared by the scheduler and the extraction
- * phase: returns a positive number when `left` is newer than `right`,
- * negative when older, and undefined when the two shapes are incomparable.
- */
-export function compareReviewCursors(left, right) {
-    if (left === right)
-        return 0;
-    const leftMatch = /^(seq|index):(\d+)$/.exec(left);
-    const rightMatch = /^(seq|index):(\d+)$/.exec(right);
-    if (!leftMatch || !rightMatch || leftMatch[1] !== rightMatch[1])
-        return undefined;
-    return Number(leftMatch[2]) - Number(rightMatch[2]);
-}
-//# sourceMappingURL=turn-snapshot.js.map