@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/src/task-budget.ts

@@ -39,19 +39,22 @@ export class TaskBudget {
     return child ? this.tasks.forSession(child.parent_session) : null;
   }
   state(id: string): Record<string, any> {
-    return this.store.db.prepare('SELECT * FROM task_runtime WHERE task_id=?').get(id) as Record<
-      string,
-      any
-    >;
+    const runtime = this.store.db.prepare('SELECT * FROM task_runtime WHERE task_id=?').get(id)!;
+    const n = Number(
+      this.store.db.prepare('SELECT count(*) AS n FROM task_invocations WHERE task_id=?').get(id)!
+        .n,
+    );
+    return { ...runtime, invocations_spent: n, external_model_usage: n ? 'unknown' : 'none' };
   }
   active(task: WorkTask): number {
     const row = this.store.db
       .prepare(
         `WITH tree(id) AS (SELECT ? UNION ALL SELECT child_session FROM child_tasks WHERE parent_session=?) SELECT
       (SELECT count(*) FROM attempts WHERE session_id IN (SELECT id FROM tree) AND state IN ('accepted','dispatching','running')) +
-      (SELECT count(*) FROM command_runs WHERE session_id IN (SELECT id FROM tree) AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')) AS n`,
+      (SELECT count(*) FROM command_runs WHERE session_id IN (SELECT id FROM tree) AND state NOT IN ('succeeded','failed','cancelled','timed_out','output_limited','interrupted')) +
+      (SELECT count(*) FROM external_runs e JOIN child_tasks c ON c.id=e.child_id JOIN attempts a ON a.id=c.child_attempt WHERE c.parent_session=? AND e.stopped=0 AND a.state NOT IN ('accepted','dispatching','running')) AS n`,
       )
-      .get(task.session_id, task.session_id)!;
+      .get(task.session_id, task.session_id, task.session_id)!;
     return Number(row.n);
   }
   private deny(session: string, message: string): never {
@@ -84,8 +87,11 @@ export class TaskBudget {
     if (!attempt) this.deny(task.session_id, 'Task model work must belong to a durable attempt');
     const l = task.limits,
       r = this.state(task.id),
-      charge = l.input_token_bound + l.output_token_bound;
-    if (input > l.input_token_bound || output > l.output_token_bound)
+      charge = l.token_units === null ? 0 : l.input_token_bound + l.output_token_bound!;
+    if (
+      input > l.input_token_bound ||
+      (l.output_token_bound !== null && output > l.output_token_bound)
+    )
       this.deny(task.session_id, 'Provider payload exceeds declared per-request token bounds');
     const reservation = this.store.db
       .prepare('SELECT * FROM task_reservations WHERE attempt_id=? AND task_id=?')
@@ -107,7 +113,10 @@ export class TaskBudget {
     } else {
       if (Number(r.requests_spent) + Number(r.reserved_requests) >= l.requests)
         this.deny(task.session_id, 'Task request limit reached');
-      if (Number(r.token_units) + Number(r.reserved_tokens) + charge > l.token_units)
+      if (
+        l.token_units !== null &&
+        Number(r.token_units) + Number(r.reserved_tokens) + charge > l.token_units
+      )
         this.deny(task.session_id, 'Task declared token budget reached');
       this.store.db
         .prepare(
@@ -121,10 +130,14 @@ export class TaskBudget {
     if (!task) return;
     this.check(session);
     const r = this.state(task.id),
-      tokens = count * (task.limits.input_token_bound + task.limits.output_token_bound);
+      tokens =
+        task.limits.token_units === null
+          ? 0
+          : count * (task.limits.input_token_bound + task.limits.output_token_bound!);
     if (
       Number(r.requests_spent) + Number(r.reserved_requests) + count > task.limits.requests ||
-      Number(r.token_units) + Number(r.reserved_tokens) + tokens > task.limits.token_units
+      (task.limits.token_units !== null &&
+        Number(r.token_units) + Number(r.reserved_tokens) + tokens > task.limits.token_units)
     )
       this.deny(task.session_id, 'Task cannot reserve the child request/token bounds');
     this.store.db

package/src/task-context.ts

@@ -65,6 +65,22 @@ export class TaskContext {
   }
   frame(id: string, binding: string): string {
     const state = this.state(id);
+    const admitted = [
+      ...new Map(
+        (this.store.workerBoundary.profiles?.snapshot(id) ?? [])
+          .filter((p) => p.state === 'active')
+          .map((p) => [
+            p.profile_id,
+            {
+              profile_id: p.profile_id,
+              profile_digest: p.profile_digest,
+              tools: p.tools,
+              route: p.route,
+              max_depth: 1,
+            },
+          ]),
+      ).values(),
+    ].sort((a, b) => a.profile_id.localeCompare(b.profile_id));
     // The compaction cursor is a projection, not a task fact/version.
     const frame =
       'SALAAM_TASK_STATE ' +
@@ -75,6 +91,7 @@ export class TaskContext {
         instructions:
           'Use active facts. Superseded facts are historical. Do not repeat completed steps. Retrieve evidence with salaam_history.',
         facts: state.facts,
+        ...(admitted.length ? { admitted_agents: admitted } : {}),
         ...(this.work?.forSession(id) ? { work_task: this.work.frame(id) } : {}),
       });
     if (Buffer.byteLength(frame) > TASK_FRAME_BYTES)

package/src/task-driver.ts

@@ -42,6 +42,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 as Error);
         for (const row of this.store.db.prepare('SELECT session_id FROM durable_tasks').all())
           this.supervisor.failControl(String(row.session_id), error as Error);
       })
@@ -153,7 +154,7 @@ export class TaskDriver {
   private async stopActive(task: WorkTask): Promise<void> {
     const attempts = this.store.db
       .prepare(
-        "SELECT id,state,submission_id FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running')",
+        "SELECT id,state,submission_id FROM attempts WHERE session_id=? AND state IN ('accepted','dispatching','running','delegated')",
       )
       .all(task.session_id) as { id: string; state: string; submission_id: string }[];
     this.store.transaction(() => {
@@ -179,6 +180,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) as { id: string }[];
@@ -208,7 +210,12 @@ export class TaskDriver {
     return this.tasks.get(id);
   }
   /** Revocation is durable before any process abort, including a job cancellation. */
-  cancelInTransaction(id: string, expected: number, authorize: () => void): { id: string } {
+  cancelInTransaction(
+    id: string,
+    expected: number,
+    authorize: () => void,
+    peer?: { peer: string; tenant: string },
+  ): { id: string } {
     if (!this.store.db.isTransaction) throw new Error('Task cancellation requires a transaction');
     authorize();
     const task = this.tasks.get(id);
@@ -217,12 +224,19 @@ 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: string): Promise<void> {
@@ -361,17 +375,32 @@ 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;
@@ -399,6 +428,7 @@ export class TaskDriver {
       return;
     }
     if (Number(r.remaining_steps) < 1) {
+      if (active) return;
       this.stop(task, 'Bounded progression step limit reached');
       return;
     }
@@ -406,14 +436,18 @@ export class TaskDriver {
     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) return;
+    const assigned = this.tasks.delegatedStep?.(task.id, next.id);
+    if ((!assigned && !(await this.worker(task))) || this.stopped) return;
     if (
+      !assigned &&
       r.auto_compact &&
       task.steps.some((s) => s.state === 'completed') &&
       !this.compact(task, next.id)
@@ -469,8 +503,10 @@ export class TaskDriver {
           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';
@@ -480,7 +516,7 @@ export class TaskDriver {
             .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';
           reason = 'Waiting for worker readiness';

package/src/task-policy.ts

@@ -7,12 +7,14 @@ export interface TaskCheck {
   cwd: string;
 }
 export interface TaskLimits {
+  /** Explicit opt-in for opaque runtimes. Omission never grants an invocation. */
+  invocations?: number;
   requests: number;
   runtime_ms: number;
   concurrency: number;
-  token_units: number;
+  token_units: number | null;
   input_token_bound: number;
-  output_token_bound: number;
+  output_token_bound: number | null;
   verification_runs: number;
 }
 export interface TaskPolicy {
@@ -63,10 +65,28 @@ export function taskPolicy(value: Record<string, unknown>): TaskPolicy {
     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) as (keyof TaskLimits)[]) {
+    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/src/task-verification.ts

@@ -125,6 +125,7 @@ export class TaskVerification {
         )
           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);
@@ -355,6 +356,7 @@ export class TaskVerification {
       if (step?.state === 'completed') 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/src/task-work.ts

@@ -65,9 +65,13 @@ export interface WorkTask extends TaskPolicy {
 
 /** Operator-driven task ledger. An attempt outcome never constitutes task success. */
 export class TaskWork {
+  providerCheck?: (limits: TaskPolicy['limits']) => void;
   assertLimits?: (session: string) => void;
   assertProgressionBinding?: (task: WorkTask, binding: string) => void;
-  private authorizeGrant(task: WorkTask, step: string, grant?: string): void {
+  delegatedStep?: (task: string, step: string) => boolean;
+  advanceDelegate?: (grant: string) => unknown;
+  assertStepReview?: (task: string, step: string) => void;
+  authorizeGrant(task: WorkTask, step: string, grant?: string): void {
     const row = this.store.db
       .prepare(
         'SELECT * FROM task_grants WHERE id=? AND task_id=? AND step_id=? AND plan_revision=?',
@@ -98,6 +102,7 @@ export class TaskWork {
     const grant = this.store.db.prepare('SELECT * FROM task_grants WHERE id=?').get(grantId) as
       { task_id: string; step_id: string; expected_revision: number } | undefined;
     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,
@@ -317,6 +322,7 @@ export class TaskWork {
     if (!this.store.db.isTransaction) 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);
@@ -381,7 +387,32 @@ 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)
@@ -458,9 +489,15 @@ export class TaskWork {
         if (controller) this.store.authorizeControl(task.session_id, controller);
         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))
           throw new ServiceError('invalid_step_state', 'Step cannot be run in its current state');
@@ -552,6 +589,7 @@ export class TaskWork {
             '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);
@@ -588,9 +626,16 @@ export class TaskWork {
       .prepare('SELECT task_id,id,state FROM task_steps WHERE attempt_id=?')
       .get(attempt.id) as { task_id: string; id: string; state: WorkStep['state'] } | undefined;
     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: WorkStep['state'] = (
       {
         accepted: 'queued',
+        delegated: 'queued',
         dispatching: 'running',
         running: 'running',
         completed: 'awaiting_review',