@jmanuelcorral/openteam 0.2.2 → 0.9.0

package/dist/contract/opencode.d.ts

@@ -1,57 +1,73 @@
 /**
- * Contrato con la superficie de extensión de opencode.
+ * Contract with opencode's extension surface.
  *
- * openteam depende de un conjunto acotado de tipos y comportamientos de
- * `@opencode-ai/plugin` y `@opencode-ai/sdk`. Este módulo es la única fuente de
- * verdad, en código, de las versiones soportadas. Los tests de contrato en
- * `tests/contract/**` fallan cuando la versión instalada se aleja de esta
- * allow-list, forzando una re-verificación manual de la superficie antes de
- * mergear un bump.
+ * openteam depends on a bounded set of types and behaviors from
+ * `@opencode-ai/plugin` and `@opencode-ai/sdk`. This module is the single
+ * source of truth, in code, for the supported versions. The contract tests in
+ * `tests/contract/**` fail when the installed version moves away from this
+ * allow-list, forcing a manual re-verification of the surface before merging a
+ * bump.
  *
- * Módulo puro: sin I/O, red, reloj, random ni env vars.
+ * Pure module: no I/O, network, clock, random, or env vars.
  */
 /**
- * Paquetes npm de opencode de los que depende openteam en runtime.
+ * opencode npm packages that openteam depends on at runtime.
  */
 export declare const OPENCODE_PACKAGES: readonly ["@opencode-ai/plugin", "@opencode-ai/sdk"];
 export type OpencodePackage = (typeof OPENCODE_PACKAGES)[number];
 /**
- * Versión mínima de los paquetes `@opencode-ai/*` verificada contra la
- * superficie que usa openteam.
+ * Minimum version of the `@opencode-ai/*` packages verified against the
+ * surface used by openteam.
  */
 export declare const MIN_SUPPORTED_OPENCODE_VERSION = "1.17.13";
 /**
- * Versiones exactas cuya superficie de contrato ha sido verificada. Al subir a
- * una versión nueva hay que añadirla aquí **después** de revisar los puntos de
- * integración documentados en {@link OPENCODE_CONTRACT_SURFACES}.
+ * Exact versions whose contract surface has been verified. When moving to a
+ * new version, it must be added here **after** reviewing the integration points
+ * documented in {@link OPENCODE_CONTRACT_SURFACES}.
  */
-export declare const SUPPORTED_OPENCODE_VERSIONS: readonly ["1.17.13", "1.18.18"];
+export declare const SUPPORTED_OPENCODE_VERSIONS: readonly ["1.17.13", "1.18.18", "1.18.19"];
 export type SupportedOpencodeVersion = (typeof SUPPORTED_OPENCODE_VERSIONS)[number];
 /**
- * Puntos de integración concretos que openteam asume estables. Sirve como
- * checklist ejecutable/documental cuando se verifica una versión nueva.
+ * The opencode version this repo currently develops against. Equals the newest
+ * entry in `SUPPORTED_OPENCODE_VERSIONS` and the version pinned in
+ * `package.json` for `@opencode-ai/plugin`.
+ *
+ * Release certificates are stamped with this value. At startup,
+ * `parseReleaseCertificate` and `parseShadowCertificate` verify that the
+ * live server version matches this constant exactly — a mismatch means the
+ * evidence was gathered under a different opencode version.
+ *
+ * **When to bump:** when a new opencode version is added to
+ * `SUPPORTED_OPENCODE_VERSIONS` AND set as the dependency in `package.json`,
+ * update this constant to match. Re-run `bun run certify:release` and
+ * `bun run certify:shadow` afterwards to emit fresh v2 artifacts.
+ */
+export declare const CURRENT_OPENCODE_VERSION: SupportedOpencodeVersion;
+/**
+ * Concrete integration points that openteam assumes are stable. Serves as an
+ * executable/documentary checklist when verifying a new version.
  */
