@open-mercato/cezar 0.9.0-pr646.708 → 0.9.0

package/dist/workflows/run.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { parseAskMarker, stripAskMarker } from '../core/ask.js';
 import { onUsage, registerRunProcess, unregisterRunProcess } from '../core/process-usage.js';
 import { createRunner } from '../core/runner-factory.js';
@@ -46,19 +46,6 @@ const DONE_MARKER_RE = /CEZ:DONE\s*$/;
  * backends can't split the marker across text events.
  */
 const MONITORING_MARKER_RE = /CEZ:MONITORING\s*$/;
-/**
- * Preserve boundaries between complete assistant text blocks while a turn is
- * accumulated for marker parsing. The runners join these same v1 blocks with
- * newlines in `AgentRunResult`; matching that contract here prevents a
- * trailing `CEZ:TITLE=` block from absorbing later commentary (#623).
- */
-export function appendTurnText(current, next) {
-    if (!current)
-        return next;
-    if (!next)
-        return current;
-    return `${current}\n${next}`;
-}
 /** Strip a trailing marker from one text event so transcripts stay free of
  *  protocol noise. Delta backends may split the marker across events — then
  *  it stays visible; detection above is unaffected. */
@@ -209,9 +196,6 @@ export class RunManager {
      *  ordinary follow-up turns the moment the session opens. In-memory only. */
     deferredMessages = new Map();
     pumping = false;
-    /** A pump that arrived while one was in flight — replayed by `pump()`'s own
-     *  loop so a slot freed mid-sweep is never a lost wakeup. */
-    pumpAgain = false;
     /**
      * Runs normally isolate in worktrees and may execute in parallel. When that
      * isolation is unavailable (or explicitly disabled), serialize access to
@@ -240,8 +224,7 @@ export class RunManager {
         this.semaphore = options.semaphore ?? new WorkspaceSemaphore();
         this.offSemaphore = this.semaphore.register({
             busySlots: () => this.busySlots(),
-            pump: () => this.pump(),
-            oldestQueuedAt: () => this.oldestQueuedAt(),
+            pump: () => void this.pump(),
         });
         // Memory guard (#memory-guard): the shared process-tree sampler already ticks ~every 2 s for
         // the runs table; piggyback on it to enforce the per-task memory ceiling.
@@ -361,19 +344,6 @@ export class RunManager {
         // Persist the full definition so a queued run survives a restart (#367) —
         // ad-hoc "(planned)" chains exist nowhere else to re-resolve from.
         this.store.updateRun(run.id, { workflowDef: workflow });
-        // Initial pasted images must be visible while the run is still queued (#612),
-        // and must survive a restart before a slot opens. Persist them before the job
-        // enters `pendingJobs`; `hydrateQueuedInput` reconstructs their content blocks
-        // from these URLs when a recovered run eventually starts.
-        if (input.images?.length) {
-            const persisted = input.images
-                .filter((b) => b.type === 'image')
-                .map((b) => this.persistImage(run.id, b.source.media_type, b.source.data, 'pasted'))
-                .filter((saved) => saved !== null);
-            if (persisted.length) {
-                this.store.updateRun(run.id, { taskImages: persisted.map((saved) => saved.url) });
-            }
-        }
         // Step-0 reference extraction (task auto-naming spec): the regex layer's
         // numbers persist immediately; the namer may add the kind it verified later.
         const skillHint = workflow.steps.find((s) => stepKind(s) === 'agent' && s.skill)?.skill?.trim();
@@ -420,95 +390,54 @@ export class RunManager {
     busySlots() {
         return this.active.size + this.starting.size - this.waiting.size;
     }
-    /** Epoch ms of this manager's oldest queued run (the semaphore's fairness
-     *  key when a freed slot is broadcast), or null when nothing is queued.
-     *  `queue` is FIFO — `startRun` pushes and `recover()` re-queues by
-     *  `createdAt` — so the head is the oldest. */
-    oldestQueuedAt() {
-        const head = this.queue[0];
-        if (!head)
-            return null;
-        const createdAt = this.store.getRun(head)?.createdAt;
-        const ms = createdAt ? Date.parse(createdAt) : Number.NaN;
-        return Number.isNaN(ms) ? null : ms;
-    }
     /**
-     * A slot this manager held just came free. Pump the whole WORKSPACE, not
-     * just this manager: `maxParallel` is counted across every project, so the
-     * run that should take the slot is the workspace's oldest queued one — which
-     * usually sits in another project's queue. Pumping only `this` is what left
-     * a queued run in project B stuck at `queued` while project A's runs came
-     * and went. `release()` pumps this manager too, so it replaces the local
-     * `pump()` at every slot-freeing transition.
-     */
-    releaseSlot() {
-        void this.semaphore.release();
-    }
-    /**
-     * Start queued runs while parallel slots are free. A run starts only under
-     * BOTH ceilings: the WORKSPACE `resources.maxParallel` (default 2, counted
-     * across every manager — spec 2026-07-20, step 2.5) AND this project's own
-     * per-project `maxParallel` when the registry sets one (spec 2026-07-22,
-     * inherits the workspace cap when unset). Legacy per-repo `maxParallel` keys
-     * are ignored. A non-git directory degrades to 1 sequential run in the repo
-     * root (spec 006 degradation rule), which is always the tighter bound.
+     * Start queued runs while parallel slots are free. The cap is the WORKSPACE
+     * `resources.maxParallel` (default 2), cached in the shared semaphore and
+     * counted across every manager (spec 2026-07-20, step 2.5) — legacy per-repo
+     * `maxParallel` keys are ignored. A non-git directory degrades to 1
+     * sequential run in the repo root (spec 006 degradation rule).
      */
     async pump() {
-        // A pump requested while one is in flight can't just be dropped: the
-        // in-flight pass may already have read capacity (it awaits `getRepoInfo`
-        // before the first check), so a slot freed in that window would be lost
-        // until the next unrelated event. Re-run the sweep instead.
-        if (this.pumping) {
-            this.pumpAgain = true;
+        if (this.pumping)
             return;
-        }
         this.pumping = true;
         try {
-            do {
-                this.pumpAgain = false;
-                const repo = await getRepoInfo(this.repoRoot);
-                const maxParallel = this.semaphore.maxParallel();
-                // Per-project ceiling (spec 2026-07-22-per-project-concurrency): this
-                // project never runs more than its own configured `maxParallel`; absent
-                // an override it equals the workspace cap, so behavior is unchanged.
-                const projectMax = this.semaphore.projectMaxParallel(this.repoRoot);
-                // `waiting` runs don't hold a slot (#347) — see busySlots(). The check
-                // below is the only slot gate: resumes never pass through it. A run
-                // starts only under BOTH the workspace cap and this project's ceiling.
-                const capacity = () => this.semaphore.busy() < maxParallel &&
-                    this.busySlots() < projectMax &&
-                    (repo !== null || this.busySlots() < 1);
-                while (this.queue.length > 0 && capacity()) {
-                    const runId = this.queue.shift();
-                    if (!runId)
-                        break;
-                    const job = this.pendingJobs.get(runId);
-                    this.pendingJobs.delete(runId);
-                    if (!job)
-                        continue;
-                    this.starting.add(runId);
-                    // Rebuild the prompt from the store at the last instant (#472), so an edit
-                    // or a stacked message that landed while the run waited is honored. Entered
-                    // in the same synchronous tick as the `pendingJobs.delete` above, so no
-                    // handler can observe a half-dequeued run.
-                    const input = this.hydrateQueuedInput(runId, job.input);
-                    void this.execute(runId, job.workflow, input).catch((err) => {
-                        const message = err instanceof Error ? err.message : String(err);
-                        this.store.updateRun(runId, {
-                            status: 'failed',
-                            error: `engine crashed: ${message}`,
-                            finishedAt: new Date().toISOString(),
-                        });
-                        const state = this.active.get(runId);
-                        if (state) {
-                            this.clearIdleTimer(state);
-                            this.clearAutosaveTimer(state);
-                        }
-                        this.starting.delete(runId);
-                        this.dropActive(runId);
+            const repo = await getRepoInfo(this.repoRoot);
+            const maxParallel = this.semaphore.maxParallel();
+            // `waiting` runs don't hold a slot (#347) — see busySlots(). The check
+            // below is the only slot gate: resumes never pass through it.
+            const capacity = () => this.semaphore.busy() < maxParallel && (repo !== null || this.busySlots() < 1);
+            while (this.queue.length > 0 && capacity()) {
+                const runId = this.queue.shift();
+                if (!runId)
+                    break;
+                const job = this.pendingJobs.get(runId);
+                this.pendingJobs.delete(runId);
+                if (!job)
+                    continue;
+                this.starting.add(runId);
+                // Rebuild the prompt from the store at the last instant (#472), so an edit
+                // or a stacked message that landed while the run waited is honored. Entered
+                // in the same synchronous tick as the `pendingJobs.delete` above, so no
+                // handler can observe a half-dequeued run.
+                const input = this.hydrateQueuedInput(runId, job.input);
+                void this.execute(runId, job.workflow, input).catch((err) => {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.store.updateRun(runId, {
+                        status: 'failed',
+                        error: `engine crashed: ${message}`,
+                        finishedAt: new Date().toISOString(),
                     });
-                }
-            } while (this.pumpAgain);
+                    const state = this.active.get(runId);
+                    if (state) {
+                        this.clearIdleTimer(state);
+                        this.clearAutosaveTimer(state);
+                    }
+                    this.starting.delete(runId);
+                    this.dropActive(runId);
+                    void this.pump();
+                });
+            }
         }
         finally {
             this.pumping = false;
@@ -635,10 +564,6 @@ export class RunManager {
         this.active.delete(runId);
         this.memoryPausing.delete(runId);
         this.lastNamerKey.delete(runId);
-        // The run's slot is gone from busySlots() as of the deletes above — hand it
-        // to the workspace's oldest queued run, in ANY project. Every terminal path
-        // funnels through here, so this one call covers them all.
-        this.releaseSlot();
         // A run leaving the active registry is a terminal transition (done/review/
         // failed/cancelled) — the one moment the finished-worktree count can grow.
         // Enforce count-based retention (#483) here so a single hook covers every
@@ -704,7 +629,7 @@ export class RunManager {
             abort();
         };
         this.waiting.add(runId);
-        this.releaseSlot();
+        void this.pump();
         try {
             await Promise.race([previous, cancelled]);
         }
@@ -759,45 +684,34 @@ export class RunManager {
         if (!run)
             return input;
         const stack = run.queuedMessages ?? [];
+        if (!stack.length)
+            return { ...input, task: run.task };
         const task = [run.task, ...stack.map((m) => m.text)]
             .map((part) => part.trim())
             .filter((part) => part.length > 0)
             .join('\n\n');
-        const readImages = (urls, kind) => {
-            const images = [];
-            for (const url of urls) {
-                const name = url.split('/').pop();
-                if (!name || name.includes('..') || name.includes('/') || name.includes('\\'))
-                    continue;
-                try {
-                    const data = readFileSync(join(this.dataDir, 'runs', `${runId}-images`, name));
-                    images.push({
-                        type: 'image',
-                        source: { type: 'base64', media_type: mediaTypeFor(name), data: data.toString('base64') },
-                    });
-                }
-                catch {
-                    // Degrade, never fail the boot (AGENTS.md): the user deleted `.ai/cezar/`
-                    // or the file is unreadable — start with the text and say which image went.
-                    this.store.appendEvent(runId, {
-                        type: 'note',
-                        message: `${kind} attachment ${name} could not be read — starting without it`,
-                    });
-                }
+        const stackedImages = [];
+        for (const url of stack.flatMap((m) => m.images ?? [])) {
+            const name = url.split('/').pop();
+            if (!name || name.includes('..') || name.includes('/') || name.includes('\\'))
+                continue;
+            try {
+                const data = readFileSync(join(this.dataDir, 'runs', `${runId}-images`, name));
+                stackedImages.push({
+                    type: 'image',
+                    source: { type: 'base64', media_type: mediaTypeFor(name), data: data.toString('base64') },
+                });
             }
-            return images;
-        };
-        // Keep the original in-memory blocks for a live process (including the
-        // best-effort case where persistence failed). Recovery has no such copy,
-        // so rebuild it from the durable task-image URLs.
-        const images = input.images?.length ? input.images : readImages(run.taskImages ?? [], 'task');
-        const stackedImages = readImages(stack.flatMap((m) => m.images ?? []), 'queued');
-        return {
-            ...input,
-            task,
-            ...(images.length ? { images } : { images: undefined }),
-            ...(stackedImages.length ? { stackedImages } : { stackedImages: undefined }),
-        };
+            catch {
+                // Degrade, never fail the boot (AGENTS.md): the user deleted `.ai/cezar/`
+                // or the file is unreadable — start with the text and say which image went.
+                this.store.appendEvent(runId, {
+                    type: 'note',
+                    message: `queued attachment ${name} could not be read — starting without it`,
+                });
+            }
+        }
+        return { ...input, task, ...(stackedImages.length ? { stackedImages } : {}) };
     }
     /**
      * Still waiting for a slot? Checked against the engine's own queue rather than
@@ -1108,7 +1022,7 @@ export class RunManager {
         const continuations = run.steps.filter((s) => s.id.startsWith('continue-')).length;
         const stepId = `continue-${continuations + 1}`;
         this.store.addStep(runId, { id: stepId, name: 'Continue', kind: 'agent' });
-        void this.runContinuation(runId, stepId, resume ? sessionStep.sessionId : undefined, targetRunner, opts.text?.trim() || 'Continue.', opts.images ?? []).catch((err) => {
+        void this.runContinuation(runId, stepId, resume ? sessionStep.sessionId : undefined, targetRunner, opts.text?.trim() || 'Continue.').catch((err) => {
             const message = err instanceof Error ? err.message : String(err);
             this.store.updateRun(runId, {
                 status: 'failed',
@@ -1116,14 +1030,11 @@ export class RunManager {
                 finishedAt: new Date().toISOString(),
             });
             this.dropActive(runId);
+            void this.pump();
         });
         return { ok: true };
     }
-    async runContinuation(runId, stepId, sessionId, backend, prompt, 
-    /** Screenshots pasted into the follow-up composer — delivered with the
-     *  reopened session's opening message, exactly like a live-session
-     *  message's attachments. */
-    images = []) {
+    async runContinuation(runId, stepId, sessionId, backend, prompt) {
         // Continuation runs in the task's worktree when it still exists (spec
         // 006) — the resumed session sees exactly what the original run left.
         // Retention (#483) may have reclaimed this run's worktree directory while
@@ -1154,6 +1065,7 @@ export class RunManager {
                 });
                 this.store.appendEvent(runId, { type: 'lifecycle', message: 'run cancelled' });
                 this.dropActive(runId);
+                void this.pump();
                 return;
             }
         }
@@ -1175,22 +1087,7 @@ export class RunManager {
             backend,
         });
         this.store.appendEvent(runId, { type: 'step-start', stepId, name: 'Continue', kind: 'agent', iteration: 1 });
-        // Attachments pasted into the follow-up composer, on the same terms as a live-session
-        // message (#357): persisted to the run's own image store so the thread renders the bubble's
-        // images rather than a bare count, and handed to the agent BOTH as base64 blocks (so it can
-        // view them) and as absolute paths appended to the prompt (so it can operate on them — and
-        // because codex/opencode drop image blocks before they reach the model).
-        const attachments = images
-            .filter((b) => b.type === 'image')
-            .map((b) => this.persistImage(runId, b.source.media_type, b.source.data, 'pasted'))
-            .filter((saved) => saved !== null);
-        this.store.appendEvent(runId, {
-            type: 'user-message',
-            stepId,
-            text: prompt,
-            imageCount: images.filter((b) => b.type === 'image').length,
-            ...(attachments.length ? { images: attachments.map((saved) => saved.url) } : {}),
-        });
+        this.store.appendEvent(runId, { type: 'user-message', stepId, text: prompt, imageCount: 0 });
         let stepCost = 0;
         let turnText = '';
         const sink = this.makeUiSink(runId, stepId);
@@ -1202,7 +1099,7 @@ export class RunManager {
                 return;
             }
             if (event.type === 'text') {
-                turnText = appendTurnText(turnText, event.text);
+                turnText += event.text;
                 const text = stripAskMarker(stripTaskMarkers(stripMonitoringMarker(stripDoneMarker(event.text))));
                 if (text)
                     this.store.appendEvent(runId, { type: 'text', text, stepId });
@@ -1274,7 +1171,7 @@ export class RunManager {
                         }
                         this.waiting.add(runId);
                         this.armIdleTimer(runId, state);
-                        this.releaseSlot();
+                        void this.pump();
                     }
                 }
                 appendHandoffHeartbeat(this.dataDir, runId, `turn complete — status=${monitoring ? 'monitoring' : sessionOpen ? 'waiting' : 'running'}`);
@@ -1318,6 +1215,7 @@ export class RunManager {
                 message: `continue failed — ${err.message}`,
             });
             this.dropActive(runId);
+            void this.pump();
             return;
         }
         const runner = createRunner(continueBackend);
@@ -1326,8 +1224,7 @@ export class RunManager {
             // run's extra system prompt (already resolved at execute time and
             // echoed on the record) rides along with the handoff contract.
             systemPrompt: composeSystemPrompt(record?.systemPrompt, generateFollowups ? HANDOFF_INSTRUCTIONS : HANDOFF_ONLY_INSTRUCTIONS),
-            userPrompt: attachments.length ? `${prompt}\n\n${pastedAttachmentsText(attachments)}` : prompt,
-            ...(images.length ? { images } : {}),
+            userPrompt: prompt,
             cwd: state.cwd,
             allowedTools: DEFAULT_ALLOWED_TOOLS,
             additionalDirectories: [join(this.dataDir, 'runs')],
@@ -1381,6 +1278,7 @@ export class RunManager {
             if (state.cwd !== this.repoRoot)
                 await autosaveCommit(state.cwd, 'turn end');
             this.dropActive(runId);
+            void this.pump();
         }
     }
     // ---- execution -----------------------------------------------------------
@@ -1486,6 +1384,7 @@ export class RunManager {
                 });
                 emit({ type: 'lifecycle', message: `run failed — ${error}` });
                 this.dropActive(runId);
