@a5c-ai/agent-platform 5.0.1-staging.04ca6ab00d21

package/dist/storage/journalWatcher.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * GAP-JSON-005: JournalWatcher — real-time event streaming from journal dir.
+ *
+ * Watches a run's journal/ directory for new .json files. Emits events
+ * incrementally (only seq > lastSeenSeq) in strict seq order. Supports
+ * fs.watch with automatic polling fallback.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJournalWatcher = createJournalWatcher;
+const fsSync = __importStar(require("node:fs"));
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+function parseJournalFilename(name) {
+    const match = name.match(/^(\d{6})\.([A-Z0-9]+)\.json$/);
+    if (!match)
+        return null;
+    return { seq: parseInt(match[1], 10), ulid: match[2] };
+}
+function createJournalWatcher(options) {
+    const { runDir, afterSeq = 0, pollIntervalMs = 1000, useFsWatch = true, onError, onDone, } = options;
+    const journalDir = path.join(runDir, "journal");
+    let lastSeenSeq = afterSeq;
+    let closed = false;
+    let pollTimer = null;
+    let fsWatcher = null;
+    let scanning = false;
+    let eventCallback = options.onEvent;
+    const watcher = {
+        get lastSeenSeq() {
+            return lastSeenSeq;
+        },
+        get onEvent() {
+            return eventCallback;
+        },
+        set onEvent(cb) {
+            eventCallback = cb;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            if (pollTimer) {
+                clearInterval(pollTimer);
+                pollTimer = null;
+            }
+            if (fsWatcher) {
+                fsWatcher.close();
+                fsWatcher = null;
+            }
+        },
+    };
+    async function scan() {
+        if (closed || scanning)
+            return;
+        scanning = true;
+        try {
+            let entries;
+            try {
+                entries = await node_fs_1.promises.readdir(journalDir);
+            }
+            catch {
+                return;
+            }
+            const parsed = entries
+                .map((name) => ({ name, parsed: parseJournalFilename(name) }))
+                .filter((entry) => entry.parsed !== null && entry.parsed.seq > lastSeenSeq)
+                .sort((a, b) => a.parsed.seq - b.parsed.seq);
+            for (const entry of parsed) {
+                if (closed)
+                    break;
+                const filePath = path.join(journalDir, entry.name);
+                let event;
+                let eventType;
+                try {
+                    const raw = await node_fs_1.promises.readFile(filePath, "utf-8");
+                    const data = JSON.parse(raw);
+                    eventType = data.type;
+                    event = {
+                        seq: entry.parsed.seq,
+                        ulid: entry.parsed.ulid,
+                        filename: entry.name,
+                        path: `journal/${entry.name}`,
+                        type: data.type,
+                        recordedAt: data.recordedAt,
+                        data: data.data,
+                        checksum: data.checksum,
+                    };
+                }
+                catch (error) {
+                    if (onError) {
+                        onError(error instanceof Error ? error : new Error(String(error)));
+                    }
+                    lastSeenSeq = entry.parsed.seq;
+                    continue;
+                }
+                try {
+                    eventCallback(event);
+                    lastSeenSeq = entry.parsed.seq;
+                }
+                catch (error) {
+                    if (onError) {
+                        onError(error instanceof Error ? error : new Error(String(error)));
+                    }
+                    lastSeenSeq = entry.parsed.seq;
+                }
+                if (eventType === "RUN_COMPLETED" || eventType === "RUN_FAILED") {
+                    if (onDone)
+                        onDone();
+                    watcher.close();
+                }
+            }
+        }
+        finally {
+            scanning = false;
+        }
+    }
+    pollTimer = setInterval(() => {
+        void scan();
+    }, pollIntervalMs);
+    if (useFsWatch) {
+        try {
+            fsWatcher = fsSync.watch(journalDir, () => {
+                void scan();
+            });
+            fsWatcher.on("error", () => {
+                if (fsWatcher) {
+                    fsWatcher.close();
+                    fsWatcher = null;
+                }
+            });
+        }
+        catch {
+            // Polling fallback remains active.
+        }
+    }
+    void scan();
+    return watcher;
+}

