harnery 0.8.0 → 0.9.0

package/dist/core/workflow/spawn-cursor.js

@@ -0,0 +1,72 @@
+/**
+ * cursor spawn adapter: runs one subagent as a headless `cursor-agent -p`
+ * subprocess with `--output-format json`.
+ *
+ * Contract notes (LIVE-VERIFIED 2026-07-17 against cursor-agent
+ * 2026.07.16-899851b: schema-gated triage + text stages round-trip via
+ * `--harness cursor`, session_id parses from the envelope):
+ * - `cursor-agent -p "<prompt>" --output-format json` prints a single result
+ *   envelope modeled on Claude Code's (`{type: "result", is_error, result,
+ *   session_id, …}`).
+ * - `--trust` is required: headless runs refuse untrusted workspaces (exit 1,
+ *   "Workspace Trust Required") — see the argv comment below.
+ * - Envelope drift guard: when stdout doesn't parse as JSON but the process
+ *   exited 0, the raw stdout is returned as the reply text.
+ * - No per-run cost surface → undefined. No max-turns equivalent → `maxTurns`
+ *   accepted and ignored (documented in the CLI docs page).
+ */
+import { exec } from "../../lib/exec.js";
+import { buildChildEnv } from "./child-env.js";
+import { notFoundError } from "./harnesses.js";
+/** Exported for unit tests (no live binary to test against). */
+export function parseCursorOutput(stdout) {
+    try {
+        const envelope = JSON.parse(stdout);
+        return {
+            text: String(envelope.result ?? ""),
+            sessionId: envelope.session_id,
+            isError: Boolean(envelope.is_error),
+        };
+    }
+    catch {
+        return { text: stdout, isError: false };
+    }
+}
+export const cursorSpawner = async (req) => {
+    const t0 = Date.now();
+    // --trust: headless cursor-agent refuses untrusted workspaces (exit 1,
+    // "Workspace Trust Required"). Workflow children run in the engine's cwd
+    // deliberately and may edit files — the same posture as the codex adapter's
+    // `--sandbox workspace-write` — so trusting that directory is implied.
+    const argv = ["cursor-agent", "-p", req.prompt, "--output-format", "json", "--trust"];
+    if (req.model)
+        argv.push("--model", req.model);
+    const r = await exec(argv, {
+        cwd: req.cwd,
+        env: buildChildEnv(req.runId, { subscriptionOnly: req.subscriptionOnly }),
+        timeout: req.timeoutMs,
+    });
+    const durationMs = Date.now() - t0;
+    if (r.exitCode === 127) {
+        return { ok: false, text: "", durationMs, error: notFoundError("cursor") };
+    }
+    if (r.exitCode !== 0) {
+        return {
+            ok: false,
+            text: "",
+            durationMs,
+            error: `cursor-agent exited ${r.exitCode}: ${(r.stderr || r.stdout).slice(0, 500)}`,
+        };
+    }
+    const parsed = parseCursorOutput(r.stdout);
+    if (parsed.isError) {
+        return {
+            ok: false,
+            text: parsed.text,
+            sessionId: parsed.sessionId,
+            durationMs,
+            error: `cursor-agent reported is_error: ${parsed.text.slice(0, 300)}`,
+        };
+    }
+    return { ok: true, text: parsed.text, sessionId: parsed.sessionId, durationMs };
+};

