@jmanuelcorral/openteam 0.1.41 → 0.2.0

package/dist/orchestrator/worktreeDispatch.d.ts

@@ -0,0 +1,84 @@
+import type { WorktreeBinding } from "../storage/graph/worktreeRegistry";
+/**
+ * Seam de despacho al worktree del run (GE-073, D-W3).
+ *
+ * Decide, para un efecto del runtime de Graph, el `directory` con el que se crea
+ * la sub-sesión hija (`query.directory`) y verifica la correlación del contrato
+ * `PluginInput.directory`/`worktree` (GE-005). Es lógica pura y determinista:
+ * sin I/O, SDK, reloj ni estado global; el probe de salud del worktree y la
+ * consulta al registro (GE-072) los hace el llamante y entrega sus resultados
+ * como datos.
+ *
+ * Invariante de UX-neutralidad: con el aislamiento **desactivado**
+ * (`graph.worktrees.enabled` = `false`, el default) el directorio resuelto es
+ * exactamente el del workspace actual, de modo que el despacho es idéntico al
+ * de hoy. Con el aislamiento activo se exige un worktree sano vinculado al run
+ * y se cierra en falso (`WorktreeDispatchError`) si falta la vinculación, el
+ * directorio desapareció (`missing`) o está sucio (`unclean`). Ninguna ruta viva
+ * llama todavía a este seam; lo consumirá la integración del executor.
+ */
+/** Salud observada del worktree de un run (resultado del probe del llamante). */
+export type WorktreeHealth = "ready" | "missing" | "unclean";
+/** Estado del despacho respecto al aislamiento por worktree del run. */
+export type WorktreeDispatchState = {
+    readonly kind: "disabled";
+} | {
+    readonly kind: "unbound";
+} | {
+    readonly kind: "missing";
+    readonly worktreePath: string;
+} | {
+    readonly kind: "unclean";
+    readonly worktreePath: string;
+} | {
+    readonly kind: "ready";
+    readonly worktreePath: string;
+};
+/** Taxonomía cerrada de fallos al vincular el despacho a un worktree. */
+export type WorktreeDispatchErrorCode = "unbound" | "missing" | "unclean" | "mismatch";
+/** Error tipado de un despacho que no puede vincularse a un worktree sano. */
+export declare class WorktreeDispatchError extends Error {
+    readonly code: WorktreeDispatchErrorCode;
+    readonly detail: string;
+    constructor(code: WorktreeDispatchErrorCode, detail: string);
+}
+/** Directorio efectivo del despacho de un efecto. */
+export type DispatchDirectory = {
+    /**
+     * Directorio a pasar como `query.directory`. `undefined` = raíz del workspace
+     * (comportamiento actual cuando el aislamiento está desactivado).
+     */
+    readonly directory: string | undefined;
+    /** Worktree correlacionado; `undefined` salvo con aislamiento activo. */
+    readonly worktree: string | undefined;
+};
+/** Correlación observada del contrato `PluginInput` de una sub-sesión. */
+export type ObservedWorktreeCorrelation = {
+    readonly directory: string;
+    readonly worktree: string;
+};
+/**
+ * Combina el flag de aislamiento, la vinculación del registro (GE-072) y la
+ * salud observada del worktree en un estado de despacho. Cierra en falso por
+ * defecto: una salud ausente o desconocida se trata como `missing`.
+ */
+export declare function worktreeDispatchState(input: {
+    readonly enabled: boolean;
+    readonly binding: WorktreeBinding | undefined;
+    readonly health: WorktreeHealth | undefined;
+}): WorktreeDispatchState;
+/**
+ * Resuelve el directorio efectivo del despacho. Con el aislamiento desactivado
+ * devuelve el `workspaceDirectory` tal cual (idéntico al comportamiento actual);
+ * con un worktree sano devuelve su ruta como `directory` y `worktree`; en
+ * cualquier otro estado cierra en falso con `WorktreeDispatchError`.
+ */
+export declare function resolveDispatchDirectory(state: WorktreeDispatchState, workspaceDirectory: string | undefined): DispatchDirectory;
+/**
+ * Verifica la correlación del contrato `PluginInput` (GE-005): el
+ * `directory`/`worktree` observado de la sub-sesión debe coincidir con el
+ * worktree leaseado del run. Lanza `WorktreeDispatchError("mismatch")` si
+ * alguno difiere; comparación de rutas normalizada por plataforma.
+ */
+export declare function assertWorktreeCorrelation(observed: ObservedWorktreeCorrelation, leasedWorktree: string): void;
+//# sourceMappingURL=worktreeDispatch.d.ts.map

