@nocobase/app-plugin-agents 0.1.0-beta.9 → 1.0.0-beta.16

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

@@ -30,41 +30,43 @@
  * 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).
  *
- * Runners take only runner agents' runs. Online agents' runs are taken by the application itself (`claimServer`, for the
- * server executor of each instance), through the same guarded update, so two instances never take the same run: the
- * holder is the instance (`server:<instance>`), there is no per-agent or per-holder limit, and the payload is a brief,
- * the run's token and its skills (read in the run's sandbox, `online/sandbox.ts`), without directories, variables or
- * mounts.
+ * 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, policyAllowsAgent, policyAllowsRepo, policyAllowsSubject, TIMINGS, } from '@nocobase/agent-protocol';
-import { runsTool, toolLimit } from '../../../shared/runners.js';
+import { GLOBAL_SKILL_TARGET } from '../../../shared/skills.js';
+import { ANNOUNCED_FAILURES, isProtocolSupported, policyAllowsAgent, policyAllowsRepo, policyAllowsSubject, TIMINGS, } from '@nocobase/agent-protocol';
+import { runnerLowOnDisk, runsEntry, toolLimit, supportsWorkspaceKey, } from '../../../shared/runners.js';
+import { queueStart } from './selection.js';
 import { createHash } from 'node:crypto';
-import { onlineEntriesOrDefault, runnerEntries, sameEntry, } from '../../../shared/agents.js';
 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 { consultSection, } from '../consultations/index.js';
-import { joinBrief, onlineSkillsSection, renderBrief, } from '../brief/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';
 import { describeVariables, variableRefs, } from '../variables/index.js';
 import { mountsFor, prepareExtensions, repoAccessFor, sessionKeyOf, withSections, } from './extensions.js';