package/dist/core/workflow/types.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Workflow engine contracts. A workflow is a small throwaway JS script with
+ * bounded, schema-gated stages that fan work out to headless harness-CLI
+ * subagents; the SCRIPT (deterministic code), not any model, decides routing
+ * between stages, and the run always terminates when the script returns.
+ *
+ * Design record: decision 0015 (portable coordination-aware workflows).
+ */
+import type { BillingMode, BillingProber } from "./billing.js";
+/** JSON-schema *subset* accepted by stage gates (see validate.ts). */
+export interface StageSchema {
+    type: "object" | "array" | "string" | "number" | "boolean";
+    /** type=object */
+    properties?: Record<string, StageSchema>;
+    required?: string[];
+    /** type=array */
+    items?: StageSchema;
+    /** any type: closed value set (compared with ===) */
+    enum?: Array<string | number | boolean>;
+}
+export interface AgentOpts {
+    /** Stage gate: when present, the agent's reply must strict-parse as JSON and
+     * validate; the engine retries with the validation error appended, up to
+     * `maxAttempts`. Without it, `agent()` resolves to the raw reply text. */
+    schema?: StageSchema;
+    /** Model slug passed through to the harness CLI (default: the CLI's default). */
+    model?: string;
+    /** Attempt ceiling for the schema-retry loop (default 2). */
+    maxAttempts?: number;
+    /** Subprocess timeout ms (default 300_000). */
+    timeoutMs?: number;
+    /** Harness-turn ceiling for the child (default 25; use 1 for pure
+     * classification stages — cheaper and faster). */
+    maxTurns?: number;
+    /** Display label in the journal (default: prompt head). */
+    label?: string;
+    /** Which harness runs this agent (default: the run's default harness).
+     * Mixed-harness workflows are legal: triage on one CLI, deep work on
+     * another. */
+    harness?: HarnessName;
+}
+export type HarnessName = "claude-code" | "codex" | "cursor";
+/** What a spawn adapter returns for one subagent run. */
+export interface SpawnResult {
+    ok: boolean;
+    /** The model's final reply text (envelope-unwrapped). */
+    text: string;
+    /** Child harness session id when the envelope carries one. */
+    sessionId?: string;
+    costUsd?: number;
+    durationMs: number;
+    /** Populated when ok=false. */
+    error?: string;
+}
+export interface SpawnRequest {
+    prompt: string;
+    model?: string;
+    timeoutMs: number;
+    maxTurns: number;
+    cwd: string;
+    /** Run id, stamped into the child env (HARNERY_WORKFLOW_RUN_ID) so the
+     * coord layer can associate child sessions with their workflow run. */
+    runId?: string;
+    /** Scrub all API-key vars from the child env so it can only authenticate
+     * via its stored (subscription) login. See billing.ts. */
+    subscriptionOnly?: boolean;
+}
+/** One headless-subagent runner. The engine is adapter-agnostic; claude-code
+ * ships first, codex/cursor land behind the same signature (plan Phase 4). */
+export type Spawner = (req: SpawnRequest) => Promise<SpawnResult>;
+/** The API surface injected into a workflow script's default export. Explicit
+ * injection (no ambient globals): keeps scripts portable and unit-testable. */
+export interface WorkflowContext {
+    /** Spawn one subagent; resolves to validated JSON (schema) or reply text. */
+    agent: (prompt: string, opts?: AgentOpts) => Promise<unknown>;
+    /** Run thunks with bounded concurrency; a rejected thunk resolves to null. */
+    parallel: <T>(thunks: Array<() => Promise<T>>) => Promise<Array<T | null>>;
+    /** Declare the current stage (journal + progress grouping). */
+    stage: (title: string) => void;
+    /** Narrate progress (stderr + journal). */
+    log: (message: string) => void;
+}
+export interface WorkflowMeta {
+    name: string;
+    description?: string;
+}
+/** Loaded script shape: `export const meta` + `export default async (ctx) => …`. */
+export interface WorkflowModule {
+    meta?: WorkflowMeta;
+    default: (ctx: WorkflowContext) => Promise<unknown>;
+}
+export interface EngineOpts {
+    /** Repo root whose .harnery/ receives the run journal. */
+    coordRoot: string;
+    /** Spawner registry keyed by harness. A single-harness caller registers one
+     * entry and names it in `defaultHarness`. */
+    spawners: Partial<Record<HarnessName, Spawner>>;
+    /** Harness used when an agent() call doesn't name one (default "claude-code"). */
+    defaultHarness?: HarnessName;
+    /** Resume: run id of a prior run whose journal supplies cached results.
+     * agent() calls whose (stage, prompt, model, maxTurns, schema) key matches a
+     * completed prior agent return the journaled result without spawning. */
+    resumeFrom?: string;
+    /** Total-agent ceiling for the run (default 50): the runaway backstop. */
+    maxAgents?: number;
+    /** Concurrent-subagent cap for parallel() (default 4). */
+    concurrency?: number;
+    /** Working directory children spawn in (default: coordRoot). */
+    cwd?: string;
+    /** Progress sink (default: process.stderr). */
+    onLog?: (line: string) => void;
+    /** Guarantee subscription billing: API-key vars are scrubbed from every
+     * child env, and a harness whose stored login is provably absent fails
+     * loud before spawning. */
+    subscriptionOnly?: boolean;
+    /** Permit the api-key-override billing state (an exported API key silently
+     * shadowing a stored subscription login), which the engine otherwise
+     * refuses. Deliberate key-only hosts don't need this — only the
+     * both-present case does. */
+    allowApiBilling?: boolean;
+    /** Billing-probe override for tests (default: the real probeBilling). */
+    probeBilling?: BillingProber;
+}
+export interface RunReport {
+    runId: string;
+    name: string;
+    /** What the script's default export returned. */
+    result: unknown;
+    agentsSpawned: number;
+    /** agent() calls satisfied from the resumeFrom journal without spawning. */
+    agentsCached: number;
+    costUsd: number;
+    durationMs: number;
+    journalPath: string;
+    /** Estimated tokens of repo instructions (CLAUDE.md/AGENTS.md at the child
+     * cwd) that EVERY child cache-writes on spawn — the fixed per-child context
+     * overhead a fan-out multiplies. bytes/4 heuristic; 0 when no such file. */
+    contextTokensPerChildEstimate: number;
+    /** Billing mode per harness actually used this run (probed on first use). */
+    billing: Array<{
+        harness: HarnessName;
+        mode: BillingMode;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/workflow/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/types.ts"],"names":[],"mappings":"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"}

package/dist/core/workflow/types.js

@@ -0,0 +1,9 @@
+/**
+ * Workflow engine contracts. A workflow is a small throwaway JS script with
+ * bounded, schema-gated stages that fan work out to headless harness-CLI
+ * subagents; the SCRIPT (deterministic code), not any model, decides routing
+ * between stages, and the run always terminates when the script returns.
+ *
+ * Design record: decision 0015 (portable coordination-aware workflows).
+ */
+export {};

package/dist/core/workflow/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minimal validator for the StageSchema JSON-schema subset. Deliberately tiny:
+ * a full JSON Schema implementation would pull a dependency (ajv) for
+ * validation depth workflow gates don't need. Supported: type, properties,
+ * required, items, enum. Returns a list of human-readable problems (empty =
+ * valid) so the engine can feed failures back into the retry prompt verbatim.
+ */
+import type { StageSchema } from "./types.js";
+export declare function validateAgainstSchema(value: unknown, schema: StageSchema, path?: string): string[];
+/** Strip accidental markdown code fences, then strict-parse JSON. */
+export declare function parseStageOutput(text: string): {
+    value?: unknown;
+    error?: string;
+};
+//# sourceMappingURL=validate.d.ts.map

package/dist/core/workflow/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/validate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,SAAM,GAAG,MAAM,EAAE,CA8C/F;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAUlF"}

package/dist/core/workflow/validate.js

@@ -0,0 +1,70 @@
+/**
+ * Minimal validator for the StageSchema JSON-schema subset. Deliberately tiny:
+ * a full JSON Schema implementation would pull a dependency (ajv) for
+ * validation depth workflow gates don't need. Supported: type, properties,
+ * required, items, enum. Returns a list of human-readable problems (empty =
+ * valid) so the engine can feed failures back into the retry prompt verbatim.
+ */
+export function validateAgainstSchema(value, schema, path = "$") {
+    const problems = [];
+    if (schema.enum) {
+        if (!schema.enum.some((v) => v === value)) {
+            problems.push(`${path}: expected one of ${JSON.stringify(schema.enum)}, got ${short(value)}`);
+        }
+        return problems; // enum is exhaustive; type check is implied by membership
+    }
+    switch (schema.type) {
+        case "object": {
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                return [`${path}: expected object, got ${short(value)}`];
+            }
+            const obj = value;
+            for (const key of schema.required ?? []) {
+                if (!(key in obj))
+                    problems.push(`${path}.${key}: required property missing`);
+            }
+            for (const [key, sub] of Object.entries(schema.properties ?? {})) {
+                if (key in obj)
+                    problems.push(...validateAgainstSchema(obj[key], sub, `${path}.${key}`));
+            }
+            return problems;
+        }
+        case "array": {
+            if (!Array.isArray(value))
+                return [`${path}: expected array, got ${short(value)}`];
+            if (schema.items) {
+                for (const [i, item] of value.entries()) {
+                    problems.push(...validateAgainstSchema(item, schema.items, `${path}[${i}]`));
+                }
+            }
+            return problems;
+        }
+        case "string":
+        case "number":
+        case "boolean": {
+            if (typeof value !== schema.type) {
+                problems.push(`${path}: expected ${schema.type}, got ${short(value)}`);
+            }
+            return problems;
+        }
+        default:
+            return [`${path}: unsupported schema type ${String(schema.type)}`];
+    }
+}
+/** Strip accidental markdown code fences, then strict-parse JSON. */
+export function parseStageOutput(text) {
+    const stripped = text
+        .trim()
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/\s*```$/, "");
+    try {
+        return { value: JSON.parse(stripped) };
+    }
+    catch (err) {
+        return { error: `not valid JSON: ${err.message}` };
+    }
+}
+function short(value) {
+    const s = JSON.stringify(value);
+    return s === undefined ? String(value) : s.length > 60 ? `${s.slice(0, 60)}…` : s;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Multi-agent coordination for AI coding agents - Claude Code, Cursor, and Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",

package/src/commander.ts

@@ -49,6 +49,7 @@ import { registerSectionCommand, registerTocCommand } from "./commands/toc.ts";
 import { registerTokensCommand } from "./commands/tokens.ts";
 import { registerTunnelCommand } from "./commands/tunnel.ts";
 import { registerWebCommand } from "./commands/web.ts";
+import { registerWorkflowCommand } from "./commands/workflow.ts";
 
 export interface HarneryContextOpts {
   /**
@@ -277,6 +278,7 @@ export function createHarneryProgram(opts: HarneryContextOpts = {}): Command {
   registerDeinitCommand(program, emit, opts.binName);
   registerBackupCommand(program, emit);
   registerSyncCommand(program, emit);
+  registerWorkflowCommand(program, emit);
   if (include("web")) registerWebCommand(program, emit);
 
   return program;

package/src/commands/doctor.ts

@@ -19,6 +19,13 @@ import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
 import { resolveBinName, ripgrepAutoInstall } from "../core/config.ts";
 import { loadHarnessWiring } from "../core/hooks/harness/wiring.ts";
+import { probeBilling } from "../core/workflow/billing.ts";
+import {
+  HARNESS_BINARIES,
+  HARNESS_INSTALL_HINTS,
+  HARNESS_LOGIN_HINTS,
+} from "../core/workflow/harnesses.ts";
+import type { HarnessName } from "../core/workflow/types.ts";
 import { findRg, installRg, managedRgPath, rgInstallSupported } from "../lib/tools/ripgrep.ts";
 
 type Severity = "ok" | "warn" | "fail";
@@ -96,6 +103,9 @@ export function runChecks(): Check[] {
     checkRipgrep(),
     checkHarneryDir(),
     checkHarnessHooks(),
+    checkWorkflowHarness("claude-code"),
+    checkWorkflowHarness("codex"),
+    checkWorkflowHarness("cursor"),
     checkRestic(),
     checkRclone(),
     checkPlaywright(),
@@ -144,6 +154,41 @@ function whichVersion(bin: string, args: string[] = ["--version"]): { ok: boolea
   return { ok: true, out };
 }
 
+/**
+ * One workflow spawn target: is the harness CLI installed, and how will its
+ * headless children bill (subscription login vs API key — see billing.ts)?
+ * Missing is a warn, not a fail: workflows degrade to the harnesses you have.
+ */
+function checkWorkflowHarness(harness: HarnessName): Check {
+  const bin = HARNESS_BINARIES[harness];
+  const name = `workflow:${harness}`;
+  const r = whichVersion(bin);
+  if (!r.ok) {
+    return {
+      name,
+      severity: "warn",
+      detail: `${bin} missing (workflow --harness ${harness} unavailable)`,
+      hint: `${HARNESS_INSTALL_HINTS[harness]}  then: ${HARNESS_LOGIN_HINTS[harness]}`,
+    };
+  }
+  const probe = probeBilling(harness);
+  if (probe.login === "absent" && !probe.apiKeyPresent) {
+    return {
+      name,
+      severity: "warn",
+      detail: `${r.out} — installed, but no stored login or API key detected`,
+      hint: HARNESS_LOGIN_HINTS[harness],
+    };
+  }
+  const billing =
+    probe.mode === "subscription"
+      ? probe.login === "present"
+        ? "billing: subscription"
+        : "billing: subscription (login unverifiable, CLI is the authority)"
+      : `billing: ${probe.mode} (${probe.apiKeySource})`;
+  return { name, severity: "ok", detail: `${r.out} — ${billing}` };
+}
+
 function checkNode(): Check {
   const v = process.versions.node;
   const major = Number.parseInt(v.split(".")[0], 10);