@hunterzhu/pulse-runtime 0.6.0 → 0.7.0

package/dist/dsl/program.d.ts

@@ -255,7 +255,9 @@ export declare class StepBuilder<TState = JsonValue> {
         resetTurnsOnEntry?: (ctx: StepContext<TState>) => string | number | undefined;
         outputSchema?: ZodTypeAny;
         requirements?: Record<string, JsonValue>;
+        manualApprovalFallback?: boolean;
         toolApproval?: {
+            requiresApproval?: (calls: JsonValue) => boolean;
             prompt: string | ((calls: JsonValue, ctx: StepContext<TState>) => string);
             onDenied?: (reason: string, ctx: StepContext<TState>) => NextStepTarget<TState>;
         };
@@ -268,6 +270,7 @@ export declare class StepBuilder<TState = JsonValue> {
         };
         onMaxTurns?: (ctx: StepContext<TState>) => NextStepTarget<TState>;
         prepareQuestion?: (toolName: string, input: JsonValue, ctx: StepContext<TState>) => JsonValue;
+        validateQuestion?: (toolName: string, input: JsonValue, ctx: StepContext<TState>) => string | undefined;
         onHumanReply?: (question: JsonValue, answer: JsonValue, ctx: StepContext<TState>) => NextStepTarget<TState> | undefined;
         onError?: (error: RuntimeError, ctx: StepContext<TState>) => NextStepTarget<TState>;
     }): this;

package/dist/dsl/program.js