package/dist/orchestrator/worktreeDispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktreeDispatch.d.ts","sourceRoot":"","sources":["../../src/orchestrator/worktreeDispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AAEH,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAE7D,wEAAwE;AACxE,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,yEAAyE;AACzE,MAAM,MAAM,yBAAyB,GACjC,SAAS,GACT,SAAS,GACT,SAAS,GACT,UAAU,CAAC;AAEf,8EAA8E;AAC9E,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YAAY,IAAI,EAAE,yBAAyB,EAAE,MAAM,EAAE,MAAM,EAK1D;CACF;AAED,qDAAqD;AACrD,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAUF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,CAAC;CAC7C,GAAG,qBAAqB,CAgBxB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,qBAAqB,EAC5B,kBAAkB,EAAE,MAAM,GAAG,SAAS,GACrC,iBAAiB,CAanB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,2BAA2B,EACrC,cAAc,EAAE,MAAM,GACrB,IAAI,CAaN"}

package/dist/orchestrator/worktreeReconciler.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Reconciliador de worktrees huérfanos tras un crash (GE-074, D-W4).
+ *
+ * Sigue el mismo contrato dry-run que los comandos de operador (GE-045,
+ * `src/commands/graph.ts`): es **lógica pura y determinista** que recibe un
+ * snapshot ya observado (worktrees listados por el adapter GE-071, qué runs
+ * siguen activos según el registro de runs GE-025, y el estado de merge-back
+ * probado por el llamante) y decide, sin ejecutar, qué acción es segura para
+ * cada worktree. La ejecución real (`prune`/merge-back) vive en la capa de
+ * wiring y sólo cuando el plan la autoriza.
+ *
+ * Política de reconciliación:
+ * - **Run activo** → `retain`: nunca se toca un worktree cuyo run sigue vivo.
+ * - **Huérfano limpio y sin commits** → `prune`: eliminación segura y reportada.
+ * - **Huérfano limpio con commits** → `merge-back`: explícito e idempotente;
+ *   nunca descarta en silencio la rama del run. Una segunda pasada, cuando la
+ *   rama ya está integrada (`alreadyMerged`), planifica `prune` en vez de
+ *   volver a fusionar.
+ * - **Sucio o ambiguo** → `block`: se detiene para una decisión del operador.
+ *
+ * Invariante de UX-neutralidad (D-W4): con `graph.worktrees.enabled` = `false`
+ * (el default) el reconciliador es un **no-op** — devuelve un informe vacío, no
+ * planifica ni crea ni poda ningún worktree. Ninguna ruta viva lo llama todavía.
+ */
+/** Estado de merge-back observado de un worktree (probe de git del llamante). */
+export type WorktreeMergeState = "clean-empty" | "clean-ahead" | "dirty";
+/** Snapshot observado de un worktree candidato a reconciliar. */
+export type WorktreeObservation = {
+    readonly runID: string;
+    readonly path: string;
+    /** El run sigue activo según el registro de runs (lease vigente). */
+    readonly runActive: boolean;
+    /** Estado de merge-back observado. */
+    readonly mergeState: WorktreeMergeState;
+    /**
+     * Sólo relevante con `mergeState: "clean-ahead"`: la rama del run ya está
+     * integrada en la base, de modo que la reconciliación es idempotente y puede
+     * podar en vez de volver a fusionar.
+     */
+    readonly alreadyMerged?: boolean;
+};
+/** Acción planificada para un worktree, decidida sin ejecutarla. */
+export type WorktreeReconcileAction = "retain" | "prune" | "merge-back" | "block";
+/** Plan de reconciliación de un worktree concreto. */
+export type WorktreeReconcilePlan = {
+    readonly runID: string;
+    readonly path: string;
+    readonly action: WorktreeReconcileAction;
+    /** Razón estable y machine-readable de la decisión. */
+    readonly reason: string;
+    /** `true` cuando la acción preserva invariantes sin override del operador. */
+    readonly safe: boolean;
+};
+/** Informe agregado de la reconciliación. */
+export type WorktreeReconcileReport = {
+    /** Estado del flag de aislamiento en el momento de reconciliar. */
+    readonly enabled: boolean;
+    /** Plan por worktree, en el orden observado. */
+    readonly plans: readonly WorktreeReconcilePlan[];
+    readonly retained: number;
+    readonly pruned: number;
+    readonly mergeBack: number;
+    readonly blocked: number;
+};
+/**
+ * Planifica la reconciliación de un conjunto de worktrees observados. Con el
+ * aislamiento desactivado devuelve un informe vacío (no-op). Puro: no ejecuta
+ * git ni toca I/O.
+ */
+export declare function planWorktreeReconciliation(input: {
+    readonly enabled: boolean;
+    readonly worktrees: readonly WorktreeObservation[];
+}): WorktreeReconcileReport;
+//# sourceMappingURL=worktreeReconciler.d.ts.map

