@farmslot/protocol 0.74.10 → 0.75.0

package/dist/client-cache/registry.js

@@ -1,12 +1,22 @@
 import { providerAccountsDependencies, providerAccountsObservationParams, providerAccountsStoredData, } from '../contracts/provider-accounts.js';
+import { jiraTicketKey } from '../rpc/dispatch.js';
 import { prForSlotObservationParams, prForSlotStoredData, prReviewCommentsObservationParams, prReviewCommentsStoredData, prStatusObservationParams, prStatusStoredData, } from '../rpc/pr-observations.js';
 import { Methods } from '../rpc/registry.js';
 import { runnerModelCatalogObservationParams, runnerModelCatalogResourceKey, runnerModelCatalogStoredData, runnerVisibleModelsObservationParams, runnerVisibleModelsStoredData, } from '../rpc/runner-models.js';
-import { analyticsParams, assessmentDependencies, assessmentHistoryParams, copilotRuntimeKey, domainParams, idParams, observerEvidenceParams, prAutomationDependencies, sessionContextParams, triageParams, } from './d07-domains.js';
+import { analyticsParams, assessmentDependencies, assessmentHistoryParams, copilotRuntimeKey, domainId, domainParams, idParams, observerEvidenceParams, prAutomationDependencies, sessionContextParams, triageParams, } from './d07-domains.js';
 import { canonicalResourceJson } from './keys.js';
 import { nativeHistoryParams, nativeObservationDependencies } from './native-history.js';
 const mb = 1024 * 1024;
 export const UPSTREAM_QUERY_MAX_BYTES = 2 * mb;
+/**
+ * Every listed run's `run.get` details: about 30 MB for a 137-run farm in 2026-11, so twice that
+ * with headroom. Background sync stops before it would exceed this, so it never evicts its own runs.
+ */
+export const RUN_DETAIL_STORE_BYTES = 64 * mb;
+/** A read keyed by its parameters keeps its most recently observed results up to these bytes. */
+function keptUpTo(maxBytes) {
+    return { maxEntries: Number.MAX_SAFE_INTEGER, maxBytes };
+}
 function requiredId(params, field) {
     const value = params && typeof params === 'object' ? Reflect.get(params, field) : undefined;
     if (typeof value !== 'string' || !value)
@@ -30,6 +40,13 @@ function roadmapListObservationParams(params) {
     delete observation.search;
     return observation;
 }
+/** Execution template ids are `<flow>/<name>`; every other selector is one segment. */
+function configurationSelector(key, item) {
+    if (typeof item !== 'string' || !item || item.includes('\\'))
+        return false;
+    const segments = key === 'executionTemplateId' ? item.split('/') : [item];
+    return segments.every((segment) => segment && !segment.includes('/') && segment !== '.' && segment !== '..');
+}
 function configurationParams(params, allowed, required = []) {
     const input = params ?? {};
     if (typeof input !== 'object' || Array.isArray(input))
@@ -44,11 +61,7 @@ function configurationParams(params, allowed, required = []) {
             if (typeof item !== 'boolean')
                 throw new Error('unfiltered must be a boolean');
         }
-        else if (typeof item !== 'string' ||
-            !item ||
-            /[/\\]/.test(item) ||
-            item === '.' ||
-            item === '..') {
+        else if (!configurationSelector(key, item)) {
             throw new Error(`Invalid configuration selector: ${key}`);
         }
     }
@@ -69,13 +82,33 @@ function configurationDependencies(params) {
     ];
 }
 const configurationDefinition = {
-    persisted: false,
+    persisted: true,
     maxBytes: 2 * mb,
+    retention: keptUpTo(8 * mb),
     live: true,
     requiresObservedRead: true,
     normalizeParams: (params) => configurationParams(params, []),
     dependencies: configurationDependencies,
 };
+function dispatchObservationParams(params, allowed) {
+    const value = domainParams(params, allowed);
+    for (const [key, item] of Object.entries(value)) {
+        if (key === 'machines') {
+            if (!Array.isArray(item) || item.some((machine) => typeof machine !== 'string'))
+                throw new Error('Dispatch machines must be strings');
+            value[key] = [...new Set(item)].sort();
+        }
+        else if (key === 'forceRefresh' || key === 'skipPrepare') {
+            if (typeof item !== 'boolean')
+                throw new Error(`Dispatch ${key} must be a boolean`);
+        }
+        else if ((key === 'flowType' || key === 'variant') && item === null)
+            delete value[key];
+        else if (typeof item !== 'string')
+            throw new Error(`Dispatch ${key} must be a string`);
+    }
+    return value;
+}
 function workerInventoryParams(params) {
     if (params == null)
         return { includeDisconnected: true };
@@ -104,6 +137,13 @@ function workerInventoryParams(params) {
         ...(machines.length ? { machines } : {}),
     };
 }
+function validateWorkspacePath(value) {
+    if (value !== undefined &&
+        (typeof value !== 'string' ||
+            value.startsWith('/') ||
+            value.replace(/\\/g, '/').split('/').includes('..')))
+        throw new Error('Workspace path must stay relative');
+}
 function workspaceParams(params) {
     if (!params || typeof params !== 'object' || Array.isArray(params))
         throw new Error('Workspace query requires parameters');
@@ -155,11 +195,7 @@ function workspaceParams(params) {
                 requiredId(worker, field);
         }
     }
-    if (value.path !== undefined &&
-        (typeof value.path !== 'string' ||
-            value.path.startsWith('/') ||
-            value.path.replace(/\\/g, '/').split('/').includes('..')))
-        throw new Error('Workspace path must stay relative');
+    validateWorkspacePath(value.path);
     if (value.includeUntracked !== undefined && typeof value.includeUntracked !== 'boolean')
         throw new Error('includeUntracked must be a boolean');
     if (value.includeUntracked && value.target !== 'worktree')
@@ -215,8 +251,9 @@ const workspaceDefinition = {
     dependencies: workspaceDependencies,
 };
 const domainDefinition = {
-    persisted: false,
+    persisted: true,
     maxBytes: 2 * mb,
+    retention: keptUpTo(8 * mb),
     live: true,
     requiresObservedRead: true,
     normalizeParams: (params) => domainParams(params, []),
@@ -405,6 +442,28 @@ export function upstreamSourceObservation(data) {
             : {}),
     };
 }
