@relayflows/sdk 2.0.51 → 2.0.52

package/src/authored-verdict.ts

@@ -21,6 +21,8 @@ import type { JournalEvent } from './journal-reader.js';
 
 /** The `instruction` discriminator `authored-root.ts` writes into the root step. */
 export const AUTHORED_ROOT_KIND = 'relayflows.authored-root.v1';
+/** Older CLIs do not recognize this root and must refuse a parallel rollback. */
+export const AUTHORED_PARALLEL_ROOT_KIND = 'relayflows.authored-root.parallel.v2';
 
 export interface AuthoredVerdict {
   readonly reason: LoweredCompletionReason;
@@ -76,7 +78,8 @@ export function declaresAuthoredRoot(spawned: JournalEvent): boolean {
   if (step === null || step['id'] !== 'authored-root') return false;
   if (typeof step['instruction'] !== 'string') return false;
   try {
-    return record(JSON.parse(step['instruction']))?.['kind'] === AUTHORED_ROOT_KIND;
+    const kind = record(JSON.parse(step['instruction']))?.['kind'];
+    return kind === AUTHORED_ROOT_KIND || kind === AUTHORED_PARALLEL_ROOT_KIND;
   } catch {
     return false;
   }

package/src/authored-worker-step.ts

@@ -19,7 +19,7 @@ import { authoredChildAdmissionKey } from './authored-admission.js';
 import { alsoRecord, recordAuthoredChild } from './authored-step-index.js';
 import type { StepFailedDetails } from './failure-kinds.js';
 import { LOCAL_AGENT_WORKSPACE } from './local-agent-pins.js';
-import { authoredWorkerSlots, type AuthoredWorkerSlots } from './worker-slots.js';
+import { authoredWorkerSlots, WorkerSlots, type AuthoredWorkerSlots } from './worker-slots.js';
 import { validateStepSecrets } from './step-secrets.js';
 
 const AGENT_TIMEOUT = Symbol('declared agent timeout');
@@ -356,8 +356,14 @@ export function authoredWorkerRunner(
 export function authoredDeterministicRunner(
   name: string, journal: JournalClient, journalSteps: AuthoredFlowJournalStep[], budget: AuthoredBudget,
   context: AuthoredStepContext = {},
+  parallel = false,
 ) {
   const rootRunId = context.rootRunId;
+  // run.start drives a deterministic child to completion before replying. The
+  // daemon reads one connection in order, so sharing the body's connection
+  // would serialize Promise.all. Each admitted child gets its own connection;
+  // this limit bounds both daemon threads and shell commands per authored body.
+  const slots = new WorkerSlots(8);
   // One lowering, two readers. `record` changes what the child run's verdict
   // MEANS, so the reader changes with it; everything before the read — spec,
   // admission key, budget, child index — is deliberately shared, because a
@@ -386,8 +392,10 @@ export function authoredDeterministicRunner(
       });
       return read(outcome);
     };
-    if (terminal) return journal.runStart(spec, undefined, admissionKey).then(consume);
-    return budget.execute(journal, spec, consume, admissionKey);
+    const admit = async () => terminal
+      ? consume(await journal.runStart(spec, undefined, admissionKey, false, parallel))
+      : budget.execute(journal, spec, consume, admissionKey, parallel);
+    return parallel ? slots.run(admit) : admit();
   }
   const lowerRun = (id: string, command: string, terminal = false, leaseMs?: number, verification?: NamedGate,
     secrets?: string[]): Promise<string> =>
@@ -398,6 +406,7 @@ export function authoredDeterministicRunner(
     secrets?: string[]): Promise<RecordedRunOutcome> =>
     lower(id, command, false, leaseMs, verification, 'record', secrets,
       outcome => readRecordedOutcome(journal, outcome, id, journalSteps, context));
+  lowerRun.stop = (reason: unknown): void => slots.close(reason);
   return lowerRun;
 }
 

package/src/cli/run.ts

@@ -415,9 +415,11 @@ export async function resumeFlow(
       return { exitCode: 2, report: { ...base, runId, socketPath,
         diagnostics: [{ severity: 'refusal', kind: 'human_influenced_run', message: error.message.replace(/^human_influenced_run: /, '') }] } };
     }
-    if (error instanceof AuthoredFlowExecutionError && error.code === 'unsupported_promise_lifecycle') {
+    if (error instanceof AuthoredFlowExecutionError
+      && (error.code === 'unsafe_parallel_runtime' || error.code === 'unsupported_promise_lifecycle')) {
       return { exitCode: 2, report: { ...base, runId, socketPath,
-        diagnostics: [{ severity: 'refusal', kind: 'invalid_spec', message: error.message }] } };
+        diagnostics: [{ severity: 'refusal',
+          kind: error.code === 'unsafe_parallel_runtime' ? error.code : 'invalid_spec', message: error.message }] } };
     }
     if (error instanceof AuthoredFlowExecutionError
       && (error.code === 'helper_slack.credential_missing' || error.code === 'helper_slack.mount_required'

package/src/failure-kinds.ts

@@ -134,6 +134,8 @@ export const RUN_FAILURE_KINDS = [
   'run_parked',
   'run_declined',
   'run_unavailable',
+  /** A pinned parallel root is still active, but this process cannot safely dispatch it. */
+  'unsafe_parallel_runtime',
   /** A predicate `.gate(fn)` judged false; the verdict is journaled as `<step>.gate`. */
   'gate_failed',
   /** `flows answer` named a wait the run is not asking: unknown, or already answered. */

package/src/journal-client.ts

@@ -135,7 +135,12 @@ export class JournalClient extends JournalConnection {
     reuseFromRunId?: string,
     admissionKey?: string,
     watch = false,
+    isolated = false,
   ): Promise<VerbContract['run.start']['result']> {
+    if (isolated) {
+      if (watch) throw new Error('an isolated run.start cannot keep a watch on its temporary session');
+      return this.runStartIsolated(spec, reuseFromRunId, admissionKey);
+    }
     for (const step of spec.steps) {
       for (const name of validateStepSecrets(step.secrets, process.env)) {
         if (this.withheld.has(name)) {
@@ -155,6 +160,20 @@ export class JournalClient extends JournalConnection {
     }, null);
   }
 
+  /** Drive a blocking deterministic child on its own socket, then close it. */
+  private async runStartIsolated(
+    spec: KernelRunSpec, reuseFromRunId?: string, admissionKey?: string,
+  ): Promise<VerbContract['run.start']['result']> {
+    const peer = this.createPeer();
+    try {
+      await peer.connect();
+      await peer.hello('flows-authored-deterministic');
+      return await peer.runStart(spec, reuseFromRunId, admissionKey);
+    } finally {
+      peer.close();
+    }
+  }
+
   /** §3 memoized resume. */
   runResume(runId: string, allowHumanInfluenced = false): Promise<VerbContract['run.resume']['result']> {
     return this.request('run.resume', {