@jinn-network/client 0.1.9 → 0.2.0-canary.0b79cd5d

package/dist/harnesses/engine/engine.d.ts

@@ -10,18 +10,31 @@ import { TaskRunPersistence, type PersistedTaskRun, type PersistedTaskRunInput }
 import type { Store } from '../../store/store.js';
 import { type ReapWorkDirsReport } from './work-dir-reaper.js';
 import { type PackagingDeps } from './packaging.js';
+import type { ReadOnlyCorpus } from '../../mcp/search-records.js';
 import { type EnvelopeAssemblyDeps } from './envelope-assembly.js';
 import { type DeliveryDeps } from './delivery.js';
 import type { Harness, HarnessContext, RuntimePlugin } from '../types.js';
 import type { IdentityPublisher, ReputationRegistryClient, ResolvedAgent } from '../../erc8004/index.js';
 import type { Task } from '../../types/task.js';
 import { TrajectoryCollector } from '../../trajectory/index.js';
+import { type ScrubPipeline } from '@jinn-network/core/scrub';
 import type { SolverNetManifestV1 } from '../../vendor/@jinn-network/sdk/dist/solvernets/index.js';
 import { type FreezeViolation } from '../../daemon/freeze-fence.js';
 export declare class NotImplementedError extends Error {
     readonly transitionName: string;
     constructor(transitionName: string);
 }
+/**
+ * A task cannot leave DISCOVERED until its canonical TaskCreated block has a
+ * valid timestamp. Exhausting the bounded lookup is recoverable: a later
+ * engine pass can query a healthy/caught-up RPC and continue the same row.
+ */
+export declare class TaskCreationTimestampUnavailableError extends Error {
+    readonly requestId: string;
+    readonly blockNumber: number;
+    readonly cause: unknown;
+    constructor(requestId: string, blockNumber: number, cause: unknown);
+}
 /**
  * Resolves a `Harness` for a given solverType (and optional role), or
  * returns `undefined` when nothing is registered/enabled.
@@ -43,6 +56,7 @@ export interface SolverNetRegistryLike {
         solverType: string;
         harness: string;
         model?: string;
+        provider?: import('../provider-ref.js').ProviderRef;
         runtimePlugins: RuntimePlugin[];
     } | undefined;
 }
@@ -70,6 +84,10 @@ export interface JoinedSolverNetsView {
     } | undefined;
     /** Enumerate all joined manifest CIDs (used for digest-based filtering). */
     manifestCids(): string[];
+    /** Add/replace one joined entry live (used by the hot-apply join applier, #1037). */
+    set(manifestCid: string, entry: {
+        roles: Array<'solver' | 'evaluator'>;
+    }): void;
 }
 /**
  * Build a `JoinedSolverNetsView` from the raw operator-config block.
@@ -82,6 +100,17 @@ export declare function joinedSolverNetsViewFromConfig(joined: Record<string, {
     manifestCid: string;
     roles: Array<'solver' | 'evaluator'>;
 }> | undefined): JoinedSolverNetsView | undefined;
+/**
+ * Mutable `JoinedSolverNetsView` for the running daemon. Unlike
+ * `joinedSolverNetsViewFromConfig` (boot snapshot), the applier
+ * (`daemon/join-applier.ts`, #1037) keeps a handle and calls `set()` when a
+ * join is hot-applied, so the engine's per-task eligibility check sees the new
+ * cid on its next call without a restart.
+ */
+export declare function createMutableJoinedSolverNetsView(initial: Record<string, {
+    manifestCid: string;
+    roles: Array<'solver' | 'evaluator'>;
+}> | undefined): JoinedSolverNetsView;
 /**
  * Resolves a launched SolverNet manifest by IPFS CID.
  *
@@ -140,6 +169,12 @@ export interface TaskEngineOptions {
      */
     implRegistry?: ImplRegistry;
     solverNetRegistry?: SolverNetRegistryLike;
+    /**
+     * Seller-side scrub pipeline applied to trajectory spans at emit time. When
+     * absent, the engine builds the default (openredaction + secretlint); supply
+     * one to add the ML PII detector.
+     */
+    scrubPipeline?: ScrubPipeline;
     /**
      * Per-launch operator eligibility filter (Task 28 of
      * `spec/2026-05-05-solvernet-creation-and-launch.md`).
@@ -158,6 +193,11 @@ export interface TaskEngineOptions {
      * SolverNet registry.
      */
     joinedSolverNets?: JoinedSolverNetsView;
+    /**
+     * Operator Safe address used for synthetic task claim filtering (§7).
+     * When set, `canAcceptTask` / `claim` reject mint-and-solve self-claims.
+     */
+    operatorSafeAddress?: `0x${string}`;
     /**
      * Resolves a launched SolverNet manifest by `solverNetManifestCid`.
      * Required for production wiring; tests that don't exercise schema
@@ -263,7 +303,46 @@ export interface TaskEngineOptions {
          */
         disabled?: boolean;
     };
+    /**
+     * Corpus knowledge autoload (#1393). Before each restoration harness
+     * spawn, the engine queries the corpus for prior solution records of the
+     * task's solverType and injects the top few into
+     * task.context.corpusKnowledge. The injection exists only in the in-memory
+     * ctx.task handed to the harness — unlike context.restorationResult (which
+     * the adapter attaches at task construction and which persists in
+     * task_payload), it is never persisted into the signed Task and never
+     * re-hashed. The durable record of what was injected is the run's
+     * consumed_refs_json column.
+     *
+     * - `corpus`: read-only corpus for network results; when absent/null the
+     *   lookup is store-only (local envelope projections + served artifacts).
+     * - `enabled`: opt-out; defaults to true (config: engine.knowledgeAutoload).
+     *
+     * Failures never block the solve path: the lookup is time-bounded and
+     * error-swallowing (loadCorpusKnowledge never throws).
+     */
+    knowledge?: {
+        corpus?: ReadOnlyCorpus | null;
+        enabled?: boolean;
+    };
+    /**
+     * Resolves the on-chain block timestamp for a task's creation block
+     * (#1827). Production wires this for every new task. It remains optional so
+     * historical/test callers can parse and exercise pre-field rows without
+     * fabricating a value.
+     *
+     * Returns `undefined` on a resolvable-but-unknown block. Undefined values
+     * and thrown transport errors are retried; a new envelope is never signed
+     * without the authoritative timestamp.
+     */
+    blockTimestamp?: {
+        getBlockTimestamp(blockNumber: number): Promise<number | undefined>;
+        /** Configured URLs let the redactor also strip detached API-key material. */
+        configuredRpcUrls?: readonly string[];
+    };
 }
+/** Min interval between transient-RPC tick_error emits per requestId (#934). */
+export declare const TRANSIENT_TICK_ERROR_HEARTBEAT_MS: number;
 /** Per-task outcome from a recovery pass. */
 export interface RecoveryReport {
     requestId: string;
@@ -287,8 +366,11 @@ export declare class TaskEngine {
     protected readonly deliveryDeps: TaskEngineOptions['deliveryDeps'];
     protected readonly implRegistry: TaskEngineOptions['implRegistry'];
     protected readonly solverNetRegistry: TaskEngineOptions['solverNetRegistry'];
+    protected readonly scrubPipeline: ScrubPipeline;
     protected readonly joinedSolverNets: TaskEngineOptions['joinedSolverNets'];
+    protected readonly operatorSafeAddress: TaskEngineOptions['operatorSafeAddress'];
     protected readonly manifestResolver: TaskEngineOptions['manifestResolver'];
+    protected readonly blockTimestamp: TaskEngineOptions['blockTimestamp'];
     protected readonly identityPublisher: TaskEngineOptions['identityPublisher'];
     protected readonly reputationFeedback: TaskEngineOptions['reputationFeedback'];
     protected readonly operatorConfig: TaskEngineOptions['operatorConfig'];
@@ -307,6 +389,9 @@ export declare class TaskEngine {
     protected readonly trajectoryCollectors: Map<string, TrajectoryCollector>;
     private readonly trajectoryRefs;
     private readonly runtimePluginsByRequest;
+    private readonly consumedRefsByRequest;
+    /** requestId → epoch ms of last transient tick_error emit (#934) */
+    private readonly lastTransientTickErrorAt;
     private readonly processingRequestIds;
     /** Set by stop(); causes runTickLoop to exit at the next iteration. */
     private stopped;
@@ -317,6 +402,8 @@ export declare class TaskEngine {
         orphanMaxAgeMs: number;
         disabled: boolean;
     };
+    /** Corpus knowledge autoload options (#1393). */
+    protected readonly knowledge: TaskEngineOptions['knowledge'];
     constructor(opts: TaskEngineOptions);
     /**
      * Called when an task is observed from an on-chain event.
@@ -362,7 +449,8 @@ export declare class TaskEngine {
     }>;
     /**
      * Recover all in-flight tasks from persisted state.
-     * Called at daemon startup before beginning normal event processing.
+     * Started at daemon startup; runs concurrently with the daemon loops
+     * (#1422 — startup must not block on a recovered impl re-execution).
      * Returns a per-task report for each task attempted.
      */
     recoverInFlight(): Promise<RecoveryReport[]>;
@@ -411,6 +499,7 @@ export declare class TaskEngine {
      * the operator has an enabled, ready Harness and advances DISCOVERED → CLAIMED.
      */
     protected claim(task: PersistedTaskRun): Promise<void>;
+    private resolveTaskCreationTimestamp;
     releaseClaimedNotStarted(): Promise<string[]>;
     /**
      * Internal routing key alias for the daemon-internal `solverType`-keyed
@@ -580,11 +669,13 @@ export declare class TaskEngine {
      *   in the L2 fallback chain failed at once) on a task whose delivery window
      *   is still open: leave the row in its current in-flight state so the next
      *   tick re-drives it once the RPCs recover, and emit a `tick_error` (warn)
-     *   event instead of inflating the FAILED counter. Without this the daemon
-     *   stamped the row FAILED, dropping it from `getInFlight()` permanently, so
-     *   L2 work went silent until a manual restart (#912). Past-window transient
-     *   errors still terminalize to avoid churning on work that can no longer
-     *   settle.
+     *   on first occurrence plus every `TRANSIENT_TICK_ERROR_HEARTBEAT_MS`
+     *   thereafter for that requestId (#934) — not once per failing tick —
+     *   instead of inflating the FAILED counter. Without the leave-in-flight
+     *   path the daemon stamped the row FAILED, dropping it from
+     *   `getInFlight()` permanently, so L2 work went silent until a manual
+     *   restart (#912). Past-window transient errors still terminalize to avoid
+     *   churning on work that can no longer settle.
      * - Everything else: existing markFailed behaviour. When invoked from
      *   recovery, `contextLabel === 'recovery'` so the failure_reason
      *   carries the `recovery:` prefix the original code path used.