@openpond/harness 0.2.6 → 0.3.0

package/dist/types/source-package.d.ts

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { type ImmutableReleaseRef } from "./common.js";
+import { type AgentSnapshot, type HarnessRelease } from "./harness.js";
+export declare const MAX_HARNESS_SOURCE_PACKAGE_BYTES: number;
+export declare const HarnessSourcePackageSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.harnessSourcePackage.v1">;
+    agentSnapshot: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.agentSnapshot.v2">;
+        id: z.ZodString;
+        sourceRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        instructions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        toolDeclarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            inputSchemaHash: z.ZodString;
+            sideEffect: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        capabilityRequirements: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            required: z.ZodBoolean;
+            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            portability: z.ZodEnum<{
+                portable: "portable";
+                host_adapter: "host_adapter";
+                local_only: "local_only";
+                hosted_only: "hosted_only";
+            }>;
+        }, z.core.$strict>>;
+        dependencyLock: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        portability: z.ZodObject<{
+            portable: z.ZodBoolean;
+            blockers: z.ZodArray<z.ZodString>;
+            localOnlyAssetRefs: z.ZodArray<z.ZodString>;
+            hostPrivateAssetRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    harnessRelease: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.harnessRelease.v2">;
+        id: z.ZodString;
+        agentSnapshot: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        program: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            inputSchemaHash: z.ZodString;
+            sideEffect: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        lifecycle: z.ZodObject<{
+            create: z.ZodLiteral<true>;
+            reset: z.ZodLiteral<true>;
+            step: z.ZodLiteral<true>;
+            collect: z.ZodLiteral<true>;
+            destroy: z.ZodLiteral<true>;
+            resetScope: z.ZodEnum<{
+                task: "task";
+                attempt: "attempt";
+            }>;
+        }, z.core.$strict>;
+        graderInterface: z.ZodObject<{
+            visibleEvidence: z.ZodArray<z.ZodString>;
+            privilegedEvidence: z.ZodArray<z.ZodString>;
+            privateVerifierIsolation: z.ZodBoolean;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        base64: z.ZodString;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type HarnessSourcePackage = z.infer<typeof HarnessSourcePackageSchema>;
+export declare const HarnessSourceSelectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.harnessSourceSelection.v1">;
+    mode: z.ZodEnum<{
+        taskset_owned: "taskset_owned";
+        selected_release: "selected_release";
+    }>;
+    harnessRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    sourcePackageHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type HarnessSourceSelection = z.infer<typeof HarnessSourceSelectionSchema>;
+/** Resolve the source selected by a captured bundle; missing source cannot be
+ * interpreted as Taskset-owned execution when the bundle selected a release. */
+export declare function resolveHarnessSourceSelection(input: {
+    selection: unknown;
+    sourcePackage?: unknown;
+    expectedRelease: ImmutableReleaseRef;
+}): {
+    selection: HarnessSourceSelection;
+    sourcePackage: HarnessSourcePackage | null;
+};
+/** Capture the full released source. Runtime admission separately authorizes
+ * export and capabilities; a source package never makes private files visible
+ * to a policy merely by transporting them. */
+export declare function createHarnessSourcePackage(input: {
+    agentSnapshot: AgentSnapshot;
+    harnessRelease: HarnessRelease;
+    files: ReadonlyMap<string, Uint8Array>;
+}): HarnessSourcePackage;
+/** Validate both release objects, their complete asset closure and exact bytes.
+ * Rehashing the outer package cannot bless a substituted instruction or file. */
+export declare function validateHarnessSourcePackage(value: unknown, expected?: ImmutableReleaseRef): HarnessSourcePackage;
+/** Return an owned byte snapshot, including visibility in the release inventory.
+ * A runtime must select policy assets explicitly rather than expose this map. */
+export declare function harnessSourcePackageFiles(value: unknown, expected?: ImmutableReleaseRef): ReadonlyMap<string, Uint8Array>;
+//# sourceMappingURL=source-package.d.ts.map

package/dist/types/source-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-package.d.ts","sourceRoot":"","sources":["../../../../src/source-package.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAQL,KAAK,mBAAmB,EACzB,MAAM,aAAa,CAAC;AACrB,OAAO,EAA6C,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAElH,eAAO,MAAM,gCAAgC,QAAmB,CAAC;AAcjE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5B,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,4BAA4B;;;;;;;;;;;kBASvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;gFACgF;AAChF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,mBAAmB,CAAC;CACtC,GAAG;IAAE,SAAS,EAAE,sBAAsB,CAAC;IAAC,aAAa,EAAE,oBAAoB,GAAG,IAAI,CAAA;CAAE,CAapF;AAED;;8CAE8C;AAC9C,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACxC,GAAG,oBAAoB,CAcvB;AAED;iFACiF;AACjF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,oBAAoB,CA8CjH;AAED;iFACiF;AACjF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAGzH"}

package/dist/types/source-runtime.d.ts

@@ -0,0 +1,114 @@
+import { type ImmutableReleaseRef } from "./common.js";
+export declare const HARNESS_SOURCE_READ_TOOL_NAME = "harness_read_file";
+export declare const HARNESS_SOURCE_READ_TOOL: {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                path: {
+                    type: string;
+                };
+                offset: {
+                    type: string;
+                    minimum: number;
+                };
+                length: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+};
+type RuntimeTool = {
+    name: string;
+    inputSchema: Record<string, unknown>;
+    definition: Record<string, unknown>;
+};
+/** Compile released instructions and Skills into an admitted context. Resource
+ * reads use the captured package, never the current workspace or channel. */
+export declare function createHarnessSourceRuntime(input: {
+    sourcePackage: unknown;
+    expectedRelease: ImmutableReleaseRef;
+    baseSystemPrompt: string;
+    runtimeId: string;
+    tools: RuntimeTool[];
+    capabilities?: Array<{
+        id: string;
+        scopes: string[];
+    }>;
+    dependencies?: Record<string, string>;
+    maxContextCharacters: number;
+}): {
+    systemPrompt: string;
+    tools: {
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: {
+                type: string;
+                properties: {
+                    path: {
+                        type: string;
+                    };
+                    offset: {
+                        type: string;
+                        minimum: number;
+                    };
+                    length: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    }[];
+    receipt: {
+        contentHash: string;
+        schemaVersion: "openpond.harnessSourceRuntimeReceipt.v1";
+        runtimeId: string;
+        harnessRelease: {
+            id: string;
+            contentHash: string;
+        };
+        sourcePackageHash: string;
+        systemPromptHash: string;
+        instructionAssets: {
+            path: string;
+            contentHash: string;
+        }[];
+        skillAssets: {
+            path: string;
+            contentHash: string;
+        }[];
+        readableAssets: {
+            path: string;
+            contentHash: string;
+        }[];
+        toolContractHash: string;
+        omittedCapabilities: string[];
+    };
+    readFile(value: unknown): {
+        path: string;
+        contentHash: string;
+        mediaType: string;
+        sizeBytes: number;
+        offset: number;
+        nextOffset: number;
+        eof: boolean;
+        encoding: "base64" | "utf8";
+        content: string;
+    };
+};
+export {};
+//# sourceMappingURL=source-runtime.d.ts.map

package/dist/types/source-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-runtime.d.ts","sourceRoot":"","sources":["../../../../src/source-runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGpE,eAAO,MAAM,6BAA6B,sBAAsB,CAAC;AAOjE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;CAYpC,CAAC;AAEF,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAE/G;6EAC6E;AAC7E,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,mBAAmB,CAAC;IACrC,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,oBAAoB,EAAE,MAAM,CAAC;CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkEmB,OAAO;;;;;;;;;;;EAgB1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpond/harness",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "Portable immutable Harness releases, workspaces, improvements, traces, tools, and model identities for OpenPond",
   "license": "MIT",
   "type": "module",
@@ -58,6 +58,10 @@
       "types": "./dist/types/tools.d.ts",
       "import": "./dist/tools.js"
     },
+    "./runtime-source": {
+      "types": "./dist/types/runtime-source.d.ts",
+      "import": "./dist/runtime-source.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -90,6 +94,7 @@
   },
   "devDependencies": {
     "@types/node": "24.13.3",
+    "esbuild": "0.28.1",
     "tsx": "4.23.1",
     "typescript": "^5.9.3",
     "vitest": "4.1.10"