@karowanorg/orc-ops 0.1.0

package/LICENSE

@@ -0,0 +1,14 @@
+BSD Zero Clause License (0BSD)
+
+Copyright (c) 2026 Kyle Rowan
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @karowanorg/orc-ops
+
+The zod-first operation registry orc's CLI, MCP server, and SDK all interpret.
+
+Part of orc - model-authored promise-native agent programs with deterministic replay, live monitoring, and pluggable harnesses. See the orc repository README for the full picture.

package/dist/exec-harness.d.ts

@@ -0,0 +1,2 @@
+import type { Harness } from "@karowanorg/orc-core";
+export declare function makeExecHarness(execPath: string, name?: string): Harness;

package/dist/exec-harness.js

@@ -0,0 +1,78 @@
+/**
+ * The any-language plugin protocol: a config-registered executable that
+ * - answers `--capabilities` with a HarnessCapabilities JSON on stdout, and
+ * - accepts a LeafRequest JSON on stdin, emitting HarnessEvent NDJSON on stdout.
+ * Registered ONLY via orc.config — never discovered from PATH.
+ */
+import * as path from "node:path";
+import { z } from "zod";
+const HarnessCapabilitiesSchema = z.object({
+    available: z.boolean(),
+    version: z.string().optional(),
+    models: z.array(z.object({
+        id: z.string(),
+        displayName: z.string().optional(),
+        reasoningEfforts: z.array(z.string()),
+        default: z.boolean().optional(),
+    })),
+    approvalModes: z.array(z.enum(["manual", "accept-edits", "auto", "bypass"])),
+    structuredOutput: z.boolean(),
+    sessions: z.boolean(),
+    detail: z.string().optional(),
+});
+export function makeExecHarness(execPath, name) {
+    const harnessName = name ?? path.basename(execPath).replace(/\.[^.]+$/, "");
+    return {
+        name: harnessName,
+        async discover({ executor }) {
+            try {
+                const res = await executor.run([execPath, "--capabilities"], { timeoutMs: 15_000 });
+                if (res.code !== 0)
+                    throw new Error(res.stderr || `exit ${res.code}`);
+                return HarnessCapabilitiesSchema.parse(JSON.parse(res.stdout));
+            }
+            catch (err) {
+                return {
+                    available: false,
+                    models: [],
+                    approvalModes: [],
+                    structuredOutput: false,
+                    sessions: false,
+                    detail: `exec harness unavailable: ${String(err instanceof Error ? err.message : err)}`,
+                };
+            }
+        },
+        async *invoke(req, ctx) {
+            const proc = ctx.executor.spawn([execPath], { cwd: req.cwd, stdin: "pipe" });
+            const onAbort = () => proc.kill();
+            ctx.signal.addEventListener("abort", onAbort);
+            proc.stdin?.end(JSON.stringify(req) + "\n");
+            try {
+                let buf = "";
+                for await (const chunk of proc.stdout) {
+                    buf += chunk.toString();
+                    let idx;
+                    while ((idx = buf.indexOf("\n")) >= 0) {
+                        const line = buf.slice(0, idx).trim();
+                        buf = buf.slice(idx + 1);
+                        if (!line)
+                            continue;
+                        try {
+                            yield JSON.parse(line);
+                        }
+                        catch {
+                            /* tolerate non-event noise */
+                        }
+                    }
+                }
+                const code = await proc.exited;
+                if (code !== 0)
+                    yield { kind: "error", message: `exec harness exited with code ${code}` };
+            }
+            finally {
+                ctx.signal.removeEventListener("abort", onAbort);
+                proc.kill();
+            }
+        },
+    };
+}

