@wjarka/cezarion 0.11.1 → 0.11.2-pr50.83

package/dist/workflows/run.d.ts

@@ -73,6 +73,9 @@ export declare function runAccountKey(run: Pick<RunRecord, 'runner' | 'agentProf
 export interface StartRunInput {
     task: string;
     model?: string;
+    /** Reasoning-effort pin (#45). Canonical `low`/`medium`/`high`/`xhigh`/`max`.
+     *  Unset = harness default. Same class of override as `model`. */
+    effort?: string;
     /** Agent backend chosen for this task (GUI). Unset = the config default. */
     runner?: RunnerId;
     /** Agent account for this task (spec 2026-07-29-agent-profiles), applying to steps that run
@@ -591,6 +594,8 @@ export declare class RunManager {
         images?: ContentBlock[];
         runner?: RunnerId;
         model?: string;
+        /** Reasoning-effort pin (#45). Omitted keeps the run's pin; empty string clears it. */
+        effort?: string;
         /** Agent account for the reopened session (spec 2026-07-29-agent-profiles). Omitted = the
          *  account the run is already on. */
         agentProfile?: string;
@@ -615,6 +620,8 @@ export declare class RunManager {
      * item-shape cache are session-scoped, like the mapper state feeding them.
      */
     private makeUiSink;
+    /** Continue autonomous runs and markerless tool turns through one bounded path. */
+    private tryAutoContinueTurn;
     /** Native backend asks arrive before turn-end. Persist and park immediately
      * so the cockpit shows attention and the run releases its workspace slot. */
     private handleRunnerUiEvent;

package/dist/workflows/run.js

@@ -55,6 +55,13 @@ const DONE_MARKER_RE = /CEZ:DONE\s*$/;
  * backends can't split the marker across text events.
  */
 const MONITORING_MARKER_RE = /CEZ:MONITORING\s*$/;
+/** Claude's native scheduler is the backend-level equivalent of the textual
+ * monitoring marker. Keep this recognition here, at the workflow boundary,
+ * so the v1 event protocol stays unchanged and other backends do not acquire
+ * semantics from a coincidentally named tool (#46). */
+function isClaudeScheduleWakeup(event, backend) {
+    return backend === 'claude' && event.type === 'tool-call' && event.tool === 'ScheduleWakeup';
+}
 /**
  * Preserve boundaries between complete assistant text blocks while a turn is
  * accumulated for marker parsing. The runners join these same v1 blocks with
@@ -122,6 +129,17 @@ const REPOSITORY_ROOT_LOCK_DISABLED_NOTE = 'repository-root lock disabled by CEZ
 const MAX_AUTO_CONTINUES = 40;
 const AUTONOMOUS_NUDGE = 'Continue working autonomously until the task is fully complete. Do not ask me for confirmation or clarification — make reasonable assumptions and proceed. When everything is done, end the session with your done signal.';
 const MONITORING_WAKE_NUDGE = 'Re-check the downstream work you were monitoring. Continue toward the task goal; emit CEZ:MONITORING again only if it is still pending.';
+/** A question at the handoff boundary may be followed by Markdown answer choices. */
+function hasUserQuestion(text) {
+    const lines = stripTaskMarkers(text).trimEnd().split('\n');
+    while (lines.length > 0) {
+        const line = lines.pop().trim();
+        if (!line || /^(?:[-*+]|\d+[.)])\s+\S/.test(line))
+            continue;
+        return /\?[*_~`]*(?:\s*\([^()]*\))?$/.test(line);
+    }
+    return false;
+}
 /**
  * Auto-resume after a provider usage limit (spec 2026-08-03-auto-resume-after-usage-limit).
  *
@@ -540,13 +558,14 @@ export class RunManager {
         // Sanitize at the manager boundary so CLI runs, workflows, variants, and
         // direct callers cannot bypass the HTTP policy.
         const effectiveInput = agentModelsLocked(this.repoRoot)
-            ? { ...input, model: undefined }
+            ? { ...input, model: undefined, effort: undefined }
             : input;
         const run = this.store.createRun({
             title: makeRunTitle(input.task, workflow) + (group ? ` (${group.variant})` : ''),
             workflow: workflow.name,
             task: input.task,
             model: effectiveInput.model,
+            effort: effectiveInput.effort,
             runner: input.runner,
             // The composer's per-task account (spec 2026-07-29-agent-profiles). Persisted at creation
             // so a queued run picks it up at dequeue and every later resume reads the same answer.
@@ -849,6 +868,7 @@ export class RunManager {
             input: this.hydrateQueuedInput(run.id, {
                 task: run.task,
                 model: run.model,
+                effort: run.effort,
                 runner: run.runner,
                 generateFollowups,
                 // Re-thread autonomy (#489): the rebuilt input feeds `execute`, whose mid-run auto-nudge
@@ -1769,7 +1789,7 @@ export class RunManager {
     /** Restart recovery may discover several interrupted tasks at once. Those
      *  continuations are queued; an explicit user Continue remains immediate. */
     deferForCapacity = false) {
-        if (agentModelsLocked(this.repoRoot) && opts.model?.trim()) {
+        if (agentModelsLocked(this.repoRoot) && (opts.model?.trim() || opts.effort?.trim())) {
             return { ok: false, error: AGENT_MODELS_LOCKED_ERROR };
         }
         if (this.active.has(runId))
@@ -1804,7 +1824,10 @@ export class RunManager {
         // run's current backend — `runContinuation` reads it off the record, later continuations
         // default to it, and the header reflects the active engine. An empty model ('') clears the
         // pin, letting the runner pick the model (auto).
-        if (opts.runner !== undefined || opts.model !== undefined || opts.agentProfile !== undefined) {
+        if (opts.runner !== undefined ||
+            opts.model !== undefined ||
+            opts.effort !== undefined ||
+            opts.agentProfile !== undefined) {
             // Guard the pairing before persisting anything: the model override applies to the runner
             // this continuation will actually use (`opts.runner ?? record.runner ?? 'claude'` — the
             // same resolution `runContinuation` reads off the record). A model that is recognizably
@@ -1842,6 +1865,9 @@ export class RunManager {
                     : inheritedAccountIsForeign
                         ? { agentProfile: undefined }
                         : {}),
+                // Effort is shared vocabulary, not per-backend, so a runner switch keeps the pin.
+                // Empty string clears it the same way `model: ''` clears auto.
+                ...(opts.effort !== undefined ? { effort: opts.effort === '' ? undefined : opts.effort } : {}),
             });
         }
         // Everything that could refuse this continuation has now passed, so a pending usage-limit
@@ -1976,6 +2002,8 @@ export class RunManager {
         });
         let stepCost = 0;
         let turnText = '';
+        let sawClaudeScheduleWakeup = false;
+        let sawToolUse = false;
         let sessionError;
         const sink = this.makeUiSink(runId, stepId);
         const onEvent = (event) => {
@@ -2010,6 +2038,10 @@ export class RunManager {
                 stepCost += event.usd;
                 this.store.updateStep(runId, stepId, { costUsd: stepCost });
             }
+            if (event.type === 'tool-call')
+                sawToolUse = true;
+            if (isClaudeScheduleWakeup(event, backend))
+                sawClaudeScheduleWakeup = true;
             if (event.type === 'turn-end') {
                 // Belt-and-braces: v2 `turn.completed` already flushed the delta
                 // coalescers; the v1 turn boundary flushes again (idempotent) so no
@@ -2023,8 +2055,14 @@ export class RunManager {
                 const askResult = sessionOpen && !done ? parseAskMarkerResult(turnText) : undefined;
                 const ask = askResult?.kind === 'valid' ? askResult.request : null;
                 const askRejection = askResult ? askMarkerRejection(askResult) : undefined;
-                const monitoring = sessionOpen && !done && !ask && MONITORING_MARKER_RE.test(turnText.trimEnd());
+                const monitoring = sessionOpen &&
+                    !done &&
+                    !ask &&
+                    (MONITORING_MARKER_RE.test(turnText.trimEnd()) || sawClaudeScheduleWakeup);
+                const markerlessMidWork = askResult?.kind === 'none' && !monitoring && sawToolUse && !hasUserQuestion(turnText);
                 turnText = '';
+                sawClaudeScheduleWakeup = false;
+                sawToolUse = false;
                 if (askRejection)
                     this.store.appendEvent(runId, { type: 'note', message: askRejection, stepId });
                 if (done) {
@@ -2034,29 +2072,15 @@ export class RunManager {
                     state.session?.end();
                     return;
                 }
+                let autoContinued = false;
                 if (sessionOpen) {
-                    // Autonomous (#autonomous): never hand the ball back to the user. Nudge the agent to
-                    // keep going (bounded by MAX_AUTO_CONTINUES) instead of parking at `waiting`.
-                    const autoContinued = state.autonomous &&
-                        (state.autoContinues ?? 0) < MAX_AUTO_CONTINUES &&
-                        !state.cancelled &&
-                        (() => {
-                            const sent = state.session?.sendMessage([{ type: 'text', text: AUTONOMOUS_NUDGE }]);
-                            if (!sent)
-                                return false;
-                            state.autoContinues = (state.autoContinues ?? 0) + 1;
-                            this.store.appendEvent(runId, {
-                                type: 'note',
-                                message: `autonomous — continuing without pausing (${state.autoContinues}/${MAX_AUTO_CONTINUES})`,
-                            });
-                            return true;
-                        })();
+                    autoContinued = this.tryAutoContinueTurn(runId, state, state.autonomous === true || markerlessMidWork);
                     if (!autoContinued) {
                         // `CEZ:ASK` → park `waiting` (attention) AND surface the structured
-                        // question as an ask card (#473). `CEZ:MONITORING` → non-attention
-                        // `running`/`activity:'monitoring'` (#490). Both share the waiting
-                        // lifecycle (free the slot, keep the idle timer); the autonomous
-                        // nudge above still wins over either.
+                        // question as an ask card (#473). `CEZ:MONITORING` or Claude's native
+                        // `ScheduleWakeup` → non-attention `running`/`activity:'monitoring'`
+                        // (#490, #46). Both free the slot; only genuine user waits keep the
+                        // idle timer. The autonomous nudge above still wins over either.
                         if (ask)
                             emitAskRequested(sink, ask);
                         if (monitoring) {
@@ -2086,7 +2110,7 @@ export class RunManager {
                 if (this.store.getRun(runId)?.autoResumeAttempts !== undefined) {
                     this.store.updateRun(runId, { autoResumeAttempts: undefined });
                 }
-                appendHandoffHeartbeat(this.dataDir, runId, `turn complete — status=${monitoring ? 'monitoring' : sessionOpen ? 'waiting' : 'running'}`);
+                appendHandoffHeartbeat(this.dataDir, runId, `turn complete — status=${autoContinued ? 'running' : monitoring ? 'monitoring' : sessionOpen ? 'waiting' : 'running'}`);
             }
         };
         // Backend + model come off the record: the run's current backend by default, or the
@@ -2196,6 +2220,7 @@ export class RunManager {
             additionalDirectories: agentDirectories(join(this.dataDir, 'runs'), continueProfile.env),
             env: continueProfile.env,
             model: continueModel,
+            effort: agentModelsLocked(this.repoRoot) ? undefined : record?.effort,
             sessionId,
             resume: sessionId !== undefined,
             timeoutMs: 0,
@@ -2587,6 +2612,8 @@ export class RunManager {
         const startTokens = stepRecord?.tokensUsed ?? 0;
         let stepCost = stepRecord?.costUsd ?? 0;
         let turnText = '';
+        let sawClaudeScheduleWakeup = false;
+        let sawToolUse = false;
         let sessionError;
         const sink = this.makeUiSink(runId, step.id);
         const onEvent = (event) => {
@@ -2622,6 +2649,10 @@ export class RunManager {
                 stepCost += event.usd;
                 this.store.updateStep(runId, step.id, { costUsd: stepCost });
             }
+            if (event.type === 'tool-call')
+                sawToolUse = true;
+            if (isClaudeScheduleWakeup(event, backend))
+                sawClaudeScheduleWakeup = true;
             if (event.type === 'turn-end') {
                 // v2 `turn.completed` already flushed the coalescers; the v1 turn
                 // boundary flushes again (idempotent) as a backstop.
@@ -2638,8 +2669,11 @@ export class RunManager {
                     sessionOpen &&
                     !done &&
                     !ask &&
-                    MONITORING_MARKER_RE.test(turnText.trimEnd());
+                    (MONITORING_MARKER_RE.test(turnText.trimEnd()) || sawClaudeScheduleWakeup);
+                const markerlessMidWork = askResult?.kind === 'none' && !monitoring && sawToolUse && !hasUserQuestion(turnText);
                 turnText = '';
+                sawClaudeScheduleWakeup = false;
+                sawToolUse = false;
                 if (askRejection)
                     emit({ type: 'note', stepId: step.id, message: askRejection });
                 if (done) {
@@ -2651,33 +2685,36 @@ export class RunManager {
                     return;
                 }
                 const waiting = interactive && sessionOpen;
+                let autoContinued = false;
                 if (waiting) {
-                    // Turn over, session open. Either the ball is in the user's court
-                    // (`waiting`) — optionally with a structured `CEZ:ASK` question the
-                    // cockpit renders as an ask card (#473) — or the agent declared it is
-                    // still working on its own downstream work with `CEZ:MONITORING`, which
-                    // parks as `running`/`activity:'monitoring'`, a non-attention state,
-                    // instead of raising "needs you" (#490). Lifecycle is identical: the
-                    // run frees its slot and keeps the idle timer.
-                    if (ask)
-                        emitAskRequested(sink, ask);
-                    if (monitoring) {
-                        this.store.updateRun(runId, { status: 'running', activity: 'monitoring' });
-                        this.store.updateStep(runId, step.id, { status: 'running' });
-                        this.monitoring.add(runId);
-                        this.clearIdleTimer(state);
-                        this.armMonitoringWakeTimer(runId, state);
-                    }
-                    else {
-                        this.store.updateRun(runId, { status: 'waiting', activity: undefined });
-                        this.store.updateStep(runId, step.id, { status: 'waiting' });
-                        this.monitoring.delete(runId);
-                        this.clearMonitoringWakeTimer(state, runId);
+                    autoContinued = this.tryAutoContinueTurn(runId, state, !ask && (state.autonomous === true || markerlessMidWork));
+                    if (!autoContinued) {
+                        // Turn over, session open. Either the ball is in the user's court
+                        // (`waiting`) — optionally with a structured `CEZ:ASK` question the
+                        // cockpit renders as an ask card (#473) — or the agent declared it is
+                        // still working through `CEZ:MONITORING` or Claude's native
+                        // `ScheduleWakeup`. Monitoring parks as `running` with no user-wait
+                        // idle timer, so the cockpit stays non-attention (#490, #46).
+                        if (ask)
+                            emitAskRequested(sink, ask);
+                        if (monitoring) {
+                            this.store.updateRun(runId, { status: 'running', activity: 'monitoring' });
+                            this.store.updateStep(runId, step.id, { status: 'running' });
+                            this.monitoring.add(runId);
+                            this.clearIdleTimer(state);
+                            this.armMonitoringWakeTimer(runId, state);
+                        }
+                        else {
+                            this.store.updateRun(runId, { status: 'waiting', activity: undefined });
+                            this.store.updateStep(runId, step.id, { status: 'waiting' });
+                            this.monitoring.delete(runId);
+                            this.clearMonitoringWakeTimer(state, runId);
+                        }
+                        this.waiting.add(runId);
+                        if (!monitoring)
+                            this.armIdleTimer(runId, state);
+                        this.releaseSlot(); // the freed slot can start a queued run right away — in any project
                     }
-                    this.waiting.add(runId);
-                    if (!monitoring)
-                        this.armIdleTimer(runId, state);
-                    this.releaseSlot(); // the freed slot can start a queued run right away — in any project
                 }
                 // The window is proven open — see the twin in `runContinuation`.
                 if (this.store.getRun(runId)?.autoResumeAttempts !== undefined) {
@@ -2685,7 +2722,7 @@ export class RunManager {
                 }
                 // Cez's own heartbeat — the handoff stays current even when the
                 // agent forgets to write (spec 007).
-                appendHandoffHeartbeat(this.dataDir, runId, `turn complete — status=${monitoring ? 'monitoring' : waiting ? 'waiting' : 'running'}`);
+                appendHandoffHeartbeat(this.dataDir, runId, `turn complete — status=${autoContinued ? 'running' : monitoring ? 'monitoring' : waiting ? 'waiting' : 'running'}`);
             }
         };
         const stepBackend = step.runner ?? taskBackend;
@@ -2747,6 +2784,9 @@ export class RunManager {
                 additionalDirectories: agentDirectories(join(this.dataDir, 'runs'), stepProfile.env),
                 env: stepProfile.env,
                 model: backendModel,
+                effort: agentModelsLocked(this.repoRoot)
+                    ? undefined
+                    : this.store.getRun(runId)?.effort ?? input.effort,
                 sessionId,
                 // Interactive sessions have no wall clock — the idle timer rules.
                 timeoutMs: interactive ? 0 : undefined,
@@ -2809,6 +2849,23 @@ export class RunManager {
             emitLive: (event) => this.store.emitEphemeral(runId, { ...event, stepId }),
         });
     }
+    /** Continue autonomous runs and markerless tool turns through one bounded path. */
+    tryAutoContinueTurn(runId, state, shouldContinue) {
+        if (!shouldContinue || (state.autoContinues ?? 0) >= MAX_AUTO_CONTINUES) {
+            return false;
+        }
+        if (state.cancelled)
+            return false;
+        const sent = state.session?.sendMessage([{ type: 'text', text: AUTONOMOUS_NUDGE }]);
+        if (!sent)
+            return false;
+        state.autoContinues = (state.autoContinues ?? 0) + 1;
+        this.store.appendEvent(runId, {
+            type: 'note',
+            message: `${state.autonomous ? 'autonomous' : 'work still in progress'} — continuing without pausing (${state.autoContinues}/${MAX_AUTO_CONTINUES})`,
+        });
+        return true;
+    }
     /** Native backend asks arrive before turn-end. Persist and park immediately
      * so the cockpit shows attention and the run releases its workspace slot. */
     handleRunnerUiEvent(runId, state, sink, event) {