package/dist/orchestrator/worktreeReconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktreeReconciler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/worktreeReconciler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,aAAa,GAAG,OAAO,CAAC;AAEzE,iEAAiE;AACjE,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,sCAAsC;IACtC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,uBAAuB,GAC/B,QAAQ,GACR,OAAO,GACP,YAAY,GACZ,OAAO,CAAC;AAEZ,sDAAsD;AACtD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,6CAA6C;AAC7C,MAAM,MAAM,uBAAuB,GAAG;IACpC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAkCF;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACpD,GAAG,uBAAuB,CAwB1B"}

package/dist/plugin/graphShadowIngress.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod";
+import type { GraphMode } from "../config/schema";
+/**
+ * **Ingesta shadow productiva** (GE-042): observa **una** ejecución legacy real
+ * y la proyecta a un `LegacyExecutionTraceV1` **reference-only**, sin duplicar
+ * trabajo.
+ *
+ * El trace es el input que el espejo sin efectos (GE-043) compila para que el
+ * comparador de paridad (GE-044) lo contraste. Por eso transporta exactamente
+ * las dimensiones que el comparador normaliza —estado terminal, orden de nodos,
+ * roles, modelos, nº de fixes y outcome— y **nada de contenido crudo**: ni
+ * brief, ni prompt, ni argumentos de tool, ni salida del modelo. Solo ids,
+ * roles, referencias de modelo/sesión, clases de error y contadores.
+ *
+ * Garantías estructurales del boundary:
+ *   - **Sin efectos ni LLM:** este módulo solo mapea una observación ya
+ *     producida; nunca despacha una tool, ejecuta un efecto ni llama al modelo,
+ *     así que no puede duplicar la ejecución legacy que observa.
+ *   - **Sin trace sintético:** una observación que no ejecutó de verdad
+ *     (reanudada o `skipped`) o sin nodos es **inelegible de forma explícita**;
+ *     el builder nunca fabrica un run.
+ *   - **Gate dormant:** solo observa con `graph.mode` en `shadow`/`active` y sin
+ *     `killSwitch`; con `off` (o sección ausente) o kill-switch, inelegible.
+ *   - **Reference-only:** un guard final rechaza cualquier campo crudo y el
+ *     parser de boundary rechaza además claves desconocidas.
+ *
+ * Módulo **puro y determinista**: sin I/O, red, reloj, random ni env vars.
+ */
+/** Versión del trace de ejecución legacy. */
+export declare const LEGACY_EXECUTION_TRACE_VERSION: 1;
+/** Estado terminal normalizado de la ejecución legacy observada. */
+export declare const LegacyExecutionStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    completed: "completed";
+    failed: "failed";
+}>;
+export type LegacyExecutionStatus = z.infer<typeof LegacyExecutionStatusSchema>;
+/** Outcome normalizado del review de la ejecución legacy observada. */
+export declare const LegacyReviewOutcomeSchema: z.ZodEnum<{
+    approved: "approved";
+    inconclusive: "inconclusive";
+    rejected: "rejected";
+}>;
+export type LegacyReviewOutcome = z.infer<typeof LegacyReviewOutcomeSchema>;
+/**
+ * Nodo del trace: solo referencias y etiquetas acotadas. `model` es la
+ * referencia normalizada del modelo (p. ej. `provider/model`); `sessionRef` es
+ * el id de la subsesión de opencode, nunca su contenido; `errorClass` es la
+ * taxonomía acotada de fallo que comparte el runtime del grafo.
+ */
+export declare const LegacyTraceNodeV1Schema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    model: z.ZodString;
+    sessionRef: z.ZodOptional<z.ZodString>;
+    errorClass: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        permanent: "permanent";
+        timeout: "timeout";
+        transient: "transient";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>;
+export type LegacyTraceNodeV1 = z.infer<typeof LegacyTraceNodeV1Schema>;
+/**
+ * Trace versionado y reference-only de una única ejecución legacy productiva.
+ * `nodes` conserva el **orden** de despacho (implementer, reviewer, fixes...),
+ * que es una de las dimensiones de paridad.
+ */
+export declare const LegacyExecutionTraceV1Schema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    runID: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    outcome: z.ZodEnum<{
+        approved: "approved";
+        inconclusive: "inconclusive";
+        rejected: "rejected";
+    }>;
+    fixes: z.ZodNumber;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        model: z.ZodString;
+        sessionRef: z.ZodOptional<z.ZodString>;
+        errorClass: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            permanent: "permanent";
+            timeout: "timeout";
+            transient: "transient";
+            unknown: "unknown";
+        }>>;
+    }, z.core.$strict>>;
+    parentSessionRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LegacyExecutionTraceV1 = z.infer<typeof LegacyExecutionTraceV1Schema>;
+/** Gate de elegibilidad: subconjunto observado de la config `graph`. */
+export type ShadowIngressGate = {
+    readonly mode: GraphMode;
+    readonly killSwitch: boolean;
+};
+/** Motivo **explícito** por el que una observación no produce trace. */
+export type ShadowIngressIneligibleReason = "graph-disabled" | "kill-switch" | "not-executed" | "no-observation";
+/** Nodo observado de la ejecución legacy real (puerto de entrada acotado). */
+export type ObservedLegacyNode = {
+    readonly id: string;
+    readonly role: LegacyTraceNodeV1["role"];
+    readonly model: string;
+    /** Éxito terminal del nodo; deriva el outcome cuando el nodo es reviewer. */
+    readonly ok: boolean;
+    readonly sessionRef?: string;
+    readonly errorClass?: LegacyTraceNodeV1["errorClass"];
+};
+/**
+ * Observación de **una** ejecución legacy real, correlada por el orquestador a
+ * partir de los hooks de evento/tool. `executed: false` marca una reanudación o
+ * un `skipped` (sin ejecución real): inelegible explícito.
+ */
+export type ObservedLegacyRun = {
+    readonly runID: string;
+    readonly executed: boolean;
+    readonly status: LegacyExecutionStatus;
+    readonly fixes: number;
+    readonly nodes: readonly ObservedLegacyNode[];
+    readonly parentSessionRef?: string;
+};
+/** Resultado de la ingesta: trace elegible o inelegibilidad explícita. */
+export type ShadowIngressResult = {
+    readonly eligible: true;
+    readonly trace: LegacyExecutionTraceV1;
+} | {
+    readonly eligible: false;
+    readonly reason: ShadowIngressIneligibleReason;
+};
+/** El gate está abierto cuando la observación shadow es elegible. */
+export declare function shadowIngressGateOpen(gate: ShadowIngressGate | undefined): boolean;
+/**
+ * Ingesta la observación de una ejecución legacy real y devuelve un
+ * `LegacyExecutionTraceV1` reference-only, o la inelegibilidad explícita. No
+ * ejecuta efectos, no llama al modelo y no fabrica traces: solo proyecta lo
+ * observado cuando el gate está abierto y la ejecución fue real.
+ */
+export declare function ingestLegacyExecution(observation: ObservedLegacyRun, gate: ShadowIngressGate | undefined): ShadowIngressResult;
+/** Error tipado de validación del trace legacy en el boundary. */
+export declare class LegacyTraceError extends Error {
+    readonly code: "invalid-legacy-trace";
+    readonly issues: string[];
+    constructor(error: z.ZodError);
+}
+/**
+ * Valida y parsea un trace legacy en el boundary (lo consume GE-043). Lanza
+ * `LegacyTraceError` si la forma es inválida o transporta claves desconocidas,
+ * incluidos los campos de contenido crudo.
+ */
+export declare function parseLegacyExecutionTrace(input: unknown): LegacyExecutionTraceV1;
+//# sourceMappingURL=graphShadowIngress.d.ts.map

