@cjhyy/code-shell-pet 0.8.0

package/dist/long-task.js

@@ -0,0 +1,795 @@
+/**
+ * Durable Pet long-task domain model.
+ *
+ * The package owns the state machine and the bounded context contract. Hosts
+ * own persistence, worker control, and UI transport. Keeping those effects out
+ * of this module lets Desktop and a future headless host share identical task
+ * semantics without teaching core about Pet.
+ */
+export const PET_LONG_TASK_SCHEMA_VERSION = 1;
+export const MAX_PET_LONG_TASK_EVENTS = 120;
+export const MAX_PET_LONG_TASK_SUMMARY_LENGTH = 8_000;
+const TERMINAL = new Set(["completed", "failed", "cancelled"]);
+function bounded(value, maximum) {
+    const normalized = value?.replace(/\s+/gu, " ").trim();
+    if (!normalized)
+        return undefined;
+    return normalized.length > maximum ? `${normalized.slice(0, maximum - 1)}…` : normalized;
+}
+function normalizeReplyAttachmentPaths(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 4)
+        return undefined;
+    const paths = [];
+    for (const entry of value) {
+        if (typeof entry !== "string")
+            return undefined;
+        const path = entry.trim();
+        if (!path || path.length > 4_096 || /[\u0000-\u001f\u007f]/u.test(path))
+            return undefined;
+        paths.push(path);
+    }
+    return new Set(paths).size === paths.length ? paths : undefined;
+}
+function normalizeReplyButton(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (Object.keys(record).some((key) => key !== "text" && key !== "url") ||
+        typeof record.text !== "string" ||
+        !record.text.trim() ||
+        record.text.length > 80 ||
+        /[\u0000-\u001f\u007f]/u.test(record.text) ||
+        typeof record.url !== "string" ||
+        record.url.length > 2_048 ||
+        record.url !== record.url.trim()) {
+        return undefined;
+    }
+    try {
+        const url = new URL(record.url);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return { text: record.text.trim(), url: record.url };
+}
+function normalizeCompletionTarget(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const channel = typeof record.channel === "string" ? record.channel.trim().toLowerCase() : "";
+    const target = typeof record.target === "string" ? record.target.trim() : "";
+    if (record.kind !== "im-gateway" ||
+        !/^[a-z0-9_-]{1,32}$/u.test(channel) ||
+        !target ||
+        target.length > 4_096 ||
+        /[\u0000-\u001f\u007f]/u.test(target)) {
+        return undefined;
+    }
+    const replyAttachmentKinds = Array.isArray(record.replyAttachmentKinds) &&
+        record.replyAttachmentKinds.length <= 4 &&
+        record.replyAttachmentKinds.every((kind) => ["image", "file", "audio", "video"].includes(String(kind)))
+        ? [...new Set(record.replyAttachmentKinds)]
+        : [];
+    const replyButton = record.replyButton === "native" || record.replyButton === "link"
+        ? record.replyButton
+        : undefined;
+    return {
+        kind: "im-gateway",
+        channel,
+        target,
+        ...(replyButton ? { replyButton } : {}),
+        ...(replyAttachmentKinds.length > 0 ? { replyAttachmentKinds } : {}),
+    };
+}
+function normalizeArtifacts(value) {
+    if (!value)
+        return [];
+    const seen = new Set();
+    const artifacts = [];
+    for (const artifact of value) {
+        if (!artifact || !["session", "result", "file", "url"].includes(artifact.kind))
+            continue;
+        const label = bounded(artifact.label, 160);
+        const reference = bounded(artifact.reference, 2_048);
+        if (!label || !reference)
+            continue;
+        const key = `${artifact.kind}\u0000${reference}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        artifacts.push({ kind: artifact.kind, label, reference });
+        if (artifacts.length >= 24)
+            break;
+    }
+    return artifacts;
+}
+function mergeArtifacts(current, incoming) {
+    return normalizeArtifacts([...current, ...(incoming ?? [])]);
+}
+function appendEvent(task, input) {
+    const sequence = (task.events.at(-1)?.sequence ?? 0) + 1;
+    const event = {
+        ...input,
+        id: `${task.id}:${sequence}`,
+        sequence,
+        message: bounded(input.message, 2_000),
+        waitingFor: bounded(input.waitingFor, 500),
+        nextAction: bounded(input.nextAction, 500),
+        artifacts: input.artifacts ? normalizeArtifacts(input.artifacts) : undefined,
+    };
+    return [...task.events, event].slice(-MAX_PET_LONG_TASK_EVENTS);
+}
+export function createPetLongTask(input) {
+    const id = bounded(input.id, 128);
+    const originClientMessageId = bounded(input.originClientMessageId, 256);
+    const objective = bounded(input.objective, 8_000);
+    const sessionId = bounded(input.sessionId, 256);
+    if (!id || !originClientMessageId || !objective || !sessionId) {
+        throw new Error("invalid Pet long-task identity or objective");
+    }
+    const workspacePath = input.workspacePath ? bounded(input.workspacePath, 4_096) : null;
+    const completionTarget = normalizeCompletionTarget(input.completionTarget);
+    const continuationDepth = typeof input.continuationDepth === "number" &&
+        Number.isSafeInteger(input.continuationDepth) &&
+        input.continuationDepth > 0
+        ? input.continuationDepth
+        : 0;
+    const created = {
+        id: `${id}:1`,
+        sequence: 1,
+        kind: "created",
+        at: input.at,
+        message: "Long-running work accepted and queued",
+        phase: "planning",
+        nextAction: "Start the work session",
+    };
+    return {
+        schemaVersion: PET_LONG_TASK_SCHEMA_VERSION,
+        id,
+        originClientMessageId,
+        objective,
+        workspacePath: workspacePath ?? null,
+        sessionId,
+        ...(input.executionBackend === "codex" ? { executionBackend: "codex" } : {}),
+        verificationMode: input.verificationMode === "goal" ? "goal" : "turn",
+        ...(completionTarget ? { completionTarget } : {}),
+        ...(continuationDepth > 0 ? { continuationDepth } : {}),
+        status: "queued",
+        phase: "planning",
+        attempt: 1,
+        revision: 1,
+        createdAt: input.at,
+        updatedAt: input.at,
+        nextAction: "Start the work session",
+        artifacts: [{ kind: "session", label: "Work session", reference: sessionId }],
+        events: [created],
+    };
+}
+/**
+ * Apply one durable transition. Terminal tasks only accept retry/cancel or a
+ * closure-delivery acknowledgement; late
+ * worker events are ignored so a stale completion cannot undo an explicit user
+ * action such as pause or cancel.
+ */
+export function transitionPetLongTask(current, transition) {
+    if (transition.kind === "closure-decided" && current.closureDecision?.key === transition.key) {
+        return current;
+    }
+    if (transition.kind === "continuation-started" &&
+        current.closureDecision?.key === transition.key &&
+        current.closureDecision.launch) {
+        return current;
+    }
+    // Stream and projection observations are handled on separate async paths.
+    // An older projection can therefore arrive after a newer assistant checkpoint;
+    // never let that stale progress erase the final result we will notify with.
+    if (transition.at < current.updatedAt &&
+        (transition.kind === "started" ||
+            transition.kind === "progress" ||
+            transition.kind === "waiting" ||
+            transition.kind === "resumed" ||
+            transition.kind === "checkpoint" ||
+            transition.kind === "interrupted" ||
+            transition.kind === "completed" ||
+            transition.kind === "failed" ||
+            transition.kind === "cancelled")) {
+        return current;
+    }
+    if (TERMINAL.has(current.status) &&
+        transition.kind !== "retrying" &&
+        transition.kind !== "cancelled" &&
+        transition.kind !== "closure-decided" &&
+        transition.kind !== "continuation-started" &&
+        transition.kind !== "closure-recorded") {
+        return current;
+    }
+    if (current.status === "cancelled" &&
+        transition.kind !== "retrying" &&
+        transition.kind !== "closure-decided" &&
+        transition.kind !== "continuation-started" &&
+        transition.kind !== "closure-recorded") {
+        return current;
+    }
+    const next = {
+        ...current,
+        revision: current.revision + 1,
+        updatedAt: Math.max(current.updatedAt, transition.at),
+        events: current.events,
+    };
+    let event;
+    switch (transition.kind) {
+        case "started":
+            Object.assign(next, {
+                status: "running",
+                phase: "executing",
+                startedAt: current.startedAt ?? transition.at,
+                waitingFor: undefined,
+                nextAction: "Continue until the objective is verified complete",
+                lastError: undefined,
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "executing",
+                message: transition.message ?? "Work session started",
+                nextAction: next.nextAction,
+            };
+            break;
+        case "progress":
+            Object.assign(next, {
+                status: "running",
+                phase: transition.phase,
+                summary: bounded(transition.summary, MAX_PET_LONG_TASK_SUMMARY_LENGTH),
+                waitingFor: undefined,
+                nextAction: "Continue until the objective is verified complete",
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: transition.phase,
+                message: next.summary,
+                nextAction: next.nextAction,
+            };
+            break;
+        case "waiting":
+            Object.assign(next, {
+                status: "waiting",
+                phase: "waiting-user",
+                waitingFor: bounded(transition.waitingFor, 500),
+                nextAction: "Open the work session and resolve the pending decision",
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "waiting-user",
+                message: transition.message,
+                waitingFor: next.waitingFor,
+                nextAction: next.nextAction,
+            };
+            break;
+        case "paused":
+            Object.assign(next, {
+                status: "paused",
+                phase: "waiting-worker",
+                waitingFor: bounded(transition.reason, 500) ?? "Paused by user",
+                nextAction: "Resume when ready",
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "waiting-worker",
+                message: next.waitingFor,
+                nextAction: next.nextAction,
+            };
+            break;
+        case "resumed":
+            Object.assign(next, {
+                status: "running",
+                phase: "executing",
+                waitingFor: undefined,
+                nextAction: "Continue from the latest durable checkpoint",
+                lastError: undefined,
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "executing",
+                message: transition.message ?? "Long-running work resumed",
+                nextAction: next.nextAction,
+            };
+            break;
+        case "retrying":
+            Object.assign(next, {
+                status: "queued",
+                phase: "planning",
+                attempt: current.attempt + 1,
+                // A retry is a new attempt in the same durable Session. Keeping the
+                // previous attempt's start time would let an old projection terminal
+                // pass the new attempt's time fence.
+                startedAt: undefined,
+                completedAt: undefined,
+                closureRecordedAt: undefined,
+                closureDecision: undefined,
+                waitingFor: undefined,
+                nextAction: "Retry from the existing work session and checkpoint",
+                lastError: undefined,
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "planning",
+                message: transition.reason ?? `Retry attempt ${next.attempt}`,
+                nextAction: next.nextAction,
+            };
+            break;
+        case "artifact":
+            Object.assign(next, {
+                artifacts: mergeArtifacts(current.artifacts, transition.artifacts),
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: next.phase,
+                message: "Work session produced an artifact",
+                artifacts: transition.artifacts,
+            };
+            break;
+        case "checkpoint":
+            Object.assign(next, {
+                summary: bounded(transition.summary, MAX_PET_LONG_TASK_SUMMARY_LENGTH),
+                resultSummary: bounded(transition.summary, MAX_PET_LONG_TASK_SUMMARY_LENGTH),
+                nextAction: bounded(transition.nextAction, 500) ?? current.nextAction,
+                artifacts: mergeArtifacts(current.artifacts, transition.artifacts),
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: next.phase,
+                message: next.summary,
+                nextAction: next.nextAction,
+                artifacts: transition.artifacts,
+            };
+            break;
+        case "verification-changed":
+            Object.assign(next, { verificationMode: transition.mode });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: next.phase,
+                message: transition.mode === "goal"
+                    ? "Completion now requires a verified Goal verdict"
+                    : "Completion now follows the ordinary Work Session result",
+            };
+            break;
+        case "interrupted":
+            Object.assign(next, {
+                status: "interrupted",
+                phase: "waiting-worker",
+                waitingFor: bounded(transition.reason, 500),
+                nextAction: "Resume from the durable work session",
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "waiting-worker",
+                message: next.waitingFor,
+                nextAction: next.nextAction,
+            };
+            break;
+        case "completed": {
+            const resultSummary = bounded(transition.summary, MAX_PET_LONG_TASK_SUMMARY_LENGTH) ?? current.resultSummary;
+            Object.assign(next, {
+                status: "completed",
+                phase: "finalizing",
+                completedAt: transition.at,
+                ...(resultSummary ? { resultSummary } : {}),
+                summary: resultSummary ?? current.summary ?? "Objective completed",
+                waitingFor: undefined,
+                nextAction: undefined,
+                lastError: undefined,
+                artifacts: mergeArtifacts(current.artifacts, transition.artifacts),
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "finalizing",
+                message: next.summary,
+                artifacts: transition.artifacts,
+            };
+            break;
+        }
+        case "failed":
+            Object.assign(next, {
+                status: "failed",
+                phase: "finalizing",
+                completedAt: transition.at,
+                summary: bounded(transition.summary, MAX_PET_LONG_TASK_SUMMARY_LENGTH) ?? current.summary,
+                waitingFor: undefined,
+                nextAction: "Inspect the failure, then retry or cancel",
+                lastError: bounded(transition.error, 2_000),
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "finalizing",
+                message: next.lastError,
+                nextAction: next.nextAction,
+            };
+            break;
+        case "cancelled":
+            Object.assign(next, {
+                status: "cancelled",
+                phase: "finalizing",
+                completedAt: transition.at,
+                waitingFor: undefined,
+                nextAction: undefined,
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: "finalizing",
+                message: transition.reason ?? "Cancelled by user",
+            };
+            break;
+        case "closure-decided": {
+            const key = bounded(transition.key, 512);
+            const text = transition.text.trim().slice(0, MAX_PET_LONG_TASK_SUMMARY_LENGTH);
+            if (!key || !text)
+                return current;
+            const replyAttachmentPaths = normalizeReplyAttachmentPaths(transition.replyAttachmentPaths);
+            if (transition.replyAttachmentPaths !== undefined && !replyAttachmentPaths)
+                return current;
+            const replyButton = normalizeReplyButton(transition.replyButton);
+            if (transition.replyButton !== undefined && !replyButton)
+                return current;
+            const continuation = transition.continuation;
+            const normalizedContinuation = continuation
+                ? {
+                    clientMessageId: continuation.clientMessageId.slice(0, 256),
+                    objective: continuation.objective.trim().slice(0, 8_000),
+                    workspacePath: typeof continuation.workspacePath === "string"
+                        ? continuation.workspacePath.slice(0, 4_096)
+                        : null,
+                    ...(continuation.executionBackend === "codex"
+                        ? { executionBackend: "codex" }
+                        : {}),
+                }
+                : undefined;
+            if (normalizedContinuation &&
+                (!normalizedContinuation.clientMessageId || !normalizedContinuation.objective)) {
+                return current;
+            }
+            Object.assign(next, {
+                closureDecision: {
+                    key,
+                    text,
+                    decidedAt: transition.at,
+                    ...(replyAttachmentPaths ? { replyAttachmentPaths } : {}),
+                    ...(replyButton ? { replyButton } : {}),
+                    ...(normalizedContinuation ? { continuation: normalizedContinuation } : {}),
+                },
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: current.phase,
+                message: normalizedContinuation
+                    ? "Mimi recorded a durable continuation decision"
+                    : "Mimi recorded a durable closure reply",
+            };
+            break;
+        }
+        case "continuation-started": {
+            if (current.closureDecision?.key !== transition.key ||
+                !current.closureDecision.continuation) {
+                return current;
+            }
+            const sessionId = transition.sessionId.trim().slice(0, 256);
+            if (!sessionId)
+                return current;
+            Object.assign(next, {
+                closureDecision: {
+                    ...current.closureDecision,
+                    launch: {
+                        sessionId,
+                        ...(transition.taskId ? { taskId: transition.taskId.slice(0, 128) } : {}),
+                        at: transition.at,
+                    },
+                },
+            });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: current.phase,
+                message: "The durable continuation task was started",
+            };
+            break;
+        }
+        case "closure-recorded":
+            Object.assign(next, { closureRecordedAt: transition.at });
+            event = {
+                kind: transition.kind,
+                at: transition.at,
+                phase: current.phase,
+                message: "Terminal outcome recorded in Pet work memory",
+            };
+            break;
+    }
+    next.events = appendEvent(current, event);
+    return next;
+}
+function isStatus(value) {
+    return (typeof value === "string" &&
+        [
+            "queued",
+            "running",
+            "waiting",
+            "paused",
+            "interrupted",
+            "completed",
+            "failed",
+            "cancelled",
+        ].includes(value));
+}
+function isPhase(value) {
+    return (typeof value === "string" &&
+        ["planning", "executing", "waiting-user", "waiting-worker", "finalizing"].includes(value));
+}
+function isEventKind(value) {
+    return (typeof value === "string" &&
+        [
+            "created",
+            "started",
+            "progress",
+            "waiting",
+            "paused",
+            "resumed",
+            "retrying",
+            "artifact",
+            "checkpoint",
+            "verification-changed",
+            "interrupted",
+            "completed",
+            "failed",
+            "cancelled",
+            "closure-decided",
+            "continuation-started",
+            "closure-recorded",
+        ].includes(value));
+}
+function parseEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const event = value;
+    if (typeof event.id !== "string" ||
+        !event.id ||
+        typeof event.sequence !== "number" ||
+        !Number.isSafeInteger(event.sequence) ||
+        event.sequence < 1 ||
+        !isEventKind(event.kind) ||
+        typeof event.at !== "number" ||
+        !Number.isFinite(event.at) ||
+        (event.phase !== undefined && !isPhase(event.phase))) {
+        return null;
+    }
+    return {
+        id: event.id.slice(0, 256),
+        sequence: event.sequence,
+        kind: event.kind,
+        at: event.at,
+        ...(typeof event.message === "string" ? { message: bounded(event.message, 2_000) } : {}),
+        ...(isPhase(event.phase) ? { phase: event.phase } : {}),
+        ...(typeof event.waitingFor === "string" ? { waitingFor: bounded(event.waitingFor, 500) } : {}),
+        ...(typeof event.nextAction === "string" ? { nextAction: bounded(event.nextAction, 500) } : {}),
+        ...(Array.isArray(event.artifacts)
+            ? { artifacts: normalizeArtifacts(event.artifacts) }
+            : {}),
+    };
+}
+function parseClosureDecision(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (typeof record.key !== "string" ||
+        !record.key.trim() ||
+        typeof record.text !== "string" ||
+        !record.text.trim() ||
+        typeof record.decidedAt !== "number" ||
+        !Number.isFinite(record.decidedAt)) {
+        return undefined;
+    }
+    const replyAttachmentPaths = normalizeReplyAttachmentPaths(record.replyAttachmentPaths);
+    if (record.replyAttachmentPaths !== undefined && !replyAttachmentPaths)
+        return undefined;
+    const replyButton = normalizeReplyButton(record.replyButton);
+    if (record.replyButton !== undefined && !replyButton)
+        return undefined;
+    let continuation;
+    if (record.continuation !== undefined) {
+        if (!record.continuation ||
+            typeof record.continuation !== "object" ||
+            Array.isArray(record.continuation)) {
+            return undefined;
+        }
+        const candidate = record.continuation;
+        if (typeof candidate.clientMessageId !== "string" ||
+            !candidate.clientMessageId.trim() ||
+            typeof candidate.objective !== "string" ||
+            !candidate.objective.trim() ||
+            (candidate.workspacePath !== null && typeof candidate.workspacePath !== "string")) {
+            return undefined;
+        }
+        continuation = {
+            clientMessageId: candidate.clientMessageId.slice(0, 256),
+            objective: candidate.objective.trim().slice(0, 8_000),
+            workspacePath: typeof candidate.workspacePath === "string"
+                ? candidate.workspacePath.slice(0, 4_096)
+                : null,
+            ...(candidate.executionBackend === "codex" ? { executionBackend: "codex" } : {}),
+        };
+    }
+    let launch;
+    if (record.launch !== undefined) {
+        if (!record.launch || typeof record.launch !== "object" || Array.isArray(record.launch)) {
+            return undefined;
+        }
+        const candidate = record.launch;
+        if (typeof candidate.sessionId !== "string" ||
+            !candidate.sessionId.trim() ||
+            typeof candidate.at !== "number" ||
+            !Number.isFinite(candidate.at) ||
+            (candidate.taskId !== undefined && typeof candidate.taskId !== "string")) {
+            return undefined;
+        }
+        launch = {
+            sessionId: candidate.sessionId.slice(0, 256),
+            ...(typeof candidate.taskId === "string" && candidate.taskId
+                ? { taskId: candidate.taskId.slice(0, 128) }
+                : {}),
+            at: candidate.at,
+        };
+    }
+    return {
+        key: record.key.trim().slice(0, 512),
+        text: record.text.trim().slice(0, MAX_PET_LONG_TASK_SUMMARY_LENGTH),
+        decidedAt: record.decidedAt,
+        ...(replyAttachmentPaths ? { replyAttachmentPaths } : {}),
+        ...(replyButton ? { replyButton } : {}),
+        ...(continuation ? { continuation } : {}),
+        ...(launch ? { launch } : {}),
+    };
+}
+/** Defensive parser used by durable hosts. Invalid rows are dropped independently. */
+export function parsePetLongTask(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.schemaVersion !== PET_LONG_TASK_SCHEMA_VERSION ||
+        typeof record.id !== "string" ||
+        !record.id ||
+        typeof record.originClientMessageId !== "string" ||
+        !record.originClientMessageId ||
+        typeof record.objective !== "string" ||
+        !record.objective ||
+        typeof record.sessionId !== "string" ||
+        !record.sessionId ||
+        !isStatus(record.status) ||
+        !isPhase(record.phase) ||
+        typeof record.attempt !== "number" ||
+        !Number.isSafeInteger(record.attempt) ||
+        record.attempt < 1 ||
+        typeof record.revision !== "number" ||
+        !Number.isSafeInteger(record.revision) ||
+        record.revision < 1 ||
+        typeof record.createdAt !== "number" ||
+        typeof record.updatedAt !== "number") {
+        return null;
+    }
+    const events = Array.isArray(record.events)
+        ? record.events
+            .map(parseEvent)
+            .filter((event) => event !== null)
+            .slice(-MAX_PET_LONG_TASK_EVENTS)
+        : [];
+    const completionTarget = normalizeCompletionTarget(record.completionTarget);
+    const continuationDepth = typeof record.continuationDepth === "number" &&
+        Number.isSafeInteger(record.continuationDepth) &&
+        record.continuationDepth > 0
+        ? record.continuationDepth
+        : 0;
+    const closureDecision = parseClosureDecision(record.closureDecision);
+    return {
+        schemaVersion: PET_LONG_TASK_SCHEMA_VERSION,
+        id: record.id.slice(0, 128),
+        originClientMessageId: record.originClientMessageId.slice(0, 256),
+        objective: record.objective.slice(0, 8_000),
+        workspacePath: typeof record.workspacePath === "string" ? record.workspacePath.slice(0, 4_096) : null,
+        sessionId: record.sessionId.slice(0, 256),
+        ...(record.executionBackend === "codex" ? { executionBackend: "codex" } : {}),
+        // Rows written before verificationMode existed were all launched with a
+        // forced Goal. Preserve that meaning while new rows default to turn mode.
+        verificationMode: record.verificationMode === "turn" ? "turn" : "goal",
+        ...(completionTarget ? { completionTarget } : {}),
+        ...(continuationDepth > 0 ? { continuationDepth } : {}),
+        status: record.status,
+        phase: record.phase,
+        attempt: record.attempt,
+        revision: record.revision,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        ...(typeof record.startedAt === "number" ? { startedAt: record.startedAt } : {}),
+        ...(typeof record.completedAt === "number" ? { completedAt: record.completedAt } : {}),
+        ...(typeof record.closureRecordedAt === "number"
+            ? { closureRecordedAt: record.closureRecordedAt }
+            : {}),
+        ...(closureDecision ? { closureDecision } : {}),
+        ...(typeof record.resultSummary === "string"
+            ? { resultSummary: record.resultSummary.slice(0, MAX_PET_LONG_TASK_SUMMARY_LENGTH) }
+            : {}),
+        ...(typeof record.summary === "string"
+            ? { summary: record.summary.slice(0, MAX_PET_LONG_TASK_SUMMARY_LENGTH) }
+            : {}),
+        ...(typeof record.waitingFor === "string"
+            ? { waitingFor: record.waitingFor.slice(0, 500) }
+            : {}),
+        ...(typeof record.nextAction === "string"
+            ? { nextAction: record.nextAction.slice(0, 500) }
+            : {}),
+        ...(typeof record.lastError === "string"
+            ? { lastError: record.lastError.slice(0, 2_000) }
+            : {}),
+        artifacts: normalizeArtifacts(Array.isArray(record.artifacts) ? record.artifacts : []),
+        events,
+    };
+}
+/** Bounded task continuity injected into each Mimi manager turn. */
+export function buildPetLongTaskContext(tasks) {
+    const sorted = [...tasks].sort((left, right) => right.updatedAt - left.updatedAt);
+    const active = sorted
+        .filter((task) => !TERMINAL.has(task.status))
+        .slice(0, 20)
+        .map((task) => ({
+        taskId: task.id,
+        objective: task.objective.slice(0, 800),
+        status: task.status,
+        phase: task.phase,
+        sessionId: task.sessionId,
+        ...(task.workspacePath ? { workspace: task.workspacePath.slice(0, 500) } : {}),
+        attempt: task.attempt,
+        updatedAt: task.updatedAt,
+        ...(task.summary ? { summary: task.summary.slice(0, 1_000) } : {}),
+        ...(task.waitingFor ? { waitingFor: task.waitingFor.slice(0, 500) } : {}),
+        ...(task.nextAction ? { nextAction: task.nextAction.slice(0, 500) } : {}),
+    }));
+    const recent = sorted
+        .filter((task) => TERMINAL.has(task.status))
+        .slice(0, 10)
+        .map((task) => ({
+        taskId: task.id,
+        objective: task.objective.slice(0, 500),
+        status: task.status,
+        sessionId: task.sessionId,
+        ...(task.workspacePath ? { workspace: task.workspacePath.slice(0, 500) } : {}),
+        updatedAt: task.updatedAt,
+        ...(task.summary ? { summary: task.summary.slice(0, 800) } : {}),
+        ...(task.artifacts.some((artifact) => artifact.kind === "file")
+            ? {
+                artifacts: task.artifacts
+                    .filter((artifact) => artifact.kind === "file")
+                    .slice(0, 8)
+                    .map((artifact) => ({ ...artifact })),
+            }
+            : {}),
+    }));
+    return { version: 1, active, recent };
+}
+export function petLongTaskResumePrompt(task) {
+    const durableCheckpoint = task.resultSummary ?? task.summary;
+    const checkpoint = durableCheckpoint ? `\nLatest durable checkpoint: ${durableCheckpoint}` : "";
+    const next = task.nextAction ? `\nExpected next action: ${task.nextAction}` : "";
+    return (`Resume the existing long-running task. Preserve prior work in this session, inspect the current state, ` +
+        `and continue until the original objective is genuinely verified complete.\n\nOriginal objective: ${task.objective}` +
+        `${checkpoint}${next}`);
+}