package/dist/guide.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The orc authoring + usage guide. One source of truth surfaced by:
+ *  - CLI:  `orc guide`
+ *  - MCP:  the `orc_guide` tool
+ */
+export declare const GUIDE = "# orc \u2014 how to write and run a program\n\norc runs a \"program\": a script that fans out AI-agent subtasks (\"leaves\") and\nrecords each one, so a run is reproducible, resumable, and observable. You write\na program, launch it, then watch it and collect the result.\n\n## 1. Write a program\n\nA program is a `.orc.ts` file with a single default-exported async function.\nIt receives an api object and returns the run's result:\n\n    import type { Program } from \"@karowanorg/orc-sdk/program\"; // optional, type-only\n\n    const program: Program = async ({ agent, parallel, phase }) => {\n      const inventory = await agent(\"List the modules in this repo.\", {\n        schema: { type: \"object\",\n                  properties: { modules: { type: \"array\", items: { type: \"string\" } } },\n                  required: [\"modules\"] },\n      });\n\n      // Ordinary async/await controls the flow. Awaiting a result before the\n      // next call makes it a dependency; independent calls run concurrently.\n      const plans = await Promise.all((inventory.modules as string[]).map(async (m) => {\n        const findings = await agent(`Audit module ${m}`, { id: `audit-${m}` });\n        return agent(`Plan a fix for ${m}: ${JSON.stringify(findings)}`, { id: `plan-${m}` });\n      }));\n\n      return phase(\"synthesis\", () => agent(`Merge these plans: ${JSON.stringify(plans)}`, { id: \"merge\" }));\n    };\n    export default program;\n\n## The api\n\nIMPORTANT \u2014 leaves are isolated. Each agent() runs a FRESH subagent that shares\nNONE of your context: it cannot see this program, your conversation, other\nleaves' prompts or results, or anything you know that you haven't written into\nits prompt (plus the shared `--brief`).\n\n- agent(prompt, opts?) => Promise<result>\n    Dispatch one agent. Returns its result (matching `schema` if you pass one).\n    A failed leaf rejects the promise, so wrap it in try/catch if you want to\n    handle failure. Options:\n      id               a label shown in the monitor\n      schema           JSON Schema; the result is structured output matching it\n      harness          \"claude\" | \"codex\" | a configured harness (default: auto)\n      model            e.g. \"claude-fable-5\", \"gpt-5.6-sol\"\n      reasoningEffort  \"low\" | \"medium\" | \"high\" | \"xhigh\" | \"max\"\n      readOnly         default true; set false for a leaf that edits files\n      cwd              working directory for this leaf (defaults to the run's)\n      host             SSH destination to run this leaf on a remote machine\n      idleTimeout      ms with no output before the leaf is killed (false = off)\n      phase            group this call under a phase label\n    To see valid `harness`, `model`, and `reasoningEffort` values for your\n    machine, run `orc capabilities` (or `orc capabilities --json`) \u2014 it lists\n    each installed harness with its available models and reasoning levels.\n    Omit any of them to use the default; an unknown value is rejected up front\n    by `orc validate`.\n\n- parallel(specs[]) => Promise<outcomes[]>\n    Run several agents at once from an array of option objects (each with a\n    `prompt`). Every lane runs to completion INDEPENDENTLY \u2014 one lane failing\n    never cancels the others. Outcomes come back in order as\n    `{ status: \"ok\", value } | { status: \"error\", error }`, so you decide how to\n    handle partial failure. (For fail-fast, use `Promise.all` over `agent()`,\n    which rejects on the first failure.)\n\n- phase(name, fn) => Promise<result>\n    Group every agent() call made inside `fn` under a phase, for a readable\n    run timeline.\n\n- settle(promise) => { status: \"ok\", value } | { status: \"error\", error }\n    Run a lane and capture its outcome instead of letting a failure stop the run\n    \u2014 useful for \"do all of these, some may fail\" fan-outs.\n\n- log(message)  \u2014 write a line to the run's live event feed.\n- ext.<name>(payload) \u2014 call a custom step you registered in orc.config.\n\nBecause leaves can't see each other, pass data between them as plain values:\nput a previous result into the next prompt with JSON.stringify so the receiving\nleaf actually has it. Use normal try/catch, Promise.all/allSettled, and bounded\nloops for control flow.\n\n## What a program may and may not do\n\n- No wall clock or randomness. `Date`, `Math.random`, timers, network, file\n  access, and imports (beyond type-only) are unavailable \u2014 a program only\n  decides which agents to run and how to combine their results.\n- Loops must be finite; an unbounded loop is stopped by a step limit.\n- These constraints let orc replay a program exactly when you resume it, so the\n  same inputs always produce the same run.\n\n## Writing files\n\nBy default leaves are read-only. To let a leaf directly modify files or run\nmutating commands, set `readOnly: false` and launch the run with\n`--allow-writes`. Configured hooks and MCP tools are not disabled for read-only\nleaves; their side effects are outside this guarantee. A write leaf runs with\nwhatever permissions your own agent has; add `--sandbox` to confine its writes\nto the working directory. If a run stops on a write leaf, `orc resume` picks it\nback up (it re-checks the working-tree state first, never blindly redoing work).\n\n## 2. Validate and launch\n\n    orc validate --program-path ./my.orc.ts       # compile + preview, no run\n    orc launch   --program-path ./my.orc.ts --brief \"what this run is for\"\n\n`--brief` (required) is shared context added to every leaf. Common launch flags:\n`--allow-writes`, `--host <ssh>`, `--approval-mode manual|accept-edits|auto|bypass`,\n`--sandbox`, `--harness claude|codex`, `--budget <usd>` (fail the run after\nobserved estimated cost exceeds this; concurrent work may overshoot), `--wait`\n(block for the result instead of running in the background).\n\n## 3. Watch and collect\n\n    orc status     --run-id <id>       # summary\n    orc wait       --run-id <id>       # block until it finishes\n    orc get-result --run-id <id>       # the final result (or --seq N for one leaf)\n    orc trace      --run-id <id>       # per-leaf and per-tool detail\n    orc open       --run-id <id>       # open the live monitor, print its URL\n    orc list                           # recent runs\n\n## 4. Approvals\n\nIn `manual` or `accept-edits` mode a leaf can pause to ask permission for a\ntool. Answer it from anywhere:\n\n    orc approvals --run-id <id>\n    orc respond   --run-id <id> --approval-id <aid> --behavior allow|deny\n\n## Discover more\n\n    orc --help                 # every command\n    orc <command> --help       # a command's flags\n    orc commands               # JSON catalog of all operations\n    orc capabilities           # available harnesses, models, and reasoning levels\n    orc doctor --host <ssh>    # check a local or remote machine is ready\n\nEvery command supports `--json`. Run state lives in `$ORC_HOME` (default\n`~/.orc`). Real runs need `claude` and/or `codex` installed and logged in.\n";

