cool-workflow 0.1.91 → 0.1.93

package/dist/orchestrator/app-operations.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadWorkflowFiles = loadWorkflowFiles;
+exports.loadAppManifestFiles = loadAppManifestFiles;
+exports.loadWorkflowApps = loadWorkflowApps;
+exports.loadWorkflowAppById = loadWorkflowAppById;
+exports.loadWorkflowAppTarget = loadWorkflowAppTarget;
+exports.listWorkflows = listWorkflows;
+exports.listApps = listApps;
+exports.showApp = showApp;
+exports.validateApp = validateApp;
+exports.initApp = initApp;
+exports.packageApp = packageApp;
+// Workflow-app management domain operations (v0.1.40 self-audit router pattern).
+// Carved out of CoolWorkflowRunner; pure functions (no instance state). Behavior
+// is identical to the inline versions — the runner-owned calls (resolveFromBase,
+// validateApp) are passed as callbacks so the bodies stay byte-identical.
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const workflow_api_1 = require("../workflow-api");
+const state_1 = require("../state");
+const workflow_app_framework_1 = require("../workflow-app-framework");
+const cli_options_1 = require("./cli-options");
+function loadWorkflowFiles(workflowsDir) {
+    if (!node_fs_1.default.existsSync(workflowsDir))
+        return [];
+    return node_fs_1.default
+        .readdirSync(workflowsDir)
+        .filter((file) => file.endsWith(".workflow.js"))
+        .sort()
+        .map((file) => node_path_1.default.join(workflowsDir, file));
+}
+function loadAppManifestFiles(appsDir) {
+    if (!node_fs_1.default.existsSync(appsDir))
+        return [];
+    return node_fs_1.default
+        .readdirSync(appsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => node_path_1.default.join(appsDir, entry.name, "app.json"))
+        .filter((file) => node_fs_1.default.existsSync(file))
+        .sort();
+}
+function loadWorkflowApps(workflowsDir, appsDir) {
+    const records = [
+        ...loadWorkflowFiles(workflowsDir).map((file) => (0, workflow_app_framework_1.loadWorkflowAppFromEntrypoint)(file)),
+        ...loadAppManifestFiles(appsDir).map((file) => (0, workflow_app_framework_1.loadWorkflowAppFromManifest)(file))
+    ].sort((left, right) => {
+        const byId = left.app.id.localeCompare(right.app.id);
+        if (byId)
+            return byId;
+        return (left.source.manifestPath || left.source.entrypointPath || left.source.path)
+            .localeCompare(right.source.manifestPath || right.source.entrypointPath || right.source.path);
+    });
+    const seen = new Map();
+    for (const record of records) {
+        const previous = seen.get(record.app.id);
+        if (previous) {
+            throw new Error(`Duplicate workflow app id ${record.app.id}: ${previous.source.manifestPath || previous.source.entrypointPath || previous.source.path} and ${record.source.manifestPath || record.source.entrypointPath || record.source.path}`);
+        }
+        seen.set(record.app.id, record);
+    }
+    return records;
+}
+function loadWorkflowAppById(workflowsDir, appsDir, appId) {
+    const record = loadWorkflowApps(workflowsDir, appsDir).find((candidate) => candidate.app.id === appId);
+    if (!record)
+        throw new Error(`Workflow app not found: ${appId}`);
+    return record;
+}
+// The runner pre-resolves `target` via resolveFromBase and passes the resolved
+// path; the original `target` is still used for the id-fallback lookup.
+function loadWorkflowAppTarget(workflowsDir, appsDir, resolved, target) {
+    if (!target)
+        throw new Error("Missing workflow app path or id");
+    if (node_fs_1.default.existsSync(resolved)) {
+        const stat = node_fs_1.default.statSync(resolved);
+        if (stat.isDirectory())
+            return (0, workflow_app_framework_1.loadWorkflowAppFromManifest)(node_path_1.default.join(resolved, "app.json"));
+        if (node_path_1.default.basename(resolved) === "app.json" || resolved.endsWith(".json"))
+            return (0, workflow_app_framework_1.loadWorkflowAppFromManifest)(resolved);
+        return (0, workflow_app_framework_1.loadWorkflowAppFromEntrypoint)(resolved);
+    }
+    return loadWorkflowAppById(workflowsDir, appsDir, target);
+}
+function listWorkflows(workflowsDir, appsDir) {
+    return loadWorkflowApps(workflowsDir, appsDir).map((record) => {
+        const summary = (0, workflow_app_framework_1.summarizeWorkflowApp)(record);
+        return {
+            id: summary.id,
+            title: summary.title,
+            summary: summary.summary,
+            file: summary.file
+        };
+    });
+}
+function listApps(workflowsDir, appsDir) {
+    return loadWorkflowApps(workflowsDir, appsDir).map((record) => (0, workflow_app_framework_1.summarizeWorkflowApp)(record));
+}
+function showApp(workflowsDir, appsDir, appId) {
+    const record = loadWorkflowAppById(workflowsDir, appsDir, appId);
+    const summary = (0, workflow_app_framework_1.summarizeWorkflowApp)(record);
+    return {
+        ...summary,
+        source: record.source,
+        app: {
+            schemaVersion: record.app.schemaVersion,
+            id: record.app.id,
+            title: record.app.title,
+            summary: record.app.summary || "",
+            version: record.app.version,
+            author: record.app.author,
+            inputs: record.app.inputs || record.app.workflow.inputs,
+            sandboxProfiles: record.app.sandboxProfiles || record.app.workflow.sandboxProfiles || [],
+            compatibility: record.app.compatibility,
+            metadata: record.app.metadata || {}
+        },
+        workflow: {
+            id: record.app.workflow.id,
+            title: record.app.workflow.title,
+            summary: record.app.workflow.summary || "",
+            limits: record.app.workflow.limits,
+            inputs: record.app.workflow.inputs,
+            sandboxProfiles: record.app.workflow.sandboxProfiles || [],
+            phases: record.app.workflow.phases.map((phase) => ({
+                id: phase.id,
+                name: phase.name,
+                status: phase.status,
+                tasks: phase.tasks.map((task) => ({
+                    id: task.id,
+                    kind: task.kind,
+                    requiresEvidence: Boolean(task.requiresEvidence),
+                    sandboxProfileId: task.sandboxProfileId
+                }))
+            }))
+        }
+    };
+}
+// The runner pre-resolves `target` via resolveFromBase and passes the resolved
+// path; both the try-loader and the catch-branch appPath use resolvedTarget.
+function validateApp(workflowsDir, appsDir, target, resolvedTarget) {
+    try {
+        const record = loadWorkflowAppTarget(workflowsDir, appsDir, resolvedTarget, target);
+        const result = (0, workflow_app_framework_1.validateWorkflowApp)(record.app, {
+            appPath: record.source.manifestPath || record.source.entrypointPath || record.source.path
+        });
+        return {
+            ...result,
+            summary: (0, workflow_app_framework_1.summarizeWorkflowApp)(record)
+        };
+    }
+    catch (error) {
+        const issues = (0, cli_options_1.validationIssuesFromError)(error);
+        return {
+            valid: false,
+            appId: target,
+            appPath: resolvedTarget,
+            issues
+        };
+    }
+}
+// resolveFromBase and validateApp are passed as callbacks so the body stays
+// byte-identical to the runner method (resolveFromBase(...) and validateApp(manifestPath)).
+function initApp(appsDir, appId, options, resolveFromBase, validateApp) {
+    const id = (0, workflow_api_1.slugify)(appId);
+    if (!id)
+        throw new Error("App id must include at least one letter or digit");
+    const title = String(options.title || titleize(id));
+    const destinationDir = resolveFromBase(String(options.directory || options.output || node_path_1.default.join(appsDir, id)));
+    const manifestPath = node_path_1.default.join(destinationDir, "app.json");
+    const entrypointPath = node_path_1.default.join(destinationDir, "workflow.js");
+    if (!options.force && (node_fs_1.default.existsSync(manifestPath) || node_fs_1.default.existsSync(entrypointPath))) {
+        throw new Error(`Refusing to overwrite existing workflow app: ${destinationDir}`);
+    }
+    node_fs_1.default.mkdirSync(destinationDir, { recursive: true });
+    node_fs_1.default.writeFileSync(manifestPath, (0, workflow_app_framework_1.renderWorkflowAppManifestTemplate)(id, title), "utf8");
+    node_fs_1.default.writeFileSync(entrypointPath, (0, workflow_app_framework_1.renderWorkflowAppEntrypointTemplate)(id, title), "utf8");
+    const validation = validateApp(manifestPath);
+    if (!validation.valid) {
+        throw new workflow_app_framework_1.WorkflowAppValidationError("Generated workflow app is invalid", validation.issues);
+    }
+    return { id, manifestPath, entrypointPath };
+}
+// resolveFromBase is passed as a callback so the body stays byte-identical.
+function packageApp(workflowsDir, appsDir, appId, options, resolveFromBase) {
+    const record = loadWorkflowAppById(workflowsDir, appsDir, appId);
+    const destination = resolveFromBase(String(options.output || node_path_1.default.join(".cw", "packages", `${record.app.id}-${record.app.version}.cwapp.json`)));
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(destination), { recursive: true });
+    (0, state_1.writeJson)(destination, {
+        schemaVersion: 1,
+        app: (0, workflow_app_framework_1.workflowAppRunMetadata)(record),
+        workflow: record.app.workflow,
+        packagedAt: new Date().toISOString()
+    });
+    return { id: record.app.id, version: record.app.version, path: destination };
+}
+function titleize(value) {
+    return value
+        .split("-")
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}