+                void this.pump();
                 return;
             }
         }
@@ -1511,18 +1410,21 @@ export class RunManager {
         const retriesUsed = new Map();
         let checkFailure = null;
         let runError = null;
-        // `startRun` already persisted task images so a queued bubble can render them
-        // (#612). Reuse those files for the agent-facing path note instead of minting
-        // duplicate pasted files when execution finally begins.
-        let startAttachments = (this.store.getRun(runId)?.taskImages ?? [])
-            .map((url) => {
-            const name = url.split('/').pop();
-            if (!name || name.includes('..') || name.includes('/') || name.includes('\\'))
-                return null;
-            const path = join(this.dataDir, 'runs', `${runId}-images`, name);
-            return existsSync(path) ? { name, url, path } : null;
-        })
-            .filter((saved) => saved !== null);
+        // Persist the task's attached images so the thread's initial bubble can render them
+        // (#image-display); they still ride the first agent step's opening message below.
+        // `pasted` prefix (#357) marks these as user attachments on disk and keeps their
+        // absolute paths so runAgentStep can tell the agent where to find the real files.
+        let startAttachments = [];
+        if (input.images?.length) {
+            const persisted = input.images
+                .filter((b) => b.type === 'image')
+                .map((b) => this.persistImage(runId, b.source.media_type, b.source.data, 'pasted'))
+                .filter((saved) => saved !== null);
+            if (persisted.length) {
+                this.store.updateRun(runId, { taskImages: persisted.map((p) => p.url) });
+                startAttachments = persisted;
+            }
+        }
         // Task screenshots go with the FIRST agent step's opening message only —
         // later steps and retry loops run in fresh sessions without them. Stacked
         // attachments (#472) ride along too, but are NOT re-persisted above: they
@@ -1620,6 +1522,7 @@ export class RunManager {
         }
         this.clearIdleTimer(state);
         this.dropActive(runId);
+        void this.pump();
     }
     /** Returns an error message, or null on success. */
     async runAgentStep(runId, state, step, input, skills, checkFailure, interactive, emit, images, taskBackend, extraSystemPrompt, 
@@ -1696,7 +1599,7 @@ export class RunManager {
                 return;
             }
             if (event.type === 'text') {
-                turnText = appendTurnText(turnText, event.text);
+                turnText += event.text;
                 const text = stripAskMarker(stripTaskMarkers(stripMonitoringMarker(stripDoneMarker(event.text))));
                 if (text)
                     emit({ type: 'text', text, stepId: step.id });
@@ -1759,7 +1662,7 @@ export class RunManager {
                     }
                     this.waiting.add(runId);
                     this.armIdleTimer(runId, state);
-                    this.releaseSlot(); // the freed slot can start a queued run right away — in any project
+                    void this.pump(); // the freed slot can start a queued run right away
                 }
                 // Cez's own heartbeat — the handoff stays current even when the
                 // agent forgets to write (spec 007).
@@ -1871,7 +1774,7 @@ export class RunManager {
         this.store.updateRun(runId, { status: 'waiting', activity: undefined });
         if (state.currentStepId)
             this.store.updateStep(runId, state.currentStepId, { status: 'waiting' });
-        this.releaseSlot();
+        void this.pump();
     }
     /**
      * Turn-end bookkeeping (#389), shared by `runAgentStep` and
@@ -2218,30 +2121,14 @@ export function makeRunTitle(task, workflow) {
     const chars = [...(prefixed || '(untitled task)')];
     return chars.length > 80 ? `${chars.slice(0, 79).join('').trimEnd()}…` : chars.join('');
 }
-/**
- * Skill identity is context, while the Markdown body remains instructions.
- *
- * For an on-disk skill we also hand the agent the ABSOLUTE directory of the
- * installed copy. A run executes in an isolated worktree that has no local
- * `.agents/skills` (gitignored, absent in a fresh checkout), so without this
- * the agent cannot read the skill's companion files (`references/*.md`) — or,
- * worse, reads a stale copy materialized from the team-repo cache. The path
- * resolves against the MAIN project root (`discoverSkills(repoRoot)`), i.e. the
- * current `npx skills`-installed copy, so a worktree agent and the main
- * checkout read the exact same, up-to-date files. Team skills are omitted here:
- * they are materialized into the worktree separately (see the call site).
- */
+/** Skill identity is context, while the Markdown body remains instructions. */
 export function skillSystemPrompt(skill) {
-    const lines = [
+    return [
         `Selected skill: /${skill.name}`,
         ...(skill.description ? [`Description: ${skill.description}`] : []),
-    ];
-    if (skill.source && skill.source !== 'team' && skill.path) {
-        const dir = dirname(skill.path);
-        lines.push('', `Skill files are installed on disk at: ${dir}`, `Read any file this skill references (for example references/*.md) from that absolute directory. ` +
-            `It is the current installed copy — use it even though your working directory is a separate worktree that does not contain the skill.`);
-    }
-    lines.push('', 'Skill instructions:', skill.body.trim());
-    return lines.join('\n');
+        '',
+        'Skill instructions:',
+        skill.body.trim(),
+    ].join('\n');
 }
 //# sourceMappingURL=run.js.map