@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/src/children.ts

@@ -3,14 +3,21 @@ import type { Store } from './store.js';
 import type { Artifacts } from './artifacts.js';
 import type { Supervisor } from './supervisor.js';
 import { digest, ServiceError, type Attempt, type ChildTask } from './protocol.js';
+import type { RepositorySnapshots } from './repository-snapshots.js';
+import type { WorkerWorkspaces } from './worker-workspaces.js';
+import type { ExternalRuntime } from './external-runtime.js';
+import type { ExternalWork } from './external-work.js';
 
 export class ChildWork {
+  external?: ExternalWork;
+  workspaces?: WorkerWorkspaces;
   private paused = false;
   private starts = new Set<Promise<void>>();
   constructor(
     readonly store: Store,
     private artifacts: Artifacts,
     private supervisor: Supervisor,
+    private repositories?: RepositorySnapshots,
   ) {
     store.finishChild = (attempt) => this.finish(attempt);
     store.cancelChildren = (attempt) => this.cancelIntents(attempt);
@@ -21,16 +28,18 @@ export class ChildWork {
       .get(session) as unknown as ChildTask | undefined;
   }
   list(parent: string): ChildTask[] {
-    return this.store.db
-      .prepare('SELECT * FROM child_tasks WHERE parent_session=? ORDER BY rowid')
-      .all(parent) as unknown as ChildTask[];
+    return (
+      this.store.db
+        .prepare('SELECT * FROM child_tasks WHERE parent_session=? ORDER BY rowid')
+        .all(parent) as unknown as ChildTask[]
+    ).map((child) => ({ ...child, worker: this.store.workerBoundary.view(child.id) }));
   }
   inspect(parent: string, id: string): ChildTask {
     const row = this.store.db
       .prepare('SELECT * FROM child_tasks WHERE id=? AND parent_session=?')
       .get(id, parent) as unknown as ChildTask | undefined;
     if (!row) throw new ServiceError('not_found', 'Child task not found', 404);
-    return row;
+    return { ...row, worker: this.store.workerBoundary.view(row.id) };
   }
   spawn(
     parent: string,
@@ -40,6 +49,13 @@ export class ChildWork {
     prompt: string,
     budget: number,
     requested: string[],
+    profileId?: string,
+    admission?: {
+      authorize: () => void;
+      defer: true;
+      assignment: { id: string; generation: number };
+      runtime?: ExternalRuntime;
+    },
   ): ChildTask {
     if (!Number.isSafeInteger(budget) || budget < 1 || budget > 8)
       throw new ServiceError('invalid_budget', 'Child request budget must be 1–8');
@@ -52,12 +68,18 @@ export class ChildWork {
     )
       throw new ServiceError('invalid_child', 'Invalid child step or prompt');
     // Current child authority is deliberately read-only and closed-world.
-    const authority = requested
-      .filter((x) => x === 'salaam_probe')
-      .filter((x, i, a) => a.indexOf(x) === i)
-      .sort();
-    const input = digest({ prompt, budget, requested: [...new Set(requested)].sort() });
-    const child = this.store.transaction(() => {
+    const input = digest({
+      prompt,
+      budget,
+      requested: [...new Set(requested)].sort(),
+      ...(profileId ? { profile: profileId } : {}),
+      ...(admission ? { assignment: admission.assignment } : {}),
+      ...(admission?.runtime ? { runtime: admission.runtime } : {}),
+    });
+    let fresh = false;
+    if (this.store.db.isTransaction && !admission?.defer)
+      throw new Error('Nested child dispatch requires an owned deferred admission');
+    const prepare = () => {
       const old = this.store.db
         .prepare('SELECT * FROM child_tasks WHERE parent_session=? AND step_key=?')
         .get(parent, step) as unknown as ChildTask | undefined;
@@ -67,21 +89,49 @@ export class ChildWork {
         return old;
       }
       if (this.paused) throw new ServiceError('stopping', 'Child dispatch is stopping');
-      this.supervisor.assertActive(parent, epoch, attempt);
+      if (admission) admission.authorize();
+      else this.supervisor.assertActive(parent, epoch, attempt);
+      const agent = profileId
+        ? this.store.workerBoundary.profiles?.resolve(parent, profileId)
+        : undefined;
+      if (profileId && !agent)
+        throw new ServiceError('authority_denied', 'Agent profile is unavailable');
+      if (!admission?.runtime)
+        this.supervisor.assertSessionProviderSupported(parent, agent?.output_cap);
+      if (!admission?.runtime && agent && budget > (agent.profile.max_requests ?? 8))
+        throw new ServiceError('invalid_budget', 'Budget exceeds the admitted profile limit');
+      const available = [
+        ...(agent?.profile.tools ?? ['salaam_probe']),
+        ...(admission && !admission.runtime ? ['salaam_team'] : []),
+      ];
+      const authority = [
+        ...new Set(
+          agent && !requested.length ? available : requested.filter((x) => available.includes(x)),
+        ),
+      ].sort();
+      const effectivePrompt = agent
+        ? `${agent.profile.prompt ?? 'Run the diagnostic probe.'}${admission?.runtime ? '\n\nRuntime binding: use the admitted external harness tools for the corresponding file and command actions. Its private draft is /workspace. Return evidence for explicit root integration; this invocation cannot verify the root task.' : ''}\n\nGoal:\n${prompt}\n\nExplicitly selected facts:\n${JSON.stringify(agent.facts)}`
+        : prompt;
+      if (Buffer.byteLength(effectivePrompt) > 65536)
+        throw new ServiceError('invalid_child', 'Specialist context exceeds 64 KiB');
       if (this.owned(parent))
         throw new ServiceError('depth_exceeded', 'Child depth is limited to one');
       if (!authority.length)
         throw new ServiceError('authority_denied', 'No requested read-only authority is available');
-      if (this.list(parent).filter((x) => x.state === 'accepted').length >= 2)
+      if (this.activeCount(parent) >= 2)
         throw new ServiceError('child_limit', 'At most two children may be active');
-      this.store.usage.budget(attempt);
-      const changed = this.store.db
-        .prepare(
-          'UPDATE attempt_budgets SET reserved_requests=reserved_requests+? WHERE attempt_id=? AND spent_requests+reserved_requests+?<=limit_requests',
-        )
-        .run(budget, attempt, budget);
-      if (!changed.changes)
-        throw new ServiceError('budget_exhausted', 'Parent cannot reserve this child budget');
+      if (this.activeCount() >= 8)
+        throw new ServiceError('child_limit', 'Daemon worker admission limit reached');
+      if (!admission?.runtime) {
+        this.store.usage.budget(attempt);
+        const changed = this.store.db
+          .prepare(
+            'UPDATE attempt_budgets SET reserved_requests=reserved_requests+? WHERE attempt_id=? AND spent_requests+reserved_requests+?<=limit_requests',
+          )
+          .run(budget, attempt, budget);
+        if (!changed.changes)
+          throw new ServiceError('budget_exhausted', 'Parent cannot reserve this child budget');
+      }
       const id = randomUUID(),
         session = randomUUID(),
         submission = randomUUID(),
@@ -91,7 +141,7 @@ export class ChildWork {
         .run(session, this.store.session(parent).cwd, session);
       this.store.db
         .prepare('INSERT INTO submissions(id,session_id,text,attempt_id) VALUES (?,?,?,?)')
-        .run(submission, session, prompt, childAttempt);
+        .run(submission, session, effectivePrompt, childAttempt);
       this.store.db
         .prepare(
           "INSERT INTO attempts(id,session_id,submission_id,state) VALUES (?,?,?,'accepted')",
@@ -112,8 +162,39 @@ export class ChildWork {
           JSON.stringify(authority),
           budget,
         );
-      this.store.taskChildReserve?.(parent, childAttempt, budget);
-      this.store.usage.budget(childAttempt, budget);
+      if (!admission?.runtime) {
+        this.store.taskChildReserve?.(parent, childAttempt, budget);
+        this.store.usage.budget(childAttempt, budget);
+      }
+      const artifact = this.artifacts.prepare(session, effectivePrompt);
+      artifact.commit();
+      const repository = agent?.profile.role
+        ? this.repositories?.capture(parent, session)
+        : undefined;
+      if (agent?.profile.role && !repository)
+        throw new ServiceError('workspace_unavailable', 'No specialist snapshot boundary');
+      const writing = authority.some((tool) => ['salaam_files', 'salaam_command'].includes(tool));
+      const isolation =
+        (writing || admission?.runtime) && repository
+          ? this.workspaces?.prepare(session, repository)
+          : undefined;
+      if (writing && !isolation)
+        throw new ServiceError('authority_denied', 'No isolated coding boundary');
+      this.store.workerBoundary.freeze(
+        this.owned(session)!,
+        artifact.id,
+        false,
+        agent,
+        repository,
+        admission?.assignment,
+        isolation,
+        admission?.runtime,
+      );
+      if (admission?.runtime) {
+        if (!this.external)
+          throw new ServiceError('runtime_unavailable', 'External runtime is unavailable');
+        this.external.prepare(this.owned(session)!);
+      }
       this.store.event(session, 'session.created', { parent_session: parent, child_id: id });
       this.store.event(session, 'submission.accepted', {
         attempt_id: childAttempt,
@@ -126,19 +207,42 @@ export class ChildWork {
         budget,
         authority,
       });
+      fresh = true;
       return this.inspect(parent, id);
-    });
+    };
+    const child = this.store.db.isTransaction ? prepare() : this.store.transaction(prepare);
     // Repeated calls only return the durable binding. They never restart a child.
     if (
+      fresh &&
+      !admission?.defer &&
       this.store.session(child.child_session).epoch === 0 &&
       this.store.attempt(child.child_attempt).state === 'accepted'
     )
       this.start(child);
     return child;
   }
+  activeCount(parent?: string): number {
+    return Number(
+      this.store.db
+        .prepare(
+          `SELECT count(*) AS n FROM child_tasks c WHERE (? IS NULL OR c.parent_session=?) AND (c.state='accepted' OR EXISTS(SELECT 1 FROM workers w WHERE w.session_id=c.child_session AND w.state!='exited') OR EXISTS(SELECT 1 FROM external_runs e WHERE e.child_id=c.id AND e.stopped=0))`,
+        )
+        .get(parent ?? null, parent ?? null)!.n,
+    );
+  }
+  launchPrepared(child: ChildTask): void {
+    if (this.store.db.isTransaction) throw new Error('Commit child intent before launch');
+    if (this.store.workerBoundary.view(child.id).dispatch_state === 'intent') this.start(child);
+  }
+  cancelSessionInTransaction(parent: string): void {
+    const child = this.list(parent)[0];
+    if (child) this.cancelIntents(child.parent_attempt);
+  }
   private start(child: ChildTask): void {
-    const task = this.supervisor
-      .start(child.child_session)
+    const external = this.store.workerBoundary.view(child.id).binding.external;
+    const task = (
+      external ? this.external!.start(child) : this.supervisor.start(child.child_session)
+    )
       .catch((error) => {
         this.store.transaction(() => {
           const attempt = this.store.attempt(child.child_attempt);
@@ -149,6 +253,7 @@ export class ChildWork {
           this.store.db
             .prepare("UPDATE submissions SET state='interrupted' WHERE id=?")
             .run(attempt.submission_id);
+          this.store.projectTaskAttempt?.(this.store.attempt(attempt.id));
           this.finish(this.store.attempt(attempt.id));
         });
       })
@@ -172,6 +277,7 @@ export class ChildWork {
       this.store.db
         .prepare('UPDATE submissions SET state=? WHERE id=?')
         .run(state, attempt.submission_id);
+      this.store.projectTaskAttempt?.(this.store.attempt(attempt.id));
       this.finish(this.store.attempt(attempt.id));
     });
   }
@@ -192,6 +298,16 @@ export class ChildWork {
         state: attempt.state,
         text: attempt.result,
         error: attempt.error,
+        ...(this.store.workerBoundary.view(child.id).binding.agent
+          ? {
+              worker_id: this.store.workerBoundary.view(child.id).binding.worker_id,
+              report:
+                this.store.db
+                  .prepare('SELECT artifact_id FROM specialist_reports WHERE worker_id=?')
+                  .get(this.store.workerBoundary.view(child.id).binding.worker_id)?.artifact_id ??
+                null,
+            }
+          : {}),
       }),
     );
     artifact.commit();
@@ -199,6 +315,7 @@ export class ChildWork {
     this.store.db
       .prepare('UPDATE child_tasks SET state=?,result_id=?,artifact_id=? WHERE id=?')
       .run(attempt.state, result, artifact.id, child.id);
+    this.store.workerBoundary.finish(child, attempt.state === 'interrupted');
     this.store.event(child.parent_session, 'child.result_available', {
       child_id: child.id,
       result_id: result,
@@ -244,6 +361,7 @@ export class ChildWork {
           this.store.db
             .prepare("UPDATE submissions SET state='interrupted' WHERE id=?")
             .run(attempt.submission_id);
+          this.store.projectTaskAttempt?.(this.store.attempt(attempt.id));
         }
         this.finish(this.store.attempt(attempt.id));
       }
@@ -262,6 +380,7 @@ export class ChildWork {
         this.store.db
           .prepare("UPDATE submissions SET state='cancelled' WHERE id=?")
           .run(work.submission_id);
+        this.store.projectTaskAttempt?.(this.store.attempt(work.id));
         this.finish(this.store.attempt(work.id));
       }
       this.store.event(child.child_session, 'attempt.cancel_requested', {
@@ -274,10 +393,32 @@ export class ChildWork {
     const children = this.store.db
       .prepare('SELECT * FROM child_tasks WHERE parent_session=?')
       .all(this.store.attempt(attempt).session_id) as unknown as ChildTask[];
+    for (const child of children.filter((child) => this.store.cancelled(child.child_attempt)))
+      for (const run of this.supervisor.coding?.list(child.child_session) ?? [])
+        if (
+          ![
+            'succeeded',
+            'failed',
+            'cancelled',
+            'timed_out',
+            'output_limited',
+            'interrupted',
+          ].includes(run.state)
+        )
+          this.supervisor.coding!.cancel(
+            child.child_session,
+            run.id,
+            'child-stop:' + run.id,
+            () => {},
+          );
     await Promise.all(
       children
         .filter((child) => this.store.cancelled(child.child_attempt))
-        .map((child) => this.supervisor.cancelAttempt(child.child_attempt)),
+        .map((child) =>
+          this.store.workerBoundary.view(child.id).binding.external
+            ? this.external!.cancel(child)
+            : this.supervisor.cancelAttempt(child.child_attempt),
+        ),
     );
   }
   pause(): void {

package/src/claude-provider.ts

@@ -1,189 +1,2 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import {
-  createAssistantMessageEventStream,
-  type AssistantMessage,
-  type AssistantMessageEvent,
-  type Model,
-  type ProviderHeaders,
-} from '@earendil-works/pi-ai';
-import { streamSimple as streamClaude } from '@earendil-works/pi-ai/api/anthropic-messages';
-import { randomUUID } from 'node:crypto';
-import { digest, textDigest } from './protocol.js';
-import { getClaudeModel, validateClaudePayload, type ProviderRoute } from './provider-config.js';
-
-export function registerClaude(
-  pi: ExtensionAPI,
-  route: ProviderRoute,
-  frame: () => string,
-  tools: string[],
-  bridge: (method: string, data: unknown) => Promise<unknown>,
-  fail: () => Promise<void>,
-): void {
-  const catalog = getClaudeModel(route.model);
-  if (!catalog) throw new Error('Pinned Claude model missing');
-  const key = process.env.ANTHROPIC_API_KEY;
-  if (!key) throw new Error('Claude API key unavailable to worker');
-  pi.registerProvider('anthropic', {
-    baseUrl: 'https://api.anthropic.com',
-    apiKey: '$ANTHROPIC_API_KEY',
-    api: 'anthropic-messages',
-    models: [{ ...catalog, maxTokens: route.max_tokens }],
-    streamSimple(model, context, options) {
-      const output = createAssistantMessageEventStream();
-      const source = 'salaam-request:' + randomUUID();
-      let dispatched = false,
-        gateFailed = false,
-        status: number | undefined;
-      let last: AssistantMessage | undefined;
-      const normalize = (message: AssistantMessage): AssistantMessage => ({
-        ...message,
-        responseId: source,
-      });
-      void (async () => {
-        try {
-          if (model.provider !== route.provider || model.id !== route.model)
-            throw new Error('Unapproved Claude route');
-          const native: Model<'anthropic-messages'> = {
-            ...catalog,
-            provider: 'anthropic',
-            api: 'anthropic-messages',
-            baseUrl: 'https://api.anthropic.com',
-            compat: {
-              ...catalog.compat,
-              supportsMidConvoSystemMessages: false,
-              supportsMidConvoToolChanges: false,
-              supportsMidConvoEffort: false,
-            },
-          };
-          const headers: ProviderHeaders = {};
-          for (const [name, value] of Object.entries(options?.headers ?? {}))
-            headers[name.toLowerCase()] = value;
-          delete headers.authorization;
-          delete headers['x-api-key'];
-          delete headers['anthropic-workspace-id'];
-          if (route.workspace_id) headers['anthropic-workspace-id'] = route.workspace_id;
-          let approvedDigest: string | undefined;
-          const upstream = streamClaude(native, context, {
-            ...options,
-            apiKey: key,
-            env: {},
-            headers,
-            maxTokens: route.max_tokens,
-            reasoning: 'low',
-            maxRetries: 0,
-            timeoutMs: 120000,
-            onPayload: async (payload, rawModel) => {
-              const replacement = await options?.onPayload?.(payload, rawModel);
-              const actual = replacement === undefined ? payload : replacement;
-              try {
-                validateClaudePayload(actual, route, frame(), tools);
-                approvedDigest = digest(actual);
-              } catch {
-                gateFailed = true;
-                throw new Error('Claude payload denied');
-              }
-              return actual;
-            },
-            onResponse: async (response, rawModel) => {
-              status = response.status;
-              await options?.onResponse?.(response, rawModel);
-            },
-            fetch: async (input, init) => {
-              try {
-                const url = new URL(input instanceof Request ? input.url : String(input));
-                if (
-                  url.href !== 'https://api.anthropic.com/v1/messages?beta=true' &&
-                  url.href !== 'https://api.anthropic.com/v1/messages'
-                )
-                  throw new Error('Unapproved Claude endpoint');
-                if (init?.method !== 'POST' || typeof init.body !== 'string' || dispatched)
-                  throw new Error('Claude request replay denied');
-                const sentHeaders = new Headers(init.headers);
-                if (sentHeaders.get('x-api-key') !== key || sentHeaders.has('authorization'))
-                  throw new Error('Unapproved Claude authentication');
-                const payload = JSON.parse(init.body);
-                validateClaudePayload(payload, route, frame(), tools);
-                if (approvedDigest !== digest(payload))
-                  throw new Error('Claude payload changed after validation');
-                dispatched = true;
-                await bridge('model', {
-                  source_key: source,
-                  provider: 'anthropic',
-                  model: route.model,
-                  context_digest: textDigest(frame()),
-                  payload_digest: approvedDigest,
-                  payload,
-                });
-              } catch {
-                gateFailed = true;
-                throw new Error('Claude request denied by Salaam');
-              }
-              return globalThis.fetch(input, { ...init, redirect: 'error' });
-            },
-          });
-          for await (const event of upstream) {
-            if ('partial' in event) last = normalize(event.partial);
-            if (event.type === 'done') {
-              const message = normalize(event.message);
-              last = message;
-              await bridge('usage', {
-                source_key: source,
-                usage: message.usage,
-                provider_response_id: event.message.responseId ?? null,
-              });
-              output.push({ ...event, message });
-            } else if (event.type === 'error') {
-              const message = normalize(event.error);
-              const code = /^(?:Error:\s*)?(\d{3})\b/.exec(message.errorMessage ?? '')?.[1];
-              status = status ?? (code ? Number(code) : undefined);
-              delete message.diagnostics;
-              message.errorMessage = options?.signal?.aborted
-                ? 'Claude request cancelled'
-                : `Claude request failed${status ? ` (HTTP ${status})` : ''}`;
-              message.content = [];
-              last = message;
-              output.push({ ...event, error: message });
-            } else
-              output.push(
-                ('partial' in event
-                  ? { ...event, partial: last! }
-                  : event) as AssistantMessageEvent,
-              );
-          }
-          output.end();
-          if (gateFailed) await fail();
-        } catch {
-          const error: AssistantMessage = {
-            role: 'assistant',
-            content: [],
-            api: 'anthropic-messages',
-            provider: 'anthropic',
-            model: route.model,
-            timestamp: Date.now(),
-            stopReason: options?.signal?.aborted ? 'aborted' : 'error',
-            usage: last?.usage ?? {
-              input: 0,
-              output: 0,
-              cacheRead: 0,
-              cacheWrite: 0,
-              totalTokens: 0,
-              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-            },
-            responseId: source,
-            errorMessage: options?.signal?.aborted
-              ? 'Claude request cancelled'
-              : 'Claude required control failed',
-          };
-          output.push({
-            type: 'error',
-            reason: error.stopReason === 'aborted' ? 'aborted' : 'error',
-            error,
-          });
-          output.end();
-          if (!options?.signal?.aborted) await fail();
-        }
-      })();
-      return output;
-    },
-  });
-}
+// Kept as an internal compatibility entry point for existing extensions.
+export { registerLiveProvider as registerClaude } from './live-provider.js';