package/dist/storage/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function getTasksDir(runDir: string): string;
+export declare function getBlobsDir(runDir: string): string;
+export declare function getStateDir(runDir: string): string;
+export declare function getStateFile(runDir: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/storage/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/storage/paths.ts"],"names":[],"mappings":"AAOA,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/storage/paths.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTasksDir = getTasksDir;
+exports.getBlobsDir = getBlobsDir;
+exports.getStateDir = getStateDir;
+exports.getStateFile = getStateFile;
+const node_path_1 = __importDefault(require("node:path"));
+const TASKS_DIR = "tasks";
+const BLOBS_DIR = "blobs";
+const STATE_DIR = "state";
+const STATE_FILE = "state.json";
+function getTasksDir(runDir) {
+    return node_path_1.default.join(runDir, TASKS_DIR);
+}
+function getBlobsDir(runDir) {
+    return node_path_1.default.join(runDir, BLOBS_DIR);
+}
+function getStateDir(runDir) {
+    return node_path_1.default.join(runDir, STATE_DIR);
+}
+function getStateFile(runDir) {
+    return node_path_1.default.join(getStateDir(runDir), STATE_FILE);
+}

package/dist/storage/snapshotState.d.ts

@@ -0,0 +1,10 @@
+import type { SnapshotStateOptions } from "./types";
+export declare function snapshotState(options: SnapshotStateOptions): Promise<{
+    journalHead: {
+        seq: number;
+        ulid: string;
+    } | null;
+    savedAt: string;
+    state: import("@a5c-ai/babysitter-sdk/dist/storage/types").JsonRecord;
+}>;
+//# sourceMappingURL=snapshotState.d.ts.map

package/dist/storage/snapshotState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotState.d.ts","sourceRoot":"","sources":["../../src/storage/snapshotState.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB;;;;;;;GAQhE"}

package/dist/storage/snapshotState.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotState = snapshotState;
+const clock_1 = require("./clock");
+const paths_1 = require("./paths");
+const atomic_1 = require("./atomic");
+async function snapshotState(options) {
+    const payload = {
+        journalHead: options.journalHead ?? null,
+        savedAt: (0, clock_1.getClockIsoString)(),
+        state: options.state,
+    };
+    await (0, atomic_1.writeFileAtomic)((0, paths_1.getStateFile)(options.runDir), JSON.stringify(payload, null, 2) + "\n");
+    return payload;
+}

package/dist/storage/storeTaskArtifacts.d.ts

@@ -0,0 +1,6 @@
+import type { StoreTaskArtifactsOptions } from "./types";
+export declare function storeTaskArtifacts(options: StoreTaskArtifactsOptions): Promise<{
+    name: string;
+    storedAt: string;
+}[]>;
+//# sourceMappingURL=storeTaskArtifacts.d.ts.map

package/dist/storage/storeTaskArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeTaskArtifacts.d.ts","sourceRoot":"","sources":["../../src/storage/storeTaskArtifacts.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAazD,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB;UAWrC,MAAM;cAAY,MAAM;KA2B7D"}

package/dist/storage/storeTaskArtifacts.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeTaskArtifacts = storeTaskArtifacts;
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
+const atomic_1 = require("./atomic");
+const paths_1 = require("./paths");
+const ARTIFACT_SPILL_THRESHOLD = 512 * 1024;
+async function writeArtifact(targetPath, data) {
+    await (0, atomic_1.writeFileAtomic)(targetPath, data);
+}
+function hashBuffer(data) {
+    const buf = typeof data === "string" ? Buffer.from(data) : data;
+    return node_crypto_1.default.createHash("sha256").update(buf).digest("hex");
+}
+async function storeTaskArtifacts(options) {
+    const taskDir = node_path_1.default.join((0, paths_1.getTasksDir)(options.runDir), options.effectId);
+    await node_fs_1.promises.mkdir(taskDir, { recursive: true });
+    if (options.task) {
+        await (0, atomic_1.writeFileAtomic)(node_path_1.default.join(taskDir, "task.json"), JSON.stringify(options.task, null, 2) + "\n");
+    }
+    if (options.result) {
+        await (0, atomic_1.writeFileAtomic)(node_path_1.default.join(taskDir, "result.json"), JSON.stringify(options.result, null, 2) + "\n");
+    }
+    const savedArtifacts = [];
+    for (const artifact of options.artifacts ?? []) {
+        const data = typeof artifact.data === "string" ? Buffer.from(artifact.data) : artifact.data;
+        if (data.length > ARTIFACT_SPILL_THRESHOLD) {
+            const hash = hashBuffer(data);
+            const blobPath = node_path_1.default.join((0, paths_1.getBlobsDir)(options.runDir), hash);
+            try {
+                await node_fs_1.promises.access(blobPath);
+            }
+            catch {
+                await writeArtifact(blobPath, data);
+            }
+            savedArtifacts.push({ name: artifact.name, storedAt: `blobs/${hash}` });
+            continue;
+        }
+        const artifactDir = node_path_1.default.join(taskDir, "artifacts");
+        await node_fs_1.promises.mkdir(artifactDir, { recursive: true });
+        const filePath = node_path_1.default.join(artifactDir, artifact.name);
+        await writeArtifact(filePath, data);
+        savedArtifacts.push({
+            name: artifact.name,
+            storedAt: `tasks/${options.effectId}/artifacts/${artifact.name}`,
+        });
+    }
+    await (0, atomic_1.writeFileAtomic)(node_path_1.default.join(taskDir, "artifacts.json"), JSON.stringify(savedArtifacts, null, 2) + "\n");
+    return savedArtifacts;
+}

package/dist/storage/types.d.ts

@@ -0,0 +1,21 @@
+import type { JsonRecord } from "@a5c-ai/babysitter-sdk";
+export type { JournalEvent, JsonRecord } from "@a5c-ai/babysitter-sdk";
+export interface SnapshotStateOptions {
+    runDir: string;
+    state: JsonRecord;
+    journalHead?: {
+        seq: number;
+        ulid: string;
+    };
+}
+export interface StoreTaskArtifactsOptions {
+    runDir: string;
+    effectId: string;
+    task?: JsonRecord;
+    result?: JsonRecord;
+    artifacts?: Array<{
+        name: string;
+        data: Buffer | string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/storage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/storage/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEvE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,CAAC,EAAE;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D"}

package/dist/storage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tasks/crud.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Programmatic Task CRUD (GAP-TOOLS-014).
+ *
+ * Harness-owned task inspection helpers for interactive/runtime tooling.
+ */
+import type { JsonRecord } from "../storage/types";
+export interface TaskSummary {
+    effectId: string;
+    taskId: string;
+    kind: string;
+    title?: string;
+    status: "requested" | "resolved" | "unknown";
+    labels?: string[];
+    requestedAt?: string;
+    resolvedAt?: string;
+}
+export interface TaskDetail extends TaskSummary {
+    definition: JsonRecord;
+    result?: JsonRecord;
+}
+export interface ListTasksOptions {
+    status?: "requested" | "resolved" | "all";
+}
+export declare function listTasks(runDir: string, options?: ListTasksOptions): Promise<TaskSummary[]>;
+export declare function readTask(runDir: string, effectId: string): Promise<TaskDetail | null>;
+export declare function readTaskStdout(runDir: string, effectId: string): Promise<string | null>;
+export declare function readTaskStderr(runDir: string, effectId: string): Promise<string | null>;
+export declare function countTasks(runDir: string): Promise<{
+    total: number;
+    requested: number;
+    resolved: number;
+}>;
+//# sourceMappingURL=crud.d.ts.map

package/dist/tasks/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/tasks/crud.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,KAAK,CAAC;CAC3C;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,WAAW,EAAE,CAAC,CAsDxB;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA+B5B;AAED,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB;AAED,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAKjE"}

package/dist/tasks/crud.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Programmatic Task CRUD (GAP-TOOLS-014).
+ *
+ * Harness-owned task inspection helpers for interactive/runtime tooling.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTasks = listTasks;
+exports.readTask = readTask;
+exports.readTaskStdout = readTaskStdout;
+exports.readTaskStderr = readTaskStderr;
+exports.countTasks = countTasks;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+async function listTasks(runDir, options = {}) {
+    const { status = "all" } = options;
+    const tasksDir = path.join(runDir, "tasks");
+    let entries;
+    try {
+        entries = await fs.readdir(tasksDir);
+    }
+    catch {
+        return [];
+    }
+    const summaries = [];
+    for (const effectId of entries) {
+        const taskDir = path.join(tasksDir, effectId);
+        const stat = await fs.stat(taskDir).catch(() => null);
+        if (!stat?.isDirectory())
+            continue;
+        const taskDefPath = path.join(taskDir, "task.json");
+        const resultPath = path.join(taskDir, "result.json");
+        let definition;
+        let result;
+        try {
+            const raw = await fs.readFile(taskDefPath, "utf-8");
+            definition = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        try {
+            const raw = await fs.readFile(resultPath, "utf-8");
+            result = JSON.parse(raw);
+        }
+        catch {
+            // No result yet.
+        }
+        const taskStatus = result ? "resolved" : "requested";
+        if (status !== "all" && status !== taskStatus)
+            continue;
+        summaries.push({
+            effectId,
+            taskId: definition.taskId ?? effectId,
+            kind: definition.kind ?? "unknown",
+            title: definition.title,
+            status: taskStatus,
+            labels: Array.isArray(definition.labels) ? definition.labels : undefined,
+            requestedAt: definition.requestedAt,
+            resolvedAt: result?.resolvedAt,
+        });
+    }
+    return summaries;
+}
+async function readTask(runDir, effectId) {
+    const taskDir = path.join(runDir, "tasks", effectId);
+    let definition;
+    try {
+        const raw = await fs.readFile(path.join(taskDir, "task.json"), "utf-8");
+        definition = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    let result;
+    try {
+        const raw = await fs.readFile(path.join(taskDir, "result.json"), "utf-8");
+        result = JSON.parse(raw);
+    }
+    catch {
+        // No result yet.
+    }
+    return {
+        effectId,
+        taskId: definition.taskId ?? effectId,
+        kind: definition.kind ?? "unknown",
+        title: definition.title,
+        status: result ? "resolved" : "requested",
+        labels: Array.isArray(definition.labels) ? definition.labels : undefined,
+        requestedAt: definition.requestedAt,
+        resolvedAt: result?.resolvedAt,
+        definition,
+        result,
+    };
+}
+async function readTaskStdout(runDir, effectId) {
+    try {
+        return await fs.readFile(path.join(runDir, "tasks", effectId, "stdout.txt"), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+async function readTaskStderr(runDir, effectId) {
+    try {
+        return await fs.readFile(path.join(runDir, "tasks", effectId, "stderr.txt"), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+async function countTasks(runDir) {
+    const all = await listTasks(runDir, { status: "all" });
+    const requested = all.filter((task) => task.status === "requested").length;
+    const resolved = all.filter((task) => task.status === "resolved").length;
+    return { total: all.length, requested, resolved };
+}

package/dist/tasks/index.d.ts

@@ -0,0 +1,2 @@
+export { listTasks, readTask, readTaskStdout, readTaskStderr, countTasks, type TaskSummary, type TaskDetail, type ListTasksOptions, } from "./crud";
+//# sourceMappingURL=index.d.ts.map

package/dist/tasks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tasks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,QAAQ,EACR,cAAc,EACd,cAAc,EACd,UAAU,EACV,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,gBAAgB,GACtB,MAAM,QAAQ,CAAC"}

package/dist/tasks/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTasks = exports.readTaskStderr = exports.readTaskStdout = exports.readTask = exports.listTasks = void 0;
+var crud_1 = require("./crud");
+Object.defineProperty(exports, "listTasks", { enumerable: true, get: function () { return crud_1.listTasks; } });
+Object.defineProperty(exports, "readTask", { enumerable: true, get: function () { return crud_1.readTask; } });
+Object.defineProperty(exports, "readTaskStdout", { enumerable: true, get: function () { return crud_1.readTaskStdout; } });
+Object.defineProperty(exports, "readTaskStderr", { enumerable: true, get: function () { return crud_1.readTaskStderr; } });
+Object.defineProperty(exports, "countTasks", { enumerable: true, get: function () { return crud_1.countTasks; } });