cool-workflow 0.1.98 → 0.2.0

package/dist/mcp-surface.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolDefinitions = exports.callTool = void 0;
-exports.requiredToolArguments = requiredToolArguments;
-const capability_registry_1 = require("./capability-registry");
-const capability_core_1 = require("./capability-core");
-var tool_call_1 = require("./mcp/tool-call");
-Object.defineProperty(exports, "callTool", { enumerable: true, get: function () { return tool_call_1.callTool; } });
-var tool_definitions_1 = require("./mcp/tool-definitions");
-Object.defineProperty(exports, "toolDefinitions", { enumerable: true, get: function () { return tool_definitions_1.toolDefinitions; } });
-function requiredToolArguments(name, value) {
-    if (value === undefined || value === null)
-        value = {};
-    if (!(0, capability_core_1.isRecord)(value))
-        throw new Error(`MCP tool ${name} arguments must be an object.`);
-    const args = value;
-    for (const group of requiredArgsForTool(name)) {
-        const keys = group.split("|");
-        if (!keys.some((key) => args[key] !== undefined && args[key] !== null && args[key] !== "")) {
-            throw new Error(`MCP tool ${name} missing required argument: ${keys.join(" or ")}`);
-        }
-    }
-    return args;
-}
-function requiredArgsForTool(name) {
-    // Required args are declared once per capability as data on the mcp binding
-    // (McpBinding.requiredArgs). This is a pure data read of the parity-gated
-    // registry — no string-pattern ladder.
-    return (0, capability_registry_1.mcpRequiredArgsForTool)(name);
-}

