@nocobase/app-plugin-agents 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/server/core/runs/claim.js

@@ -1,3 +1,4 @@
+import { GLOBAL_SKILL_TARGET } from '../../../shared/skills.js';
 /**
  * Claiming: handing queued runs to a runner that fits them, within each agent's concurrency limit, one run per
  * (agent, subject, thread) at a time, through the runners' one long-poll (`routes/runners/runner.ts`), which hands
@@ -29,6 +30,16 @@
  *
  * Portable by design: the database layer offers no `FOR UPDATE SKIP LOCKED` or advisory locks, and the guarded update
  * plus the agent-row write give the same guarantees on every dialect (SQLite serializes writers anyway).
+ *
+ * Polls are the hot path: every runner walks the same candidates, so a write per candidate is a write per candidate per
+ * runner per poll. Everything that rules a candidate out is read outside any transaction — identity, `fits()`, slots,
+ * concurrency and comment consent — and a transaction opens only for the run about to be claimed. The agent row is
+ * the only row a claim locks with a self-update, and only in that final transaction after `fits()` (or when a stale
+ * identity has to be repaired first, which current work never needs). PostgreSQL runs at READ COMMITTED, where each
+ * statement sees the latest committed rows, so no transaction needs no-op writes to refresh a snapshot; comment
+ * consent needs no chain lock, because confirmation is final and rejection or Run as me end the chain's queued runs,
+ * which the guarded update sees. A new write or lock here needs a measured reason (`tests/claim-concurrency.test.ts`
+ * counts them, and the lock waits on PostgreSQL).
 
  */
 import { ANNOUNCED_FAILURES, isProtocolSupported, policyAllowsAgent, policyAllowsRepo, policyAllowsSubject, TIMINGS, } from '@nocobase/agent-protocol';
@@ -38,8 +49,8 @@ import { createHash } from 'node:crypto';
 import { later } from '../../kernel/clock.js';
 import { notFound } from '../../kernel/errors.js';
 import { runSecretsKey } from '../../kernel/redaction.js';
-import { cleanList, covers } from '../../kernel/values.js';
-import { findAgent, lockAgentForClaim } from '../agents/index.js';
+import { cleanList, covers, jsonObject } from '../../kernel/values.js';
+import { findAgent, findAgents, lockAgentForClaim } from '../agents/index.js';
 import { joinBrief, renderBrief } from '../brief/index.js';
 import { cliPackageFor } from './cli-package.js';
 import { executionHistory } from './execution.js';
@@ -47,11 +58,12 @@ import { describeVariables, variableRefs, } from '../variables/index.js';
 import { mountsFor, prepareExtensions, repoAccessFor, sessionKeyOf, withSections, } from './extensions.js';
 import { MAX_CLAIM_FAILURES, toolPolicyFor } from './policy.js';
 import { mintRunToken } from './run-tokens.js';
-import { runsHeldByTool } from './runner-view.js';
-import { ACTIVE, countActive, eventsRepo, findRunRecord, markDelivered, pendingInputs, runsOfKey, runsRepo, sessionsRepo, toInput, toRun, } from './run.store.js';
+import { ACTIVE, countActive, eventsRepo, findRunRecord, markDelivered, pendingInputs, runsOfKey, runsRepo, inputsRepo, sessionsRepo, toInput, toExecutions, toRun, } from './run.store.js';
 import { dropInputs } from './input-gate.js';
 import { finishRun } from './transitions.js';
-import { refreshQueuedIdentity } from './identity.js';
+import { queuedIdentityCurrent, refreshQueuedIdentity } from './identity.js';
+import { currentCommentOwner, commentConsent, commentFromOwner, withdrawCommentRequests, } from './comment-consent.js';
+import { insertRunRequest, runRequestsRepo } from './run-requests.js';
 import { consumeReset, saveBrief } from './workspace.store.js';
 /** Queued runs looked at per claim, oldest first by priority. */
 const CANDIDATES = 50;
