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

package/dist/server/core/runs/claim.d.ts

@@ -29,6 +29,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 { type AgentTool, type RunApp, type RunnerFeature, type RunPayload, type RunSkill, type WorkspaceDir } from '@nocobase/agent-protocol';
@@ -42,7 +52,7 @@ import { type Clock } from '../../kernel/clock.js';
 import type { People } from '../../kernel/people.js';
 import type { IdSource } from '../../kernel/ids.js';
 import { type SecretMemory } from '../../kernel/redaction.js';
-import type { TxRunner } from '../../kernel/tx.js';
+import type { Tx, TxRunner } from '../../kernel/tx.js';
 import type { SkillService, SkillTarget } from '../skills/index.js';
 import { type VariableService, type VariableTarget } from '../variables/index.js';
 import { type RepoAccessRegistry, type BriefSectionRegistry, type RunMountRegistry } from './extensions.js';
@@ -51,6 +61,8 @@ import { type AgentCli } from './policy.js';
 import { type RunRecord } from './run.store.js';
 import { type TransitionDeps } from './transitions.js';
 export interface ClaimService {
+    reconcileCommentConsent(unit: Tx, runId: string): Promise<void>;
+    reconcileCommentQueue(): Promise<void>;
     /** Structured ordered-model diagnostics; machine visibility is enforced by the caller. */
     selectionWait(runId: string): Promise<import('../../../shared/runs.js').ModelSelectionWait | null>;
     /** Read-only capacity and compatibility for a real subject and candidate agent, as the run's actor. */
@@ -120,8 +132,8 @@ export declare function payloadRequires(dirs: readonly WorkspaceDir[], skills: n
 export declare function payloadDirs(dirs: readonly SubjectDir[]): WorkspaceDir[];
 /** Where a run's variables come from, in merge order: the subject's scopes, its directories', the agent's. */
 export declare function variableTargets(agent: Pick<Agent, 'id'>, assembly: Pick<SubjectAssembly, 'scopes' | 'dirs'>): VariableTarget[];
-/** Where a run's skills come from, the agent's first so its own win a shared slug. */
-export declare function skillTargets(agent: Pick<Agent, 'id'>, assembly: Pick<SubjectAssembly, 'scopes' | 'dirs'>): SkillTarget[];
+/** Team defaults, application scopes and directories, from lowest to highest priority. */
+export declare function skillTargets(_agent: Pick<Agent, 'id'>, assembly: Pick<SubjectAssembly, 'scopes' | 'dirs'>): SkillTarget[];
 /** The brief of a run on a subject, as the claim renders it; the preview renders it the same way. */
 export interface RenderedBrief {
     readonly layers: BriefLayers;

package/dist/server/core/runs/claim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../../../server/core/runs/claim.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../../../server/core/runs/claim.ts"],"names":[],"mappings":"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"}

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,7 +49,7 @@ 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 { cleanList, covers, jsonObject } from '../../kernel/values.js';
 import { findAgent, lockAgentForClaim } from '../agents/index.js';
 import { joinBrief, renderBrief } from '../brief/index.js';
 import { cliPackageFor } from './cli-package.js';
@@ -48,10 +59,12 @@ import { mountsFor, prepareExtensions, repoAccessFor, sessionKeyOf, withSections
 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 +171,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 }] : []),
     ];
 }
@@ -257,13 +270,14 @@ export function createClaimService(deps) {
             return 'restricted';
         return 'ready';
     }
-    async function selectionFacts(conn, run, agent, requirePolicy = true) {
+    async function selectionFacts(conn, run, agent, requirePolicy = true, trust) {
         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}.`);
@@ -536,7 +550,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 +671,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 +850,17 @@ 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 deps.slotsUsed(conn, runner.id)) >= runner.slots)
+            return { kind: 'full', scope: 'runner' };
+        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 +873,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;
@@ -753,6 +933,8 @@ export function createClaimService(deps) {
                     ]),
                     values: {
                         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.
@@ -762,16 +944,21 @@ export function createClaimService(deps) {
                         lastActivityAt: nowText,
                         availableAt: null,
                         updatedAt: nowText,
+                        ...(consent.confirmedByUserId
+                            ? { confirmedByUserId: consent.confirmedByUserId }
+                            : {}),
                     },
                 });
                 if (claimed.updatedCount !== 1)
                     return null;
                 const run = (await findRunRecord(conn, candidate.id));
-                const pending = await pendingInputs(conn, run.id);
+                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.
@@ -865,6 +1052,11 @@ export function createClaimService(deps) {
             await discardRepoAccess(candidate, prepared);
             return { 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 +1089,7 @@ export function createClaimService(deps) {
                 filter: { id: runId },
                 values: {
                     claimFailures: failures,
+                    failureReason: 'setupFailed',
                     failureDetail: error.message.slice(0, 10_000),
                 },
             });
@@ -927,8 +1120,9 @@ export function createClaimService(deps) {
         const conn = tx.read();
         const queued = await candidates();
         const agents = new Map();
+        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))
@@ -945,6 +1139,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 +1159,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();