package/dist/plugin/graphShadowIngress.d.ts.map

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

package/dist/plugin/graphTool.d.ts

@@ -0,0 +1,63 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { GraphIngress, IngressDecision, IngressOutcome, IngressPolicy } from "../orchestrator/graphIngress";
+import type { SessionTracker } from "./sessionTracker";
+import { type ShadowObserver, type ShadowPipelineDeps } from "./shadowPipeline";
+/**
+ * GE-050 — superficie de opencode del ingress activo de SDD.
+ *
+ * En R1 la herramienta se registra pero la puerta interna está cerrada, así que
+ * responde siempre "no disponible" y **explica el bloqueo más externo**. Se
+ * registra igualmente porque el punto de entrada es justo lo que faltaba: sin
+ * él, "activar el grafo" seguiría sin significar nada operativamente y R2 no
+ * tendría dónde enchufar el piloto.
+ *
+ * `ingress` es opcional a propósito: R1 no tiene ejecutor de efectos de sesión
+ * (lo aporta GE-030/GE-051), y fabricar uno falso en producción sería peor que
+ * declarar la ausencia. Mientras no exista, ninguna acción mutante es posible.
+ *
+ * Este módulo no nombra el otorgante interno de la capability: la puerta solo se
+ * abre desde el módulo que la declara, y eso se verifica estructuralmente en g5.
+ */
+/** Acciones expuestas por la herramienta `openteam-graph`. */
+export type GraphToolAction = "status" | "start" | "cancel" | "report-run";
+export type GraphToolDeps = {
+    readonly policy: IngressPolicy;
+    /** Ingress real; ausente mientras el runtime activo no esté enchufado. */
+    readonly ingress?: GraphIngress;
+    /** Shadow pipeline deps; absent under mode "off" or when kill switch is active. */
+    readonly shadow?: ShadowPipelineDeps | undefined;
+    /** Session/model tracker for cross-verification of agent-reported fields. */
+    readonly tracker: SessionTracker;
+};
+/** Surface returned by createGraphTool: the tool definition plus the shadow observer. */
+export type GraphToolSurface = {
+    /** The opencode tool definition for registration. */
+    readonly definition: ToolDefinition;
+    /**
+     * Observe a legacy execution through the shadow pipeline. Returns a result
+     * indicating whether an observation was persisted, was ineligible, or
+     * failed with containment. If shadow deps were not provided, returns
+     * ineligible with reason "shadow-not-configured".
+     */
+    readonly observeLegacyExecution: ShadowObserver;
+};
+/** Texto estable para una decisión de enrutado. Puro y total. */
+export declare function describeDecision(decision: IngressDecision): string;
+/** Texto estable para el resultado de una operación. Puro y total. */
+export declare function describeOutcome(outcome: IngressOutcome): string;
+/** Motivo por el que una acción mutante no puede ejecutarse todavía. */
+export declare function unavailableReason(deps: GraphToolDeps, taskID: string): string;
+export declare function createGraphTool(deps: GraphToolDeps): GraphToolSurface;
+/**
+ * Despacha la acción `report-run`: valida, contrasta y produce una
+ * observación shadow. Contenido por try/catch: un fallo aquí nunca
+ * se propaga como excepción al agente.
+ *
+ * `tracker` es obligatorio: sin él no hay capacidad de contraverificación
+ * y todos los nodos quedan como no verificables. El compilador caza la
+ * omisión; el guard runtime maneja el caso dinámico imposible.
+ *
+ * Exportado para testing directo de la capa de contención externa.
+ */
+export declare function handleReportRun(args: Record<string, unknown>, observe: ShadowObserver, tracker: SessionTracker): Promise<string>;
+//# sourceMappingURL=graphTool.d.ts.map