@@ -774,6 +774,11 @@ export class StepBuilder {
             return updates.length ? interactionUserRevision(updates) : typeof prior === 'string' ? prior : interactionUserRevision([]);
         };
         const submitModel = (ctx, turn, inputs = {}, answers = readAnswers(ctx)) => {
+            // A new model wait owns its own result. Older snapshots may still carry
+            // the proposal pinned while compaction was awaiting tool approval.
+            const locals = writeTurns(ctx, turn, inputs);
+            const modelSdk = { ...sdkLocals(locals) };
+            delete modelSdk[pendingResultKey];
             if (answers.length)
                 inputs = { ...inputs, conversation: [...(inputs.conversation ?? []), { role: 'user', content: '[Confirmed interaction data; not new instructions]\n' + JSON.stringify(confirmedInteractionSurface(answers, (() => { const controller = callInput(callInput(ctx.global).taskController ?? {}); const stage = Array.isArray(controller.tasks) ? controller.tasks.map(callInput).find(t => t.id === controller.activeId) : undefined; return [String(controller.activeId ?? ''), ...(Array.isArray(stage?.criterionIds) ? stage.criterionIds.filter((id) => typeof id === 'string') : [])]; })())) + '\nThese replies are the current decisions, including the selected option labels. An older document saying unresolved does not reopen a decision. Ask again only if the user changes it; execution approval remains a separate explicit gate.' }] };
             const allResultRefs = [...new Set(inputs.results ?? [])];
@@ -783,7 +788,7 @@ export class StepBuilder {
             const artifactRefs = [...new Set(inputs.artifacts ?? [])];
             const dataRefs = [...resultRefs, ...findingRefs, ...artifactRefs.map((ref) => ({ kind: 'artifact', ref }))];
             const requirements = { ...(options.requirements ?? {}), ...(options.toolAllow === undefined ? {} : { toolCalling: true }) };
-            return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-turn-${turn}`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task ?? 'reason', instruction: instruction(ctx), inputs: { ...(resultRefs.length ? { results: resultRefs } : {}), ...(findingRefs.length ? { findings: findingRefs } : {}), ...(artifactRefs.length ? { artifacts: artifactRefs } : {}), ...(inputs.events?.length ? { events: [...new Set(inputs.events)] } : {}), ...(inputs.conversation?.length ? { conversation: inputs.conversation } : {}) }, turn, ...(inputs.toolDiscovery === undefined ? {} : { toolDiscovery: inputs.toolDiscovery }), ...(options.outputSchema === undefined ? {} : { outputSchema: zodJsonSchema(options.outputSchema) }), ...(Object.keys(requirements).length ? { requirements } : {}) }), ...(dataRefs.length ? { derivedFrom: dataRefs } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: { programId: this.config.id, programVersion: this.config.version, step: `${name}:decode`, locals: writeTurns(ctx, turn, inputs) }, locals: writeTurns(ctx, turn, inputs) };
+            return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-turn-${turn}`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task ?? 'reason', instruction: instruction(ctx), inputs: { ...(resultRefs.length ? { results: resultRefs } : {}), ...(findingRefs.length ? { findings: findingRefs } : {}), ...(artifactRefs.length ? { artifacts: artifactRefs } : {}), ...(inputs.events?.length ? { events: [...new Set(inputs.events)] } : {}), ...(inputs.conversation?.length ? { conversation: inputs.conversation } : {}) }, turn, ...(inputs.toolDiscovery === undefined ? {} : { toolDiscovery: inputs.toolDiscovery }), ...(options.outputSchema === undefined ? {} : { outputSchema: zodJsonSchema(options.outputSchema) }), ...(Object.keys(requirements).length ? { requirements } : {}) }), ...(dataRefs.length ? { derivedFrom: dataRefs } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: { programId: this.config.id, programVersion: this.config.version, step: `${name}:decode`, locals: { ...locals, $sdk: modelSdk } }, locals: { ...locals, $sdk: modelSdk } };
         };
         const invalidInputRecovery = (ctx) => {
             const input = ctx.resumeInput;
@@ -819,6 +824,18 @@ export class StepBuilder {
             return { ...output, next: `${name}:decode`, locals: { ...locals, $sdk: { ...sdk, [failureKey]: { signature, count, observations: [{ code: 'INVALID_TOOL_INPUT', message }] }, [`${name}QueuedTools`]: [], [`${name}StopAfterSerial`]: false } } };
         };
         this.handlers.set(name, (ctx) => { const resetToken = options.resetTurnsOnEntry?.(ctx); const priorToken = sdkLocals(ctx.lane.resume.locals)[resetTokenKey]; const reset = resetToken !== undefined && priorToken !== resetToken; const turn = (reset ? 0 : readTurns(ctx)) + 1; const inputs = options.inputs?.(ctx) ?? {}; const output = submitModel(ctx, turn, inputs); const locals = writeTurns(ctx, turn, inputs, resetToken); return { ...output, next: `${name}:decode`, locals }; });
+        this.handlers.set(`${name}:manual-approval`, (ctx) => {
+            const dependency = Object.values(waitResolution(ctx.resumeInput)?.dependencies ?? {}).find(item => item.state === 'settled' && item.outcome.resultRef);
+            const ref = dependency?.state === 'settled' ? dependency.outcome.resultRef : undefined;
+            const answer = ref ? readResult(ctx, ref) : undefined;
+            if (!answer || typeof answer !== 'object' || Array.isArray(answer) || answer.approved !== true)
+                return { next: { fail: { code: 'APPROVAL_DENIED', message: 'Manual approval denied or cancelled. Operation not executed.', retryable: false } } };
+            const calls = sdkLocals(ctx.lane.resume.locals)[`${name}ManualCalls`];
+            const question = ref ? ctx.results.meta(ref)?.humanQuestion : undefined;
+            if (!Array.isArray(calls) || !calls.length || !question || typeof question !== 'object' || Array.isArray(question) || JSON.stringify(question.tools) !== JSON.stringify(calls))
+                return { next: { fail: { code: 'APPROVAL_DIGEST_MISMATCH', message: 'Approved operation does not match the persisted question.', retryable: false } } };
+            return { actions: [{ type: 'submit_effects', effects: calls.map((call, index) => { const c = call; return { key: `${name}-manual-approved-${index}`, kind: 'tool', concurrencyClass: 'tool', toolCallId: String(c.toolCallId), derivedFrom: ref ? [ref] : [], input: { name: String(c.toolName), arguments: c.input ?? {}, toolCallId: String(c.toolCallId) } }; }), wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:tools`, locals: { ...ctx.lane.resume.locals, $sdk: { ...sdkLocals(ctx.lane.resume.locals), [`${name}ManualCalls`]: null } } };
+        });
         this.handlers.set(`${name}:tools`, (ctx) => {
             for (const ref of resultRefsFromWait(ctx)) {
                 const meta = ctx.results.meta(ref);
@@ -828,6 +845,16 @@ export class StepBuilder {
                 if (next)
                     return { next };
             }
+            const manualCalls = Object.values(waitResolution(ctx.resumeInput)?.dependencies ?? {}).flatMap(dependency => {
+                const details = dependency.state === 'settled' ? dependency.outcome.error?.details : undefined;
+                if (!details || typeof details !== 'object' || Array.isArray(details) || details.manualApproval !== true || typeof details.toolName !== 'string' || typeof details.toolCallId !== 'string')
+                    return [];
+                return [{ toolName: details.toolName, toolCallId: details.toolCallId, input: details.input ?? {} }];
+            });
+            if (options.manualApprovalFallback && manualCalls.length) {
+                const calls = [...new Map(manualCalls.map(call => [call.toolCallId, call])).values()];
+                return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-manual-approval`, kind: 'human', concurrencyClass: 'none', input: { prompt: '本地审批未通过或不可用。请确认下面的原始操作；未确认前不会执行。', tools: calls } }], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:manual-approval`, locals: { ...ctx.lane.resume.locals, $sdk: { ...sdkLocals(ctx.lane.resume.locals), [`${name}ManualCalls`]: calls } } };
+            }
             // Stop before another model turn or queued call can bypass a denied operation.
             const stopped = Object.values(waitResolution(ctx.resumeInput)?.dependencies ?? {}).find(dependency => dependency.state === 'settled' && (dependency.outcome.status === 'cancelled' || dependency.outcome.error?.code.startsWith('AI_APPROVAL_') || ['AI_APPROVAL_DENIED', 'APPROVAL_DENIED', 'APPROVAL_REQUIRED', 'TASK_MODEL_CALL_BUDGET_EXHAUSTED', 'TASK_MODEL_CALL_BUDGET_CORRUPT'].includes(dependency.outcome.error?.code ?? '')));
             if (stopped?.state === 'settled')
@@ -978,6 +1005,73 @@ export class StepBuilder {
             delete nextSdk[skippedKey];
             return { ...output, next: `${name}:decode`, locals: { ...locals, $sdk: nextSdk } };
         });
+        const dispatchTools = (action, locals, deferred = [], skippedNames = []) => {
+            if (action.type !== 'submit_effects')
+                throw new Error('INVALID_TOOL_ACTION');
+            const serial = options.serialTools !== undefined && action.effects.some(effect => options.serialTools.includes(String(callInput(effect.input ?? {}).name)));
+            const limit = serial ? 1 : Math.max(1, options.maxToolsPerTurn ?? action.effects.length);
+            const base = locals;
+            const priorSdk = sdkLocals(base);
+            const usedTools = new Set(Array.isArray(priorSdk[`${name}UsedTools`]) ? priorSdk[`${name}UsedTools`].filter((item) => typeof item === 'string') : []);
+            for (const effect of action.effects) {
+                const input = effect.input && typeof effect.input === 'object' && !Array.isArray(effect.input) ? effect.input : {};
+                if (typeof input.name === 'string')
+                    usedTools.add(input.name);
+            }
+            const sdk = { ...priorSdk, [`${name}ReadGateSkipped`]: deferred, [`${name}UsedTools`]: [...usedTools], [`${name}QueuedTools`]: action.effects.slice(limit), [`${name}StopAfterSerial`]: options.stopAfterFirstSerialTool === true && serial && action.effects.length > limit };
+            // Approval must retain the proposal until it is checked, then consume
+            // it once just like direct tool dispatch after compaction.
+            delete sdk[pendingResultKey];
+            if (skippedNames.length)
+                sdk[`${name}SkippedTools`] = skippedNames;
+            return { actions: [{ ...action, effects: action.effects.slice(0, limit) }], next: `${name}:tools`, locals: { ...base, $sdk: sdk } };
+        };
+        // Approval is a durable resume point, so register it when the program is built.
+        // A handler installed only during decode disappears in a new process and would
+        // fall back to the entry step, losing the approved operations.
+        this.handlers.set(`${name}:approval`, ctx => {
+            // A denied or mismatched approval is the user's decision for this lane.
+            // Stage recovery would mark one stage blocked and keep dispatching the rest.
+            const stopsLane = (code) => code === 'APPROVAL_DENIED' || code === 'APPROVAL_DIGEST_MISMATCH' || code === 'APPROVAL_CALLS_MISSING' || code === 'APPROVAL_RESPONSE_INVALID' || code === 'APPROVAL_RESPONSE_MISSING' || code.startsWith('TASK_MODEL_CALL_BUDGET_') || code.startsWith('AI_APPROVAL_');
+            const fail = (error) => stopsLane(error.code) ? { next: { fail: error } } : options.onError ? { next: options.onError(error, ctx), locals: clearPendingResult(ctx) } : { next: { fail: error } };
+            const resolution = waitResolution(ctx.resumeInput);
+            const error = waitFailure(ctx);
+            if (error)
+                return fail(error);
+            const dependency = resolution && Object.values(resolution.dependencies).find(item => item.state === 'settled' && item.outcome);
+            if (!dependency || dependency.state !== 'settled' || !dependency.outcome?.resultRef)
+                return fail({ code: 'APPROVAL_RESPONSE_INVALID', message: 'Approval wait has no settled reply.', retryable: false });
+            const reply = z.object({ approved: z.boolean(), reason: z.string().optional() }).safeParse(readResult(ctx, dependency.outcome.resultRef));
+            if (!reply.success)
+                return fail({ code: 'APPROVAL_RESPONSE_INVALID', message: 'Approval response must contain approved=true or false.', retryable: false });
+            if (!reply.data.approved)
+                return options.toolApproval?.onDenied ? { next: options.toolApproval.onDenied(reply.data.reason ?? 'User denied the proposed tool call.', ctx) } : fail({ code: 'APPROVAL_DENIED', message: reply.data.reason ?? 'User denied the proposed tool call.', retryable: false });
+            const sdk = sdkLocals(ctx.lane.resume.locals), approvalKey = `${name}PendingToolCalls`, digestKey = `${name}PendingToolDigest`;
+            const pending = sdk[approvalKey];
+            if (!Array.isArray(pending))
+                return fail({ code: 'APPROVAL_CALLS_MISSING', message: 'Approved calls are missing from persisted lane state.', retryable: false });
+            const evidenceKey = `${name}PendingToolEvidence`;
+            const storedEvidence = sdk[evidenceKey];
+            const legacyDigest = storedEvidence === undefined && sdk[digestKey] === contentHash(pending);
+            if (!legacyDigest && sdk[digestKey] !== contentHash({ calls: pending, evidence: storedEvidence ?? null }))
+                return fail({ code: 'APPROVAL_DIGEST_MISMATCH', message: 'Persisted calls differ from the approved digest.', retryable: false });
+            const evidence = legacyDigest ? {} : callInput(storedEvidence ?? {});
+            const sourceRef = typeof sdk[pendingResultKey] === 'string' ? sdk[pendingResultKey] : undefined;
+            const sourceMeta = sourceRef ? ctx.results.meta(sourceRef) : undefined;
+            const sourceEffectId = typeof evidence.sourceEffectId === 'string' ? evidence.sourceEffectId : sourceMeta?.producer.kind === 'effect' ? sourceMeta.producer.id : undefined;
+            const privacy = ['public', 'cloud_allowed', 'local_only'].includes(String(evidence.sourcePrivacy)) ? evidence.sourcePrivacy : sourceMeta?.privacy;
+            const refs = Array.isArray(evidence.derivedFrom) ? evidence.derivedFrom.filter((ref) => typeof ref === 'string') : sourceRef ? [sourceRef] : [];
+            const turns = readTurns(ctx);
+            const action = { type: 'submit_effects', effects: pending.map((raw, index) => {
+                    const call = callInput(raw), toolCallId = String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`);
+                    return { key: `${name}-tool-${turns}-${index + 1}`, toolCallId, kind: 'tool', concurrencyClass: 'tool', ...(sourceEffectId ? { llmEffectId: sourceEffectId } : {}), ...(privacy ? { privacy } : {}), ...(refs.length ? { derivedFrom: refs } : {}), input: { toolCallId, name: String(call.toolName), arguments: call.input ?? {}, ...(privacy ? { privacy } : {}), ...(refs.length ? { derivedFrom: refs } : {}) } };
+                }), wait: { onUnsatisfied: 'resume_with_error' } };
+            const locals = ordinaryLocals(ctx.lane.resume.locals);
+            const cleared = { ...locals, $sdk: { ...sdk, [approvalKey]: null, [digestKey]: null, [`${name}PendingToolEvidence`]: null } };
+            const deferred = Array.isArray(evidence.deferred) ? evidence.deferred.filter((name) => typeof name === 'string') : [];
+            const skipped = Array.isArray(evidence.skippedNames) ? evidence.skippedNames.filter((name) => typeof name === 'string') : [];
+            return dispatchTools(action, cleared, deferred, skipped);
+        });
         this.handlers.set(`${name}:decode`, (ctx) => {
             const recovered = invalidInputRecovery(ctx);
             if (recovered)
@@ -1081,6 +1175,18 @@ export class StepBuilder {
                     const toolName = canonicalToolName(rawToolName);
                     return { originalId, toolName, toolCallId: options.scopeToolCallsToEffect ? `${name}:${sourceEffectId ?? 'turn'}:${turns}:${originalId}` : `${name}:${turns}:${originalId}`, input: toolName.startsWith('ask.') && options.prepareQuestion ? options.prepareQuestion(toolName, normalizeModelToolInput(toolName, item.input ?? {}), ctx) : normalizeModelToolInput(toolName, item.input ?? {}) };
                 });
+                const questionNotice = decodedCalls.filter(call => call.toolName.startsWith('ask.')).map(call => options.validateQuestion?.(call.toolName, call.input, ctx)).find(Boolean);
+                if (questionNotice) {
+                    const key = `${name}QuestionValidationFailures`, signature = contentHash(questionNotice);
+                    const previous = callInput(sdkLocals(ctx.lane.resume.locals)[key] ?? {});
+                    const count = previous.signature === signature ? Number(previous.count ?? 0) + 1 : 1;
+                    if (count >= 3 || turns >= maxTurns)
+                        return fail({ code: 'QUESTION_VALIDATION_FAILED', message: questionNotice, retryable: false });
+                    const current = options.inputs?.(ctx) ?? {};
+                    const output = submitModel(ctx, turns + 1, { ...readInputs(ctx), ...current, conversation: [...(current.conversation ?? []), { role: 'user', content: questionNotice }] });
+                    const locals = output.locals;
+                    return { ...output, next: `${name}:decode`, locals: { ...locals, $sdk: { ...sdkLocals(locals), [key]: { signature, count } } } };
+                }
                 const patchKey = `${name}PatchRecovery`;
                 const patchRefs = [...new Set([...(readInputs(ctx).results ?? []), ...(options.inputs?.(ctx).results ?? []), ...ctx.history.flatMap(h => h.resultRefs)])];
                 const patchRecoveries = refreshPatchRecoveries(ctx, readPatchRecoveries(sdkLocals(ctx.lane.resume.locals)[patchKey]), patchRefs);
@@ -1282,68 +1388,16 @@ export class StepBuilder {
                     return { actions: [{ type: 'submit_effects', effects: askEffects, wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:tools`, locals: clearPendingResult(ctx) };
                 }
                 const makeToolEffects = (approvedCalls) => ({ type: 'submit_effects', effects: approvedCalls.map((call, index) => ({ key: `${name}-tool-${turns}-${index + 1}`, toolCallId: String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`), ...(sourceEffectId === undefined ? {} : { llmEffectId: sourceEffectId }), ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }), ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}), kind: 'tool', concurrencyClass: 'tool', input: { toolCallId: String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`), name: String(call.toolName), arguments: call.input, ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }), ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) } })), wait: { onUnsatisfied: 'resume_with_error' } });
-                const dispatchTools = (action, locals) => {
-                    if (action.type !== 'submit_effects')
-                        throw new Error('INVALID_TOOL_ACTION');
-                    const serial = options.serialTools !== undefined && calls.some((call) => options.serialTools.includes(String(call.toolName)));
-                    const limit = serial ? 1 : Math.max(1, options.maxToolsPerTurn ?? action.effects.length);
-                    const base = locals;
-                    const priorSdk = sdkLocals(base);
-                    const usedTools = new Set(Array.isArray(priorSdk[`${name}UsedTools`]) ? priorSdk[`${name}UsedTools`].filter((item) => typeof item === 'string') : []);
-                    for (const effect of action.effects) {
-                        const input = effect.input && typeof effect.input === 'object' && !Array.isArray(effect.input) ? effect.input : {};
-                        if (typeof input.name === 'string')
-                            usedTools.add(input.name);
-                    }
-                    const sdk = { ...priorSdk, [`${name}ReadGateSkipped`]: deferred, [`${name}UsedTools`]: [...usedTools], [`${name}QueuedTools`]: action.effects.slice(limit), [`${name}StopAfterSerial`]: options.stopAfterFirstSerialTool === true && serial && action.effects.length > limit };
-                    if (skippedNames.length)
-                        sdk[`${name}SkippedTools`] = skippedNames;
-                    return { actions: [{ ...action, effects: action.effects.slice(0, limit) }], next: `${name}:tools`, locals: { ...base, $sdk: sdk } };
-                };
-                if (options.toolApproval) {
+                if (options.toolApproval && (options.toolApproval.requiresApproval?.(calls) ?? true)) {
                     const approvalKey = `${name}PendingToolCalls`;
                     const digestKey = `${name}PendingToolDigest`;
                     const locals = ctx.lane.resume.locals && typeof ctx.lane.resume.locals === 'object' && !Array.isArray(ctx.lane.resume.locals) ? ctx.lane.resume.locals : {};
-                    const digest = contentHash(calls);
+                    const evidenceRecord = { sourceEffectId: sourceEffectId ?? null, sourcePrivacy: sourcePrivacy ?? null, derivedFrom: toolDerivedFrom, deferred, skippedNames };
+                    const digest = contentHash({ calls, evidence: evidenceRecord });
                     const listing = calls.map((call, index) => `${index + 1}. ${call.toolName} ${call.toolCallId}`).join('\n');
                     const extra = typeof options.toolApproval.prompt === 'string' ? options.toolApproval.prompt : options.toolApproval.prompt(calls.map((call) => ({ name: call.toolName, toolCallId: call.originalId })), ctx);
                     const prompt = boundedInstruction(`Approve ${calls.length} tool call(s). Digest ${digest}.\n${listing}\n${extra}`);
-                    this.handlers.set(`${name}:approval`, (approvalCtx) => {
-                        const resolution = waitResolution(approvalCtx.resumeInput);
-                        const dependency = resolution === undefined ? undefined : Object.values(resolution.dependencies).find((candidate) => candidate.state === 'settled');
-                        const approvalError = waitFailure(approvalCtx);
-                        if (approvalError)
-                            return fail(approvalError);
-                        const settledDependency = dependency;
-                        if (settledDependency?.state !== 'settled') {
-                            return fail({
-                                code: 'APPROVAL_RESPONSE_MISSING',
-                                message: 'Approval response was not received.',
-                                retryable: false,
-                                details: { dependencyState: settledDependency?.state ?? 'missing', waitId: resolution?.waitId ?? null },
-                            });
-                        }
-                        const value = settledDependency.outcome.resultRef ? readResult(approvalCtx, settledDependency.outcome.resultRef) : undefined;
-                        const parsed = z.object({ approved: z.boolean(), reason: z.string().optional() }).safeParse(value);
-                        if (!parsed.success)
-                            return fail({ code: 'APPROVAL_RESPONSE_INVALID', message: 'Approval response must contain approved=true or false.', retryable: false, details: parsed.error.message });
-                        if (!parsed.data.approved) {
-                            const reason = parsed.data.reason ?? 'User denied the proposed tool call.';
-                            if (options.toolApproval?.onDenied)
-                                return { next: options.toolApproval.onDenied(reason, approvalCtx) };
-                            return { next: { fail: { code: 'APPROVAL_DENIED', message: reason, retryable: false } } };
-                        }
-                        const pendingLocals = sdkLocals(approvalCtx.lane.resume.locals);
-                        const pending = pendingLocals[approvalKey];
-                        if (!Array.isArray(pending))
-                            return fail({ code: 'APPROVAL_CALLS_MISSING', message: 'Approved tool calls were not found in the persisted lane state.', retryable: false });
-                        if (pendingLocals[digestKey] !== contentHash(pending))
-                            return fail({ code: 'APPROVAL_DIGEST_MISMATCH', message: 'Persisted tool calls no longer match the approved digest.', retryable: false });
-                        const approvedCalls = pending.flatMap((item) => item && typeof item === 'object' && !Array.isArray(item) ? [{ originalId: item.originalId ?? '', toolName: item.toolName ?? '', toolCallId: item.toolCallId ?? '', input: item.input ?? {} }] : []);
-                        const cleared = { ...locals, $sdk: { ...pendingLocals, [approvalKey]: null, [digestKey]: null } };
-                        return dispatchTools(makeToolEffects(approvedCalls), cleared);
-                    });
-                    return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-approval-${turns}`, kind: 'human', concurrencyClass: 'none', input: { prompt, digest, tools: calls }, ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:approval`, locals: { ...locals, $sdk: { ...sdkLocals(locals), [approvalKey]: calls, [digestKey]: digest } } };
+                    return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-approval-${turns}`, kind: 'human', concurrencyClass: 'none', input: { prompt, digest, tools: calls }, ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:approval`, locals: { ...locals, $sdk: { ...sdkLocals(locals), [approvalKey]: calls, [digestKey]: digest, [`${name}PendingToolEvidence`]: evidenceRecord } } };
                 }
                 const gatedLocals = clearPendingResult(ctx);
                 const gatedSdk = { ...sdkLocals(gatedLocals) };
@@ -1351,7 +1405,7 @@ export class StepBuilder {
                     gatedSdk[editGateKey] = editGateReads + 1;
                 else
                     delete gatedSdk[editGateKey];
-                return dispatchTools(makeToolEffects(calls), { ...gatedLocals, $sdk: gatedSdk });
+                return dispatchTools(makeToolEffects(calls), { ...gatedLocals, $sdk: gatedSdk }, deferred, skippedNames);
             }
             const answerText = typeof record?.text === 'string' ? record.text : '';
             if (toolCalls.length === 0 && looksLikeUnexecutedToolRequest(answerText)) {

package/dist/dsl/templates.d.ts

@@ -21,6 +21,7 @@ export interface ReActLaneConfig {
     maxTruncationRetries?: number;
     maxToolsPerTurn?: number;
     prepareQuestion?: (toolName: string, input: JsonValue, ctx: StepContext<JsonValue>) => JsonValue;
+    validateQuestion?: (toolName: string, input: JsonValue, ctx: StepContext<JsonValue>) => string | undefined;
     onHumanReply?: (question: JsonValue, answer: JsonValue, ctx: StepContext<JsonValue>) => NextStepTarget<JsonValue> | undefined;
     /** Bound investigation-only rounds for an implementation run; pagination is exempt. */
     maxReadOnlyRounds?: number | ((ctx: StepContext<JsonValue>) => number | undefined);
@@ -30,7 +31,9 @@ export interface ReActLaneConfig {
     resetTurnsOnEntry?: (ctx: StepContext<JsonValue>) => string | number | undefined;
     outputSchema?: ZodTypeAny;
     requirements?: Record<string, JsonValue>;
+    manualApprovalFallback?: boolean;
     toolApproval?: {
+        requiresApproval?: (calls: JsonValue) => boolean;
         prompt: string | ((calls: JsonValue, ctx: StepContext<JsonValue>) => string);
         onDenied?: (reason: string, ctx: StepContext<JsonValue>) => NextStepTarget<JsonValue>;
     };

package/dist/dsl/templates.js

@@ -4,7 +4,7 @@ export function defineReActLane(config) {
         const onFinish = config.onFinish ?? (config.outputSchema === undefined
             ? { text: (resultRef) => ({ complete: { value: { textRef: resultRef } } }) }
             : { text: (resultRef) => ({ complete: { value: { textRef: resultRef } } }), structured: { schema: config.outputSchema, onParsed: (value) => ({ complete: { value: value } }) } });
-        builder.addReActLoopStep('react', { ...(config.task === undefined ? {} : { task: config.task }), instruction: config.instruction, ...(config.prepareQuestion === undefined ? {} : { prepareQuestion: config.prepareQuestion }), ...(config.onHumanReply === undefined ? {} : { onHumanReply: config.onHumanReply }), ...(config.inputs === undefined ? {} : { inputs: config.inputs }), ...(config.toolAllow === undefined ? {} : { toolAllow: config.toolAllow }), ...(config.maxToolsPerTurn === undefined ? {} : { maxToolsPerTurn: config.maxToolsPerTurn }), ...(config.maxReadOnlyRounds === undefined ? {} : { maxReadOnlyRounds: config.maxReadOnlyRounds }), ...(config.serialTools === undefined ? {} : { serialTools: config.serialTools }), ...(config.stopAfterFirstSerialTool === undefined ? {} : { stopAfterFirstSerialTool: config.stopAfterFirstSerialTool }), ...(config.maxTruncationRetries === undefined ? {} : { maxTruncationRetries: config.maxTruncationRetries }), ...(config.maxTurns === undefined ? {} : { maxTurns: config.maxTurns }), ...(config.resetTurnsOnEntry === undefined ? {} : { resetTurnsOnEntry: config.resetTurnsOnEntry }), ...(config.outputSchema === undefined ? {} : { outputSchema: config.outputSchema }), ...(config.requirements === undefined ? {} : { requirements: config.requirements }), ...(config.toolApproval === undefined ? {} : { toolApproval: config.toolApproval }), onFinish });
+        builder.addReActLoopStep('react', { ...(config.task === undefined ? {} : { task: config.task }), instruction: config.instruction, ...(config.manualApprovalFallback ? { manualApprovalFallback: true } : {}), ...(config.prepareQuestion === undefined ? {} : { prepareQuestion: config.prepareQuestion }), ...(config.validateQuestion === undefined ? {} : { validateQuestion: config.validateQuestion }), ...(config.onHumanReply === undefined ? {} : { onHumanReply: config.onHumanReply }), ...(config.inputs === undefined ? {} : { inputs: config.inputs }), ...(config.toolAllow === undefined ? {} : { toolAllow: config.toolAllow }), ...(config.maxToolsPerTurn === undefined ? {} : { maxToolsPerTurn: config.maxToolsPerTurn }), ...(config.maxReadOnlyRounds === undefined ? {} : { maxReadOnlyRounds: config.maxReadOnlyRounds }), ...(config.serialTools === undefined ? {} : { serialTools: config.serialTools }), ...(config.stopAfterFirstSerialTool === undefined ? {} : { stopAfterFirstSerialTool: config.stopAfterFirstSerialTool }), ...(config.maxTruncationRetries === undefined ? {} : { maxTruncationRetries: config.maxTruncationRetries }), ...(config.maxTurns === undefined ? {} : { maxTurns: config.maxTurns }), ...(config.resetTurnsOnEntry === undefined ? {} : { resetTurnsOnEntry: config.resetTurnsOnEntry }), ...(config.outputSchema === undefined ? {} : { outputSchema: config.outputSchema }), ...(config.requirements === undefined ? {} : { requirements: config.requirements }), ...(config.toolApproval === undefined ? {} : { toolApproval: config.toolApproval }), onFinish });
         config.extend?.(builder);
     });
 }

package/dist/scheduler/runtime.js

@@ -2616,6 +2616,12 @@ export class PulseRuntime {
         }
         let effectiveExecution = execution;
         let outputError = error ?? execution.error;
+        // A timeout remains a failure even when an aborted executor returns a generic cancellation.
+        const timeoutReason = effect.cancelRequested?.reason;
+        if (timeoutReason === 'ATTEMPT_TIMEOUT' || timeoutReason === 'TIMEOUT') {
+            outputError = { code: timeoutReason, message: `Effect exceeded its execution time limit (${timeoutReason}).`, retryable: false };
+            effectiveExecution = { ...execution, status: 'failed', executionState: 'failed', error: outputError };
+        }
         let resultDerivedFrom = [...(effect.derivedFrom ?? [])];
         let publishedArtifact;
         const rawInput = effect.input && typeof effect.input === 'object' && !Array.isArray(effect.input) ? effect.input : {};

package/dist/tools/registry.d.ts

@@ -58,6 +58,7 @@ export interface RuntimeToolDefinition {
     execute(input: unknown, context: RuntimeToolContext): Promise<unknown> | unknown;
     executionRef?(input: unknown, context: RuntimeToolContext): JsonValue;
     resolveResources?(input: unknown): ResourceLockSpec[];
+    resolveTimeoutMs?(input: unknown): number;
     reconcile?(executionRef: JsonValue, context: RuntimeReconcileContext): Promise<RuntimeReconcileResult>;
     normalize?(output: unknown): JsonValue;
     summarize?(output: unknown): JsonValue;

package/dist/tools/registry.js

@@ -299,7 +299,10 @@ export class RuntimeToolRegistry {
     admission(name, input) {
         const definition = this.require(name);
         const parsed = this.validateInput(name, input);
-        return { locks: structuredClone(this.resolveResources(name, parsed)), sideEffectPolicy: definition.manifest.sideEffectPolicy, defaultTimeoutMs: definition.manifest.defaultTimeoutMs, retrySafety: definition.manifest.retrySafety, version: definition.manifest.version };
+        const timeout = definition.resolveTimeoutMs?.(parsed) ?? definition.manifest.defaultTimeoutMs;
+        if (definition.resolveTimeoutMs && (!Number.isSafeInteger(timeout) || timeout <= 0 || timeout > 600_000))
+            throw Object.assign(new Error('Resolved tool timeout is outside host limits.'), { code: 'INVALID_TOOL_TIMEOUT' });
+        return { locks: structuredClone(this.resolveResources(name, parsed)), sideEffectPolicy: definition.manifest.sideEffectPolicy, defaultTimeoutMs: timeout, retrySafety: definition.manifest.retrySafety, version: definition.manifest.version };
     }
     require(name) {
         if (!this.isAllowed(name))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunterzhu/pulse-runtime",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "PolyForm-Noncommercial-1.0.0",
   "repository": {
     "type": "git",