-import { dialectOf, } from './ports.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 { 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;
-/** Whether a run holder id is an application instance's (an online run's), not a runner's. */
-export function isServerHolder(runnerId) {
-    return runnerId !== null && runnerId.startsWith('server:');
-}
 class AssemblyError extends Error {
     cause;
     constructor(message, cause) {
@@ -101,57 +103,50 @@ function toolRoom(tools) {
     };
 }
 /**
- * The entry `runner` takes a run of `agent` with: the first whose tool it has enabled, installed and signed in. Null
- * when it has none of them, and always for an online agent, which has no tool.
+ * The entry `runner` takes a run of `agent` with: the first whose tool it has enabled, installed and signed in, with
+ * the entry's model among those it reports (`runsEntry`). Null when it has none of them.
  */
-export function pickEntry(runner, agent) {
-    return (runnerEntries(agent).find((entry) => runsTool(runner, entry.tool)) ?? null);
+export function pickEntry(runner, agent, now) {
+    return (agent.modelEntries.find((entry) => runsEntry(runner, entry, now)) ?? null);
 }
 /**
  * The entry `runner` takes a run of `agent` with when some of its tools are full: the first whose tool it runs and
  * `open` says has room. Null when none has.
  */
-export function pickOpenEntry(runner, agent, open) {
-    return (runnerEntries(agent).find((entry) => runsTool(runner, entry.tool) && open(entry.tool)) ?? null);
-}
-/** Whether `runner` has one of `agent`'s tools enabled, installed and signed in; never for an online agent. */
-export function hasTool(runner, agent) {
-    return pickEntry(runner, agent) !== null;
+export function pickOpenEntry(runner, agent, open, now) {
+    return (agent.modelEntries.find((entry) => runsEntry(runner, entry, now) && open(entry.tool)) ?? null);
 }
-/**
- * The entry an online run uses: the one its subject asks for while the agent lists it, else the agent's first; for an
- * agent that lists none, the system default chat model (`fallback`).
- */
-export function onlineEntryOf(agent, wanted, fallback = null) {
-    const entries = onlineEntriesOrDefault(agent, fallback);
-    return ((wanted && entries.find((entry) => sameEntry(entry, wanted))) ??
-        entries[0] ??
-        null);
+/** Whether `runner` has one of `agent`'s tools and models enabled, installed, signed in and reported. */
+export function hasTool(runner, agent, now) {
+    return pickEntry(runner, agent, now) !== null;
 }
 /**
  * Whether `runner` may run work of `agent` as `actorUserId` that needs `requires`, before any lock is taken and before
- * a payload is known: the agent's tool signed in there, its owner's policy, the agent's named runners, and trust.
+ * a payload is known: the agent enabled, its tool and model reported there, its owner's policy, and trust.
  */
-export function fitsActor(runner, agent, actorUserId, requires) {
-    if (agent.archivedAt || agent.type !== 'runner')
+export function fitsActor(runner, agent, actorUserId, requires, now) {
+    if (agent.status !== 'enabled' || runnerLowOnDisk(runner))
+        return false;
+    if (!isProtocolSupported(runner.protocolVersion) ||
+        runner.status === 'upgrade_required' ||
+        runner.status === 'revoked')
         return false;
     if (!covers(runner.features, requires))
         return false;
-    if (!hasTool(runner, agent))
+    if (!hasTool(runner, agent, now))
         return false;
     if (!policyAllowsAgent(runner.policy, agent))
         return false;
-    if (agent.runnerIds.length > 0 && !agent.runnerIds.includes(runner.id))
-        return false;
     return runner.trust === 'team' || runner.ownerUserId === actorUserId;
 }
 /** Whether `runner` may run `run` of `agent`, before any lock is taken and before its payload is known. */
-export function fits(runner, agent, run) {
-    return fitsActor(runner, agent, run.actorUserId, toRun(run).requires);
+export function fits(runner, agent, run, now) {
+    return fitsActor(runner, agent, run.actorUserId, toRun(run).requires, now);
 }
 /** The runner features a payload needs. */
-export function payloadRequires(dirs, skills, variables) {
+export function payloadRequires(dirs, skills, variables, workspaceKey = false) {
     return [
+        ...(workspaceKey ? ['workspaceKey'] : []),
         ...(dirs.some((dir) => dir.kind === 'repo') ? ['checkout'] : []),
         ...(dirs.some((dir) => dir.kind === 'directory')
             ? ['directories']
@@ -175,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 }] : []),
     ];
 }
@@ -198,7 +193,6 @@ function fingerprint(agent, entry, layers, skills) {
 /** The brief for `assembly`, with the skills a run would get. */
 export function briefOf(agent, assembly, skills, cli, appName) {
     const rendered = renderBrief({
-        dialect: dialectOf(agent),
         agentName: agent.name,
         subject: { noun: assembly.subject.noun, key: assembly.subject.key },
         task: assembly.task,
@@ -252,7 +246,226 @@ async function settleClaimInputs(conn, pending, effective, now) {
 }
 export function createClaimService(deps) {
     const { tx, clock } = deps;
-    async function assemble({ conn }, run, agent, runner, inputs, leaseExpiresAt, prepared, entry) {
+    /** 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, resources = claimResources(conn, run.id)) {
+        if (!isProtocolSupported(runner.protocolVersion) ||
+            (assembly.workspaceKey && !supportsWorkspaceKey(runner)))
+            return 'incompatible';
+        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)),
+        ]))
+            return 'incompatible';
+        if (!fitsActor(runner, agent, run.actorUserId, run.requires, clock.now().getTime()) ||
+            !policyAllowsSubject(runner.policy, assembly.subject.key) ||
+            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' && variables.teamOnly.length > 0)
+            return 'restricted';
+        return 'ready';
+    }
+    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)).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}.`);
+        const inputs = (await pendingInputs(conn, run.id)).map(toInput);
+        const active = await countActive(conn, 'agentId', agent.id);
+        const sameWork = (await runsOfKey(conn, {
+            agentId: agent.id,
+            subjectKind: run.subject.kind,
+            subjectId: run.subject.id,
+            threadScope: run.threadScope,
+        }, ACTIVE)).length > 0;
+        const entries = [];
+        for (const entry of agent.modelEntries) {
+            const single = { ...agent, modelEntries: [entry] };
+            const candidates = registered.filter((runner) => runner.status !== 'revoked');
+            const connected = candidates.filter((runner) => (runner.status === 'online' ||
+                runner.status === 'upgrade_required') &&
+                runner.lastSeenAt !== null &&
+                new Date(runner.lastSeenAt).getTime() + TIMINGS.offlineAfterMs >
+                    now.getTime());
+            const installed = connected.filter((runner) => runner.tools.some((tool) => tool.kind === entry.tool));
+            const usable = installed.filter((runner) => runsEntry(runner, entry, clock.now().getTime()));
+            const online = usable.filter((runner) => runner.trust === 'team' || runner.ownerUserId === run.actorUserId);
+            const compatible = [];
+            const loads = [];
+            let unknown = false;
+            let incompatible = false;
+            let ready = false;
+            let directoryBlocked = false;
+            for (const runner of online) {
+                if (!isProtocolSupported(runner.protocolVersion) ||
+                    runner.status === 'upgrade_required') {
+                    incompatible = true;
+                    loads.push({
+                        name: runner.name,
+                        ownerUserId: runner.ownerUserId,
+                        reason: 'incompatible',
+                        lastSeenAt: runner.lastSeenAt,
+                    });
+                    continue;
+                }
+                const assembly = await binding.context
+                    .assemble(conn, {
+                    run: run,
+                    agent,
+                    runner,
+                    inputs,
+                    cli: deps.cli.name,
+                    appName: deps.app.name,
+                })
+                    .catch(() => null);
+                if (!assembly) {
+                    unknown = true;
+                    loads.push({
+                        name: runner.name,
+                        ownerUserId: runner.ownerUserId,
+                        reason: 'unknown',
+                        lastSeenAt: runner.lastSeenAt,
+                    });
+                    continue;
+                }
+                const reason = await assemblyCompatibility(conn, run, single, runner, assembly, resources);
+                if (reason !== 'ready') {
+                    incompatible ||= reason === 'incompatible';
+                    loads.push({
+                        name: runner.name,
+                        ownerUserId: runner.ownerUserId,
+                        reason,
+                        lastSeenAt: runner.lastSeenAt,
+                    });
+                    continue;
+                }
+                const requiredVariables = (await resources(single, assembly)).variables
+                    .passthrough;
+                if (requiredVariables.length > 0 && runner.variables == null) {
+                    unknown = true;
+                    continue;
+                }
+                if (requiredVariables.some((name) => !runner.variables?.includes(name)))
+                    continue;
+                compatible.push(runner);
+                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));
+                directoryBlocked ||= blockedDirectory;
+                const hasRoom = !runner.draining &&
+                    (runner.globalFree ?? 1) > 0 &&
+                    used < runner.slots &&
+                    (byTool[entry.tool] ?? 0) < toolLimit(runner, entry.tool) &&
+                    (runner.toolLoad?.[entry.tool]?.free ?? 1) > 0 &&
+                    !blockedDirectory;
+                ready ||= hasRoom && runner.globalFree !== undefined;
+                if (hasRoom && runner.globalFree === undefined)
+                    unknown = true;
+                loads.push({
+                    name: runner.name,
+                    ownerUserId: runner.ownerUserId,
+                    reason: hasRoom
+                        ? runner.globalFree === undefined
+                            ? 'unknown'
+                            : 'ready'
+                        : runner.draining
+                            ? runner.draining
+                            : blockedDirectory
+                                ? 'restricted'
+                                : 'busy',
+                    lastSeenAt: runner.lastSeenAt,
+                    used,
+                    limit: runner.slots,
+                    toolUsed: byTool[entry.tool] ?? 0,
+                    toolLimit: toolLimit(runner, entry.tool),
+                    reportedFree: runner.toolLoad?.[entry.tool]?.free,
+                    reportedTotalFree: runner.globalFree,
+                });
+            }
+            let reason = compatible.length
+                ? ready
+                    ? 'ready'
+                    : 'busy'
+                : online.length
+                    ? incompatible
+                        ? 'incompatible'
+                        : 'restricted'
+                    : usable.length
+                        ? 'noSharedRunner'
+                        : installed.length
+                            ? 'toolUnavailable'
+                            : connected.length
+                                ? 'toolNotInstalled'
+                                : 'offline';
+            if (directoryBlocked && !ready)
+                reason = 'restricted';
+            if (!ready &&
+                compatible.length > 0 &&
+                loads.every((runner) => runner.reason === 'updatePending' || runner.reason === 'pruning'))
+                reason = loads.some((runner) => runner.reason === 'updatePending')
+                    ? 'updatePending'
+                    : 'pruning';
+            if (unknown &&
+                !ready &&
+                !loads.some((runner) => runner.reason === 'busy'))
+                reason = 'unknown';
+            if (compatible.length && sameWork)
+                reason = 'sameWorkActive';
+            else if (compatible.length && active >= agent.maxConcurrentRuns)
+                reason = 'concurrencyFull';
+            else if (start > now.getTime())
+                reason = 'delayed';
+            entries.push({
+                tool: entry.tool,
+                model: entry.model,
+                reason,
+                compatibleCount: compatible.length,
+                blockers: [
+                    ...(unknown ? ['unknown'] : []),
+                    ...new Set(loads
+                        .map((runner) => runner.reason)
+                        .filter((reason) => reason !== undefined && reason !== 'ready')),
+                ],
+                runners: loads,
+            });
+        }
+        return {
+            queueEnteredAt: new Date(start).toISOString(),
+            fallbackAfterSeconds: policy?.fallbackAfterSeconds ?? 0,
+            sampledAt: now.toISOString(),
+            entries,
+        };
+    }
+    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}".`);
@@ -264,9 +477,11 @@ export function createClaimService(deps) {
             inputs,
             cli: deps.cli.name,
             appName: deps.app.name,
-            dialect: 'cli',
         };
-        const assembly = await binding.context.assemble(conn, claim);
+        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, resources)) === 'incompatible')
+            throw new NotForThisRunner();
         inputs = assembly.inputs ?? inputs;
         const effectiveClaim = { ...claim, inputs };
         // Its owner's local policy keeps this runner off the subject, or off one of the repositories: another runner takes
@@ -282,30 +497,29 @@ 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),
+            ...payloadRequires(dirs, skills.length, names.length, Boolean(assembly.workspaceKey)),
         ]);
         if (!covers(runner.features, requires))
             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({
@@ -352,6 +566,11 @@ export function createClaimService(deps) {
         const sessionNote = resume ? assembly.turn.resumed : assembly.turn.fresh;
         const turn = [
             brief.turn,
+            ...(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.',
+                ]
+                : []),
             ...resumeNotes,
             ...(sessionNote ? [sessionNote] : []),
         ].join('\n\n');
@@ -395,10 +614,13 @@ export function createClaimService(deps) {
             },
             inputs,
             workspace: {
+                sessionScope: run.threadScope,
                 dirs,
                 env,
                 ...(passthrough.length > 0 ? { passthrough } : {}),
                 ...(clean ? { clean: true } : {}),
+                ...(assembly.workspaceKey ? { key: assembly.workspaceKey } : {}),
+                ...(assembly.readOnly ? { readOnly: true } : {}),
                 ...(git ? { git } : {}),
             },
             skills,
@@ -465,18 +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,
-            dialect: dialectOf(agent),
-        });
+        }, prepared);
         if (!rejection)
             return true;
         await finishRun(unit, deps, run, {
@@ -487,62 +866,144 @@ export function createClaimService(deps) {
         return false;
     }
     async function attempt(runner, agent, candidate, reported) {
-        // 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 ||
+        // 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);
+                return run?.status === 'queued'
+                    ? refreshQueuedIdentity(unit, deps, run)
+                    : null;
+            });
+            if (!current)
+                return { kind: 'skipped' };
+            candidate = current;
+        }
+        // Avoid assembling or asking authorization when a cheap claim rule already rules this work out.
+        if (!fits(runner, agent, candidate, clock.now().getTime()) ||
             (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 = await prepareExtensions(toRun(candidate), deps.sections, deps.mounts, (error) => deps.onClaimFailure?.(candidate.id, error), deps.repoAccess, { onDemand: asksCredentialsOnDemand(runner) });
+        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;
+        if (subjectContext?.prepare) {
+            try {
+                prepared.set('subject', await subjectContext.prepare(toRun(candidate)));
+            }
+            catch (error) {
+                deps.onClaimFailure?.(candidate.id, error);
+            }
+        }
         let taken;
+        let runnerFull = false;
         try {
             taken = await tx.run(async (unit) => {
                 const { conn } = unit;
                 const now = clock.now();
                 const nowText = now.toISOString();
                 await lockAgentForClaim(conn, agent.id, nowText);
+                const queuedRun = await findRunRecord(conn, candidate.id);
+                if (!queuedRun || queuedRun.status !== 'queued')
+                    return null;
+                const identity = await refreshQueuedIdentity(unit, deps, queuedRun);
+                // Providers were prepared for the candidate's identity outside this transaction.
+                if (!identity || identity.actorUserId !== candidate.actorUserId)
+                    return null;
                 if ((await countActive(conn, 'agentId', agent.id)) >=
                     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;
+                }
+                // 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 &&
+                        new Date(current.availableAt).getTime() > now.getTime()))
                     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 entry = pickOpenEntry(runner, agent, (tool) => (byTool[tool] ?? 0) < toolLimit(runner, tool) && reported.has(tool));
+                const entry = pickOpenEntry(runner, agent, (tool) => (byTool[tool] ?? 0) < toolLimit(runner, tool) && reported.has(tool), now.getTime());
                 if (!entry)
                     return null;
                 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,
-                        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;
-                    assembled = await assemble(unit, run, agent, runner, pending.map(toInput), leaseExpiresAt, prepared, entry);
+                    // Admission must precede preflight assembly: a missing or obsolete
+                    // subject is cancelled normally, rather than counted as setup failure.
+                    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' ||
+                        selection?.entries[0]?.blockers?.includes('unknown') === true;
+                    const chosenIndex = agent.modelEntries.indexOf(entry);
+                    if (selection && chosenIndex > 0) {
+                        // Throw to roll back the provisional dispatch; the original run keeps
+                        // waiting for its first choice without consuming an attempt or token.
+                        if (preferredAvailable && elapsed < selection.fallbackAfterSeconds)
+                            throw new NotForThisRunner();
+                        selectionSnapshot = {
+                            reason: preferredAvailable
+                                ? 'preferredQueued'
+                                : 'preferredUnavailable',
+                            preferredTool: agent.modelEntries[0].tool,
+                            preferredModel: agent.modelEntries[0].model,
+                            queueEnteredAt: selection.queueEnteredAt,
+                            waitedSeconds: elapsed,
+                        };
+                    }
+                    assembled = await assemble(unit, run, agent, runner, pending.map(toInput), leaseExpiresAt, prepared, entry, resources);
                 }
                 catch (error) {
                     if (error instanceof NotForThisRunner)
@@ -558,6 +1019,7 @@ export function createClaimService(deps) {
                         directoryKey: assembled.directoryKey,
                         tool: assembled.entry.tool,
                         executionHistory: executionHistory(run, {
+                            ...(selectionSnapshot ? { selection: selectionSnapshot } : {}),
                             attempt: Number(run.attempt),
                             runnerId: runner.id,
                             runnerName: runner.name,
@@ -608,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) {
@@ -642,20 +1111,18 @@ export function createClaimService(deps) {
                 filter: { id: runId },
                 values: {
                     claimFailures: failures,
+                    failureReason: 'setupFailed',
                     failureDetail: error.message.slice(0, 10_000),
                 },
             });
         });
     }
-    /** Queued runs of agents of `type` that may be claimed now, in claim order. */
-    async function candidatesOf(type) {
+    /** Queued runs that may be claimed now, in claim order. */
+    async function candidates() {
         const now = clock.now();
         return runsRepo(tx.read()).findMany({
             filter: (f) => f.and([
                 f.string('status').eq('queued'),
-                f.string('agentType').eq(type),
-                // A consultation is taken by the holder of the run that asked it, never from the queue.
-                f.string('parentRunId').empty(),
                 f.or([
                     f.date('availableAt').empty(),
                     f.date('availableAt').notAfter(now),
@@ -669,180 +1136,38 @@ export function createClaimService(deps) {
             limit: CANDIDATES,
         });
     }
-    /** Takes an online run for `holder` in one transaction, or skips it when another holder or run got there first. */
-    async function attemptServer(holder, agent, candidate) {
-        const prepared = await prepareExtensions(toRun(candidate), deps.sections, undefined, (error) => deps.onClaimFailure?.(candidate.id, error));
-        return tx.run(async (unit) => {
-            const { conn } = unit;
-            const now = clock.now();
-            const nowText = now.toISOString();
-            // Serializes claims and enqueues of this agent, so one key never has two runs held.
-            await lockAgentForClaim(conn, agent.id, nowText);
-            if ((await runsOfKey(conn, candidate, ACTIVE)).length > 0)
-                return null;
-            const leaseExpiresAt = later(now, TIMINGS.leaseMs);
-            const taken = await runsRepo(conn).updateMany({
-                filter: (f) => f.and([
-                    f.string('id').eq(candidate.id),
-                    f.string('status').eq('queued'),
-                ]),
-                values: {
-                    status: 'dispatched',
-                    runnerId: holder.id,
-                    leaseExpiresAt,
-                    dispatchedAt: nowText,
-                    lastActivityAt: nowText,
-                    availableAt: null,
-                    updatedAt: nowText,
-                },
-            });
-            if (taken.updatedCount !== 1)
-                return null;
-            const run = (await findRunRecord(conn, candidate.id));
-            const pending = await pendingInputs(conn, run.id);
-            const inputs = pending.map(toInput);
-            let claimed;
-            try {
-                if (!(await admit(unit, run, agent, null, inputs)))
-                    return null;
-                claimed = await assembleServer(unit, run, agent, holder, inputs, leaseExpiresAt, prepared);
-            }
-            catch (error) {
-                throw new AssemblyError(error instanceof Error ? error.message : String(error), error);
-            }
-            await settleClaimInputs(conn, pending, claimed.inputs, nowText);
-            await runsRepo(conn).updateMany({
-                filter: { id: run.id },
-                values: {
-                    tool: null,
-                    executionHistory: executionHistory(run, {
-                        attempt: Number(run.attempt),
-                        runnerId: holder.id,
-                        runnerName: null,
-                        runnerOwnerUserId: null,
-                        runnerOwnerName: null,
-                        runnerTrust: null,
-                        tool: null,
-                        toolVersion: null,
-                        modelService: claimed.model?.modelService ?? null,
-                        model: claimed.model?.model ?? null,
-                        actualModels: [],
-                        effort: claimed.model?.effort ?? null,
-                        dispatchedAt: nowText,
-                        finishedAt: null,
-                        failureReason: null,
-                    }),
-                    modelService: claimed.model?.modelService ?? null,
-                    model: claimed.model?.model ?? null,
-                    effort: claimed.model?.effort ?? null,
-                },
-            });
-            unit.emit({ type: 'run.changed', runId: run.id, status: 'dispatched' });
-            return {
-                ...claimed,
-                run: {
-                    ...claimed.run,
-                    tool: null,
-                    modelService: claimed.model?.modelService ?? null,
-                    model: claimed.model?.model ?? null,
-                    effort: claimed.model?.effort ?? null,
-                },
-            };
-        });
-    }
-    async function assembleServer({ conn }, run, agent, holder, inputs, leaseExpiresAt, prepared) {
-        const binding = deps.subjects.get(run.subjectKind);
-        if (!binding)
-            throw new Error(`No context provider is registered for subjects of kind "${run.subjectKind}".`);
-        const view = toRun(run);
-        const claim = {
-            run: view,
-            agent,
-            runner: null,
-            inputs,
-            cli: deps.cli.name,
-            appName: deps.app.name,
-            dialect: 'tools',
-        };
-        const assembly = await binding.context.assemble(conn, claim);
-        inputs = assembly.inputs ?? inputs;
-        const effectiveClaim = { ...claim, inputs };
-        if (assembly.dirs.length > 0)
-            throw new Error('An online agent has no working directory, and this work needs one.');
-        const skills = await deps.skills.forRun(conn, skillTargets(agent, assembly), run.id);
-        const own = new Set(skills.map((skill) => skill.slug));
-        const rendered = briefOf(agent, await withSections(conn, deps.sections, effectiveClaim, assembly, prepared), [], deps.cli.name, deps.app.name);
-        // The skills an online run reads through its tools, and the agents it may consult, whatever system layer its
-        // subject gives it.
-        const consultable = (await deps.consultations?.targets(conn, run, agent)) ?? [];
-        const depth = run.parentRunId
-            ? ((await deps.consultations?.chain(conn, run))?.length ?? 1) - 1
-            : 0;
-        const section = [
-            ...onlineSkillsSection([
-                ...skills,
-                ...(deps.onlineSkills?.() ?? []).filter((skill) => !own.has(skill.slug)),
-            ]),
-            ...(consultable.length > 0 ? ['', ...consultSection(consultable)] : []),
-        ];
-        const layers = section.length > 0
-            ? {
-                ...rendered.layers,
-                system: [rendered.layers.system, '', ...section].join('\n'),
-            }
-            : rendered.layers;
-        const brief = { ...rendered, layers, prompt: joinBrief(layers) };
-        const token = await mintRunToken(conn, deps, run, holder.id);
-        deps.secrets?.remember(runSecretsKey(run.id), [token.value]);
-        const last = await eventsRepo(conn).findOne({
-            filter: { runId: run.id },
-            sort: (sort) => sort.field('seq').desc(),
-        });
-        await saveBrief(conn, () => deps.ids.next(), {
-            runId: run.id,
-            attempt: Number(run.attempt),
-            layers: brief.layers,
-            turn: brief.turn,
-            prompt: brief.prompt,
-            createdAt: clock.now().toISOString(),
-        });
-        return {
-            runId: run.id,
-            attempt: Number(run.attempt),
-            agent,
-            run: view,
-            model: onlineEntryOf(agent, assembly.model, (await deps.defaultModel?.(conn)) ?? null),
-            system: brief.prompt,
-            turn: brief.turn,
-            inputs,
-            token: token.value,
-            skills,
-            leaseExpiresAt,
-            firstSeq: (last ? Number(last.seq) : 0) + 1,
-            consultable,
-            depth,
-        };
-    }
     async function claimOne(runner, seen, reported) {
+        if (runner.draining)
+            return null;
         const conn = tx.read();
-        const candidates = await candidatesOf('runner');
-        const agents = new Map();
-        for (const candidate of candidates) {
-            if (seen.has(candidate.id))
+        const queued = await candidates();
+        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) || 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 || !fits(runner, agent, candidate))
+            if (!agent ||
+                (!deps.subjects.get(candidate.subjectKind)?.actsAs &&
+                    !fits(runner, agent, candidate, clock.now().getTime())))
                 continue;
             // None of its tools has room on the runner's side: the runs behind it may still fit.
-            if (!pickOpenEntry(runner, agent, (tool) => reported.has(tool)))
+            if (!pickOpenEntry(runner, agent, (tool) => reported.has(tool), clock.now().getTime()))
                 continue;
             try {
                 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.
@@ -856,16 +1181,57 @@ 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();
+            const run = await findRunRecord(conn, runId);
+            if (!run || run.status !== 'queued')
+                return null;
+            const agent = await findAgent(conn, run.agentId);
+            return agent ? selectionFacts(conn, toRun(run), agent, false) : null;
+        },
         async claim(runner, free, tools) {
-            if (runner.status !== 'online')
-                return [];
-            if ((await deps.slotsUsed(tx.read(), runner.id)) >= runner.slots)
+            if (runner.status !== 'online' || runnerLowOnDisk(runner))
                 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;
@@ -874,64 +1240,6 @@ export function createClaimService(deps) {
             }
             return payloads;
         },
-        async claimServer(holder, limit) {
-            const claimed = [];
-            const conn = tx.read();
-            const agents = new Map();
-            for (const candidate of await candidatesOf('online')) {
-                if (claimed.length >= limit)
-                    break;
-                if (!agents.has(candidate.agentId))
-                    agents.set(candidate.agentId, await findAgent(conn, candidate.agentId));
-                const agent = agents.get(candidate.agentId);
-                if (!agent || agent.archivedAt || agent.type !== 'online')
-                    continue;
-                try {
-                    const taken = await attemptServer(holder, agent, candidate);
-                    if (taken)
-                        claimed.push(taken);
-                }
-                catch (error) {
-                    if (!(error instanceof AssemblyError))
-                        throw error;
-                    await recordFailure(candidate.id, error);
-                }
-            }
-            return claimed;
-        },
-        async claimChild(holder, runId) {
-            const conn = tx.read();
-            const candidate = await findRunRecord(conn, runId);
-            if (!candidate?.parentRunId || candidate.status !== 'queued')
-                throw notFound('Run');
-            const parent = await findRunRecord(conn, candidate.parentRunId);
-            if (parent?.runnerId !== holder.id)
-                throw notFound('Run');
-            const agent = await findAgent(conn, candidate.agentId);
-            if (!agent || agent.archivedAt || agent.type !== 'online')
-                throw notFound('Agent');
-            try {
-                const taken = await attemptServer(holder, agent, candidate);
-                if (!taken)
-                    throw notFound('Run');
-                return taken;
-            }
-            catch (error) {
-                if (!(error instanceof AssemblyError))
-                    throw error;
-                // One attempt: a consultation that cannot be assembled fails at once.
-                await tx.run(async (unit) => {
-                    const run = await findRunRecord(unit.conn, runId);
-                    if (run)
-                        await finishRun(unit, deps, run, {
-                            status: 'failed',
-                            reason: 'setupFailed',
-                            detail: error.message,
-                        });
-                });
-                throw error;
-            }
-        },
         async runSkills(runner, runId) {
             const conn = tx.read();
             const run = await findRunRecord(conn, runId);
@@ -948,8 +1256,7 @@ export function createClaimService(deps) {
                 inputs: [],
                 cli: deps.cli.name,
                 appName: deps.app.name,
-                dialect: dialectOf(agent),
-            });
+            }, await binding.context.prepare?.(toRun(run)));
             return deps.skills.forRun(conn, skillTargets(agent, assembly), run.id);
         },
     };