-export declare const OPENCODE_CONTRACT_SURFACES: readonly ['Hooks["chat.message"] permite mutar output.message.model', 'Hooks["chat.message"] permite mutar output.parts[].text (inyección de contexto)', "tool() + tool.schema (zod) para custom tools", "PluginModule = { id?, server } con server: (input, options?) => Promise<Hooks>", "SDK session.create / session.prompt aceptan body.model = { providerID, modelID }", 'Hooks["tool.execute.before"] / Hooks["tool.execute.after"] reciben { tool, sessionID, callID }', 'Hooks["event"] con message.updated trae properties.info (AssistantMessage) con cost:number y tokens{input,output,reasoning,cache{read,write}} y time{created,completed}', 'El frontmatter `permission` de un agente (`.opencode/agent/*.md`) ANULA el `permission` global de `opencode.json`; el catch-all `"*": allow` concede todos los permisos (base del modo YOLO)'];
+export declare const OPENCODE_CONTRACT_SURFACES: readonly ['Hooks["chat.message"] allows mutating output.message.model', 'Hooks["chat.message"] allows mutating output.parts[].text (context injection)', "tool() + tool.schema (zod) for custom tools", "PluginModule = { id?, server } with server: (input, options?) => Promise<Hooks>", "SDK session.create accepts parentID/title; session.prompt accepts body.model = { providerID, modelID }", 'Hooks["tool.execute.before"] / Hooks["tool.execute.after"] receive { tool, sessionID, callID }', 'Hooks["event"] with message.updated brings properties.info (AssistantMessage) with cost:number and tokens{input,output,reasoning,cache{read,write}} and time{created,completed}', 'A per-agent `permission` frontmatter (`.opencode/agent/*.md`) OVERRIDES the global `permission` in `opencode.json`; the catch-all `"*": allow` grants all permissions (basis of YOLO mode)'];
 export type Semver = {
     readonly major: number;
     readonly minor: number;
     readonly patch: number;
 };
 /**
- * Parsea una versión semver, tolerando prefijos de rango habituales en
- * `package.json` (`^`, `~`, `=`, `v`). Ignora sufijos de pre-release/build.
+ * Parses a semver version, tolerating common range prefixes in `package.json`
+ * (`^`, `~`, `=`, `v`). Ignores pre-release/build suffixes.
  */
 export declare function parseSemver(version: string): Semver;
 /**
- * Compara dos versiones semver. Devuelve -1 si a<b, 0 si iguales, 1 si a>b.
+ * Compares two semver versions. Returns -1 if a<b, 0 if equal, 1 if a>b.
  */
 export declare function compareSemver(a: Semver, b: Semver): -1 | 0 | 1;
 /**
- * true si la versión exacta está en la allow-list verificada.
+ * true if the exact version is in the verified allow-list.
  */
 export declare function isSupportedOpencodeVersion(version: string): version is SupportedOpencodeVersion;
 /**
- * true si la versión cumple el piso mínimo soportado.
+ * true if the version meets the minimum supported floor.
  */
 export declare function meetsMinimumOpencodeVersion(version: string): boolean;
 //# sourceMappingURL=opencode.d.ts.map

package/dist/contract/opencode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/contract/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,YAC5B,qBAAqB,EACrB,kBAAkB,CACV,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,YAAY,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,YAAI,SAAS,EAAE,SAAS,CAAU,CAAC;AAE3E,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YACrC,0DAA0D,EAC1D,iFAAiF,EACjF,8CAA8C,EAC9C,gFAAgF,EAChF,kFAAkF,EAClF,gGAAgG,EAChG,yKAAyK,EACzK,8LAA8L,CACtL,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAIF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAanD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAc9D;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,IAAI,wBAAwB,CAErC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpE"}
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/contract/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,YAC5B,qBAAqB,EACrB,kBAAkB,CACV,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,YAAY,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,YACtC,SAAS,EACT,SAAS,EACT,SAAS,CACD,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,EAAE,wBAAoC,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YACrC,4DAA4D,EAC5D,+EAA+E,EAC/E,6CAA6C,EAC7C,iFAAiF,EACjF,wGAAwG,EACxG,gGAAgG,EAChG,iLAAiL,EACjL,4LAA4L,CACpL,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAIF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAanD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAc9D;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,IAAI,wBAAwB,CAErC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpE"}

package/dist/graph/certificate.d.ts

@@ -140,6 +140,32 @@ export declare class ShadowCertificateError extends Error {
     readonly detail: string;
     constructor(code: ShadowCertificateErrorCode, detail: string);
 }
