1cf86baa1c
## Summary
Wave 18 continues the package code-organization program after wave 17
domain folders (U4 Slice A from
`docs/plans/2026-07-14-001-refactor-package-code-organization-plan.md`).
### What changed
Peel **pure, behavior-preserving** helpers out of
`packages/engine/src/executor.ts` into domain modules under
`packages/engine/src/executor/`, with **stable re-exports** from
`executor.ts` so deep imports and `vi.mock("../executor.js")` keep
working.
| New module | Symbols |
|------------|---------|
| `executor/task-done-refusal.ts` | `evaluateTaskDoneRefusal`,
`determineRevisionResetStart`, skip-bypass refusal helper |
| `executor/workflow-feedback-paths.ts` |
`extractReferencedPathsFromWorkflowFeedback`,
`isAlwaysAllowedScopeLeakPath`, `workflowPathMatchesDeclaredScope` |
| `executor/workflow-step-verdict.ts` |
`FUSION_WORKFLOW_STEP_CONVENTIONS_PREAMBLE`, `parseWorkflowStepVerdict`
/ `parseWorkflowStepOutput`, step outcome types |
| `executor/await-input-parse.ts` | `parseAwaitInputSentinel`,
`parseAwaitInputQuestionToolCall` |
| `executor/no-commit-eligibility.ts` | `getNoCommitEligibilityReason`
(+ prompt heuristics) |
`executor.ts` live LOC ~**22817 → ~22427** (first pure-peel batch; more
peels needed to approach the 2k cap).
### Shims
- `old path` `executor.ts` public exports → `new path` `executor/*.ts` →
delete-when consumer deep-imports are re-pointed (not this PR)
### Test plan
- [x] `@fusion/engine` typecheck
- [x] Oracle: task-done refusal, skip-bypass, workflow malformed
verdict, scope-leak allowlist, executor-step-session, executor-prompt
- [x] `vitest --project=engine-core` (merge-gate curated suite)
- [ ] CI merge gate
**Stack:** wave17 (merged) → **this PR**
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **New Features**
* Improved recognition of workflow outcomes from structured and
conversational responses.
* Added support for extracting questions from await-input responses and
tool calls.
* Improved workflow feedback handling for referenced files and declared
scope patterns.
* Added clearer guidance for task execution, approvals, verification,
and available tools.
* **Bug Fixes**
* Prevented completion when required review approvals are missing or
revisions remain pending.
* Improved handling of workflows that legitimately require no code
changes.
* Added clearer refusal messages and more reliable revision restarts.
* Sanitized repository paths in Git remediation instructions.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
102 lines
22 KiB
TypeScript
102 lines
22 KiB
TypeScript
/**
|
|
* FNXC:CodeOrganization 2026-08-04-09:20:
|
|
* Workflow graph / merge-boundary / graph-failure routing facades peeled from TaskExecutor (U4).
|
|
* isBackwardMoveOutOfPlanning stays on TaskExecutor for inert-sync-lane (2 guards).
|
|
*/
|
|
import type { Task, TaskDetail, Settings, Agent, WorkflowIr, WorkflowColumnAgent } from "@fusion/core";
|
|
import * as impl from "./impl-bindings.js";
|
|
import * as bags from "./deps-bags.js";
|
|
import { type FacadeRestArgs, type FacadeAfterFirst } from "./facade-methods.js";
|
|
import { createWorkflowRuntimePrimitiveProvider } from "../workflows/workflow-runtime-primitive-provider.js";
|
|
import { TaskExecutorSessionFacades } from "./task-executor-session-facades.js";
|
|
|
|
export abstract class TaskExecutorGraphFacades extends TaskExecutorSessionFacades {
|
|
protected async executeWorkflowGraph(...args: FacadeRestArgs<typeof impl.executeWorkflowGraphImpl>): ReturnType<typeof impl.executeWorkflowGraphImpl> { return impl.executeWorkflowGraphImpl(bags.buildExecuteWorkflowGraphDeps(this), ...args); }
|
|
protected buildBranchPersistence(): ReturnType<typeof impl.buildBranchPersistenceImpl> { return impl.buildBranchPersistenceImpl({ store: this.store }); }
|
|
protected buildStepInstancePersistence(): ReturnType<typeof impl.buildStepInstancePersistenceImpl> { return impl.buildStepInstancePersistenceImpl({ store: this.store }); }
|
|
protected async advanceNoMergeWorkflowToCompleteColumn(task: TaskDetail): ReturnType<typeof impl.advanceNoMergeWorkflowToCompleteColumnImpl> { return impl.advanceNoMergeWorkflowToCompleteColumnImpl(this.store, task); }
|
|
protected buildColumnBoundaryHooks(task: Pick<Task, "id">, workflowRunId?: string): ReturnType<typeof impl.buildColumnBoundaryHooksImpl> { return impl.buildColumnBoundaryHooksImpl(bags.buildColumnBoundaryHooksFacadeDeps(this), task, workflowRunId); }
|
|
protected resolveTaskStepSource(ir: WorkflowIr | undefined) { return impl.resolveTaskStepSourceImpl(ir); }
|
|
protected async resolveTaskCustomFieldDefs(taskId: string): ReturnType<typeof impl.resolveTaskCustomFieldDefsImpl> { return impl.resolveTaskCustomFieldDefsImpl({ store: this.store }, taskId); }
|
|
protected async readTaskArtifact(taskId: string, key: string): ReturnType<typeof impl.readTaskArtifactImpl> { return impl.readTaskArtifactImpl({ store: this.store }, taskId, key); }
|
|
protected buildParseStepsDeps(runId?: string): ReturnType<typeof impl.buildParseStepsDepsImpl> { return impl.buildParseStepsDepsImpl(bags.buildParseStepsFacadeDeps(this), runId); }
|
|
protected buildCodeNodeRunner(): ReturnType<typeof impl.buildCodeNodeRunnerImpl> { return impl.buildCodeNodeRunnerImpl(bags.buildCodeNodeRunnerFacadeDeps(this)); }
|
|
protected buildForeachWorktreeDeps(...args: FacadeRestArgs<typeof impl.buildForeachWorktreeDepsImpl>): ReturnType<typeof impl.buildForeachWorktreeDepsImpl> { return impl.buildForeachWorktreeDepsImpl(bags.buildBuildForeachWorktreeDepsDeps(this), ...args); }
|
|
protected async applyGraphRethinkReset(...args: FacadeRestArgs<typeof impl.applyGraphRethinkResetImpl>): ReturnType<typeof impl.applyGraphRethinkResetImpl> { return impl.applyGraphRethinkResetImpl(bags.buildApplyGraphRethinkResetDeps(this), ...args); }
|
|
protected async runImplementationPhase(...args: FacadeRestArgs<typeof impl.runImplementationPhaseImpl>): ReturnType<typeof impl.runImplementationPhaseImpl> { return impl.runImplementationPhaseImpl(bags.buildRunImplementationPhaseDeps(this), ...args); }
|
|
protected async runGraphTaskStep(...args: FacadeRestArgs<typeof impl.runGraphTaskStepImpl>): ReturnType<typeof impl.runGraphTaskStepImpl> { return impl.runGraphTaskStepImpl(bags.buildRunGraphTaskStepDeps(this), ...args); }
|
|
protected foreachActiveForTask(taskId: string, instanceId?: string): ReturnType<typeof impl.foreachActiveForTaskImpl> { return impl.foreachActiveForTaskImpl({ graphStepActiveContext: this.graphStepActiveContext }, taskId, instanceId); }
|
|
protected async runProjectedGraphTaskStep(...args: FacadeRestArgs<typeof impl.runProjectedGraphTaskStepImpl>): ReturnType<typeof impl.runProjectedGraphTaskStepImpl> { return impl.runProjectedGraphTaskStepImpl(bags.buildRunProjectedGraphTaskStepDeps(this), ...args); }
|
|
public createAuthoritativeWorkflowPrimitives(settings: Settings) { return createWorkflowRuntimePrimitiveProvider((providerSettings) => this.createAuthoritativeWorkflowPrimitivesFromExecutor(providerSettings)).create(settings); }
|
|
protected createAuthoritativeWorkflowPrimitivesFromExecutor(settings: Settings): ReturnType<typeof impl.createAuthoritativeWorkflowPrimitivesFromExecutorImpl> { return impl.createAuthoritativeWorkflowPrimitivesFromExecutorImpl(bags.buildCreateAuthoritativeWorkflowPrimitivesFromExecutorDeps(this), settings); }
|
|
protected async resolveMergeBoundaryColumn(taskId: string, nodeId: string): ReturnType<typeof impl.resolveMergeBoundaryColumnImpl> { return impl.resolveMergeBoundaryColumnImpl({ store: this.store }, taskId, nodeId); }
|
|
protected async ensureWorkflowMergeBoundaryTask(...args: FacadeRestArgs<typeof impl.ensureWorkflowMergeBoundaryTaskImpl>): ReturnType<typeof impl.ensureWorkflowMergeBoundaryTaskImpl> { return impl.ensureWorkflowMergeBoundaryTaskImpl(bags.buildEnsureWorkflowMergeBoundaryTaskDeps(this), ...args); }
|
|
protected async evaluateWorkflowMergeBoundary(...args: FacadeRestArgs<typeof impl.evaluateWorkflowMergeBoundaryImpl>): ReturnType<typeof impl.evaluateWorkflowMergeBoundaryImpl> { return impl.evaluateWorkflowMergeBoundaryImpl(bags.buildEvaluateWorkflowMergeBoundaryDeps(this), ...args); }
|
|
protected async loadMergeBoundaryInstances(...args: FacadeRestArgs<typeof impl.loadMergeBoundaryInstancesImpl>): ReturnType<typeof impl.loadMergeBoundaryInstancesImpl> { return impl.loadMergeBoundaryInstancesImpl({ store: this.store }, ...args); }
|
|
protected async getWorkflowMergeImplementationProofFailure(...args: FacadeRestArgs<typeof impl.getWorkflowMergeImplementationProofFailureImpl>): ReturnType<typeof impl.getWorkflowMergeImplementationProofFailureImpl> { return impl.getWorkflowMergeImplementationProofFailureImpl(bags.buildWorkflowMergeImplementationProofFailureDeps(this), ...args); }
|
|
protected shouldCompleteChecklistAtWorkflowMerge(task: TaskDetail, proof?: { complete: boolean }): ReturnType<typeof impl.shouldCompleteChecklistAtWorkflowMergeImpl> { return impl.shouldCompleteChecklistAtWorkflowMergeImpl(task, proof); }
|
|
public createAuthoritativeWorkflowSeams(_settings: Settings) { return impl.createAuthoritativeWorkflowSeamsImpl(bags.buildCreateAuthoritativeWorkflowSeamsDeps(this), _settings); }
|
|
protected async updateStepGraph(...args: FacadeRestArgs<typeof impl.updateStepGraphImpl>): ReturnType<typeof impl.updateStepGraphImpl> { return impl.updateStepGraphImpl({ store: this.store }, ...args); }
|
|
protected async runAwaitInputNode(node: Parameters<typeof impl.runAwaitInputNodeImpl>[1], live: TaskDetail): ReturnType<typeof impl.runAwaitInputNodeImpl> { return impl.runAwaitInputNodeImpl(bags.buildStoreRunContextDeps(this), node, live); }
|
|
protected async pauseForCliApproval(node: Parameters<typeof impl.pauseForCliApprovalImpl>[1], live: TaskDetail, command: string): ReturnType<typeof impl.pauseForCliApprovalImpl> { return impl.pauseForCliApprovalImpl(bags.buildStoreRunContextDeps(this), node, live, command); }
|
|
protected async runRawCliCommand(...args: FacadeRestArgs<typeof impl.runRawCliCommandImpl>): Promise<{ success: boolean; output?: string; error?: string }> { return impl.runRawCliCommandImpl(bags.buildRunRawCliCommandDeps(this), ...args); }
|
|
protected async adoptColumnAgentForNode(...args: FacadeRestArgs<typeof impl.adoptColumnAgentForNodeImpl>): Promise<{ modelProvider?: string; modelId?: string; persona?: string } | undefined> { return impl.adoptColumnAgentForNodeImpl(bags.buildAdoptColumnAgentForNodeDeps(this), ...args); }
|
|
protected async resolveSeamColumnAgent(...args: FacadeRestArgs<typeof impl.resolveSeamColumnAgentImpl>): Promise<{ agent: Agent; mode: WorkflowColumnAgent["mode"] | undefined } | undefined> { return impl.resolveSeamColumnAgentImpl(bags.buildResolveSeamColumnAgentDeps(this), ...args); }
|
|
protected resolveEffectivePrincipalId(...args: FacadeRestArgs<typeof impl.resolveEffectivePrincipalIdImpl>): ReturnType<typeof impl.resolveEffectivePrincipalIdImpl> { return impl.resolveEffectivePrincipalIdImpl(bags.buildResolveEffectivePrincipalIdDeps(this), ...args); }
|
|
isAgentEffectivelyExecuting(agentId: string): boolean { return impl.isAgentEffectivelyExecutingImpl(this.effectiveColumnAgentByTask, agentId); }
|
|
protected async buildInjectedRuntimeEnv(...args: FacadeRestArgs<typeof impl.buildInjectedRuntimeEnvImpl>): Promise<{ env: NodeJS.ProcessEnv; injectedKeyCount: number; pathEntryCount: number }> { return impl.buildInjectedRuntimeEnvImpl(bags.buildInjectedRuntimeEnvDeps(this), ...args); }
|
|
protected async ensureGraphCustomNodeWorktree(...args: FacadeRestArgs<typeof impl.ensureGraphCustomNodeWorktreeImpl>): ReturnType<typeof impl.ensureGraphCustomNodeWorktreeImpl> { return impl.ensureGraphCustomNodeWorktreeImpl(bags.buildEnsureGraphCustomNodeWorktreeDeps(this), ...args); }
|
|
public async releasePreExecutionWorktree(...args: FacadeRestArgs<typeof impl.releasePreExecutionWorktreeImpl>): ReturnType<typeof impl.releasePreExecutionWorktreeImpl> { return impl.releasePreExecutionWorktreeImpl(bags.buildReleasePreExecutionWorktreeDeps(this), ...args); }
|
|
public async ensureTaskWorktreeForPlanning(taskId: string): Promise<string | null> { return impl.ensureTaskWorktreeForPlanningImpl(bags.buildEnsureTaskWorktreeForPlanningDeps(this), taskId); }
|
|
protected async prepareGraphNodeExecution(...args: FacadeRestArgs<typeof impl.prepareGraphNodeExecutionImpl>): ReturnType<typeof impl.prepareGraphNodeExecutionImpl> { return impl.prepareGraphNodeExecutionImpl(bags.buildPrepareGraphNodeExecutionDeps(this), ...args); }
|
|
protected async finalizeMergeConfirmedWorkflowGraphTask(...args: FacadeRestArgs<typeof impl.finalizeMergeConfirmedWorkflowGraphTaskImpl>): ReturnType<typeof impl.finalizeMergeConfirmedWorkflowGraphTaskImpl> { return impl.finalizeMergeConfirmedWorkflowGraphTaskImpl(bags.buildFinalizeMergeConfirmedWorkflowGraphTaskDeps(this), ...args); }
|
|
protected async runGraphCustomNode(...args: FacadeRestArgs<typeof impl.runGraphCustomNodeImpl>): ReturnType<typeof impl.runGraphCustomNodeImpl> { return impl.runGraphCustomNodeImpl(bags.buildRunGraphCustomNodeDeps(this), ...args); }
|
|
protected async runCliAgentNode(...args: FacadeRestArgs<typeof impl.runCliAgentNodeImpl>): ReturnType<typeof impl.runCliAgentNodeImpl> { return impl.runCliAgentNodeImpl(bags.buildRunCliAgentNodeDeps(this), ...args); }
|
|
protected async reapCliTaskSessionForHandoff(session: Parameters<typeof impl.reapCliTaskSessionForHandoffImpl>[0], taskId: string): ReturnType<typeof impl.reapCliTaskSessionForHandoffImpl> { return impl.reapCliTaskSessionForHandoffImpl(session, taskId); }
|
|
protected clearSessionContentionHold(taskId: string): void { this.sessionContentionHoldAttempts.delete(taskId); }
|
|
protected async holdForSessionContention(...args: FacadeRestArgs<typeof impl.holdForSessionContentionImpl>): ReturnType<typeof impl.holdForSessionContentionImpl> { return impl.holdForSessionContentionImpl(bags.buildHoldForSessionContentionDeps(this), ...args); }
|
|
protected async routeUnusableWorktreeGraphFailureToRecovery(...args: FacadeRestArgs<typeof impl.routeUnusableWorktreeGraphFailureToRecoveryImpl>): ReturnType<typeof impl.routeUnusableWorktreeGraphFailureToRecoveryImpl> { return impl.routeUnusableWorktreeGraphFailureToRecoveryImpl(bags.buildRouteUnusableWorktreeGraphFailureToRecoveryDeps(this), ...args); }
|
|
protected hasLiveTaskSessionSurface(taskId: string): ReturnType<typeof impl.hasLiveTaskSessionSurfaceImpl> { return impl.hasLiveTaskSessionSurfaceImpl(bags.buildHasLiveTaskSessionSurfaceDeps(this), taskId); }
|
|
protected async isRemediationGraphNode(taskId: string, failedNode: string | undefined): ReturnType<typeof impl.isRemediationGraphNodeImpl> { return impl.isRemediationGraphNodeImpl({ store: this.store }, taskId, failedNode); }
|
|
protected async isPreMergeRemediationGraphNode(taskId: string, failedNode: string | undefined): ReturnType<typeof impl.isPreMergeRemediationGraphNodeImpl> { return impl.isPreMergeRemediationGraphNodeImpl({ store: this.store }, taskId, failedNode); }
|
|
protected async resolveFailedPreMergeWorkflowStepBudget(...args: FacadeAfterFirst<typeof impl.resolveFailedPreMergeWorkflowStepBudgetImpl>): ReturnType<typeof impl.resolveFailedPreMergeWorkflowStepBudgetImpl> { return impl.resolveFailedPreMergeWorkflowStepBudgetImpl({ store: this.store }, ...args); }
|
|
protected async isLiveSharedBranchGroupMember(live: Pick<TaskDetail, "branchContext" | "autoMerge" | "autoMergeProvenance">): ReturnType<typeof impl.isLiveSharedBranchGroupMemberImpl> { return impl.isLiveSharedBranchGroupMemberImpl({ store: this.store, rootDir: this.rootDir }, live); }
|
|
protected async routeRetryableRemediationGraphFailureToPreMergeFix(...args: FacadeRestArgs<typeof impl.routeRetryableRemediationGraphFailureToPreMergeFixImpl>): ReturnType<typeof impl.routeRetryableRemediationGraphFailureToPreMergeFixImpl> { return impl.routeRetryableRemediationGraphFailureToPreMergeFixImpl(bags.buildRouteRetryableRemediationGraphFailureToPreMergeFixDeps(this), ...args); }
|
|
protected async isRetryableBenignMergePauseAbort(...args: FacadeRestArgs<typeof impl.isRetryableBenignMergePauseAbortImpl>): ReturnType<typeof impl.isRetryableBenignMergePauseAbortImpl> { return impl.isRetryableBenignMergePauseAbortImpl(bags.buildResumeLaneClassifierDeps(this), ...args); }
|
|
protected async isBenignManualMergeHoldPauseAbort(...args: FacadeRestArgs<typeof impl.isBenignManualMergeHoldPauseAbortImpl>): ReturnType<typeof impl.isBenignManualMergeHoldPauseAbortImpl> { return impl.isBenignManualMergeHoldPauseAbortImpl(bags.buildResumeLaneClassifierDeps(this), ...args); }
|
|
protected async handleStaleInReviewPlanPauseAbortReplay(...args: FacadeRestArgs<typeof impl.handleStaleInReviewPlanPauseAbortReplayImpl>): ReturnType<typeof impl.handleStaleInReviewPlanPauseAbortReplayImpl> { return impl.handleStaleInReviewPlanPauseAbortReplayImpl(bags.buildHandleStaleInReviewPlanPauseAbortReplayDeps(this), ...args); }
|
|
protected async handleStaleInReviewParsePauseAbortReplay(...args: FacadeRestArgs<typeof impl.handleStaleInReviewParsePauseAbortReplayImpl>): ReturnType<typeof impl.handleStaleInReviewParsePauseAbortReplayImpl> { return impl.handleStaleInReviewParsePauseAbortReplayImpl(bags.buildHandleStaleInReviewParsePauseAbortReplayDeps(this), ...args); }
|
|
protected async isReentrantPausedAbortedInFlightNode(...args: FacadeRestArgs<typeof impl.isReentrantPausedAbortedInFlightNodeImpl>): ReturnType<typeof impl.isReentrantPausedAbortedInFlightNodeImpl> { return impl.isReentrantPausedAbortedInFlightNodeImpl(bags.buildResumeLaneClassifierDeps(this), ...args); }
|
|
protected async resolveResumeLanes(...args: FacadeRestArgs<typeof impl.resolveResumeLanesImpl>): Promise<{ hold: string; wip: string; review: string; wipDeclared: boolean }> { return impl.resolveResumeLanesImpl({ store: this.store }, ...args); }
|
|
protected async reenterPausedAbortedWorkflowNode(...args: FacadeRestArgs<typeof impl.reenterPausedAbortedWorkflowNodeImpl>): ReturnType<typeof impl.reenterPausedAbortedWorkflowNodeImpl> { return impl.reenterPausedAbortedWorkflowNodeImpl(bags.buildReenterPausedAbortedWorkflowNodeDeps(this), ...args); }
|
|
protected async routeGraphMergeFailureToRetry(...args: FacadeRestArgs<typeof impl.routeGraphMergeFailureToRetryImpl>): ReturnType<typeof impl.routeGraphMergeFailureToRetryImpl> { return impl.routeGraphMergeFailureToRetryImpl(bags.buildRouteGraphMergeFailureToRetryDeps(this), ...args); }
|
|
protected async routeImplementationIncompleteMergeGraphFailure(...args: FacadeRestArgs<typeof impl.routeImplementationIncompleteMergeGraphFailureImpl>): ReturnType<typeof impl.routeImplementationIncompleteMergeGraphFailureImpl> { return impl.routeImplementationIncompleteMergeGraphFailureImpl(bags.buildRouteImplementationIncompleteMergeGraphFailureDeps(this), ...args); }
|
|
protected async hasTrailingConsecutiveToolFailures(taskId: string, cursor: number | null | undefined, threshold: number): ReturnType<typeof impl.hasTrailingConsecutiveToolFailuresImpl> { return impl.hasTrailingConsecutiveToolFailuresImpl({ store: this.store }, taskId, cursor, threshold); }
|
|
protected async handleGraphFailure(task: Task, result: Parameters<typeof impl.handleGraphFailureImpl>[2]): ReturnType<typeof impl.handleGraphFailureImpl> { return impl.handleGraphFailureImpl(bags.buildHandleGraphFailureDeps(this), task, result); }
|
|
protected async routeGraphFailureToExecutionResume(...args: FacadeRestArgs<typeof impl.routeGraphFailureToExecutionResumeImpl>): ReturnType<typeof impl.routeGraphFailureToExecutionResumeImpl> { return impl.routeGraphFailureToExecutionResumeImpl(bags.buildRouteGraphFailureToExecutionResumeDeps(this), ...args); }
|
|
protected async routeResetParsePinMismatchToRetry(live: TaskDetail): ReturnType<typeof impl.routeResetParsePinMismatchToRetryImpl> { return impl.routeResetParsePinMismatchToRetryImpl(bags.buildRouteResetParsePinMismatchToRetryDeps(this), live); }
|
|
protected async maybeDispatchWorkflowWorkEngine(task: Task): ReturnType<typeof impl.maybeDispatchWorkflowWorkEngineImpl> { return impl.maybeDispatchWorkflowWorkEngineImpl({ store: this.store }, task); }
|
|
protected async evaluateTaskVerdictProviders(...args: FacadeRestArgs<typeof impl.evaluateTaskVerdictProvidersImpl>): Promise<{ ok: true } | { ok: false; message: string }> { return impl.evaluateTaskVerdictProvidersImpl({ store: this.store }, ...args); }
|
|
protected async blockOuterDispatchWhenDependenciesUnmet(task: Task): ReturnType<typeof impl.blockOuterDispatchWhenDependenciesUnmetImpl> { return impl.blockOuterDispatchWhenDependenciesUnmetImpl(bags.buildStoreRunContextDeps(this), task); }
|
|
protected async blockOuterDispatchWhenEphemeralDisabled(task: Task): ReturnType<typeof impl.blockOuterDispatchWhenEphemeralDisabledImpl> { return impl.blockOuterDispatchWhenEphemeralDisabledImpl(bags.buildBlockOuterDispatchWhenEphemeralDisabledDeps(this), task); }
|
|
protected getAutoRecoveryDispatcher(audit: Parameters<typeof impl.getAutoRecoveryDispatcherImpl>[1]): ReturnType<typeof impl.getAutoRecoveryDispatcherImpl> { return impl.getAutoRecoveryDispatcherImpl(bags.buildGetAutoRecoveryDispatcherDeps(this), audit); }
|
|
protected async renewTaskLease(...args: FacadeRestArgs<typeof impl.renewTaskLeaseImpl>): ReturnType<typeof impl.renewTaskLeaseImpl> { return impl.renewTaskLeaseImpl(bags.buildRenewTaskLeaseDeps(this), ...args); }
|
|
protected async finalizeAlreadyReviewedTask(taskId: string): ReturnType<typeof impl.finalizeAlreadyReviewedTaskImpl> { return impl.finalizeAlreadyReviewedTaskImpl(bags.buildFinalizeAlreadyReviewedTaskDeps(this), taskId); }
|
|
protected async getExecutionPauseLabel(): ReturnType<typeof impl.getExecutionPauseLabelImpl> { return impl.getExecutionPauseLabelImpl({ store: this.store }); }
|
|
protected async shouldDeferCompletionForGlobalPause(...args: FacadeRestArgs<typeof impl.shouldDeferCompletionForGlobalPauseImpl>): ReturnType<typeof impl.shouldDeferCompletionForGlobalPauseImpl> { return impl.shouldDeferCompletionForGlobalPauseImpl(bags.buildShouldDeferCompletionForGlobalPauseDeps(this), ...args); }
|
|
protected async shouldDeferWorkflowStepCompletion(...args: FacadeRestArgs<typeof impl.shouldDeferWorkflowStepCompletionImpl>): ReturnType<typeof impl.shouldDeferWorkflowStepCompletionImpl> { return impl.shouldDeferWorkflowStepCompletionImpl(bags.buildShouldDeferWorkflowStepCompletionDeps(this), ...args); }
|
|
protected async handoffTaskToReview(...args: FacadeRestArgs<typeof impl.handoffTaskToReviewImpl>): ReturnType<typeof impl.handoffTaskToReviewImpl> { return impl.handoffTaskToReviewImpl(bags.buildHandoffTaskToReviewDeps(this), ...args); }
|
|
protected async generateCompletionFeatureVideo(task: Task): ReturnType<typeof impl.generateCompletionFeatureVideoImpl> { return impl.generateCompletionFeatureVideoImpl(bags.buildGenerateCompletionFeatureVideoDeps(this), task); }
|
|
protected async awaitFeatureVideoBounded(result: Promise<import("../review-artifacts/feature-video.js").FeatureVideoResult>): Promise<import("../review-artifacts/feature-video.js").FeatureVideoResult> { return impl.awaitFeatureVideoBoundedImpl(result); }
|
|
protected getModelRegistry() { return impl.getModelRegistryImpl({ getModelRegistryCache: () => this._modelRegistry, setModelRegistryCache: (value) => { this._modelRegistry = value; } }); }
|
|
protected get approvalRequestStore() { return impl.getApprovalRequestStoreImpl({ getCache: () => this._approvalRequestStore, setCache: (value) => { this._approvalRequestStore = value; }, store: this.store }); }
|
|
protected buildActionGateContext(...args: FacadeRestArgs<typeof impl.buildActionGateContextImpl>): ReturnType<typeof impl.buildActionGateContextImpl> { return impl.buildActionGateContextImpl(bags.buildBuildActionGateContextDeps(this), ...args); }
|
|
protected buildPermanentAgentGatingContext(...args: FacadeRestArgs<typeof impl.buildPermanentAgentGatingContextImpl>): ReturnType<typeof impl.buildPermanentAgentGatingContextImpl> { return impl.buildPermanentAgentGatingContextImpl(bags.buildBuildPermanentAgentGatingContextDeps(this), ...args); }
|
|
protected async resetMergeStateIfNeeded(task: Task, from: Task["column"]): ReturnType<typeof impl.resetMergeStateIfNeededImpl> { return impl.resetMergeStateIfNeededImpl(bags.buildResetMergeStateIfNeededDeps(this), task, from); }
|
|
protected async cleanupMergeStateForReverification(...args: FacadeRestArgs<typeof impl.cleanupMergeStateForReverificationImpl>): ReturnType<typeof impl.cleanupMergeStateForReverificationImpl> { return impl.cleanupMergeStateForReverificationImpl(bags.buildStoreRunContextDeps(this), ...args); }
|
|
protected async clearResumeFailureState(task: Task): ReturnType<typeof impl.clearResumeFailureStateImpl> { return impl.clearResumeFailureStateImpl({ store: this.store }, task); }
|
|
protected async isRequiredArtifactRecoveryProtected(task: Task): ReturnType<typeof impl.isRequiredArtifactRecoveryProtectedImpl> { return impl.isRequiredArtifactRecoveryProtectedImpl(this.store, (taskId: string) => this.resolveResumeLanes(taskId), task); }
|
|
protected async executeCore(task: import("@fusion/core").Task): ReturnType<typeof impl.executeCoreImpl> { return impl.executeCoreImpl(bags.buildExecuteCoreDeps(this), task); }
|
|
protected async runImplementation(...args: FacadeRestArgs<typeof impl.runImplementationImpl>): ReturnType<typeof impl.runImplementationImpl> { return impl.runImplementationImpl(bags.buildRunImplementationFacadeDeps(this), ...args); }
|
|
}
|