package/dist/plugin/graphTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphTool.d.ts","sourceRoot":"","sources":["../../src/plugin/graphTool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,MAAM,qBAAqB,CAAC;AAEhE,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,aAAa,EACd,MAAM,8BAA8B,CAAC;AAUtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;;;;;;;GAeG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE3E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;IAChC,mFAAmF;IACnF,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACjD,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC,CAAC;AAEF,yFAAyF;AACzF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,sBAAsB,EAAE,cAAc,CAAC;CACjD,CAAC;AAEF,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAclE;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAe/D;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK7E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB,CA6FrE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC,CAwDjB"}

package/dist/plugin/hooks.d.ts

@@ -14,6 +14,12 @@ export type ChatMessageHookOptions = {
      * altera el determinismo del router ni el hash del prompt.
      */
     injectMemory?: (queryText: string) => Promise<string | null>;
+    /**
+     * Callback de routing (issue #53): notifica la sesión y el modelo enrutado
+     * tras cada decisión de `chat.message`. Usado por el `SessionTracker` para
+     * contraverificar los campos auto-reportados del agente en `report-run`.
+     */
+    onRoute?: (sessionID: string, model: string) => void;
 };
 export declare function deriveTaskSignals(input: Parameters<ChatMessageHook>[0], output: Parameters<ChatMessageHook>[1]): TaskSignals;
 /**

package/dist/plugin/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/plugin/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;AAEjE,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC9D,CAAC;AA8CF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACrC,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACrC,WAAW,CAqBb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACtC,KAAK,EAAE,MAAM,GACZ,OAAO,CAQT;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA+CjB;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,KAAK,CAIP"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/plugin/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;AAEjE,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC7D;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACtD,CAAC;AA8CF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACrC,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACrC,WAAW,CAqBb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EACtC,KAAK,EAAE,MAAM,GACZ,OAAO,CAQT;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA0DjB;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,sBAA2B,GACnC,KAAK,CAIP"}

package/dist/plugin/legacyRunProducer.d.ts

@@ -0,0 +1,60 @@
+import type { ObservedLegacyRun } from "./graphShadowIngress";
+import type { ReportRunPayload } from "./reportRunSchema";
+import type { SessionTracker } from "./sessionTracker";
+import type { ShadowPipelineResult } from "./shadowPipeline";
+/**
+ * **Productor de `ObservedLegacyRun`** (issue #53, ADR Option D §3–4).
+ *
+ * Recibe un `ReportRunPayload` validado por Zod en la frontera, contrasta
+ * los campos `model` y `sessionRef` contra la telemetría de sesión/routing
+ * acumulada por el `SessionTracker`, construye un `ObservedLegacyRun` y lo
+ * pasa al observador shadow.
+ *
+ * Módulo puro (sin I/O, reloj ni azar). La contención de fallos la da el
+ * shadow pipeline; aquí solo se construye la observación.
+ */
+/**
+ * Resultado de la producción de la observación legacy. Extiende el
+ * `ShadowPipelineResult` con metadatos de contraverificación.
+ */
+export type ProducerResult = {
+    /** Resultado del pipeline shadow. */
+    readonly pipeline: ShadowPipelineResult;
+    /** Nodos con modelo no verificable (sessionRef ausente o sin routing). */
+    readonly unverifiedModels: readonly string[];
+    /** Nodos con modelo verificado y discrepancia. */
+    readonly modelMismatches: readonly string[];
+    /** Nodos con sessionRef desconocida. */
+    readonly unknownSessions: readonly string[];
+};
+/** Resultado conciso devuelto a la herramienta como texto. */
+export type ReportRunResponse = {
+    readonly result: "observed" | "observation-rejected" | "ineligible" | "contained-failure";
+    readonly detail?: string;
+    /** Avisos de contraverificación, si hubo. */
+    readonly warnings?: readonly string[];
+};
+/**
+ * Produce una `ObservedLegacyRun` a partir de un reporte validado del agente.
+ * El run se marca como `executed: true` porque la acción solo se invoca al
+ * completar una ejecución real.
+ */
+export declare function buildObservedRun(payload: ReportRunPayload): ObservedLegacyRun;
+/**
+ * Contrasta los campos del reporte contra la telemetría acumulada.
+ * Devuelve avisos de contraverificación (warnings), nunca bloquea.
+ */
+export declare function crossVerify(payload: ReportRunPayload, tracker: SessionTracker): {
+    unverifiedModels: string[];
+    modelMismatches: string[];
+    unknownSessions: string[];
+};
+/**
+ * Formatea los warnings de contraverificación para la respuesta al agente.
+ */
+export declare function formatWarnings(verification: ReturnType<typeof crossVerify>): string[];
+/**
+ * Construye la respuesta de texto que la herramienta devuelve al agente.
+ */
+export declare function formatResponse(response: ReportRunResponse): string;
+//# sourceMappingURL=legacyRunProducer.d.ts.map

