@jinn-network/client 0.1.9 → 0.2.0

package/node_modules/@jinn-network/core/dist/trajectory/hash-chain.js

@@ -0,0 +1,47 @@
+/**
+ * In-run per-span hash chain.
+ *
+ * Scope: §3.1 trajectory-signing-granularity row — "each span carries
+ * jinn.prevSpanHash linking to the previous span's hash; first span
+ * links to a run-start genesis value derived from envelope task CID."
+ *
+ * Motivation: a crashed run that failed to upload the signed trajectory
+ * blob still produces a verifiable-as-prefix trace if spans are recovered
+ * elsewhere (enclave memory dump, challenger capture). Partial authenticity
+ * is not zero.
+ */
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import canonicalize from 'canonicalize';
+function coerceNonFinite(value) {
+    if (typeof value === 'number' && !Number.isFinite(value))
+        return null;
+    if (Array.isArray(value))
+        return value.map(coerceNonFinite);
+    if (value !== null && typeof value === 'object') {
+        const toJson = value.toJSON;
+        if (typeof toJson === 'function')
+            return coerceNonFinite(toJson.call(value));
+        const output = {};
+        for (const [key, entry] of Object.entries(value)) {
+            output[key] = coerceNonFinite(entry);
+        }
+        return output;
+    }
+    return value;
+}
+function canonicalJson(value) {
+    const result = canonicalize(coerceNonFinite(value));
+    return result ?? 'null';
+}
+function keccakUtf8(value) {
+    return `0x${bytesToHex(keccak_256(new TextEncoder().encode(value)))}`;
+}
+/** Genesis value for the chain — keccak256(JCS({runStart: taskCid})). */
+export function computeGenesisHash(taskCid) {
+    return keccakUtf8(canonicalJson({ runStart: taskCid }));
+}
+/** Hash of a finalized span, to be set as jinn.prevSpanHash on the next one. */
+export function computePrevSpanHash(span) {
+    return keccakUtf8(canonicalJson(span));
+}

package/node_modules/@jinn-network/core/dist/trajectory/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hash-chain.js';
+export * from './schema.js';
+export * from './transcript-parsers/index.js';
+export * from './transcript-to-spans/index.js';

package/node_modules/@jinn-network/core/dist/trajectory/index.js

@@ -0,0 +1,4 @@
+export * from './hash-chain.js';
+export * from './schema.js';
+export * from './transcript-parsers/index.js';
+export * from './transcript-to-spans/index.js';

package/node_modules/@jinn-network/core/dist/trajectory/schema.d.ts

