cool-workflow 0.1.82 → 0.1.84

package/apps/pr-review-fix-ci/app.json

@@ -3,7 +3,7 @@
   "id": "pr-review-fix-ci",
   "title": "PR Review Fix CI",
   "summary": "Review a pull request or branch, inspect CI failures, diagnose actionable issues, optionally patch, verify, and summarize with evidence.",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/release-cut/app.json

@@ -3,7 +3,7 @@
   "id": "release-cut",
   "title": "Release Cut",
   "summary": "Prepare a release with checklist discipline: version checks, changelog, tests, packaging, release notes, and final verification.",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/research-synthesis/app.json

@@ -3,7 +3,7 @@
   "id": "research-synthesis",
   "title": "Research Synthesis",
   "summary": "Split a research question into claims, investigate sources, cross-check evidence, verify claims, and synthesize a concise answer.",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/dist/capability-core.js

@@ -333,13 +333,12 @@ function queueShow(reg, id) {
 // ---- control-plane scheduling (v0.1.37) -----------------------------------
 function loadSchedulingPolicy(reg) {
     const file = reg.schedulingPolicyPath();
+    // Absent policy => conservative DEFAULT (an unconfigured backend, which §4
+    // permits). But a PRESENT-but-corrupt policy must fail closed: silently
+    // substituting defaults would schedule under settings the operator never
+    // chose while their broken file sits on disk. Let readJson's throw surface it.
     if (node_fs_1.default.existsSync(file)) {
-        try {
-            return { policy: (0, scheduling_1.normalizeSchedulingPolicy)((0, state_1.readJson)(file)), source: "file" };
-        }
-        catch {
-            /* fall through to default */
-        }
+        return { policy: (0, scheduling_1.normalizeSchedulingPolicy)((0, state_1.readJson)(file)), source: "file" };
     }
     return { policy: scheduling_1.DEFAULT_SCHEDULING_POLICY, source: "default" };
 }
@@ -400,8 +399,17 @@ function schedPolicySet(reg, args) {
     const current = loadSchedulingPolicy(reg).policy;
     const patch = {};
     for (const key of ["maxConcurrent", "maxAttempts", "leaseTtlMs", "backoffBaseMs", "backoffFactor", "backoffCapMs"]) {
-        if (args[key] !== undefined)
-            patch[key] = Number(args[key]);
+        if (args[key] === undefined)
+            continue;
+        // Fail closed on a non-numeric flag instead of letting normalizeSchedulingPolicy
+        // silently substitute the DEFAULT (which would report source:"file" + exit 0,
+        // so the operator believes they set a value they didn't). Matches the
+        // Number.isFinite guard the sibling reclaimPolicyFrom already uses.
+        const value = Number(args[key]);
+        if (!Number.isFinite(value)) {
+            throw new Error(`Invalid --${key} "${String(args[key])}": expected a number (e.g. --${key} 4)`);
+        }
+        patch[key] = value;
     }
     const policy = (0, scheduling_1.normalizeSchedulingPolicy)({ ...current, ...patch });
     (0, state_1.writeJson)(reg.schedulingPolicyPath(), policy);

package/dist/capability-registry.js

@@ -26,10 +26,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CAPABILITY_REGISTRY = void 0;
 exports.declaredMcpTools = declaredMcpTools;
+exports.mcpCapabilityForTool = mcpCapabilityForTool;
+exports.mcpCapabilityForId = mcpCapabilityForId;
+exports.mcpRequiredArgsForTool = mcpRequiredArgsForTool;
+exports.mcpToolDefinition = mcpToolDefinition;
 exports.declaredCliTokens = declaredCliTokens;
 exports.requiresReason = requiresReason;
 exports.isPayloadProbeOptOut = isPayloadProbeOptOut;
 exports.payloadIdenticalCapabilities = payloadIdenticalCapabilities;
+exports.payloadProbeTargets = payloadProbeTargets;
+exports.deferredPayloadProbeCapabilities = deferredPayloadProbeCapabilities;
+exports.payloadProbePlan = payloadProbePlan;
 exports.buildParityReport = buildParityReport;
 // ---------------------------------------------------------------------------
 // Builtin entries. Grouped to mirror the CLI dispatch and the MCP tool list.
@@ -52,6 +59,14 @@ const BUILTIN_CAPABILITIES = [
         cli: { path: ["list"], jsonMode: "default" },
         mcp: { tool: "cw_list" }
     },
+    {
+        capability: "doctor",
+        summary: "Diagnose the host for setup problems (Node version, agent backend, agent binary on PATH, git, writable home/repo state) and print an actionable fix per check.",
+        entry: "runDoctor",
+        surface: "cli-only",
+        cli: { path: ["doctor"], jsonMode: "flag" },
+        reason: "Environment diagnostics are inherently local to the CLI host — Node version, $PATH, $CW_HOME/cwd writability. An MCP client diagnosing the server process's environment is not meaningful; agents already receive the same readiness facts in their typed results (e.g. status: blocked, agentConfigured). Inspired by `brew doctor`."
+    },
     {
         capability: "init",
         summary: "Scaffold a new workflow definition.",
@@ -404,12 +419,236 @@ const BUILTIN_CAPABILITIES = [
  *  silently-dead duplicate the way the old snapshot-then-register design allowed. */
 exports.CAPABILITY_REGISTRY = Array.from(new Map(BUILTIN_CAPABILITIES.map((cap) => [cap.capability, cap])).values());
 // ---------------------------------------------------------------------------
+// Payload probe classification.
+// ---------------------------------------------------------------------------
+const GLOBAL_PAYLOAD_PROBE_CAPABILITIES = [
+    "list",
+    "app.list",
+    "topology.list",
+    "sandbox.list",
+    "backend.list",
+    "backend.agent.config.show",
+    "metrics.summary"
+];
+const RUN_PAYLOAD_PROBE_CAPABILITIES = [
+    "status",
+    "operator.status",
+    "operator.report",
+    "graph",
+    "report",
+    "next",
+    "state.check",
+    "contract.show",
+    "node.list",
+    "node.graph",
+    "worker.summary",
+    "candidate.summary",
+    "feedback.summary",
+    "commit.summary",
+    "audit.summary",
+    "multi-agent.summary",
+    "workbench.view",
+    "metrics.show",
+    "review.status",
+    "comment.list",
+    "run.drive",
+    "gc.plan",
+    "gc.verify"
+];
+const PAYLOAD_PROBE_DEFERRED_GROUPS = [
+    {
+        reason: "Not safe for the deterministic bootstrap parity probe yet: this capability needs extra target ids/files, mutates durable state, depends on external state, or needs a dedicated fixture beyond cwd/runId.",
+        capabilities: [
+            "init",
+            "plan",
+            "dispatch",
+            "result",
+            "app.show",
+            "app.validate",
+            "app.init",
+            "app.package",
+            "app.run",
+            "node.show",
+            "node.snapshot",
+            "node.diff",
+            "node.replay",
+            "node.replay.verify",
+            "migration.list",
+            "migration.check",
+            "migration.prove",
+            "topology.show",
+            "topology.validate",
+            "topology.apply",
+            "topology.summary",
+            "topology.graph",
+            "summary.refresh",
+            "summary.show",
+            "multi-agent.run",
+            "multi-agent.status",
+            "multi-agent.step",
+            "multi-agent.blackboard",
+            "multi-agent.score",
+            "multi-agent.select",
+            "multi-agent.summarize",
+            "multi-agent.graph",
+            "multi-agent.graph.compact",
+            "multi-agent.dependencies",
+            "multi-agent.failures",
+            "multi-agent.evidence",
+            "multi-agent.reasoning",
+            "multi-agent.reasoning.refresh",
+            "multi-agent.run.create",
+            "multi-agent.run.transition",
+            "multi-agent.run.show",
+            "multi-agent.role.create",
+            "multi-agent.role.show",
+            "multi-agent.group.create",
+            "multi-agent.group.show",
+            "multi-agent.membership.create",
+            "multi-agent.membership.show",
+            "multi-agent.fanout.create",
+            "multi-agent.fanout.show",
+            "multi-agent.fanin.collect",
+            "multi-agent.fanin.show",
+            "eval.snapshot",
+            "eval.replay",
+            "eval.compare",
+            "eval.score",
+            "eval.gate",
+            "eval.report",
+            "blackboard.summary",
+            "blackboard.summarize",
+            "blackboard.graph",
+            "blackboard.resolve",
+            "blackboard.topic.create",
+            "blackboard.message.post",
+            "blackboard.message.list",
+            "blackboard.context.put",
+            "blackboard.artifact.add",
+            "blackboard.artifact.list",
+            "blackboard.snapshot",
+            "coordinator.summary",
+            "coordinator.decision",
+            "audit.verify",
+            "audit.worker",
+            "audit.provenance",
+            "audit.multi-agent",
+            "audit.policy",
+            "audit.role",
+            "audit.blackboard",
+            "audit.judge",
+            "audit.attest",
+            "audit.decision",
+            "sandbox.show",
+            "sandbox.validate",
+            "sandbox.choose",
+            "sandbox.resolve",
+            "backend.show",
+            "backend.probe",
+            "worker.list",
+            "worker.show",
+            "worker.manifest",
+            "worker.output",
+            "worker.fail",
+            "worker.validate",
+            "candidate.list",
+            "candidate.show",
+            "candidate.register",
+            "candidate.score",
+            "candidate.rank",
+            "candidate.select",
+            "candidate.reject",
+            "feedback.list",
+            "feedback.show",
+            "feedback.collect",
+            "feedback.task",
+            "feedback.resolve",
+            "schedule.create",
+            "schedule.list",
+            "schedule.delete",
+            "schedule.due",
+            "schedule.complete",
+            "schedule.pause",
+            "schedule.resume",
+            "schedule.run-now",
+            "schedule.history",
+            "routine.create",
+            "routine.list",
+            "routine.delete",
+            "routine.fire",
+            "routine.events",
+            "registry.refresh",
+            "registry.show",
+            "run.search",
+            "run.list",
+            "run.show",
+            "run.resume",
+            "run.archive",
+            "run.rerun",
+            "run.export",
+            "run.import",
+            "run.verify-import",
+            "run.inspect-archive",
+            "queue.add",
+            "queue.list",
+            "queue.drain",
+            "queue.show",
+            "sched.plan",
+            "sched.lease",
+            "sched.release",
+            "sched.complete",
+            "sched.reclaim",
+            "sched.reset",
+            "sched.policy.show",
+            "sched.policy.set",
+            "telemetry.verify",
+            "history",
+            "approve",
+            "reject",
+            "comment.add",
+            "handoff",
+            "review.policy"
+        ]
+    }
+];
+// ---------------------------------------------------------------------------
 // Derivations + the fail-closed parity report builder.
 // ---------------------------------------------------------------------------
 /** The MCP tool names this registry declares. */
 function declaredMcpTools() {
     return exports.CAPABILITY_REGISTRY.filter((cap) => cap.mcp).map((cap) => cap.mcp.tool);
 }
+/** The descriptor for a registry-declared MCP tool name. */
+function mcpCapabilityForTool(tool) {
+    return exports.CAPABILITY_REGISTRY.find((capability) => capability.mcp?.tool === tool);
+}
+/** The descriptor for a registry-declared capability id. */
+function mcpCapabilityForId(capabilityId) {
+    const descriptor = exports.CAPABILITY_REGISTRY.find((capability) => capability.capability === capabilityId);
+    return descriptor?.mcp ? descriptor : undefined;
+}
+/** Required MCP argument groups for a registry-declared tool. */
+function mcpRequiredArgsForTool(tool) {
+    return mcpCapabilityForTool(tool)?.mcp?.requiredArgs ?? [];
+}
+function mcpToolDefinition(capabilityId, descriptionOrProperties, maybeProperties) {
+    const descriptor = mcpCapabilityForId(capabilityId);
+    if (!descriptor?.mcp)
+        throw new Error(`MCP capability not declared: ${capabilityId}`);
+    const description = typeof descriptionOrProperties === "string" ? descriptionOrProperties : descriptor.summary;
+    const properties = typeof descriptionOrProperties === "string" ? maybeProperties : descriptionOrProperties;
+    if (!properties)
+        throw new Error(`MCP capability ${capabilityId} missing input schema properties.`);
+    return {
+        name: descriptor.mcp.tool,
+        description,
+        inputSchema: {
+            type: "object",
+            properties,
+            additionalProperties: true
+        }
+    };
+}
 /** The CLI `case` tokens this registry declares (deduped). */
 function declaredCliTokens() {
     const tokens = new Set();
@@ -452,6 +691,30 @@ function isPayloadProbeOptOut(cap) {
 function payloadIdenticalCapabilities() {
     return exports.CAPABILITY_REGISTRY.filter((cap) => cap.surface === "both" && cap.cli && cap.mcp && !isPayloadProbeOptOut(cap));
 }
+function payloadProbeTargets() {
+    return [
+        ...GLOBAL_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "global" })),
+        ...RUN_PAYLOAD_PROBE_CAPABILITIES.map((capability) => ({ capability, kind: "run" }))
+    ];
+}
+function deferredPayloadProbeCapabilities() {
+    return PAYLOAD_PROBE_DEFERRED_GROUPS.flatMap((group) => group.capabilities.map((capability) => ({ capability, reason: group.reason })));
+}
+function payloadProbePlan() {
+    const candidateIds = new Set(payloadIdenticalCapabilities().map((cap) => cap.capability));
+    const counts = new Map();
+    const classified = [...payloadProbeTargets().map((entry) => entry.capability), ...deferredPayloadProbeCapabilities().map((entry) => entry.capability)];
+    for (const capability of classified)
+        counts.set(capability, (counts.get(capability) || 0) + 1);
+    const classifiedIds = new Set(classified);
+    return {
+        targets: payloadProbeTargets(),
+        deferred: deferredPayloadProbeCapabilities(),
+        unclassified: [...candidateIds].filter((capability) => !classifiedIds.has(capability)).sort(),
+        duplicateClassifications: [...counts.entries()].filter(([, count]) => count > 1).map(([capability]) => capability).sort(),
+        invalidClassifications: [...classifiedIds].filter((capability) => !candidateIds.has(capability)).sort()
+    };
+}
 function lintRegistry() {
     const issues = [];
     const seenCaps = new Set();
@@ -494,12 +757,16 @@ function buildParityReport(input) {
     const reasonlessExceptions = exports.CAPABILITY_REGISTRY.filter((cap) => requiresReason(cap) && !(cap.reason && cap.reason.trim()))
         .map((cap) => cap.capability)
         .sort();
+    const payloadPlan = payloadProbePlan();
     const registryLint = lintRegistry();
     const ok = missingMcpTools.length === 0 &&
         undeclaredMcpTools.length === 0 &&
         missingCliTokens.length === 0 &&
         undeclaredCliTokens.length === 0 &&
         reasonlessExceptions.length === 0 &&
+        payloadPlan.unclassified.length === 0 &&
+        payloadPlan.duplicateClassifications.length === 0 &&
+        payloadPlan.invalidClassifications.length === 0 &&
         registryLint.length === 0;
     return {
         ok,
@@ -509,6 +776,9 @@ function buildParityReport(input) {
         missingCliTokens,
         undeclaredCliTokens,
         reasonlessExceptions,
+        payloadProbeUnclassified: payloadPlan.unclassified,
+        payloadProbeDuplicateClassifications: payloadPlan.duplicateClassifications,
+        payloadProbeInvalidClassifications: payloadPlan.invalidClassifications,
         registryLint
     };
 }