package/dist/plugin/legacyRunProducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyRunProducer.d.ts","sourceRoot":"","sources":["../../src/plugin/legacyRunProducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAqB,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;IACxC,0EAA0E;IAC1E,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,kDAAkD;IAClD,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,wCAAwC;IACxC,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,MAAM,EACX,UAAU,GACV,sBAAsB,GACtB,YAAY,GACZ,mBAAmB,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,CAAC;AAmBF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,iBAAiB,CAW7E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,cAAc,GACtB;IACD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CA8BA;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,GAC3C,MAAM,EAAE,CAkBV;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CASlE"}

package/dist/plugin/reportRunSchema.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+/**
+ * **Esquema Zod de la acción `report-run`** (issue #53, ADR Option D).
+ *
+ * Valida la forma estructural del reporte que el agente orquestador envía
+ * a través de la herramienta `openteam-graph`. Claves desconocidas se
+ * rechazan (`.strict()`): el payload del agente solo transporta campos
+ * documentados.
+ *
+ * Módulo puro: sin I/O, reloj ni azar.
+ */
+/** Nodo reportado por el agente: identidad + rol + modelo + éxito. */
+export declare const ReportRunNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        reviewer: "reviewer";
+    }>;
+    model: z.ZodString;
+    ok: z.ZodBoolean;
+    sessionRef: z.ZodOptional<z.ZodString>;
+    errorClass: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        permanent: "permanent";
+        timeout: "timeout";
+        transient: "transient";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>;
+export type ReportRunNode = z.infer<typeof ReportRunNodeSchema>;
+/** Payload completo de `report-run`. */
+export declare const ReportRunPayloadSchema: z.ZodObject<{
+    runID: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    fixes: z.ZodNumber;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            implementer: "implementer";
+            reviewer: "reviewer";
+        }>;
+        model: z.ZodString;
+        ok: z.ZodBoolean;
+        sessionRef: z.ZodOptional<z.ZodString>;
+        errorClass: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            permanent: "permanent";
+            timeout: "timeout";
+            transient: "transient";
+            unknown: "unknown";
+        }>>;
+    }, z.core.$strict>>;
+    parentSessionRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ReportRunPayload = z.infer<typeof ReportRunPayloadSchema>;
+//# sourceMappingURL=reportRunSchema.d.ts.map