+/**
+ * Computes a stable chain-binding digest for a shadow certificate's evidence.
+ *
+ * The binding digest covers all structural evidence fields — parity counts,
+ * privacy results, overhead budget and sample count, provenance, and the
+ * opencode version — but intentionally excludes `overhead.p95Millis`.
+ *
+ * WHY: `p95Millis` is a wall-clock measurement that varies between runs of
+ * identical code (different CPU load, timer resolution, scheduler jitter). The
+ * shadow certificate's own `digest` covers it for tamper-evidence on the
+ * stored artifact, but the *chain binding* that links a release certificate to
+ * a particular shadow run must be stable across runs of the same code. Using
+ * `cert.digest` for the chain binding therefore makes the release certificate
+ * unverifiable at startup: `certify:release` captures one timing value, a
+ * separately run `certify:shadow` captures a different timing value, and the
+ * two digests never match.
+ *
+ * The binding digest answers "is this the shadow evidence produced for THIS
+ * version and configuration?" — a question that wall-clock measurements cannot
+ * help answer, and including them only introduces spurious inequality.
+ *
+ * `overhead.budgetMillis` and `overhead.samples` ARE included: the budget is a
+ * configuration constant and the sample count is determined by the fixture, so
+ * both are stable across runs.
+ */
+export declare function shadowCertificateBindingDigest(evidence: ShadowCertificateEvidence): string;
 /**
  * Construye el certificado a partir de la evidencia. El veredicto **no es un
  * parámetro**: se deriva de las puertas, de modo que no existe un camino para
@@ -157,8 +183,12 @@ export declare function parseShadowCertificate(value: unknown, opencodeVersion:
  * Puertas del certificado de release. Cada una es condición **necesaria**: una
  * puerta que corrió cero casos falla por vacuidad, y la ausencia de evidencia
  * es fracaso, no éxito.
+ *
+ * La puerta `migration` fue eliminada en v2: no existe ninguna instalación con
+ * datos en formato legacy que necesite migración, y certificar código
+ * inalcanzable era teatro, no evidencia real.
  */