package/dist/multi-agent/graph.js

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildMultiAgentGraphFromState = buildMultiAgentGraphFromState;
-// Multi-agent provenance-graph builder (god-module carve, FreeBSD router pattern
-// — cf. orchestrator/topology-operations.ts and run-registry/derive.ts). This is
-// the largest cohesive renderer in the module: it walks the resolved
-// MultiAgentState and emits the nodes/edges that the operator-UX and orchestrator
-// graph surfaces consume. BEHAVIOR-PRESERVING — pure code movement, zero logic
-// change. multi-agent.ts keeps the public buildMultiAgentGraph(run) entry point
-// as a thin delegator (it resolves the state via ensureMultiAgentState, then
-// calls buildMultiAgentGraphFromState) so the state is still ensured exactly
-// once, in the same order, with the same side effects.
-const node_fs_1 = __importDefault(require("node:fs"));
-const paths_1 = require("./paths");
-const helpers_1 = require("./helpers");
-function buildMultiAgentGraphFromState(run, state) {
-    const root = (0, paths_1.multiAgentRoot)(run);
-    const nodes = [];
-    const edges = [];
-    for (const record of state.runs) {
-        nodes.push({ id: `${run.id}:multi-agent:${record.id}`, kind: "multi-agent-run", status: record.status, label: record.title || record.id, path: (0, paths_1.recordPath)(run, "runs", record.id) });
-        edges.push({ from: `${run.id}:run`, to: `${run.id}:multi-agent:${record.id}` });
-        if (record.blackboardId)
-            edges.push({ from: `${run.id}:multi-agent:${record.id}`, to: `${run.id}:blackboard:${record.blackboardId}`, label: "blackboard" });
-        if (record.parentMultiAgentRunId)
-            edges.push({ from: `${run.id}:multi-agent:${record.parentMultiAgentRunId}`, to: `${run.id}:multi-agent:${record.id}`, label: "child" });
-    }
-    for (const record of state.roles) {
-        nodes.push({ id: `${run.id}:multi-agent:role:${record.id}`, kind: "agent-role", status: record.status, label: record.title, path: (0, paths_1.recordPath)(run, "roles", record.id) });
-        edges.push({ from: `${run.id}:multi-agent:${record.multiAgentRunId}`, to: `${run.id}:multi-agent:role:${record.id}` });
-        if (record.blackboardId)
-            edges.push({ from: `${run.id}:multi-agent:role:${record.id}`, to: `${run.id}:blackboard:${record.blackboardId}`, label: "blackboard" });
-    }
-    for (const record of state.groups) {
-        nodes.push({ id: `${run.id}:multi-agent:group:${record.id}`, kind: "agent-group", status: record.status, label: record.title || record.id, path: (0, paths_1.recordPath)(run, "groups", record.id) });
-        edges.push({ from: `${run.id}:multi-agent:${record.multiAgentRunId}`, to: `${run.id}:multi-agent:group:${record.id}` });
-        if (record.blackboardId)
-            edges.push({ from: `${run.id}:multi-agent:group:${record.id}`, to: `${run.id}:blackboard:${record.blackboardId}`, label: "blackboard" });
-        for (const taskId of record.taskIds)
-            edges.push({ from: `${run.id}:multi-agent:group:${record.id}`, to: `${run.id}:task:${taskId}`, label: "task" });
-    }
-    for (const record of state.fanouts) {
-        nodes.push({ id: `${run.id}:multi-agent:fanout:${record.id}`, kind: "agent-fanout", status: record.status, label: record.reason, path: (0, paths_1.recordPath)(run, "fanouts", record.id) });
-        edges.push({ from: `${run.id}:multi-agent:group:${record.groupId}`, to: `${run.id}:multi-agent:fanout:${record.id}` });
-        for (const dispatchId of record.dispatchIds)
-            edges.push({ from: `${run.id}:multi-agent:fanout:${record.id}`, to: `${run.id}:dispatch:${dispatchId}`, label: "dispatch" });
-    }
-    for (const record of state.memberships) {
-        nodes.push({ id: `${run.id}:multi-agent:membership:${record.id}`, kind: "agent-membership", status: record.status, label: `${record.roleId}/${record.taskId}`, path: (0, paths_1.recordPath)(run, "memberships", record.id) });
-        edges.push({ from: `${run.id}:multi-agent:group:${record.groupId}`, to: `${run.id}:multi-agent:membership:${record.id}` });
-        edges.push({ from: `${run.id}:multi-agent:role:${record.roleId}`, to: `${run.id}:multi-agent:membership:${record.id}` });
-        edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: `${run.id}:task:${record.taskId}`, label: "task" });
-        if (record.workerId)
-            edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: `${run.id}:worker:${record.workerId}`, label: "worker" });
-        if (record.resultNodeId)
-            edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: record.resultNodeId, label: "result" });
-        if (record.verifierNodeId)
-            edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: record.verifierNodeId, label: "verifier" });
-        if (record.blackboardId)
-            edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: `${run.id}:blackboard:${record.blackboardId}`, label: "blackboard" });
-        for (const artifactId of record.blackboardArtifactRefIds || [])
-            edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: `${run.id}:blackboard:artifact:${artifactId}`, label: "evidence" });
-        for (const messageId of record.blackboardMessageIds || [])
-            edges.push({ from: `${run.id}:multi-agent:membership:${record.id}`, to: `${run.id}:blackboard:message:${messageId}`, label: "message" });
-    }
-    for (const record of state.fanins) {
-        nodes.push({ id: `${run.id}:multi-agent:fanin:${record.id}`, kind: "agent-fanin", status: record.status, label: record.strategy, path: (0, paths_1.recordPath)(run, "fanins", record.id) });
-        edges.push({ from: `${run.id}:multi-agent:group:${record.groupId}`, to: `${run.id}:multi-agent:fanin:${record.id}` });
-        if (record.fanoutId)
-            edges.push({ from: `${run.id}:multi-agent:fanout:${record.fanoutId}`, to: `${run.id}:multi-agent:fanin:${record.id}` });
-        for (const membershipId of record.reportedMembershipIds)
-            edges.push({ from: `${run.id}:multi-agent:membership:${membershipId}`, to: `${run.id}:multi-agent:fanin:${record.id}`, label: "reported" });
-        for (const membershipId of record.missingMembershipIds)
-            edges.push({ from: `${run.id}:multi-agent:membership:${membershipId}`, to: `${run.id}:multi-agent:fanin:${record.id}`, label: "missing" });
-        if (record.blackboardId)
-            edges.push({ from: `${run.id}:multi-agent:fanin:${record.id}`, to: `${run.id}:blackboard:${record.blackboardId}`, label: "blackboard" });
-    }
-    if (!node_fs_1.default.existsSync(root))
-        node_fs_1.default.mkdirSync(root, { recursive: true });
-    return { nodes, edges: (0, helpers_1.uniqueEdges)(edges) };
-}

