@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/loop/dist/sessions/session-closeout.js

@@ -0,0 +1,150 @@
+import { writeBrainDump } from "@ocean/brain/memory/brain-dump.js";
+import { appendDailyNarrative, appendObservations, } from "@ocean/brain/memory/daily-narrative.js";
+import { learnFromSession, } from "@ocean/brain/memory/lesson-learning.js";
+import { generateModelNarrative } from "@ocean/brain/memory/model-narrative.js";
+import { writeSessionSummary, } from "@ocean/brain/memory/session-summary.js";
+import { safeJsonParse } from "@ocean/core/shared/fs-utils.js";
+import { gitChangedFiles } from "@ocean/core/shared/project-resolution.js";
+import { createHandoffWithStore } from "../handoff/handoff-service.js";
+async function changedFiles(workingDirectory) {
+    return (await gitChangedFiles(workingDirectory)).slice(0, 100);
+}
+function lastEvent(events, type) {
+    return [...events].reverse().find((event) => event.type === type);
+}
+function evidence(events, result) {
+    return events
+        .filter((event) => event.type === "evidence" || event.type === "provider_blocked")
+        .map((event) => {
+        const value = safeJsonParse(event.data);
+        if (event.type === "provider_blocked")
+            return result === "blocked"
+                ? String(value?.reason ?? event.data)
+                : null;
+        const proven = value?.result === "proven";
+        if (result === "proven" && proven)
+            return String(value?.criterion ?? "verified result");
+        if (result === "notProven" && !proven)
+            return String(value?.criterion ?? value?.result ?? "not proven");
+        return null;
+    })
+        .filter((value) => Boolean(value))
+        .slice(0, 12);
+}
+export async function finalizeSession(store, sessionId, input = {}) {
+    const session = store.get(sessionId);
+    if (!session)
+        throw new Error(`Session not found: ${sessionId}`);
+    // finalizeSession can legitimately be invoked more than once for the same session
+    // (e.g. a caller's success path completes closeout, then a later step in that same
+    // caller throws and its catch block calls finalizeSession again). The summary/handoff
+    // work below is already idempotent (guarded by existing handoffId / session_summary
+    // event checks), but the daily-narrative append is a pure side effect with no such
+    // check, so a re-run would otherwise write a duplicate "Work log" line. closedAt is
+    // only ever set by the updateCloseout call further down, so its presence here means
+    // this session has already been closed out once.
+    const alreadyClosedOut = Boolean(session.closedAt);
+    const events = store.listEvents(sessionId);
+    const exitEvent = lastEvent(events, "process_exit");
+    const exitCode = input.exitCode ??
+        (exitEvent
+            ? Number(safeJsonParse(exitEvent.data)?.exitCode ?? 1)
+            : session.status === "completed"
+                ? 0
+                : 1);
+    const closeoutStatus = session.status === "completed" && exitCode === 0 ? "completed" : "failed";
+    const files = await changedFiles(session.workingDirectory);
+    const summary = await writeSessionSummary({
+        session,
+        events,
+        changedFiles: files,
+        exitCode,
+        nextAction: input.nextAction,
+    });
+    let handoffId = session.handoffId;
+    const enoughEvidence = Boolean(session.taskId ||
+        (closeoutStatus === "completed" &&
+            events.some((event) => ["user_input", "provider_output", "text", "json"].includes(event.type))));
+    if (!handoffId && enoughEvidence) {
+        try {
+            const handoff = await createHandoffWithStore(store, {
+                sessionId,
+                taskId: session.taskId ?? undefined,
+                nextAction: input.nextAction,
+                sourceSummaryPath: summary.summaryPath,
+                changedFiles: files,
+                verification: evidence(events, "proven"),
+                notProven: evidence(events, "notProven"),
+                blocked: evidence(events, "blocked"),
+            });
+            handoffId = handoff.handoffId;
+        }
+        catch (error) {
+            store.appendEvent(sessionId, "closeout_warning", error instanceof Error ? error.message : String(error));
+        }
+    }
+    const closedAt = new Date().toISOString();
+    store.updateCloseout(sessionId, { ...summary, closeoutStatus, closedAt });
+    if (!alreadyClosedOut) {
+        // Computed first so writeBrainDump can surface the same signals as the
+        // daily narrative, but kept in its own try/catch: a failure here must
+        // not skip the narrative/summary work below, and vice versa.
+        let observations = [];
+        try {
+            const learning = await learnFromSession(store, sessionId);
+            observations = learning.created;
+            // Only when the session changed the store: a no-op closeout adds no event.
+            if (learning.created.length ||
+                learning.confirmed.length ||
+                learning.contradicted.length ||
+                learning.promoted.length ||
+                learning.errors.length)
+                store.appendEvent(sessionId, "lesson_scored", JSON.stringify({
+                    verified: learning.score.verified,
+                    created: learning.created.map((lesson) => lesson.id),
+                    confirmed: learning.confirmed,
+                    contradicted: learning.contradicted,
+                    promoted: learning.promoted,
+                    errors: learning.errors,
+                }));
+            await appendObservations(session, observations);
+        }
+        catch (error) {
+            store.appendEvent(sessionId, "closeout_warning", error instanceof Error ? error.message : String(error));
+        }
+        try {
+            const narrative = await generateModelNarrative({
+                session,
+                events,
+                changedFiles: files,
+                nextAction: input.nextAction,
+            });
+            await appendDailyNarrative({
+                session,
+                events,
+                exitCode,
+                nextAction: input.nextAction,
+                narrative,
+            });
+            await writeBrainDump({
+                session,
+                events,
+                changedFiles: files,
+                exitCode,
+                nextAction: input.nextAction,
+                narrative,
+                observations,
+            });
+        }
+        catch (error) {
+            store.appendEvent(sessionId, "closeout_warning", error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (!store
+        .listEvents(sessionId)
+        .some((event) => event.type === "session_summary")) {
+        store.appendEvent(sessionId, "session_summary", JSON.stringify({ ...summary, handoffId, closeoutStatus, closedAt }));
+    }
+    return { ...summary, handoffId, closeoutStatus };
+}
+//# sourceMappingURL=session-closeout.js.map

package/node_modules/@ocean/loop/dist/sessions/session-pointer.js

@@ -0,0 +1,133 @@
+import path from "node:path";
+import { validateBudget } from "@ocean/context/context/context-ladder.js";
+import { sameProject } from "@ocean/core/shared/paths.js";
+import { resolveProject } from "@ocean/core/shared/project-resolution.js";
+// Sessions are created with randomUUID(), so a pointer that is not a UUID did not come from
+// Ocean and is refused before any lookup.
+const SESSION_ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const STALE_RESUME_MS = 24 * 60 * 60 * 1000;
+const MAX_NEXT_ACTION_CHARS = 200;
+export function validateSessionIdentifier(sessionId) {
+    if (typeof sessionId !== "string" || sessionId.length === 0)
+        return { valid: false, reason: "session pointer is missing" };
+    if (sessionId.includes("\0"))
+        return { valid: false, reason: "session pointer contains a null byte" };
+    if (!SESSION_ID_SHAPE.test(sessionId))
+        return {
+            valid: false,
+            reason: `session pointer '${sessionId}' is not a valid Ocean session identifier`,
+        };
+    return { valid: true, value: sessionId };
+}
+function refused(reason, violations = []) {
+    return {
+        ok: false,
+        mode: "refused",
+        reason,
+        pointer: null,
+        parentSessionId: null,
+        violations,
+    };
+}
+function clip(value) {
+    return value.length > MAX_NEXT_ACTION_CHARS
+        ? `${value.slice(0, MAX_NEXT_ACTION_CHARS)}…`
+        : value;
+}
+async function projectIdFor(directory) {
+    const resolution = await resolveProject(directory);
+    return resolution.status === "bound" ? resolution.projectId : null;
+}
+// Builds the compact pointer for a session that is already known to exist. Carries only
+// references: summaryPath is a path, not the summary; nextAction is clipped.
+export async function buildSessionPointer(session) {
+    return {
+        sessionId: session.sessionId,
+        parentSessionId: session.parentSessionId,
+        projectId: await projectIdFor(session.workingDirectory),
+        provider: session.provider,
+        status: session.status,
+        taskId: session.taskId,
+        checkpointRef: session.summaryPath,
+        nextAction: clip(session.nextAction ?? ""),
+        updatedAt: session.updatedAt,
+    };
+}
+// Deterministic, read-only resume planning. Budget is validated before the store is read.
+export async function planSessionResume(store, sessionId, budget, options = {}) {
+    const budgetCheck = validateBudget(budget);
+    if (!budgetCheck.valid)
+        return refused(`invalid-budget: ${budgetCheck.reason}`, ["invalid-budget"]);
+    const identifier = validateSessionIdentifier(sessionId);
+    if (!identifier.valid)
+        return refused(identifier.reason);
+    const session = store.get(identifier.value);
+    if (!session)
+        return refused(`session ${identifier.value} does not exist in Ocean`);
+    const pointer = await buildSessionPointer(session);
+    const cwd = options.cwd;
+    if (cwd) {
+        const currentProject = await projectIdFor(path.resolve(cwd));
+        if (pointer.projectId &&
+            currentProject &&
+            !sameProject(pointer.projectId, currentProject)) {
+            return refused(`cross-project resume refused: session belongs to '${pointer.projectId}', current directory resolves to '${currentProject}'`);
+        }
+    }
+    if (options.requestedProject &&
+        pointer.projectId &&
+        !sameProject(options.requestedProject, pointer.projectId)) {
+        return refused(`cross-project resume refused: session belongs to '${pointer.projectId}', request targeted '${options.requestedProject}'`);
+    }
+    const now = options.now ?? Date.now();
+    const age = now - Date.parse(session.updatedAt);
+    if (session.status === "created") {
+        return refused(`session ${identifier.value} never started (status: created) — nothing to resume`);
+    }
+    if (session.status === "failed" || session.status === "cancelled") {
+        return refused(`session ${identifier.value} ended in terminal status '${session.status}' — a new session must be started explicitly, Ocean will not reassign it automatically`);
+    }
+    if (session.status === "running" &&
+        Number.isFinite(age) &&
+        age > STALE_RESUME_MS) {
+        return refused(`session ${identifier.value} is stale: last updated ${Math.floor(age / 3_600_000)}h ago while still marked running — run 'ocean session doctor' before resuming`, ["stale-session"]);
+    }
+    const mode = session.status === "running" ? "attach-child" : "pointer-only";
+    const plan = {
+        ok: true,
+        mode,
+        reason: mode === "attach-child"
+            ? `session ${identifier.value} is live; a child session may attach to it`
+            : `session ${identifier.value} is closed cleanly; a new child session may point at its checkpoint without replaying it`,
+        pointer,
+        parentSessionId: identifier.value,
+        violations: [],
+    };
+    const bounded = budget;
+    const serialized = JSON.stringify(plan).length;
+    if (serialized > bounded.maxChars) {
+        return refused(`resume plan is ${serialized} chars, budget.maxChars allows ${bounded.maxChars}`, ["max-chars-exceeded"]);
+    }
+    return plan;
+}
+// Validates an explicitly supplied parent before a caller passes it to store.create().
+// A missing parent is reported as "none", never inferred from the most recent session.
+export function validateParentSession(store, parentSessionId, childSessionId) {
+    if (parentSessionId === null || parentSessionId === undefined) {
+        return { ok: true, parentSessionId: null };
+    }
+    const identifier = validateSessionIdentifier(parentSessionId);
+    if (!identifier.valid)
+        return { ok: false, reason: identifier.reason };
+    if (childSessionId && childSessionId === identifier.value) {
+        return { ok: false, reason: "a session cannot be its own parent" };
+    }
+    const parent = store.get(identifier.value);
+    if (!parent)
+        return {
+            ok: false,
+            reason: `parent session ${identifier.value} does not exist in Ocean`,
+        };
+    return { ok: true, parentSessionId: identifier.value };
+}
+//# sourceMappingURL=session-pointer.js.map

package/node_modules/@ocean/loop/dist/sessions/session-projects.js

@@ -0,0 +1,26 @@
+import { folderProject } from "@ocean/core/shared/project-resolution.js";
+// The project to record on a new session. Recording a session must not fail on registry state,
+// so an unreadable registry yields null; the next `ocean migrate --apply` fills it.
+export async function sessionProjectId(cwd) {
+    try {
+        return await folderProject(cwd);
+    }
+    catch {
+        return null;
+    }
+}
+// Fill project_id on sessions recorded before the column existed, then on the handoffs that
+// came from them. An unreadable registry throws and aborts: never guess a folder's project.
+export async function backfillSessionProjects(store) {
+    let sessions = 0;
+    let unresolved = 0;
+    for (const directory of store.sessionDirectoriesMissingProject()) {
+        const project = await folderProject(directory);
+        if (project)
+            sessions += store.setProjectForDirectory(directory, project);
+        else
+            unresolved += 1;
+    }
+    return { sessions, handoffs: store.backfillHandoffProjects(), unresolved };
+}
+//# sourceMappingURL=session-projects.js.map

package/node_modules/@ocean/loop/dist/sessions/session-retention.js

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { mkdir, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { writeSessionSummary } from "@ocean/brain/memory/session-summary.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+// Session retention (T-228): summarize finished, unsummarized sessions to markdown, then
+// prune their raw provider_output/terminal_input events (never a session row, a handoff, an
+// idea, or a capture-referenced event), then checkpoint+VACUUM. Default mode is dry-run
+// (planRetention only); simulate measures a VACUUMed copy; apply is fingerprint-gated and is
+// never invoked against the live sessions.sqlite by this task — only against fixture
+// databases in tests.
+export const DEFAULT_KEEP_DAYS = 7;
+function computeFingerprint(before, types, sessionIds, eventIds) {
+    const sorted = [...sessionIds].sort();
+    // Not Math.max(...eventIds): spreading tens of thousands of event ids as call arguments
+    // overflows the engine's argument-count limit (RangeError: Maximum call stack size
+    // exceeded) on a real corpus, even though small fixture-scale tests never hit it.
+    let maxEventId = 0;
+    for (const id of eventIds)
+        if (id > maxEventId)
+            maxEventId = id;
+    return createHash("sha256")
+        .update(JSON.stringify({
+        before,
+        types: [...types].sort(),
+        sessionIds: sorted,
+        eventCount: eventIds.length,
+        maxEventId,
+    }))
+        .digest("hex");
+}
+export function planRetention(store, options = {}) {
+    const keepDays = options.keepDays ?? DEFAULT_KEEP_DAYS;
+    const before = options.before ??
+        new Date((options.now ?? Date.now()) - keepDays * 24 * 60 * 60 * 1000).toISOString();
+    const sessions = store.retentionEligibleSessions(before);
+    const sessionIds = sessions.map((session) => session.sessionId);
+    const needSummary = sessions
+        .filter((session) => !session.summaryPath)
+        .map((session) => session.sessionId);
+    const eventIds = store.retentionPrunableEventIds(sessionIds);
+    const dataBytes = store.eventsDataBytes(eventIds);
+    const RAW_EVENT_TYPES = ["provider_output", "terminal_input"];
+    return {
+        before,
+        keepDays,
+        sessionIds,
+        needSummary,
+        eventIds,
+        dataBytes,
+        fingerprint: computeFingerprint(before, RAW_EVENT_TYPES, sessionIds, eventIds),
+    };
+}
+// Measures the effect of applying `plan` against a throwaway VACUUMed COPY of the database
+// file backing `store` — the live file is never touched. The copy lives under a private,
+// mode-0700 directory (never /tmp), and is always removed, even on error.
+export async function simulateRetention(store, _sourceFile, plan, openStore) {
+    const simDir = oceanPath(SYSTEM_DIR, "sessions", ".compaction-sim");
+    await mkdir(simDir, { recursive: true, mode: 0o700 });
+    const copyPath = path.join(simDir, `sim-${process.pid}-${Date.now()}.sqlite`);
+    await rm(copyPath, { force: true });
+    try {
+        await store.backupTo(copyPath);
+        const beforeBytes = (await stat(copyPath)).size;
+        const copyStore = openStore(copyPath);
+        try {
+            copyStore.deleteEvents(plan.eventIds);
+            copyStore.checkpointAndVacuum();
+        }
+        finally {
+            copyStore.close();
+        }
+        const afterBytes = (await stat(copyPath)).size;
+        return {
+            beforeBytes,
+            afterBytes,
+            freedBytes: beforeBytes - afterBytes,
+            plan,
+        };
+    }
+    finally {
+        await rm(copyPath, { force: true });
+        await rm(`${copyPath}-wal`, { force: true });
+        await rm(`${copyPath}-shm`, { force: true });
+    }
+}
+// Fingerprint-gated: refuses to run if `fingerprint` does not match a freshly recomputed
+// plan for the same `before`/keepDays — the database must not have moved out from under the
+// plan between planning and applying. Backs up first, summarizes any unsummarized finished
+// session (verifying the written file's hash before trusting it), deletes only the planned
+// event ids, appends one audit event per session, then checkpoints+VACUUMs.
+export async function applyRetention(store, sourceFile, plan, fingerprint) {
+    const fresh = planRetention(store, {
+        keepDays: plan.keepDays,
+        before: plan.before,
+    });
+    if (fresh.fingerprint !== fingerprint ||
+        fresh.fingerprint !== plan.fingerprint) {
+        throw new Error("retention plan fingerprint mismatch — the database changed since this plan was made; refusing to apply a stale plan");
+    }
+    const backupDir = oceanPath(SYSTEM_DIR, "sessions", ".backups");
+    await mkdir(backupDir, { recursive: true, mode: 0o700 });
+    const backupPath = path.join(backupDir, `sessions-${Date.now()}.sqlite`);
+    await store.backupTo(backupPath);
+    const beforeBytes = (await stat(sourceFile)).size;
+    const summarized = [];
+    for (const sessionId of plan.needSummary) {
+        const session = store.get(sessionId);
+        if (!session)
+            continue;
+        const events = store.listEvents(sessionId);
+        const written = await writeSessionSummary({ session, events });
+        store.setSummary(sessionId, written);
+        summarized.push(sessionId);
+    }
+    store.deleteEvents(plan.eventIds);
+    // Retention's audit event is best-effort and coarse (the total pruned count for the whole
+    // plan, not a precise per-session breakdown), recorded once against every planned session.
+    for (const sessionId of plan.sessionIds) {
+        store.recordRetentionPrune(sessionId, plan.eventIds.length, plan.before);
+    }
+    store.checkpointAndVacuum();
+    const afterBytes = (await stat(sourceFile)).size;
+    return {
+        backupPath,
+        summarized,
+        eventsDeleted: plan.eventIds.length,
+        beforeBytes,
+        afterBytes,
+    };
+}
+//# sourceMappingURL=session-retention.js.map

package/node_modules/@ocean/loop/dist/tasks/archive-tasks.js

@@ -0,0 +1,210 @@
+import { access, mkdir, readdir, readFile, rename, rmdir, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { resolveWithin, WORKSPACE_PROJECT_ID, workspaceTasksRoot, } from "@ocean/core/shared/paths.js";
+import { projectArchiveName, WORKSPACE_ARCHIVE_NAMESPACE, } from "@ocean/core/shared/task-reference.js";
+import { verifyTask } from "./verify-task.js";
+const field = (source, name) => source
+    .match(new RegExp(`^${name}:\\s*(.+)$`, "m"))?.[1]
+    ?.trim()
+    .replace(/^['"]|['"]$/g, "") ?? "";
+function setState(source, state) {
+    return source.replace(/^state:\s*.+$/m, `state: ${state}`);
+}
+function section(source, heading) {
+    const header = new RegExp(`^## ${heading}[ \\t]*\\r?$`, "m").exec(source);
+    if (!header)
+        return undefined;
+    const start = source.indexOf("\n", header.index) + 1;
+    const nextHeading = /^## /m.exec(source.slice(start));
+    return source.slice(start, nextHeading ? start + nextHeading.index : source.length);
+}
+function completionIssues(source) {
+    const issues = [];
+    if (/^\s*-\s+"?\[ \] /m.test(source))
+        issues.push("unchecked work");
+    const blockers = section(source, "Blockers");
+    if (blockers === undefined) {
+        issues.push("missing Blockers section");
+    }
+    else {
+        const entries = blockers
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const open = entries.filter((line) => {
+            if (/^(?:[-*]\s*)?(?:none|no blockers?)\.?$/i.test(line))
+                return false;
+            const checkbox = line.match(/^[-*]\s+\[([ xX])\]\s+.+$/);
+            if (checkbox)
+                return checkbox[1].toLowerCase() !== "x";
+            return true;
+        });
+        if (open.length)
+            issues.push("unresolved blockers");
+    }
+    const definition = section(source, "Definition of done");
+    if (definition === undefined) {
+        issues.push("missing Definition of done section");
+    }
+    else {
+        const criteria = definition
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        if (!criteria.length) {
+            issues.push("missing acceptance criteria");
+        }
+        else {
+            const unchecked = criteria.some((line) => {
+                const checkbox = line.match(/^[-*]\s+\[([ xX])\]\s+.+$/);
+                if (!checkbox)
+                    return true;
+                return checkbox[1].toLowerCase() !== "x";
+            });
+            const malformed = criteria.some((line) => !/^[-*]\s+\[([ xX])\]\s+.+$/.test(line));
+            if (malformed)
+                issues.push("acceptance criteria must use checked boxes");
+            else if (unchecked)
+                issues.push("unchecked acceptance criteria");
+        }
+    }
+    return issues;
+}
+export async function completeTask(id, root = workspaceTasksRoot(), options = {}) {
+    const taskFile = resolveWithin(root, id, "task.md");
+    const source = await readFile(taskFile, "utf8");
+    const issues = completionIssues(source);
+    if (issues.length)
+        throw new Error(`Cannot complete ${id}: ${issues.join("; ")}`);
+    const outcome = await verifyTask(id, root, {
+        cwd: options.cwd,
+        run: options.run,
+    });
+    if (!outcome.passed)
+        throw new Error(`Cannot complete ${id}: ${outcome.reason}`);
+    if (field(source, "state") !== "done")
+        await writeFile(taskFile, setState(source, "done"));
+    const archived = await archiveDoneTasks(root, true, {
+        ...options,
+        verified: new Set([id]),
+        only: new Set([id]),
+    });
+    const skipped = archived.skipped.find((entry) => entry.id === id);
+    if (skipped) {
+        await writeFile(taskFile, source, "utf8");
+        throw new Error(`Cannot complete ${id}: ${skipped.reason}`);
+    }
+    return { id, state: "done", ...archived };
+}
+export async function archiveDoneTasks(root = workspaceTasksRoot(), apply = false, options = {}) {
+    const result = {
+        candidates: [],
+        skipped: [],
+        moved: [],
+        repaired: [],
+    };
+    const archiveRoot = resolveWithin(root, "archive");
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return result;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === "archive")
+            continue;
+        const sourceDirectory = resolveWithin(root, entry.name);
+        const taskFile = resolveWithin(root, entry.name, "task.md");
+        try {
+            await access(taskFile);
+        }
+        catch {
+            const archivedDirectory = resolveWithin(archiveRoot, WORKSPACE_ARCHIVE_NAMESPACE, entry.name);
+            try {
+                await access(path.join(archivedDirectory, "task.md"));
+            }
+            catch {
+                continue; // not archived
+            }
+            if (!apply)
+                continue;
+            for (const artifact of await readdir(sourceDirectory, {
+                withFileTypes: true,
+            })) {
+                const destination = resolveWithin(archivedDirectory, artifact.name);
+                try {
+                    await access(destination);
+                    result.skipped.push({
+                        id: entry.name,
+                        reason: `archive artifact exists: ${artifact.name}`,
+                    });
+                    continue;
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+                await rename(path.join(sourceDirectory, artifact.name), destination);
+            }
+            try {
+                await rmdir(sourceDirectory);
+            }
+            catch (error) {
+                if (error.code !== "ENOTEMPTY")
+                    throw error;
+            }
+            result.repaired.push(entry.name);
+            continue;
+        }
+        const source = await readFile(taskFile, "utf8");
+        const id = field(source, "id") || entry.name;
+        const state = field(source, "state");
+        if (state !== "done" && state !== "cancelled")
+            continue;
+        if (options.only && !options.only.has(id))
+            continue;
+        if (state === "done") {
+            const issues = completionIssues(source);
+            if (issues.length) {
+                result.skipped.push({ id, reason: issues.join("; ") });
+                continue;
+            }
+            if (apply && !options.verified?.has(id)) {
+                const outcome = await verifyTask(id, root, {
+                    cwd: options.cwd,
+                    run: options.run,
+                });
+                if (!outcome.passed) {
+                    result.skipped.push({ id, reason: outcome.reason });
+                    continue;
+                }
+            }
+        }
+        if (state === "cancelled" && source.match(/^\s*-\s+"?\[ \] /m)) {
+            result.skipped.push({ id, reason: "unchecked work" });
+            continue;
+        }
+        result.candidates.push(id);
+        if (!apply)
+            continue;
+        const project = field(source, "project") || WORKSPACE_PROJECT_ID;
+        const destinationDirectory = resolveWithin(archiveRoot, projectArchiveName(project), id);
+        try {
+            await access(destinationDirectory);
+            result.skipped.push({ id, reason: "archive destination exists" });
+            continue;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await mkdir(path.dirname(destinationDirectory), { recursive: true });
+        await rename(sourceDirectory, destinationDirectory);
+        result.moved.push(id);
+    }
+    return result;
+}
+//# sourceMappingURL=archive-tasks.js.map

package/node_modules/@ocean/loop/dist/tasks/checkpoint-task.js

@@ -0,0 +1,31 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { localDate } from "@ocean/core/shared/local-date.js";
+import { resolveWithin, workspaceTasksRoot } from "@ocean/core/shared/paths.js";
+/**
+ * Append a durable checkpoint to a task's `## Log` and, when given, replace its
+ * `## Next action`. Writing to the task file means the checkpoint survives a
+ * cold restart: a later loop iteration or a fresh session reads it back from
+ * disk rather than from in-memory state.
+ */
+export async function checkpointTask(id, root = workspaceTasksRoot(), input) {
+    if (!input.note?.trim())
+        throw new Error("Checkpoint requires a note.");
+    const taskFile = resolveWithin(root, id, "task.md");
+    let source = await readFile(taskFile, "utf8");
+    const date = input.date ?? localDate();
+    const entry = `- ${date} — ${input.note.trim()}`;
+    if (/^## Log\s*$/m.test(source))
+        source = source.replace(/^## Log\s*$/m, `## Log\n\n${entry}`);
+    else
+        source = `${source.trimEnd()}\n\n## Log\n\n${entry}\n`;
+    if (input.next?.trim()) {
+        const next = input.next.trim();
+        if (/^## Next action\s*$/m.test(source))
+            source = source.replace(/^## Next action\s*$[\s\S]*?(?=^## |\s*$)/m, `## Next action\n\n${next}\n\n`);
+        else
+            source = `${source.trimEnd()}\n\n## Next action\n\n${next}\n`;
+    }
+    await writeFile(taskFile, source, "utf8");
+    return { checkpointed: id };
+}
+//# sourceMappingURL=checkpoint-task.js.map