cool-workflow 0.1.80 → 0.1.82

package/dist/multi-agent-host.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hostRun = hostRun;
 exports.hostStatus = hostStatus;
 exports.hostStep = hostStep;
-exports.hostAutoStep = hostAutoStep;
 exports.hostBlackboard = hostBlackboard;
 exports.hostScore = hostScore;
 exports.hostSelect = hostSelect;
@@ -179,24 +178,6 @@ function hostStep(run, options = {}) {
         requiredHostAction: "No safe deterministic step is available. Use multi-agent status for the next explicit command."
     });
 }
-/** Auto-step: loop hostStep until blocked, complete, or max iterations reached
- *  (v0.1.74). Each iteration performs one deterministic step. Returns the final
- *  response and the number of steps taken. */
-function hostAutoStep(run, options = {}) {
-    const maxSteps = Number(options.maxSteps || options["max-steps"] || 20);
-    const steps = [];
-    let response = envelope(run, "step", { performed: "none" });
-    for (let i = 0; i < maxSteps; i++) {
-        response = hostStep(run, options);
-        const performed = response.data?.performed;
-        steps.push({ step: i + 1, performed: String(performed || "none") });
-        if (performed === "none" || performed === undefined)
-            break;
-        if (response.data?.requiredHostAction)
-            break;
-    }
-    return { finalResponse: response, stepsTaken: steps.length, steps };
-}
 function hostBlackboard(run, action, options = {}) {
     const topology = optionalSingleActiveTopology(run);
     const blackboardId = resolveHostBlackboardId(run, topology, options);
@@ -403,22 +384,54 @@ function hostSelect(run, options = {}) {
     }
     return envelope(run, "select", { performed: "selected-candidate", data: selection });
 }
