@oneharness/sdk 0.3.22

package/dist/generated/zod.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { ActionEvent, BatchReport, FailureKind, FallThrough, FallbackReport, OutputFormat, RunReport, RunResult, SessionReport, Status, Usage } from "./contracts.js";
+import type { DetectInfo, DetectReport } from "./detection.js";
+import type { HistoryRecord } from "./history.js";
+import type { HistoryList, HistorySessionSummary } from "./history-list.js";
+import type { HistoryListOptions } from "./history-list-options.js";
+import type { HistoryLookup, HistoryLookupByLast, HistoryLookupBySession } from "./history-lookup.js";
+import type { HistoryRecords } from "./history-records.js";
+import type { PermissionMode, RunOptions } from "./options.js";
+import type { HarnessInfo, ListReport, ModeInfo } from "./registry.js";
+export type BatchStrategy = BatchReport["strategy"];
+export type ModeHeadless = ModeInfo["headless"];
+export type SessionPhase = SessionReport["phase"];
+export declare const ActionEventSchema: z.ZodType<ActionEvent>;
+export declare const BatchReportSchema: z.ZodType<BatchReport>;
+export declare const BatchStrategySchema: z.ZodType<BatchStrategy>;
+export declare const DetectInfoSchema: z.ZodType<DetectInfo>;
+export declare const DetectReportSchema: z.ZodType<DetectReport>;
+export declare const FailureKindSchema: z.ZodType<FailureKind>;
+export declare const FallThroughSchema: z.ZodType<FallThrough>;
+export declare const FallbackReportSchema: z.ZodType<FallbackReport>;
+export declare const HarnessInfoSchema: z.ZodType<HarnessInfo>;
+export declare const HistoryListSchema: z.ZodType<HistoryList>;
+export declare const HistoryListOptionsSchema: z.ZodType<HistoryListOptions>;
+export declare const HistoryLookupSchema: z.ZodType<HistoryLookup>;
+export declare const HistoryLookupByLastSchema: z.ZodType<HistoryLookupByLast>;
+export declare const HistoryLookupBySessionSchema: z.ZodType<HistoryLookupBySession>;
+export declare const HistoryRecordSchema: z.ZodType<HistoryRecord>;
+export declare const HistoryRecordsSchema: z.ZodType<HistoryRecords>;
+export declare const HistorySessionSummarySchema: z.ZodType<HistorySessionSummary>;
+export declare const ListReportSchema: z.ZodType<ListReport>;
+export declare const ModeHeadlessSchema: z.ZodType<ModeHeadless>;
+export declare const ModeInfoSchema: z.ZodType<ModeInfo>;
+export declare const OutputFormatSchema: z.ZodType<OutputFormat>;
+export declare const PermissionModeSchema: z.ZodType<PermissionMode>;
+export declare const RunOptionsSchema: z.ZodType<RunOptions>;
+export declare const RunReportSchema: z.ZodType<RunReport>;
+export declare const RunResultSchema: z.ZodType<RunResult>;
+export declare const SessionPhaseSchema: z.ZodType<SessionPhase>;
+export declare const SessionReportSchema: z.ZodType<SessionReport>;
+export declare const StatusSchema: z.ZodType<Status>;
+export declare const UsageSchema: z.ZodType<Usage>;

package/dist/generated/zod.js