package/dist/plugin/reportRunSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportRunSchema.d.ts","sourceRoot":"","sources":["../../src/plugin/reportRunSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB;;;;;;;;;GASG;AAEH,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;kBASrB,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,wCAAwC;AACxC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQxB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/plugin/sessionTracker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * **Rastreador de sesiones y modelos** (issue #53, ADR Option D §1).
+ *
+ * Acumula en memoria las sesiones conocidas (de eventos de ciclo de vida) y
+ * el modelo enrutado por sesión (de decisiones de `chat.message`). Ambos
+ * datos se usan para contraverificar los campos auto-reportados del agente
+ * en la acción `report-run`.
+ *
+ * Módulo con estado mutable (in-memory map); vive en `plugin/` porque es
+ * parte de la superficie de producción del plugin, no del router puro.
+ */
+/** Resultado de la contraverificación de modelo para un nodo. */
+export type ModelVerification = {
+    readonly verified: true;
+    readonly match: boolean;
+} | {
+    readonly verified: false;
+};
+/** Resultado de la contraverificación de sessionRef. */
+export type SessionRefVerification = {
+    readonly known: true;
+} | {
+    readonly known: false;
+} | {
+    readonly known: null;
+};
+export type SessionTracker = {
+    /** Registra una sesión conocida (de session.created, session.idle, etc.). */
+    readonly trackSession: (sessionID: string) => void;
+    /** Registra el modelo enrutado para una sesión (de chat.message). */
+    readonly trackRoutedModel: (sessionID: string, model: string) => void;
+    /** Verifica si un modelo reportado coincide con el enrutado. */
+    readonly verifyModel: (sessionRef: string, reportedModel: string) => ModelVerification;
+    /** Verifica si una referencia de sesión corresponde a una sesión conocida. */
+    readonly verifySessionRef: (sessionRef: string | undefined) => SessionRefVerification;
+};
+/**
+ * Crea un rastreador de sesiones y modelos. El estado es efímero: vive
+ * mientras el plugin esté cargado, no se persiste.
+ */
+export declare function createSessionTracker(): SessionTracker;
+//# sourceMappingURL=sessionTracker.d.ts.map

package/dist/plugin/sessionTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionTracker.d.ts","sourceRoot":"","sources":["../../src/plugin/sessionTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,iEAAiE;AACjE,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,CAAC;AAEjC,wDAAwD;AACxD,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,qEAAqE;IACrE,QAAQ,CAAC,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtE,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,CACpB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,KAClB,iBAAiB,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,EAAE,CACzB,UAAU,EAAE,MAAM,GAAG,SAAS,KAC3B,sBAAsB,CAAC;CAC7B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CA4BrD"}