+function machineParams(params, extra = []) {
+    const value = domainParams(params, ['machine', 'machines', ...extra]);
+    const selectors = (one, many) => {
+        const list = value[many] ?? [];
+        if (!Array.isArray(list))
+            throw new Error(`${many} must be a list`);
+        const all = value[one] === undefined ? list : [value[one], ...list];
+        return [...new Set(all.map((entry) => domainId(entry, one)))].sort();
+    };
+    const selected = selectors('machine', 'machines');
+    const scoped = selectors('project', 'projects');
+    return {
+        ...(selected.length ? { machines: selected } : {}),
+        ...(scoped.length ? { projects: scoped } : {}),
+    };
+}
+function chatHistoryParams(params) {
+    const { limit, ...session } = domainParams(params, ['sessionId', 'limit']);
+    if (limit !== undefined && (!Number.isSafeInteger(limit) || Number(limit) < 1))
+        throw new Error('Invalid chat history limit');
+    return { ...sessionContextParams(session), ...(limit === undefined ? {} : { limit }) };
+}
 /** Closed to runtime registration. Each migration changes its owning definition here. */
 export const RESOURCE_QUERY_DEFINITIONS = {
     [Methods.GATEWAY_STATUS]: {
@@ -651,6 +710,56 @@ export const RESOURCE_QUERY_DEFINITIONS = {
             { ...copilotRuntimeKey, sessionId: String(sessionContextParams(params).sessionId) },
         ],
     },
+    [Methods.DISPATCH_CANDIDATES]: {
+        persisted: true,
+        maxBytes: 2 * mb,
+        retention: { maxEntries: 50, maxBytes: 8 * mb },
+        timeoutMs: 60_000,
+        live: true,
+        normalizeParams: (params) => dispatchObservationParams(params, [
+            'project',
+            'flowType',
+            'machines',
+            'targetBranch',
+            'ticketOrPr',
+            'app',
+            'prepareProfile',
+            'skipPrepare',
+            'forceRefresh',
+            'lane',
+            'familyId',
+            'variant',
+            'runner',
+            'model',
+        ]),
+        dependencies: (params) => {
+            const runner = params && typeof params === 'object' ? Reflect.get(params, 'runner') : undefined;
+            return [
+                { family: 'slots', scope: 'farm' },
+                { family: 'node', scope: 'farm' },
+                { family: 'capabilities' },
+                { family: 'runs', scope: 'farm' },
+                ...configurationDependencies(params),
+                ...(typeof runner === 'string' ? [runnerModelCatalogResourceKey({ runner })] : []),
+            ];
+        },
+    },
+    [Methods.DISPATCH_MATCH_PROJECT]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: { maxEntries: 100, maxBytes: 2 * mb },
+        live: true,
+        normalizeParams: (params) => {
+            const value = dispatchObservationParams(params, ['ticketOrPr', 'flowType']);
+            requiredId(value, 'ticketOrPr');
+            const ticket = String(value.ticketOrPr).trim();
+            value.ticketOrPr = ticket;
+            if (jiraTicketKey(ticket))
+                delete value.flowType;
+            return value;
+        },
+        dependencies: configurationDependencies,
+    },
     [Methods.CONFIG_PROJECTS]: {
         ...configurationDefinition,
         persisted: true,
@@ -721,7 +830,7 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         dependencies: (params, nativeReaderId) => nativeObservationDependencies(Methods.NATIVE_SESSION_LIST, params, nativeReaderId ?? ''),
     },
     [Methods.NATIVE_SESSION_CATALOG]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
         retention: { maxEntries: 1, maxBytes: 2 * mb },
         live: true,
