@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/dist/src/task-driver.js

@@ -38,6 +38,7 @@ export class TaskDriver {
         this.active = this.tick()
             .catch((error) => {
             // A persistence failure cannot authorize more work. Fence all affected task workers.
+            this.children.external?.failAll(error);
             for (const row of this.store.db.prepare('SELECT session_id FROM durable_tasks').all())
                 this.supervisor.failControl(String(row.session_id), error);
         })
@@ -119,7 +120,7 @@ export class TaskDriver {
     }
     async stopActive(task) {
         const attempts = this.store.db
-            .prepare("SELECT id,state,submission_id FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running')")
+            .prepare("SELECT id,state,submission_id FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running','delegated')")
             .all(task.session_id);
         this.store.transaction(() => {
             for (const attempt of attempts) {
@@ -144,6 +145,7 @@ export class TaskDriver {
             await this.children.cancelOwned(attempt.id);
             await this.supervisor.cancelAttempt(attempt.id);
         }
+        await this.children.external?.cancelRoot(task.session_id);
         const compactions = this.store.db
             .prepare("SELECT id FROM compactions WHERE session_id=? AND state='running'")
             .all(task.session_id);
@@ -164,7 +166,7 @@ export class TaskDriver {
         return this.tasks.get(id);
     }
     /** Revocation is durable before any process abort, including a job cancellation. */
-    cancelInTransaction(id, expected, authorize) {
+    cancelInTransaction(id, expected, authorize, peer) {
         if (!this.store.db.isTransaction)
             throw new Error('Task cancellation requires a transaction');
         authorize();
@@ -174,10 +176,16 @@ export class TaskDriver {
         if (['succeeded', 'succeeded_with_exception', 'cancelled'].includes(task.state))
             throw new ServiceError('task_settled', 'Task already settled');
         this.store.db.prepare('UPDATE task_runtime SET auto_enabled=0 WHERE task_id=?').run(id);
+        this.children.cancelSessionInTransaction(task.session_id);
         this.store.db
-            .prepare("UPDATE durable_tasks SET state='cancelled',reason='Operator cancelled the task; inspect any uncertain effects',revision=revision+1 WHERE id=?")
-            .run(id);
-        this.store.event(task.session_id, 'work_task.cancelled', { task_id: id });
+            .prepare("UPDATE durable_tasks SET state='cancelled',reason=?,revision=revision+1 WHERE id=?")
+            .run(peer
+            ? 'Authenticated peer cancelled its dedicated task; inspect any uncertain effects'
+            : 'Operator cancelled the task; inspect any uncertain effects', id);
+        this.store.event(task.session_id, 'work_task.cancelled', {
+            task_id: id,
+            ...(peer ? { peer } : {}),
+        });
         return { id };
     }
     async stopCancelled(id) {
@@ -288,15 +296,24 @@ export class TaskDriver {
             this.stop(task, 'An interrupted or failed step requires explicit operator review');
             return;
         }
-        if (this.budget.active(task) > 0) {
-            const accepted = task.steps.some((s) => s.state === 'queued');
+        const active = this.budget.active(task);
+        if (active > 0) {
+            const accepted = task.steps.some((s) => s.state === 'queued' && !this.tasks.delegatedStep?.(task.id, s.id));
             if (accepted &&
                 !['ready', 'starting'].includes(this.supervisor.inspect(task.session_id).state))
                 await this.worker(task);
-            return;
+            const rootActive = this.store.db
+                .prepare("SELECT 1 FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running')")
+                .get(task.session_id);
+            if (rootActive ||
+                active >= task.limits.concurrency ||
+                this.children.activeCount(task.session_id) >= 2 ||
+                this.children.activeCount() >= 8)
+                return;
         }
         const reviewing = task.steps.find((s) => s.state === 'awaiting_review');
-        if (reviewing) {
+        if (reviewing && !active) {
+            this.tasks.assertStepReview?.(task.id, reviewing.id);
             if (!reviewing.checks?.length) {
                 this.stop(task, 'Step requires operator review');
                 return;
@@ -322,19 +339,26 @@ export class TaskDriver {
             return;
         }
         if (Number(r.remaining_steps) < 1) {
+            if (active)
+                return;
             this.stop(task, 'Bounded progression step limit reached');
             return;
         }
         this.tasks.assertProgressionBinding?.(task, String(r.auto_binding));
         const next = task.steps.find((s) => s.state === 'pending' &&
+            (!active || this.tasks.delegatedStep?.(task.id, s.id)) &&
             s.depends_on.every((k) => task.steps.find((p) => p.key === k)?.state === 'completed'));
         if (!next) {
+            if (active)
+                return;
             this.stop(task, 'No eligible step; inspect the plan');
             return;
         }
-        if (!(await this.worker(task)) || this.stopped)
+        const assigned = this.tasks.delegatedStep?.(task.id, next.id);
+        if ((!assigned && !(await this.worker(task))) || this.stopped)
             return;
-        if (r.auto_compact &&
+        if (!assigned &&
+            r.auto_compact &&
             task.steps.some((s) => s.state === 'completed') &&
             !this.compact(task, next.id))
             return;
@@ -377,8 +401,8 @@ export class TaskDriver {
             if (task.steps.some((s) => ['queued', 'running'].includes(s.state)) && !r.blocked_reason) {
                 let state = 'running', reason = 'Explicit step attempt in progress';
                 if (this.store.db
-                    .prepare("SELECT 1 FROM approvals WHERE session_id=? AND state='pending'")
-                    .get(task.session_id)) {
+                    .prepare("SELECT 1 FROM approvals WHERE state='pending' AND (session_id=? OR session_id IN (SELECT child_session FROM child_tasks WHERE parent_session=?))")
+                    .get(task.session_id, task.session_id)) {
                     state = 'waiting_for_person';
                     reason = 'An operation-bound human approval is pending';
                 }
@@ -386,7 +410,7 @@ export class TaskDriver {
                     .prepare("SELECT 1 FROM child_tasks WHERE parent_session=? AND state='accepted'")
                     .get(task.session_id)) {
                     state = 'waiting_for_child';
-                    reason = 'Read-only child work is pending';
+                    reason = 'A child worker is pending';
                 }
                 else if (this.supervisor.inspect(task.session_id).state !== 'ready') {
                     state = 'waiting_for_infrastructure';

package/dist/src/task-policy.js

@@ -41,11 +41,30 @@ export function taskPolicy(value) {
         output_token_bound: 8192,
         verification_runs: 256,
     };
+    // Explicit opt-out; omitted limits retain the existing capped defaults.
+    if (input.token_units === null) {
+        limits.token_units = null;
+        if (input.output_token_bound === undefined)
+            limits.output_token_bound = null;
+    }
     for (const key of Object.keys(limits)) {
+        if ((key === 'token_units' || key === 'output_token_bound') && input[key] === null) {
+            limits[key] = null;
+            continue;
+        }
         if (input[key] !== undefined)
             limits[key] = integer(input[key], key);
-        if (limits[key] < 1 || limits[key] > max[key])
+        const bound = limits[key];
+        if (bound !== null && bound !== undefined && (bound < 1 || bound > max[key]))
             throw new ServiceError('invalid_budget', 'Task limit out of range: ' + key, 400);
     }
+    if (limits.output_token_bound === null && limits.token_units !== null)
+        throw new ServiceError('invalid_budget', 'A token budget requires an output token bound', 400);
+    if (input.invocations !== undefined) {
+        const n = integer(input.invocations, 'invocations');
+        if (n < 1 || n > 64)
+            throw new ServiceError('invalid_budget', 'Invocation limit must be 1–64', 400);
+        limits.invocations = n;
+    }
     return { acceptance, deliverables, limits };
 }

package/dist/src/task-verification.js

@@ -78,6 +78,8 @@ export class TaskVerification {
                 !task.steps.some((s) => s.id === step && s.state === 'awaiting_review' && s.checks?.includes(key)))
                 throw new ServiceError('invalid_check', 'Step does not await this configured check');
             const w = this.workspaces.verify(task.session_id);
+            if (step)
+                this.tasks.assertStepReview?.(task.id, step);
             if (!this.coding.executor)
                 throw new ServiceError('verification_unavailable', 'No proven verification executor');
             this.budget.verification(task);
@@ -270,6 +272,7 @@ export class TaskVerification {
                 return;
             if (step?.state !== 'awaiting_review' || !step.checks?.length)
                 throw new ServiceError('verification_required', 'Step requires configured checks');
+            this.tasks.assertStepReview?.(current.id, stepId);
             this.assertIdle(current);
             const receipts = step.checks.map((key) => this.latest(current, key, stepId));
             if (receipts.some((r) => !r || !this.fresh(r)))

package/dist/src/task-work.js

@@ -5,8 +5,12 @@ import { canonical, object, ServiceError, string, } from './protocol.js';
 export class TaskWork {
     store;
     context;
+    providerCheck;
     assertLimits;
     assertProgressionBinding;
+    delegatedStep;
+    advanceDelegate;
+    assertStepReview;
     authorizeGrant(task, step, grant) {
         const row = this.store.db
             .prepare('SELECT * FROM task_grants WHERE id=? AND task_id=? AND step_id=? AND plan_revision=?')
@@ -34,6 +38,8 @@ export class TaskWork {
         const grant = this.store.db.prepare('SELECT * FROM task_grants WHERE id=?').get(grantId);
         if (!grant)
             throw new ServiceError('not_found', 'Task grant not found', 404);
+        if (this.delegatedStep?.(grant.task_id, grant.step_id))
+            return this.advanceDelegate(grantId);
         return this.run(grant.task_id, grant.step_id, 'task-grant:' + grantId, grant.expected_revision, null, null, null, grantId);
     }
     constructor(store, context) {
@@ -184,6 +190,7 @@ export class TaskWork {
             throw new Error('Task admission requires a transaction');
         const plan = this.parse(input);
         authorize();
+        this.providerCheck?.(plan.limits);
         if (expected !== 0)
             throw new ServiceError('task_revision_conflict', 'New tasks require revision zero');
         this.idle(session);
@@ -225,7 +232,22 @@ export class TaskWork {
             const task = this.get(id);
             this.store.authorizeControl(task.session_id, controller);
             this.expect(task, expected);
+            this.providerCheck?.(plan.limits);
             this.idle(task.session_id);
+            const runtime = this.store.db
+                .prepare('SELECT * FROM task_runtime WHERE task_id=?')
+                .get(id);
+            const invocations = Number(this.store.db
+                .prepare('SELECT count(*) AS n FROM task_invocations WHERE task_id=?')
+                .get(id).n);
+            if (plan.limits.invocations !== undefined && plan.limits.invocations < invocations)
+                throw new ServiceError('invalid_budget', 'Invocation limits cannot discard admitted work');
+            if (task.limits.token_units === null &&
+                plan.limits.token_units !== null &&
+                (Number(runtime.requests_spent) > 0 ||
+                    Number(runtime.reserved_requests) > 0 ||
+                    invocations > 0))
+                throw new ServiceError('invalid_budget', 'Cannot enable token budgeting after uncapped model work is admitted');
             for (const [index, step] of task.steps.entries()) {
                 const next = plan.steps[index];
                 if (!next || next.key !== step.key)
@@ -277,9 +299,12 @@ export class TaskWork {
             else
                 this.authorizeGrant(task, stepId, grantId);
             this.expect(task, expected);
+            this.providerCheck?.(task.limits);
             if (['cancelled', 'succeeded', 'succeeded_with_exception'].includes(task.state))
                 throw new ServiceError('task_settled', 'Revise a settled task before another step');
             const step = task.steps.find((s) => s.id === stepId);
+            if (this.delegatedStep?.(id, stepId))
+                throw new ServiceError('team_step_required', 'Run assigned steps through their durable team assignment');
             if (!step)
                 throw new ServiceError('invalid_step', 'Step does not belong to this task');
             if (!['pending', 'failed', 'interrupted', 'cancelled'].includes(step.state))
@@ -327,6 +352,7 @@ export class TaskWork {
                 !step.attempt_id ||
                 this.store.attempt(step.attempt_id).state !== 'completed')
                 throw new ServiceError('invalid_step_state', 'Only a settled step awaiting operator review can be completed');
+            this.assertStepReview?.(id, step.id);
             this.store.db
                 .prepare("UPDATE task_steps SET state='completed',review=? WHERE id=?")
                 .run(review, step.id);
@@ -354,8 +380,13 @@ export class TaskWork {
             .get(attempt.id);
         if (!row || row.state === 'completed')
             return;
+        if (this.store.db
+            .prepare('SELECT 1 FROM team_rejections WHERE step_id=? AND attempt_id=?')
+            .get(row.id, attempt.id))
+            return;
         const state = {
             accepted: 'queued',
+            delegated: 'queued',
             dispatching: 'running',
             running: 'running',
             completed: 'awaiting_review',

package/dist/src/team-work.js

@@ -0,0 +1,378 @@
+import { randomUUID } from 'node:crypto';
+import { digest, ServiceError } from './protocol.js';
+/** Assignment claims extend the task ledger. They are never an independent scheduler. */
+export class TeamWork {
+    store;
+    tasks;
+    budget;
+    children;
+    profiles;
+    constructor(store, tasks, budget, children, profiles) {
+        this.store = store;
+        this.tasks = tasks;
+        this.budget = budget;
+        this.children = children;
+        this.profiles = profiles;
+        store.workerBoundary.assertAssignment = (binding) => this.assert(binding);
+        store.teamSnapshot = (session) => {
+            const task = tasks.forSession(session);
+            return task ? this.view(task.id) : null;
+        };
+        tasks.delegatedStep = (task, step) => !!this.forStep(task, step);
+        tasks.advanceDelegate = (id) => {
+            const grant = store.db.prepare('SELECT * FROM task_grants WHERE id=?').get(id);
+            const assignment = this.forStep(String(grant.task_id), String(grant.step_id));
+            if (!assignment)
+                throw new ServiceError('team_assignment_missing', 'Step assignment disappeared');
+            return this.run(assignment.id, 'task-grant:' + id, Number(grant.expected_revision), assignment.generation, null, null, null, id);
+        };
+    }
+    forStep(task, step) {
+        return this.store.db
+            .prepare('SELECT * FROM team_assignments WHERE task_id=? AND step_id=? AND superseded=0')
+            .get(task, step);
+    }
+    get(id) {
+        const row = this.store.db
+            .prepare('SELECT * FROM team_assignments WHERE id=?')
+            .get(id);
+        if (!row)
+            throw new ServiceError('not_found', 'Team assignment not found', 404);
+        return row;
+    }
+    expect(task, revision) {
+        if (this.tasks.get(task).revision !== revision)
+            throw new ServiceError('task_revision_conflict', 'Task revision changed');
+    }
+    assign(taskId, stepId, profile, requests, request, expected, controller, runtime) {
+        return this.store.request('local-operator', request, {
+            kind: 'team-assign',
+            taskId,
+            stepId,
+            profile,
+            requests,
+            expected,
+            ...(runtime ? { runtime } : {}),
+        }, () => {
+            const task = this.tasks.get(taskId);
+            this.store.authorizeControl(task.session_id, controller);
+            this.expect(taskId, expected);
+            if (['cancelled', 'succeeded', 'succeeded_with_exception'].includes(task.state))
+                throw new ServiceError('task_settled', 'Revise the task before assigning workers');
+            const step = task.steps.find((s) => s.id === stepId);
+            if (!step || step.attempt_id || step.state !== 'pending')
+                throw new ServiceError('invalid_step_state', 'Assign an unattempted pending step');
+            const old = this.forStep(taskId, stepId);
+            if (old) {
+                if (old.plan_revision === task.plan_revision || old.generation !== 0)
+                    throw new ServiceError('team_assignment_exists', 'An immutable assignment already owns this step');
+                this.store.db.prepare('UPDATE team_assignments SET superseded=1 WHERE id=?').run(old.id);
+            }
+            const grant = this.profiles.resolve(task.session_id, profile);
+            if (!Number.isSafeInteger(requests) ||
+                requests < 1 ||
+                requests > (grant.profile.max_requests ?? 8))
+                throw new ServiceError('invalid_budget', 'Assignment exceeds profile request bounds');
+            const id = randomUUID();
+            this.store.db
+                .prepare('INSERT INTO team_assignments VALUES (?,?,?,?,?,?,?,0,NULL,0)')
+                .run(id, taskId, stepId, task.plan_revision, profile, grant.id, requests);
+            if (runtime) {
+                if (!this.children.external || requests !== 1)
+                    throw new ServiceError('runtime_unavailable', 'External assignments require one invocation and a configured runtime');
+                this.children.external.assign(id, task, runtime, grant.profile.tools);
+            }
+            this.changed(taskId, 'assigned', {
+                assignment_id: id,
+                step_id: stepId,
+                profile_id: profile,
+            });
+            return this.get(id);
+        });
+    }
+    run(id, request, expected, generation, instruction, continuation, controller, grantId, peerAdmission) {
+        let launch;
+        const result = this.store.request(peerAdmission?.scope ?? 'local-operator', request, {
+            kind: 'team-run',
+            id,
+            expected,
+            ...(!grantId ? { generation } : {}),
+            instruction,
+            continuation,
+            ...(grantId ? { grantId } : {}),
+            ...(peerAdmission ? { peer_admission: peerAdmission.digest } : {}),
+        }, () => {
+            const row = this.get(id), task = this.tasks.get(row.task_id);
+            if (peerAdmission)
+                peerAdmission.authorize();
+            else if (controller)
+                this.store.authorizeControl(task.session_id, controller);
+            else
+                this.tasks.authorizeGrant(task, row.step_id, grantId);
+            this.expect(task.id, expected);
+            if (row.superseded ||
+                row.plan_revision !== task.plan_revision ||
+                row.generation !== generation)
+                throw new ServiceError('team_claim_stale', 'Assignment plan or generation changed');
+            if (generation >= 8)
+                throw new ServiceError('team_claim_limit', 'At most eight explicitly admitted generations per assignment');
+            if (['cancelled', 'succeeded', 'succeeded_with_exception'].includes(task.state))
+                throw new ServiceError('task_settled', 'Task no longer admits work');
+            const step = task.steps.find((s) => s.id === row.step_id);
+            if (!['pending', 'interrupted', 'failed', 'cancelled'].includes(step.state))
+                throw new ServiceError('invalid_step_state', 'Assignment is active or already awaiting review');
+            if (step.depends_on.some((key) => task.steps.find((s) => s.key === key)?.state !== 'completed'))
+                throw new ServiceError('dependency_pending', 'Complete predecessor steps first');
+            const interrupted = step.attempt_id && this.store.attempt(step.attempt_id).state === 'interrupted'
+                ? step.attempt_id
+                : null;
+            if (continuation !== interrupted || (row.child_id && !instruction))
+                throw new ServiceError('invalid_continuation', 'Follow-up requires a new instruction and the exact interrupted attempt, if any');
+            if (instruction !== null && (!instruction.trim() || instruction.length > 4096))
+                throw new ServiceError('invalid_field', 'Supply a bounded follow-up instruction', 400);
+            if (row.child_id) {
+                const prior = this.children.inspect(task.session_id, row.child_id);
+                if (prior.state === 'accepted' ||
+                    (prior.worker?.binding.external && !this.children.external?.stopped(prior.id)) ||
+                    this.store.db
+                        .prepare("SELECT 1 FROM workers WHERE session_id=? AND state!='exited'")
+                        .get(prior.child_session))
+                    throw new ServiceError('team_worker_uncertain', 'Confirm the previous process stopped before claiming a new generation');
+            }
+            const agent = this.profiles.resolve(task.session_id, row.profile_id);
+            if (agent.id !== row.grant_id)
+                throw new ServiceError('team_claim_stale', 'Assignment requires its original profile admission');
+            this.budget.check(task.session_id);
+            this.children.external?.validateAssignment(id, task);
+            if (this.budget.active(task) >= task.limits.concurrency)
+                throw new ServiceError('task_busy', 'Root task concurrency is full');
+            if (this.store.db
+                .prepare("SELECT 1 FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running','interrupted') AND resolved_by IS NULL")
+                .get(task.session_id))
+                throw new ServiceError('task_busy', 'Root session has pending work');
+            const envelope = randomUUID(), submission = randomUUID();
+            // A delegated envelope has never been dispatched to a model. Dispatcher excludes this state.
+            this.store.db
+                .prepare("INSERT INTO submissions(id,session_id,text,state,attempt_id) VALUES (?,?,?,'delegated',?)")
+                .run(submission, task.session_id, step.instruction, envelope);
+            this.store.db
+                .prepare("INSERT INTO attempts(id,session_id,submission_id,state) VALUES (?,?,?,'delegated')")
+                .run(envelope, task.session_id, submission);
+            const next = generation + 1;
+            const child = this.children.spawn(task.session_id, 0, envelope, `team:${id}:${next}`, instruction ?? step.instruction, row.budget, [], row.profile_id, {
+                authorize: () => { },
+                defer: true,
+                assignment: { id, generation: next },
+                runtime: this.children.external?.assignment(id),
+            });
+            this.store.db
+                .prepare('UPDATE team_assignments SET generation=?,child_id=? WHERE id=?')
+                .run(next, child.id, id);
+            this.store.db
+                .prepare('INSERT INTO task_step_attempts VALUES (?,?,?,?)')
+                .run(child.child_attempt, step.id, task.plan_revision, instruction ?? step.instruction);
+            this.store.db
+                .prepare("UPDATE task_steps SET attempt_id=?,state='queued',review=NULL WHERE id=?")
+                .run(child.child_attempt, step.id);
+            if (interrupted)
+                this.store.db
+                    .prepare('UPDATE attempts SET resolved_by=? WHERE id=?')
+                    .run(child.child_attempt, interrupted);
+            this.store.db
+                .prepare('UPDATE task_runtime SET started_at=coalesce(started_at,?) WHERE task_id=?')
+                .run(Date.now(), task.id);
+            this.store.db
+                .prepare("UPDATE durable_tasks SET state='running',reason='Team assignment claimed' WHERE id=?")
+                .run(task.id);
+            if (grantId)
+                this.store.db.prepare("UPDATE task_grants SET state='accepted' WHERE id=?").run(grantId);
+            this.changed(task.id, 'claimed', {
+                assignment_id: id,
+                generation: next,
+                child_id: child.id,
+                attempt_id: child.child_attempt,
+            });
+            peerAdmission?.committed(child);
+            launch = child;
+            return this.get(id);
+        });
+        if (launch)
+            this.children.launchPrepared(launch);
+        return result;
+    }
+    reject(id, request, expected, generation, reason, controller) {
+        return this.store.request('local-operator', request, { kind: 'team-reject', id, expected, generation, reason }, () => {
+            const assignment = this.get(id), task = this.tasks.get(assignment.task_id), step = task.steps.find((s) => s.id === assignment.step_id);
+            this.store.authorizeControl(task.session_id, controller);
+            this.expect(task.id, expected);
+            if (task.state === 'cancelled' ||
+                assignment.generation !== generation ||
+                !step.attempt_id ||
+                !['awaiting_review', 'failed', 'interrupted'].includes(step.state))
+                throw new ServiceError('team_claim_stale', 'Reject the current settled claim only');
+            if (!reason.trim() || reason.length > 4096)
+                throw new ServiceError('invalid_field', 'Record a bounded rejection reason', 400);
+            this.store.db
+                .prepare('INSERT INTO team_rejections VALUES (?,?,?,?)')
+                .run(step.id, step.attempt_id, request, reason);
+            this.store.db
+                .prepare("UPDATE task_steps SET state='failed',review=? WHERE id=?")
+                .run(reason, step.id);
+            this.store.db
+                .prepare('UPDATE task_runtime SET auto_enabled=0 WHERE task_id=?')
+                .run(task.id);
+            this.store.db
+                .prepare("UPDATE durable_tasks SET state='blocked',reason='Operator rejected worker proposal; explicit follow-up required' WHERE id=?")
+                .run(task.id);
+            this.changed(task.id, 'proposal_rejected', {
+                assignment_id: id,
+                generation,
+                attempt_id: step.attempt_id,
+                reason,
+            });
+            return this.get(id);
+        });
+    }
+    assert(binding) {
+        const row = this.get(binding.assignment.id), task = this.tasks.get(row.task_id), step = task.steps.find((s) => s.id === row.step_id);
+        if (task.state === 'cancelled' ||
+            row.plan_revision !== task.plan_revision ||
+            row.generation !== binding.assignment.generation ||
+            row.child_id === null ||
+            this.children.inspect(task.session_id, row.child_id).child_attempt !== binding.attempt_id ||
+            step?.attempt_id !== binding.attempt_id ||
+            binding.owner_task !== task.id ||
+            binding.owner_session !== task.session_id ||
+            binding.agent?.id !== row.grant_id)
+            throw new ServiceError('team_claim_stale', 'Worker no longer owns the current task-step claim');
+        return row;
+    }
+    changed(task, kind, detail) {
+        this.store.db.prepare('UPDATE durable_tasks SET revision=revision+1 WHERE id=?').run(task);
+        this.store.event(this.tasks.get(task).session_id, 'team.' + kind, {
+            task_id: task,
+            ...detail,
+        });
+    }
+    view(task) {
+        const current = this.tasks.get(task);
+        const assignments = this.store.db
+            .prepare('SELECT * FROM team_assignments WHERE task_id=? ORDER BY rowid')
+            .all(task).map((a) => ({
+            ...a,
+            stale: a.plan_revision !== current.plan_revision,
+            step_state: current.steps.find((s) => s.id === a.step_id)?.state,
+            worker: a.child_id ? this.children.inspect(current.session_id, a.child_id).worker : null,
+            runtime: this.children.external?.assignment(a.id) ?? null,
+            execution: a.child_id && this.children.inspect(current.session_id, a.child_id).worker?.binding.external
+                ? {
+                    state: this.children.external.row(a.child_id).state,
+                    stopped: this.children.external.stopped(a.child_id),
+                    stop_scope: this.children.external.assignment(a.id)?.kind === 'a2a'
+                        ? (() => {
+                            const receipt = this.children.external.row(a.child_id).receipt;
+                            return receipt
+                                ? (JSON.parse(receipt).scope ?? 'remote-terminal-receipt')
+                                : 'remote-terminal-receipt';
+                        })()
+                        : 'owned-processes',
+                    peer: (() => {
+                        const row = this.children.external.row(a.child_id);
+                        const cp = row.checkpoint ? JSON.parse(row.checkpoint) : null;
+                        return cp?.dialect === 'a2a'
+                            ? {
+                                peer_id: cp.peer_id,
+                                task_id: cp.task_id,
+                                context_id: cp.context_id,
+                                cancel_state: cp.cancel_state ?? null,
+                                remote_state: cp.result?.status?.state ?? null,
+                            }
+                            : null;
+                    })(),
+                }
+                : null,
+        }));
+        const messages = this.store.db
+            .prepare('SELECT id,sender,recipient,created_at,delivered_at,acknowledged_at FROM team_messages WHERE task_id=? ORDER BY rowid DESC LIMIT 128')
+            .all(task);
+        return {
+            task_id: task,
+            assignments,
+            messages,
+            bounds: {
+                root_concurrency: current.limits.concurrency,
+                session_workers: 2,
+                daemon_workers: 8,
+                wake_on_message: false,
+            },
+        };
+    }
+    send(taskId, sender, recipient, text, messageId, authorize) {
+        return this.store.request(`team-message:${taskId}:${sender}`, messageId, { recipient, text }, () => {
+            authorize();
+            const task = this.tasks.get(taskId);
+            if (task.state === 'cancelled')
+                throw new ServiceError('task_settled', 'Task is cancelled');
+            if (this.get(recipient).task_id !== taskId ||
+                (sender !== 'operator' && this.get(sender).task_id !== taskId))
+                throw new ServiceError('team_message_scope', 'Messages stay within their owning task');
+            if (!text.trim() || Buffer.byteLength(text) > 4096 || !messageId || messageId.length > 128)
+                throw new ServiceError('invalid_field', 'Bound messages to 4 KiB and IDs to 128 characters', 400);
+            const n = Number(this.store.db
+                .prepare('SELECT count(*) AS n FROM team_messages WHERE task_id=?')
+                .get(taskId).n);
+            if (n >= 256 ||
+                Number(this.store.db
+                    .prepare('SELECT count(*) AS n FROM team_messages WHERE recipient=? AND acknowledged_at IS NULL')
+                    .get(recipient).n) >= 32)
+                throw new ServiceError('team_backpressure', 'Team message quota reached');
+            const id = randomUUID();
+            this.store.db
+                .prepare('INSERT INTO team_messages VALUES (?,?,?,?,?,?,?,NULL,NULL)')
+                .run(id, taskId, sender, recipient, text, digest({ sender, recipient, text }), Date.now());
+            this.store.event(task.session_id, 'team.message_saved', {
+                message_id: id,
+                sender,
+                recipient,
+                wakes_worker: false,
+            });
+            return { id, stored: true, delivered: false, acknowledged: false, wakes_worker: false };
+        });
+    }
+    receive(recipient, request, authorize) {
+        return this.store.request('team-receive:' + recipient, request, {}, () => {
+            authorize();
+            const row = this.get(recipient), now = Date.now();
+            const messages = this.store.db
+                .prepare('SELECT * FROM team_messages WHERE recipient=? AND acknowledged_at IS NULL ORDER BY rowid LIMIT 32')
+                .all(recipient);
+            for (const m of messages)
+                this.store.db
+                    .prepare('UPDATE team_messages SET delivered_at=coalesce(delivered_at,?) WHERE id=?')
+                    .run(now, String(m.id));
+            this.store.event(this.tasks.get(row.task_id).session_id, 'team.messages_delivered', {
+                recipient,
+                message_ids: messages.map((m) => m.id),
+            });
+            return messages.map((m) => ({ ...m, delivered_at: m.delivered_at ?? now }));
+        });
+    }
+    acknowledge(recipient, id, request, authorize) {
+        return this.store.request('team-ack:' + recipient, request, { id }, () => {
+            authorize();
+            const row = this.get(recipient), message = this.store.db
+                .prepare('SELECT * FROM team_messages WHERE id=? AND recipient=?')
+                .get(id, recipient);
+            if (!message?.delivered_at)
+                throw new ServiceError('message_not_delivered', 'Receive the message before acknowledging');
+            this.store.db
+                .prepare('UPDATE team_messages SET acknowledged_at=coalesce(acknowledged_at,?) WHERE id=?')
+                .run(Date.now(), id);
+            this.store.event(this.tasks.get(row.task_id).session_id, 'team.message_acknowledged', {
+                recipient,
+                message_id: id,
+            });
+            return { id, acknowledged: true };
+        });
+    }
+}