@karowanorg/orc-harness-claude 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-harness-claude
+
+Claude harness for orc: Anthropic Agent SDK locally, claude CLI stream-json over SSH.
+
+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/index.d.ts

@@ -0,0 +1,10 @@
+export declare function systemClaudePath(): string | undefined;
+import type { Harness, Json } from "@karowanorg/orc-core";
+export declare const claudeHarness: Harness;
+/** Normalize a tool_result content field into a bounded string for the trace. */
+export declare function toolResultText(content: unknown): Json;
+/**
+ * Best-effort: parse the final text as JSON, else scan (string-aware) for the
+ * last top-level balanced {...} that parses.
+ */
+export declare function extractJson(text: string): Json;

package/dist/index.js

@@ -0,0 +1,643 @@
+/**
+ * The claude harness — built-in harness #1.
+ *
+ * Two transports behind one contract:
+ * - LOCAL (no host): @anthropic-ai/claude-agent-sdk `query()` — richest path:
+ *   canUseTool approval bridging, settingSources (user's own settings are the
+ *   policy substrate), native structured output, session resume. Note the SDK
+ *   still SPAWNS the bundled CLI as a subprocess (verified in sdk source) — the
+ *   SDK owns that child's lifecycle; cancellation goes through abortController.
+ * - REMOTE (host set): the claude CLI over the executor (ssh), speaking the
+ *   same stream-json protocol. v1 remote supports approval modes auto/bypass
+ *   only (manual/accept-edits need an approval back-channel — fail closed).
+ *
+ * Approval-mode mapping (verified against SDK 0.3.215 types):
+ * - manual       -> permissionMode "default"  + canUseTool -> requestApproval
+ * - accept-edits -> permissionMode "acceptEdits" + canUseTool for the rest
+ * - auto         -> permissionMode "dontAsk"  (deny-and-report; NOT "default",
+ *                   which prompts — the verified correction)
+ * - bypass       -> permissionMode "bypassPermissions" + allowDangerouslySkipPermissions
+ *
+ * Read-only scoping uses disallowedTools (NOT bare allowedTools, which
+ * auto-approves before canUseTool — the verified interplay defect). Inherited
+ * settings and MCP tools are not disabled; side effects from configured hooks
+ * and integrations are outside the narrow direct command/filesystem guarantee.
+ */
+import * as path from "node:path";
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * orc does NOT bundle the Claude Code CLI — the system `claude` is a
+ * prerequisite. Point the Agent SDK at it (never its own bundled binary, which
+ * we don't install). Override with ORC_CLAUDE_PATH.
+ */
+let cachedClaudePath;
+export function systemClaudePath() {
+    if (cachedClaudePath !== undefined)
+        return cachedClaudePath ?? undefined;
+    const env = process.env.ORC_CLAUDE_PATH;
+    if (env && existsSync(env))
+        return (cachedClaudePath = env);
+    try {
+        const cmd = process.platform === "win32" ? "where" : "which";
+        const found = execFileSync(cmd, ["claude"], { encoding: "utf8" }).split("\n")[0]?.trim();
+        cachedClaudePath = found && existsSync(found) ? found : null;
+    }
+    catch {
+        cachedClaudePath = null;
+    }
+    return cachedClaudePath ?? undefined;
+}
+const WRITE_TOOLS = ["Edit", "Write", "NotebookEdit"];
+const READ_ONLY_DISALLOWED_TOOLS = ["Bash", ...WRITE_TOOLS];
+const POST_EXIT_DRAIN_MS = 10_000;
+export const claudeHarness = {
+    name: "claude",
+    async discover({ executor }) {
+        const version = await executor.run(["claude", "--version"], { timeoutMs: 15_000 }).catch(() => null);
+        if (!version || version.code !== 0) {
+            return {
+                available: false,
+                models: [],
+                approvalModes: [],
+                structuredOutput: false,
+                sessions: false,
+                detail: "claude CLI not found on this executor",
+            };
+        }
+        let models = [];
+        if (!executor.host) {
+            // Native catalog via the SDK's supportedModels control request. Each
+            // ModelInfo carries its OWN supportedEffortLevels (per-model). Point at
+            // the system claude — orc doesn't ship the SDK's bundled CLI.
+            try {
+                const claudePath = systemClaudePath();
+                const q = query({
+                    prompt: "",
+                    options: { maxTurns: 0, ...(claudePath ? { pathToClaudeCodeExecutable: claudePath } : {}) },
+                });
+                // NB: clear the deadline timer once the race settles — an uncleared
+                // setTimeout keeps the Node event loop alive, so the CLI would print
+                // its result and then appear to hang until the timer fired.
+                let deadline;
+                const infos = await Promise.race([
+                    q.supportedModels(),
+                    new Promise((_, rej) => {
+                        deadline = setTimeout(() => rej(new Error("timeout")), 20_000);
+                    }),
+                ]).finally(() => deadline && clearTimeout(deadline));
+                const seen = new Set();
+                for (const m of infos) {
+                    const id = m.resolvedModel ?? m.value;
+                    if (!id || seen.has(id))
+                        continue;
+                    seen.add(id);
+                    const info = m;
+                    models.push({
+                        id,
+                        displayName: info.displayName,
+                        reasoningEfforts: info.supportsEffort === false ? [] : (info.supportedEffortLevels ?? []),
+                    });
+                }
+                await q.interrupt().catch(() => undefined);
+            }
+            catch {
+                /* version-only capability report */
+            }
+        }
+        return {
+            available: true,
+            version: version.stdout.trim().split("\n")[0],
+            models,
+            approvalModes: executor.host ? ["auto", "bypass"] : ["manual", "accept-edits", "auto", "bypass"],
+            structuredOutput: true,
+            sessions: true,
+            detail: executor.host
+                ? "claude CLI over ssh (stream-json); remote approvals limited to auto/bypass in v1"
+                : "Agent SDK; model catalog via supportedModels()",
+        };
+    },
+    invoke(req, ctx) {
+        return req.host ? invokeRemoteCli(req, ctx) : invokeSdk(req, ctx);
+    },
+};
+// ---------------------------------------------------------------------------
+// Local transport: Agent SDK
+// ---------------------------------------------------------------------------
+async function* invokeSdk(req, ctx) {
+    if (ctx.signal.aborted) {
+        yield { kind: "error", message: `aborted: ${String(ctx.signal.reason ?? "cancelled")}` };
+        return;
+    }
+    const abort = new AbortController();
+    const onAbort = () => abort.abort(ctx.signal.reason);
+    ctx.signal.addEventListener("abort", onAbort, { once: true });
+    if (ctx.signal.aborted)
+        onAbort();
+    const bridgeApprovals = !req.readOnly && (req.approvalMode === "manual" || req.approvalMode === "accept-edits");
+    const sandboxWrites = req.sandbox === true && !req.readOnly;
+    const roots = sandboxRoots(req);
+    const permissionMode = req.readOnly
+        ? "dontAsk"
+        : sandboxWrites && (req.approvalMode === "auto" || req.approvalMode === "bypass")
+            ? "default"
+            : req.approvalMode === "manual"
+                ? "default"
+                : req.approvalMode === "accept-edits"
+                    ? "acceptEdits"
+                    : req.approvalMode === "bypass"
+                        ? "bypassPermissions"
+                        : "dontAsk";
+    const canUseTool = bridgeApprovals || sandboxWrites
+        ? async (toolName, input, permission) => {
+            if (sandboxWrites && WRITE_TOOLS.includes(toolName)) {
+                const target = (input.file_path ?? input.notebook_path ?? input.path);
+                const targets = [target, permission.blockedPath].filter((candidate) => typeof candidate === "string");
+                if (targets.length === 0 ||
+                    targets.some((candidate) => !pathWithin(candidate, roots, req.cwd))) {
+                    return {
+                        behavior: "deny",
+                        message: `sandbox: ${toolName} target is outside the allowed roots`,
+                    };
+                }
+                if (!bridgeApprovals) {
+                    return { behavior: "allow", updatedInput: input };
+                }
+            }
+            if (!bridgeApprovals) {
+                return { behavior: "allow", updatedInput: input };
+            }
+            const decision = await ctx.requestApproval({
+                runId: req.runId,
+                seq: req.seq,
+                toolName,
+                input: input,
+            });
+            return decision.behavior === "allow"
+                ? { behavior: "allow", updatedInput: input }
+                : { behavior: "deny", message: decision.message ?? "denied by operator" };
+        }
+        : undefined;
+    const claudePath = systemClaudePath();
+    const options = {
+        cwd: req.cwd,
+        model: req.model,
+        effort: req.reasoningEffort,
+        resume: req.sessionId,
+        abortController: abort,
+        permissionMode,
+        ...(claudePath ? { pathToClaudeCodeExecutable: claudePath } : {}),
+        // Sandboxed write leaves isolate settings because settings can add writable
+        // roots. Read-only deliberately does not disable configured integrations.
+        settingSources: sandboxWrites ? [] : ["user", "project", "local"],
+        strictMcpConfig: sandboxWrites,
+        systemPrompt: { type: "preset", preset: "claude_code", append: req.system },
+        maxTurns: 100,
+        ...(req.approvalMode === "bypass" && !req.readOnly && !sandboxWrites
+            ? { allowDangerouslySkipPermissions: true }
+            : {}),
+        ...(req.readOnly ? { disallowedTools: READ_ONLY_DISALLOWED_TOOLS } : {}),
+        ...(sandboxWrites
+            ? {
+                additionalDirectories: roots.slice(1),
+                sandbox: {
+                    enabled: true,
+                    failIfUnavailable: true,
+                    allowUnsandboxedCommands: false,
+                    filesystem: { allowWrite: roots },
+                },
+            }
+            : {}),
+        ...(req.schema ? { outputFormat: { type: "json_schema", schema: req.schema } } : {}),
+        ...(canUseTool ? { canUseTool } : {}),
+    };
+    // Announce the requested model/effort immediately so the monitor shows them
+    // from the first frame; refine `model` to the SDK's resolved id when it arrives.
+    yield { kind: "model", model: req.model, reasoningEffort: req.reasoningEffort };
+    let reportedModel = req.model;
+    try {
+        for await (const message of query({ prompt: req.prompt, options })) {
+            const m = message.message?.model ??
+                message.model;
+            if (m && m !== reportedModel) {
+                reportedModel = m;
+                yield { kind: "model", model: m, reasoningEffort: req.reasoningEffort };
+            }
+            for (const ev of mapSdkMessage(message))
+                yield ev;
+        }
+    }
+    catch (err) {
+        if (ctx.signal.aborted) {
+            yield { kind: "error", message: `aborted: ${String(ctx.signal.reason ?? "cancelled")}` };
+        }
+        else {
+            yield { kind: "error", message: String(err instanceof Error ? err.message : err) };
+        }
+    }
+    finally {
+        ctx.signal.removeEventListener("abort", onAbort);
+    }
+}
+function* mapSdkMessage(message) {
+    const now = Date.now();
+    if (message.type === "system" && message.subtype === "init") {
+        yield { kind: "session", sessionId: message.session_id };
+    }
+    else if (message.type === "system" && message.subtype === "permission_denied") {
+        yield {
+            kind: "denied",
+            toolName: message.tool_name,
+            reason: message.decision_reason ??
+                message.decision_reason_type ??
+                "denied by permission policy",
+            atMs: now,
+        };
+    }
+    else if (message.type === "assistant") {
+        for (const block of message.message.content ?? []) {
+            if (typeof block === "object" && block !== null && block.type === "tool_use") {
+                const b = block;
+                yield { kind: "tool-call-open", id: b.id, name: b.name, input: b.input, atMs: now };
+            }
+        }
+    }
+    else if (message.type === "user") {
+        const content = message.message?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (typeof block === "object" && block !== null && block.type === "tool_result") {
+                    const b = block;
+                    yield {
+                        kind: "tool-call-close",
+                        id: b.tool_use_id,
+                        status: b.is_error ? "error" : "ok",
+                        result: toolResultText(b.content),
+                        atMs: now,
+                    };
+                }
+            }
+        }
+    }
+    else if (message.type === "result") {
+        const usage = message.usage;
+        yield {
+            kind: "usage",
+            tokensIn: usage?.input_tokens,
+            tokensOut: usage?.output_tokens,
+            costUsd: message.total_cost_usd,
+        };
+        if (message.subtype === "success") {
+            const structured = message.structured_output;
+            if (structured !== undefined) {
+                yield { kind: "result", output: structured };
+            }
+            else {
+                yield { kind: "result", output: extractJson(message.result) };
+            }
+        }
+        else {
+            yield { kind: "error", message: `claude leaf failed: ${message.subtype}` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Remote transport: claude CLI over the executor (same stream-json protocol)
+// ---------------------------------------------------------------------------
+async function* invokeRemoteCli(req, ctx) {
+    if (ctx.signal.aborted) {
+        yield { kind: "error", message: `aborted: ${String(ctx.signal.reason ?? "cancelled")}` };
+        return;
+    }
+    if (req.approvalMode === "manual" || req.approvalMode === "accept-edits") {
+        yield {
+            kind: "error",
+            message: `approval mode "${req.approvalMode}" is not supported for remote claude leaves in v1 ` +
+                `(no approval back-channel over ssh yet) — use auto or bypass, fail-closed`,
+        };
+        return;
+    }
+    const args = ["claude", "-p", "--verbose", "--output-format", "stream-json"];
+    const sandboxWrites = req.sandbox === true && !req.readOnly;
+    if (sandboxWrites) {
+        args.push("--permission-mode", "acceptEdits");
+    }
+    else if (req.approvalMode === "bypass" && !req.readOnly) {
+        args.push("--permission-mode", "bypassPermissions", "--dangerously-skip-permissions");
+    }
+    else {
+        args.push("--permission-mode", "dontAsk");
+    }
+    const roots = sandboxRoots(req);
+    if (req.readOnly)
+        args.push("--disallowedTools", READ_ONLY_DISALLOWED_TOOLS.join(","));
+    if (sandboxWrites)
+        args.push("--setting-sources=", "--strict-mcp-config");
+    if (sandboxWrites) {
+        args.push("--settings", JSON.stringify({
+            sandbox: {
+                enabled: true,
+                failIfUnavailable: true,
+                allowUnsandboxedCommands: false,
+                filesystem: { allowWrite: roots },
+            },
+        }));
+        for (const root of roots.slice(1))
+            args.push("--add-dir", root);
+    }
+    if (req.model)
+        args.push("--model", req.model);
+    if (req.sessionId)
+        args.push("--resume", req.sessionId);
+    if (req.system)
+        args.push("--append-system-prompt", req.system);
+    if (req.schema)
+        args.push("--json-schema", JSON.stringify(req.schema));
+    const proc = ctx.executor.spawn(args, { cwd: req.cwd, stdin: "pipe" });
+    const onAbort = () => proc.kill();
+    ctx.signal.addEventListener("abort", onAbort, { once: true });
+    if (ctx.signal.aborted)
+        onAbort();
+    const stderrDone = drainStderr(proc.stderr, ctx.log);
+    const cancelStdoutGuard = guardPostExitDrain(proc.stdout, proc.exited, "stdout", ctx.log);
+    const cancelStderrGuard = guardPostExitDrain(proc.stderr, proc.exited, "stderr", ctx.log);
+    let stdinError;
+    if (!proc.stdin) {
+        ctx.signal.removeEventListener("abort", onAbort);
+        proc.kill();
+        destroyStream(proc.stdout);
+        await stderrDone;
+        cancelStdoutGuard();
+        cancelStderrGuard();
+        yield { kind: "error", message: "remote claude stdin is unavailable" };
+        return;
+    }
+    proc.stdin.on("error", (err) => {
+        stdinError = err;
+        if (err.code !== "EPIPE")
+            proc.kill();
+    });
+    try {
+        proc.stdin.end(req.prompt);
+    }
+    catch (err) {
+        stdinError = err instanceof Error ? err : new Error(String(err));
+        proc.kill();
+    }
+    yield { kind: "model", model: req.model, reasoningEffort: req.reasoningEffort };
+    let sawResult = false;
+    try {
+        try {
+            for await (const line of lines(proc.stdout)) {
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue; // non-JSON noise
+                }
+                for (const ev of mapCliLine(msg)) {
+                    if (ev.kind === "result")
+                        sawResult = true;
+                    yield ev;
+                }
+            }
+        }
+        finally {
+            cancelStdoutGuard();
+        }
+        const code = await proc.exited;
+        if (!sawResult) {
+            yield {
+                kind: "error",
+                message: stdinError
+                    ? `remote claude stdin failed: ${stdinError.message}`
+                    : `remote claude exited with code ${code} without a result`,
+            };
+        }
+    }
+    finally {
+        ctx.signal.removeEventListener("abort", onAbort);
+        proc.kill();
+        await stderrDone;
+        cancelStdoutGuard();
+        cancelStderrGuard();
+    }
+}
+function* mapCliLine(msg) {
+    const now = Date.now();
+    const type = msg.type;
+    if (type === "system" && msg.subtype === "init" && typeof msg.session_id === "string") {
+        yield { kind: "session", sessionId: msg.session_id };
+    }
+    else if (type === "assistant") {
+        const content = msg.message?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                const b = block;
+                if (b.type === "tool_use" && b.id && b.name) {
+                    yield { kind: "tool-call-open", id: b.id, name: b.name, input: b.input, atMs: now };
+                }
+            }
+        }
+    }
+    else if (type === "user") {
+        const content = msg.message?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                const b = block;
+                if (b.type === "tool_result" && b.tool_use_id) {
+                    yield {
+                        kind: "tool-call-close",
+                        id: b.tool_use_id,
+                        status: b.is_error ? "error" : "ok",
+                        result: toolResultText(b.content),
+                        atMs: now,
+                    };
+                }
+            }
+        }
+    }
+    else if (type === "result") {
+        const usage = msg.usage;
+        yield {
+            kind: "usage",
+            tokensIn: usage?.input_tokens,
+            tokensOut: usage?.output_tokens,
+            costUsd: msg.total_cost_usd,
+        };
+        if (msg.subtype === "success") {
+            if (msg.structured_output !== undefined) {
+                yield { kind: "result", output: msg.structured_output };
+            }
+            else {
+                yield { kind: "result", output: extractJson(String(msg.result ?? "")) };
+            }
+        }
+        else {
+            yield { kind: "error", message: `claude leaf failed: ${String(msg.subtype)}` };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+async function* lines(stream) {
+    let buf = "";
+    try {
+        for await (const chunk of stream) {
+            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)
+                    yield line;
+            }
+        }
+    }
+    catch (err) {
+        if (err.code !== "ERR_STREAM_PREMATURE_CLOSE")
+            throw err;
+    }
+    if (buf.trim())
+        yield buf.trim();
+}
+function sandboxRoots(req) {
+    return [
+        ...new Set([req.cwd, ...(req.sandboxDirs ?? [])].map((root) => path.normalize(path.isAbsolute(root) ? root : path.resolve(req.cwd, root)))),
+    ];
+}
+function pathWithin(target, roots, cwd) {
+    const candidate = path.resolve(cwd, target);
+    return roots.some((root) => {
+        const rel = path.relative(root, candidate);
+        return rel === "" || (rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel));
+    });
+}
+function guardPostExitDrain(stream, exited, name, log) {
+    let cancelled = false;
+    let timer;
+    void exited.then(() => {
+        if (cancelled)
+            return;
+        timer = setTimeout(() => {
+            log(`remote claude ${name} remained open after exit; stopping drain`);
+            destroyStream(stream);
+        }, POST_EXIT_DRAIN_MS);
+        timer.unref?.();
+    });
+    return () => {
+        cancelled = true;
+        if (timer)
+            clearTimeout(timer);
+    };
+}
+function destroyStream(stream) {
+    stream.destroy?.();
+}
+async function drainStderr(stream, log) {
+    let buf = "";
+    try {
+        for await (const chunk of stream) {
+            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)
+                    log(line);
+            }
+        }
+    }
+    catch (err) {
+        if (err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+            log(`remote claude stderr read failed: ${String(err)}`);
+        }
+    }
+    finally {
+        if (buf.trim())
+            log(buf.trim());
+    }
+}
+/** Normalize a tool_result content field into a bounded string for the trace. */
+export function toolResultText(content) {
+    const MAX = 8 * 1024;
+    let text;
+    if (typeof content === "string") {
+        text = content;
+    }
+    else if (Array.isArray(content)) {
+        text = content
+            .map((b) => {
+            if (typeof b === "string")
+                return b;
+            if (b && typeof b === "object" && typeof b.text === "string") {
+                return b.text;
+            }
+            return JSON.stringify(b);
+        })
+            .join("\n");
+    }
+    else if (content === undefined || content === null) {
+        return null;
+    }
+    else {
+        text = JSON.stringify(content);
+    }
+    return text.length > MAX ? text.slice(0, MAX) + `\n… [truncated ${text.length - MAX} chars]` : text;
+}
+/**
+ * Best-effort: parse the final text as JSON, else scan (string-aware) for the
+ * last top-level balanced {...} that parses.
+ */
+export function extractJson(text) {
+    const trimmed = text.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        /* fall through */
+    }
+    let last;
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < trimmed.length; i++) {
+        const c = trimmed[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (c === "\\")
+                escaped = true;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"') {
+            if (depth > 0)
+                inString = true;
+            continue;
+        }
+        if (c === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (c === "}") {
+            if (depth > 0) {
+                depth--;
+                if (depth === 0 && start >= 0) {
+                    try {
+                        last = JSON.parse(trimmed.slice(start, i + 1));
+                    }
+                    catch {
+                        /* not a JSON object after all */
+                    }
+                    start = -1;
+                }
+            }
+        }
+    }
+    return last ?? { text: trimmed };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@karowanorg/orc-harness-claude",
+  "version": "0.1.0",
+  "license": "0BSD",
+  "type": "module",
+  "main": "dist/index.js",
+  "dependencies": {
+    "@karowanorg/orc-core": "^0.1.0",
+    "@karowanorg/orc-executors": "^0.1.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.0",
+    "zod": "^4.1.0"
+  },
+  "description": "Claude harness for orc: Anthropic Agent SDK locally, claude CLI stream-json over SSH.",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}