@relayflows/sdk 2.0.9 → 2.0.10

package/dist/authored-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-budget.js","sourceRoot":"","sources":["../src/authored-budget.ts"],"names":[],"mappings":"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"}

package/dist/authored-flow-error.d.ts

@@ -1,28 +1,9 @@
-import type { CheckFailureKind } from './failure-kinds.js';
 import type { CompletionReason as ProtocolCompletionReason, RunCompletionReason as ProtocolRunCompletionReason } from './protocol.js';
-export type AuthoredFlowExecutionErrorCode = 'agent_cli_unresolved' | 'agent_parked' | 'duplicate_completion' | 'journal_protocol_violation' | 'missing_completion' | 'operation_after_completion' | 'operation_callback_failed' | 'step_failed' | 'unsupported_completion' | 'unsupported_gate' | 'unsupported_header' | 'unsettled_derived_work' | 'unsupported_promise_lifecycle' | 'unsupported_workspace_permission' | 'unawaited_step' | 'unsupported_verb';
+export type AuthoredFlowExecutionErrorCode = 'helper_provider.mount_required' | 'helper_provider.unsupported' | 'helper_slack.credential_missing' | 'helper_slack.mount_required' | 'budget_syntax_invalid' | 'budget_missing_price' | 'agent_cli_unresolved' | 'agent_parked' | 'llm_cli_unresolved' | 'llm_parked' | 'duplicate_completion' | 'journal_protocol_violation' | 'missing_completion' | 'memory_unreachable' | 'operation_after_completion' | 'operation_callback_failed' | 'step_failed' | 'lease_exceeded' | 'unsupported_completion' | 'unsupported_gate' | 'unsupported_header' | 'unsettled_derived_work' | 'unsupported_promise_lifecycle' | 'unsupported_workspace_permission' | 'unawaited_step' | 'unsupported_verb';
 export declare class AuthoredFlowExecutionError extends Error {
     readonly code: AuthoredFlowExecutionErrorCode;
     readonly completionReason?: (ProtocolCompletionReason | ProtocolRunCompletionReason) | undefined;
     readonly runId?: string | undefined;
-    /**
-     * Set only for `code === 'agent_cli_unresolved'`: the specific preflight
-     * refusal kind (`cli_missing`, `model_unknown`, `model_unavailable`, ...)
-     * `checkAuthoredFlow` actually produced, so a caller can distinguish a bad
-     * model declaration from a missing CLI the same way the declarative
-     * `flows check` path's `report.diagnostics[].kind` already lets it —
-     * collapsing every refusal to one generic code would lose that taxonomy.
-     */
-    readonly refusalKind?: CheckFailureKind | undefined;
-    constructor(code: AuthoredFlowExecutionErrorCode, message: string, completionReason?: (ProtocolCompletionReason | ProtocolRunCompletionReason) | undefined, runId?: string | undefined, 
-    /**
-     * Set only for `code === 'agent_cli_unresolved'`: the specific preflight
-     * refusal kind (`cli_missing`, `model_unknown`, `model_unavailable`, ...)
-     * `checkAuthoredFlow` actually produced, so a caller can distinguish a bad
-     * model declaration from a missing CLI the same way the declarative
-     * `flows check` path's `report.diagnostics[].kind` already lets it —
-     * collapsing every refusal to one generic code would lose that taxonomy.
-     */
-    refusalKind?: CheckFailureKind | undefined);
+    constructor(code: AuthoredFlowExecutionErrorCode, message: string, completionReason?: (ProtocolCompletionReason | ProtocolRunCompletionReason) | undefined, runId?: string | undefined);
 }
 //# sourceMappingURL=authored-flow-error.d.ts.map