+function memoize(compute) {
+    let cached;
+    return (run) => (cached ??= { value: compute(run) }).value;
+}
+function createHostSummaryCache(run) {
+    const topologies = memoize(topology_1.summarizeTopologies);
+    const multiAgent = memoize(multi_agent_1.summarizeMultiAgent);
+    const blackboard = memoize(coordinator_1.summarizeBlackboard);
+    const workers = memoize(operator_ux_1.summarizeOperatorWorkers);
+    const candidates = memoize(operator_ux_1.summarizeOperatorCandidates);
+    const feedback = memoize(operator_ux_1.summarizeOperatorFeedback);
+    const commits = memoize(operator_ux_1.summarizeOperatorCommits);
+    const trust = memoize(trust_audit_1.summarizeTrustAudit);
+    const operator = memoize(operator_ux_1.summarizeOperatorRun);
+    const multiAgentOperator = memoize(multi_agent_operator_ux_1.summarizeMultiAgentOperator);
+    const active = memoize(activeTopologies);
+    return {
+        run,
+        topologies: () => topologies(run),
+        multiAgent: () => multiAgent(run),
+        blackboard: () => blackboard(run),
+        workers: () => workers(run),
+        candidates: () => candidates(run),
+        feedback: () => feedback(run),
+        commits: () => commits(run),
+        trust: () => trust(run),
+        operator: () => operator(run),
+        multiAgentOperator: () => multiAgentOperator(run),
+        active: () => active(run)
+    };
+}
 function envelope(run, command, options = {}) {
-    const topologies = (0, topology_1.summarizeTopologies)(run);
-    const multiAgent = (0, multi_agent_1.summarizeMultiAgent)(run);
-    const blackboard = (0, coordinator_1.summarizeBlackboard)(run);
-    const workers = (0, operator_ux_1.summarizeOperatorWorkers)(run);
-    const candidates = (0, operator_ux_1.summarizeOperatorCandidates)(run);
-    const feedback = (0, operator_ux_1.summarizeOperatorFeedback)(run);
-    const commits = (0, operator_ux_1.summarizeOperatorCommits)(run);
-    const trust = (0, trust_audit_1.summarizeTrustAudit)(run);
-    const operator = (0, operator_ux_1.summarizeOperatorRun)(run);
-    const multiAgentOperator = (0, multi_agent_operator_ux_1.summarizeMultiAgentOperator)(run);
-    const active = activeTopologies(run);
+    const cache = createHostSummaryCache(run);
+    const topologies = cache.topologies();
+    const multiAgent = cache.multiAgent();
+    const blackboard = cache.blackboard();
+    const workers = cache.workers();
+    const candidates = cache.candidates();
+    const feedback = cache.feedback();
+    const commits = cache.commits();
+    const trust = cache.trust();
+    const operator = cache.operator();
+    const multiAgentOperator = cache.multiAgentOperator();
+    const active = cache.active();
     const blockedReasons = unique([...operator.blockedReasons, ...(options.extraBlockedReasons || [])]);
-    const state = blockedReasons.length ? "blocked" : classifyHostState(run);
+    const state = blockedReasons.length ? "blocked" : classifyHostState(run, cache);
     const ids = activeIds(run, active);
-    const nextActions = hostNextActions(run, state, active, options.requiredHostAction);
+    const nextActions = hostNextActions(run, state, active, options.requiredHostAction, cache);
     return {
         schemaVersion: 1,
         surface: "multi-agent-host",
@@ -446,12 +459,12 @@ function envelope(run, command, options = {}) {
         data: options.data
     };
 }
-function classifyHostState(run) {
-    const active = activeTopologies(run);
-    const feedback = (0, operator_ux_1.summarizeOperatorFeedback)(run);
-    const workers = (0, operator_ux_1.summarizeOperatorWorkers)(run);
-    const candidates = (0, operator_ux_1.summarizeOperatorCandidates)(run);
-    const commits = (0, operator_ux_1.summarizeOperatorCommits)(run);
+function classifyHostState(run, cache = createHostSummaryCache(run)) {
+    const active = cache.active();
+    const feedback = cache.feedback();
+    const workers = cache.workers();
+    const candidates = cache.candidates();
+    const commits = cache.commits();
     if (!active.length && !(run.multiAgent?.runs || []).length)
         return "needs-run";
     if (feedback.open.some((entry) => !entry.retryable))
@@ -494,7 +507,7 @@ function activeIds(run, active) {
         auditEventIds: unique(active.flatMap((entry) => entry.links.auditEventIds))
     };
 }
-function hostNextActions(run, state, active, requiredHostAction) {
+function hostNextActions(run, state, active, requiredHostAction, cache = createHostSummaryCache(run)) {
     if (requiredHostAction)
         return [{ command: "host-action", reason: requiredHostAction, priority: "high" }];
     const runId = run.id;
@@ -512,7 +525,7 @@ function hostNextActions(run, state, active, requiredHostAction) {
         case "ready-for-selection":
             return [{ command: `node scripts/cw.js multi-agent select ${runId} --candidate <candidate-id> --reason "<rationale>"`, reason: "Select a scored candidate after verifier gates pass.", priority: "high" }];
         case "ready-for-commit": {
-            const ready = (0, operator_ux_1.summarizeOperatorCandidates)(run).readyForCommit[0];
+            const ready = cache.candidates().readyForCommit[0];
             return [{ command: `node scripts/cw.js commit ${runId} --selection ${ready.selectionId} --reason "<verified rationale>"`, reason: "Create a verifier-gated CW state commit.", priority: "high" }];
         }
         case "complete":

package/dist/multi-agent-operator-ux.js

@@ -15,6 +15,7 @@ const coordinator_1 = require("./coordinator");
 const multi_agent_1 = require("./multi-agent");
 const topology_1 = require("./topology");
 const trust_audit_1 = require("./trust-audit");
+const validation_1 = require("./validation");
 function summarizeMultiAgentOperator(run) {
     const topologies = (0, topology_1.summarizeTopologies)(run);
     const multiAgent = (0, multi_agent_1.summarizeMultiAgent)(run);
@@ -447,7 +448,7 @@ function readScores(run, candidateId) {
         .readdirSync(dir)
         .filter((file) => file.endsWith(".json"))
         .sort()
-        .map((file) => JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, file), "utf8")));
+        .map((file) => (0, validation_1.validateCandidateScore)(JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, file), "utf8"))));
 }
 function scorePath(run, candidateId, scoreId) {
     const file = node_path_1.default.join(run.paths.candidatesDir || node_path_1.default.join(run.paths.runDir, "candidates"), safeFileName(candidateId), "scores", `${safeFileName(scoreId)}.json`);

package/dist/multi-agent-trust.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyForRole = policyForRole;
 exports.policyForGroup = policyForGroup;
@@ -16,7 +13,7 @@ exports.summarizeMultiAgentTrust = summarizeMultiAgentTrust;
 exports.hasAcceptedJudgeRationale = hasAcceptedJudgeRationale;
 exports.sourceForActor = sourceForActor;
 exports.hashText = hashText;
-const node_crypto_1 = __importDefault(require("node:crypto"));
+const execution_backend_1 = require("./execution-backend");
 const trust_audit_1 = require("./trust-audit");
 function policyForRole(role) {
     const topologyRole = String(role.metadata?.topologyRoleId || role.title || "").toLowerCase();
@@ -294,8 +291,11 @@ function sourceForActor(actor) {
         return "runtime-derived";
     return "cw-validated";
 }
+// Delegates to the shared execution-backend sha256 (F10 dedup). Byte-identical:
+// both emit `sha256:<hex>` and Node's Hash.update(string) defaults to utf8, the
+// same encoding the shared helper passes explicitly.
 function hashText(value) {
-    return `sha256:${node_crypto_1.default.createHash("sha256").update(value).digest("hex")}`;
+    return (0, execution_backend_1.sha256)(value);
 }
 function resolvePolicy(run, input) {
     const membership = input.membershipId ? run.multiAgent?.memberships.find((entry) => entry.id === input.membershipId) : undefined;