@@ -158,11 +170,11 @@ export function variableTargets(agent, assembly) {
         { scope: 'agent', scopeId: agent.id },
     ];
 }
-/** Where a run's skills come from, the agent's first so its own win a shared slug. */
-export function skillTargets(agent, assembly) {
+/** Team defaults, application scopes and directories, from lowest to highest priority. */
+export function skillTargets(_agent, assembly) {
     return [
-        { scope: 'agent', scopeId: agent.id },
-        ...assembly.scopes,
+        GLOBAL_SKILL_TARGET,
+        ...assembly.scopes.filter((target) => target.scope !== 'agent' && target.scope !== 'global'),
         ...assembly.dirs.flatMap((dir) => dir.scopeId ? [{ scope: 'workdir', scopeId: dir.scopeId }] : []),
     ];
 }
@@ -234,14 +246,31 @@ async function settleClaimInputs(conn, pending, effective, now) {
 }
 export function createClaimService(deps) {
     const { tx, clock } = deps;
+    /** Reuse only identical ordered targets, within this attempt and connection. */
+    function claimResources(conn, runId) {
+        const cache = new Map();
+        return (agent, assembly) => {
+            const skills = skillTargets(agent, assembly);
+            const variables = variableTargets(agent, assembly);
+            const key = JSON.stringify([skills, variables]);
+            let result = cache.get(key);
+            if (!result) {
+                result = (async () => ({
+                    skills: await deps.skills.forRun(conn, skills, runId),
+                    variables: await deps.variables.prepareRun(conn, variables),
+                }))();
+                cache.set(key, result);
+            }
+            return result;
+        };
+    }
     /** Database reads only; used by the actual claim and ordered-model diagnostics. */
-    async function assemblyCompatibility(conn, run, agent, runner, assembly) {
+    async function assemblyCompatibility(conn, run, agent, runner, assembly, resources = claimResources(conn, run.id)) {
         if (!isProtocolSupported(runner.protocolVersion) ||
             (assembly.workspaceKey && !supportsWorkspaceKey(runner)))
             return 'incompatible';
-        const skills = await deps.skills.forRun(conn, skillTargets(agent, assembly), run.id);
-        const targets = variableTargets(agent, assembly);
-        const names = await deps.variables.namesOf(conn, targets);
+        const { skills, variables } = await resources(agent, assembly);
+        const names = variables.names;
         if (!covers(runner.features, [
             ...run.requires,
             ...payloadRequires(payloadDirs(assembly.dirs), skills.length, names.length, Boolean(assembly.workspaceKey)),
@@ -252,18 +281,18 @@ export function createClaimService(deps) {
             assembly.dirs.some((dir) => (dir.kind === 'repo' && !policyAllowsRepo(runner.policy, dir.url)) ||
                 (dir.kind === 'directory' && dir.runnerId !== runner.id)))
             return 'restricted';
-        if (runner.trust !== 'team' &&
-            (await deps.variables.teamOnly(conn, targets)).length > 0)
+        if (runner.trust !== 'team' && variables.teamOnly.length > 0)
             return 'restricted';
         return 'ready';
     }
-    async function selectionFacts(conn, run, agent, requirePolicy = true) {
+    async function selectionFacts(conn, run, agent, requirePolicy = true, trust, resources = claimResources(conn, run.id)) {
         const policy = await deps.selectionPolicies?.forRun(conn, run);
         if ((requirePolicy && !policy) || !deps.runners)
             return null;
         const now = clock.now();
         const start = queueStart(run);
-        const registered = await deps.runners.all(conn);
+        const registered = (await deps.runners.all(conn)).filter((runner) => !trust ||
+            (trust === 'team' ? runner.trust === 'team' : runner.trust !== 'team'));
         const binding = deps.subjects.get(run.subject.kind);
         if (!binding)
             throw new Error(`No context provider for ${run.subject.kind}.`);
@@ -325,7 +354,7 @@ export function createClaimService(deps) {
                     });
                     continue;
                 }
-                const reason = await assemblyCompatibility(conn, run, single, runner, assembly);
+                const reason = await assemblyCompatibility(conn, run, single, runner, assembly, resources);
                 if (reason !== 'ready') {
                     incompatible ||= reason === 'incompatible';
                     loads.push({
@@ -336,7 +365,8 @@ export function createClaimService(deps) {
                     });
                     continue;
                 }
-                const requiredVariables = await deps.variables.passthroughOf(conn, variableTargets(single, assembly));
+                const requiredVariables = (await resources(single, assembly)).variables
+                    .passthrough;
                 if (requiredVariables.length > 0 && runner.variables == null) {
                     unknown = true;
                     continue;
@@ -344,8 +374,9 @@ export function createClaimService(deps) {
                 if (requiredVariables.some((name) => !runner.variables?.includes(name)))
                     continue;
                 compatible.push(runner);
-                const byTool = await runsHeldByTool(conn, runner.id);
-                const used = await deps.slotsUsed(conn, runner.id);
+                const held = await deps.slotsHeld(conn, runner.id);
+                const byTool = held.byTool ?? {};
+                const used = held.jobs + held.runs;
                 const directory = directoryKeyOf(runner.id, payloadDirs(assembly.dirs));
                 const blockedDirectory = directory !== null &&
                     (await directoryBusy(conn, runner.id, run.id, directory));
@@ -434,7 +465,7 @@ export function createClaimService(deps) {
             entries,
         };
     }
-    async function assemble({ conn }, run, agent, runner, inputs, leaseExpiresAt, prepared, entry) {
+    async function assemble({ conn }, run, agent, runner, inputs, leaseExpiresAt, prepared, entry, resources = claimResources(conn, run.id)) {
         const binding = deps.subjects.get(run.subjectKind);
         if (!binding)
             throw new Error(`No context provider is registered for subjects of kind "${run.subjectKind}".`);
@@ -449,7 +480,7 @@ export function createClaimService(deps) {
         };
         const assembly = await binding.context.assemble(conn, claim, prepared.get('subject'));
         // workspace.key is required for coordinating runs; old runners must not silently ignore it.
-        if ((await assemblyCompatibility(conn, toRun(run), agent, runner, assembly)) === 'incompatible')
+        if ((await assemblyCompatibility(conn, toRun(run), agent, runner, assembly, resources)) === 'incompatible')
             throw new NotForThisRunner();
         inputs = assembly.inputs ?? inputs;
         const effectiveClaim = { ...claim, inputs };
@@ -466,9 +497,8 @@ export function createClaimService(deps) {
         if (directoryKey !== null &&
             (await directoryBusy(conn, runner.id, run.id, directoryKey)))
             throw new NotForThisRunner();
-        const skills = await deps.skills.forRun(conn, skillTargets(agent, assembly), run.id);
-        const variables = variableTargets(agent, assembly);
-        const names = await deps.variables.namesOf(conn, variables);
+        const { skills, variables } = await resources(agent, assembly);
+        const names = variables.names;
         const requires = cleanList([
             ...view.requires,
             ...payloadRequires(dirs, skills.length, names.length, Boolean(assembly.workspaceKey)),
@@ -477,19 +507,19 @@ export function createClaimService(deps) {
             throw new NotForThisRunner();
         // A variable for team runners only keeps a personal runner off the run.
         if (names.length > 0 && runner.trust !== 'team') {
-            const teamOnly = await deps.variables.teamOnly(conn, variables);
+            const teamOnly = variables.teamOnly;
             if (teamOnly.length > 0)
                 throw new TeamRunnersOnly(teamOnly);
         }
         const env = names.length > 0
-            ? await deps.variables.forRun(conn, variables, {
+            ? await variables.deliver({
                 runId: run.id,
                 runnerId: runner.id,
             })
             : [];
         // Variables taken from the runner: names only. A runner that does not provide one fails the run while preparing
         // it, saying how to provide it; runners are not chosen by them.
-        const passthrough = await deps.variables.passthroughOf(conn, variables);
+        const passthrough = variables.passthrough;
         const nowText = clock.now().toISOString();
         const clean = await consumeReset(conn, { kind: run.subjectKind, id: run.subjectId }, run.id, nowText);
         const session = await sessionsRepo(conn).findOne({
@@ -536,7 +566,7 @@ export function createClaimService(deps) {
         const sessionNote = resume ? assembly.turn.resumed : assembly.turn.fresh;
         const turn = [
             brief.turn,
-            ...(run.failureReason === 'runnerUpgrade'
+            ...(toExecutions(run.executionHistory).find((execution) => execution.attempt === Number(run.attempt) - 1)?.failureReason === 'runnerUpgrade'
                 ? [
                     'The previous attempt was interrupted by a runner upgrade. Continue from the current state.',
                 ]
@@ -657,17 +687,175 @@ export function createClaimService(deps) {
                 });
         });
     }
-    async function admit(unit, run, agent, runner, inputs) {
-        const rejection = await deps.subjects
-            .get(run.subjectKind)
-            ?.context.admit?.(unit.conn, {
+    /** What reconciling a comment run would change, read without writing: most runs need nothing. */
+    async function planCommentConsent(conn, runId) {
+        const none = { kind: 'none' };
+        const run = await findRunRecord(conn, runId);
+        if (!run?.commentRootRunId)
+            return none;
+        const root = await findRunRecord(conn, run.commentRootRunId);
+        if (!root)
+            return none;
+        if (run.status !== 'queued') {
+            const pending = await runRequestsRepo(conn).findMany({
+                filter: {
+                    commentRootRunId: root.id,
+                    commentRunId: run.id,
+                    purpose: 'personalRunner',
+                    status: 'pending',
+                },
+                limit: 1,
+            });
+            return pending.length > 0 ? { kind: 'withdraw', rootId: root.id } : none;
+        }
+        if (!(await queuedIdentityCurrent(conn, deps, run)))
+            return { kind: 'refresh', run };
+        if (!(await currentCommentOwner(conn, deps.subjects, root)))
+            return {
+                kind: 'cancel',
+                run,
+                detail: 'The comment belongs to an earlier owner assignment.',
+            };
+        if (root.commentExecution === 'requester' ||
+            run.actorUserId !== root.ownerUserId)
+            return none;
+        const { decision } = await commentConsent(conn, root);
+        if (decision === 'confirmed' || decision === 'pending')
+            return none;
+        if (await commentFromOwner(conn, root))
+            return none;
+        if (decision === 'rejected')
+            return {
+                kind: 'cancel',
+                run,
+                detail: 'The comment personal runner authorization is no longer valid.',
+            };
+        const agent = await findAgent(conn, run.agentId);
+        if (!agent)
+            return none;
+        const team = await selectionFacts(conn, toRun(run), agent, false, 'team');
+        if (!team ||
+            team.entries.some((e) => e.compatibleCount > 0 ||
+                e.reason === 'unknown' ||
+                e.blockers?.includes('unknown')))
+            return none;
+        const personal = await selectionFacts(conn, toRun(run), agent, false, 'personal');
+        if (!personal?.entries.some((e) => e.compatibleCount > 0))
+            return none;
+        const sourceInputs = await inputsRepo(conn).findMany({
+            filter: { runId: root.id },
+            sort: (sort) => [sort.field('createdAt').asc(), sort.field('id').asc()],
+        });
+        const input = sourceInputs.find((input) => input.type === 'comment' &&
+            jsonObject(input.payload).commentSourceSnapshot === true) ?? sourceInputs.find((input) => input.type === 'comment');
+        return input ? { kind: 'request', run, root, input } : none;
+    }
+    /**
+     * Brings a comment run's consent up to date. It takes no lock of its own: callers that may create a request hold
+     * the run's agent row (enqueue, retry and the sweeper do), which serializes the duplicate check in insertRunRequest
+     * with every other enqueue and claim of that agent. Everything else is a guarded update.
+     */
+    async function reconcileCommentConsent(unit, runId) {
+        let plan = await planCommentConsent(unit.conn, runId);
+        if (plan.kind === 'refresh') {
+            if (!(await refreshQueuedIdentity(unit, deps, plan.run)))
+                return;
+            plan = await planCommentConsent(unit.conn, runId);
+        }
+        switch (plan.kind) {
+            case 'withdraw':
+                await withdrawCommentRequests(unit, plan.rootId, clock.now().toISOString(), runId);
+                return;
+            case 'cancel':
+                await finishRun(unit, deps, plan.run, {
+                    status: 'cancelled',
+                    reason: null,
+                    detail: plan.detail,
+                });
+                return;
+            case 'request': {
+                const { run, root, input } = plan;
+                await insertRunRequest(unit, deps, {
+                    purpose: 'personalRunner',
+                    commentRootRunId: root.id,
+                    commentRunId: run.id,
+                    commentOwnerKey: root.commentOwnerKey ?? null,
+                    agentId: run.agentId,
+                    subject: toRun(run).subject,
+                    threadScope: run.threadScope,
+                    // The plan only asks for runs acting as the chain's owner.
+                    responsibleUserId: run.actorUserId,
+                    requestedByUserId: root.requestedByUserId ?? root.actorUserId,
+                    ownerUserId: run.actorUserId,
+                    priority: Number(run.priority),
+                    requires: toRun(run).requires,
+                    fireAt: run.availableAt,
+                    maxAttempts: Number(run.maxAttempts),
+                    input: toInput(input),
+                });
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    /**
+     * Whether this runner may take this candidate under comment consent, read outside any transaction. Immutable facts
+     * settle most candidates without a query: no comment chain, work run as the commenter, or work not run as the
+     * chain's owner. The rest read the chain's requests once. A decision never needs a lock: confirmation is final,
+     * and rejection or Run as me end the chain's queued runs, which the claim's guarded `status = 'queued'` update sees.
+     */
+    async function commentConsentFor(conn, runner, run) {
+        const allowed = { allowed: true, confirmedByUserId: null };
+        const refused = { allowed: false, confirmedByUserId: null };
+        if (!run.commentRootRunId || run.commentExecution === 'requester')
+            return allowed;
+        const root = await findRunRecord(conn, run.commentRootRunId);
+        if (!root || root.commentRootRunId !== root.id)
+            return refused;
+        if (root.commentExecution === 'requester' ||
+            run.actorUserId !== root.ownerUserId)
+            return allowed;
+        const { decision, confirmation } = await commentConsent(conn, root);
+        if (decision === 'rejected')
+            return refused;
+        if (decision === 'confirmed')
+            return {
+                allowed: true,
+                confirmedByUserId: confirmation?.settledById ?? null,
+            };
+        if (runner.trust === 'team')
+            return allowed;
+        return (await commentFromOwner(conn, root)) ? allowed : refused;
+    }
+    /** Withdraws the request a team claim made obsolete, writing only when one is pending. */
+    async function withdrawIfPending(rootId, runId) {
+        try {
+            const pending = await runRequestsRepo(tx.read()).findMany({
+                filter: {
+                    commentRootRunId: rootId,
+                    commentRunId: runId,
+                    purpose: 'personalRunner',
+                    status: 'pending',
+                },
+                limit: 1,
+            });
+            if (pending.length > 0)
+                await tx.run((unit) => withdrawCommentRequests(unit, rootId, clock.now().toISOString(), runId));
+        }
+        catch (error) {
+            deps.onClaimFailure?.(runId, error);
+        }
+    }
+    async function admit(unit, run, agent, runner, inputs, prepared) {
+        const rejection = await deps.subjects.get(run.subjectKind)?.context.admit?.(unit.conn, {
             run: toRun(run),
             agent,
             runner,
             inputs,
             cli: deps.cli.name,
             appName: deps.app.name,
-        });
+        }, prepared);
         if (!rejection)
             return true;
         await finishRun(unit, deps, run, {
@@ -678,8 +866,15 @@ export function createClaimService(deps) {
         return false;
     }
     async function attempt(runner, agent, candidate, reported) {
-        // Repair pre-upgrade queued work before even checking personal runner ownership.
-        if (deps.subjects.get(candidate.subjectKind)?.actsAs) {
+        const conn = tx.read();
+        // Rules that do not depend on who the run acts as come first, and settle the rest of the pass: an agent at its
+        // limit is checked once per poll, not once per queued run.
+        if ((await countActive(conn, 'agentId', agent.id)) >= agent.maxConcurrentRuns)
+            return { kind: 'full', scope: 'agent' };
+        // Repair pre-upgrade queued work before even checking personal runner ownership. Reading first keeps a poll over
+        // current work free of transactions and row locks; only work whose identity changed is written.
+        if (deps.subjects.get(candidate.subjectKind)?.actsAs &&
+            !(await queuedIdentityCurrent(conn, deps, candidate))) {
             const current = await tx.run(async (unit) => {
                 await lockAgentForClaim(unit.conn, agent.id, clock.now().toISOString());
                 const run = await findRunRecord(unit.conn, candidate.id);
@@ -692,13 +887,12 @@ export function createClaimService(deps) {
             candidate = current;
         }
         // Avoid assembling or asking authorization when a cheap claim rule already rules this work out.
-        const conn = tx.read();
         if (!fits(runner, agent, candidate) ||
-            (await deps.slotsUsed(conn, runner.id)) >= runner.slots ||
-            (await countActive(conn, 'agentId', agent.id)) >=
-                agent.maxConcurrentRuns ||
             (await runsOfKey(conn, candidate, ACTIVE)).length > 0)
             return { kind: 'skipped' };
+        const consent = await commentConsentFor(conn, runner, candidate);
+        if (!consent.allowed)
+            return { kind: 'skipped' };
         // Before the transaction: on SQLite it holds the only connection, so the providers read what else they need now.
         const prepared = new Map(await prepareExtensions(toRun(candidate), deps.sections, deps.mounts, (error) => deps.onClaimFailure?.(candidate.id, error), deps.repoAccess, { onDemand: asksCredentialsOnDemand(runner) }));
         const subjectContext = deps.subjects.get(candidate.subjectKind)?.context;
@@ -711,6 +905,7 @@ export function createClaimService(deps) {
             }
         }
         let taken;
+        let runnerFull = false;
         try {
             taken = await tx.run(async (unit) => {
                 const { conn } = unit;
@@ -728,11 +923,14 @@ export function createClaimService(deps) {
                     agent.maxConcurrentRuns)
                     return null;
                 // Slots are shared with the jobs the runner holds.
-                if ((await deps.slotsUsed(conn, runner.id)) >= runner.slots)
+                const held = await deps.slotsHeld(conn, runner.id);
+                if (held.runs + held.jobs >= runner.slots) {
+                    runnerFull = true;
                     return null;
-                // The first of the agent's tools with room, by its limit here and by what the runner said it can take.
-                const byTool = await runsHeldByTool(conn, runner.id);
-                const current = await findRunRecord(conn, candidate.id);
+                }
+                // Total and per-tool room come from the same locked snapshot.
+                const byTool = held.byTool ?? {};
+                const current = identity;
                 if (!current ||
                     current.status !== 'queued' ||
                     (current.availableAt &&
@@ -744,38 +942,47 @@ export function createClaimService(deps) {
                 const busy = await runsOfKey(conn, candidate, ACTIVE);
                 if (busy.length > 0)
                     return null;
-                const leaseExpiresAt = later(now, TIMINGS.leaseMs);
+                const leaseExpiresAt = later(now, TIMINGS.startTimeoutMs);
+                const dispatchValues = {
+                    status: 'dispatched',
+                    failureReason: null,
+                    failureDetail: null,
+                    runnerId: runner.id,
+                    // Brief providers observe this reservation inside the claim transaction.
+                    // Replace a previous attempt's tool before computing the roster.
+                    tool: entry.tool,
+                    leaseExpiresAt,
+                    dispatchedAt: nowText,
+                    lastActivityAt: nowText,
+                    availableAt: null,
+                    updatedAt: nowText,
+                    ...(consent.confirmedByUserId
+                        ? { confirmedByUserId: consent.confirmedByUserId }
+                        : {}),
+                };
                 const claimed = await runsRepo(conn).updateMany({
                     filter: (f) => f.and([
                         f.string('id').eq(candidate.id),
                         f.string('status').eq('queued'),
                         f.string('actorUserId').eq(candidate.actorUserId),
                     ]),
-                    values: {
-                        status: 'dispatched',
-                        runnerId: runner.id,
-                        // Brief providers observe this reservation inside the claim transaction.
-                        // Replace a previous attempt's tool before computing the roster.
-                        tool: entry.tool,
-                        leaseExpiresAt,
-                        dispatchedAt: nowText,
-                        lastActivityAt: nowText,
-                        availableAt: null,
-                        updatedAt: nowText,
-                    },
+                    values: dispatchValues,
                 });
                 if (claimed.updatedCount !== 1)
                     return null;
-                const run = (await findRunRecord(conn, candidate.id));
-                const pending = await pendingInputs(conn, run.id);
+                const run = { ...current, ...dispatchValues };
+                const pending = (await pendingInputs(conn, run.id)).filter((input) => !run.commentRootRunId ||
+                    input.type !== 'comment' ||
+                    jsonObject(input.payload).commentRootRunId === run.commentRootRunId);
                 let assembled;
                 let selectionSnapshot;
                 try {
-                    if (!(await admit(unit, run, agent, runner, pending.map(toInput))))
+                    if (!(await admit(unit, run, agent, runner, pending.map(toInput), prepared.get('subject'))))
                         return null;
                     // Admission must precede preflight assembly: a missing or obsolete
                     // subject is cancelled normally, rather than counted as setup failure.
-                    const selection = await selectionFacts(conn, toRun(current), agent);
+                    const resources = claimResources(conn, run.id);
+                    const selection = await selectionFacts(conn, toRun(current), agent, true, undefined, resources);
                     const elapsed = Math.max(0, (now.getTime() - queueStart(toRun(current))) / 1000);
                     const preferredAvailable = (selection?.entries[0]?.compatibleCount ?? 0) > 0 ||
                         selection?.entries[0]?.reason === 'unknown' ||
@@ -796,7 +1003,7 @@ export function createClaimService(deps) {
                             waitedSeconds: elapsed,
                         };
                     }
-                    assembled = await assemble(unit, run, agent, runner, pending.map(toInput), leaseExpiresAt, prepared, entry);
+                    assembled = await assemble(unit, run, agent, runner, pending.map(toInput), leaseExpiresAt, prepared, entry, resources);
                 }
                 catch (error) {
                     if (error instanceof NotForThisRunner)
@@ -863,8 +1070,15 @@ export function createClaimService(deps) {
         }
         if (!taken) {
             await discardRepoAccess(candidate, prepared);
-            return { kind: 'skipped' };
+            return runnerFull
+                ? { kind: 'full', scope: 'runner' }
+                : { kind: 'skipped' };
         }
+        // After the claim commits, never inside it: decisions settle the request before touching runs, so a claim that
+        // held its run while waiting for the request could deadlock with them. A request left pending by a crash here is
+        // withdrawn by the next reconciliation, and confirming it finds the run no longer waiting.
+        if (candidate.commentRootRunId && runner.trust === 'team')
+            await withdrawIfPending(candidate.commentRootRunId, candidate.id);
         return { kind: 'claimed', payload: taken };
     }
     async function discardRepoAccess(run, prepared) {
@@ -897,6 +1111,7 @@ export function createClaimService(deps) {
                 filter: { id: runId },
                 values: {
                     claimFailures: failures,
+                    failureReason: 'setupFailed',
                     failureDetail: error.message.slice(0, 10_000),
                 },
             });
@@ -926,13 +1141,14 @@ export function createClaimService(deps) {
             return null;
         const conn = tx.read();
         const queued = await candidates();
-        const agents = new Map();
+        const agents = await findAgents(conn, queued
+            .filter((candidate) => !seen.has(candidate.id))
+            .map((candidate) => candidate.agentId));
+        const full = new Set();
         for (const candidate of queued) {
-            if (seen.has(candidate.id))
+            if (seen.has(candidate.id) || full.has(candidate.agentId))
                 continue;
             seen.add(candidate.id);
-            if (!agents.has(candidate.agentId))
-                agents.set(candidate.agentId, await findAgent(conn, candidate.agentId));
             const agent = agents.get(candidate.agentId);
             if (!agent ||
                 (!deps.subjects.get(candidate.subjectKind)?.actsAs &&
@@ -945,6 +1161,13 @@ export function createClaimService(deps) {
                 const result = await attempt(runner, agent, candidate, reported);
                 if (result.kind === 'claimed')
                     return result.payload;
+                if (result.kind === 'full') {
+                    if (result.scope === 'runner')
+                        return null;
+                    // Seen candidates are passed over for good in this claim; unvisited ones stay eligible for the next pass.
+                    seen.delete(candidate.id);
+                    full.add(candidate.agentId);
+                }
             }
             catch (error) {
                 // Rolled back: the run stays queued for a runner it fits.
@@ -958,6 +1181,38 @@ export function createClaimService(deps) {
         return null;
     }
     return {
+        reconcileCommentConsent,
+        async reconcileCommentQueue() {
+            const conn = tx.read();
+            const queued = await runsRepo(conn).findMany({
+                filter: (f) => f.and([
+                    f.string('status').eq('queued'),
+                    f.string('commentRootRunId').notEmpty(),
+                ]),
+                sort: (s) => [s.field('createdAt').asc()],
+                limit: 100,
+            });
+            const pending = await runRequestsRepo(conn).findMany({
+                filter: { purpose: 'personalRunner', status: 'pending' },
+                limit: 100,
+            });
+            for (const id of new Set([
+                ...queued.map((run) => run.id),
+                ...pending
+                    .map((request) => request.commentRunId)
+                    .filter((id) => Boolean(id)),
+            ])) {
+                // Read first: a sweep over settled chains opens no transaction at all.
+                const plan = await planCommentConsent(conn, id);
+                if (plan.kind === 'none')
+                    continue;
+                await tx.run(async (unit) => {
+                    if (plan.kind === 'request' || plan.kind === 'refresh')
+                        await lockAgentForClaim(unit.conn, plan.run.agentId, clock.now().toISOString());
+                    await reconcileCommentConsent(unit, id);
+                });
+            }
+        },
         diagnose: (conn, run, agent) => selectionFacts(conn, run, agent, false),
         async selectionWait(runId) {
             const conn = tx.read();
@@ -970,13 +1225,13 @@ export function createClaimService(deps) {
         async claim(runner, free, tools) {
             if (runner.status !== 'online' || runnerLowOnDisk(runner))
                 return [];
-            if ((await deps.slotsUsed(tx.read(), runner.id)) >= runner.slots)
-                return [];
             const payloads = [];
             const seen = new Set();
             const limit = Math.min(free, runner.slots);
             const reported = toolRoom(tools);
             while (payloads.length < limit) {
+                if ((await deps.slotsUsed(tx.read(), runner.id)) >= runner.slots)
+                    break;
                 const payload = await claimOne(runner, seen, reported);
                 if (!payload)
                     break;