-export type ReleaseCertificateGate = "shadow-valid" | "determinism" | "crash-recovery" | "replay-equivalence" | "privacy" | "contract" | "migration" | "health" | "performance";
+export type ReleaseCertificateGate = "shadow-valid" | "determinism" | "crash-recovery" | "replay-equivalence" | "privacy" | "contract" | "health" | "performance";
 declare const ReleaseEvidenceSchema: z.ZodObject<{
     opencodeVersion: z.ZodString;
     platform: z.ZodEnum<{
@@ -186,10 +216,6 @@ declare const ReleaseEvidenceSchema: z.ZodObject<{
         roundTrips: z.ZodNumber;
         allSettled: z.ZodBoolean;
     }, z.core.$strict>;
-    migration: z.ZodObject<{
-        cases: z.ZodNumber;
-        allSucceeded: z.ZodBoolean;
-    }, z.core.$strict>;
     health: z.ZodObject<{
         samples: z.ZodNumber;
         bounded: z.ZodBoolean;
@@ -204,7 +230,7 @@ declare const ReleaseEvidenceSchema: z.ZodObject<{
 /** Evidencia bruta que alimenta el certificado de release. */
 export type ReleaseCertificateEvidence = z.infer<typeof ReleaseEvidenceSchema>;
 declare const ReleaseCertificateSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+    version: z.ZodLiteral<2>;
     certificate: z.ZodLiteral<"graph-release">;
     platform: z.ZodEnum<{
         linux: "linux";
@@ -239,10 +265,6 @@ declare const ReleaseCertificateSchema: z.ZodObject<{
             roundTrips: z.ZodNumber;
             allSettled: z.ZodBoolean;
         }, z.core.$strict>;
-        migration: z.ZodObject<{
-            cases: z.ZodNumber;
-            allSucceeded: z.ZodBoolean;
-        }, z.core.$strict>;
         health: z.ZodObject<{
             samples: z.ZodNumber;
             bounded: z.ZodBoolean;
@@ -263,7 +285,6 @@ declare const ReleaseCertificateSchema: z.ZodObject<{
         "crash-recovery": "crash-recovery";
         determinism: "determinism";
         health: "health";
-        migration: "migration";
         performance: "performance";
         privacy: "privacy";
         "replay-equivalence": "replay-equivalence";
@@ -271,8 +292,8 @@ declare const ReleaseCertificateSchema: z.ZodObject<{
     }>>;
     digest: z.ZodString;
 }, z.core.$strict>;
-/** Certificado machine-readable de release del grafo. */
-export type GraphReleaseCertificateV1 = z.infer<typeof ReleaseCertificateSchema>;
+/** Certificado machine-readable de release del grafo (v2). */
+export type GraphReleaseCertificateV2 = z.infer<typeof ReleaseCertificateSchema>;
 /** Motivo tipado por el que un certificado de release no es aceptable. */
 export type ReleaseCertificateErrorCode = "invalid-certificate" | "field-inconsistency" | "verdict-mismatch" | "digest-mismatch" | "opencode-mismatch";
 /** Error fail-closed del certificado de release. */
@@ -290,7 +311,7 @@ export declare class ReleaseCertificateError extends Error {
  * coincide, la puerta `shadow-valid` falla. Es obligatorio: un certificado
  * nunca puede ser su propio testigo.
  */
-export declare function buildReleaseCertificate(evidence: ReleaseCertificateEvidence, expectedShadowDigest: string): GraphReleaseCertificateV1;
+export declare function buildReleaseCertificate(evidence: ReleaseCertificateEvidence, expectedShadowDigest: string): GraphReleaseCertificateV2;
 /**
  * Valida un certificado de release de procedencia no confiable. Fail-closed:
  * `invalid-certificate` → `field-inconsistency` → `verdict-mismatch` →
@@ -300,7 +321,7 @@ export declare function buildReleaseCertificate(evidence: ReleaseCertificateEvid
  * espera — impide que un certificado forjado declare un digest falso y pase
  * la puerta `shadow-valid` por autocomparación.
  */
-export declare function parseReleaseCertificate(value: unknown, opencodeVersion: string, expectedShadowDigest: string): GraphReleaseCertificateV1;
+export declare function parseReleaseCertificate(value: unknown, opencodeVersion: string, expectedShadowDigest: string): GraphReleaseCertificateV2;
 /**
  * Puertas del certificado soak. Cada una es condición **necesaria**; cero
  * observaciones fallan cerrado por la puerta `minimum-observations`, no por
@@ -311,7 +332,7 @@ export type SoakCertificateGate = "minimum-observations" | "minimum-duration" |
  * Shadow divergence codes that the soak mechanism can classify as critical.
  * Defined here (not imported from orchestrator) to keep the graph module pure.
  */
-export declare const ShadowDivergenceCodeSchema: z.ZodEnum<{
+declare const ShadowDivergenceCodeSchema: z.ZodEnum<{
     fixes: "fixes";
     models: "models";
     order: "order";

package/dist/graph/certificate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"certificate.d.ts","sourceRoot":"","sources":["../../src/graph/certificate.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"certificate.d.ts","sourceRoot":"","sources":["../../src/graph/certificate.ts"],"names":[],"mappings":"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"}

package/dist/graph/langgraph/adapter.d.ts

@@ -0,0 +1,56 @@
+import type { PrivacyClass } from "../../context/schema";
+import { type PrivacyMode } from "../privacyPolicy";
+import type { AdapterDeps, AdapterInput, AdapterState, NodeFn, NodeName, RouteKind } from "./types";
+/**
+ * LangGraph runtime adapter (W4-S03, #177) — engine-agnostic decision core.
+ *
+ * `@langchain/langgraph@1.4.12` is now a declared dependency (W4-S01/W4-S02),
+ * marked `--external` in the build flags, but this module deliberately still
+ * does not import the library: it stays an engine-agnostic decision core so the
+ * six release gates certify deterministic semantics rather than a library
+ * version, and because runtime resolution under Node (Bun's resolver is more
+ * forgiving) is not yet proven. Instead it defines the
+ * StateGraph the binding will build — a route node, a dispatch node, an
+ * accumulating `visited` channel and a conditional edge — and a deterministic
+ * reference runner (`invokeStateGraph`) that executes those semantics. The
+ * eventual binding is a thin, mechanical mapping:
+ *
+ *   const g = new StateGraph(Annotation.Root({ ...channels, visited: reducer }))
+ *     .addNode("route", routeNode)
+ *     .addNode("dispatch", dispatchNode)
+ *     .addConditionalEdges("route", next)
+ *     .addEdge("dispatch", END);
+ *   return g.compile().invoke(input);
+ *
+ * The determinism, latency and privacy-routing properties proven against this
+ * runner are exactly what that binding preserves. Like the in-house facade
+ * (`orchestrator/graphFacade.ts`), the adapter is contained: it governs only
+ * routing/reduction and drives effects through the injected executor.
+ */
+/** Terminal marker, mirroring LangGraph's `END`. */
+declare const GRAPH_END: "__end__";
+/** Static description of the two-node StateGraph the binding will compile. */
+export type StateGraphDefinition = {
+    readonly entry: NodeName;
+    readonly nodes: Readonly<Record<NodeName, NodeFn>>;
+    readonly next: (state: AdapterState, current: NodeName) => NodeName | typeof GRAPH_END;
+};
+/**
+ * Resolves the effective dispatch route. Delegates to the shared GE-037 rule
+ * `frontierAllowed` (`../privacyPolicy`) — the single source of truth also used
+ * by `orchestrator/resolveDispatchRoute`. The privacy rule is reused, not
+ * forked: a `sensitive` node under `forceLocalOnSensitive` degrades a preferred
+ * `frontier` route to `local` (zero frontier dispatches) rather than throwing.
+ */
+export declare function resolveNodeRoute(privacyClass: PrivacyClass, mode: PrivacyMode, preferred: RouteKind): RouteKind;
+/** Builds the two-node StateGraph definition: route -> dispatch -> END. */
+export declare function buildAdapterDefinition(): StateGraphDefinition;
+/**
+ * Deterministic reference runner for a `StateGraphDefinition`. Executes each
+ * node, merges its update through the pure reducer, and follows the conditional
+ * edge until `END`. Given a deterministic executor, the same input yields the
+ * same final state on every invocation.
+ */
+export declare function invokeStateGraph(definition: StateGraphDefinition, input: AdapterInput, deps: AdapterDeps): Promise<AdapterState>;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/graph/langgraph/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,SAAS,EAEV,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,oDAAoD;AACpD,QAAA,MAAM,SAAS,EAAG,SAAkB,CAAC;AAErC,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,CACb,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,QAAQ,KACd,QAAQ,GAAG,OAAO,SAAS,CAAC;CAClC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,SAAS,GACnB,SAAS,CAIX;AA8BD,2EAA2E;AAC3E,wBAAgB,sBAAsB,IAAI,oBAAoB,CAM7D;AAKD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,oBAAoB,EAChC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,YAAY,CAAC,CAoBvB"}

package/dist/graph/langgraph/certification.d.ts

@@ -0,0 +1,64 @@
+import type { ReleaseCertificateEvidence } from "../certificate";
+import { type StateGraphDefinition } from "./adapter";
+import { type CheckpointerSelection, type ReferenceOnlySaver } from "./checkpointer";
+import type { AdapterReceipt, NodeExecutor } from "./types";
+/**
+ * Serializes a receipt and parses it back through the wire schema. The contract
+ * gate is satisfied only when the reconstructed receipt equals the original, so
+ * a codec that drops or corrupts a field turns the gate red.
+ */
+export declare function roundTripReceipt(receipt: AdapterReceipt): AdapterReceipt;
+/** Options for gathering release evidence. Counts and clock are injectable so
+ * tests can drive fault cases deterministically; defaults exercise the engine. */
+export type LangGraphEvidenceOptions = {
+    readonly executor: NodeExecutor;
+    readonly opencodeVersion: string;
+    readonly platform: "linux" | "win32";
+    readonly shadowCertificateDigest: string;
+    readonly now?: () => number;
+    readonly determinismRuns?: number;
+    readonly performanceSamples?: number;
+    readonly performanceBudgetMillis?: number;
+    readonly crashScenarios?: number;
+    readonly replayChecks?: number;
+    readonly privacySurfaces?: number;
+    readonly contractRoundTrips?: number;
+    readonly healthSamples?: number;
+};
+export declare function determinismEvidence(definition: StateGraphDefinition, executor: NodeExecutor, runs: number): Promise<{
+    runs: number;
+    allMatch: boolean;
+}>;
+export declare function performanceEvidence(definition: StateGraphDefinition, executor: NodeExecutor, samples: number, budgetMillis: number, now: () => number): Promise<{
+    p95Millis: number;
+    budgetMillis: number;
+    samples: number;
+}>;
+export declare function crashRecoveryEvidence(definition: StateGraphDefinition, executor: NodeExecutor, scenarios: number): Promise<{
+    scenarios: number;
+    allConverge: boolean;
+}>;
+export declare function replayEquivalenceEvidence(definition: StateGraphDefinition, executor: NodeExecutor, checks: number): Promise<{
+    checks: number;
+    allEquivalent: boolean;
+}>;
+export declare function requireReferenceOnlySaver(selection: CheckpointerSelection): ReferenceOnlySaver;
+export declare function privacyEvidence(definition: StateGraphDefinition, executor: NodeExecutor, surfaces: number): Promise<{
+    surfacesScanned: number;
+    rawFindings: number;
+}>;
+export declare function contractEvidence(definition: StateGraphDefinition, executor: NodeExecutor, roundTrips: number): Promise<{
+    roundTrips: number;
+    allSettled: boolean;
+}>;
+export declare function healthEvidence(definition: StateGraphDefinition, executor: NodeExecutor, samples: number, nodeCount: number): Promise<{
+    samples: number;
+    bounded: boolean;
+    idempotent: boolean;
+}>;
+/**
+ * Runs the LangGraph adapter and reconstructed primitives to produce a complete
+ * `ReleaseCertificateEvidence` object. Feed the result to `buildReleaseCertificate`.
+ */
+export declare function gatherLangGraphReleaseEvidence(options: LangGraphEvidenceOptions): Promise<ReleaseCertificateEvidence>;
+//# sourceMappingURL=certification.d.ts.map

package/dist/graph/langgraph/certification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"certification.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/certification.ts"],"names":[],"mappings":"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"}

package/dist/graph/langgraph/checkpointReplay.d.ts

@@ -0,0 +1,49 @@
+import type { StateGraphDefinition } from "./adapter";
+import type { AdapterDeps, AdapterInput, AdapterState, StateUpdate } from "./types";
+/**
+ * Reconstructed journal / snapshot / replay / recovery primitives over the
+ * LangGraph adapter (W4-S05, #179).
+ *
+ * The retired in-house kernel exposed a deterministic reducer, a filesystem
+ * journal, per-step snapshots, replay equivalence and recovery. LangGraph
+ * exposes none of those natively, only a checkpointer. Rather than redefine the
+ * six certificate gates around what LangGraph happens to offer (which would make
+ * the gates unfalsifiable), this module **reconstructs** those primitives from
+ * the checkpoint sequence — the approved option (a). It is bespoke, but bounded,
+ * pure (no clock/random/I/O beyond the injected executor) and testable, so the
+ * crash-recovery and replay-equivalence gates keep their original meaning when
+ * measured against the new engine.
+ */
+/** One recorded super-step: the node that ran, the update it produced, the
+ * reduced state after it, and a digest of that state (the snapshot). */
+export type Checkpoint = {
+    readonly step: number;
+    readonly node: string;
+    readonly update: StateUpdate;
+    readonly state: AdapterState;
+    readonly stateHash: string;
+};
+/** A run plus its full checkpoint sequence. */
+export type RecordedRun = {
+    readonly final: AdapterState;
+    readonly checkpoints: readonly Checkpoint[];
+};
+/** Digest (snapshot id) of an adapter state. */
+export declare function hashState(state: AdapterState): string;
+/** Runs the graph, recording a checkpoint (journal entry + snapshot) after each
+ * super-step. This is the reconstructed journal. */
+export declare function runRecordingCheckpoints(definition: StateGraphDefinition, input: AdapterInput, deps: AdapterDeps): Promise<RecordedRun>;
+/**
+ * Crash recovery: given the checkpoint the run had reached before a simulated
+ * crash (in-memory state lost), resume purely from that persisted snapshot and
+ * drive to completion. A correct engine converges to the same final state a
+ * crash-free run would reach.
+ */
+export declare function resumeFromCheckpoint(definition: StateGraphDefinition, checkpoint: Checkpoint, deps: AdapterDeps): Promise<AdapterState>;
+/**
+ * Replay equivalence: reconstruct the final state purely by folding the recorded
+ * updates through the deterministic reducer, independent of the live run. A
+ * replay-equivalent engine reproduces the live final state exactly.
+ */
+export declare function replayCheckpoints(input: AdapterInput, checkpoints: readonly Checkpoint[]): AdapterState;
+//# sourceMappingURL=checkpointReplay.d.ts.map

package/dist/graph/langgraph/checkpointReplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpointReplay.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/checkpointReplay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EAEZ,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;GAaG;AAEH;wEACwE;AACxE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,+CAA+C;AAC/C,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C,CAAC;AAmBF,gDAAgD;AAChD,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAErD;AAkDD;oDACoD;AACpD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,oBAAoB,EAChC,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,WAAW,CAAC,CAEtB;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,oBAAoB,EAChC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,YAAY,CAAC,CAavB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,YAAY,CAMd"}

package/dist/graph/langgraph/checkpointer.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/** Where a graph run's state lives, which decides the checkpointer. */
+export type CheckpointStateLocation = "ephemeral" | "committed";
+/**
+ * The only fields a committed checkpoint may carry: identifiers, the resolved
+ * route and a state digest. `.strict()` REJECTS any other key rather than
+ * stripping it. This is load-bearing for the option (a) certification story: a
+ * checkpoint whose shape drifts (e.g. under a LangGraph version bump) must fail
+ * loudly instead of parsing "successfully" with fields silently dropped, which
+ * would leave the reconstructed primitives wrong while every gate stayed green —
+ * an unfalsifiable certificate. `assertReferenceOnly` enforces no-raw-content
+ * first; strict parsing then pins the persisted record to exactly this
+ * allow-list.
+ */
+declare const PersistedCheckpointSchema: z.ZodObject<{
+    runID: z.ZodString;
+    nodeID: z.ZodString;
+    route: z.ZodEnum<{
+        frontier: "frontier";
+        local: "local";
+    }>;
+    stateHash: z.ZodString;
+}, z.core.$strict>;
+/** Allow-listed, reference-only persisted checkpoint. */
+export type PersistedCheckpoint = z.infer<typeof PersistedCheckpointSchema>;
+/** A saver that persists only reference fields, rejecting raw content. */
+export interface ReferenceOnlySaver {
+    readonly location: string;
+    /** Validates an untrusted checkpoint payload and returns the allow-listed
+     * record. Throws `RedactionError` on any raw content field. */
+    save(payload: unknown): PersistedCheckpoint;
+}
+/** The selected checkpointer for a run, by state location. */
+export type CheckpointerSelection = {
+    readonly kind: "off-the-shelf";
+    readonly location: string;
+} | {
+    readonly kind: "reference-only";
+    readonly location: string;
+    readonly saver: ReferenceOnlySaver;
+};
+/**
+ * Selects the checkpointer for a run by where its state lives. Ephemeral state
+ * uses the off-the-shelf checkpointer under the machine-local path; committed
+ * state uses the reference-only saver.
+ */
+export declare function selectCheckpointer(location: CheckpointStateLocation): CheckpointerSelection;
+export {};
+//# sourceMappingURL=checkpointer.d.ts.map

package/dist/graph/langgraph/checkpointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpointer.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/checkpointer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+BxB,uEAAuE;AACvE,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG,WAAW,CAAC;AAEhE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;kBAOpB,CAAC;AAEZ,yDAAyD;AACzD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;mEAC+D;IAC/D,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAAC;CAC7C;AAgBD,8DAA8D;AAC9D,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;CACpC,CAAC;AAEN;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,uBAAuB,GAChC,qBAAqB,CASvB"}

package/dist/graph/langgraph/engine.d.ts

@@ -0,0 +1,34 @@
+import type { OpenTeamConfig } from "../../config/schema";
+import type { GraphEffectExecutor } from "../../orchestrator/graphEffects";
+import type { NodeExecutor } from "./types";
+/**
+ * Engine selection seam (W4-S03, #177).
+ *
+ * The bespoke `src/graph/` runtime and the LangGraph adapter coexist behind a
+ * single configuration switch. `resolveGraphEngine` reads `graph.engine`, which
+ * defaults to `builtin`, so a fresh clone keeps the current engine and the
+ * LangGraph path is strictly opt-in. This module is the ONLY production wiring
+ * that reaches the adapter, which is what makes the six release gates
+ * (`certification.ts`, #179) meaningful: they certify exactly the engine a user
+ * can select here, not an isolated module no entrypoint reaches.
+ */
+/** Which graph runtime a run uses. */
+export type GraphEngineKind = "builtin" | "langgraph";
+/** Resolves the selected engine, defaulting to the current bespoke runtime. */
+export declare function resolveGraphEngine(config: OpenTeamConfig): GraphEngineKind;
+/**
+ * A `GraphEffectExecutor` backed by the LangGraph adapter. The adapter's
+ * deterministic reference runner (`invokeStateGraph`) stands in for
+ * `@langchain/langgraph`, which is now a declared dependency but is
+ * intentionally not bound here until runtime resolution under Node is proven;
+ * the routing, reduction and reference-only checkpoint semantics are identical
+ * to what the eventual library binding preserves.
+ *
+ * The dispatch effect is produced by the injected `NodeExecutor`. When none is
+ * configured — the current state, because the opencode session adapter is not
+ * wired and the library is intentionally not bound here yet — invoking the
+ * effect throws, exactly as the builtin `inertGraphEffects` does, rather than
+ * silently succeeding.
+ */
+export declare function createLangGraphEffects(nodeExecutor?: NodeExecutor): GraphEffectExecutor;
+//# sourceMappingURL=engine.d.ts.map

package/dist/graph/langgraph/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAOzC,OAAO,KAAK,EAAgB,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;GAUG;AAEH,sCAAsC;AACtC,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;AAEtD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,CAE1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,CAAC,EAAE,YAAY,GAC1B,mBAAmB,CAwDrB"}

package/dist/graph/langgraph/graphModel.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Salvaged, dependency-free graph model (W4-S06, #180).
+ *
+ * The retired kernel described a run's structure in `../schema.ts` as Zod
+ * schemas fused to the in-house event log, journal and reducer. The LangGraph
+ * engine only needs the *structural* shape of a run — its nodes and their
+ * dependency edges — so this module re-expresses the reusable node/edge types
+ * as plain TypeScript, with no Zod, no events, no reducer and no I/O. W5 can
+ * build the LangGraph `StateGraph` topology from these types without importing
+ * the legacy kernel.
+ *
+ * It is purely additive: `../schema.ts` and its consumers are untouched. This
+ * file is type-only; it declares no runtime value.
+ */
+/** Who executes a node's effect. Mirrors the retired `NodeRole`. */
+export type GraphModelRole = "implementer" | "reviewer";
+/**
+ * A node in a run's dependency DAG. A `reviewer` names, via `reviews`, the node
+ * whose artifact it reviews; an `implementer` never carries `reviews`.
+ */
+export type GraphModelNode = {
+    readonly id: string;
+    readonly role: GraphModelRole;
+    readonly dependsOn: readonly string[];
+    readonly reviews?: string;
+};
+/** A directed dependency edge: `from` must complete before `to` may run. */
+export type GraphModelEdge = {
+    readonly from: string;
+    readonly to: string;
+};
+/** A run as plain structure: an identifier and its nodes. */
+export type GraphModel = {
+    readonly runID: string;
+    readonly nodes: readonly GraphModelNode[];
+};
+//# sourceMappingURL=graphModel.d.ts.map

package/dist/graph/langgraph/graphModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphModel.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/graphModel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,UAAU,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CAC3C,CAAC"}

package/dist/graph/langgraph/reducer.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterState, StateUpdate } from "./types";
+/**
+ * Pure channel reducer for the LangGraph adapter state (W4-S03, #177).
+ *
+ * This is the adapter's decision core: it merges a node's partial channel
+ * update into the reduced state exactly as a LangGraph `Annotation.Root`
+ * reducer would — scalar/reference channels (`input`, `route`, `receipt`)
+ * overwrite, while `visited` accumulates in dispatch order. It is a pure
+ * function of its inputs: no clock, randomness, filesystem, network or
+ * environment access, so a graph built on it is deterministic and the
+ * router-purity contract is preserved.
+ */
+/**
+ * Applies one channel update to the reduced state, returning a fresh state.
+ * Overwrite channels take the update when present; `visited` concatenates.
+ */
+export declare function reduceAdapterState(current: AdapterState, update: StateUpdate): AdapterState;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/graph/langgraph/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../../src/graph/langgraph/reducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,WAAW,GAClB,YAAY,CAad"}