@@ -0,0 +1,606 @@
+/**
+ * jinn.trajectory.v1 — OTLP-JSON-shaped trace blob signed and uploaded once
+ * per run. Scope: docs/superpowers/specs/2026-04-23-jinn-execution-envelope-tee-scope.md
+ * §3.1 trajectory row + K6 span profile, §4.3 trajectory profile deliverable.
+ *
+ * Each span carries jinn.prevSpanHash (in-run hash chain) + jinn.span.kind
+ * (normative profile). Secret-scrub (§4.3 V1 minimum) produces a run-level
+ * redactionManifest signed alongside the spans.
+ */
+import { z } from 'zod/v3';
+export declare const JinnSpanKindSchema: z.ZodEnum<["jinn.phase", "jinn.llm_call", "jinn.mcp_call", "jinn.artifact.emit", "jinn.venue_io", "jinn.state_transition", "jinn.agent_turn", "jinn.tool_call"]>;
+export type JinnSpanKind = z.infer<typeof JinnSpanKindSchema>;
+/** An OTLP-shaped span with Jinn-required attributes. */
+export declare const SpanSchema: z.ZodObject<{
+    traceId: z.ZodString;
+    spanId: z.ZodString;
+    parentSpanId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    kind: z.ZodEnum<["INTERNAL", "CLIENT", "SERVER", "PRODUCER", "CONSUMER"]>;
+    startTimeUnixNano: z.ZodString;
+    endTimeUnixNano: z.ZodString;
+    attributes: z.ZodEffects<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>, Record<string, unknown>, Record<string, unknown>>;
+    events: z.ZodArray<z.ZodObject<{
+        timeUnixNano: z.ZodString;
+        name: z.ZodString;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        timeUnixNano: string;
+        attributes?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        timeUnixNano: string;
+        attributes?: Record<string, unknown> | undefined;
+    }>, "many">;
+    status: z.ZodObject<{
+        code: z.ZodEnum<["UNSET", "OK", "ERROR"]>;
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNSET" | "OK" | "ERROR";
+        message?: string | undefined;
+    }, {
+        code: "UNSET" | "OK" | "ERROR";
+        message?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    spanId: string;
+    parentSpanId: string | null;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: Record<string, unknown>;
+    status: {
+        code: "UNSET" | "OK" | "ERROR";
+        message?: string | undefined;
+    };
+    kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+    events: {
+        name: string;
+        timeUnixNano: string;
+        attributes?: Record<string, unknown> | undefined;
+    }[];
+    traceId: string;
+}, {
+    spanId: string;
+    parentSpanId: string | null;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: Record<string, unknown>;
+    status: {
+        code: "UNSET" | "OK" | "ERROR";
+        message?: string | undefined;
+    };
+    kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+    events: {
+        name: string;
+        timeUnixNano: string;
+        attributes?: Record<string, unknown> | undefined;
+    }[];
+    traceId: string;
+}>;
+export type Span = z.infer<typeof SpanSchema>;
+export declare const RedactionManifestSchema: z.ZodEffects<z.ZodObject<{
+    spans: z.ZodArray<z.ZodObject<{
+        spanId: z.ZodString;
+        redactedKeys: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        spanId: string;
+        redactedKeys: string[];
+    }, {
+        spanId: string;
+        redactedKeys: string[];
+    }>, "many">;
+    totalRedactions: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    spans: {
+        spanId: string;
+        redactedKeys: string[];
+    }[];
+    totalRedactions: number;
+}, {
+    spans: {
+        spanId: string;
+        redactedKeys: string[];
+    }[];
+    totalRedactions: number;
+}>, {
+    spans: {
+        spanId: string;
+        redactedKeys: string[];
+    }[];
+    totalRedactions: number;
+}, {
+    spans: {
+        spanId: string;
+        redactedKeys: string[];
+    }[];
+    totalRedactions: number;
+}>;
+export type RedactionManifest = z.infer<typeof RedactionManifestSchema>;
+export declare const JinnTrajectoryV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"jinn.trajectory.v1">;
+    runId: z.ZodString;
+    parentEnvelopeCid: z.ZodNullable<z.ZodString>;
+    spans: z.ZodArray<z.ZodObject<{
+        traceId: z.ZodString;
+        spanId: z.ZodString;
+        parentSpanId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        kind: z.ZodEnum<["INTERNAL", "CLIENT", "SERVER", "PRODUCER", "CONSUMER"]>;
+        startTimeUnixNano: z.ZodString;
+        endTimeUnixNano: z.ZodString;
+        attributes: z.ZodEffects<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>, Record<string, unknown>, Record<string, unknown>>;
+        events: z.ZodArray<z.ZodObject<{
+            timeUnixNano: z.ZodString;
+            name: z.ZodString;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }>, "many">;
+        status: z.ZodObject<{
+            code: z.ZodEnum<["UNSET", "OK", "ERROR"]>;
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        }, {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }, {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }>, "many">;
+    redactionManifest: z.ZodEffects<z.ZodObject<{
+        spans: z.ZodArray<z.ZodObject<{
+            spanId: z.ZodString;
+            redactedKeys: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            spanId: string;
+            redactedKeys: string[];
+        }, {
+            spanId: string;
+            redactedKeys: string[];
+        }>, "many">;
+        totalRedactions: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }>, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }>;
+    signature: z.ZodObject<{
+        algo: z.ZodLiteral<"secp256k1">;
+        signer: z.ZodString;
+        hash: z.ZodString;
+        sig: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        algo: "secp256k1";
+        signer: string;
+        hash: string;
+        sig: string;
+    }, {
+        algo: "secp256k1";
+        signer: string;
+        hash: string;
+        sig: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn.trajectory.v1";
+    signature: {
+        algo: "secp256k1";
+        signer: string;
+        hash: string;
+        sig: string;
+    };
+    spans: {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }[];
+    runId: string;
+    parentEnvelopeCid: string | null;
+    redactionManifest: {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    };
+}, {
+    schemaVersion: "jinn.trajectory.v1";
+    signature: {
+        algo: "secp256k1";
+        signer: string;
+        hash: string;
+        sig: string;
+    };
+    spans: {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }[];
+    runId: string;
+    parentEnvelopeCid: string | null;
+    redactionManifest: {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    };
+}>;
+export type JinnTrajectoryV1 = z.infer<typeof JinnTrajectoryV1Schema>;
+/** Unsigned form — what we hash + sign. */
+export declare const UnsignedTrajectorySchema: z.ZodObject<Omit<{
+    schemaVersion: z.ZodLiteral<"jinn.trajectory.v1">;
+    runId: z.ZodString;
+    parentEnvelopeCid: z.ZodNullable<z.ZodString>;
+    spans: z.ZodArray<z.ZodObject<{
+        traceId: z.ZodString;
+        spanId: z.ZodString;
+        parentSpanId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        kind: z.ZodEnum<["INTERNAL", "CLIENT", "SERVER", "PRODUCER", "CONSUMER"]>;
+        startTimeUnixNano: z.ZodString;
+        endTimeUnixNano: z.ZodString;
+        attributes: z.ZodEffects<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>, Record<string, unknown>, Record<string, unknown>>;
+        events: z.ZodArray<z.ZodObject<{
+            timeUnixNano: z.ZodString;
+            name: z.ZodString;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }>, "many">;
+        status: z.ZodObject<{
+            code: z.ZodEnum<["UNSET", "OK", "ERROR"]>;
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        }, {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }, {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }>, "many">;
+    redactionManifest: z.ZodEffects<z.ZodObject<{
+        spans: z.ZodArray<z.ZodObject<{
+            spanId: z.ZodString;
+            redactedKeys: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            spanId: string;
+            redactedKeys: string[];
+        }, {
+            spanId: string;
+            redactedKeys: string[];
+        }>, "many">;
+        totalRedactions: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }>, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }, {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    }>;
+    signature: z.ZodObject<{
+        algo: z.ZodLiteral<"secp256k1">;
+        signer: z.ZodString;
+        hash: z.ZodString;
+        sig: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        algo: "secp256k1";
+        signer: string;
+        hash: string;
+        sig: string;
+    }, {
+        algo: "secp256k1";
+        signer: string;
+        hash: string;
+        sig: string;
+    }>;
+}, "signature">, "strip", z.ZodTypeAny, {
+    schemaVersion: "jinn.trajectory.v1";
+    spans: {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }[];
+    runId: string;
+    parentEnvelopeCid: string | null;
+    redactionManifest: {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    };
+}, {
+    schemaVersion: "jinn.trajectory.v1";
+    spans: {
+        spanId: string;
+        parentSpanId: string | null;
+        name: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes: Record<string, unknown>;
+        status: {
+            code: "UNSET" | "OK" | "ERROR";
+            message?: string | undefined;
+        };
+        kind: "INTERNAL" | "CLIENT" | "SERVER" | "PRODUCER" | "CONSUMER";
+        events: {
+            name: string;
+            timeUnixNano: string;
+            attributes?: Record<string, unknown> | undefined;
+        }[];
+        traceId: string;
+    }[];
+    runId: string;
+    parentEnvelopeCid: string | null;
+    redactionManifest: {
+        spans: {
+            spanId: string;
+            redactedKeys: string[];
+        }[];
+        totalRedactions: number;
+    };
+}>;
+export type UnsignedTrajectory = z.infer<typeof UnsignedTrajectorySchema>;
+/**
+ * Per-run capture manifest — records the operator's authorisation and
+ * coarse harness-bundle metadata for telemetry capture. v0 deliberately
+ * keeps operator control at the bundle level (no per-file curation) per
+ * DR-2026-05-07-g; the audit surface is "what did the operator authorise
+ * the daemon to read?" not "what did the daemon ultimately read?"
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §3.3
+ */
+export declare const CaptureManifestSchema: z.ZodObject<{
+    scrubProcessors: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        config?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        version: string;
+        config?: Record<string, unknown> | undefined;
+    }>, "many">;
+    reviewedBy: z.ZodObject<{
+        safeAddress: z.ZodString;
+        reviewedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        safeAddress: string;
+        reviewedAt: string;
+    }, {
+        safeAddress: string;
+        reviewedAt: string;
+    }>;
+    trustedRepoToggle: z.ZodBoolean;
+    harnessBundle: z.ZodObject<{
+        included: z.ZodBoolean;
+        sha256: z.ZodString;
+        allowedDirectoriesHash: z.ZodString;
+        capturePath: z.ZodEnum<["A", "B", "C", "D"]>;
+    }, "strip", z.ZodTypeAny, {
+        sha256: string;
+        included: boolean;
+        allowedDirectoriesHash: string;
+        capturePath: "A" | "B" | "C" | "D";
+    }, {
+        sha256: string;
+        included: boolean;
+        allowedDirectoriesHash: string;
+        capturePath: "A" | "B" | "C" | "D";
+    }>;
+    /**
+     * The single `share` consent (mono#1714): may a mined task be published off
+     * the box (enforced at the mint publish gate). Local retention is
+     * unconditional, so there is no separate retention-consent field.
+     */
+    publishMinedTasksConsent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    publishMinedTasksConsent: boolean;
+    scrubProcessors: {
+        name: string;
+        version: string;
+        config?: Record<string, unknown> | undefined;
+    }[];
+    reviewedBy: {
+        safeAddress: string;
+        reviewedAt: string;
+    };
+    trustedRepoToggle: boolean;
+    harnessBundle: {
+        sha256: string;
+        included: boolean;
+        allowedDirectoriesHash: string;
+        capturePath: "A" | "B" | "C" | "D";
+    };
+}, {
+    scrubProcessors: {
+        name: string;
+        version: string;
+        config?: Record<string, unknown> | undefined;
+    }[];
+    reviewedBy: {
+        safeAddress: string;
+        reviewedAt: string;
+    };
+    trustedRepoToggle: boolean;
+    harnessBundle: {
+        sha256: string;
+        included: boolean;
+        allowedDirectoriesHash: string;
+        capturePath: "A" | "B" | "C" | "D";
+    };
+    publishMinedTasksConsent?: boolean | undefined;
+}>;
+export type CaptureManifest = z.infer<typeof CaptureManifestSchema>;
+/** sha256 of an empty (no-files) bundle. Used when the operator opts out of harness-bundle capture. */
+export declare const EMPTY_BUNDLE_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";