@@ -737,7 +846,7 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         dependencies: (params, nativeReaderId) => nativeObservationDependencies(Methods.NATIVE_PROFILE_LIST, params, nativeReaderId ?? ''),
     },
     [Methods.NATIVE_PROFILE_STATUS]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
         retention: { maxEntries: 10, maxBytes: 2 * mb },
         live: true,
@@ -756,8 +865,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
     [Methods.NATIVE_SESSION_WORKSPACE_DIFF]: { ...workspaceDefinition, maxBytes: 5 * mb },
     [Methods.TMUX_WORKER_LIST]: {
         requiresObservedRead: true,
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(4 * mb),
         timeoutMs: 10_000,
         live: true,
         normalizeParams: workerInventoryParams,
@@ -786,8 +896,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         dependencies: () => [{ family: 'planning', collection: 'work-graphs' }],
     },
     [Methods.WORK_GRAPH_GET]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(16 * mb),
         live: true,
         normalizeParams: planningObservationParams,
         dependencies: (params) => [
@@ -819,8 +930,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         ],
     },
     [Methods.ROADMAP_GET]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(16 * mb),
         live: true,
         normalizeParams: planningObservationParams,
         dependencies: (params) => [
@@ -834,6 +946,7 @@ export const RESOURCE_QUERY_DEFINITIONS = {
     [Methods.SOURCES_STATUS]: {
         persisted: true,
         maxBytes: 2 * mb,
+        retention: { maxEntries: 1, maxBytes: 2 * mb },
         timeoutMs: 120_000,
         live: true,
         dependencies: () => [{ family: 'sources', scope: 'farm' }],
@@ -847,10 +960,11 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         // Every write to any run changes the farm runs key, several times a minute on a busy farm.
         rereadIntervalMs: { runs: 30_000 },
     },
+    // Background sync stores every listed run's details (ADR-071 Amendment 2), so bytes bound it.
     [Methods.RUN_GET]: {
         persisted: true,
         maxBytes: 20 * mb,
-        retention: { maxEntries: 50, maxBytes: 20 * mb },
+        retention: keptUpTo(RUN_DETAIL_STORE_BYTES),
         live: true,
         dependencies: (params) => [
             { family: 'run', runId: requiredId(params, 'runId') },
@@ -866,8 +980,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         dependencies: () => [{ family: 'decisions', scope: 'farm' }],
     },
     [Methods.FAMILY_OBSERVABILITY_GET]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(16 * mb),
         live: true,
         dependencies: (params) => [
             { family: 'family', familyId: requiredId(params, 'familyId') },
@@ -876,8 +991,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         ],
     },
     [Methods.RUN_RECIPE_RUNS_FOR_RUN]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(32 * mb),
         timeoutMs: 60_000,
         live: true,
         dependencies: (params) => [
@@ -886,8 +1002,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         ],
     },
     [Methods.RUN_SLOT_HISTORY]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(4 * mb),
         live: true,
         dependencies: () => [
             { family: 'runs', scope: 'farm' },
@@ -895,8 +1012,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         ],
     },
     [Methods.RUN_FOR_SLOT]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 20 * mb,