package/dist/guide.js

@@ -0,0 +1,145 @@
+/**
+ * The orc authoring + usage guide. One source of truth surfaced by:
+ *  - CLI:  `orc guide`
+ *  - MCP:  the `orc_guide` tool
+ */
+export const GUIDE = `# orc — how to write and run a program
+
+orc runs a "program": a script that fans out AI-agent subtasks ("leaves") and
+records each one, so a run is reproducible, resumable, and observable. You write
+a program, launch it, then watch it and collect the result.
+
+## 1. Write a program
+
+A program is a \`.orc.ts\` file with a single default-exported async function.
+It receives an api object and returns the run's result:
+
+    import type { Program } from "@karowanorg/orc-sdk/program"; // optional, type-only
+
+    const program: Program = async ({ agent, parallel, phase }) => {
+      const inventory = await agent("List the modules in this repo.", {
+        schema: { type: "object",
+                  properties: { modules: { type: "array", items: { type: "string" } } },
+                  required: ["modules"] },
+      });
+
+      // Ordinary async/await controls the flow. Awaiting a result before the
+      // next call makes it a dependency; independent calls run concurrently.
+      const plans = await Promise.all((inventory.modules as string[]).map(async (m) => {
+        const findings = await agent(\`Audit module \${m}\`, { id: \`audit-\${m}\` });
+        return agent(\`Plan a fix for \${m}: \${JSON.stringify(findings)}\`, { id: \`plan-\${m}\` });
+      }));
+
+      return phase("synthesis", () => agent(\`Merge these plans: \${JSON.stringify(plans)}\`, { id: "merge" }));
+    };
+    export default program;
+
+## The api
+
+IMPORTANT — leaves are isolated. Each agent() runs a FRESH subagent that shares
+NONE of your context: it cannot see this program, your conversation, other
+leaves' prompts or results, or anything you know that you haven't written into
+its prompt (plus the shared \`--brief\`).
+
+- agent(prompt, opts?) => Promise<result>
+    Dispatch one agent. Returns its result (matching \`schema\` if you pass one).
+    A failed leaf rejects the promise, so wrap it in try/catch if you want to
+    handle failure. Options:
+      id               a label shown in the monitor
+      schema           JSON Schema; the result is structured output matching it
+      harness          "claude" | "codex" | a configured harness (default: auto)
+      model            e.g. "claude-fable-5", "gpt-5.6-sol"
+      reasoningEffort  "low" | "medium" | "high" | "xhigh" | "max"
+      readOnly         default true; set false for a leaf that edits files
+      cwd              working directory for this leaf (defaults to the run's)
+      host             SSH destination to run this leaf on a remote machine
+      idleTimeout      ms with no output before the leaf is killed (false = off)
+      phase            group this call under a phase label
+    To see valid \`harness\`, \`model\`, and \`reasoningEffort\` values for your
+    machine, run \`orc capabilities\` (or \`orc capabilities --json\`) — it lists
+    each installed harness with its available models and reasoning levels.
+    Omit any of them to use the default; an unknown value is rejected up front
+    by \`orc validate\`.
+
+- parallel(specs[]) => Promise<outcomes[]>
+    Run several agents at once from an array of option objects (each with a
+    \`prompt\`). Every lane runs to completion INDEPENDENTLY — one lane failing
+    never cancels the others. Outcomes come back in order as
+    \`{ status: "ok", value } | { status: "error", error }\`, so you decide how to
+    handle partial failure. (For fail-fast, use \`Promise.all\` over \`agent()\`,
+    which rejects on the first failure.)
+
+- phase(name, fn) => Promise<result>
+    Group every agent() call made inside \`fn\` under a phase, for a readable
+    run timeline.
+
+- settle(promise) => { status: "ok", value } | { status: "error", error }
+    Run a lane and capture its outcome instead of letting a failure stop the run
+    — useful for "do all of these, some may fail" fan-outs.
+
+- log(message)  — write a line to the run's live event feed.
+- ext.<name>(payload) — call a custom step you registered in orc.config.
+
+Because leaves can't see each other, pass data between them as plain values:
+put a previous result into the next prompt with JSON.stringify so the receiving
+leaf actually has it. Use normal try/catch, Promise.all/allSettled, and bounded
+loops for control flow.
+
+## What a program may and may not do
+
+- No wall clock or randomness. \`Date\`, \`Math.random\`, timers, network, file
+  access, and imports (beyond type-only) are unavailable — a program only
+  decides which agents to run and how to combine their results.
+- Loops must be finite; an unbounded loop is stopped by a step limit.
+- These constraints let orc replay a program exactly when you resume it, so the
+  same inputs always produce the same run.
+
+## Writing files
+
+By default leaves are read-only. To let a leaf directly modify files or run
+mutating commands, set \`readOnly: false\` and launch the run with
+\`--allow-writes\`. Configured hooks and MCP tools are not disabled for read-only
+leaves; their side effects are outside this guarantee. A write leaf runs with
+whatever permissions your own agent has; add \`--sandbox\` to confine its writes
+to the working directory. If a run stops on a write leaf, \`orc resume\` picks it
+back up (it re-checks the working-tree state first, never blindly redoing work).
+
+## 2. Validate and launch
+
+    orc validate --program-path ./my.orc.ts       # compile + preview, no run
+    orc launch   --program-path ./my.orc.ts --brief "what this run is for"
+
+\`--brief\` (required) is shared context added to every leaf. Common launch flags:
+\`--allow-writes\`, \`--host <ssh>\`, \`--approval-mode manual|accept-edits|auto|bypass\`,
+\`--sandbox\`, \`--harness claude|codex\`, \`--budget <usd>\` (fail the run after
+observed estimated cost exceeds this; concurrent work may overshoot), \`--wait\`
+(block for the result instead of running in the background).
+
+## 3. Watch and collect
+
+    orc status     --run-id <id>       # summary
+    orc wait       --run-id <id>       # block until it finishes
+    orc get-result --run-id <id>       # the final result (or --seq N for one leaf)
+    orc trace      --run-id <id>       # per-leaf and per-tool detail
+    orc open       --run-id <id>       # open the live monitor, print its URL
+    orc list                           # recent runs
+
+## 4. Approvals
+
+In \`manual\` or \`accept-edits\` mode a leaf can pause to ask permission for a
+tool. Answer it from anywhere:
+
+    orc approvals --run-id <id>
+    orc respond   --run-id <id> --approval-id <aid> --behavior allow|deny
+
+## Discover more
+
+    orc --help                 # every command
+    orc <command> --help       # a command's flags
+    orc commands               # JSON catalog of all operations
+    orc capabilities           # available harnesses, models, and reasoning levels
+    orc doctor --host <ssh>    # check a local or remote machine is ready
+
+Every command supports \`--json\`. Run state lives in \`$ORC_HOME\` (default
+\`~/.orc\`). Real runs need \`claude\` and/or \`codex\` installed and logged in.
+`;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ops.js";
+export * from "./registry.js";
+export * from "./supervisor-run.js";
+export { GUIDE } from "./guide.js";
+export { makeExecHarness } from "./exec-harness.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./ops.js";
+export * from "./registry.js";
+export * from "./supervisor-run.js";
+export { GUIDE } from "./guide.js";
+export { makeExecHarness } from "./exec-harness.js";