package/dist/authored-flow-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authored-flow-error.d.ts","sourceRoot":"","sources":["../src/authored-flow-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EACV,gBAAgB,IAAI,wBAAwB,EAC5C,mBAAmB,IAAI,2BAA2B,EACnD,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,8BAA8B,GACtC,sBAAsB,GACtB,cAAc,GACd,sBAAsB,GACtB,4BAA4B,GAC5B,oBAAoB,GACpB,4BAA4B,GAC5B,2BAA2B,GAC3B,aAAa,GACb,wBAAwB,GACxB,kBAAkB,GAClB,oBAAoB,GACpB,wBAAwB,GACxB,+BAA+B,GAC/B,kCAAkC,GAClC,gBAAgB,GAChB,kBAAkB,CAAC;AAEvB,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,QAAQ,CAAC,IAAI,EAAE,8BAA8B;IAE7C,QAAQ,CAAC,gBAAgB,CAAC,GAAE,wBAAwB,GAAG,2BAA2B;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB;gBAZ9B,IAAI,EAAE,8BAA8B,EAC7C,OAAO,EAAE,MAAM,EACN,gBAAgB,CAAC,GAAE,wBAAwB,GAAG,2BAA2B,aAAA,EACzE,KAAK,CAAC,EAAE,MAAM,YAAA;IACvB;;;;;;;OAOG;IACM,WAAW,CAAC,EAAE,gBAAgB,YAAA;CAK1C"}
+{"version":3,"file":"authored-flow-error.d.ts","sourceRoot":"","sources":["../src/authored-flow-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,IAAI,wBAAwB,EAC5C,mBAAmB,IAAI,2BAA2B,EACnD,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,8BAA8B,GACtC,gCAAgC,GAChC,6BAA6B,GAC7B,iCAAiC,GACjC,6BAA6B,GAC7B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,cAAc,GACd,oBAAoB,GACpB,YAAY,GACZ,sBAAsB,GACtB,4BAA4B,GAC5B,oBAAoB,GACpB,oBAAoB,GACpB,4BAA4B,GAC5B,2BAA2B,GAC3B,aAAa,GACb,gBAAgB,GAChB,wBAAwB,GACxB,kBAAkB,GAClB,oBAAoB,GACpB,wBAAwB,GACxB,+BAA+B,GAC/B,kCAAkC,GAClC,gBAAgB,GAChB,kBAAkB,CAAC;AAEvB,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,QAAQ,CAAC,IAAI,EAAE,8BAA8B;IAE7C,QAAQ,CAAC,gBAAgB,CAAC,GAAE,wBAAwB,GAAG,2BAA2B;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM;gBAHd,IAAI,EAAE,8BAA8B,EAC7C,OAAO,EAAE,MAAM,EACN,gBAAgB,CAAC,GAAE,wBAAwB,GAAG,2BAA2B,aAAA,EACzE,KAAK,CAAC,EAAE,MAAM,YAAA;CAK1B"}

package/dist/authored-flow-error.js

@@ -2,22 +2,11 @@ export class AuthoredFlowExecutionError extends Error {
     code;
     completionReason;
     runId;
-    refusalKind;
-    constructor(code, message, completionReason, runId, 
-    /**
-     * Set only for `code === 'agent_cli_unresolved'`: the specific preflight
-     * refusal kind (`cli_missing`, `model_unknown`, `model_unavailable`, ...)
-     * `checkAuthoredFlow` actually produced, so a caller can distinguish a bad
-     * model declaration from a missing CLI the same way the declarative
-     * `flows check` path's `report.diagnostics[].kind` already lets it —
-     * collapsing every refusal to one generic code would lose that taxonomy.
-     */
-    refusalKind) {
+    constructor(code, message, completionReason, runId) {
         super(`${code}: ${message}`);
         this.code = code;
         this.completionReason = completionReason;
         this.runId = runId;
-        this.refusalKind = refusalKind;
         this.name = 'AuthoredFlowExecutionError';
     }
 }

package/dist/authored-flow-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"authored-flow-error.js","sourceRoot":"","sources":["../src/authored-flow-error.ts"],"names":[],"mappings":"AAwBA,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAExC;IAEA;IACA;IASA;IAbX,YACW,IAAoC,EAC7C,OAAe,EACN,gBAAyE,EACzE,KAAc;IACvB;;;;;;;OAOG;IACM,WAA8B;QAEvC,KAAK,CAAC,GAAG,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;QAdpB,SAAI,GAAJ,IAAI,CAAgC;QAEpC,qBAAgB,GAAhB,gBAAgB,CAAyD;QACzE,UAAK,GAAL,KAAK,CAAS;QASd,gBAAW,GAAX,WAAW,CAAmB;QAGvC,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;IAC3C,CAAC;CACF"}
+{"version":3,"file":"authored-flow-error.js","sourceRoot":"","sources":["../src/authored-flow-error.ts"],"names":[],"mappings":"AAiCA,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAExC;IAEA;IACA;IAJX,YACW,IAAoC,EAC7C,OAAe,EACN,gBAAyE,EACzE,KAAc;QAEvB,KAAK,CAAC,GAAG,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;QALpB,SAAI,GAAJ,IAAI,CAAgC;QAEpC,qBAAgB,GAAhB,gBAAgB,CAAyD;QACzE,UAAK,GAAL,KAAK,CAAS;QAGvB,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;IAC3C,CAAC;CACF"}

package/dist/authored-flow-executor.d.ts

@@ -1,9 +1,11 @@
-import type { FlowHandle } from '@relayflows/surface/runtime';
+import { type FlowCompletionReason } from '@relayflows/surface';
+import { type FlowHandle } from '@relayflows/surface/runtime';
+import { type ProgressEvent } from './progress.js';
 import type { GetFlowDefinition } from './authored-flow-loader.js';
-import { type RunLifecycleOptions } from './cli/run.js';
+import type { RunLifecycleOptions } from './cli/run.js';
 import { AuthoredFlowExecutionError, type AuthoredFlowExecutionErrorCode } from './authored-flow-error.js';
 import { JournalClient } from './journal-client.js';
-import type { CompletionReason as ProtocolCompletionReason, RunCompletionReason as ProtocolRunCompletionReason } from './protocol.js';
+import type { CompletionReason as ProtocolCompletionReason } from './protocol.js';
 export { AuthoredFlowExecutionError, type AuthoredFlowExecutionErrorCode };
 export interface AuthoredFlowJournalStep {
     readonly id: string;
@@ -12,7 +14,7 @@ export interface AuthoredFlowJournalStep {
 }
 export interface AuthoredFlowExecutionResult {
     readonly name: string;
-    readonly completionReason: ProtocolRunCompletionReason;
+    readonly completionReason: FlowCompletionReason;
     readonly journalSteps: readonly AuthoredFlowJournalStep[];
 }
 /**
@@ -20,9 +22,9 @@ export interface AuthoredFlowExecutionResult {
  *
  * This is deliberately not exported by the SDK package: without a durable
  * authored root, it is not a resumable public runner. The seam is narrow: an
- * empty-header flow may await plain `f.run(...)` steps and must finish with
- * `f.done("success")`. Every run and
- * the terminal marker is a compiled deterministic spec submitted through
+ * flow with an optional budget may await `f.run`, `f.llm`, and `f.agent` steps and must
+ * finish with `f.done("success")` or `f.done("needs_human")`. Each step and the terminal marker is
+ * a compiled spec submitted through
  * `JournalClient`; values are read back from `step.completed` journal entries.
  * Unsupported headers, verbs, gates, or completion lowering fail closed.
  */
@@ -34,6 +36,8 @@ export interface ExecuteAuthoredFlowOptions {
      * `getDefinition` instead; see authored-flow-loader.ts's comment on why.
      */
     readonly getDefinition?: GetFlowDefinition;
+    /** Helper receipt and mock-writeback storage; CLI passes its daemon data directory. */
+    readonly dataDir?: string;
     /**
      * The flow file's own path — passed straight to `checkAuthoredFlow`
      * (cli/check.ts) so `f.agent` resolves a CLI the same way a declarative
@@ -49,6 +53,8 @@ export interface ExecuteAuthoredFlowOptions {
     /** Passed straight through to classifyOutcome (cli/run.ts) for f.agent's wait. */
     readonly signal?: RunLifecycleOptions['signal'];
     readonly onWait?: RunLifecycleOptions['onWait'];
+    readonly onProgress?: (event: ProgressEvent) => void;
+    readonly localAgentStream?: string;
 }
 export declare function executeAuthoredFlow<Input = undefined>(handle: FlowHandle, journal: JournalClient, input?: Input, options?: ExecuteAuthoredFlowOptions): Promise<AuthoredFlowExecutionResult>;
 //# sourceMappingURL=authored-flow-executor.d.ts.map

package/dist/authored-flow-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authored-flow-executor.d.ts","sourceRoot":"","sources":["../src/authored-flow-executor.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAI9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEzE,OAAO,EACL,0BAA0B,EAC1B,KAAK,8BAA8B,EACpC,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EACV,gBAAgB,IAAI,wBAAwB,EAC5C,mBAAmB,IAAI,2BAA2B,EAEnD,MAAM,eAAe,CAAC;AAqBvB,OAAO,EAAE,0BAA0B,EAAE,KAAK,8BAA8B,EAAE,CAAC;AAW3E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,wBAAwB,CAAC;CACrD;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,2BAA2B,CAAC;IACvD,QAAQ,CAAC,YAAY,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC3D;AASD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;CACjD;AAED,wBAAsB,mBAAmB,CAAC,KAAK,GAAG,SAAS,EACzD,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,aAAa,EACtB,KAAK,CAAC,EAAE,KAAK,EACb,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,2BAA2B,CAAC,CAkTtC"}
+{"version":3,"file":"authored-flow-executor.d.ts","sourceRoot":"","sources":["../src/authored-flow-executor.ts"],"names":[],"mappings":"AAcA,OAAO,EAML,KAAK,oBAAoB,EAG1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAmD,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE/G,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EACL,0BAA0B,EAC1B,KAAK,8BAA8B,EACpC,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EACV,gBAAgB,IAAI,wBAAwB,EAE7C,MAAM,eAAe,CAAC;AAoBvB,OAAO,EAAE,0BAA0B,EAAE,KAAK,8BAA8B,EAAE,CAAC;AAE3E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,wBAAwB,CAAC;CACrD;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,EAAE,oBAAoB,CAAC;IAChD,QAAQ,CAAC,YAAY,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC3D;AASD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C,uFAAuF;IACvF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAChD,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACrD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,wBAAsB,mBAAmB,CAAC,KAAK,GAAG,SAAS,EACzD,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,aAAa,EACtB,KAAK,CAAC,EAAE,KAAK,EACb,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,2BAA2B,CAAC,CAsQtC"}

package/dist/authored-flow-executor.js

@@ -1,174 +1,133 @@
-import { COMPLETION_REASONS, RUN_COMPLETION_REASONS, } from '@relayflows/surface';
+import { pluginHelpers } from './plugin-loader.js';
+import { runPluginEffect } from './authored-plugin-effect.js';
+import { randomUUID } from 'node:crypto';
+import { dirname } from 'node:path';
+import { runHelperEffect } from './authored-helper-effect.js';
+import { checkSlackHelpers } from './slack-preflight.js';
+import { snapshotJsonValue } from './json-value.js';
+import { checkMcpHeader, McpPreflightError } from './cli/check-typescript.js';
+import { buildMcpProxy, runMcpEffect } from './authored-mcp.js';
+import { AuthoredBudget } from './authored-budget.js';
+import { assertMemoryReachable, authoredMemory, scriptMemoryScope } from './authored-memory.js';
+import { authoredDeterministicRunner, authoredWorkerRunner } from './authored-worker-step.js';
+import { isSurfaceRunCompletionReason } from './authored-step-output.js';
+import { createHelpers, helperProviders } from '@relayflows/surface/runtime';
 import { join } from 'node:path';
-import { compileSpec, toKernelSpec } from './compile.js';
+import { observeStep } from './progress.js';
+import { parseStepTimeout } from './compile.js';
 import { getAuthoredFlowDefinition } from './authored-flow.js';
-import { checkAuthoredFlow } from './cli/check.js';
-import { classifyOutcome } from './cli/run.js';
 import { AuthoredFlowExecutionError, } from './authored-flow-error.js';
 import { AuthoredFlowOperation, stopAuthoredOperations, verifyAuthoredOperations, } from './authored-flow-operation.js';
 import { AuthoredFlowLifecycle } from './authored-flow-lifecycle.js';
-import { SPEC_SCHEMA_VERSION } from './spec.js';
 export { AuthoredFlowExecutionError };
-/**
- * Matches the `"path/glob: readonly"` / `"path/glob: readwrite"` shorthand
- * shown in docs/SURFACE.md and the examples — the only shape a workspace
- * string could plausibly declare a permission in. No parser anywhere in this
- * package turns that annotation into a real restriction, so `lowerAgent`
- * refuses rather than silently accepting and ignoring it.
- */
-const WORKSPACE_PERMISSION_ANNOTATION = /:\s*(readonly|readwrite)\s*$/i;
 export async function executeAuthoredFlow(handle, journal, input, options = {}) {
     const getDefinition = options.getDefinition ?? getAuthoredFlowDefinition;
+    const localAgentStream = options.localAgentStream;
+    const onProgress = options.onProgress;
     const flowPath = options.flowPath ?? join(process.cwd(), 'flow.ts');
-    // Named separately from `options` because `lowerAgent` below has its own,
-    // differently-typed `options: AgentOptions` parameter that shadows this one.
     const waitOptions = {
         ...(options.signal !== undefined ? { signal: options.signal } : {}),
         ...(options.onWait !== undefined ? { onWait: options.onWait } : {}),
     };
     const definition = getDefinition(handle);
-    // `agents` is the one header field this executor lowers today (into
-    // `FlowSpec.agents`, resolved by `lowerAgent` below exactly like the
-    // declarative dialect's `agents:` map). Every other header field remains
-    // unimplemented and refuses closed rather than being silently ignored.
-    const unsupportedHeaderFields = Object.keys(definition.header)
-        .filter((field) => field !== 'agents');
-    if (unsupportedHeaderFields.length > 0) {
-        throw new AuthoredFlowExecutionError('unsupported_header', `flow "${definition.name}" uses unsupported header fields: ${unsupportedHeaderFields.join(', ')}`);
+    const headerFields = Object.keys(definition.header).filter(key => key !== 'tools' && key !== 'budget' && key !== 'memory');
+    if (definition.header.tools && Object.keys(definition.header.tools).some(key => !['mcp', ...helperProviders.map(p => p.namespace)].includes(key)))
+        headerFields.push('tools');
+    if (definition.header.tools?.relayfile !== undefined)
+        headerFields.push('tools.relayfile');
+    const helperPreflight = checkSlackHelpers(definition);
+    if (!helperPreflight.ok) {
+        const diagnostic = helperPreflight.diagnostics[0];
+        throw new AuthoredFlowExecutionError(diagnostic.kind, diagnostic.message);
     }
-    // Every declared named agent's model must be checked BEFORE the body runs,
-    // not lazily the first time a matching `f.agent` call happens to be
-    // reached: the declarative dialect's own preflight (preflight.ts's
-    // unknownModelDiagnostics) checks every entry in `flow.agents`, used or
-    // not, before any step submits — an unregistered model on a header entry
-    // the body never selects must refuse the same way, not silently pass. This
-    // is header data available before the body starts (no need to predict
-    // arbitrary TS control flow): a placeholder no-op deterministic step
-    // carries the declared `agents` map through the same real preflight
-    // `lowerAgent` uses, without probing any CLI (deterministic steps are
-    // never CLI-resolved) and without journaling anything on success.
-    if (definition.header.agents !== undefined && Object.keys(definition.header.agents).length > 0) {
-        const { report } = checkAuthoredFlow({
-            version: SPEC_SCHEMA_VERSION,
-            name: `${definition.name}/declared-agents`,
-            agents: { ...definition.header.agents },
-            steps: [{ id: 'declared-agents', type: 'deterministic', command: ':' }],
-        }, flowPath);
-        if (!report.ok) {
-            const refusal = report.diagnostics.find((diagnostic) => diagnostic.severity === 'refusal');
-            throw new AuthoredFlowExecutionError('agent_cli_unresolved', refusal?.message
-                ?? `flow "${definition.name}" declares an invalid named agent`, undefined, undefined, refusal?.kind ?? 'invalid_spec');
-        }
+    if (headerFields.length > 0) {
+        throw new AuthoredFlowExecutionError('unsupported_header', `flow "${definition.name}" uses unsupported header fields: ${headerFields.join(', ')}`);
+    }
+    const checkedMcp = await checkMcpHeader(definition, flowPath);
+    if (!checkedMcp.report.ok)
+        throw new McpPreflightError(checkedMcp.report);
+    const budget = new AuthoredBudget(definition.header.budget);
+    if (definition.header.memory?.agent === true) {
+        throw new AuthoredFlowExecutionError('unsupported_header', 'memory.agent requires the follow-up identity-scoped agent memory adapter');
+    }
+    // Direct member use is checked before any body effects; aliases are checked
+    // by the helper itself, without executing the body during discovery.
+    if (definition.header.memory !== undefined || /\.memory\b/.test(String(definition.body))) {
+        await assertMemoryReachable();
     }
     const journalSteps = [];
     const authoredSteps = [];
     const lifecycle = new AuthoredFlowLifecycle();
     let nextStep = 1;
     let requestedCompletion;
-    const lowerDeterministic = async (id, command) => {
-        const spec = toKernelSpec(compileSpec({
-            version: SPEC_SCHEMA_VERSION,
-            name: `${definition.name}/${id}`,
-            steps: [{ id, type: 'deterministic', command }],
-        }));
-        const outcome = await journal.runStart(spec);
-        return readSuccessfulOutput(journal, outcome, id, journalSteps);
-    };
-    // `name` (the first f.agent argument, e.g. "fixer") selects a NAMED
-    // declaration from the flow header's `agents` map, exactly like the
-    // declarative dialect's `agent: fixer` step field selects from a top-level
-    // `agents:` map — but ONLY when `name` actually matches a declared entry.
-    // `compile.ts`'s `resolveNamedAgent` throws `unknown named agent` for any
-    // `step.agent` that doesn't resolve, so setting it unconditionally would
-    // break every call that uses `name` purely for step-id readability (the
-    // common case, and every pre-existing `f.agent` caller). When there's no
-    // match, `agent` stays unset and CLI selection falls through to the
-    // project's flows.json default below, same as a bare `type: agent` YAML
-    // step with no explicit `cli`/`agent`. `options.cli`/`options.model`
-    // always pass through as step-level overrides, which win over any named
-    // declaration independent of whether `name` matched one.
-    const lowerAgent = async (id, name, options) => {
-        if (options.workspace !== undefined && WORKSPACE_PERMISSION_ANNOTATION.test(options.workspace)) {
-            throw new AuthoredFlowExecutionError('unsupported_workspace_permission', `flow "${definition.name}" step "${id}": workspace "${options.workspace}" declares a `
-                + 'permission annotation ("...: readonly" / "...: readwrite"), but nothing enforces it — '
-                + 'no parser anywhere in this package turns that annotation into a real restriction '
-                + '(kernel/DAEMON-LIFECYCLE.md\'s permission model is untouched by f.agent). '
-                + 'Silently accepting and ignoring it would let a flow believe a restriction is in effect '
-                + "when it is not. Declare a bare surface name (no trailing \": readonly\"/\": readwrite\") "
-                + 'if you do not need enforcement, or use the declarative spec\'s `permissions` field, which is real.');
-        }
-        const namedAgents = definition.header.agents;
-        const matchesNamedAgent = namedAgents !== undefined && Object.hasOwn(namedAgents, name);
-        const authoring = {
-            version: SPEC_SCHEMA_VERSION,
-            name: `${definition.name}/${id}`,
-            ...(namedAgents === undefined ? {} : { agents: { ...namedAgents } }),
-            steps: [{
-                    id,
-                    type: 'agent',
-                    instruction: options.task,
-                    ...(matchesNamedAgent ? { agent: name } : {}),
-                    ...(options.cli === undefined ? {} : { cli: options.cli }),
-                    ...(options.model === undefined ? {} : { model: options.model }),
-                    ...(options.workspace === undefined ? {} : {
-                        surfaces: { workspace: [{ surface: options.workspace }] },
-                    }),
-                }],
-        };
-        // The kernel never resolves a `cli` on its own — every declarative
-        // `flows run`/`flows check` binds it first via this exact function
-        // (cli/check.ts), searching for the nearest flows.json from `flowPath`
-        // and real-probing auth/model readiness. An authored agent step gets
-        // nothing for free just because it was declared in TS instead of YAML.
-        const { report, flow: resolved } = checkAuthoredFlow(authoring, flowPath);
-        if (!report.ok || resolved === undefined) {
-            const refusal = report.diagnostics.find((diagnostic) => diagnostic.severity === 'refusal');
-            throw new AuthoredFlowExecutionError('agent_cli_unresolved', refusal?.message
-                ?? `flow "${definition.name}" step "${id}": no CLI could be resolved for f.agent `
-                    + `(searched for flows.json from "${flowPath}")`, undefined, undefined, refusal?.kind ?? 'invalid_spec');
-        }
-        const spec = toKernelSpec(resolved);
-        const outcome = await journal.runStart(spec);
-        // Reuse the declarative CLI's own wait/classification (cli/run.ts) rather
-        // than a hand-rolled poll: `step.completed` and the run's own terminal
-        // state are appended as two SEPARATE actions (kernel/relayflowd-core/src/machine.rs
-        // completion_actions vs complete_run_actions), so a naive read right
-        // after runStart can race a real, valid completion — and a genuinely
-        // long-running agent has no reason to be bounded by anything other than
-        // its own worker's lease, which classifyOutcome already follows
-        // (renewing as the lease renews, per docs/SURFACE.md §5's WAITING
-        // [worker_lease] contract), never an unrelated fixed deadline.
-        const execution = await classifyOutcome(journal, 'run', outcome, report, '', waitOptions);
-        if (execution.exitCode === 3) {
-            const parked = execution.report.parkedStep;
-            throw new AuthoredFlowExecutionError('agent_parked', execution.report.diagnostics.at(-1)?.message
-                ?? `flow "${definition.name}" step "${id}" parked`
-                    + (parked !== undefined ? ` (${parked.type})` : '')
-                    + ': no worker is attached to run it.', undefined, outcome.run_id);
-        }
-        if (execution.exitCode !== 0) {
-            const reason = execution.report.completionReason;
-            throw new AuthoredFlowExecutionError('step_failed', execution.report.diagnostics.at(-1)?.message
-                ?? `flow "${definition.name}" step "${id}" did not complete successfully `
-                    + `(status: ${execution.report.status ?? 'unknown'})`, isSurfaceCompletionReason(reason) ? reason : undefined, outcome.run_id);
-        }
-        return readSuccessfulAgentOutput(journal, outcome.run_id, id, journalSteps);
-    };
+    const lowerDeterministic = authoredDeterministicRunner(definition.name, journal, journalSteps, budget);
+    const worker = authoredWorkerRunner(definition, journal, flowPath, journalSteps, waitOptions, localAgentStream, budget, definition.header.budget);
+    function llmOperation(prompt, ...values) {
+        assertOperationAllowed('llm', definition.name, requestedCompletion);
+        const id = `llm-${nextStep++}`;
+        // Hoist the operation reference so the start closure can read the
+        // caller's `.gate(config)` at spec-build time. AuthoredFlowOperation
+        // begins after construction returns, so `llmOp` is defined by then.
+        let llmOp;
+        llmOp = new AuthoredFlowOperation(id, 'llm', () => assertOperationAllowed('llm', definition.name, requestedCompletion), () => observeStep(id, 'llm', () => {
+            if (typeof prompt === 'string') {
+                if (values.length !== 1 || values[0] === undefined) {
+                    throw new AuthoredFlowExecutionError('llm_cli_unresolved', 'f.llm(prompt, options) requires an output JSON Schema.');
+                }
+                return worker.llm(id, prompt, values[0], llmOp.namedGate);
+            }
+            const text = prompt.reduce((result, part, index) => result + part
+                + (index < values.length ? String(values[index]) : ''), '');
+            return worker.llm(id, text, undefined, llmOp.namedGate);
+        }, onProgress), lifecycle);
+        return trackStep(authoredSteps, llmOp);
+    }
+    const slackRun = randomUUID();
+    function slackOperation(call) {
+        assertOperationAllowed(`slack.${call.verb}`, definition.name, requestedCompletion);
+        const snapshot = snapshotJsonValue(call, 'f.slack call');
+        const id = `slack-${slackRun}-${nextStep++}`;
+        return trackStep(authoredSteps, new AuthoredFlowOperation(id, `slack.${call.verb}`, () => assertOperationAllowed(`slack.${call.verb}`, definition.name, requestedCompletion), async () => {
+            const receipt = await runHelperEffect(journal, definition.name, id, snapshot, options.dataDir ?? dirname(journal.socketPath), journalSteps);
+            return (call.verb === 'react' ? undefined : receipt);
+        }, lifecycle));
+    }
     const context = {
-        run(command) {
+        ...createHelpers((call) => {
+            const verb = `${call.provider}.${call.verb}`;
+            assertOperationAllowed(verb, definition.name, requestedCompletion);
+            const snapshot = snapshotJsonValue(call, `f.${verb} call`);
+            const id = `${call.provider}-${slackRun}-${nextStep++}`;
+            return trackStep(authoredSteps, new AuthoredFlowOperation(id, verb, () => assertOperationAllowed(verb, definition.name, requestedCompletion), async () => await runHelperEffect(journal, definition.name, id, snapshot, options.dataDir ?? dirname(journal.socketPath), journalSteps), lifecycle));
+        }),
+        slack: {
+            post: (channel, text, opts) => slackOperation({ type: 'effect', provider: 'slack', verb: 'post', params: { channel, text, ...(opts === undefined ? {} : { opts }) } }),
+            dm: (user, text) => slackOperation({ type: 'effect', provider: 'slack', verb: 'dm', params: { user, text } }),
+            reply: (channel, threadTs, text) => slackOperation({ type: 'effect', provider: 'slack', verb: 'reply', params: { channel, threadTs, text } }),
+            react: (channel, messageTs, emoji) => slackOperation({ type: 'effect', provider: 'slack', verb: 'react', params: { channel, messageTs, emoji } }),
+        },
+        mcp: buildMcpProxy(checkedMcp.inventory, (server, tool, args, known) => {
+            assertOperationAllowed('mcp', definition.name, requestedCompletion);
+            const id = `mcp-${nextStep++}`;
+            return trackStep(authoredSteps, new AuthoredFlowOperation(id, 'mcp', () => assertOperationAllowed('mcp', definition.name, requestedCompletion), () => runMcpEffect(journal, definition.name, id, server, tool, args, known, checkedMcp.servers[server], journalSteps), lifecycle));
+        }),
+        memory: authoredMemory(scriptMemoryScope(flowPath, definition.name), () => assertOperationAllowed('memory', definition.name, requestedCompletion), definition.header.memory?.script !== false),
+        run(command, runOptions) {
             assertOperationAllowed('run', definition.name, requestedCompletion);
+            const leaseMs = runOptions?.timeout === undefined ? undefined : parseStepTimeout(runOptions.timeout);
             const id = `run-${nextStep++}`;
-            return trackStep(authoredSteps, new AuthoredFlowOperation(id, 'run', () => assertOperationAllowed('run', definition.name, requestedCompletion), () => lowerDeterministic(id, command), lifecycle));
-        },
-        llm() {
-            assertOperationAllowed('llm', definition.name, requestedCompletion);
-            const id = `llm-${nextStep++}`;
-            return trackStep(authoredSteps, unsupportedStep(id, 'llm', () => assertOperationAllowed('llm', definition.name, requestedCompletion), lifecycle));
+            let runOp;
+            runOp = new AuthoredFlowOperation(id, 'run', () => assertOperationAllowed('run', definition.name, requestedCompletion), () => observeStep(id, 'deterministic', () => lowerDeterministic(id, command, false, leaseMs, runOp.namedGate), options.onProgress), lifecycle);
+            return trackStep(authoredSteps, runOp);
         },
+        llm: llmOperation,
         agent(name, options) {
             assertOperationAllowed('agent', definition.name, requestedCompletion);
+            void name; // Authored headers do not yet declare reusable named agents.
             const id = `agent-${nextStep++}`;
-            return trackStep(authoredSteps, new AuthoredFlowOperation(id, 'agent', () => assertOperationAllowed('agent', definition.name, requestedCompletion), () => lowerAgent(id, name, options), lifecycle));
+            let agentOp;
+            agentOp = new AuthoredFlowOperation(id, 'agent', () => assertOperationAllowed('agent', definition.name, requestedCompletion), () => observeStep(id, 'agent', () => worker.agent(id, options, agentOp.namedGate), onProgress), lifecycle);
+            return trackStep(authoredSteps, agentOp);
         },
         human() {
             assertOperationAllowed('human', definition.name, requestedCompletion);
@@ -179,13 +138,13 @@ export async function executeAuthoredFlow(handle, journal, input, options = {})
             throw unsupportedVerb('dispatch');
         },
         done(reason) {
-            if (!isSurfaceRunCompletionReason(reason)) {
+            if (reason !== 'needs_human' && !isSurfaceRunCompletionReason(reason)) {
                 throw new AuthoredFlowExecutionError('unsupported_completion', `unknown completion reason: ${String(reason)}`);
             }
             if (requestedCompletion !== undefined) {
                 throw new AuthoredFlowExecutionError('duplicate_completion', `flow "${definition.name}" called done() more than once`);
             }
-            if (reason !== 'success') {
+            if (reason !== 'success' && reason !== 'needs_human') {
                 throw new AuthoredFlowExecutionError('unsupported_completion', `the initial authored executor cannot lower done("${reason}")`, reason);
             }
             lifecycle.markCompletion();
@@ -193,6 +152,12 @@ export async function executeAuthoredFlow(handle, journal, input, options = {})
         },
         cloud: unsupportedCloud(() => assertOperationAllowed('cloud', definition.name, requestedCompletion)),
     };
+    Object.assign(context, pluginHelpers(checkedMcp.plugins ?? [], (plugin, verb, args) => {
+        const label = `${verb.namespace}.${verb.method}`;
+        assertOperationAllowed(label, definition.name, requestedCompletion);
+        const id = `plugin-${nextStep++}`;
+        return trackStep(authoredSteps, new AuthoredFlowOperation(id, label, () => assertOperationAllowed(label, definition.name, requestedCompletion), () => runPluginEffect(journal, definition.name, id, plugin, verb, args, journalSteps, budget), lifecycle));
+    }));
     let bodyFailed = false;
     let bodyFailure;
     try {
@@ -242,7 +207,11 @@ export async function executeAuthoredFlow(handle, journal, input, options = {})
     finally {
         lifecycle.close();
     }
-    await lowerDeterministic(`complete-${nextStep}`, ':');
+    // The authored runner has no durable root yet. Record the handoff as a
+    // successful effect containing the authored outcome, not a fabricated kernel
+    // run.completed reason. The CLI reports this outcome as parked (exit 3).
+    await lowerDeterministic(`complete-${nextStep}`, requestedCompletion === 'needs_human'
+        ? `printf '%s' '{"completionReason":"needs_human"}'` : ':', true);
     return Object.freeze({
         name: definition.name,
         completionReason: requestedCompletion,
@@ -253,17 +222,12 @@ function trackStep(tracked, operation) {
     tracked.push(operation);
     return operation.step;
 }
-function unsupportedStep(id, verb, assertCanStart, lifecycle) {
-    return new AuthoredFlowOperation(id, verb, assertCanStart, async () => {
-        throw unsupportedVerb(verb);
-    }, lifecycle);
-}
 function unsupportedVerb(verb) {
     return new AuthoredFlowExecutionError('unsupported_verb', `the initial authored executor does not lower f.${verb}`);
 }
 function assertOperationAllowed(verb, flowName, completion) {
     if (completion !== undefined) {
-        throw new AuthoredFlowExecutionError('operation_after_completion', `flow "${flowName}" called f.${verb} after done()`, completion);
+        throw new AuthoredFlowExecutionError('operation_after_completion', `flow "${flowName}" called f.${verb} after done()`, completion === 'needs_human' ? undefined : completion);
     }
 }
 function unsupportedCloud(assertOpen) {
@@ -274,87 +238,4 @@ function unsupportedCloud(assertOpen) {
         },
     });
 }
-/**
- * Shared by every `f.*` verb that lowers to one kernel step run in isolation:
- * find its `step.completed` entry, record it, and refuse anything but a
- * clean success before handing the raw `output` back for verb-specific
- * extraction (a plain string for `f.run`, an `AgentResult` for `f.agent`).
- *
- * Callers are responsible for having already established that the RUN
- * reached a terminal, successful state before calling this — `f.run`'s
- * caller relies on `runStart`'s own immediate response (the kernel drives a
- * deterministic step to completion inline, no race); `f.agent`'s caller
- * relies on `classifyOutcome` (cli/run.ts) having already polled to a true
- * terminal state. Given that, a single read from the start of this run's
- * (small, single-step) journal is enough — no polling here, and no run
- * outcome ever needs re-checking.
- */
-async function readCompletedStepOutput(journal, runId, stepId, journalSteps) {
-    const entries = (await journal.journalRead(runId, 1)).entries;
-    const completed = entries.find((entry) => isStepCompleted(entry, stepId));
-    if (!isStepCompleted(completed, stepId)) {
-        throw protocolViolation(runId, `journal has no step.completed for "${stepId}"`);
-    }
-    const reason = completed.payload.completionReason;
-    journalSteps.push(Object.freeze({ id: stepId, runId, completionReason: reason }));
-    if (reason !== 'success') {
-        throw new AuthoredFlowExecutionError('step_failed', `journal step "${stepId}" completed with ${reason}`, reason, runId);
-    }
-    return completed.payload.output;
-}
-async function readSuccessfulOutput(journal, outcome, stepId, journalSteps) {
-    const output = await readCompletedStepOutput(journal, outcome.run_id, stepId, journalSteps);
-    if (!isRecord(output) || typeof output['stdout_tail'] !== 'string') {
-        throw protocolViolation(outcome.run_id, `step "${stepId}" has no string stdout_tail`);
-    }
-    return output['stdout_tail'];
-}
-/**
- * The kernel journals an agent step's raw `CliResult` shape
- * (`exit_code`/`stdout_tail`/`stderr_tail`) — same as a deterministic step —
- * UNLESS the CLI's stdout parsed as JSON, in which case `output` is that
- * parsed object directly (worker.ts: `parseJsonOutput(result.stdout_tail) ??
- * result`). Neither shape carries a real `artifacts` list today: nothing in
- * the kernel or worker enumerates files an agent wrote, and `f.agent`'s
- * `AgentOptions` has no `output` schema parameter for a CLI to target either
- * (unlike the declarative `AgentStepSpec.output` field). `artifacts` is
- * therefore always empty here — honest about what data exists, not a
- * placeholder for something not yet wired.
- */
-async function readSuccessfulAgentOutput(journal, runId, stepId, journalSteps) {
-    const output = await readCompletedStepOutput(journal, runId, stepId, journalSteps);
-    if (!isRecord(output)) {
-        throw protocolViolation(runId, `step "${stepId}" produced a non-object output`);
-    }
-    if (typeof output['stdout_tail'] === 'string') {
-        return { summary: output['stdout_tail'], artifacts: [] };
-    }
-    // The CLI's stdout parsed as JSON, so `output` is that value, not a
-    // CliResult. Fall back to a stable, inspectable summary rather than
-    // refusing a run whose agent step genuinely succeeded.
-    return { summary: JSON.stringify(output), artifacts: [] };
-}
-function isStepCompleted(value, stepId) {
-    if (!isRecord(value) || value['entry_type'] !== 'step.completed' || value['step_id'] !== stepId) {
-        return false;
-    }
-    const payload = value['payload'];
-    return isRecord(payload)
-        && isSurfaceCompletionReason(payload['completionReason'])
-        && 'output' in payload;
-}
-function isSurfaceCompletionReason(value) {
-    return typeof value === 'string'
-        && COMPLETION_REASONS.includes(value);
-}
-function isSurfaceRunCompletionReason(value) {
-    return typeof value === 'string'
-        && RUN_COMPLETION_REASONS.includes(value);
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function protocolViolation(runId, detail) {
-    return new AuthoredFlowExecutionError('journal_protocol_violation', detail, undefined, runId);
-}
 //# sourceMappingURL=authored-flow-executor.js.map