package/dist/multi-agent/helpers.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createId = exports.MULTI_AGENT_SCHEMA_VERSION = void 0;
-exports.indexRow = indexRow;
-exports.assertNoRecordPathCollisions = assertNoRecordPathCollisions;
-exports.pluralKind = pluralKind;
-exports.statusToNodeStatus = statusToNodeStatus;
-exports.assertLifecycleTransition = assertLifecycleTransition;
-exports.lifecycleEvent = lifecycleEvent;
-exports.isMembershipReported = isMembershipReported;
-exports.touch = touch;
-exports.compact = compact;
-exports.unique = unique;
-exports.countBy = countBy;
-exports.uniqueEdges = uniqueEdges;
-const state_1 = require("../state");
-exports.MULTI_AGENT_SCHEMA_VERSION = 1;
-function indexRow(record) {
-    return { id: record.id, status: record.status, updatedAt: record.updatedAt };
-}
-function assertNoRecordPathCollisions(label, records) {
-    const seen = new Map();
-    for (const record of records) {
-        const safe = (0, state_1.safeFileName)(record.id);
-        const existing = seen.get(safe);
-        if (existing && existing !== record.id) {
-            throw new Error(`${label} ids ${existing} and ${record.id} collide on safe file name ${safe}`);
-        }
-        seen.set(safe, record.id);
-    }
-}
-function pluralKind(kind) {
-    switch (kind) {
-        case "multi-agent-run":
-            return "runs";
-        case "agent-role":
-            return "roles";
-        case "agent-group":
-            return "groups";
-        case "agent-membership":
-            return "memberships";
-        case "agent-fanout":
-            return "fanouts";
-        case "agent-fanin":
-            return "fanins";
-        default:
-            return `${kind}s`;
-    }
-}
-function statusToNodeStatus(status) {
-    switch (status) {
-        case "completed":
-        case "reported":
-        case "ready":
-            return "completed";
-        case "running":
-        case "forming":
-        case "collecting":
-        case "verifying":
-        case "assigned":
-        case "active":
-        case "dispatched":
-            return "running";
-        case "blocked":
-            return "blocked";
-        case "failed":
-            return "failed";
-        case "cancelled":
-        case "rejected":
-            return "rejected";
-        default:
-            return "pending";
-    }
-}
-function assertLifecycleTransition(from, to) {
-    const allowed = {
-        planned: ["forming", "running", "failed", "cancelled"],
-        forming: ["running", "failed", "cancelled"],
-        running: ["collecting", "completed", "failed", "cancelled"],
-        collecting: ["verifying", "completed", "failed", "cancelled"],
-        verifying: ["completed", "failed", "cancelled"],
-        completed: [],
-        failed: [],
-        cancelled: []
-    };
-    if (from === to)
-        return;
-    if (!allowed[from].includes(to))
-        throw new Error(`Invalid MultiAgentRun lifecycle transition: ${from} -> ${to}`);
-}
-function lifecycleEvent(from, to, reason, actor = "cw", metadata) {
-    return {
-        at: new Date().toISOString(),
-        from,
-        to,
-        actor,
-        reason,
-        metadata: compact(metadata)
-    };
-}
-function isMembershipReported(membership) {
-    return (membership.status === "reported" || membership.status === "verified") && membership.evidenceRefs.length > 0;
-}
-function touch(record) {
-    record.updatedAt = new Date().toISOString();
-    return record;
-}
-// Deterministic record id — single source of truth in ./ids. Re-exported here so
-// multi-agent.ts importers stay byte-unchanged (F10 dedup: the coordinator layer
-// shares the exact same helper).
-var ids_1 = require("./ids");
-Object.defineProperty(exports, "createId", { enumerable: true, get: function () { return ids_1.createId; } });
-function compact(value) {
-    if (!value)
-        return undefined;
-    const entries = Object.entries(value).filter(([, entry]) => entry !== undefined);
-    return entries.length ? Object.fromEntries(entries) : undefined;
-}
-function unique(values) {
-    return Array.from(new Set(values.filter(Boolean))).sort();
-}
-function countBy(items, key) {
-    const counts = {};
-    for (const item of items) {
-        const value = key(item);
-        counts[value] = (counts[value] || 0) + 1;
-    }
-    return counts;
-}
-function uniqueEdges(edges) {
-    const seen = new Set();
-    const result = [];
-    for (const edge of edges) {
-        const key = `${edge.from}\0${edge.to}\0${edge.label || ""}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        result.push(edge);
-    }
-    return result;
-}

package/dist/multi-agent/ids.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createId = createId;
-// Single source of truth for the deterministic record id scheme shared by the
-// multi-agent kernel (multi-agent/helpers.ts) and the coordinator/blackboard
-// layer (coordinator/util.ts). Both previously copy-pasted byte-identical
-// zero-padded-seq logic; this dedup (F10) collapses them onto one helper.
-//
-// Deterministic record id (FreeBSD-audit L12/L13): the record's POSITION in its
-// per-run collection, threaded from the call site. No wall-clock stamp, no PRNG
-// suffix — re-running the same multi-agent topology / coordination mints
-// byte-identical ids, so snapshot/replay digests match. Each call site already
-// asserts the minted id is unique within its collection, and these collections
-// only ever append.
-//
-// REPLAY DETERMINISM: pure function of its arguments — no Date, no random.
-// The output MUST stay byte-identical: `${prefix}-${4-digit-zero-padded-seq}`.
-function createId(prefix, seq) {
-    return `${prefix}-${String(seq).padStart(4, "0")}`;
-}

package/dist/multi-agent/paths.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.multiAgentRoot = multiAgentRoot;
-exports.recordPath = recordPath;
-// Filesystem path resolution for multi-agent records (god-module carve, FreeBSD
-// router pattern). BEHAVIOR-PRESERVING — pure code movement, zero logic change.
-// These two free functions derive paths from run.paths only; they are shared by
-// the persistence, node-append, and graph clusters, so they live in their own
-// leaf module to keep those clusters free of a circular import back to
-// multi-agent.ts. Re-exported there is unnecessary (both are private), but the
-// derivation is byte-identical to the originals.
-const node_path_1 = __importDefault(require("node:path"));
-const state_1 = require("../state");
-function multiAgentRoot(run) {
-    return run.paths.multiAgentDir || node_path_1.default.join(run.paths.runDir, "multi-agent");
-}
-function recordPath(run, kind, id) {
-    return node_path_1.default.join(multiAgentRoot(run), kind, `${(0, state_1.safeFileName)(id)}.json`);
-}

package/dist/multi-agent-eval/normalize.js

@@ -1,51 +0,0 @@
-"use strict";
-// Pure, stateless normalization helpers for the multi-agent eval replay layer —
-// timestamp/path scrubbing, recursive value normalization, and stable
-// stringification. Carved out of multi-agent-eval.ts (FreeBSD-audit god-module
-// split) so the eval router no longer bundles the deterministic-normalization
-// primitives. Nothing here touches state; everything is a pure function of its
-// arguments. Re-exported verbatim from multi-agent-eval.ts so every importer
-// (including node-snapshot.ts and reclamation.ts) stays byte-unchanged.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeValue = normalizeValue;
-exports.lines = lines;
-exports.replayStableStringify = replayStableStringify;
-function normalizeValue(value) {
-    if (Array.isArray(value))
-        return value.map(normalizeValue);
-    if (!value || typeof value !== "object") {
-        if (typeof value === "string")
-            return normalizeString(value);
-        return value;
-    }
-    const record = value;
-    const normalized = {};
-    for (const key of Object.keys(record).sort()) {
-        if (["createdAt", "updatedAt", "recordedAt", "selectedAt", "replayedAt", "generatedAt"].includes(key))
-            continue;
-        if (key.endsWith("Path") || key === "path" || key === "cwd" || key === "runDir" || key.endsWith("Dir")) {
-            normalized[key] = normalizeString(String(record[key]));
-        }
-        else {
-            normalized[key] = normalizeValue(record[key]);
-        }
-    }
-    return normalized;
-}
-function normalizeString(value) {
-    return value
-        .replace(/[0-9]{8}T[0-9]{6}Z/g, "<timestamp>")
-        .replace(/[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9:.]+Z/g, "<timestamp>")
-        .replace(/\/[^"\s]+\/\.cw\/runs\/[^"\s/]+/g, "<run-dir>")
-        .replace(/\/[^"\s]+\/\.cw\/evals\/[^"\s/]+/g, "<eval-dir>")
-        .replace(/\/var\/folders\/[^"\s]+|\/tmp\/[^"\s]+|\/private\/tmp\/[^"\s]+/g, "<tmp>");
-}
-function lines(value) {
-    const normalized = normalizeValue(value);
-    if (Array.isArray(normalized))
-        return normalized.map((entry) => replayStableStringify(entry)).sort();
-    return [replayStableStringify(normalized)].sort();
-}
-function replayStableStringify(value) {
-    return JSON.stringify(normalizeValue(value));
-}