@wjarka/cezarion 0.14.4 → 0.14.5

package/dist/workflows/run.d.ts

@@ -680,6 +680,10 @@ export declare class RunManager {
     /** A settled-but-uncollected result is work for the parent, not a live worker.
      * Keep the private termination proof: a public terminal status can precede exit. */
     private hasLiveWorkers;
+    private delegationFinishBlockedReason;
+    /** The read-only verdict and explicit Finish share this decision. Operational failures
+     * (for example a failed durable write) are still handled at execution time. */
+    private finishDecision;
     finishBlockedReason(runId: string): string | undefined;
     /** One durable automatic worker wait per cycle. Further premature DONEs with
      * live workers use the existing capped monitoring wakes; settled uncollected

package/dist/workflows/run.js

@@ -2331,7 +2331,7 @@ export class RunManager {
             return blocker.reason === 'outstanding' && worker?.role === 'worker' && worker.parentRunId === runId;
         });
     }
-    finishBlockedReason(runId) {
+    delegationFinishBlockedReason(runId) {
         const parent = this.store.getRun(runId);
         if (parent?.delegation?.role !== 'root')
             return undefined;
@@ -2340,6 +2340,30 @@ export class RunManager {
         const blockers = this.parentCompletionBlockers(runId);
         return blockers.length ? `Workers must finish or be stopped, prove termination, and have their latest results collected before finishing: ${blockers.map(b => `${b.workerId} (${b.reason})`).join(', ')}` : undefined;
     }
+    /** The read-only verdict and explicit Finish share this decision. Operational failures
+     * (for example a failed durable write) are still handled at execution time. */
+    finishDecision(runId) {
+        const blocked = this.delegationFinishBlockedReason(runId);
+        if (blocked)
+            return { reason: blocked, warn: true };
+        if (this.active.get(runId)?.session?.open)
+            return { action: 'session' };
+        const run = this.store.getRun(runId);
+        if (run?.status === 'waiting' && !hasRegisteredRunProcess(runId) && !this.isActive(runId) &&
+            (run.delegation?.role === 'root' || run.delegation === undefined)) {
+            if (this.waitingBeforeFinalWorkflowStep(run)) {
+                return { reason: 'Continue the remaining workflow steps before finishing.' };
+            }
+            return { action: run.delegation?.role === 'root' ? 'root' : 'waiting' };
+        }
+        if (run?.status === 'review' && !this.isActive(runId))
+            return { action: 'review' };
+        return { reason: 'no open session' };
+    }
+    finishBlockedReason(runId) {
+        const decision = this.finishDecision(runId);
+        return 'reason' in decision ? decision.reason : undefined;
+    }
     /** One durable automatic worker wait per cycle. Further premature DONEs with
      * live workers use the existing capped monitoring wakes; settled uncollected
      * results retain attention. Human input starts a fresh completion cycle. */
@@ -3137,13 +3161,14 @@ export class RunManager {
      *  over), "Finish" is the third review exit: accept the changes without a
      *  PR and flip straight to `done`. */
     finish(runId) {
-        const state = this.active.get(runId);
-        const blocked = this.finishBlockedReason(runId);
-        if (blocked) {
-            this.store.appendEvent(runId, { type: 'note', tone: 'warning', message: blocked });
+        const decision = this.finishDecision(runId);
+        if ('reason' in decision) {
+            if (decision.warn)
+                this.store.appendEvent(runId, { type: 'note', tone: 'warning', message: decision.reason });
             return false;
         }
-        if (state?.session?.open) {
+        const state = this.active.get(runId);
+        if (decision.action === 'session' && state?.session) {
             try {
                 this.withdrawWorkerWait(runId);
             }
@@ -3157,8 +3182,7 @@ export class RunManager {
             return true;
         }
         const run = this.store.getRun(runId);
-        if (run?.status === 'waiting' && !hasRegisteredRunProcess(runId) && run.delegation?.role === 'root' && !this.isActive(runId) &&
-            !this.waitingBeforeFinalWorkflowStep(run)) {
+        if (decision.action === 'root') {
             try {
                 this.store.commitRootFinishIntent(runId);
             }
@@ -3168,8 +3192,7 @@ export class RunManager {
             void this.settleRequestedRootFinish(runId);
             return true;
         }
-        if (run?.status === 'waiting' && !hasRegisteredRunProcess(runId) && run.delegation === undefined && !this.isActive(runId) &&
-            !this.waitingBeforeFinalWorkflowStep(run)) {
+        if (decision.action === 'waiting' && run) {
             const finishedAt = new Date().toISOString();
             for (const step of run.steps) {
                 if (step.status === 'waiting' || step.status === 'running') {
@@ -3179,7 +3202,7 @@ export class RunManager {
             void this.settleSuccess(runId);
             return true;
         }
-        if (run?.status === 'review' && !this.isActive(runId)) {
+        if (decision.action === 'review') {
             this.store.updateRun(runId, { status: 'done' });
             this.store.appendEvent(runId, { type: 'lifecycle', message: 'review accepted — finished without a PR' });
             return true;
@@ -3840,6 +3863,21 @@ export class RunManager {
         const grants = this.workerIdentity(runId)?.grants ?? {
             allowedTools: allowedToolsForStep(toolsStep, continueBackend), bashAllowlist: toolsStep?.bashAllowlist,
         };
+        let continueEffort;
+        try {
+            const modelsLocked = agentModelsLocked(this.repoRoot);
+            const authoredStepEffort = toolsStep?.effort !== undefined;
+            if (modelsLocked && toolsStep?.effort?.trim())
+                throw new Error(AGENT_MODELS_LOCKED_ERROR);
+            const stepEffort = parseDelegationEffort(toolsStep?.effort);
+            continueEffort = modelsLocked
+                ? undefined
+                : authoredStepEffort ? stepEffort : record?.effort;
+        }
+        catch (err) {
+            failBeforeSpawn(err instanceof Error ? err.message : String(err));
+            return;
+        }
         // The temp-directory preflight (#785) rides along with the account resolution: a resumed
         // turn hits the same broken `/tmp` a fresh one would, and an agent whose shell silently
         // returns nothing is worse than a turn that refuses to start and says why.
@@ -3867,7 +3905,7 @@ export class RunManager {
             return;
         this.store.updateStep(runId, stepId, { profileId: continueProfile.profileId });
         state.delegationSettings = { cwd: state.cwd, runner: continueBackend, model: continueModel,
-            effort: agentModelsLocked(this.repoRoot) ? undefined : record?.effort, agentProfile: continueProfile.profileId, accountBinding: continueProfile.accountBinding,
+            effort: continueEffort, agentProfile: continueProfile.profileId, accountBinding: continueProfile.accountBinding,
             systemPrompt: record?.systemPrompt, allowedTools: grants.allowedTools, bashAllowlist: grants.bashAllowlist };
         const runner = createRunner(continueBackend);
         state.currentStepId = stepId;
@@ -3901,7 +3939,7 @@ export class RunManager {
                 env: { ...continueProfile.env, ...delegation?.env },
                 ...(delegation ? { restrictNativeDelegation: delegation.restrictNativeDelegation } : {}),
                 model: continueModel,
-                effort: agentModelsLocked(this.repoRoot) ? undefined : record?.effort,
+                effort: continueEffort,
                 sessionId,
                 resume: sessionId !== undefined,
                 timeoutMs: 0,
@@ -4611,8 +4649,17 @@ export class RunManager {
         // unresolvable model (e.g. a bare id on opencode) returns the step error
         // instead of letting the backend silently substitute its default.
         let backendModel;
+        let effectiveEffort;
         try {
-            const normalized = normalizeModelForBackend(stepBackend, agentModelsLocked(this.repoRoot) ? undefined : step.model ?? input.model, { configuredProvider: await configuredModelProvider(stepBackend, state.cwd) });
+            const modelsLocked = agentModelsLocked(this.repoRoot);
+            const authoredStepEffort = step.effort !== undefined;
+            if (modelsLocked && step.effort?.trim())
+                return AGENT_MODELS_LOCKED_ERROR;
+            const stepEffort = parseDelegationEffort(step.effort);
+            effectiveEffort = modelsLocked
+                ? undefined
+                : authoredStepEffort ? stepEffort : this.store.getRun(runId)?.effort ?? input.effort;
+            const normalized = normalizeModelForBackend(stepBackend, modelsLocked ? undefined : step.model ?? input.model, { configuredProvider: await configuredModelProvider(stepBackend, state.cwd) });
             backendModel = normalized?.backendModel;
             // Persist the identity of what ACTUALLY runs (#405, review M1). The run-start echo
             // (line ~993) is best-effort from `taskBackend`/`input.model`; a per-step `runner`/`model`
@@ -4623,7 +4670,7 @@ export class RunManager {
             });
         }
         catch (err) {
-            if (err instanceof ModelIdentityError)
+            if (err instanceof ModelIdentityError || err instanceof DelegationPolicyError)
                 return err.message;
             throw err;
         }
@@ -4651,7 +4698,7 @@ export class RunManager {
             allowedTools: allowedToolsForStep(step, stepBackend), bashAllowlist: step.bashAllowlist,
         };
         state.delegationSettings = { cwd: state.cwd, runner: stepBackend, model: backendModel,
-            effort: agentModelsLocked(this.repoRoot) ? undefined : this.store.getRun(runId)?.effort ?? input.effort,
+            effort: effectiveEffort,
             agentProfile: stepProfile.profileId, accountBinding: stepProfile.accountBinding, systemPrompt: composeSystemPrompt(systemPrompt, extraSystemPrompt),
             allowedTools: grants.allowedTools, bashAllowlist: grants.bashAllowlist };
         const runner = createRunner(stepBackend);
@@ -4681,9 +4728,7 @@ export class RunManager {
                 env: { ...stepProfile.env, ...delegation?.env },
                 ...(delegation ? { restrictNativeDelegation: delegation.restrictNativeDelegation } : {}),
                 model: backendModel,
-                effort: agentModelsLocked(this.repoRoot)
-                    ? undefined
-                    : this.store.getRun(runId)?.effort ?? input.effort,
+                effort: effectiveEffort,
                 sessionId,
                 // Interactive sessions have no wall clock — the idle timer rules.
                 timeoutMs: interactive ? 0 : undefined,