@@ -0,0 +1,268 @@
+/* Generated from oneharness Rust JSON Schemas. Do not edit. */
+import { z } from "zod";
+export const ActionEventSchema = z.looseObject({
+    index: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    input: z.unknown().refine((value) => value !== undefined, { message: "Required" }),
+    kind: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    name: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    output: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const BatchReportSchema = z.looseObject({
+    forked: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    prompt_count: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    strategy: z.lazy(() => BatchStrategySchema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const BatchStrategySchema = z.union([z.literal("speed"), z.literal("min-tokens")]);
+export const DetectInfoSchema = z.looseObject({
+    available: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    bin: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    id: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    path: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    version: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const DetectReportSchema = z.looseObject({
+    detected: z.array(z.lazy(() => DetectInfoSchema)).refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+});
+export const FailureKindSchema = z.union([
+    z.literal("auth"),
+    z.literal("rate_limit"),
+    z.literal("model_not_found"),
+    z.literal("quota"),
+    z.literal("tool_deferred"),
+]);
+export const FallThroughSchema = z.looseObject({
+    harness: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    reason: z.string().refine((value) => value !== undefined, { message: "Required" }),
+});
+export const FallbackReportSchema = z.looseObject({
+    fell_through: z
+        .array(z.lazy(() => FallThroughSchema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    ran: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HarnessInfoSchema = z.looseObject({
+    default_bin: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    display: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    example_command: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    fork_reuses_cache: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    id: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    install_hint: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    mock_rewrite: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    modes: z.array(z.lazy(() => ModeInfoSchema)).refine((value) => value !== undefined, { message: "Required" }),
+    output_format: z.lazy(() => OutputFormatSchema).refine((value) => value !== undefined, { message: "Required" }),
+    session_capable: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_allowed_tools: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_denied_tools: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_fork: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_hooks: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_mock_deny: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_native_schema: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_prompt_stdin: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_reasoning: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_resume: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    supports_system_file: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    sync_file: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HistoryListSchema = z.array(z.lazy(() => HistorySessionSummarySchema));
+export const HistoryListOptionsSchema = z.strictObject({
+    allProjects: z.boolean().optional(),
+    historyDir: z.string().optional(),
+    project: z.string().optional(),
+});
+export const HistoryLookupSchema = z.union([
+    z.lazy(() => HistoryLookupByLastSchema),
+    z.lazy(() => HistoryLookupBySessionSchema),
+]);
+export const HistoryLookupByLastSchema = z.strictObject({
+    allProjects: z.boolean().optional(),
+    historyDir: z.string().optional(),
+    last: z.literal(true).refine((value) => value !== undefined, { message: "Required" }),
+    project: z.string().optional(),
+    session: z.string().optional(),
+});
+export const HistoryLookupBySessionSchema = z.strictObject({
+    allProjects: z.boolean().optional(),
+    historyDir: z.string().optional(),
+    last: z.boolean().optional(),
+    project: z.string().optional(),
+    session: z
+        .string()
+        .min(1)
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HistoryRecordSchema = z.looseObject({
+    duration_ms: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    events: z
+        .union([z.array(z.lazy(() => ActionEventSchema)), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    exit_code: z.union([z.int(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    failure_kind: z
+        .union([z.lazy(() => FailureKindSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    harness: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    model: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    name: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    permission_mode: z.lazy(() => PermissionModeSchema).refine((value) => value !== undefined, { message: "Required" }),
+    project: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    prompt: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    session: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    session_id: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    status: z.lazy(() => StatusSchema).refine((value) => value !== undefined, { message: "Required" }),
+    text: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    text_source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    timestamp: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    usage: z.lazy(() => UsageSchema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const HistoryRecordsSchema = z.array(z.lazy(() => HistoryRecordSchema));
+export const HistorySessionSummarySchema = z.looseObject({
+    harnesses: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    id: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    name: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    path: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    project: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    record_count: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    started: z.string().refine((value) => value !== undefined, { message: "Required" }),
+});
+export const ListReportSchema = z.looseObject({
+    harnesses: z.array(z.lazy(() => HarnessInfoSchema)).refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+});
+export const ModeHeadlessSchema = z.union([z.literal("clean"), z.literal("hangs")]);
+export const ModeInfoSchema = z.looseObject({
+    headless: z.lazy(() => ModeHeadlessSchema).refine((value) => value !== undefined, { message: "Required" }),
+    mode: z.lazy(() => PermissionModeSchema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const OutputFormatSchema = z.union([
+    z.literal("text"),
+    z.literal("json"),
+    z.literal("stream-json"),
+]);
+export const PermissionModeSchema = z.union([
+    z.literal("read-only"),
+    z.literal("plan"),
+    z.literal("default"),
+    z.literal("edit"),
+    z.literal("auto"),
+    z.literal("bypass"),
+]);
+export const RunOptionsSchema = z.strictObject({
+    bins: z.record(z.string(), z.string()).optional(),
+    cwd: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    events: z.boolean().optional(),
+    fork: z.boolean().optional(),
+    harnesses: z.array(z.string()).optional(),
+    history: z.boolean().optional(),
+    historyDir: z.string().optional(),
+    historyName: z.string().optional(),
+    mode: z.lazy(() => PermissionModeSchema).optional(),
+    models: z.array(z.string()).optional(),
+    prompt: z
+        .string()
+        .min(1)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    reasoning: z.string().optional(),
+    resume: z.string().optional(),
+    session: z.string().optional(),
+    system: z.string().optional(),
+    timeoutSeconds: z.int().gte(0).optional(),
+});
+export const RunReportSchema = z.looseObject({
+    batch: z
+        .union([z.lazy(() => BatchReportSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    bypass_permissions: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    config_files: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    dry_run: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    fallback: z
+        .union([z.lazy(() => FallbackReportSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    fork: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    history_file: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    mock_rules: z.unknown().refine((value) => value !== undefined, { message: "Required" }),
+    model: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    models: z.union([z.array(z.string()), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    oneharness_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    permission_mode: z.lazy(() => PermissionModeSchema).refine((value) => value !== undefined, { message: "Required" }),
+    prompt: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    results: z.array(z.lazy(() => RunResultSchema)).refine((value) => value !== undefined, { message: "Required" }),
+    resume: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    schema: z.unknown().refine((value) => value !== undefined, { message: "Required" }),
+    schema_max_retries: z
+        .union([z.int().gte(0), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    schema_version: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    session: z
+        .union([z.lazy(() => SessionReportSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    spy_file: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const RunResultSchema = z.looseObject({
+    available: z.boolean().refine((value) => value !== undefined, { message: "Required" }),
+    bin: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    command: z.array(z.string()).refine((value) => value !== undefined, { message: "Required" }),
+    duration_ms: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    error: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    events: z
+        .union([z.array(z.lazy(() => ActionEventSchema)), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    events_source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    exit_code: z.union([z.int(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    failure_kind: z
+        .union([z.lazy(() => FailureKindSchema), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    failure_kind_source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    harness: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    model: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    output_format: z.lazy(() => OutputFormatSchema).refine((value) => value !== undefined, { message: "Required" }),
+    prompt: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    schema_attempts: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    schema_error: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    schema_valid: z.union([z.boolean(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    session_id: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    status: z.lazy(() => StatusSchema).refine((value) => value !== undefined, { message: "Required" }),
+    stderr: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    stdout: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    structured: z.unknown().refine((value) => value !== undefined, { message: "Required" }),
+    text: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    text_source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    usage: z.lazy(() => UsageSchema).refine((value) => value !== undefined, { message: "Required" }),
+    usage_source: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const SessionPhaseSchema = z.union([z.literal("create"), z.literal("continue")]);
+export const SessionReportSchema = z.looseObject({
+    name: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    phase: z.lazy(() => SessionPhaseSchema).refine((value) => value !== undefined, { message: "Required" }),
+    store_file: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    token: z.union([z.string(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const StatusSchema = z.union([
+    z.literal("ok"),
+    z.literal("nonzero"),
+    z.literal("timeout"),
+    z.literal("spawn-error"),
+    z.literal("skipped"),
+    z.literal("planned"),
+]);
+export const UsageSchema = z.looseObject({
+    cache_read_tokens: z
+        .union([z.int().gte(0), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    cache_write_tokens: z
+        .union([z.int().gte(0), z.null()])
+        .refine((value) => value !== undefined, { message: "Required" }),
+    cost_usd: z.union([z.number(), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    input_tokens: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+    output_tokens: z.union([z.int().gte(0), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
+});

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { RunReport } from "./generated/contracts.js";
+import type { DetectInfo } from "./generated/detection.js";
+import type { HistoryRecord } from "./generated/history.js";
+import type { HistorySessionSummary } from "./generated/history-list.js";
+import type { HistoryListOptions } from "./generated/history-list-options.js";
+import type { HistoryLookup } from "./generated/history-lookup.js";
+import type { RunOptions } from "./generated/options.js";
+import type { HarnessInfo } from "./generated/registry.js";
+export type { ActionEvent, BatchReport, FailureKind, FallbackReport, FallThrough, OutputFormat, RunReport, RunResult, SessionReport, Status, Usage, } from "./generated/contracts.js";
+export type { DetectInfo, DetectReport } from "./generated/detection.js";
+export type { HistoryRecord } from "./generated/history.js";
+export type { HistoryList, HistorySessionSummary, } from "./generated/history-list.js";
+export type { HistoryListOptions } from "./generated/history-list-options.js";
+export type { HistoryLookup, HistoryLookupByLast, HistoryLookupBySession, } from "./generated/history-lookup.js";
+export type { HistoryRecords } from "./generated/history-records.js";
+export type { PermissionMode, RunOptions } from "./generated/options.js";
+export type Detection = DetectInfo;
+export type { HarnessInfo, ListReport, ModeInfo, } from "./generated/registry.js";
+export * from "./generated/zod.js";
+export type OneHarnessOptions = {
+    executable?: string;
+    executableArgs?: readonly string[];
+    env?: Readonly<Record<string, string>>;
+};
+export declare class OneHarness {
+    private readonly options;
+    constructor(options?: OneHarnessOptions);
+    run(options: RunOptions): Promise<RunReport>;
+    list(): Promise<HarnessInfo[]>;
+    detect(harnesses?: readonly string[]): Promise<Detection[]>;
+    history(lookup: HistoryLookup): Promise<HistoryRecord[]>;
+    historyList(options?: HistoryListOptions): Promise<HistorySessionSummary[]>;
+}

package/dist/index.js

@@ -0,0 +1,146 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { DetectReportSchema, HistoryListOptionsSchema, HistoryListSchema, HistoryLookupSchema, HistoryRecordsSchema, ListReportSchema, RunOptionsSchema, RunReportSchema, } from "./generated/zod.js";
+export * from "./generated/zod.js";
+function parseContract(schema, value, label) {
+    const parsed = schema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    const details = parsed.error.issues
+        .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+        .join("; ");
+    throw new Error(`${label}: ${details}`);
+}
+function executable(options) {
+    if (options.executable)
+        return {
+            command: options.executable,
+            prefix: [...(options.executableArgs ?? [])],
+        };
+    if (process.env.ONEHARNESS_BIN)
+        return { command: process.env.ONEHARNESS_BIN, prefix: [] };
+    const require = createRequire(import.meta.url);
+    return {
+        command: process.execPath,
+        prefix: [require.resolve("oneharness-cli/bin/oneharness.js")],
+    };
+}
+async function invokeWith(options, args, cwd, acceptJsonOnNonzero = false) {
+    const bin = executable(options);
+    return await new Promise((resolve, reject) => {
+        const child = spawn(bin.command, [...bin.prefix, ...args], {
+            cwd,
+            env: { ...process.env, ...options.env },
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout
+            .setEncoding("utf8")
+            .on("data", (chunk) => (stdout += chunk));
+        child.stderr
+            .setEncoding("utf8")
+            .on("data", (chunk) => (stderr += chunk));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code !== 0 && !acceptJsonOnNonzero)
+                return reject(new Error(`oneharness exited ${code}: ${stderr.trim()}`));
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch (error) {
+                if (code !== 0)
+                    return reject(new Error(`oneharness exited ${code}: ${stderr.trim()}`));
+                reject(new Error(`oneharness returned invalid JSON: ${String(error)}`));
+            }
+        });
+    });
+}
+function pushMany(args, flag, values) {
+    for (const value of values ?? [])
+        args.push(flag, value);
+}
+export class OneHarness {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async run(options) {
+        const input = parseContract(RunOptionsSchema, options, "invalid oneharness run options");
+        const args = ["run", "--prompt", input.prompt, "--compact"];
+        pushMany(args, "--harness", input.harnesses);
+        pushMany(args, "--model", input.models);
+        if (input.system !== undefined)
+            args.push("--system", input.system);
+        if (input.reasoning !== undefined)
+            args.push("--reasoning", input.reasoning);
+        if (input.resume !== undefined)
+            args.push("--resume", input.resume);
+        if (input.session !== undefined)
+            args.push("--session", input.session);
+        if (input.fork)
+            args.push("--fork");
+        if (input.mode)
+            args.push("--mode", input.mode);
+        if (input.timeoutSeconds !== undefined)
+            args.push("--timeout", String(input.timeoutSeconds));
+        if (input.events)
+            args.push("--events");
+        if (input.history)
+            args.push("--history");
+        if (input.historyName !== undefined)
+            args.push("--history-name", input.historyName);
+        if (input.historyDir !== undefined)
+            args.push("--history-dir", input.historyDir);
+        for (const [key, value] of Object.entries(input.env ?? {}))
+            args.push("--env", `${key}=${value}`);
+        for (const [key, value] of Object.entries(input.bins ?? {}))
+            args.push("--bin", `${key}=${value}`);
+        const value = await invokeWith(this.options, args, input.cwd, true);
+        return parseContract(RunReportSchema, value, "invalid oneharness run contract");
+    }
+    async list() {
+        const value = await invokeWith(this.options, ["list", "--compact"]);
+        return parseContract(ListReportSchema, value, "invalid oneharness list contract").harnesses;
+    }
+    async detect(harnesses = []) {
+        const args = ["detect", "--compact"];
+        pushMany(args, "--harness", harnesses);
+        const value = await invokeWith(this.options, args);
+        return parseContract(DetectReportSchema, value, "invalid oneharness detect contract").detected;
+    }
+    async history(lookup) {
+        const input = parseContract(HistoryLookupSchema, lookup, "invalid oneharness history options");
+        const args = ["history", "show", "--compact"];
+        // A lookup that selects no session is not a HistoryLookup, so only these
+        // two cases remain. The variants overlap on `{session, last: true}`, and
+        // `last: true` keeps its long-standing priority over a name — which is why
+        // the union tries the last-session variant first, in Rust and in the
+        // generated Zod alike. Ruling that case out here leaves the variant whose
+        // session the type guarantees is present.
+        if (input.last === true)
+            args.push("--last");
+        else
+            args.push(input.session);
+        if (input.project)
+            args.push("--project", input.project);
+        if (input.allProjects)
+            args.push("--all-projects");
+        if (input.historyDir)
+            args.push("--history-dir", input.historyDir);
+        const value = await invokeWith(this.options, args);
+        return parseContract(HistoryRecordsSchema, value, "invalid history contract");
+    }
+    async historyList(options = {}) {
+        const input = parseContract(HistoryListOptionsSchema, options, "invalid oneharness history list options");
+        const args = ["history", "list", "--compact"];
+        if (input.project)
+            args.push("--project", input.project);
+        if (input.allProjects)
+            args.push("--all-projects");
+        if (input.historyDir)
+            args.push("--history-dir", input.historyDir);
+        const value = await invokeWith(this.options, args);
+        return parseContract(HistoryListSchema, value, "invalid history list contract");
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@oneharness/sdk",
+  "version": "0.3.22",
+  "description": "Typed Node.js SDK for oneharness",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "oneharness-cli": "0.3.22",
+    "zod": "^4.4.3"
+  }
+}