cool-workflow 0.1.78

package/manifest/plugin.manifest.json

@@ -0,0 +1,316 @@
+{
+  "_comment": "SINGLE SOURCE OF TRUTH for every vendor manifest. Edit THIS file, then run `npm run gen:manifests`. Do NOT hand-edit the generated vendor manifests (.claude-plugin/, .codex-plugin/, .agents/, .mcp.json) — `npm run gen:manifests -- --check` (run by release:check) will fail if they drift from this source.",
+  "identity": {
+    "name": "cool-workflow",
+    "version": "0.1.78",
+    "license": "BSD-2-Clause",
+    "homepage": "https://github.com/coo1white/cool-workflow",
+    "author": {
+      "name": "COOLWHITE LLC"
+    },
+    "keywords": [
+      "workflow",
+      "control-plane",
+      "dynamic-workflows",
+      "subagents",
+      "orchestration",
+      "agents",
+      "multi-agent",
+      "mcp"
+    ]
+  },
+  "descriptions": {
+    "short": "Auditable workflow control-plane.",
+    "standard": "Auditable workflow control-plane and orchestration runtime: TypeScript dispatch, evidence-gated verification, state commits, scheduling, routines, multi-agent coordination, and MCP. Delegates execution to external agents — never runs models.",
+    "long": "Cool Workflow (CW) is an auditable workflow control-plane and orchestration runtime. It provides a TypeScript COL runtime, Workflow App framework contracts, Router/Orchestrator, Subagent Dispatch, Deterministic Harness, Adversarial Verifier, Git/State Commit, Sandbox Profiles, scheduled tasks, routine triggers, a high-level Multi-Agent CLI/MCP host surface, and an MCP JSON-RPC 2.0 bridge. Developers write reusable workflow apps; CW delegates execution to an external agent host and records verified, replayable state — it never embeds a model API."
+  },
+  "interface": {
+    "displayName": "Cool Workflow",
+    "category": "Productivity",
+    "capabilities": [
+      "Interactive",
+      "Read",
+      "Write"
+    ],
+    "brandColor": "#2563EB",
+    "defaultPrompt": [
+      "Use Cool Workflow to plan this as phases and agents.",
+      "Run the architecture review workflow with CW.",
+      "Create a reusable CW workflow for this task."
+    ]
+  },
+  "layout": {
+    "pluginPathFromRepoRoot": "./plugins/cool-workflow",
+    "skillsDir": "./skills/",
+    "mcpServerScript": "dist/mcp-server.js"
+  },
+  "mcp": {
+    "serverName": "cool-workflow",
+    "command": "node"
+  },
+  "targets": {
+    "claude": {
+      "marketplace": ".claude-plugin/marketplace.json",
+      "plugin": "plugins/cool-workflow/.claude-plugin/plugin.json",
+      "mcp": "plugins/cool-workflow/.mcp.json",
+      "pluginRootVar": "${CLAUDE_PLUGIN_ROOT}/"
+    },
+    "codex": {
+      "marketplace": ".agents/plugins/marketplace.json",
+      "plugin": "plugins/cool-workflow/.codex-plugin/plugin.json",
+      "mcp": "plugins/cool-workflow/.codex-plugin/mcp.json",
+      "pluginRootVar": "./"
+    },
+    "agents": {
+      "plugin": ".agents/plugins/cool-workflow/plugin.json",
+      "mcp": ".agents/plugins/cool-workflow/mcp.json",
+      "pluginRootVar": "./"
+    },
+    "gemini": {
+      "plugin": "plugins/cool-workflow/.gemini-plugin/plugin.json",
+      "mcp": "plugins/cool-workflow/.gemini-plugin/mcp.json",
+      "pluginRootVar": "./"
+    },
+    "opencode": {
+      "plugin": "plugins/cool-workflow/.opencode-plugin/plugin.json",
+      "mcp": "plugins/cool-workflow/.opencode-plugin/mcp.json",
+      "pluginRootVar": "./"
+    }
+  },
+  "_comment_vendors": "VENDOR ADAPTER REGISTRY (v0.1.47). Each vendor declares its outputs as templates over the source fields above. Adding a new AI platform: add ONE entry here — no gen-manifests.js changes needed. Templates use {{path.to.field}} interpolation; {{pluginRootVar}} resolves to the vendor's pluginRootVar.",
+  "vendors": {
+    "claude": {
+      "outputs": [
+        {
+          "path": "{{targets.claude.marketplace}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "owner": "{{identity.author}}",
+            "metadata": {
+              "description": "{{descriptions.standard}}",
+              "version": "{{identity.version}}"
+            },
+            "plugins": [
+              {
+                "name": "{{identity.name}}",
+                "source": "{{layout.pluginPathFromRepoRoot}}",
+                "description": "{{descriptions.standard}}",
+                "category": "{{interface.category|lowercase}}"
+              }
+            ]
+          }
+        },
+        {
+          "path": "{{targets.claude.plugin}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "description": "{{descriptions.standard}}",
+            "version": "{{identity.version}}",
+            "author": "{{identity.author}}",
+            "homepage": "{{identity.homepage}}",
+            "license": "{{identity.license}}",
+            "keywords": "{{identity.keywords}}"
+          }
+        },
+        {
+          "path": "{{targets.claude.mcp}}",
+          "json": {
+            "mcpServers": {
+              "{{mcp.serverName}}": {
+                "command": "{{mcp.command}}",
+                "args": [
+                  "{{pluginRootVar}}{{layout.mcpServerScript}}"
+                ]
+              }
+            }
+          }
+        }
+      ]
+    },
+    "codex": {
+      "outputs": [
+        {
+          "path": "{{targets.codex.marketplace}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "interface": {
+              "displayName": "{{interface.displayName}}"
+            },
+            "plugins": [
+              {
+                "name": "{{identity.name}}",
+                "source": {
+                  "source": "local",
+                  "path": "{{layout.pluginPathFromRepoRoot}}"
+                },
+                "policy": {
+                  "installation": "AVAILABLE",
+                  "authentication": "ON_INSTALL"
+                },
+                "category": "{{interface.category}}"
+              }
+            ]
+          }
+        },
+        {
+          "path": "{{targets.codex.plugin}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "version": "{{identity.version}}",
+            "description": "{{descriptions.standard}}",
+            "author": "{{identity.author}}",
+            "keywords": "{{identity.keywords}}",
+            "skills": "{{layout.skillsDir}}",
+            "mcpServers": "./.codex-plugin/mcp.json",
+            "interface": {
+              "displayName": "{{interface.displayName}}",
+              "shortDescription": "{{descriptions.short}}",
+              "longDescription": "{{descriptions.long}}",
+              "developerName": "{{identity.author.name}}",
+              "category": "{{interface.category}}",
+              "capabilities": "{{interface.capabilities}}",
+              "brandColor": "{{interface.brandColor}}",
+              "defaultPrompt": "{{interface.defaultPrompt}}"
+            }
+          }
+        },
+        {
+          "path": "{{targets.codex.mcp}}",
+          "json": {
+            "mcpServers": {
+              "{{mcp.serverName}}": {
+                "command": "{{mcp.command}}",
+                "args": [
+                  "{{pluginRootVar}}{{layout.mcpServerScript}}"
+                ]
+              }
+            }
+          }
+        }
+      ]
+    },
+    "agents": {
+      "outputs": [
+        {
+          "path": "{{targets.agents.plugin}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "description": "{{descriptions.standard}}",
+            "version": "{{identity.version}}",
+            "author": "{{identity.author}}",
+            "homepage": "{{identity.homepage}}",
+            "license": "{{identity.license}}",
+            "keywords": "{{identity.keywords}}",
+            "skills": "{{layout.skillsDir}}",
+            "mcpServers": "./.codex-plugin/mcp.json",
+            "interface": {
+              "displayName": "{{interface.displayName}}",
+              "shortDescription": "{{descriptions.short}}",
+              "longDescription": "{{descriptions.long}}",
+              "developerName": "{{identity.author.name}}",
+              "category": "{{interface.category}}",
+              "capabilities": "{{interface.capabilities}}",
+              "brandColor": "{{interface.brandColor}}",
+              "defaultPrompt": "{{interface.defaultPrompt}}"
+            }
+          }
+        },
+        {
+          "path": "{{targets.agents.mcp}}",
+          "json": {
+            "mcpServers": {
+              "{{mcp.serverName}}": {
+                "command": "{{mcp.command}}",
+                "args": [
+                  "{{pluginRootVar}}{{layout.mcpServerScript}}"
+                ]
+              }
+            }
+          }
+        }
+      ]
+    },
+    "gemini": {
+      "outputs": [
+        {
+          "path": "{{targets.gemini.plugin}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "description": "{{descriptions.standard}}",
+            "version": "{{identity.version}}",
+            "author": "{{identity.author}}",
+            "homepage": "{{identity.homepage}}",
+            "license": "{{identity.license}}",
+            "keywords": "{{identity.keywords}}",
+            "skills": "{{layout.skillsDir}}",
+            "mcpServers": "./.gemini-plugin/mcp.json",
+            "interface": {
+              "displayName": "{{interface.displayName}}",
+              "shortDescription": "{{descriptions.short}}",
+              "longDescription": "{{descriptions.long}}",
+              "developerName": "{{identity.author.name}}",
+              "category": "{{interface.category}}",
+              "capabilities": "{{interface.capabilities}}",
+              "brandColor": "{{interface.brandColor}}",
+              "defaultPrompt": "{{interface.defaultPrompt}}"
+            }
+          }
+        },
+        {
+          "path": "{{targets.gemini.mcp}}",
+          "json": {
+            "mcpServers": {
+              "{{mcp.serverName}}": {
+                "command": "{{mcp.command}}",
+                "args": [
+                  "{{pluginRootVar}}{{layout.mcpServerScript}}"
+                ]
+              }
+            }
+          }
+        }
+      ]
+    },
+    "opencode": {
+      "outputs": [
+        {
+          "path": "{{targets.opencode.plugin}}",
+          "json": {
+            "name": "{{identity.name}}",
+            "description": "{{descriptions.standard}}",
+            "version": "{{identity.version}}",
+            "author": "{{identity.author}}",
+            "homepage": "{{identity.homepage}}",
+            "license": "{{identity.license}}",
+            "keywords": "{{identity.keywords}}",
+            "skills": "{{layout.skillsDir}}",
+            "mcpServers": "./.opencode-plugin/mcp.json",
+            "interface": {
+              "displayName": "{{interface.displayName}}",
+              "shortDescription": "{{descriptions.short}}",
+              "longDescription": "{{descriptions.long}}",
+              "developerName": "{{identity.author.name}}",
+              "category": "{{interface.category}}",
+              "capabilities": "{{interface.capabilities}}",
+              "brandColor": "{{interface.brandColor}}",
+              "defaultPrompt": "{{interface.defaultPrompt}}"
+            }
+          }
+        },
+        {
+          "path": "{{targets.opencode.mcp}}",
+          "json": {
+            "mcpServers": {
+              "{{mcp.serverName}}": {
+                "command": "{{mcp.command}}",
+                "args": [
+                  "{{pluginRootVar}}{{layout.mcpServerScript}}"
+                ]
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+}

package/manifest/pricing.policy.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "id": "bundled-example-v1",
+  "currency": "USD",
+  "source": "Bundled EXAMPLE pricing policy (data, not kernel). Prices are USD per 1e6 tokens and are an editable starting point, NOT a live price feed. Copy this file, edit the numbers for your contract, and pass it with `--pricing <path>` to override. When no policy is supplied at all, cost is reported `unreported`/`unpriced`, never guessed.",
+  "models": [
+    { "model": "claude-opus-4-8", "inputPerMillion": 15, "outputPerMillion": 75 },
+    { "model": "claude-opus-4-1", "inputPerMillion": 15, "outputPerMillion": 75 },
+    { "model": "claude-sonnet-4-6", "inputPerMillion": 3, "outputPerMillion": 15 },
+    { "model": "claude-sonnet-4-5", "inputPerMillion": 3, "outputPerMillion": 15 },
+    { "model": "claude-haiku-4-5", "inputPerMillion": 1, "outputPerMillion": 5 }
+  ],
+  "defaultPrice": { "inputPerMillion": 3, "outputPerMillion": 15 }
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "cool-workflow",
+  "version": "0.1.78",
+  "bin": {
+    "cool-workflow": "scripts/cw.js",
+    "cw": "scripts/cw.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coo1white/cool-workflow.git",
+    "directory": "plugins/cool-workflow"
+  },
+  "homepage": "https://github.com/coo1white/cool-workflow#readme",
+  "bugs": {
+    "url": "https://github.com/coo1white/cool-workflow/issues"
+  },
+  "description": "Auditable workflow control-plane and orchestration runtime: TypeScript dispatch, evidence-gated verification, state commits, scheduling, routines, multi-agent coordination, and MCP. Delegates execution to external agents — never runs models.",
+  "type": "commonjs",
+  "license": "BSD-2-Clause",
+  "author": {
+    "name": "COOLWHITE LLC"
+  },
+  "files": [
+    ".claude-plugin/",
+    ".codex-plugin/",
+    ".mcp.json",
+    "manifest/",
+    "README.md",
+    "apps/",
+    "dist/",
+    "docs/",
+    "scripts/",
+    "skills/",
+    "ui/",
+    "workflows/",
+    "package.json",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "dist:check": "node scripts/dist-drift-check.js",
+    "golden-path": "node scripts/golden-path.js",
+    "dogfood:release": "node scripts/dogfood-release.js",
+    "canonical-apps": "node scripts/canonical-apps.js",
+    "fixture-compat": "node test/run-fixture-compat-smoke.js",
+    "sync:project-index": "node scripts/sync-project-index.js",
+    "index:check": "node scripts/sync-project-index.js --check",
+    "bump:version": "node scripts/bump-version.js",
+    "new:feature": "node scripts/new-feature.js",
+    "forward-ref": "node scripts/forward-ref-docs.js",
+    "verify:container": "node scripts/verify-container-selfref.js",
+    "gen:manifests": "node scripts/gen-manifests.js",
+    "parity:check": "node scripts/parity-check.js --check",
+    "version:sync": "node scripts/version-sync-check.js",
+    "release:check": "node scripts/release-check.js",
+    "test": "node dist/cli.js list && node test/run-all.js",
+    "test:fast": "npm run build --if-present && node dist/cli.js list && node test/run-all.js --concurrency auto",
+    "eval:replay": "tsc -p tsconfig.json && node test/multi-agent-eval-replay-harness-smoke.js",
+    "ci": "npm run build && npm run check && npm run test && npm run release:check",
+    "validate:schema": "node scripts/validate-run-state-schema.js"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  },
+  "keywords": [
+    "agent",
+    "workflow",
+    "control-plane",
+    "mcp",
+    "multi-agent",
+    "orchestration",
+    "audit",
+    "llm-pipeline",
+    "claude",
+    "delegation"
+  ]
+}

package/scripts/agents/claude-p-agent.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+"use strict";
+
+// claude-p-agent.js — EXAMPLE operator agent config for CW Agent Delegation Drive.
+//
+// This is a CONFIG, NOT a CW dependency: CW spawns it out-of-process (argv-style,
+// shell:false, cwd = the target repo) and records its attested output; the model
+// runs in claude's process, never in CW. Node port of claude-p-agent.sh (which now
+// delegates here) so the documented onboarding path is portable (node-only repo
+// convention, Windows included).
+//
+// It fulfills ONE worker: read the worker's input.md ({{input}}), delegate the
+// analysis to headless claude READ-ONLY, persist claude's final markdown to the
+// worker's result.md ({{result}}), and forward claude's JSON (model + usage) on
+// stdout so CW records the agent-REPORTED model and token usage as provenance.
+//
+// READ-ONLY by design: claude gets NO Write tool. The architecture-review app
+// declares the `readonly` sandbox profile — the agent must not touch the repo.
+// This wrapper (the transport) writes the single result.md artifact itself, so
+// the worker completes WITHOUT granting the model file-write access.
+//
+// Point CW at it (from plugins/cool-workflow/):
+//   CW_AGENT_COMMAND="node $(pwd)/scripts/agents/claude-p-agent.js {{input}} {{result}}"
+// or per-invocation:
+//   --agent-command "node $(pwd)/scripts/agents/claude-p-agent.js {{input}} {{result}}"
+
+const fs = require("node:fs");
+const { spawnSync } = require("node:child_process");
+
+const inputPath = process.argv[2];
+const resultPath = process.argv[3];
+if (!inputPath || !resultPath) {
+  process.stderr.write("usage: claude-p-agent.js <inputPath> <resultPath>  (CW substitutes {{input}} {{result}})\n");
+  process.exit(2);
+}
+
+const CONTRACT = `
+=== HOW TO RETURN YOUR ANSWER (overrides any 'write to result.md' instruction above) ===
+You have NO file-write access. Do NOT attempt to write, create, or edit any file —
+result.md is persisted FOR YOU from your final message, so writing it yourself is
+neither needed nor possible. Use ONLY read-only tools (read files, grep, list).
+Respond with ONLY your FINAL answer as Markdown, and it MUST END WITH a fenced
+cw:result block that EXACTLY follows this schema:
+
+\`\`\`cw:result
+{
+  "summary": "one-paragraph direct answer",
+  "findings": [
+    {
+      "id": "unique-kebab-id",
+      "title": "short risk title",
+      "severity": "P0",
+      "classification": "real",
+      "evidence": ["path/to/file.ts:42"]
+    }
+  ],
+  "evidence": ["path/to/file.ts:42", "path/to/other.ts:10"]
+}
+\`\`\`
+
+HARD RULES (the result is REJECTED otherwise):
+- Every object in "findings" MUST have a unique "id" (non-empty string).
+- "classification", if present, MUST be one of: real, conditional, non-issue, unknown.
+- Any finding with "severity" P0, P1, or P2 MUST include a NON-EMPTY "evidence" array.
+- The top-level "evidence" array MUST be NON-EMPTY with REAL file:line locators from this repo.
+- If you have no structured findings, use "findings": [] (empty) — never omit a finding's id.
+`;
+
+const prompt = `${fs.readFileSync(inputPath, "utf8")}\n${CONTRACT}`;
+
+// Read-only analysis: NO Write tool, so claude cannot touch the repo. This wrapper
+// (the transport) persists claude's final markdown to the worker's result.md.
+// --output-format json so CW can read the agent-REPORTED model + usage from stdout
+// (the attested model; CW never uses CW_AGENT_MODEL as the attested model).
+const child = spawnSync("claude", ["-p", prompt, "--output-format", "json", "--allowedTools", "Read,Grep,Glob,Bash"], {
+  encoding: "utf8",
+  maxBuffer: 32 * 1024 * 1024,
+  shell: false
+});
+if (child.error) {
+  process.stderr.write(`claude spawn failed: ${child.error.message}\n`);
+  process.exit(1);
+}
+if (child.status !== 0) {
+  process.stderr.write(String(child.stderr || `claude exited ${child.status}`));
+  process.exit(child.status === null ? 1 : child.status);
+}
+
+const out = String(child.stdout || "");
+let parsed;
+try {
+  parsed = JSON.parse(out);
+} catch (error) {
+  // Fail closed: no parsable agent JSON ⇒ no result.md ⇒ CW records a failed hop.
+  process.stderr.write(`claude output was not JSON: ${error.message}\n`);
+  process.exit(1);
+}
+
+// Persist the AGENT's final markdown to the worker's result.md for CW's separate
+// acceptance layer. CW is only the transport; the content is the agent's.
+fs.writeFileSync(resultPath, String(parsed.result || ""), "utf8");
+
+// Hand the agent's JSON (model + usage + result) back to CW on stdout.
+process.stdout.write(out);

package/scripts/agents/claude-p-agent.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# EXAMPLE operator agent config for CW Agent Delegation Drive — bash entry point.
+#
+# The single source of truth is claude-p-agent.js (the portable node version);
+# this shim only delegates so the two can never drift. Point CW at either:
+#   CW_AGENT_COMMAND="node $(pwd)/scripts/agents/claude-p-agent.js {{input}} {{result}}"
+#   CW_AGENT_COMMAND="bash $(pwd)/scripts/agents/claude-p-agent.sh {{input}} {{result}}"
+set -euo pipefail
+exec node "$(dirname "$0")/claude-p-agent.js" "$@"

package/scripts/agents/cw-attest-keygen.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"use strict";
+
+// cw-attest-keygen (Track 1) — generate the ed25519 keypair for telemetry
+// attestation. The PRIVATE key stays with the executor/signing wrapper
+// (CW_AGENT_ATTEST_PRIVKEY); the PUBLIC key is handed to CW to VERIFY with
+// (CW_AGENT_ATTEST_PUBKEY / agent attestPublicKey). CW never holds the private
+// half — it can verify attribution but never forge a signature.
+//
+// Usage:
+//   node cw-attest-keygen.js [--out-dir DIR]   # writes cw-attest.key + cw-attest.pub
+//   node cw-attest-keygen.js --print           # print both PEMs to stdout, write nothing
+
+const fs = require("node:fs");
+const crypto = require("node:crypto");
+const path = require("node:path");
+
+function arg(name, fallback) {
+  const i = process.argv.indexOf(name);
+  return i >= 0 ? process.argv[i + 1] : fallback;
+}
+
+const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+const privatePem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+const publicPem = publicKey.export({ type: "spki", format: "pem" }).toString();
+
+if (process.argv.includes("--print")) {
+  process.stdout.write(`# PRIVATE (executor / wrapper — CW_AGENT_ATTEST_PRIVKEY)\n${privatePem}\n# PUBLIC (CW verify — CW_AGENT_ATTEST_PUBKEY)\n${publicPem}\n`);
+  process.exit(0);
+}
+
+const outDir = path.resolve(arg("--out-dir", process.cwd()));
+const keyPath = path.join(outDir, "cw-attest.key");
+const pubPath = path.join(outDir, "cw-attest.pub");
+fs.mkdirSync(outDir, { recursive: true });
+// Private key: owner-only perms (0600). It is NEVER committed to .cw/ or config.
+fs.writeFileSync(keyPath, privatePem, { mode: 0o600 });
+fs.writeFileSync(pubPath, publicPem);
+
+process.stdout.write(
+  [
+    `Wrote ed25519 keypair:`,
+    `  private (executor):  ${keyPath}   (chmod 0600)`,
+    `  public  (CW verify): ${pubPath}`,
+    ``,
+    `Executor / signing wrapper:`,
+    `  export CW_AGENT_ATTEST_PRIVKEY="${keyPath}"`,
+    ``,
+    `CW (verify side):`,
+    `  export CW_AGENT_ATTEST_PUBKEY="${pubPath}"`,
+    ``,
+    `Keep the PRIVATE key off any committed state. CW only needs the PUBLIC key.`,
+    ``
+  ].join("\n")
+);