@jinn-network/client 0.1.2 → 0.1.3-canary.262e5cda

package/dist/restorer/engine/engine.d.ts

@@ -11,24 +11,32 @@ import type { Store } from '../../store/store.js';
 import { type MarketplaceClaimer } from './claim.js';
 import type { ClaimRegistryClient } from '../../adapters/claim-registry/client.js';
 import { type PackagingDeps } from './packaging.js';
-import { type ManifestAssemblyDeps } from './manifest-assembly.js';
+import { type EnvelopeAssemblyDeps } from './envelope-assembly.js';
 import { type DeliveryDeps } from './delivery.js';
 import type { RestorerImpl } from '../types.js';
-import type { Registry8004 } from '../../discovery/registry.js';
+import type { IdentityPublisher, ReputationRegistryClient, ResolvedAgent } from '../../erc8004/index.js';
+import { TrajectoryCollector } from '../../trajectory/index.js';
 export declare class NotImplementedError extends Error {
     readonly transitionName: string;
     constructor(transitionName: string);
 }
-export interface RestorerImplRegistry {
-    /** Returns the impl name for a given spec kind (and optional type), or null if none registered. */
-    resolveImplName(ctx: {
-        kind: string | null;
+/**
+ * Resolves a `RestorerImpl` for a given spec kind (and optional type), or
+ * returns `undefined` when nothing is registered/enabled.
+ *
+ * The engine only needs `findFor` — `resolveImplName` was a redundant alias
+ * for `findFor(...)?.name` and was removed under jinn-mono-qip (supersedes
+ * jinn-mono-cy4). Concrete implementation lives in
+ * `restorer/engine/registry.ts` (`RestorerImplRegistry`).
+ */
+export interface ImplRegistry {
+    findFor(ctx: {
+        kind: string;
         type?: 'restoration' | 'evaluation';
-    }): string | null;
+    }): RestorerImpl | undefined;
 }
 export interface RestorationEngineOptions {
     store: Store;
-    registry: RestorerImplRegistry;
     paths: {
         workingDirRoot: string;
         implStateDirRoot: string;
@@ -45,13 +53,22 @@ export interface RestorationEngineOptions {
     /**
      * Packaging dependencies. When provided, pack() is functional.
      * When absent, pack() falls back to NotImplementedError.
+     *
+     * `requestId` is filled per-call by the engine from the in-flight intent;
+     * `collector` is wired per-call from `trajectoryCollectors`.
      */
-    packagingDeps?: PackagingDeps;
+    packagingDeps?: Omit<PackagingDeps, 'requestId' | 'collector'>;
     /**
-     * Manifest assembly dependencies. When provided, pack() can assemble + sign.
+     * Envelope assembly dependencies. When provided, pack() can assemble + sign.
      * When absent, pack() falls back to NotImplementedError.
+     *
+     * Replaces the old `manifestDeps` (ManifestAssemblyDeps). The safeAddress
+     * field that was on ManifestAssemblyDeps is now sourced from deliveryDeps
+     * or passed directly in EnvelopeInputs.participant.
      */
-    manifestDeps?: ManifestAssemblyDeps;
+    envelopeDeps?: EnvelopeAssemblyDeps & {
+        safeAddress?: `0x${string}`;
+    };
     /**
      * Delivery dependencies. When provided, deliver() is functional.
      * When absent, deliver() falls back to NotImplementedError.
@@ -61,20 +78,60 @@ export interface RestorationEngineOptions {
      * Impl registry for resolving which RestorerImpl to run.
      * When provided and findFor() returns an impl, runImpl() dispatches to it.
      */
-    implRegistry?: {
-        findFor(ctx: {
-            kind: string;
-            type?: 'restoration' | 'evaluation';
-        }): RestorerImpl | undefined;
+    implRegistry?: ImplRegistry;
+    /**
+     * ERC-8004 Identity Registry per-execution publisher (jinn-mono-3zk).
+     * When provided, the engine calls
+     *   `IdentityRegistry.setMetadata(agentId, "envelope:<cid>", v1Payload)`
+     * after `pack()` returns the manifest CID + evidenceHash, anchoring the
+     * execution under the operator's agent NFT (DR §4.2).
+     *
+     * Failures are logged but NEVER fatal — JinnRouter.claimDelivery(evidenceHash)
+     * remains the authoritative on-chain commitment; this publish is the
+     * discovery anchor.
+     *
+     * Optional — when absent, the engine simply skips publishing.
+     */
+    identityPublisher?: IdentityPublisher;
+    /**
+     * ERC-8004 ReputationRegistry feedback hook (jinn-mono-yg4).
+     *
+     * When provided, the engine fires `submitEvaluatorFeedback` after a
+     * successful evaluator-side `claimDelivery`, so the restorer's agent NFT
+     * accrues a rating per DR §4.3. Requires:
+     *
+     *   - `client`: a `ReputationRegistryClient` (writes are routed through the
+     *     evaluator's Safe so `msg.sender` matches the operator identity).
+     *   - `resolveAgentId`: looks up the restorer's `agentId` from the parent
+     *     manifest's `evidenceHash`. Returns `null` when no match is found
+     *     (subgraph not yet indexed; envelope not published) — the engine
+     *     skips feedback gracefully without failing delivery.
+     *
+     * Failures inside the hook are logged but NEVER fatal: JinnRouter's
+     * `claimDelivery` is the authoritative settlement. Restoration-only
+     * intents skip this branch entirely.
+     *
+     * Optional — when absent, the engine simply skips feedback.
+     */
+    reputationFeedback?: {
+        client: ReputationRegistryClient;
+        resolveAgentId: (manifestHash: `0x${string}`) => Promise<ResolvedAgent | null>;
     };
     /**
-     * ERC-8004 Identity Registry client. When provided, the engine registers
-     * the envelope (adw:ExecutionEnvelope) and each artifact (adw:Artifact with
-     * parentEnvelopeCid) after successful pack().
+     * Operator-local artifact serving config (Phase A.1, jinn-mono-vy37.1.3).
      *
-     * Optional — tests and development modes may skip registration.
+     * `publicEndpoint` is the externally-reachable base URL stamped onto every
+     * artifact + trajectory `access.endpoint`. `defaultPriceUsdc` and
+     * `perArtifactTypePrice` are pinned here so the engine doesn't have to thread
+     * them through `packagingDeps` separately for trajectory refs.
+     *
+     * Required for production wiring; tests may construct a synthetic value.
      */
-    erc8004Registry?: Registry8004;
+    operatorConfig?: {
+        publicEndpoint: string;
+        defaultPriceUsdc: string;
+        perArtifactTypePrice: Record<string, string>;
+    };
 }
 /** Per-intent outcome from a recovery pass. */
 export interface RecoveryReport {
@@ -84,15 +141,22 @@ export interface RecoveryReport {
 }
 export declare class RestorationEngine {
     protected readonly persistence: IntentPersistence;
-    protected readonly registry: RestorerImplRegistry;
     protected readonly paths: RestorationEngineOptions['paths'];
     protected readonly claimDeps: RestorationEngineOptions['claimDeps'];
     protected readonly packagingDeps: RestorationEngineOptions['packagingDeps'];
-    protected readonly manifestDeps: RestorationEngineOptions['manifestDeps'];
+    protected readonly envelopeDeps: RestorationEngineOptions['envelopeDeps'];
     protected readonly deliveryDeps: RestorationEngineOptions['deliveryDeps'];
     protected readonly implRegistry: RestorationEngineOptions['implRegistry'];
-    protected readonly erc8004Registry: RestorationEngineOptions['erc8004Registry'];
+    protected readonly identityPublisher: RestorationEngineOptions['identityPublisher'];
+    protected readonly reputationFeedback: RestorationEngineOptions['reputationFeedback'];
+    protected readonly operatorConfig: RestorationEngineOptions['operatorConfig'];
+    /** Local SQLite-backed store; used to emit `restoration-result` /
+     *  `evaluation-verdict` artifact rows when a cycle completes via a
+     *  deterministic impl (the legacy claude/MCP path writes them itself). */
+    protected readonly store: Store;
     private readonly implOutputs;
+    protected readonly trajectoryCollectors: Map<string, TrajectoryCollector>;
+    private readonly trajectoryRefs;
     /** Set by stop(); causes runTickLoop to exit at the next iteration. */
     private stopped;
     constructor(opts: RestorationEngineOptions);
@@ -172,9 +236,9 @@ export declare class RestorationEngine {
     protected takePostSnapshot(_intent: PersistedIntent): Promise<void>;
     /**
      * PACKAGING transition: walk workingDir, upload artifacts, assemble + sign
-     * manifest, upload manifest, persist manifest CID + artifact CIDs.
+     * envelope, upload envelope, persist envelope CID + artifact CIDs.
      *
-     * Requires packagingDeps + manifestDeps. When absent, falls back to
+     * Requires packagingDeps + envelopeDeps. When absent, falls back to
      * NotImplementedError.
      */
     protected pack(intent: PersistedIntent): Promise<void>;
@@ -188,6 +252,59 @@ export declare class RestorationEngine {
      * crashed), we skip the deliver step and go straight to claimDelivery.
      */
     protected deliver(intent: PersistedIntent): Promise<void>;
+    /**
+     * Post evaluator feedback on the restorer's agent NFT.
+     *
+     * Pulls the verdict from the persisted gating claim (the evaluator impl
+     * writes `{ verdict, score, scoreBasis, ... }` into `output.gating`),
+     * resolves the restorer's `agentId` via the configured subgraph
+     * resolver, and submits a single `ReputationRegistry.giveFeedback` tx.
+     *
+     * Skipped silently when:
+     *   - No `reputationFeedback` deps wired.
+     *   - `gatingClaim` doesn't carry a verdict (impl shape mismatch — log and
+     *     return).
+     *   - The parent restorer's manifest hash isn't reachable from the
+     *     persisted state (legacy intents that pre-date evidenceHash
+     *     threading — log and return).
+     *   - `resolveAgentId` returns null (subgraph not indexed yet, or no
+     *     subgraph URL configured at all — log and return).
+     *
+     * The mapping policy (PASS / FAIL / REJECTED / INDETERMINATE → score) lives
+     * inside `submitEvaluatorFeedback` / `mapVerdictToScore` in the
+     * feedback-hook module; we just hand it the verdict.
+     */
+    /**
+     * Insert a SQLite `artifacts` row for a successfully delivered cycle so the
+     * release acceptance gate (and the search API) can observe completion via
+     * the same surface as the legacy claude / MCP path.
+     *
+     * The legacy `legacy-claude` impl writes via the MCP `submit_restoration_result`
+     * tool when Claude reports success; deterministic impls don't go through MCP.
+     * This emitter closes that gap by writing the row from the engine when the
+     * cycle hits COMPLETE.
+     *
+     * Idempotent: if a row already exists for (requestId, tag) — e.g. the legacy
+     * MCP path got there first — we leave it alone.
+     */
+    private emitCycleArtifact;
+    private _maybePostEvaluatorFeedback;
+    /**
+     * Extract the restorer's `evidenceHash` (and best-effort `manifestCid`)
+     * from the persisted evaluation intent.
+     *
+     * The evaluator's `intent.context.restorationResult` holds the restorer's
+     * full signed manifest JSON inlined as a string (per
+     * `MechAdapter.tryCreateEvaluationJob`). We parse it and pull the
+     * `signature.hash`, which is exactly the on-chain `evidenceHash`.
+     *
+     * The CID is not always inlined — the manifest carries its own
+     * `intent.cid` field (the *original intent* CID), not its self-CID. We
+     * therefore return `manifestCid: null` here and rely on the subgraph
+     * resolver to surface the published manifest CID. Returns `null` when
+     * the inlined payload is missing or malformed.
+     */
+    private _extractRestorerManifestRef;
     /**
      * Returns the next state if the current state can be advanced purely from
      * persisted data (no external work needed), or null if external work is required.