@agwab/pi-workflow 0.2.0 → 0.3.0

package/dist/store.js

@@ -1,13 +1,17 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { cp, mkdir, open, readdir, readFile, realpath, rename, stat, unlink, utimes, writeFile, } from "node:fs/promises";
+import { cp, link, mkdir, open, readdir, readFile, realpath, rename, stat, unlink, utimes, writeFile, } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep, } from "node:path";
 import { randomBytes } from "node:crypto";
 import { parseWorkflow } from "./schema.js";
 import { WORKFLOW_RUN_TYPE, } from "./types.js";
 const TERMINAL_INDEX_LIMIT = 50;
 const LEASE_STALE_MS = 30_000;
+const LEASE_ABSOLUTE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 const INDEX_LOCK_WAIT_MS = 5_000;
 const INDEX_LOCK_RETRY_MS = 50;
+const DEFAULT_INDEX_UPDATE_DEBOUNCE_MS = 500;
+let indexUpdateDebounceMs = DEFAULT_INDEX_UPDATE_DEBOUNCE_MS;
+const pendingIndexUpdates = new Map();
 const runLeaseContext = new AsyncLocalStorage();
 const TASK_STATUSES = [
     "pending",
@@ -139,34 +143,74 @@ async function reclaimStaleLock(lockFile) {
     const snapshot = await readLockSnapshot(lockFile);
     if (!snapshot)
         return true;
-    if (Date.now() - snapshot.mtimeMs <= LEASE_STALE_MS)
+    if (!isReclaimableLockSnapshot(snapshot))
         return false;
-    if (snapshot.pid !== undefined && isProcessAlive(snapshot.pid))
+    const reclaimFile = `${lockFile}.reclaim-${process.pid}-${randomBytes(3).toString("hex")}`;
+    try {
+        await rename(lockFile, reclaimFile);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
         return false;
-    const latest = await readLockSnapshot(lockFile);
-    if (!latest)
+    }
+    const claimed = await readLockSnapshot(reclaimFile);
+    if (!claimed)
         return true;
-    if (latest.ownerId !== snapshot.ownerId || latest.pid !== snapshot.pid)
+    if (!sameLockOwnerSnapshot(snapshot, claimed)) {
+        await restoreReclaimFile(reclaimFile, lockFile);
         return false;
-    if (Date.now() - latest.mtimeMs <= LEASE_STALE_MS)
+    }
+    if (!isReclaimableLockSnapshot(claimed)) {
+        await restoreReclaimFile(reclaimFile, lockFile);
         return false;
-    if (latest.pid !== undefined && isProcessAlive(latest.pid))
+    }
+    await unlink(reclaimFile).catch(() => undefined);
+    return true;
+}
+async function restoreReclaimFile(reclaimFile, lockFile) {
+    try {
+        await link(reclaimFile, lockFile);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    finally {
+        await unlink(reclaimFile).catch(() => undefined);
+    }
+}
+function isReclaimableLockSnapshot(snapshot) {
+    const now = Date.now();
+    const leaseStale = now - snapshot.mtimeMs > LEASE_STALE_MS;
+    const absoluteStale = now - (snapshot.createdAtMs ?? snapshot.mtimeMs) > LEASE_ABSOLUTE_STALE_MS;
+    if (!leaseStale && !absoluteStale)
+        return false;
+    if (snapshot.pid !== undefined &&
+        isProcessAlive(snapshot.pid) &&
+        !absoluteStale)
         return false;
-    await unlink(lockFile).catch(() => undefined);
     return true;
 }
+function sameLockOwnerSnapshot(left, right) {
+    return (left.ownerId === right.ownerId &&
+        left.pid === right.pid &&
+        left.createdAtMs === right.createdAtMs);
+}
 async function readLockSnapshot(lockFile) {
     try {
         const [fileStat, text] = await Promise.all([
             stat(lockFile),
             readFile(lockFile, "utf8"),
         ]);
-        const [ownerId = "", pidText] = text.split(/\r?\n/);
+        const [ownerId = "", pidText, createdAtText] = text.split(/\r?\n/);
         const pid = Number.parseInt(pidText ?? "", 10);
+        const createdAtMs = Date.parse(createdAtText ?? "");
         return {
             ownerId,
             pid: Number.isFinite(pid) ? pid : undefined,
             mtimeMs: fileStat.mtimeMs,
+            createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : undefined,
         };
     }
     catch (error) {
@@ -256,7 +300,46 @@ export async function writeRunRecord(cwd, run) {
     const derived = deriveRunStatus(run);
     Object.assign(run, derived);
     await writeJsonAtomic(workflowRunPath(cwd, run.runId), run);
-    await updateIndex(cwd).catch(() => undefined);
+    scheduleIndexUpdate(cwd, run.runId, {
+        immediate: isTerminalWorkflowStatus(run.status),
+    });
+}
+function indexUpdateKey(cwd, runId) {
+    return `${cwd}\0${runId}`;
+}
+function scheduleIndexUpdate(cwd, runId, options) {
+    const key = indexUpdateKey(cwd, runId);
+    const existing = pendingIndexUpdates.get(key);
+    if (existing) {
+        clearTimeout(existing.timer);
+        pendingIndexUpdates.delete(key);
+    }
+    const runUpdate = () => {
+        pendingIndexUpdates.delete(key);
+        void updateIndex(cwd, runId).catch(() => undefined);
+    };
+    if (options.immediate) {
+        runUpdate();
+        return;
+    }
+    // Pending debounced index writes are intentionally not flushed on process exit:
+    // the next explicit index rebuild/read path self-heals from run.json records.
+    const timer = setTimeout(runUpdate, indexUpdateDebounceMs);
+    timer.unref?.();
+    pendingIndexUpdates.set(key, { cwd, runId, timer });
+}
+export async function flushPendingIndexUpdatesForTests() {
+    const pending = [...pendingIndexUpdates.values()];
+    pendingIndexUpdates.clear();
+    for (const item of pending)
+        clearTimeout(item.timer);
+    await Promise.all(pending.map((item) => updateIndex(item.cwd, item.runId)));
+}
+export function setIndexUpdateDebounceMsForTests(value) {
+    indexUpdateDebounceMs =
+        value === undefined
+            ? DEFAULT_INDEX_UPDATE_DEBOUNCE_MS
+            : Math.max(0, Math.floor(value));
 }
 export async function writeCompiledRunArtifact(cwd, runId, compiled) {
     const runDir = workflowRunDir(cwd, runId);
@@ -830,48 +913,15 @@ function isRunRecordLike(value) {
         typeof task.status === "string" &&
         TASK_STATUSES.includes(task.status)));
 }
-export async function updateIndex(cwd) {
+export async function updateIndex(cwd, changedRunId) {
     const lockFile = join(workflowsRoot(cwd), "index.lock");
     const ownerId = `${process.pid}-${randomBytes(3).toString("hex")}`;
     await ensureDir(workflowsRoot(cwd));
     await acquireLockWithWait(lockFile, ownerId);
     try {
-        const runs = (await listRunRecords(cwd)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-        const active = runs.filter((run) => !isTerminalWorkflowStatus(run.status));
-        const terminal = runs
-            .filter((run) => isTerminalWorkflowStatus(run.status))
-            .slice(0, TERMINAL_INDEX_LIMIT);
-        const selected = [...active, ...terminal].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-        const index = {
-            schemaVersion: 1,
-            updatedAt: nowIso(),
-            runs: selected.map((run) => ({
-                runId: run.runId,
-                name: run.name,
-                type: run.type,
-                artifactGraph: run.artifactGraph,
-                status: run.status,
-                taskSummary: run.taskSummary,
-                createdAt: run.createdAt,
-                updatedAt: run.updatedAt,
-                parentRunId: run.parentRunId,
-                rootRunId: run.rootRunId,
-                round: run.round,
-                fanout: run.fanout,
-                runJson: toProjectPath(cwd, workflowRunPath(cwd, run.runId)),
-                tasks: run.tasks.map((task) => ({
-                    taskId: task.taskId,
-                    displayName: task.displayName,
-                    agent: task.agent,
-                    kind: task.kind,
-                    stageId: task.stageId,
-                    backendHandle: task.backendHandle,
-                    status: task.status,
-                    statusDetail: task.statusDetail,
-                    lastMessage: task.lastMessage,
-                })),
-            })),
-        };
+        const index = changedRunId
+            ? await updateIndexIncremental(cwd, changedRunId)
+            : await rebuildIndex(cwd);
         await writeJsonAtomic(workflowIndexPath(cwd), index);
         return index;
     }
@@ -879,6 +929,93 @@ export async function updateIndex(cwd) {
         await releaseLock(lockFile, ownerId);
     }
 }
+async function updateIndexIncremental(cwd, changedRunId) {
+    const existing = await readIndexForIncremental(cwd);
+    if (!existing)
+        return rebuildIndex(cwd);
+    let changedRun;
+    try {
+        changedRun = await readRunRecord(cwd, changedRunId);
+    }
+    catch {
+        return rebuildIndex(cwd);
+    }
+    const changedEntry = buildIndexEntry(cwd, changedRun);
+    const entries = existing.runs
+        .filter((entry) => entry.runId !== changedRun.runId)
+        .concat(changedEntry);
+    return {
+        schemaVersion: 1,
+        updatedAt: nowIso(),
+        runs: selectIndexEntries(entries),
+    };
+}
+async function readIndexForIncremental(cwd) {
+    let index;
+    try {
+        index = await readIndex(cwd);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isIndexRecordLike(index))
+        return undefined;
+    return index;
+}
+async function rebuildIndex(cwd) {
+    const runs = await listRunRecords(cwd);
+    return {
+        schemaVersion: 1,
+        updatedAt: nowIso(),
+        runs: selectIndexEntries(runs.map((run) => buildIndexEntry(cwd, run))),
+    };
+}
+function selectIndexEntries(entries) {
+    const sorted = [...entries].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    const active = sorted.filter((entry) => !isTerminalWorkflowStatus(entry.status));
+    const terminal = sorted
+        .filter((entry) => isTerminalWorkflowStatus(entry.status))
+        .slice(0, TERMINAL_INDEX_LIMIT);
+    return [...active, ...terminal].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function buildIndexEntry(cwd, run) {
+    return {
+        runId: run.runId,
+        name: run.name,
+        type: run.type,
+        artifactGraph: run.artifactGraph,
+        status: run.status,
+        taskSummary: run.taskSummary,
+        createdAt: run.createdAt,
+        updatedAt: run.updatedAt,
+        parentRunId: run.parentRunId,
+        rootRunId: run.rootRunId,
+        round: run.round,
+        fanout: run.fanout,
+        runJson: toProjectPath(cwd, workflowRunPath(cwd, run.runId)),
+        tasks: run.tasks.map((task) => ({
+            taskId: task.taskId,
+            displayName: task.displayName,
+            agent: task.agent,
+            kind: task.kind,
+            stageId: task.stageId,
+            backendHandle: task.backendHandle,
+            status: task.status,
+            statusDetail: task.statusDetail,
+            lastMessage: task.lastMessage,
+        })),
+    };
+}
+function isIndexRecordLike(value) {
+    return (value?.schemaVersion === 1 &&
+        Array.isArray(value.runs) &&
+        value.runs.every((entry) => entry &&
+            typeof entry === "object" &&
+            typeof entry.runId === "string" &&
+            typeof entry.updatedAt === "string" &&
+            typeof entry.status === "string" &&
+            Array.isArray(entry.tasks)));
+}
 export function deriveRunStatus(run) {
     const next = { ...run, tasks: run.tasks };
     next.taskSummary = summarizeTasks(next.tasks);
@@ -900,8 +1037,10 @@ export function deriveWorkflowStatus(summary) {
         return "running";
     if (summary.total > 0 && summary.completed === summary.total)
         return "completed";
-    if (summary.failed > 0 || summary.interrupted > 0)
+    if (summary.failed > 0)
         return "failed";
+    if (summary.interrupted > 0)
+        return "interrupted";
     return "interrupted";
 }
 export function isTerminalWorkflowStatus(status) {
@@ -1080,6 +1219,7 @@ export function createTaskRunRecord(cwd, runId, task, index) {
         dependsOn: task.dependsOn,
         artifactGraph: taskArtifactGraph,
         dynamicGenerated: task.dynamicGenerated,
+        foreachGenerated: task.foreachGenerated,
         files,
         lastMessage: blocked ? task.safety.permission.reason : undefined,
     };

package/dist/subagent-backend.d.ts

@@ -1,6 +1,10 @@
 import type { CompiledTask, WorkflowRunRecord, WorkflowTaskRunRecord } from "./types.js";
 import type { BackendLaunchResult } from "./backend.js";
 export declare function setSubagentApiForTests(api: unknown | undefined): void;
+export declare function setSubagentLaunchControlsForTests(options?: {
+    releaseDelayMs?: number;
+    retryJitterMs?: number | (() => number);
+}): void;
 export declare function cleanupSubagentRun(_cwd: string, run: WorkflowRunRecord): Promise<void>;
 export declare function launchSubagentTask(cwd: string, run: WorkflowRunRecord, task: WorkflowTaskRunRecord, compiledTask: CompiledTask): Promise<BackendLaunchResult>;
 export declare function refreshRunFromSubagentArtifacts(cwd: string, run: WorkflowRunRecord): Promise<WorkflowRunRecord>;