@oneharness/sdk 0.19.1 → 0.21.1

package/dist/generated/zod.js

@@ -1139,6 +1139,7 @@ export const HistoryListOptionsSchema = z.strictObject({
     noConfig: z.boolean().optional(),
     project: z.string().optional(),
     variant: z.string().optional(),
+    window: z.union([z.lazy(() => HistoryWindowSchema), z.null()]).optional(),
 });
 export const HistoryLookupSchema = z.union([
     z.lazy(() => HistoryLookupByLastSchema),
@@ -1153,6 +1154,7 @@ export const HistoryLookupByLastSchema = z.strictObject({
     noConfig: z.boolean().optional(),
     project: z.string().optional(),
     session: z.string().optional(),
+    window: z.union([z.lazy(() => HistoryWindowSchema), z.null()]).optional(),
 });
 export const HistoryLookupBySessionSchema = z.strictObject({
     all: z.boolean().optional(),
@@ -1166,6 +1168,7 @@ export const HistoryLookupBySessionSchema = z.strictObject({
         .string()
         .min(1)
         .refine((value) => value !== undefined, { message: "Required" }),
+    window: z.union([z.lazy(() => HistoryWindowSchema), z.null()]).optional(),
 });
 export const HistoryMigrateOptionsSchema = z.strictObject({
     config: z.array(z.string()).optional(),
@@ -2235,7 +2238,27 @@ export const HistoryRecordSchema = z.intersection(z.intersection(z.intersection(
         schema_version: z.literal("1.9").optional(),
     }),
 ])));
-export const HistoryRecordsSchema = z.array(z.lazy(() => HistoryRecordSchema));
+export const HistoryReindexOptionsSchema = z.strictObject({
+    config: z.array(z.string()).optional(),
+    historyDir: z.string().optional(),
+    noConfig: z.boolean().optional(),
+});
+export const HistoryReindexReportSchema = z.looseObject({
+    entries_added: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    files_read: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    segments: z
+        .array(z.lazy(() => SegmentReindexSummarySchema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+    unreadable: z
+        .array(z.lazy(() => UnreadableSessionFileSchema))
+        .refine((value) => value !== undefined, { message: "Required" }),
+});
 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" }),
@@ -2250,6 +2273,11 @@ export const HistorySessionSummarySchema = z.looseObject({
     running: z.boolean().optional(),
     started: z.string().refine((value) => value !== undefined, { message: "Required" }),
 });
+export const HistoryShowEntriesSchema = z.array(z.lazy(() => HistoryShowEntrySchema));
+export const HistoryShowEntrySchema = z.union([
+    z.lazy(() => HistoryRecordSchema),
+    z.lazy(() => IncompleteHistoryRunSchema),
+]);
 export const HistoryStreamEnvelopeSchema = z.union([
     z.looseObject({
         record: z.lazy(() => HistoryRecordSchema).refine((value) => value !== undefined, { message: "Required" }),
@@ -2287,7 +2315,29 @@ export const HistoryWatchOptionsSchema = z.strictObject({
     ])
         .optional(),
     variant: z.string().optional(),
+    window: z.union([z.lazy(() => HistoryWindowSchema), z.null()]).optional(),
 });
+export const HistoryWindowSchema = z.union([
+    z.strictObject({
+        recent: z
+            .strictObject({
+            days: z
+                .int()
+                .gte(1)
+                .refine((value) => value !== undefined, { message: "Required" }),
+        })
+            .refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.strictObject({
+        since: z
+            .string()
+            .min(10)
+            .regex(new RegExp("^(?:[1-9][0-9]{3}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12][0-9]|3[01])|(?:0[469]|11)-(?:0[1-9]|[12][0-9]|30)|02-(?:0[1-9]|1[0-9]|2[0-8]))|(?:[1-9][0-9](?:0[48]|[2468][048]|[13579][26])|(?:1[26]|2[048]|3[26]|4[048]|5[26]|6[048]|7[26]|8[048]|9[26])00)-02-29)$", "u"))
+            .refine((value) => [...value].length <= 10, { message: "Too long: expected at most 10 characters" })
+            .refine((value) => value !== undefined, { message: "Required" }),
+    }),
+    z.literal("allTime"),
+]);
 export const HookEntrySchema = z.strictObject({
     command: z.string().refine((value) => value !== undefined, { message: "Required" }),
     harnesses: z.union([z.array(z.string()), z.null()]).refine((value) => value !== undefined, { message: "Required" }),
@@ -2313,6 +2363,21 @@ export const IdentitySelectorSchema = z.union([
         kind: z.literal("ambient").refine((value) => value !== undefined, { message: "Required" }),
     }),
 ]);
+export const IncompleteHistoryRunSchema = z.looseObject({
+    events: z
+        .array(z.lazy(() => ActionEventSchema))
+        .min(1)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    harness: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    run_id: z
+        .string()
+        .min(36)
+        .regex(new RegExp("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$", "u"))
+        .refine((value) => [...value].length <= 36, { message: "Too long: expected at most 36 characters" })
+        .refine((value) => value !== undefined, { message: "Required" }),
+    type: z.lazy(() => IncompleteRunTypeSchema).refine((value) => value !== undefined, { message: "Required" }),
+});
+export const IncompleteRunTypeSchema = z.literal("incomplete");
 export const InitOptionsSchema = z.strictObject({
     force: z.boolean().optional(),
     path: z.string().optional(),
@@ -2540,6 +2605,14 @@ export const RunStreamEnvelopeSchema = z.union([
     }),
 ]);
 export const RunWorkSchema = z.union([z.literal("done"), z.literal("none")]);
+export const SegmentReindexSummarySchema = z.looseObject({
+    added: z
+        .int()
+        .gte(0)
+        .refine((value) => value !== undefined, { message: "Required" }),
+    path: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    segment: z.string().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" }),
@@ -2623,6 +2696,10 @@ export const UnmappedRuleSchema = z.looseObject({
     reason: z.string().refine((value) => value !== undefined, { message: "Required" }),
     rule: z.string().refine((value) => value !== undefined, { message: "Required" }),
 });
+export const UnreadableSessionFileSchema = z.looseObject({
+    error: z.string().refine((value) => value !== undefined, { message: "Required" }),
+    path: z.string().refine((value) => value !== undefined, { message: "Required" }),
+});
 export const UsageSchema = z.looseObject({
     cache_read_tokens: z
         .union([z.int().gte(0), z.null()])

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import type { ZodType } from "zod";
 import type { ConfigOptions } from "./generated/config-options.js";
 import type { ConfigReport } from "./generated/config-report.js";
 import type { RunReport } from "./generated/contracts.js";
@@ -14,6 +15,9 @@ import type { HistoryMigrateOptions } from "./generated/history-migrate-options.
 import type { HistoryMigrateReport } from "./generated/history-migrate-report.js";
 import type { HistoryPointers } from "./generated/history-pointers.js";
 import type { HistoryPointersOptions } from "./generated/history-pointers-options.js";
+import type { HistoryReindexOptions } from "./generated/history-reindex-options.js";
+import type { HistoryReindexReport } from "./generated/history-reindex-report.js";
+import type { HistoryShowEntries, HistoryShowEntry, IncompleteHistoryRun } from "./generated/history-show-entries.js";
 import type { HistoryStreamEnvelope } from "./generated/history-stream-envelope.js";
 import type { HistoryWatchOptions } from "./generated/history-watch-options.js";
 import type { InitOptions } from "./generated/init-options.js";
@@ -40,13 +44,15 @@ export type { HistoryClearOptions } from "./generated/history-clear-options.js";
 export type { HistoryClearDryRun, HistoryClearRemoved, HistoryClearReport, } from "./generated/history-clear-report.js";
 export type { HistoryLine } from "./generated/history-line.js";
 export type { HistoryList, HistorySessionSummary, } from "./generated/history-list.js";
-export type { HistoryListOptions } from "./generated/history-list-options.js";
+export type { HistoryListOptions, HistoryWindow, } from "./generated/history-list-options.js";
 export type { HistoryLookup, HistoryLookupByLast, HistoryLookupBySession, } from "./generated/history-lookup.js";
 export type { HistoryMigrateOptions } from "./generated/history-migrate-options.js";
 export type { HistoryMigrateReport } from "./generated/history-migrate-report.js";
 export type { HistoryPointer, HistoryPointers, } from "./generated/history-pointers.js";
 export type { HistoryPointersOptions } from "./generated/history-pointers-options.js";
-export type { HistoryRecords } from "./generated/history-records.js";
+export type { HistoryReindexOptions } from "./generated/history-reindex-options.js";
+export type { HistoryReindexReport, SegmentReindexSummary, UnreadableSessionFile, } from "./generated/history-reindex-report.js";
+export type { HistoryShowEntries, HistoryShowEntry, IncompleteHistoryRun, } from "./generated/history-show-entries.js";
 export type { HistoryStreamEnvelope } from "./generated/history-stream-envelope.js";
 export type { HistoryWatchOptions } from "./generated/history-watch-options.js";
 export type { InitOptions } from "./generated/init-options.js";
@@ -62,6 +68,20 @@ export type { UsageReport } from "./generated/usage-report.js";
 export type Detection = DetectInfo;
 export type { HarnessInfo, ListReport, ModeInfo, } from "./generated/registry.js";
 export * from "./generated/zod.js";
+/**
+ * Finished runs' records only.
+ *
+ * @deprecated `history show` also answers an in-flight run, so its output is
+ * `HistoryShowEntries`; this names only the finished records it can carry.
+ */
+export type HistoryRecords = HistoryRecord[];
+/**
+ * Validates finished runs' records only; an in-flight entry fails it.
+ *
+ * @deprecated `history show`'s output is validated by
+ * `HistoryShowEntriesSchema`, which also accepts an in-flight run.
+ */
+export declare const HistoryRecordsSchema: ZodType<HistoryRecords>;
 export type OneHarnessOptions = {
     executable?: string;
     executableArgs?: readonly string[];
@@ -74,6 +94,11 @@ export type MockHarnessScript = {
     exitCode?: number;
     latencyMs?: number;
 };
+/**
+ * Whether a `history()` entry is a run still in flight rather than a finished
+ * run's record. Records carry no `type`; an in-flight entry's is `incomplete`.
+ */
+export declare function isIncompleteHistoryRun(entry: HistoryShowEntry): entry is IncompleteHistoryRun;
 /** A non-zero exit from the oneharness subprocess. */
 export declare class OneHarnessProcessError extends Error {
     readonly exitCode: number | null;
@@ -138,7 +163,14 @@ export declare class OneHarness {
      * on. So a non-zero exit still yields the frame.
      */
     interrupt(options: InterruptOptions): Promise<InterruptResponse>;
-    history(lookup: HistoryLookup): Promise<HistoryRecord[]>;
+    /**
+     * Resolve one history record or session.
+     *
+     * A run still in flight has no record yet: it is an `IncompleteHistoryRun`
+     * entry (`type: "incomplete"`) carrying its `run_id`, `harness` and the
+     * `events` so far.
+     */
+    history(lookup: HistoryLookup): Promise<HistoryShowEntries>;
     historyList(options?: HistoryListOptions): Promise<HistorySessionSummary[]>;
     /**
      * Remove history sessions.
@@ -150,6 +182,15 @@ export declare class OneHarness {
     historyClear(options?: HistoryClearOptions): Promise<HistoryClearReport>;
     /** Rewrite legacy session files to the current record version. */
     historyMigrate(options?: HistoryMigrateOptions): Promise<HistoryMigrateReport>;
+    /**
+     * Index every session line the dated history index lacks: append one entry
+     * per run or event line its date's segment does not hold yet.
+     *
+     * Idempotent and append-only, and the only verb that reads every session
+     * file to build the index. The report names what was added per segment and
+     * every file that could not be read.
+     */
+    historyReindex(options?: HistoryReindexOptions): Promise<HistoryReindexReport>;
     /**
      * Read a run's pointer file (`historyPointerFile` on `run()`): one line per
      * harness run begun with history on, naming where its session went.

package/dist/index.js

@@ -2,9 +2,23 @@ import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { createInterface } from "node:readline";
 import { CAPABILITIES, } from "./generated/capabilities.js";
-import { ConfigOptionsSchema, ConfigReportSchema, DetectOptionsSchema, DetectReportSchema, GateOptionsSchema, HistoryClearOptionsSchema, HistoryClearReportSchema, HistoryListOptionsSchema, HistoryListSchema, HistoryLookupSchema, HistoryMigrateOptionsSchema, HistoryMigrateReportSchema, HistoryPointersOptionsSchema, HistoryPointersSchema, HistoryRecordsSchema, HistoryStreamEnvelopeSchema, HistoryWatchOptionsSchema, InitOptionsSchema, InterruptOptionsSchema, InterruptResponseSchema, ListReportSchema, MockOptionsSchema, RunOptionsSchema, RunReportSchema, RunStreamEnvelopeSchema, SyncOptionsSchema, SyncReportSchema, UsageOptionsSchema, UsageReportSchema, } from "./generated/zod.js";
+import { ConfigOptionsSchema, ConfigReportSchema, DetectOptionsSchema, DetectReportSchema, GateOptionsSchema, HistoryClearOptionsSchema, HistoryClearReportSchema, HistoryListOptionsSchema, HistoryListSchema, HistoryLookupSchema, HistoryMigrateOptionsSchema, HistoryMigrateReportSchema, HistoryPointersOptionsSchema, HistoryPointersSchema, HistoryRecordSchema, HistoryReindexOptionsSchema, HistoryReindexReportSchema, HistoryShowEntriesSchema, HistoryStreamEnvelopeSchema, HistoryWatchOptionsSchema, InitOptionsSchema, InterruptOptionsSchema, InterruptResponseSchema, ListReportSchema, MockOptionsSchema, RunOptionsSchema, RunReportSchema, RunStreamEnvelopeSchema, SyncOptionsSchema, SyncReportSchema, UsageOptionsSchema, UsageReportSchema, } from "./generated/zod.js";
 export { CAPABILITIES } from "./generated/capabilities.js";
 export * from "./generated/zod.js";
+/**
+ * Validates finished runs' records only; an in-flight entry fails it.
+ *
+ * @deprecated `history show`'s output is validated by
+ * `HistoryShowEntriesSchema`, which also accepts an in-flight run.
+ */
+export const HistoryRecordsSchema = HistoryRecordSchema.array();
+/**
+ * Whether a `history()` entry is a run still in flight rather than a finished
+ * run's record. Records carry no `type`; an in-flight entry's is `incomplete`.
+ */
+export function isIncompleteHistoryRun(entry) {
+    return entry.type === "incomplete";
+}
 /** A non-zero exit from the oneharness subprocess. */
 export class OneHarnessProcessError extends Error {
     exitCode;
@@ -230,6 +244,23 @@ function statesAChoice(binding, value) {
         return String(value) !== "";
     return true;
 }
+/**
+ * The one flag a history window renders: `--days N`, `--since D`, or
+ * `--all-time`. The window is a single validated value, so exactly one of the
+ * three is ever sent.
+ */
+function windowArguments(binding, window) {
+    // `FlagKind::Window` serializes its spellings beside the binding, so a
+    // window binding without them is a manifest this client cannot render.
+    const flags = binding.window;
+    if (flags === undefined)
+        throw new Error(`the capability manifest's \`${binding.option}\` window binding names no flags`);
+    if (window === "allTime")
+        return [flags.allTime];
+    if ("since" in window)
+        return [flags.since, window.since];
+    return [flags.days, String(window.recent.days)];
+}
 /**
  * Render one capability's argv from its declared bindings.
  *
@@ -297,6 +328,12 @@ function capabilityArguments(method, options) {
             case "trailing":
                 trailing.push(...value.map(String));
                 break;
+            case "window":
+                // A `window` binding only ever names an option the contract types as
+                // `HistoryWindow`, and Zod validated this value against that contract
+                // before it reached here, so the assertion restates a checked shape.
+                args.push(...windowArguments(binding, value));
+                break;
         }
     }
     args.push(...positional);
@@ -450,13 +487,20 @@ export class OneHarness {
     async interrupt(options) {
         return await this.call("interrupt", options, InterruptOptionsSchema, InterruptResponseSchema, { acceptJsonOnNonzero: true });
     }
+    /**
+     * Resolve one history record or session.
+     *
+     * A run still in flight has no record yet: it is an `IncompleteHistoryRun`
+     * entry (`type: "incomplete"`) carrying its `run_id`, `harness` and the
+     * `events` so far.
+     */
     async history(lookup) {
         // The `--last`-suppresses-a-name rule is declared, not re-derived here:
         // the union deliberately accepts `{session, last: true}` and resolves it
         // to "the most recent", and the manifest binds `session` with
         // `unless: "last"` so the builder renders only `--last`. Rust, the
         // generated Zod, and this call therefore agree by construction.
-        return await this.call("history", lookup, HistoryLookupSchema, HistoryRecordsSchema, {
+        return await this.call("history", lookup, HistoryLookupSchema, HistoryShowEntriesSchema, {
             history: true,
             optionsLabel: "invalid oneharness history options",
             contractLabel: "invalid history contract",
@@ -482,6 +526,17 @@ export class OneHarness {
     async historyMigrate(options = {}) {
         return await this.call("historyMigrate", options, HistoryMigrateOptionsSchema, HistoryMigrateReportSchema);
     }
+    /**
+     * Index every session line the dated history index lacks: append one entry
+     * per run or event line its date's segment does not hold yet.
+     *
+     * Idempotent and append-only, and the only verb that reads every session
+     * file to build the index. The report names what was added per segment and
+     * every file that could not be read.
+     */
+    async historyReindex(options = {}) {
+        return await this.call("historyReindex", options, HistoryReindexOptionsSchema, HistoryReindexReportSchema);
+    }
     /**
      * Read a run's pointer file (`historyPointerFile` on `run()`): one line per
      * harness run begun with history on, naming where its session went.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneharness/sdk",
-  "version": "0.19.1",
+  "version": "0.21.1",
   "description": "Typed Node.js SDK for oneharness",
   "type": "module",
   "main": "dist/index.js",
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "oneharness-cli": "0.19.1",
+    "oneharness-cli": "0.21.1",
     "zod": "^4.4.3"
   }
 }