package/dist/ops.d.ts

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import { type Json, type Registry, type RunStatus } from "@karowanorg/orc-core";
+export interface OpContext {
+    registry: Registry;
+    registryCwd?: string;
+    mcpClientName?: string;
+}
+export interface OpDef<I extends z.ZodType = z.ZodType, O = unknown> {
+    name: string;
+    doc: string;
+    readOnly: boolean;
+    input: I;
+    handler(input: z.infer<I>, ctx: OpContext): Promise<O>;
+}
+interface FirstFrontierCall {
+    seq: number;
+    kind: string;
+    id?: string;
+    readOnly: boolean;
+    harness?: string;
+    host?: string;
+    model?: string;
+    reasoningEffort?: string;
+    schema?: Json;
+    promptPreview?: string;
+}
+export declare const launch: OpDef<z.ZodObject<{
+    programPath: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    brief: z.ZodString;
+    allowWrites: z.ZodDefault<z.ZodBoolean>;
+    approvalMode: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        "accept-edits": "accept-edits";
+        auto: "auto";
+        bypass: "bypass";
+    }>>;
+    sandbox: z.ZodDefault<z.ZodBoolean>;
+    sandboxDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    budget: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    harness: z.ZodOptional<z.ZodString>;
+    wait: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    runId: string;
+    requestsWrite: boolean;
+    monitorUrl: string;
+    reportPath: string;
+    status: RunStatus;
+    allowWrites?: undefined;
+    approvalMode?: undefined;
+    wait?: undefined;
+} | {
+    runId: string;
+    requestsWrite: boolean;
+    allowWrites: boolean;
+    approvalMode: import("@karowanorg/orc-core").ApprovalMode;
+    monitorUrl: string;
+    reportPath: string;
+    wait: {
+        op: string;
+        input: {
+            runId: string;
+            timeoutSeconds: number;
+        };
+    };
+    status?: undefined;
+}>;
+export declare const validate: OpDef<z.ZodObject<{
+    programPath: z.ZodString;
+    allowWrites: z.ZodDefault<z.ZodBoolean>;
+    approvalMode: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        "accept-edits": "accept-edits";
+        auto: "auto";
+        bypass: "bypass";
+    }>>;
+    harness: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    checkCapabilities: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    ok: boolean;
+    sha256: string;
+    requestsWrite: boolean;
+    firstCalls: FirstFrontierCall[];
+    problems: string[];
+}>;
+export declare const status: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>, RunStatus>;
+export declare const wait: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+    timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, {
+    outcome: "completed" | "failed" | "cancelled";
+    timedOut: boolean;
+    status: RunStatus;
+    retry?: undefined;
+} | {
+    outcome: string;
+    timedOut: boolean;
+    status: RunStatus;
+    retry: {
+        op: string;
+        input: {
+            runId: string;
+            timeoutSeconds: number;
+        };
+    };
+}>;
+export declare const getResult: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+    seq: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, {
+    body: Json;
+    sha256: string;
+}>;
+export declare const getTrace: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>, {
+    status: RunStatus;
+    traces: (import("@karowanorg/orc-core").RunEventRecord | import("@karowanorg/orc-core").HarnessLogRecord | {
+        prompt: string | undefined;
+        brief: string | undefined;
+        error: string | undefined;
+        t: "leaf";
+        seq: number;
+        attempt: number;
+        rev: number;
+        status: "running" | "ok" | "error";
+        id?: string;
+        phase?: string;
+        kind: string;
+        harness?: string;
+        model?: string;
+        reasoningEffort?: string;
+        host?: string;
+        cwd?: string;
+        readOnly: boolean;
+        startMs: number;
+        endMs?: number;
+        output?: Json;
+        sessionId?: string;
+        toolCalls?: import("@karowanorg/orc-core").ToolCallTrace[];
+        tokensIn?: number;
+        tokensOut?: number;
+        costUsd?: number;
+        costEstimated?: boolean;
+        reoriented?: boolean;
+    })[];
+}>;
+export declare const list: OpDef<z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, {
+    runId: string;
+    name: string | undefined;
+    state: string;
+    createdAtMs: number;
+    host: string | undefined;
+    cwd: string;
+}[]>;
+export declare const cancel: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>, {
+    enqueued: boolean;
+}>;
+export declare const resume: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+    wait: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    runId: string;
+    status: RunStatus;
+    resumed?: undefined;
+} | {
+    runId: string;
+    resumed: boolean;
+    status?: undefined;
+}>;
+export declare const listApprovals: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>, import("@karowanorg/orc-core").ApprovalRequest[]>;
+export declare const respondApproval: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+    approvalId: z.ZodString;
+    behavior: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    enqueued: boolean;
+}>;
+export declare const capabilities: OpDef<z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    refresh: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    host: string;
+    defaultHarness: string;
+    harnesses: Record<string, unknown>;
+    extensions: string[];
+}>;
+export declare const openMonitor: OpDef<z.ZodObject<{
+    runId: z.ZodOptional<z.ZodString>;
+    browser: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    url: string;
+}>;
+export declare const report: OpDef<z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>, {
+    path: string;
+}>;
+export declare const guide: OpDef<z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    probe: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, {
+    guide: string;
+}>;
+export declare const doctor: OpDef<z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    host: string;
+    checks: Record<string, unknown>;
+}>;
+export declare const ALL_OPS: OpDef[];
+/** Machine-readable catalog for `orc commands --json` and agent discovery. */
+export declare function catalog(): Json;
+/** Start the package-owned detached supervisor and wait for its startup signal. */
+export declare function spawnDetachedSupervisor(runId: string, registryCwd?: string): Promise<void>;
+export {};