+        retention: keptUpTo(40 * mb),
         live: true,
         dependencies: (params) => [
             { family: 'runs', scope: 'farm' },
@@ -904,8 +1022,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         ],
     },
     [Methods.RUN_RECIPE_RUNS_FOR_SLOT]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(16 * mb),
         timeoutMs: 60_000,
         live: true,
         dependencies: (params) => [
@@ -914,8 +1033,9 @@ export const RESOURCE_QUERY_DEFINITIONS = {
         ],
     },
     [Methods.RUN_TAGS_LIST]: {
-        persisted: false,
+        persisted: true,
         maxBytes: 2 * mb,
+        retention: keptUpTo(2 * mb),
         live: true,
         dependencies: () => [{ family: 'runs', scope: 'farm' }],
     },
@@ -977,6 +1097,247 @@ export const RESOURCE_QUERY_DEFINITIONS = {
             return [{ family: 'slot', slotId: requiredId(params, 'slotId') }];
         },
     },
+    // ADR-071 Amendment 2: reads that screens used to send straight to the gateway. A read is
+    // `live` only where every writer of its state publishes its keys; the others show their stored
+    // result and reread when opened.
+    [Methods.RUNTIME_POSTURE_STATUS]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: keptUpTo(16 * mb),
+        live: true,
+        normalizeParams: (params) => idParams(params, ['runId']),
+        dependencies: (params) => [
+            { family: 'run', runId: requiredId(params, 'runId') },
+            { family: 'capabilities' },
+            { family: 'sources', scope: 'farm' },
+        ],
+    },
+    [Methods.RESOURCE_LIST]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: keptUpTo(16 * mb),
+        live: true,
+        normalizeParams: (params) => idParams(params, ['slotId']),
+        dependencies: (params) => [
+            { family: 'slot', slotId: requiredId(params, 'slotId') },
+            { family: 'configuration', scope: 'farm' },
+            { family: 'sources', scope: 'farm' },
+        ],
+    },
+    // Probes slots and asks nodes for their panes, so changes never reread it on their own.
+    [Methods.RESOURCE_PRESSURE_SNAPSHOT]: {
+        persisted: true,
+        maxBytes: 2 * mb,
+        retention: keptUpTo(8 * mb),
+        live: false,
+        normalizeParams: (params) => machineParams(params, ['project', 'projects']),
+        dependencies: () => [],
+    },
+    [Methods.RESOURCE_PRESSURE_HISTORY]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: keptUpTo(8 * mb),
+        live: true,
+        normalizeParams: (params) => machineParams(params),
+        dependencies: (params) => {
+            const machines = (machineParams(params).machines ?? []);
+            // Every node sample advances the farm slots key, which covers an unfiltered read.
+            return machines.length
+                ? machines.map((nodeId) => ({ family: 'pressure', nodeId }))
+                : [{ family: 'slots', scope: 'farm' }];
+        },
+    },
+    // Runs simctl and adb on a cache miss; `refresh` stays an imperative probe.
+    [Methods.RESOURCE_DEVICE_INVENTORY]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: keptUpTo(8 * mb),
+        live: false,
+        normalizeParams: (params) => {
+            const { refresh, ...observation } = domainParams(params, ['slotId', 'refresh']);
+            if (refresh !== undefined && refresh !== false)
+                throw new Error('Device inventory observations cannot refresh');
+            return idParams(observation, ['slotId']);
+        },
+        dependencies: () => [],
+    },
+    [Methods.SLOT_ACTION_LIST]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: keptUpTo(8 * mb),
+        live: true,
+        normalizeParams: (params) => {
+            const value = domainParams(params, ['slotId', 'placement']);
+            domainId(value.slotId, 'slotId');
+            if (value.placement !== undefined)
+                domainId(value.placement, 'placement');
+            return value;
+        },
+        dependencies: (params) => [
+            { family: 'slot', slotId: requiredId(params, 'slotId') },
+            { family: 'configuration', scope: 'farm' },
+            { family: 'sources', scope: 'farm' },
+        ],
+    },
+    [Methods.GIT_FILES]: {
+        persisted: true,
+        maxBytes: 10 * mb,
+        retention: { maxEntries: 8, maxBytes: 40 * mb },
+        live: false,
+        normalizeParams: (params) => idParams(params, ['slotId']),
+        dependencies: () => [],
+    },
+    // Spec files are also edited outside the gateway, and nothing watches them yet.
+    [Methods.BACKLOG_SPEC_GET]: {
+        persisted: true,
+        maxBytes: 2 * mb,
+        retention: keptUpTo(16 * mb),
+        live: false,
+        normalizeParams: (params) => idParams(params, ['itemId']),
+        dependencies: () => [{ family: 'planning', collection: 'backlog' }],
+    },
+    // Whether the refinement's tmux session exists is not observed.
+    [Methods.BACKLOG_REFINEMENT_SESSION_GET]: {
+        persisted: true,
+        maxBytes: 256 * 1024,
+        retention: keptUpTo(2 * mb),
+        live: false,
+        normalizeParams: (params) => idParams(params, ['itemId']),
+        dependencies: () => [{ family: 'planning', collection: 'backlog' }],
+    },
+    [Methods.ROADMAP_REFINEMENT_SESSION_GET]: {
+        persisted: true,
+        maxBytes: 256 * 1024,
+        retention: keptUpTo(2 * mb),
+        live: false,
+        normalizeParams: (params) => idParams(params, ['itemId']),
+        dependencies: (params) => [
+            { family: 'planning', collection: 'roadmap' },
+            { family: 'planning', collection: 'roadmap', itemId: requiredId(params, 'itemId') },
+        ],
+    },
+    [Methods.CHAT_HISTORY]: {
+        persisted: true,
+        maxBytes: 5 * mb,
+        retention: keptUpTo(20 * mb),
+        live: true,
+        normalizeParams: chatHistoryParams,
+        dependencies: (params) => [
+            { ...copilotRuntimeKey, sessionId: String(chatHistoryParams(params).sessionId) },
+        ],
+    },
+    // Creating, pinning and saving a session publish no key yet.
+    [Methods.CHAT_SESSIONS]: {
+        persisted: true,
+        maxBytes: 1 * mb,
+        retention: keptUpTo(1 * mb),
+        live: false,
+        normalizeParams: (params) => domainParams(params, []),
+        dependencies: () => [copilotRuntimeKey],
+    },
+    // Pending confirmations expire, and issuing or confirming one publishes no key yet.
+    [Methods.CHAT_LIST_ACTIONS]: {
+        persisted: true,
+        maxBytes: 256 * 1024,
+        retention: keptUpTo(2 * mb),
+        live: false,
+        normalizeParams: sessionContextParams,
+        dependencies: () => [],
+    },
+    // Audit records are appended to files without publishing a key.
+    [Methods.INTELLIGENCE_ACTIONS_SUMMARY]: {
+        persisted: true,
+        maxBytes: 2 * mb,
+        retention: keptUpTo(8 * mb),
+        live: false,
+        normalizeParams: (params) => {
+            const value = domainParams(params, ['limit', 'dateFrom', 'dateTo']);
+            if (value.limit !== undefined && !Number.isSafeInteger(value.limit))
+                throw new Error('Invalid intelligence page size');
+            for (const field of ['dateFrom', 'dateTo'])
+                if (value[field] !== undefined && Number.isNaN(Date.parse(String(value[field]))))
+                    throw new Error(`Invalid intelligence selector: ${field}`);
+            return value;
+        },
+        dependencies: () => [],
+    },
+    // Setting a cap publishes no key yet.
+    [Methods.EVAL_SUITE_CAP_GET]: {
+        timeoutMs: 30_000,
+        persisted: true,
+        maxBytes: 256 * 1024,
+        retention: keptUpTo(2 * mb),
+        live: false,
+        normalizeParams: (params) => idParams(params, ['capGroupId']),
+        dependencies: () => [],
+    },
+    [Methods.EVAL_TRIAL_RESULT_GET]: {
+        timeoutMs: 30_000,
+        persisted: true,
+        maxBytes: 20 * mb,
+        retention: keptUpTo(40 * mb),
+        live: true,
+        normalizeParams: (params) => idParams(params, ['runId']),
+        dependencies: (params) => [
+            { family: 'run', runId: requiredId(params, 'runId') },
+            { family: 'artifacts', runId: requiredId(params, 'runId') },
+        ],
+    },
+    [Methods.FINETUNE_INDEX]: {
+        persisted: true,
+        maxBytes: 2 * mb,
+        retention: keptUpTo(8 * mb),
+        live: true,
+        normalizeParams: (params) => {
+            const value = domainParams(params, ['project']);
+            if (value.project !== undefined)
+                domainId(value.project, 'project');
+            return value;
+        },
+        rereadIntervalMs: { runs: 30_000 },
+        dependencies: () => [{ family: 'runs', scope: 'farm' }],
+    },
+    // Its pressure section probes slots like `resource.pressure.snapshot`.
+    [Methods.MACHINE_PAUSE_STATUS]: {
+        persisted: true,
+        maxBytes: 2 * mb,
+        retention: keptUpTo(8 * mb),
+        live: false,
+        normalizeParams: (params) => idParams(params, ['machine']),
+        dependencies: () => [],
+    },
+    // Toggling admission writes its control file without publishing a key.
+    [Methods.DISPATCH_PRESSURE_ADMISSION_GET]: {
+        persisted: true,
+        maxBytes: 256 * 1024,
+        retention: { maxEntries: 1, maxBytes: 256 * 1024 },
+        live: false,
+        normalizeParams: (params) => domainParams(params, []),
+        dependencies: () => [],
+    },
+    // One turn's diff of one file does not change; a pruned checkpoint reads NOT_FOUND.
+    [Methods.NATIVE_SESSION_TURN_DIFF]: {
+        persisted: true,
+        maxBytes: 5 * mb,
+        retention: { maxEntries: 50, maxBytes: 20 * mb },
+        live: false,
+        normalizeParams: (params) => {
+            const { sequence, path, ...target } = domainParams(params, [
+                'sessionId',
+                'executionNodeId',
+                'worker',
+                'sequence',
+                'path',
+            ]);
+            if (!Number.isSafeInteger(sequence) || Number(sequence) < 0)
+                throw new Error('Invalid native turn sequence');
+            if (typeof path !== 'string' || !path)
+                throw new Error('Native turn diff requires a path');
+            validateWorkspacePath(path);
+            return { ...nativeHistoryParams(target), sequence, path };
+        },
+        dependencies: () => [],
+    },
 };
 /** Advertise only collectors whose owning read and notification contract are enabled. */
 export function resourceCollectorReadMethods() {
@@ -1002,10 +1363,44 @@ export function resourceReadTimeout(method) {
     return definition.timeoutMs;
 }
 /** Experimental, portable query factory; mutations and streams are never registered here. */
-export function resourceQuery(method, params = {}, nativeReaderId) {
+function readDefinition(method, params) {
     const definition = RESOURCE_QUERY_DEFINITIONS[method];
     if (!definition)
         throw new Error(`Unregistered resource read: ${method}`);
+    if ((method !== Methods.GIT_DIFF && method !== Methods.GIT_SHOW) ||
+        !params ||
+        typeof params !== 'object' ||
+        !Reflect.get(params, 'runId') ||
+        Reflect.get(params, 'slotId') ||
+        Reflect.get(params, 'sessionId'))
+        return definition;
+    // A slotless review reads exact retained commits, not a mutable workspace observation.
+    return {
+        ...definition,
+        live: false,
+        requiresObservedRead: false,
+        requiresWorkspaceRead: false,
+        normalizeParams(input) {
+            const value = domainParams(input, method === Methods.GIT_SHOW
+                ? ['slotId', 'runId', 'ref', 'path']
+                : ['slotId', 'runId', 'base', 'head', 'path', 'oldPath']);
+            requiredId(value, 'runId');
+            for (const field of method === Methods.GIT_SHOW ? ['ref', 'path'] : ['base', 'head'])
+                requiredId(value, field);
+            validateWorkspacePath(value.path);
+            validateWorkspacePath(value.oldPath);
+            return { ...value, slotId: '' };
+        },
+        dependencies: () => [],
+        retentionGroups: (value) => [`run:${requiredId(value, 'runId')}`],
+    };
+}
+/** Snapshot reads use the ordinary RPC contract, including on gateways predating registration. */
+export function resourceReadIsLive(method, params) {
+    return readDefinition(method, params).live;
+}
+export function resourceQuery(method, params = {}, nativeReaderId) {
+    const definition = readDefinition(method, params);
     const canonical = canonicalResourceJson(definition.normalizeParams ? definition.normalizeParams(params) : (params ?? {}));
     const normalized = JSON.parse(canonical);
     return {
@@ -1038,7 +1433,7 @@ export function resourceQuery(method, params = {}, nativeReaderId) {
 export function resourceDependenciesForRead(method, params, nativeReaderId) {
     if (!Object.hasOwn(RESOURCE_QUERY_DEFINITIONS, method))
         return undefined;
-    const definition = RESOURCE_QUERY_DEFINITIONS[method];
+    const definition = readDefinition(method, params);
     return definition.live ? definition.dependencies(params, nativeReaderId) : undefined;
 }
 //# sourceMappingURL=registry.js.map