package/dist/orchestrator/report.js

@@ -25,6 +25,11 @@ function writeReport(run) {
     (0, dispatch_1.updatePhaseStatuses)(run);
     const workerSummary = (0, worker_isolation_1.summarizeWorkers)(run);
     const candidateSummary = (0, candidate_scoring_1.summarizeCandidates)(run);
+    // A research run reads a local folder of files, not a code repo — label its source line
+    // "Source". Skip the relabel when the run ALSO carries a remote-provenance "- Source: <url>"
+    // line below (run.inputs.sourceUrl set by a --link/URL), so a report never shows two
+    // "- Source:" lines. Every other app keeps the byte-identical "Repository:" (POLA).
+    const sourceLabel = run.workflow.app?.metadata?.domain === "research" && !run.inputs.sourceUrl ? "Source" : "Repository";
     const report = [
         `# ${run.workflow.title}`,
         "",
@@ -38,7 +43,7 @@ function writeReport(run) {
             : []),
         `- Created: ${run.createdAt}`,
         `- Updated: ${run.updatedAt}`,
-        `- Repository: ${String(run.inputs.repo || run.cwd)}`,
+        `- ${sourceLabel}: ${String(run.inputs.repo || run.cwd)}`,
         // Remote provenance (v0.1.91): when the repo was materialized from a --link/URL, record
         // the sanitized origin + resolved commit so the report itself says where the code came
         // from. Conditional — absent for a local-repo run, so existing reports stay byte-identical.

package/dist/orchestrator.js

@@ -42,9 +42,11 @@ exports.suggestCommand = suggestCommand;
 exports.formatSearchResults = formatSearchResults;
 exports.formatInfo = formatInfo;
 exports.formatHelp = formatHelp;
+exports.formatCommandHelp = formatCommandHelp;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const workflow_api_1 = require("./workflow-api");
+const capability_registry_1 = require("./capability-registry");
 const workflow_app_framework_1 = require("./workflow-app-framework");
 const dispatch_1 = require("./dispatch");
 const state_1 = require("./state");
@@ -62,6 +64,7 @@ const state_explosion_1 = require("./state-explosion");
 const evidence_reasoning_1 = require("./evidence-reasoning");
 const report_1 = require("./orchestrator/report");
 const cli_options_1 = require("./orchestrator/cli-options");
+const appOps = __importStar(require("./orchestrator/app-operations"));
 const auditOps = __importStar(require("./orchestrator/audit-operations"));
 const candidateOps = __importStar(require("./orchestrator/candidate-operations"));
 const collaborationOps = __importStar(require("./orchestrator/collaboration-operations"));
@@ -114,110 +117,22 @@ class CoolWorkflowRunner {
         return new CoolWorkflowRunner({ pluginRoot: this.pluginRoot, baseDir: resolved });
     }
     listWorkflows() {
-        return this.loadWorkflowApps().map((record) => {
-            const summary = (0, workflow_app_framework_1.summarizeWorkflowApp)(record);
-            return {
-                id: summary.id,
-                title: summary.title,
-                summary: summary.summary,
-                file: summary.file
-            };
-        });
+        return appOps.listWorkflows(this.workflowsDir, this.appsDir);
     }
     listApps() {
-        return this.loadWorkflowApps().map((record) => (0, workflow_app_framework_1.summarizeWorkflowApp)(record));
+        return appOps.listApps(this.workflowsDir, this.appsDir);
     }
     showApp(appId) {
-        const record = this.loadWorkflowAppById(appId);
-        const summary = (0, workflow_app_framework_1.summarizeWorkflowApp)(record);
-        return {
-            ...summary,
-            source: record.source,
-            app: {
-                schemaVersion: record.app.schemaVersion,
-                id: record.app.id,
-                title: record.app.title,
-                summary: record.app.summary || "",
-                version: record.app.version,
-                author: record.app.author,
-                inputs: record.app.inputs || record.app.workflow.inputs,
-                sandboxProfiles: record.app.sandboxProfiles || record.app.workflow.sandboxProfiles || [],
-                compatibility: record.app.compatibility,
-                metadata: record.app.metadata || {}
-            },
-            workflow: {
-                id: record.app.workflow.id,
-                title: record.app.workflow.title,
-                summary: record.app.workflow.summary || "",
-                limits: record.app.workflow.limits,
-                inputs: record.app.workflow.inputs,
-                sandboxProfiles: record.app.workflow.sandboxProfiles || [],
-                phases: record.app.workflow.phases.map((phase) => ({
-                    id: phase.id,
-                    name: phase.name,
-                    status: phase.status,
-                    tasks: phase.tasks.map((task) => ({
-                        id: task.id,
-                        kind: task.kind,
-                        requiresEvidence: Boolean(task.requiresEvidence),
-                        sandboxProfileId: task.sandboxProfileId
-                    }))
-                }))
-            }
-        };
+        return appOps.showApp(this.workflowsDir, this.appsDir, appId);
     }
     validateApp(target) {
-        try {
-            const record = this.loadWorkflowAppTarget(target);
-            const result = (0, workflow_app_framework_1.validateWorkflowApp)(record.app, {
-                appPath: record.source.manifestPath || record.source.entrypointPath || record.source.path
-            });
-            return {
-                ...result,
-                summary: (0, workflow_app_framework_1.summarizeWorkflowApp)(record)
-            };
-        }
-        catch (error) {
-            const issues = (0, cli_options_1.validationIssuesFromError)(error);
-            return {
-                valid: false,
-                appId: target,
-                appPath: this.resolveFromBase(target),
-                issues
-            };
-        }
+        return appOps.validateApp(this.workflowsDir, this.appsDir, target, this.resolveFromBase(target));
     }
     initApp(appId, options) {
-        const id = (0, workflow_api_1.slugify)(appId);
-        if (!id)
-            throw new Error("App id must include at least one letter or digit");
-        const title = String(options.title || titleize(id));
-        const destinationDir = this.resolveFromBase(String(options.directory || options.output || node_path_1.default.join(this.appsDir, id)));
-        const manifestPath = node_path_1.default.join(destinationDir, "app.json");
-        const entrypointPath = node_path_1.default.join(destinationDir, "workflow.js");
-        if (!options.force && (node_fs_1.default.existsSync(manifestPath) || node_fs_1.default.existsSync(entrypointPath))) {
-            throw new Error(`Refusing to overwrite existing workflow app: ${destinationDir}`);
-        }
-        node_fs_1.default.mkdirSync(destinationDir, { recursive: true });
-        node_fs_1.default.writeFileSync(manifestPath, (0, workflow_app_framework_1.renderWorkflowAppManifestTemplate)(id, title), "utf8");
-        node_fs_1.default.writeFileSync(entrypointPath, (0, workflow_app_framework_1.renderWorkflowAppEntrypointTemplate)(id, title), "utf8");
-        const validation = this.validateApp(manifestPath);
-        if (!validation.valid) {
-            throw new workflow_app_framework_1.WorkflowAppValidationError("Generated workflow app is invalid", validation.issues);
-        }
-        return { id, manifestPath, entrypointPath };
+        return appOps.initApp(this.appsDir, appId, options, (t) => this.resolveFromBase(t), (m) => this.validateApp(m));
     }
     packageApp(appId, options = {}) {
-        const record = this.loadWorkflowAppById(appId);
-        const destination = this.resolveFromBase(String(options.output || node_path_1.default.join(".cw", "packages", `${record.app.id}-${record.app.version}.cwapp.json`)));
-        node_fs_1.default.mkdirSync(node_path_1.default.dirname(destination), { recursive: true });
-        (0, state_1.writeJson)(destination, {
-            schemaVersion: 1,
-            app: (0, workflow_app_framework_1.workflowAppRunMetadata)(record),
-            workflow: record.app.workflow,
-            packagedAt: new Date().toISOString()
-        });
-        return { id: record.app.id, version: record.app.version, path: destination };
+        return appOps.packageApp(this.workflowsDir, this.appsDir, appId, options, (t) => this.resolveFromBase(t));
     }
     init(workflowId, options) {
         const id = (0, workflow_api_1.slugify)(workflowId);
@@ -726,64 +641,7 @@ class CoolWorkflowRunner {
         return node_path_1.default.resolve(this.invocationCwd(), target);
     }
     loadWorkflowAppById(appId) {
-        const record = this.loadWorkflowApps().find((candidate) => candidate.app.id === appId);
-        if (!record)
-            throw new Error(`Workflow app not found: ${appId}`);
-        return record;
-    }
-    loadWorkflowAppTarget(target) {
-        if (!target)
-            throw new Error("Missing workflow app path or id");
-        const resolved = this.resolveFromBase(target);
-        if (node_fs_1.default.existsSync(resolved)) {
-            const stat = node_fs_1.default.statSync(resolved);
-            if (stat.isDirectory())
-                return (0, workflow_app_framework_1.loadWorkflowAppFromManifest)(node_path_1.default.join(resolved, "app.json"));
-            if (node_path_1.default.basename(resolved) === "app.json" || resolved.endsWith(".json"))
-                return (0, workflow_app_framework_1.loadWorkflowAppFromManifest)(resolved);
-            return (0, workflow_app_framework_1.loadWorkflowAppFromEntrypoint)(resolved);
-        }
-        return this.loadWorkflowAppById(target);
-    }
-    loadWorkflowApps() {
-        const records = [
-            ...this.loadWorkflowFiles().map((file) => (0, workflow_app_framework_1.loadWorkflowAppFromEntrypoint)(file)),
-            ...this.loadAppManifestFiles().map((file) => (0, workflow_app_framework_1.loadWorkflowAppFromManifest)(file))
-        ].sort((left, right) => {
-            const byId = left.app.id.localeCompare(right.app.id);
-            if (byId)
-                return byId;
-            return (left.source.manifestPath || left.source.entrypointPath || left.source.path)
-                .localeCompare(right.source.manifestPath || right.source.entrypointPath || right.source.path);
-        });
-        const seen = new Map();
-        for (const record of records) {
-            const previous = seen.get(record.app.id);
-            if (previous) {
-                throw new Error(`Duplicate workflow app id ${record.app.id}: ${previous.source.manifestPath || previous.source.entrypointPath || previous.source.path} and ${record.source.manifestPath || record.source.entrypointPath || record.source.path}`);
-            }
-            seen.set(record.app.id, record);
-        }
-        return records;
-    }
-    loadWorkflowFiles() {
-        if (!node_fs_1.default.existsSync(this.workflowsDir))
-            return [];
-        return node_fs_1.default
-            .readdirSync(this.workflowsDir)
-            .filter((file) => file.endsWith(".workflow.js"))
-            .sort()
-            .map((file) => node_path_1.default.join(this.workflowsDir, file));
-    }
-    loadAppManifestFiles() {
-        if (!node_fs_1.default.existsSync(this.appsDir))
-            return [];
-        return node_fs_1.default
-            .readdirSync(this.appsDir, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => node_path_1.default.join(this.appsDir, entry.name, "app.json"))
-            .filter((file) => node_fs_1.default.existsSync(file))
-            .sort();
+        return appOps.loadWorkflowAppById(this.workflowsDir, this.appsDir, appId);
     }
 }
 exports.CoolWorkflowRunner = CoolWorkflowRunner;
@@ -973,7 +831,37 @@ function formatHelp() {
         "  --no-color             Disable ANSI color (also honors NO_COLOR / FORCE_COLOR)",
         "",
         (0, term_1.bold)("More commands", out),
-        ...wrapped
+        ...wrapped,
+        "",
+        // 4-space indent on purpose: the CLI/MCP parity help-token check only parses
+        // 2-space command lines, so this note never registers as a bogus token.
+        "    Run  cw help <command>  for one command's subcommands and descriptions."
+    ].join("\n");
+}
+/** Per-command help: `cw help <verb>` (and `cw <verb> --help`) lists that verb's
+ *  CLI subcommands with one-line summaries, derived from CAPABILITY_REGISTRY — the
+ *  SAME table the dispatcher and the CLI/MCP parity check use, so there is no
+ *  second source to drift. Additive: formatHelp()'s parity-checked token list is
+ *  untouched. */
+function formatCommandHelp(verb) {
+    const out = process.stdout;
+    const matches = capability_registry_1.CAPABILITY_REGISTRY.filter((cap) => cap.cli && cap.cli.path[0] === verb);
+    if (matches.length === 0) {
+        const lines = [`Unknown command: ${verb}`];
+        const hint = suggestCommand(verb);
+        if (hint)
+            lines.push(`  Did you mean:  cw ${hint}`);
+        lines.push("  Try:  cw help   (list all commands)");
+        return lines.join("\n");
+    }
+    const rows = matches
+        .map((cap) => ({ cmd: `cw ${cap.cli.path.join(" ")}`, summary: cap.summary }))
+        .sort((a, b) => (a.cmd < b.cmd ? -1 : a.cmd > b.cmd ? 1 : 0));
+    const width = Math.min(40, rows.reduce((max, row) => Math.max(max, row.cmd.length), 0));
+    return [
+        (0, term_1.bold)(`cw ${verb}`, out),
+        "",
+        ...rows.map((row) => `  ${row.cmd.padEnd(width)}  ${row.summary}`)
     ].join("\n");
 }
 function appendOption(options, key, value) {

package/dist/state-explosion.js

@@ -7,7 +7,6 @@ exports.stateExplosionReportLines = exports.formatBlackboardDigest = exports.for
 exports.computeStateSize = computeStateSize;
 exports.summarizeBlackboardDigest = summarizeBlackboardDigest;
 exports.buildCompactGraph = buildCompactGraph;
-exports.buildOperatorDigest = buildOperatorDigest;
 exports.buildStateExplosionReport = buildStateExplosionReport;
 exports.maybeCompactRun = maybeCompactRun;
 exports.refreshStateExplosionSummaries = refreshStateExplosionSummaries;
@@ -732,12 +731,6 @@ function expansionCommandFor(run, view, key) {
         return `node scripts/cw.js multi-agent graph ${run.id} --view full --json`;
     return `node scripts/cw.js multi-agent graph ${run.id} --view full --focus ${key} --json`;
 }
-// ---------------------------------------------------------------------------
-// Operator digest
-// ---------------------------------------------------------------------------
-function buildOperatorDigest(run, thresholds = exports.DEFAULT_STATE_EXPLOSION_THRESHOLDS) {
-    return buildOperatorDigestWithContext(run, thresholds, createStateExplosionBuildContext());
-}
 function buildOperatorDigestWithContext(run, thresholds, context) {
     const stateSize = stateSizeFor(run, thresholds, context);
     const operator = operatorFor(run, context);

package/dist/term.js

@@ -14,13 +14,11 @@ exports.yellow = yellow;
 exports.red = red;
 exports.cyan = cyan;
 exports.doctorGlyph = doctorGlyph;
-exports.cwLabel = cwLabel;
 exports.indent = indent;
 exports.nextHint = nextHint;
 exports.tryHint = tryHint;
 exports.sectionHeader = sectionHeader;
 exports.phaseProgressLine = phaseProgressLine;
-exports.formatDuration = formatDuration;
 exports.printSuccessSummary = printSuccessSummary;
 exports.stripAnsi = stripAnsi;
 exports.visibleWidth = visibleWidth;
@@ -84,10 +82,6 @@ function doctorGlyph(status, stream) {
     };
     return color[status](`${glyph[status]}`, stream);
 }
-/** "cw:" prefix with bold and optional color. */
-function cwLabel(stream) {
-    return bold("cw:", stream);
-}
 /** Render a multi-line block with consistent 2-space indentation. */
 function indent(text, spaces = 2) {
     const prefix = " ".repeat(spaces);
@@ -113,18 +107,6 @@ function phaseProgressLine(name, done, total, mode, stream) {
     const count = total > 0 ? ` (${done}/${total})` : "";
     return `${sectionHeader(name, stream)} ${glyph}${count}`;
 }
-/** Format a DURATION in ms as `850ms` / `5.2s` / `1m02s`. Pure (no clock) — the
- *  caller measures elapsed via process.hrtime, so this never reads wall-clock time. */
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${Math.max(0, Math.round(ms))}ms`;
-    const s = Math.round(ms / 100) / 10;
-    if (s < 60)
-        return `${s}s`;
-    const m = Math.floor(s / 60);
-    const rem = Math.round(s % 60);
-    return `${m}m${String(rem).padStart(2, "0")}s`;
-}
 /** Print a success summary to stderr (TTY-gated). Shows the report path, a one-line
  *  status (with N/N worker counts when known), and a copy-pasteable next/recovery
  *  command. Pipe-friendly: silent when stderr is not a TTY, so it never pollutes

package/dist/validation.js

@@ -19,15 +19,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecordValidationError = void 0;
 exports.validateWorkerScope = validateWorkerScope;
-exports.tryValidateWorkerScope = tryValidateWorkerScope;
 exports.validateNodeSnapshot = validateNodeSnapshot;
-exports.tryValidateNodeSnapshot = tryValidateNodeSnapshot;
 exports.validateNodeReplayRun = validateNodeReplayRun;
-exports.tryValidateNodeReplayRun = tryValidateNodeReplayRun;
 exports.validateCandidateScore = validateCandidateScore;
 exports.tryValidateCandidateScore = tryValidateCandidateScore;
 exports.validateCandidateRecord = validateCandidateRecord;
-exports.tryValidateCandidateRecord = tryValidateCandidateRecord;
 // ---------------------------------------------------------------------------
 // Primitive predicates — small, total, never throw.
 // ---------------------------------------------------------------------------
@@ -126,10 +122,6 @@ function validateWorkerScope(value) {
         throw new RecordValidationError("WorkerScope", problem.reason, problem.field);
     return value;
 }
-/** Best-effort variant: returns null on mismatch (caller skips the record). */
-function tryValidateWorkerScope(value) {
-    return workerScopeReason(value) ? null : value;
-}
 // ---------------------------------------------------------------------------
 // NodeSnapshotBody — shared by NodeSnapshot.body and NodeReplayRun.body.
 // Required (per src/types/state-node.ts): id, kind, status, loopStage strings;
@@ -184,10 +176,6 @@ function validateNodeSnapshot(value) {
         throw new RecordValidationError("NodeSnapshot", problem.reason, problem.field);
     return value;
 }
-/** Best-effort variant: returns null on mismatch. */
-function tryValidateNodeSnapshot(value) {
-    return nodeSnapshotReason(value) ? null : value;
-}
 // ---------------------------------------------------------------------------
 // NodeReplayRun — node-snapshot.ts:133
 // Required: schemaVersion===1, replayId, runId, nodeId, snapshotId, replayedAt,
@@ -226,10 +214,6 @@ function validateNodeReplayRun(value) {
         throw new RecordValidationError("NodeReplayRun", problem.reason, problem.field);
     return value;
 }
-/** Best-effort variant: returns null on mismatch. */
-function tryValidateNodeReplayRun(value) {
-    return nodeReplayRunReason(value) ? null : value;
-}
 // ---------------------------------------------------------------------------
 // CandidateScore — multi-agent-operator-ux.ts:502 / evidence-reasoning.ts:750
 // Required (per src/types/candidate.ts): schemaVersion===1, id, candidateId,
@@ -321,8 +305,3 @@ function validateCandidateRecord(value) {
         throw new RecordValidationError("CandidateRecord", problem.reason, problem.field);
     return value;
 }
-/** Best-effort variant: returns null on mismatch (caller skips the record so the
- *  downstream selection gate fails closed on its absence). */
-function tryValidateCandidateRecord(value) {
-    return candidateRecordReason(value) ? null : value;
-}

package/dist/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION = exports.LEGACY_RUN_STATE_SCHEMA_VERSION = exports.CURRENT_RUN_STATE_SCHEMA_VERSION = exports.WORKFLOW_APP_SCHEMA_VERSION = exports.CURRENT_COOL_WORKFLOW_VERSION = void 0;
-exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.91";
+exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.93";
 exports.WORKFLOW_APP_SCHEMA_VERSION = 1;
 exports.CURRENT_RUN_STATE_SCHEMA_VERSION = 1;
 exports.LEGACY_RUN_STATE_SCHEMA_VERSION = 0;

package/docs/agent-delegation-drive.7.md

@@ -336,3 +336,5 @@ The one-command `cw -q` headline now routes the question and defaults the repo t
 0.1.90
 
 0.1.91
+
+0.1.93

package/docs/canonical-workflow-apps.7.md

@@ -98,6 +98,11 @@ node scripts/cw.js plan release-cut \
 Break a research question into claims, look into sources, cross-check
 the evidence, check the claims, and put together a short answer.
 
+When you point it at a folder, it reads the local files there as primary
+sources. So this app works over any corpus — your own docs, notes, or
+papers — not only a git code repo. The working directory is the corpus,
+so the agent can back its answer with your own files.
+
 ```bash
 node scripts/cw.js plan research-synthesis \
   --cwd /tmp/research-run \
@@ -107,6 +112,13 @@ node scripts/cw.js plan research-synthesis \
   --freshness "as of today"
 ```
 
+Over a local corpus folder, point `--repo` at it:
+
+```bash
+cw quickstart research-synthesis --repo /path/to/papers \
+  --question "What do these papers conclude?"
+```
+
 ## Validation Matrix
 
 Run the canonical app matrix from the plugin root directory: