@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/store/store.js

@@ -1,7 +1,31 @@
 import Database from 'better-sqlite3';
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { RESTORATION_INTENTS_SCHEMA } from '../restorer/engine/persistence.js';
+import { TASK_RUNS_SCHEMA } from '../harnesses/engine/persistence.js';
+function readClaimPolicyMaxClaims(taskPayload) {
+    if (!taskPayload)
+        return undefined;
+    try {
+        const parsed = JSON.parse(taskPayload);
+        const value = parsed.claimPolicy?.maxClaims ?? parsed.signedTask?.claimPolicy?.maxClaims;
+        return Number.isInteger(value) && value > 0 ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function derivePostedTaskLocalState(args) {
+    if (args.runs.some((run) => run.state === 'FAILED'))
+        return 'failed';
+    if (args.runs.some((run) => run.state === 'COMPLETE' || run.delivery_tx_hash))
+        return 'settled';
+    if (args.maxClaims !== undefined && args.localRestorationClaims >= args.maxClaims) {
+        return 'fully-claimed';
+    }
+    if (args.localRestorationClaims > 0 || args.runs.length > 0)
+        return 'claims-in-flight';
+    return undefined;
+}
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS own_activity (
   request_id TEXT PRIMARY KEY,
@@ -15,7 +39,9 @@ CREATE TABLE IF NOT EXISTS config (
 
 CREATE TABLE IF NOT EXISTS artifacts (
   id TEXT PRIMARY KEY,
-  desired_state_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  protocol_task_id TEXT,
+  task_cid TEXT,
   request_id TEXT NOT NULL,
   title TEXT NOT NULL,
   content TEXT,
@@ -28,7 +54,6 @@ CREATE TABLE IF NOT EXISTS artifacts (
   created_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
 
-CREATE INDEX IF NOT EXISTS idx_artifacts_desired_state ON artifacts (desired_state_id);
 CREATE INDEX IF NOT EXISTS idx_artifacts_outcome ON artifacts (outcome);
 CREATE INDEX IF NOT EXISTS idx_artifacts_remote ON artifacts (remote);
 
@@ -39,7 +64,7 @@ CREATE TABLE IF NOT EXISTS activity_events (
   request_id TEXT,
   service_index INTEGER,
   tx_hash TEXT,
-  spec_kind TEXT,
+  solver_type TEXT,
   outcome TEXT,
   detail TEXT
 );
@@ -71,21 +96,118 @@ CREATE TABLE IF NOT EXISTS balance_cache (
   error TEXT
 );
 
-CREATE TABLE IF NOT EXISTS intent_posts (
+CREATE TABLE IF NOT EXISTS task_posts (
   creator_safe_address TEXT NOT NULL,
   source_key TEXT NOT NULL,
   policy_type TEXT NOT NULL CHECK (policy_type IN ('once_per_safe', 'once_per_bucket', 'interval')),
   scope_key TEXT NOT NULL DEFAULT '',
-  desired_state_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
   request_id TEXT NOT NULL,
   first_posted_at TEXT NOT NULL,
   last_posted_at TEXT NOT NULL,
   post_count INTEGER NOT NULL DEFAULT 1,
   PRIMARY KEY (creator_safe_address, source_key, policy_type, scope_key)
 );
-CREATE INDEX IF NOT EXISTS idx_intent_posts_desired_state ON intent_posts (desired_state_id);
 
-CREATE TABLE IF NOT EXISTS intent_post_locks (
+CREATE TABLE IF NOT EXISTS served_artifacts (
+  sha256 TEXT PRIMARY KEY,
+  artifact_type TEXT NOT NULL,
+  request_id TEXT,
+  envelope_cid TEXT,
+  content BLOB NOT NULL,
+  content_size INTEGER NOT NULL,
+  price_usdc TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_served_artifacts_request ON served_artifacts (request_id);
+CREATE INDEX IF NOT EXISTS idx_served_artifacts_envelope ON served_artifacts (envelope_cid);
+CREATE INDEX IF NOT EXISTS idx_served_artifacts_artifact_type ON served_artifacts (artifact_type);
+
+CREATE TABLE IF NOT EXISTS artifact_access_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  sha256 TEXT NOT NULL,
+  artifact_type TEXT,
+  price_usdc TEXT,
+  outcome TEXT NOT NULL CHECK (outcome IN (
+    'free_served',
+    'payment_required',
+    'paid_served',
+    'verification_failed',
+    'settlement_failed',
+    'payment_malformed',
+    'not_found'
+  )),
+  http_status INTEGER NOT NULL,
+  payer TEXT,
+  settlement_tx TEXT,
+  error_reason TEXT,
+  remote_addr TEXT,
+  user_agent TEXT,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_artifact_access_events_sha ON artifact_access_events (sha256);
+CREATE INDEX IF NOT EXISTS idx_artifact_access_events_created ON artifact_access_events (created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_artifact_access_events_outcome ON artifact_access_events (outcome);
+
+CREATE TABLE IF NOT EXISTS network_artifacts (
+  sha256 TEXT PRIMARY KEY,
+  artifact_type TEXT NOT NULL,
+  envelope_cid TEXT,
+  content BLOB NOT NULL,
+  content_size INTEGER NOT NULL,
+  source TEXT NOT NULL CHECK (source IN ('origin', 'route-resolver', 'self-store-mirror')),
+  source_operator TEXT,
+  source_endpoint TEXT,
+  paid_amount_usdc TEXT NOT NULL,
+  fetched_at TEXT NOT NULL,
+  last_used_at TEXT NOT NULL,
+  peer_catalog_id TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_network_artifacts_envelope ON network_artifacts (envelope_cid);
+CREATE INDEX IF NOT EXISTS idx_network_artifacts_artifact_type ON network_artifacts (artifact_type);
+CREATE INDEX IF NOT EXISTS idx_network_artifacts_last_used ON network_artifacts (last_used_at DESC);
+
+CREATE TABLE IF NOT EXISTS envelope_projections (
+  envelope_id TEXT PRIMARY KEY,
+  envelope_cid TEXT,
+  envelope_sha256 TEXT,
+  signature_hash TEXT NOT NULL,
+  solver_type TEXT NOT NULL,
+  role TEXT NOT NULL,
+  task_cid TEXT,
+  task_id TEXT,
+  request_id TEXT,
+  generated_at INTEGER NOT NULL,
+  evidence_tier TEXT NOT NULL,
+  participant_safe_address TEXT,
+  participant_agent_eoa TEXT,
+  executor_impl_name TEXT,
+  executor_impl_version TEXT,
+  executor_runtime_bundle_digest TEXT,
+  executor_plugins_json TEXT NOT NULL DEFAULT '[]',
+  solution_envelope_cid TEXT,
+  solution_envelope_sha256 TEXT,
+  solution_envelope_ref TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_envelope_projections_solver_role ON envelope_projections (solver_type, role);
+CREATE INDEX IF NOT EXISTS idx_envelope_projections_task_cid ON envelope_projections (task_cid);
+CREATE INDEX IF NOT EXISTS idx_envelope_projections_request ON envelope_projections (request_id);
+CREATE INDEX IF NOT EXISTS idx_envelope_projections_generated ON envelope_projections (generated_at DESC);
+
+CREATE TABLE IF NOT EXISTS envelope_projection_metadata (
+  envelope_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  value_text TEXT NOT NULL,
+  value_type TEXT NOT NULL CHECK (value_type IN ('string', 'number', 'boolean')),
+  PRIMARY KEY (envelope_id, key),
+  FOREIGN KEY (envelope_id) REFERENCES envelope_projections(envelope_id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_envelope_projection_metadata_key_value
+  ON envelope_projection_metadata (key, value_text);
+
+CREATE TABLE IF NOT EXISTS task_post_locks (
   creator_safe_address TEXT NOT NULL,
   source_key TEXT NOT NULL,
   policy_type TEXT NOT NULL CHECK (policy_type IN ('once_per_safe', 'once_per_bucket', 'interval')),
@@ -95,6 +217,39 @@ CREATE TABLE IF NOT EXISTS intent_post_locks (
   PRIMARY KEY (creator_safe_address, source_key, policy_type, scope_key)
 );
 
+CREATE TABLE IF NOT EXISTS pending_captures (
+  session_id TEXT PRIMARY KEY,
+  captured_at TEXT NOT NULL,
+  originating_tool_name TEXT NOT NULL,
+  originating_tool_version TEXT,
+  capture_path TEXT NOT NULL CHECK (capture_path IN ('A','B','C','D')),
+  status TEXT NOT NULL CHECK (status IN ('pending','approved','skipped')),
+  span_count INTEGER NOT NULL,
+  duration_ms INTEGER NOT NULL,
+  redacted_span_count INTEGER NOT NULL,
+  repo_remote_url TEXT,
+  repo_commit_hash TEXT,
+  envelope_cid TEXT,
+  published_at TEXT,
+  skipped_at TEXT
+);
+CREATE INDEX IF NOT EXISTS pending_captures_status_capturedat
+  ON pending_captures (status, captured_at DESC);
+
+CREATE TABLE IF NOT EXISTS capture_spans (
+  session_id TEXT NOT NULL,
+  span_id TEXT NOT NULL,
+  trace_id TEXT NOT NULL,
+  parent_span_id TEXT,
+  name TEXT NOT NULL,
+  start_time_unix_nano TEXT NOT NULL,
+  end_time_unix_nano TEXT NOT NULL,
+  attributes_json TEXT NOT NULL,
+  redacted_keys_json TEXT NOT NULL,
+  PRIMARY KEY (session_id, span_id)
+);
+CREATE INDEX IF NOT EXISTS capture_spans_session ON capture_spans (session_id);
+
 `;
 export class Store {
     /** Exposed for engine persistence layer — treat as package-internal. */
@@ -108,9 +263,119 @@ export class Store {
         this.db = new Database(dbPath);
         this.db.pragma('journal_mode = WAL');
         this.db.exec(SCHEMA);
-        this.db.exec(RESTORATION_INTENTS_SCHEMA);
+        this.db.exec(TASK_RUNS_SCHEMA);
+        this.ensureArtifactsTaskColumns();
         this.ensureRewardClaimsTxIndex();
+        this.ensureNetworkArtifactsPeerCatalogId();
+        this.ensureTaskPostsTaskCoordinatorColumns();
+        this.ensureEnvelopeProjectionColumns();
         this.backfillActivityEvents();
+        this.recordLegacyRestorationIntentsIgnored();
+    }
+    /** Older request-first DBs keyed artifacts by desired_state_id before Task-native IDs landed. */
+    ensureArtifactsTaskColumns() {
+        const cols = this.db.prepare(`PRAGMA table_info(artifacts)`).all();
+        const names = new Set(cols.map((c) => c.name));
+        if (!names.has('task_id')) {
+            this.db.exec(`ALTER TABLE artifacts ADD COLUMN task_id TEXT`);
+            if (names.has('desired_state_id')) {
+                this.db.exec(`UPDATE artifacts SET task_id = desired_state_id WHERE task_id IS NULL`);
+            }
+        }
+        if (!names.has('protocol_task_id')) {
+            this.db.exec(`ALTER TABLE artifacts ADD COLUMN protocol_task_id TEXT`);
+        }
+        if (!names.has('task_cid')) {
+            this.db.exec(`ALTER TABLE artifacts ADD COLUMN task_cid TEXT`);
+        }
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_artifacts_task ON artifacts (task_id)`);
+    }
+    /** Older on-disk DBs predate `peer_catalog_id` on network_artifacts. */
+    ensureNetworkArtifactsPeerCatalogId() {
+        const cols = this.db.prepare(`PRAGMA table_info(network_artifacts)`).all();
+        if (!cols.some((c) => c.name === 'peer_catalog_id')) {
+            this.db.exec(`ALTER TABLE network_artifacts ADD COLUMN peer_catalog_id TEXT`);
+        }
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_network_artifacts_peer_catalog ON network_artifacts (peer_catalog_id)`);
+    }
+    /** Fresh v1 state is Task-first; older local DBs get additive columns only. */
+    ensureTaskPostsTaskCoordinatorColumns() {
+        const cols = this.db.prepare(`PRAGMA table_info(task_posts)`).all();
+        const names = new Set(cols.map((c) => c.name));
+        if (!names.has('task_id')) {
+            this.db.exec(`ALTER TABLE task_posts ADD COLUMN task_id TEXT`);
+        }
+        if (!names.has('protocol_task_id')) {
+            this.db.exec(`ALTER TABLE task_posts ADD COLUMN protocol_task_id TEXT`);
+        }
+        if (!names.has('task_cid')) {
+            this.db.exec(`ALTER TABLE task_posts ADD COLUMN task_cid TEXT`);
+        }
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_task_posts_task ON task_posts (task_id)`);
+    }
+    /** Older local DBs may have the projection table from before Task grouping fields landed. */
+    ensureEnvelopeProjectionColumns() {
+        const cols = this.db.prepare(`PRAGMA table_info(envelope_projections)`).all();
+        const names = new Set(cols.map((c) => c.name));
+        const addColumn = (name, ddl) => {
+            if (!names.has(name))
+                this.db.exec(`ALTER TABLE envelope_projections ADD COLUMN ${ddl}`);
+        };
+        addColumn('task_id', 'task_id TEXT');
+        addColumn('executor_runtime_bundle_digest', 'executor_runtime_bundle_digest TEXT');
+        addColumn('executor_plugins_json', `executor_plugins_json TEXT NOT NULL DEFAULT '[]'`);
+        addColumn('solution_envelope_cid', 'solution_envelope_cid TEXT');
+        addColumn('solution_envelope_sha256', 'solution_envelope_sha256 TEXT');
+        addColumn('solution_envelope_ref', 'solution_envelope_ref TEXT');
+        addColumn('metadata_json', `metadata_json TEXT NOT NULL DEFAULT '{}'`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_envelope_projections_task_id ON envelope_projections (task_id)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_envelope_projections_solution_ref ON envelope_projections (solution_envelope_ref)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_envelope_projections_generated ON envelope_projections (generated_at DESC)`);
+    }
+    /**
+     * Task-native startup ignores the retired request-first `restoration_intents`
+     * table. Keep a one-time local marker when old in-flight rows are present so
+     * operators can see why they were not resumed without blocking Store startup.
+     */
+    recordLegacyRestorationIntentsIgnored() {
+        const table = this.db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'restoration_intents'`).get();
+        if (!table)
+            return;
+        const cols = this.db.prepare(`PRAGMA table_info(restoration_intents)`).all();
+        const names = new Set(cols.map((c) => c.name));
+        if (!names.has('state'))
+            return;
+        try {
+            const row = this.db.prepare(`SELECT COUNT(*) AS count
+         FROM restoration_intents
+         WHERE state NOT IN ('COMPLETE', 'FAILED')`).get();
+            const count = row?.count ?? 0;
+            if (count <= 0)
+                return;
+            const detail = `Ignored ${count} legacy request-first restoration_intents row${count === 1 ? '' : 's'}; ` +
+                'Task-native recovery does not resume ClaimRegistry/request-first jobs.';
+            const ts = new Date().toISOString();
+            const marker = {
+                schemaVersion: 1,
+                ignoredAt: ts,
+                table: 'restoration_intents',
+                inFlightRows: count,
+                reason: 'legacy_request_first_task_native_update',
+            };
+            const tx = this.db.transaction(() => {
+                this.db.prepare(`INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)`).run('legacy_restoration_intents_ignored_v1', JSON.stringify(marker));
+                this.db.prepare(`INSERT INTO activity_events (ts, kind, outcome, detail)
+           SELECT @ts, 'legacy_ignored', 'ignored', @detail
+           WHERE NOT EXISTS (
+             SELECT 1 FROM activity_events
+             WHERE kind = 'legacy_ignored' AND detail = @detail
+           )`).run({ ts, detail });
+            });
+            tx();
+        }
+        catch {
+            // Legacy schemas varied. Never let stale request-first state block Store startup.
+        }
     }
     /** Idempotent: older DBs before idx_reward_claims_tx may lack the unique index. */
     ensureRewardClaimsTxIndex() {
@@ -147,10 +412,11 @@ export class Store {
     setConfigValue(key, value) {
         this.db.prepare('INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)').run(key, value);
     }
-    getIntentPostRecord(args) {
-        const row = this.db.prepare(`SELECT creator_safe_address, source_key, policy_type, scope_key, desired_state_id, request_id,
+    getTaskPostRecord(args) {
+        const row = this.db.prepare(`SELECT creator_safe_address, source_key, policy_type, scope_key, task_id,
+              protocol_task_id, task_cid, request_id,
               first_posted_at, last_posted_at, post_count
-       FROM intent_posts
+       FROM task_posts
        WHERE creator_safe_address = @creatorSafeAddress
          AND source_key = @sourceKey
          AND policy_type = @policyType
@@ -162,37 +428,163 @@ export class Store {
             sourceKey: row.source_key,
             policyType: row.policy_type,
             scopeKey: row.scope_key,
-            desiredStateId: row.desired_state_id,
+            taskId: row.task_id,
+            protocolTaskId: row.protocol_task_id,
+            taskCid: row.task_cid,
             requestId: row.request_id,
             firstPostedAt: row.first_posted_at,
             lastPostedAt: row.last_posted_at,
             postCount: row.post_count,
         };
     }
-    upsertIntentPostRecord(record) {
-        this.db.prepare(`INSERT INTO intent_posts
-         (creator_safe_address, source_key, policy_type, scope_key, desired_state_id, request_id,
+    /**
+     * Posted Tasks for the launcher mode (`GET /v1/launcher/tasks`,
+     * spec/2026-05-05-launcher-role-and-mode.md §5.3). Returns rows from
+     * `task_posts` filtered by creator Safe address, sorted by `last_posted_at
+     * DESC` (most recent first). The `solverType` is denormalised in by joining
+     * `activity_events` on `request_id` for the `task_posted` kind — that's
+     * where `posting-service.ts` writes the SolverType when the post lands.
+     *
+     * `before` filters to rows with `last_posted_at < before` (ISO-8601). When
+     * `before` is undefined, returns the most recent `limit` rows.
+     *
+     * Caller-side: `gatherLauncherTasks` (`api/launcher-tasks.ts`) maps the
+     * solver_type back to the operator's SolverNet name via config lookup.
+     */
+    listPostedTasksByCreator(args) {
+        const limit = Math.max(0, Math.min(args.limit, 1000));
+        if (limit === 0)
+            return [];
+        const params = {
+            creator: args.creatorSafeAddress,
+            limit,
+        };
+        let beforeClause = '';
+        if (args.before) {
+            beforeClause = ' AND tp.last_posted_at < @before';
+            params['before'] = args.before;
+        }
+        // LEFT JOIN: a stale `task_posts` row from before activity_events backfill
+        // (or one whose event was lost to `recordActivityEvent` failure) still
+        // surfaces with a NULL solver_type — the gather function falls back to
+        // `solverNet: 'unknown'` rather than dropping the row, because the
+        // operator should still see the Task they posted.
+        const rows = this.db.prepare(`SELECT
+         tp.task_id,
+         tp.task_cid,
+         tp.protocol_task_id,
+         tp.request_id,
+         tp.last_posted_at,
+         (
+           SELECT ae.solver_type
+           FROM activity_events ae
+           WHERE ae.request_id = tp.request_id
+             AND ae.kind = 'task_posted'
+             AND ae.solver_type IS NOT NULL
+           ORDER BY ae.id DESC
+           LIMIT 1
+         ) AS solver_type
+       FROM task_posts tp
+       WHERE tp.creator_safe_address = @creator${beforeClause}
+       ORDER BY tp.last_posted_at DESC
+       LIMIT @limit`).all(params);
+        const localRunsForPost = this.db.prepare(`SELECT request_id, state, task_role, task_payload, delivery_tx_hash, state_updated_at
+       FROM task_runs
+       WHERE request_id = @requestId
+          OR (@taskId != '' AND task_id = @taskId)
+          OR (@protocolTaskId != '' AND task_id = @protocolTaskId)
+          OR (@taskCid != '' AND task_cid = @taskCid)
+       ORDER BY state_updated_at DESC`);
+        return rows.map((r) => {
+            // task_id was added by an additive migration; the column exists on every
+            // post-migration insert (posting-service.ts always writes it). Older
+            // rows fall back to protocol_task_id (chain Task ID) and finally
+            // request_id so the response shape's `taskId` is always populated.
+            const taskId = r.task_id ?? r.protocol_task_id ?? r.request_id;
+            const protocolTaskId = r.protocol_task_id ?? '';
+            const taskCid = r.task_cid ?? '';
+            const runs = localRunsForPost.all({
+                requestId: r.request_id,
+                taskId,
+                protocolTaskId,
+                taskCid,
+            });
+            const maxClaims = runs
+                .map((run) => readClaimPolicyMaxClaims(run.task_payload))
+                .find((value) => value !== undefined);
+            const localRestorationClaims = new Set(runs
+                .filter((run) => run.task_role !== 'evaluation')
+                .map((run) => run.request_id)).size;
+            const state = derivePostedTaskLocalState({
+                runs,
+                localRestorationClaims,
+                maxClaims,
+            });
+            return {
+                taskId,
+                taskCid,
+                solverType: r.solver_type,
+                requestId: r.request_id,
+                postedAt: r.last_posted_at,
+                ...(state ? { state } : {}),
+                ...(runs.length > 0 || maxClaims !== undefined
+                    ? {
+                        claims: {
+                            current: localRestorationClaims,
+                            ...(maxClaims !== undefined ? { max: maxClaims } : {}),
+                        },
+                    }
+                    : {}),
+            };
+        });
+    }
+    /** Count of posted Tasks for this creator with the given solver_type. v1
+     *  treats every posted Task as in-flight (state derivation lands with
+     *  router-watcher hardening, jinn-mono-l2zl.12). */
+    countPostedTasksByCreatorAndSolverType(args) {
+        const row = this.db.prepare(`SELECT COUNT(DISTINCT tp.task_id) AS c
+       FROM task_posts tp
+       INNER JOIN activity_events ae
+         ON ae.request_id = tp.request_id
+         AND ae.kind = 'task_posted'
+       WHERE tp.creator_safe_address = @creator
+         AND ae.solver_type = @solverType`).get({
+            creator: args.creatorSafeAddress,
+            solverType: args.solverType,
+        });
+        return row?.c ?? 0;
+    }
+    upsertTaskPostRecord(record) {
+        const params = {
+            ...record,
+            protocolTaskId: record.protocolTaskId ?? null,
+            taskCid: record.taskCid ?? null,
+        };
+        this.db.prepare(`INSERT INTO task_posts
+         (creator_safe_address, source_key, policy_type, scope_key, task_id, protocol_task_id, task_cid, request_id,
           first_posted_at, last_posted_at, post_count)
        VALUES
-         (@creatorSafeAddress, @sourceKey, @policyType, @scopeKey, @desiredStateId, @requestId,
+         (@creatorSafeAddress, @sourceKey, @policyType, @scopeKey, @taskId, @protocolTaskId, @taskCid, @requestId,
           @firstPostedAt, @lastPostedAt, @postCount)
        ON CONFLICT(creator_safe_address, source_key, policy_type, scope_key) DO UPDATE SET
-         desired_state_id = excluded.desired_state_id,
+         task_id = excluded.task_id,
+         protocol_task_id = excluded.protocol_task_id,
+         task_cid = excluded.task_cid,
          request_id = excluded.request_id,
          first_posted_at = excluded.first_posted_at,
          last_posted_at = excluded.last_posted_at,
-         post_count = excluded.post_count`).run(record);
+         post_count = excluded.post_count`).run(params);
     }
-    acquireIntentPostLock(args) {
+    acquireTaskPostLock(args) {
         const tx = this.db.transaction((params) => {
             const existing = this.db.prepare(`SELECT owner_token, locked_at
-         FROM intent_post_locks
+         FROM task_post_locks
          WHERE creator_safe_address = @creatorSafeAddress
            AND source_key = @sourceKey
            AND policy_type = @policyType
            AND scope_key = @scopeKey`).get(params);
             if (!existing) {
-                this.db.prepare(`INSERT INTO intent_post_locks
+                this.db.prepare(`INSERT INTO task_post_locks
              (creator_safe_address, source_key, policy_type, scope_key, owner_token, locked_at)
            VALUES
              (@creatorSafeAddress, @sourceKey, @policyType, @scopeKey, @ownerToken, @lockedAt)`).run(params);
@@ -206,7 +598,7 @@ export class Store {
             if (!isStale) {
                 return false;
             }
-            this.db.prepare(`UPDATE intent_post_locks
+            this.db.prepare(`UPDATE task_post_locks
          SET owner_token = @ownerToken, locked_at = @lockedAt
          WHERE creator_safe_address = @creatorSafeAddress
            AND source_key = @sourceKey
@@ -216,8 +608,8 @@ export class Store {
         });
         return tx(args);
     }
-    releaseIntentPostLock(args) {
-        this.db.prepare(`DELETE FROM intent_post_locks
+    releaseTaskPostLock(args) {
+        this.db.prepare(`DELETE FROM task_post_locks
        WHERE creator_safe_address = @creatorSafeAddress
          AND source_key = @sourceKey
          AND policy_type = @policyType
@@ -244,14 +636,14 @@ export class Store {
         return legacyRows.map(r => ({ requestId: r.request_id, role: r.role }));
     }
     recordActivityEvent(event) {
-        this.db.prepare(`INSERT INTO activity_events (ts, kind, request_id, service_index, tx_hash, spec_kind, outcome, detail)
-       VALUES (@ts, @kind, @requestId, @serviceIndex, @txHash, @specKind, @outcome, @detail)`).run({
+        this.db.prepare(`INSERT INTO activity_events (ts, kind, request_id, service_index, tx_hash, solver_type, outcome, detail)
+       VALUES (@ts, @kind, @requestId, @serviceIndex, @txHash, @solverType, @outcome, @detail)`).run({
             ts: event.ts ?? null,
             kind: event.kind,
             requestId: event.requestId ?? null,
             serviceIndex: event.serviceIndex ?? null,
             txHash: event.txHash ?? null,
-            specKind: event.specKind ?? null,
+            solverType: event.solverType ?? null,
             outcome: event.outcome ?? null,
             detail: event.detail ?? null,
         });
@@ -269,7 +661,7 @@ export class Store {
             params['cursor'] = opts.cursor;
         }
         const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
-        const rows = this.db.prepare(`SELECT id, ts, kind, request_id, service_index, tx_hash, spec_kind, outcome, detail
+        const rows = this.db.prepare(`SELECT id, ts, kind, request_id, service_index, tx_hash, solver_type, outcome, detail
        FROM activity_events
        ${where}
        ORDER BY id DESC
@@ -281,7 +673,7 @@ export class Store {
             requestId: r.request_id,
             serviceIndex: r.service_index,
             txHash: r.tx_hash,
-            specKind: r.spec_kind,
+            solverType: r.solver_type,
             outcome: r.outcome,
             detail: r.detail,
         }));
@@ -290,7 +682,7 @@ export class Store {
     getActivityEventsAfterId(afterId, limit) {
         const effectiveLimit = Math.max(0, Math.min(limit, 1000));
         const rows = this.db
-            .prepare(`SELECT id, ts, kind, request_id, service_index, tx_hash, spec_kind, outcome, detail
+            .prepare(`SELECT id, ts, kind, request_id, service_index, tx_hash, solver_type, outcome, detail
          FROM activity_events
          WHERE id > @afterId
          ORDER BY id ASC
@@ -303,7 +695,7 @@ export class Store {
             requestId: r.request_id,
             serviceIndex: r.service_index,
             txHash: r.tx_hash,
-            specKind: r.spec_kind,
+            solverType: r.solver_type,
             outcome: r.outcome,
             detail: r.detail,
         }));
@@ -410,6 +802,10 @@ export class Store {
         });
         tx();
     }
+    getTaskEvidenceHash(requestId) {
+        const row = this.db.prepare('SELECT evidence_hash FROM task_runs WHERE request_id = ?').get(requestId);
+        return row?.evidence_hash ?? null;
+    }
     getLastProcessedBlock() {
         const row = this.db.prepare('SELECT value FROM config WHERE key = ?').get('last_processed_block');
         return row?.value ? BigInt(row.value) : null;
@@ -419,8 +815,8 @@ export class Store {
     }
     insertArtifact(artifact) {
         this.db.prepare(`
-      INSERT OR REPLACE INTO artifacts (id, desired_state_id, request_id, title, content, tags, outcome)
-      VALUES (@id, @desiredStateId, @requestId, @title, @content, @tags, @outcome)
+      INSERT OR REPLACE INTO artifacts (id, task_id, request_id, title, content, tags, outcome)
+      VALUES (@id, @taskId, @requestId, @title, @content, @tags, @outcome)
     `).run({
             ...artifact,
             tags: JSON.stringify(artifact.tags),
@@ -437,9 +833,9 @@ export class Store {
             conditions.push('request_id = @requestId');
             params['requestId'] = query.requestId;
         }
-        if (query.desiredStateId) {
-            conditions.push('desired_state_id = @desiredStateId');
-            params['desiredStateId'] = query.desiredStateId;
+        if (query.taskId) {
+            conditions.push('task_id = @taskId');
+            params['taskId'] = query.taskId;
         }
         if (query.after) {
             conditions.push('created_at >= @after');
@@ -457,7 +853,7 @@ export class Store {
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
         const limit = query.limit ?? 50;
-        const rows = this.db.prepare(`SELECT id, title, content, tags, outcome, request_id, desired_state_id, created_at FROM artifacts ${where} ORDER BY created_at DESC LIMIT ${limit}`).all(params);
+        const rows = this.db.prepare(`SELECT id, title, content, tags, outcome, request_id, task_id, created_at FROM artifacts ${where} ORDER BY created_at DESC LIMIT ${limit}`).all(params);
         return rows.map(row => ({
             ...row,
             tags: JSON.parse(row.tags),
@@ -465,19 +861,29 @@ export class Store {
     }
     insertRemoteArtifact(artifact) {
         this.db.prepare(`
-      INSERT OR REPLACE INTO artifacts (id, desired_state_id, request_id, title, tags, outcome, remote, owner_address, endpoint, price)
-      VALUES (@id, @desiredStateId, @requestId, @title, @tags, @outcome, 1, @ownerAddress, @endpoint, @price)
+      INSERT OR REPLACE INTO artifacts (id, task_id, request_id, title, tags, outcome, remote, owner_address, endpoint, price)
+      VALUES (@id, @taskId, @requestId, @title, @tags, @outcome, 1, @ownerAddress, @endpoint, @price)
     `).run({
             ...artifact,
             tags: JSON.stringify(artifact.tags),
             price: artifact.price ?? null,
         });
     }
-    getArtifactContent(id) {
-        const row = this.db.prepare('SELECT content FROM artifacts WHERE id = ?').get(id);
-        return row?.content ?? null;
+    /**
+     * Text body for a catalog artifact id: local `artifacts.content`, else a peer-cached
+     * blob in `network_artifacts` (via `peer_catalog_id`).
+     */
+    resolveCatalogArtifactContent(id) {
+        const local = this.db.prepare('SELECT content FROM artifacts WHERE id = ?').get(id);
+        if (local?.content != null)
+            return local.content;
+        const net = this.db.prepare(`SELECT content FROM network_artifacts WHERE peer_catalog_id = ? ORDER BY fetched_at DESC LIMIT 1`).get(id);
+        if (!net)
+            return null;
+        return net.content.toString('utf-8');
     }
-    getRemoteArtifactInfo(id) {
+    /** Endpoint / owner for a remote (peer-synced) catalog row in `artifacts`. */
+    getRemoteDiscoveryMetadata(id) {
         const row = this.db.prepare('SELECT endpoint, owner_address, price FROM artifacts WHERE id = ? AND remote = 1').get(id);
         if (!row)
             return null;
@@ -493,11 +899,559 @@ export class Store {
             return null;
         return { ...row, tags: JSON.parse(row.tags) };
     }
-    cacheRemoteContent(id, content) {
-        this.db.prepare('UPDATE artifacts SET content = ? WHERE id = ?').run(content, id);
+    saveServedArtifact(input) {
+        this.db.prepare(`INSERT OR REPLACE INTO served_artifacts
+         (sha256, artifact_type, request_id, envelope_cid, content, content_size, price_usdc, created_at)
+       VALUES
+         (@sha256, @artifactType, @requestId, @envelopeCid, @content, @contentSize, @priceUsdc, @createdAt)`).run({
+            sha256: input.sha256,
+            artifactType: input.artifactType,
+            requestId: input.requestId ?? null,
+            envelopeCid: input.envelopeCid ?? null,
+            content: input.content,
+            contentSize: input.content.length,
+            priceUsdc: input.priceUsdc,
+            createdAt: input.createdAt,
+        });
+    }
+    getServedArtifact(sha256) {
+        const row = this.db.prepare(`SELECT sha256, artifact_type, request_id, envelope_cid, content, content_size, price_usdc, created_at
+       FROM served_artifacts WHERE sha256 = ?`).get(sha256);
+        if (!row)
+            return null;
+        return {
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            requestId: row.request_id,
+            envelopeCid: row.envelope_cid,
+            content: row.content,
+            contentSize: row.content_size,
+            priceUsdc: row.price_usdc,
+            createdAt: row.created_at,
+        };
+    }
+    getServedArtifactMetadata(sha256) {
+        const row = this.db.prepare(`SELECT sha256, artifact_type, request_id, envelope_cid, content_size, price_usdc, created_at
+       FROM served_artifacts WHERE sha256 = ?`).get(sha256);
+        if (!row)
+            return null;
+        return {
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            requestId: row.request_id,
+            envelopeCid: row.envelope_cid,
+            contentSize: row.content_size,
+            priceUsdc: row.price_usdc,
+            createdAt: row.created_at,
+        };
+    }
+    listServedArtifactMetadata(filter = {}) {
+        const limit = Math.min(Math.max(1, filter.limit ?? 100), 500);
+        const sql = filter.artifactType
+            ? `SELECT sha256, artifact_type, request_id, envelope_cid, content_size, price_usdc, created_at
+         FROM served_artifacts
+         WHERE artifact_type = @artifactType
+         ORDER BY created_at DESC
+         LIMIT @limit`
+            : `SELECT sha256, artifact_type, request_id, envelope_cid, content_size, price_usdc, created_at
+         FROM served_artifacts
+         ORDER BY created_at DESC
+         LIMIT @limit`;
+        const rows = this.db.prepare(sql).all({
+            limit,
+            ...(filter.artifactType ? { artifactType: filter.artifactType } : {}),
+        });
+        return rows.map((row) => ({
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            requestId: row.request_id,
+            envelopeCid: row.envelope_cid,
+            contentSize: row.content_size,
+            priceUsdc: row.price_usdc,
+            createdAt: row.created_at,
+        }));
+    }
+    recordArtifactAccessEvent(input) {
+        this.db.prepare(`INSERT INTO artifact_access_events
+         (sha256, artifact_type, price_usdc, outcome, http_status, payer,
+          settlement_tx, error_reason, remote_addr, user_agent, created_at)
+       VALUES
+         (@sha256, @artifactType, @priceUsdc, @outcome, @httpStatus, @payer,
+          @settlementTx, @errorReason, @remoteAddr, @userAgent, @createdAt)`).run({
+            sha256: input.sha256,
+            artifactType: input.artifactType ?? null,
+            priceUsdc: input.priceUsdc ?? null,
+            outcome: input.outcome,
+            httpStatus: input.httpStatus,
+            payer: input.payer ?? null,
+            settlementTx: input.settlementTx ?? null,
+            errorReason: input.errorReason ?? null,
+            remoteAddr: input.remoteAddr ?? null,
+            userAgent: input.userAgent ?? null,
+            createdAt: input.createdAt,
+        });
+    }
+    listArtifactAccessEvents(filter = {}) {
+        const limit = Math.min(Math.max(1, filter.limit ?? 50), 500);
+        const sql = filter.sha256
+            ? `SELECT id, sha256, artifact_type, price_usdc, outcome, http_status,
+                payer, settlement_tx, error_reason, remote_addr, user_agent, created_at
+         FROM artifact_access_events
+         WHERE sha256 = @sha256
+         ORDER BY created_at DESC, id DESC
+         LIMIT @limit`
+            : `SELECT id, sha256, artifact_type, price_usdc, outcome, http_status,
+                payer, settlement_tx, error_reason, remote_addr, user_agent, created_at
+         FROM artifact_access_events
+         ORDER BY created_at DESC, id DESC
+         LIMIT @limit`;
+        const rows = this.db.prepare(sql).all({
+            limit,
+            ...(filter.sha256 ? { sha256: filter.sha256 } : {}),
+        });
+        return rows.map((row) => ({
+            id: row.id,
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            priceUsdc: row.price_usdc,
+            outcome: row.outcome,
+            httpStatus: row.http_status,
+            payer: row.payer,
+            settlementTx: row.settlement_tx,
+            errorReason: row.error_reason,
+            remoteAddr: row.remote_addr,
+            userAgent: row.user_agent,
+            createdAt: row.created_at,
+        }));
+    }
+    getArtifactAccessSummary() {
+        const row = this.db.prepare(`SELECT
+         COUNT(*) AS access_count,
+         COALESCE(SUM(CASE WHEN outcome = 'paid_served' THEN 1 ELSE 0 END), 0) AS paid_serve_count,
+         COALESCE(SUM(CASE WHEN outcome = 'free_served' THEN 1 ELSE 0 END), 0) AS free_serve_count,
+         COALESCE(SUM(CASE WHEN outcome IN ('verification_failed', 'settlement_failed', 'payment_malformed') THEN 1 ELSE 0 END), 0) AS failed_payment_count,
+         COALESCE(SUM(CASE WHEN outcome = 'payment_required' THEN 1 ELSE 0 END), 0) AS payment_required_count,
+         COALESCE(SUM(CASE WHEN outcome = 'paid_served' THEN CAST(price_usdc AS REAL) ELSE 0 END), 0) AS revenue_usdc,
+         MAX(created_at) AS last_access_at,
+         MAX(CASE WHEN outcome = 'paid_served' THEN created_at ELSE NULL END) AS last_paid_at
+       FROM artifact_access_events`).get();
+        return {
+            accessCount: row.access_count,
+            paidServeCount: row.paid_serve_count,
+            freeServeCount: row.free_serve_count,
+            failedPaymentCount: row.failed_payment_count,
+            paymentRequiredCount: row.payment_required_count,
+            revenueUsdc: String(row.revenue_usdc),
+            lastAccessAt: row.last_access_at,
+            lastPaidAt: row.last_paid_at,
+        };
+    }
+    getArtifactAccessStatsBySha(sha256s) {
+        const unique = Array.from(new Set(sha256s)).filter((sha256) => sha256.length > 0);
+        if (unique.length === 0)
+            return {};
+        const placeholders = unique.map((_, idx) => `@sha${idx}`).join(', ');
+        const params = Object.fromEntries(unique.map((sha256, idx) => [`sha${idx}`, sha256]));
+        const rows = this.db.prepare(`SELECT
+         sha256,
+         COUNT(*) AS access_count,
+         COALESCE(SUM(CASE WHEN outcome = 'paid_served' THEN 1 ELSE 0 END), 0) AS paid_serve_count,
+         COALESCE(SUM(CASE WHEN outcome = 'free_served' THEN 1 ELSE 0 END), 0) AS free_serve_count,
+         COALESCE(SUM(CASE WHEN outcome IN ('verification_failed', 'settlement_failed', 'payment_malformed') THEN 1 ELSE 0 END), 0) AS failed_payment_count,
+         COALESCE(SUM(CASE WHEN outcome = 'payment_required' THEN 1 ELSE 0 END), 0) AS payment_required_count,
+         COALESCE(SUM(CASE WHEN outcome = 'paid_served' THEN CAST(price_usdc AS REAL) ELSE 0 END), 0) AS revenue_usdc,
+         MAX(created_at) AS last_access_at,
+         MAX(CASE WHEN outcome = 'paid_served' THEN created_at ELSE NULL END) AS last_paid_at
+       FROM artifact_access_events
+       WHERE sha256 IN (${placeholders})
+       GROUP BY sha256`).all(params);
+        return Object.fromEntries(rows.map((row) => [
+            row.sha256,
+            {
+                accessCount: row.access_count,
+                paidServeCount: row.paid_serve_count,
+                freeServeCount: row.free_serve_count,
+                failedPaymentCount: row.failed_payment_count,
+                paymentRequiredCount: row.payment_required_count,
+                revenueUsdc: String(row.revenue_usdc),
+                lastAccessAt: row.last_access_at,
+                lastPaidAt: row.last_paid_at,
+            },
+        ]));
+    }
+    setServedArtifactEnvelopeCid(sha256, envelopeCid) {
+        this.db.prepare(`UPDATE served_artifacts SET envelope_cid = ? WHERE sha256 = ?`).run(envelopeCid, sha256);
+    }
+    getServedArtifactsByRequestId(requestId) {
+        const rows = this.db.prepare(`SELECT sha256, artifact_type, request_id, envelope_cid, content, content_size, price_usdc, created_at
+       FROM served_artifacts WHERE request_id = ? ORDER BY created_at ASC`).all(requestId);
+        return rows.map((row) => ({
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            requestId: row.request_id,
+            envelopeCid: row.envelope_cid,
+            content: row.content,
+            contentSize: row.content_size,
+            priceUsdc: row.price_usdc,
+            createdAt: row.created_at,
+        }));
+    }
+    saveNetworkArtifact(input) {
+        if (input.peerCatalogId) {
+            this.db.prepare(`DELETE FROM network_artifacts WHERE peer_catalog_id = ?`).run(input.peerCatalogId);
+        }
+        this.db.prepare(`INSERT OR REPLACE INTO network_artifacts
+         (sha256, artifact_type, envelope_cid, content, content_size, source,
+          source_operator, source_endpoint, paid_amount_usdc, fetched_at, last_used_at, peer_catalog_id)
+       VALUES
+         (@sha256, @artifactType, @envelopeCid, @content, @contentSize, @source,
+          @sourceOperator, @sourceEndpoint, @paidAmountUsdc, @fetchedAt, @fetchedAt, @peerCatalogId)`).run({
+            sha256: input.sha256,
+            artifactType: input.artifactType,
+            envelopeCid: input.envelopeCid ?? null,
+            content: input.content,
+            contentSize: input.content.length,
+            source: input.source,
+            sourceOperator: input.sourceOperator ?? null,
+            sourceEndpoint: input.sourceEndpoint ?? null,
+            paidAmountUsdc: input.paidAmountUsdc,
+            fetchedAt: input.fetchedAt,
+            peerCatalogId: input.peerCatalogId ?? null,
+        });
+    }
+    getNetworkArtifact(sha256) {
+        const row = this.db.prepare(`SELECT sha256, artifact_type, envelope_cid, content, content_size, source,
+              source_operator, source_endpoint, paid_amount_usdc, fetched_at, last_used_at,
+              peer_catalog_id
+       FROM network_artifacts WHERE sha256 = ?`).get(sha256);
+        if (!row)
+            return null;
+        return {
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            envelopeCid: row.envelope_cid,
+            content: row.content,
+            contentSize: row.content_size,
+            source: row.source,
+            sourceOperator: row.source_operator,
+            sourceEndpoint: row.source_endpoint,
+            paidAmountUsdc: row.paid_amount_usdc,
+            fetchedAt: row.fetched_at,
+            lastUsedAt: row.last_used_at,
+            peerCatalogId: row.peer_catalog_id,
+        };
+    }
+    getNetworkArtifactMetadata(sha256) {
+        const row = this.db.prepare(`SELECT sha256, artifact_type, envelope_cid, content_size, source,
+              source_operator, source_endpoint, paid_amount_usdc, fetched_at, last_used_at,
+              peer_catalog_id
+       FROM network_artifacts WHERE sha256 = ?`).get(sha256);
+        if (!row)
+            return null;
+        return {
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            envelopeCid: row.envelope_cid,
+            contentSize: row.content_size,
+            source: row.source,
+            sourceOperator: row.source_operator,
+            sourceEndpoint: row.source_endpoint,
+            paidAmountUsdc: row.paid_amount_usdc,
+            fetchedAt: row.fetched_at,
+            lastUsedAt: row.last_used_at,
+            peerCatalogId: row.peer_catalog_id,
+        };
+    }
+    listNetworkArtifactMetadata(filter = {}) {
+        const limit = Math.min(Math.max(1, filter.limit ?? 100), 500);
+        const sql = filter.artifactType
+            ? `SELECT sha256, artifact_type, envelope_cid, content_size, source,
+                source_operator, source_endpoint, paid_amount_usdc, fetched_at,
+                last_used_at, peer_catalog_id
+         FROM network_artifacts
+         WHERE artifact_type = @artifactType
+         ORDER BY fetched_at DESC
+         LIMIT @limit`
+            : `SELECT sha256, artifact_type, envelope_cid, content_size, source,
+                source_operator, source_endpoint, paid_amount_usdc, fetched_at,
+                last_used_at, peer_catalog_id
+         FROM network_artifacts
+         ORDER BY fetched_at DESC
+         LIMIT @limit`;
+        const rows = this.db.prepare(sql).all({
+            limit,
+            ...(filter.artifactType ? { artifactType: filter.artifactType } : {}),
+        });
+        return rows.map((row) => ({
+            sha256: row.sha256,
+            artifactType: row.artifact_type,
+            envelopeCid: row.envelope_cid,
+            contentSize: row.content_size,
+            source: row.source,
+            sourceOperator: row.source_operator,
+            sourceEndpoint: row.source_endpoint,
+            paidAmountUsdc: row.paid_amount_usdc,
+            fetchedAt: row.fetched_at,
+            lastUsedAt: row.last_used_at,
+            peerCatalogId: row.peer_catalog_id,
+        }));
+    }
+    touchNetworkArtifactUsage(sha256, ts) {
+        this.db.prepare(`UPDATE network_artifacts SET last_used_at = ? WHERE sha256 = ?`).run(ts, sha256);
+    }
+    /**
+     * Local fast-path search across own (served) artifacts and cached (network)
+     * artifacts. Used by MCP record search to prepend locally held matches to
+     * corpus query results without loading artifact bytes.
+     */
+    searchOwnAndCached(filter) {
+        const limit = Math.min(Math.max(1, filter.limit), 500);
+        const ownSql = filter.artifactType
+            ? `SELECT sha256, artifact_type, envelope_cid, content_size, price_usdc, created_at FROM served_artifacts WHERE artifact_type = @type ORDER BY created_at DESC LIMIT @limit`
+            : `SELECT sha256, artifact_type, envelope_cid, content_size, price_usdc, created_at FROM served_artifacts ORDER BY created_at DESC LIMIT @limit`;
+        const cachedSql = filter.artifactType
+            ? `SELECT sha256, artifact_type, envelope_cid, content_size, source_operator, source_endpoint, paid_amount_usdc, fetched_at FROM network_artifacts WHERE artifact_type = @type ORDER BY fetched_at DESC LIMIT @limit`
+            : `SELECT sha256, artifact_type, envelope_cid, content_size, source_operator, source_endpoint, paid_amount_usdc, fetched_at FROM network_artifacts ORDER BY fetched_at DESC LIMIT @limit`;
+        const params = { limit };
+        if (filter.artifactType)
+            params['type'] = filter.artifactType;
+        const own = this.db.prepare(ownSql).all(params);
+        const cached = this.db.prepare(cachedSql).all(params);
+        return [
+            ...own.map((r) => ({
+                sha256: r.sha256,
+                artifactType: r.artifact_type,
+                source: 'served',
+                envelopeCid: r.envelope_cid,
+                createdAt: r.created_at,
+                contentSize: r.content_size,
+                priceUsdc: r.price_usdc,
+            })),
+            ...cached.map((r) => ({
+                sha256: r.sha256,
+                artifactType: r.artifact_type,
+                source: 'network',
+                envelopeCid: r.envelope_cid,
+                createdAt: r.fetched_at,
+                contentSize: r.content_size,
+                sourceEndpoint: r.source_endpoint,
+                sourceOperator: r.source_operator,
+                paidAmountUsdc: r.paid_amount_usdc,
+            })),
+        ];
+    }
+    saveEnvelopeProjection(projection) {
+        const tx = this.db.transaction((p) => {
+            this.db.prepare(`INSERT INTO envelope_projections
+           (envelope_id, envelope_cid, envelope_sha256, signature_hash, solver_type, role,
+            task_cid, task_id, request_id, generated_at, evidence_tier,
+            participant_safe_address, participant_agent_eoa,
+            executor_impl_name, executor_impl_version, executor_runtime_bundle_digest,
+            executor_plugins_json, solution_envelope_cid, solution_envelope_sha256,
+            solution_envelope_ref, metadata_json)
+         VALUES
+           (@envelopeId, @envelopeCid, @envelopeSha256, @signatureHash, @solverType, @role,
+            @taskCid, @taskId, @requestId, @generatedAt, @evidenceTier,
+            @participantSafeAddress, @participantAgentEoa,
+            @executorImplName, @executorImplVersion, @executorRuntimeBundleDigest,
+            @executorPluginsJson, @solutionEnvelopeCid, @solutionEnvelopeSha256,
+            @solutionEnvelopeRef, @metadataJson)
+         ON CONFLICT(envelope_id) DO UPDATE SET
+           envelope_cid = excluded.envelope_cid,
+           envelope_sha256 = excluded.envelope_sha256,
+           signature_hash = excluded.signature_hash,
+           solver_type = excluded.solver_type,
+           role = excluded.role,
+           task_cid = excluded.task_cid,
+           task_id = excluded.task_id,
+           request_id = excluded.request_id,
+           generated_at = excluded.generated_at,
+           evidence_tier = excluded.evidence_tier,
+           participant_safe_address = excluded.participant_safe_address,
+           participant_agent_eoa = excluded.participant_agent_eoa,
+           executor_impl_name = excluded.executor_impl_name,
+           executor_impl_version = excluded.executor_impl_version,
+           executor_runtime_bundle_digest = excluded.executor_runtime_bundle_digest,
+           executor_plugins_json = excluded.executor_plugins_json,
+           solution_envelope_cid = excluded.solution_envelope_cid,
+           solution_envelope_sha256 = excluded.solution_envelope_sha256,
+           solution_envelope_ref = excluded.solution_envelope_ref,
+           metadata_json = excluded.metadata_json`).run({
+                envelopeId: p.envelopeId,
+                envelopeCid: p.envelopeCid,
+                envelopeSha256: p.envelopeSha256,
+                signatureHash: p.signatureHash,
+                solverType: p.solverType,
+                role: p.role,
+                taskCid: p.taskCid,
+                taskId: p.taskId,
+                requestId: p.requestId,
+                generatedAt: p.generatedAt,
+                evidenceTier: p.evidenceTier,
+                participantSafeAddress: p.participantSafeAddress,
+                participantAgentEoa: p.participantAgentEoa,
+                executorImplName: p.executorImplName,
+                executorImplVersion: p.executorImplVersion,
+                executorRuntimeBundleDigest: p.executorRuntimeBundleDigest,
+                executorPluginsJson: JSON.stringify(p.executorPlugins),
+                solutionEnvelopeCid: p.solutionEnvelopeCid,
+                solutionEnvelopeSha256: p.solutionEnvelopeSha256,
+                solutionEnvelopeRef: p.solutionEnvelopeRef,
+                metadataJson: JSON.stringify(p.metadata),
+            });
+            this.db.prepare(`DELETE FROM envelope_projection_metadata WHERE envelope_id = ?`).run(p.envelopeId);
+            const insertMetadata = this.db.prepare(`INSERT INTO envelope_projection_metadata (envelope_id, key, value_text, value_type)
+         VALUES (@envelopeId, @key, @valueText, @valueType)`);
+            for (const [key, value] of Object.entries(p.metadata)) {
+                insertMetadata.run({
+                    envelopeId: p.envelopeId,
+                    key,
+                    valueText: metadataValueText(value),
+                    valueType: typeof value,
+                });
+            }
+        });
+        tx(projection);
+    }
+    queryEnvelopeProjections(query = {}) {
+        const conditions = [];
+        const params = {};
+        if (query.envelopeRefs && query.envelopeRefs.length > 0) {
+            const placeholders = query.envelopeRefs.map((ref, index) => {
+                const key = `envelopeRef${index}`;
+                params[key] = ref;
+                return `@${key}`;
+            }).join(', ');
+            conditions.push(`(envelope_id IN (${placeholders})
+          OR envelope_cid IN (${placeholders})
+          OR envelope_sha256 IN (${placeholders})
+          OR signature_hash IN (${placeholders}))`);
+        }
+        if (query.solverType) {
+            conditions.push('solver_type = @solverType');
+            params['solverType'] = query.solverType;
+        }
+        if (query.role) {
+            conditions.push('role = @role');
+            params['role'] = query.role;
+        }
+        if (query.taskCid) {
+            conditions.push('task_cid = @taskCid');
+            params['taskCid'] = query.taskCid;
+        }
+        if (query.taskId) {
+            conditions.push('task_id = @taskId');
+            params['taskId'] = query.taskId;
+        }
+        if (query.requestId) {
+            conditions.push('request_id = @requestId');
+            params['requestId'] = query.requestId;
+        }
+        if (query.participant?.safeAddress) {
+            conditions.push('participant_safe_address = @participantSafeAddress');
+            params['participantSafeAddress'] = query.participant.safeAddress;
+        }
+        if (query.participant?.agentEoa) {
+            conditions.push('participant_agent_eoa = @participantAgentEoa');
+            params['participantAgentEoa'] = query.participant.agentEoa;
+        }
+        if (query.solutionEnvelopeRef) {
+            conditions.push('solution_envelope_ref = @solutionEnvelopeRef');
+            params['solutionEnvelopeRef'] = query.solutionEnvelopeRef;
+        }
+        if (query.generatedAfter !== undefined) {
+            conditions.push('generated_at >= @generatedAfter');
+            params['generatedAfter'] = query.generatedAfter;
+        }
+        if (query.generatedBefore !== undefined) {
+            conditions.push('generated_at <= @generatedBefore');
+            params['generatedBefore'] = query.generatedBefore;
+        }
+        let metadataIndex = 0;
+        for (const [key, value] of Object.entries(query.metadata ?? {})) {
+            const keyParam = `metadataKey${metadataIndex}`;
+            const valueParam = `metadataValue${metadataIndex}`;
+            conditions.push(`EXISTS (
+          SELECT 1 FROM envelope_projection_metadata m${metadataIndex}
+          WHERE m${metadataIndex}.envelope_id = envelope_projections.envelope_id
+            AND m${metadataIndex}.key = @${keyParam}
+            AND m${metadataIndex}.value_text = @${valueParam}
+        )`);
+            params[keyParam] = key;
+            params[valueParam] = metadataValueText(value);
+            metadataIndex += 1;
+        }
+        const limit = Math.max(0, Math.min(query.limit ?? 100, 1000));
+        params['limit'] = limit;
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.db.prepare(`SELECT envelope_id, envelope_cid, envelope_sha256, signature_hash, solver_type, role,
+              task_cid, task_id, request_id, generated_at, evidence_tier,
+              participant_safe_address, participant_agent_eoa,
+              executor_impl_name, executor_impl_version, executor_runtime_bundle_digest,
+              executor_plugins_json, solution_envelope_cid, solution_envelope_sha256,
+              solution_envelope_ref, metadata_json
+       FROM envelope_projections
+       ${where}
+       ORDER BY generated_at DESC, envelope_id ASC
+       LIMIT @limit`).all(params);
+        return rows.map(rowToEnvelopeProjection);
     }
     close() {
         this.db.close();
     }
 }
+function rowToEnvelopeProjection(row) {
+    return {
+        envelopeId: row.envelope_id,
+        envelopeCid: row.envelope_cid,
+        envelopeSha256: row.envelope_sha256,
+        signatureHash: row.signature_hash,
+        solverType: row.solver_type,
+        role: row.role,
+        taskCid: row.task_cid,
+        taskId: row.task_id,
+        requestId: row.request_id,
+        generatedAt: row.generated_at,
+        evidenceTier: row.evidence_tier,
+        participantSafeAddress: row.participant_safe_address,
+        participantAgentEoa: row.participant_agent_eoa,
+        executorImplName: row.executor_impl_name,
+        executorImplVersion: row.executor_impl_version,
+        executorRuntimeBundleDigest: row.executor_runtime_bundle_digest,
+        executorPlugins: parseStringArray(row.executor_plugins_json),
+        solutionEnvelopeCid: row.solution_envelope_cid,
+        solutionEnvelopeSha256: row.solution_envelope_sha256,
+        solutionEnvelopeRef: row.solution_envelope_ref,
+        metadata: parseMetadata(row.metadata_json),
+    };
+}
+function metadataValueText(value) {
+    return String(value);
+}
+function parseStringArray(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed.filter((value) => typeof value === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseMetadata(json) {
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                out[key] = value;
+            }
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
 //# sourceMappingURL=store.js.map