cool-workflow 0.1.98 → 0.2.1

package/dist/shell/workbench-text.js

@@ -0,0 +1,18 @@
+"use strict";
+// shell/workbench-text.ts — human text for `cw workbench view`. Byte-
+// exact port of the old build's src/cli/format.ts's formatWorkbenchView.
+//
+// MILESTONE 11 (reporting/observability).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWorkbenchView = formatWorkbenchView;
+function formatWorkbenchView(view) {
+    const lines = [`Workbench view ${view.runId} (${view.resolved ? "resolved" : "UNRESOLVED"})`, view.error ? `  error: ${view.error}` : ""].filter(Boolean);
+    for (const [group, panels] of Object.entries(view.panels)) {
+        lines.push(`  ${group}:`);
+        for (const [name, panel] of Object.entries(panels)) {
+            const note = panel.status === "present" ? panel.capability : `absent (${panel.error || "unreadable"})`;
+            lines.push(`    ${name}: ${panel.status} — ${note}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/shell/workbench.js

@@ -0,0 +1,170 @@
+"use strict";
+// shell/workbench.ts — the read-only Workbench view: `cw workbench view`
+// (five-panel JSON view of one run) and the serve descriptor.
+//
+// MILESTONE 11 (reporting/observability). Byte-exact port of the panel
+// group/member shape from the old build's src/workbench.ts. Each panel
+// embeds the SAME payload as the matching `cw <cmd> --json` call — built
+// here by calling the matching capability's own MCP handler in-process
+// (never a duplicate implementation), so panel data can never drift from
+// the standalone command's output.
+//
+// Evidence: SPEC/reporting-ux.md "Workbench" (panel groups/members,
+// serve descriptor, fail-closed-but-honest unresolved-run shape),
+// invariant 11 (workbench is read-only and fails closed).
+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.WORKBENCH_UI_RELATIVE = exports.WORKBENCH_DEFAULT_PORT = void 0;
+exports.buildWorkbenchRunView = buildWorkbenchRunView;
+exports.workbenchUiRoot = workbenchUiRoot;
+exports.buildWorkbenchServeDescriptor = buildWorkbenchServeDescriptor;
+exports.buildWorkbenchIndex = buildWorkbenchIndex;
+const path = __importStar(require("node:path"));
+const capability_table_1 = require("../core/capability-table");
+const run_store_1 = require("./run-store");
+exports.WORKBENCH_DEFAULT_PORT = 7717;
+exports.WORKBENCH_UI_RELATIVE = "ui/workbench";
+/** Panel groups/members, in the SPEC's declared order. Each entry names
+ *  the capability id whose MCP handler is called to fill the panel. */
+const PANEL_MAP = {
+    graph: { operator: "graph", multiAgent: "multi-agent.graph", compact: "summary.show", criticalPath: "summary.show" },
+    blackboard: { coordinator: "coordinator.summary", digest: "blackboard.summary", graph: "blackboard.graph" },
+    worker: { summary: "worker.summary" },
+    candidate: { summary: "candidate.summary", reasoning: "candidate.summary" },
+    metrics: { report: "metrics.show" },
+    audit: { summary: "audit.summary", multiAgent: "audit.multi-agent", policy: "audit.policy", judge: "audit.judge" },
+    collaboration: { review: "review.status", comments: "comment.list" },
+};
+function cliCommandFor(capability) {
+    const row = (0, capability_table_1.findCapability)(capability);
+    return row?.cli ? `cw ${row.cli.path.join(" ")}` : `cw ${capability.replace(/\./g, " ")}`;
+}
+function mcpToolFor(capability) {
+    const row = (0, capability_table_1.findCapability)(capability);
+    return row?.mcp?.tool || `cw_${capability.replace(/\./g, "_")}`;
+}
+function buildPanel(capability, args) {
+    const cli = cliCommandFor(capability);
+    const mcp = mcpToolFor(capability);
+    const row = (0, capability_table_1.findCapability)(capability);
+    if (!row || !row.mcp) {
+        return { capability, cli, mcp, status: "absent", error: `capability not available: ${capability}` };
+    }
+    try {
+        const data = row.mcp.handler(args);
+        return { capability, cli, mcp, status: "present", data };
+    }
+    catch (error) {
+        return { capability, cli, mcp, status: "absent", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** `cw workbench view <run-id>` — read-only, never throws: an
+ *  unresolvable run gives `resolved:false` and every panel `absent` with
+ *  the real error, never a fabricated view. */
+function buildWorkbenchRunView(runId, args = {}) {
+    const cwd = typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
+    let resolved = true;
+    let resolveError;
+    try {
+        (0, run_store_1.loadRunFromCwd)(runId, cwd);
+    }
+    catch (error) {
+        resolved = false;
+        resolveError = error instanceof Error ? error.message : String(error);
+    }
+    const panels = {};
+    const panelArgs = { ...args, runId, cwd };
+    for (const [group, members] of Object.entries(PANEL_MAP)) {
+        panels[group] = {};
+        for (const [member, capability] of Object.entries(members)) {
+            panels[group][member] = resolved
+                ? buildPanel(capability, panelArgs)
+                : { capability, cli: cliCommandFor(capability), mcp: mcpToolFor(capability), status: "absent", error: resolveError };
+        }
+    }
+    return { schemaVersion: 1, surface: "workbench", runId, resolved, ...(resolveError ? { error: resolveError } : {}), panels };
+}
+/** Package-relative resolution only — never falls back to the invocation
+ *  cwd. `ui/` ships as a sibling of `dist/` in the published package
+ *  (package.json's `files`), so from `dist/shell/workbench.js` the fixed
+ *  path is two levels up. Matches the existing precedent in
+ *  execution-backend/agent.ts's BATCH_DELEGATE_CHILD_SCRIPT resolution. */
+function workbenchUiRoot() {
+    return path.resolve(__dirname, "..", "..", exports.WORKBENCH_UI_RELATIVE);
+}
+const WORKBENCH_ROUTES = [
+    { method: "GET", path: "/", description: "Index page (or the UI's index.html, when installed)." },
+    { method: "GET", path: "/ui/*", description: "Static Workbench UI assets, when installed." },
+    { method: "GET", path: "/api/index", description: "Read-only index of available runs." },
+    { method: "GET", path: "/api/serve", description: "This serve descriptor." },
+    { method: "GET", path: "/api/run/:runId", description: "The five-panel WorkbenchRunView for one run." },
+];
+/** `cw workbench serve [--port N] [--once] [--scope repo|home]` — the
+ *  serve descriptor. Building this never starts a listener; the caller
+ *  (shell/workbench-host.ts's `run()`) decides whether to actually bind. */
+function buildWorkbenchServeDescriptor(args = {}, boundPort) {
+    const cwd = typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
+    const uiRoot = workbenchUiRoot();
+    const fs = require("node:fs");
+    return {
+        schemaVersion: 1,
+        surface: "workbench",
+        command: "serve",
+        host: "127.0.0.1",
+        port: boundPort ?? (args.port !== undefined ? Number(args.port) : exports.WORKBENCH_DEFAULT_PORT),
+        once: Boolean(args.once),
+        readOnly: true,
+        scope: args.scope === "home" ? "home" : "repo",
+        root: cwd,
+        uiAvailable: fs.existsSync(uiRoot),
+        uiRoot,
+        routes: WORKBENCH_ROUTES,
+    };
+}
+/** The cross-run index (old build's src/workbench.ts buildWorkbenchIndex):
+ *  the registry index (`cw registry show`) plus the run list (`cw run
+ *  list`), each embedded VERBATIM from its own already-declared capability
+ *  handler — the Workbench adds no new source of truth. Composed the same
+ *  way the panels are (findCapability(...).mcp.handler), so `/api/index`
+ *  can never drift from the standalone `cw` commands. Read-only. */
+function buildWorkbenchIndex(args = {}) {
+    const scope = args.scope === "home" ? "home" : "repo";
+    const scoped = { ...args, scope };
+    const registryRow = (0, capability_table_1.findCapability)("registry.show");
+    const runListRow = (0, capability_table_1.findCapability)("run.list");
+    const registry = registryRow?.mcp ? registryRow.mcp.handler(scoped) : undefined;
+    const runs = runListRow?.mcp ? runListRow.mcp.handler(scoped) : [];
+    return { schemaVersion: 1, surface: "workbench", command: "index", scope, registry, runs };
+}

package/dist/shell/worker-cli.js

@@ -0,0 +1,124 @@
+"use strict";
+// shell/worker-cli.ts — `cw worker list|show|manifest|output|fail|validate`
+// (and the mirrored cw_worker_* MCP tools) handler bodies. Byte-exact behavior
+// port of the old build's src/cli/handlers/worker.ts routing into the
+// worker-isolation shell. Impure: loads run state, mutates, persists.
+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.workerListCli = workerListCli;
+exports.workerShowCli = workerShowCli;
+exports.workerManifestCli = workerManifestCli;
+exports.workerOutputCli = workerOutputCli;
+exports.workerFailCli = workerFailCli;
+exports.workerValidateCli = workerValidateCli;
+const path = __importStar(require("node:path"));
+const run_store_1 = require("./run-store");
+const worker_isolation_1 = require("./worker-isolation");
+const dispatch_1 = require("../core/pipeline/dispatch");
+const drive_1 = require("./drive");
+const commit_1 = require("./commit");
+const report_1 = require("./report");
+const operator_ux_1 = require("./operator-ux");
+function cwdFor(args) {
+    return typeof args.cwd === "string" && args.cwd.trim() ? path.resolve(args.cwd) : process.cwd();
+}
+function req(value, label) {
+    const s = value === undefined || value === null ? "" : String(value);
+    if (!s)
+        throw new Error(`Missing ${label}`);
+    return s;
+}
+function workerListCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    return (0, worker_isolation_1.listWorkerScopes)(run, { status: typeof args.status === "string" ? args.status : undefined });
+}
+function workerShowCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    const scope = (0, worker_isolation_1.getWorkerScope)(run, req(args.workerId, "worker id"));
+    if (!scope)
+        throw new Error(`Unknown worker for run ${run.id}: ${args.workerId}`);
+    return scope;
+}
+function workerManifestCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    const scope = (0, worker_isolation_1.getWorkerScope)(run, req(args.workerId, "worker id"));
+    if (!scope)
+        throw new Error(`Unknown worker for run ${run.id}: ${args.workerId}`);
+    const manifest = (0, worker_isolation_1.writeWorkerManifest)(run, scope);
+    (0, run_store_1.saveCheckpoint)(run);
+    return manifest;
+}
+/** `cw worker output <run> <worker> <result>` — records the worker's result
+ *  and returns the full RunSummary, a byte-behavior port of the old build's
+ *  orchestrator recordWorkerOutput wrapper (lifecycle-operations.ts). The bare
+ *  accept (worker-isolation.recordWorkerOutput) only mutates the worker/task;
+ *  the operator-facing verb ALSO advances the run: loopStage -> observe, refresh
+ *  phase statuses, expand a bounded loop round if one is ready, commit the
+ *  accept as its own `worker:<id>:result` checkpoint, and write the report.
+ *  Callers (pdca / run-export / the golden-path smoke) read the RunSummary's
+ *  tasks.completed, workers.byStatus, and loopStage. The drive loop does these
+ *  same steps itself around the bare accept, so it never routes through here. */
+function workerOutputCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    (0, worker_isolation_1.recordWorkerOutput)(run, req(args.workerId, "worker id"), req(args.resultPath, "result file"), {});
+    run.loopStage = "observe";
+    (0, dispatch_1.updatePhaseStatuses)(run);
+    (0, drive_1.maybeExpandLoop)(run);
+    (0, commit_1.commitState)(run, `worker:${req(args.workerId, "worker id")}:result`);
+    (0, report_1.writeReport)(run);
+    (0, run_store_1.saveCheckpoint)(run);
+    return (0, operator_ux_1.summarizeRun)(run);
+}
+function workerFailCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    const message = String(args.message || req(args.resultPath, "failure message"));
+    const scope = (0, worker_isolation_1.recordWorkerFailure)(run, req(args.workerId, "worker id"), message, {
+        code: typeof args.code === "string" ? args.code : undefined,
+        path: typeof args.path === "string" ? args.path : undefined,
+        retryable: args.retryable !== undefined ? Boolean(args.retryable) : undefined,
+    });
+    (0, run_store_1.saveCheckpoint)(run);
+    return scope;
+}
+/** validate returns the boundary violation (null when the write path is
+ *  allowed) and signals a violation through a non-zero exit code, not just
+ *  stdout — a validate verb must report an invalid verdict via its exit code. */
+function workerValidateCli(args) {
+    const run = (0, run_store_1.loadRunFromCwd)(req(args.runId, "run id"), cwdFor(args));
+    const target = args.path || args.resultPath;
+    const violation = (0, worker_isolation_1.validateWorkerBoundary)(run, req(args.workerId, "worker id"), target ? { path: String(target) } : {});
+    (0, run_store_1.saveCheckpoint)(run);
+    return { violation, exitCode: violation ? 1 : undefined };
+}