@wjarka/cezarion 0.10.0-pr30.54

package/dist/workspace/projects.js

@@ -0,0 +1,250 @@
+import { realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, join, resolve, sep } from 'node:path';
+import { PROJECT_TAGS_MAX, PROJECT_TAG_MAX_LENGTH } from '../contract/index.js';
+import { forgeKindOfRemote, forgeWebRoot } from '../server/forge/index.js';
+import { getRepoInfo } from '../server/git.js';
+import { mergeWriteWorkspaceConfig, loadWorkspaceConfig, } from './config.js';
+/**
+ * Project registry operations over `~/.cezar/config.json` (spec
+ * 2026-07-20-multi-project-workspace, "Project identity" + "Boot flow"):
+ *
+ * - `registerProject(root)` — realpath-normalize, dedupe by realpath, allocate
+ *   a human-readable slug from `basename(root)`. Registration is additive and
+ *   goes through the read-modify-write merge, so the worst race outcome
+ *   between concurrent `cezar serve` processes is a lost `lastOpenedAt` bump —
+ *   never a lost project.
+ * - `listProjects()` — registry entries + a cheap per-root status/branch probe
+ *   behind a short TTL cache, so a sidebar render never shells `git` N times.
+ * - `removeProject(id)` — unregister only. It never touches any file inside
+ *   the repo (a project's own state stays in `<repo>/.ai/cezar/`).
+ */
+/**
+ * Slugs the allocator must never hand out: `default` is the reserved alias
+ * for the boot project, the rest are the cockpit shell's own top-level path
+ * segments. A repo named `default/` becomes `default-2` and can never shadow
+ * the alias or a route.
+ */
+export const RESERVED_PROJECT_IDS = new Set([
+    'default',
+    'new',
+    'settings',
+    'api',
+    'p',
+    'assets',
+]);
+/** Slug length cap — mirrors `PROJECT_ID_RE` (1 head char + up to 63 more). */
+const SLUG_MAX = 64;
+/**
+ * `basename(root)` → slug base: lowercase, runs of `[^a-z0-9-]` become one
+ * `-`, edge dashes trimmed so the result matches `^[a-z0-9][a-z0-9-]{0,63}$`.
+ * A degenerate basename (e.g. `日本語/`) falls back to `project` rather than
+ * ever escaping the slug shape.
+ */
+function slugBase(root) {
+    const base = basename(root)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, SLUG_MAX);
+    return base || 'project';
+}
+/**
+ * Allocate a unique slug for `root`: the slug base, deduplicated against
+ * `taken` ids AND the reserved ids with a numeric suffix (`api`, `api-2`,
+ * `api-3`, …). Suffixed candidates stay within the 64-char cap by truncating
+ * the base, never the suffix.
+ */
+export function allocateProjectSlug(root, taken) {
+    const used = new Set(RESERVED_PROJECT_IDS);
+    for (const id of taken)
+        used.add(id);
+    const base = slugBase(root);
+    if (!used.has(base))
+        return base;
+    for (let n = 2;; n++) {
+        const suffix = `-${n}`;
+        const candidate = `${base.slice(0, SLUG_MAX - suffix.length)}${suffix}`;
+        if (!used.has(candidate))
+            return candidate;
+    }
+}
+/**
+ * Realpath-normalize a root: resolves symlinks and drops trailing slashes, so
+ * every spelling of the same directory dedupes to one registry entry. A path
+ * that cannot be realpath'd (doesn't exist yet, unreadable) degrades to plain
+ * `resolve()` — registration callers guard existence; this module never throws
+ * over it.
+ */
+async function normalizeRoot(root) {
+    try {
+        return await realpath(root);
+    }
+    catch {
+        return resolve(root);
+    }
+}
+/** True when `path` sits inside a cezar task worktree (`…/.ai/cezar/worktrees/…`). */
+function isInsideTaskWorktree(path) {
+    const marker = `${sep}.ai${sep}cezar${sep}worktrees${sep}`;
+    return `${path}${sep}`.includes(marker);
+}
+/**
+ * Registration guard (spec 2026-07-20-multi-project-workspace, "Boot flow"):
+ * auto-registration is suppressed — the process still serves the folder
+ * normally, it just doesn't pollute the registry — when the resolved
+ * `repoRoot` is:
+ *
+ * - inside any `…/.ai/cezar/worktrees/…` path (task worktrees and nested
+ *   `cez` invocations — the same nesting reality the `CEZ_TODOS_FILE=''`
+ *   guard in `workflows/run.ts` acknowledges), checked on both the raw and
+ *   realpath'd spelling so neither a symlinked prefix nor a literal one
+ *   slips through; or
+ * - the user's home directory itself (realpath-compared, so a symlinked
+ *   `$HOME` still matches).
+ */
+export async function shouldRegisterProject(repoRoot) {
+    const real = await normalizeRoot(repoRoot);
+    if (isInsideTaskWorktree(real) || isInsideTaskWorktree(resolve(repoRoot)))
+        return false;
+    const home = await normalizeRoot(homedir());
+    return real !== home;
+}
+/**
+ * Register `root` in the workspace registry (idempotent). Known root (by
+ * realpath) → bump its `lastOpenedAt` and return the existing entry, id and
+ * all. Unknown → allocate a slug and append a new entry via merge-write.
+ */
+export async function registerProject(root, source = 'local') {
+    const real = await normalizeRoot(root);
+    const now = new Date().toISOString();
+    let entry;
+    await mergeWriteWorkspaceConfig((config) => {
+        const existing = config.projects.find((p) => p.root === real);
+        if (existing) {
+            existing.lastOpenedAt = now;
+            entry = existing;
+            return;
+        }
+        entry = {
+            id: allocateProjectSlug(real, config.projects.map((p) => p.id)),
+            root: real,
+            name: basename(real),
+            addedAt: now,
+            lastOpenedAt: now,
+            source,
+        };
+        config.projects.push(entry);
+    });
+    // The mutator always runs, so `entry` is always set — this satisfies TS.
+    if (!entry)
+        throw new Error('registerProject: merge-write did not run the mutator');
+    return entry;
+}
+/**
+ * The ONE spelling rule for project tags — applied on every write, never on read.
+ *
+ * Trimmed, empties dropped, over-long ones truncated, deduped CASE-INSENSITIVELY (the first
+ * spelling wins, so `Storefront` typed before `storefront` keeps its capital), capped at
+ * `PROJECT_TAGS_MAX`, and sorted so two projects tagged with the same set store and render the
+ * same list. Case-insensitive dedupe is what makes tags usable as a grouping key: `API` and `api`
+ * grouping into two columns of the same thing is the whole failure this prevents.
+ *
+ * Returns `undefined` — never `[]` — for an empty result, because the registry stores nothing for
+ * an untagged project and `delete entry.tags` is what the writers then do.
+ */
+export function normalizeProjectTags(tags) {
+    if (!tags)
+        return undefined;
+    const bySpelling = new Map();
+    for (const raw of tags) {
+        const tag = raw.trim().slice(0, PROJECT_TAG_MAX_LENGTH);
+        if (!tag)
+            continue;
+        const key = tag.toLowerCase();
+        if (!bySpelling.has(key))
+            bySpelling.set(key, tag);
+        if (bySpelling.size >= PROJECT_TAGS_MAX)
+            break;
+    }
+    const normalized = [...bySpelling.values()].sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+    return normalized.length > 0 ? normalized : undefined;
+}
+/** Probe TTL — long enough to coalesce a burst of sidebar renders, short
+ *  enough that a deleted repo shows as `missing` on the next real look. */
+const PROBE_TTL_MS = 5_000;
+const probeCache = new Map();
+/** Test hook: drop cached probes so status changes are visible immediately. */
+export function clearProjectProbeCache() {
+    probeCache.clear();
+}
+async function computeProbe(root) {
+    try {
+        if (!(await stat(root)).isDirectory())
+            return { status: 'missing' };
+    }
+    catch {
+        return { status: 'missing' };
+    }
+    try {
+        // `.git` may be a dir (normal clone) or a file (worktree/submodule) —
+        // a bare stat covers both without shelling out.
+        await stat(join(root, '.git'));
+    }
+    catch {
+        return { status: 'not-git' };
+    }
+    // Branch and forge are best-effort garnish: getRepoInfo never throws (null
+    // on e.g. an unborn HEAD), and a repo without either is still status ok.
+    const info = await getRepoInfo(root);
+    const forge = forgeKindOfRemote(info?.remote);
+    // Free: `getRepoInfo` already ran for the branch, and the remote is already parsed for `forge`.
+    const repoUrl = forgeWebRoot(info?.remote);
+    return {
+        status: 'ok',
+        ...(info?.branch ? { branch: info.branch } : {}),
+        ...(forge ? { forge } : {}),
+        ...(repoUrl ? { repoUrl } : {}),
+    };
+}
+async function probeRoot(root) {
+    const cached = probeCache.get(root);
+    if (cached && Date.now() - cached.at < PROBE_TTL_MS)
+        return cached.probe;
+    const probe = await computeProbe(root);
+    probeCache.set(root, { at: Date.now(), probe });
+    return probe;
+}
+/**
+ * One root's `status` (+`branch`) through the same TTL cache `listProjects`
+ * uses. Exported for `POST /api/projects` (step 4.2): the register route
+ * answers with the freshly registered entry and must hand the cockpit the
+ * SAME shape the list route does — one project, one shape, whichever route
+ * produced it.
+ */
+export async function probeProjectStatus(root) {
+    return probeRoot(root);
+}
+export async function listProjects(selector) {
+    const config = await loadWorkspaceConfig();
+    const projects = selector
+        ? config.projects.filter((project) => project.id === selector.projectId)
+        : config.projects;
+    return Promise.all(projects.map(async (project) => ({ ...project, ...(await probeRoot(project.root)) })));
+}
+/**
+ * Remove `id` from the registry. Returns false when no such entry exists.
+ * Pure unregistration: nothing inside the repo (worktrees, `.ai/cezar/`,
+ * run history) is touched — re-registering the same root later gets a fresh
+ * slug but finds all its state intact.
+ */
+export async function removeProject(id) {
+    let removed = false;
+    await mergeWriteWorkspaceConfig((config) => {
+        const next = config.projects.filter((p) => p.id !== id);
+        removed = next.length !== config.projects.length;
+        config.projects = next;
+    });
+    return removed;
+}
+//# sourceMappingURL=projects.js.map

package/dist/workspace/projects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects.js","sourceRoot":"","sources":["../../src/workspace/projects.ts"],"names":[],"mappings":"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"}

package/dist/workspace/semaphore.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Workspace-wide resource governance (spec 2026-07-20-multi-project-workspace,
+ * "Resource governance", step 2.5): `maxParallel` and `memoryLimitMb` protect
+ * the *host*, not a repo, so they live in `~/.cezar/config.json` `resources`
+ * and are enforced by ONE shared object across every `RunManager` — the boot
+ * path constructs a single `WorkspaceSemaphore` and threads it through
+ * `ProjectContexts` and the boot manager.
+ *
+ * Two jobs, deliberately fused because they cache the same file:
+ *
+ * 1. **Parallel cap** — `busy()` sums every registered manager's held slots;
+ *    a manager's `pump()` starts queued runs only while `busy() <
+ *    maxParallel()`. Slot accounting stays inside each manager (its
+ *    `active + starting − waiting` count), which is what carries the #347
+ *    exemption verbatim: a `waiting` run holds no slot, and a message into a
+ *    waiting run resumes it immediately even when that momentarily exceeds
+ *    the cap — a resume must never wait on other projects' runs.
+ * 2. **Cached resource config** — `maxParallel()`/`memoryLimitMb()` answer
+ *    from an in-memory snapshot, NOT the file: the memory guard ticks ~every
+ *    2 s per manager, and N projects re-reading `~/.cezar/config.json` every
+ *    tick is exactly what the spec forbids. `refresh()` is the single cache
+ *    hook: boot calls it once, and `PUT /api/workspace/config` (step 2.7)
+ *    calls it after a write — it re-reads the file and pumps every manager so
+ *    a raised cap starts queued runs without a restart.
+ *
+ * Per-repo legacy `maxParallel`/`memoryLimitMb` keys are ignored by
+ * enforcement post-migration (`loadConfig` still parses them for old files;
+ * nothing consults them here).
+ */
+/** The cached `resources` slice run enforcement consults. */
+export interface WorkspaceResourceLimits {
+    /** Workspace-wide cap on concurrently *running* agent runs. */
+    maxParallel: number;
+    /** Durable monitoring sessions that do not consume active-task capacity. */
+    maxMonitoringSessions?: number;
+    /** Automatic monitoring re-check cadence in minutes. Default ON at
+     *  `DEFAULT_MONITORING_WAKE_MINUTES`; explicit `null` means stay parked; absent means
+     *  "this loader predates the key" and reads as the default. */
+    monitoringWakeIntervalMinutes?: number | null;
+    /** Resume a run stopped by a provider usage limit when that limit resets. Default ON. */
+    autoResumeOnUsageLimit?: boolean;
+    /** Per-task process-tree memory ceiling in MiB; null = no limit. */
+    memoryLimitMb: number | null;
+    /**
+     * Per-project concurrency ceilings, keyed by realpath-normalized project
+     * root (the registry stores normalized `root`). A root absent from the map
+     * inherits the workspace `maxParallel`. Optional so older `load` stubs that
+     * only return the resource slice keep working — an absent map means "no
+     * project has an override", i.e. every project inherits.
+     */
+    projectLimits?: ReadonlyMap<string, number>;
+}
+/**
+ * The two kinds of usage-limit hold an account can be under, kept apart because they bind
+ * different work (spec 2026-08-03-auto-resume-after-usage-limit):
+ *
+ *  - `deadline` — a run is parked on a reset instant that has not arrived. The window is known to
+ *    be shut, so this blocks EVERYTHING on that account, resumes included.
+ *  - `inFlight` — a resume is running right now, re-testing the window. Nothing is proven yet, so
+ *    this blocks fresh work but NOT other resumes: a resume blocked by a resume is the deadlock
+ *    that stopped a live workspace dead.
+ */
+export interface AccountHolds {
+    deadline: ReadonlySet<string>;
+    inFlight: ReadonlySet<string>;
+}
+/** One manager's seam into the shared counter. */
+export interface SemaphoreParticipant {
+    /** Slots this manager currently holds. The #347 exemption lives in the
+     *  participant's own accounting: `waiting` runs are already subtracted. */
+    busySlots(): number;
+    /** Kick the manager's queue — capacity may have appeared. Awaited by
+     *  `release()` so the manager taking a freed slot has registered it before
+     *  the next participant evaluates capacity. */
+    pump(): void | Promise<void>;
+    /** Epoch ms of this manager's oldest queued run, or null when its queue is
+     *  empty — `release()`'s ordering key, so a freed slot goes to the
+     *  workspace's longest-waiting run instead of whichever manager happens to
+     *  have registered first. */
+    oldestQueuedAt(): number | null;
+    /**
+     * Agent accounts this participant is holding, by KIND (spec
+     * 2026-08-03-auto-resume-after-usage-limit, `RunManager.accountHolds`).
+     *
+     * Workspace-scoped for the same reason the parallel cap is: a limit closes an ACCOUNT, and one
+     * account can be driving tasks in several projects at once. Optional so a stub participant —
+     * and any caller that predates the hold — keeps working; absent simply holds nothing.
+     */
+    accountHolds?(): AccountHolds;
+}
+export interface WorkspaceSemaphoreOptions {
+    /** Snapshot source for `refresh()` — tests inject a stub; production keeps
+     *  the `~/.cezar/config.json` reader. */
+    load?: () => Promise<WorkspaceResourceLimits>;
+    /** Starting cache, before any `refresh()` — defaults to the workspace
+     *  schema's own defaults (`maxParallel: 2`, no memory limit), so a manager
+     *  constructed without boot wiring behaves like a fresh workspace. */
+    initial?: Partial<WorkspaceResourceLimits>;
+}
+export declare class WorkspaceSemaphore {
+    private readonly participants;
+    private readonly load;
+    private limits;
+    /** A `release()` sweep is in flight — see `pendingRelease`. */
+    private broadcasting;
+    /** A slot freed DURING a sweep. The in-flight sweep may already have pumped
+     *  the manager that should get it, so re-run rather than drop the wakeup. */
+    private pendingRelease;
+    constructor(options?: WorkspaceSemaphoreOptions);
+    /** Join the shared counter. Returns the unregister handle — the manager's
+     *  `dispose()` must call it so a torn-down project stops counting. */
+    register(participant: SemaphoreParticipant): () => void;
+    /** Slots held across EVERY registered manager (waiting runs excluded by
+     *  each participant — the #347 rule). */
+    busy(): number;
+    /** Cached workspace-wide parallel cap. */
+    maxParallel(): number;
+    maxMonitoringSessions(): number;
+    /** Cadence for automatic monitoring re-checks, or null when the operator chose "park
+     *  until resumed". Deliberately NOT `?? DEFAULT`: `null` is a real user choice and
+     *  `null ?? 5` would silently override it (#810). Only an ABSENT key — an older `load`
+     *  stub, a partial `initial` — falls back to the shipped default. */
+    monitoringWakeIntervalMinutes(): number | null;
+    /** Whether a usage-limit stop schedules its own resume. Absent (an older `load` stub, a config
+     *  written before the key existed) reads as ON — the shipped default. */
+    autoResumeOnUsageLimit(): boolean;
+    /** Cached per-task memory ceiling (MiB), or null for no limit. */
+    memoryLimitMb(): number | null;
+    /**
+     * Every agent account held across the WHOLE workspace, by kind — the union of what each manager
+     * reports (spec 2026-08-03-auto-resume-after-usage-limit). A `pump()` consults this before
+     * starting a queued run, so a limit hit in one project also stops the same account being walked
+     * into the wall from another.
+     *
+     * Asked live rather than cached: the underlying answer is derived from run records that change
+     * on every schedule, resume and cancel, and a stale snapshot here would either stall a queue
+     * whose window has reopened or leak a stampede through one that has not.
+     */
+    accountHolds(): AccountHolds;
+    /**
+     * A slot came free somewhere in the workspace: pump EVERY manager,
+     * longest-waiting-queue first.
+     *
+     * This is the counterpart to `busy()` being workspace-wide. A `RunManager`
+     * only ever pumps itself, so before this existed a freed slot reached
+     * exactly one project's queue: a run queued in project B stayed `queued`
+     * while project A's runs came and went, until B happened to start or finish
+     * a run of its own (or someone saved the workspace config). Every
+     * slot-freeing transition — a run settling, a session parking at `waiting`
+     * — routes here instead.
+     *
+     * Pumps are awaited in turn so the manager that takes the slot has it
+     * counted (`starting`) before the next manager evaluates capacity — two
+     * managers pumping concurrently could both read the same free slot and
+     * overshoot `maxParallel`. Ordering is best-effort fairness, not a global
+     * FIFO gate: a manager whose head-of-queue can't start (non-git root,
+     * spec 006 degradation) must never block the rest of the workspace.
+     */
+    release(): Promise<void>;
+    /**
+     * The effective per-project concurrency cap for a manager's repo root: the
+     * project's own `maxParallel` if set in the registry, else the workspace cap
+     * (`maxParallel()`). Answered from the cached snapshot — the class's
+     * no-per-tick-file-read invariant is preserved; the only syscall is a
+     * `realpathSync` to key the lookup the same way the registry normalizes
+     * `root` (once per `pump()`, alongside the existing `getRepoInfo` stat). A
+     * root with no registry entry (an ad-hoc run outside the registry) has no
+     * override and inherits the workspace cap.
+     */
+    projectMaxParallel(repoRoot: string): number;
+    /**
+     * The workspace resource-cache hook: re-read the config and pump every
+     * registered manager, so a config change takes effect without a restart.
+     * Called at boot and by `PUT /api/workspace/config` (step 2.7). A failed
+     * read keeps the last good cache — enforcement never degrades to unlimited
+     * because the file was momentarily unreadable.
+     */
+    refresh(): Promise<void>;
+}

package/dist/workspace/semaphore.js

@@ -0,0 +1,195 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { DEFAULT_MONITORING_WAKE_MINUTES, loadWorkspaceConfig } from './config.js';
+/** Realpath-normalize a root the same way the registry does
+ *  (`workspace/projects.ts` `normalizeRoot`), but synchronously — this answers
+ *  a manager's hot-path lookup and must not `await`. A path that cannot be
+ *  realpath'd degrades to `resolve()`, matching the registry's own fallback. */
+function normalizeRootSync(root) {
+    try {
+        return realpathSync(root);
+    }
+    catch {
+        return resolve(root);
+    }
+}
+const DEFAULT_LIMITS = {
+    maxParallel: 2,
+    maxMonitoringSessions: 2,
+    monitoringWakeIntervalMinutes: DEFAULT_MONITORING_WAKE_MINUTES,
+    autoResumeOnUsageLimit: true,
+    memoryLimitMb: null,
+};
+/** Production loader: the `resources` slice of `~/.cezar/config.json`
+ *  (schema-defaulted, so a missing/corrupt file yields the zero-config
+ *  2 parallel / 2 monitoring / 5-minute wake / no memory cap),
+ *  plus the per-project `maxParallel` overrides built into a root→limit map.
+ *  The registry `root` is already realpath-normalized (`registerProject`), so
+ *  the keys match `normalizeRootSync`'s output at lookup time. */
+async function loadResourceLimits() {
+    const { resources, projects } = await loadWorkspaceConfig();
+    const projectLimits = new Map();
+    for (const project of projects) {
+        if (typeof project.maxParallel === 'number')
+            projectLimits.set(project.root, project.maxParallel);
+    }
+    return {
+        maxParallel: resources.maxParallel,
+        maxMonitoringSessions: resources.maxMonitoringSessions,
+        monitoringWakeIntervalMinutes: resources.monitoringWakeIntervalMinutes,
+        autoResumeOnUsageLimit: resources.autoResumeOnUsageLimit,
+        memoryLimitMb: resources.memoryLimitMb,
+        projectLimits,
+    };
+}
+export class WorkspaceSemaphore {
+    participants = new Set();
+    load;
+    limits;
+    /** A `release()` sweep is in flight — see `pendingRelease`. */
+    broadcasting = false;
+    /** A slot freed DURING a sweep. The in-flight sweep may already have pumped
+     *  the manager that should get it, so re-run rather than drop the wakeup. */
+    pendingRelease = false;
+    constructor(options = {}) {
+        this.load = options.load ?? loadResourceLimits;
+        this.limits = { ...DEFAULT_LIMITS, ...options.initial };
+    }
+    /** Join the shared counter. Returns the unregister handle — the manager's
+     *  `dispose()` must call it so a torn-down project stops counting. */
+    register(participant) {
+        this.participants.add(participant);
+        return () => this.participants.delete(participant);
+    }
+    /** Slots held across EVERY registered manager (waiting runs excluded by
+     *  each participant — the #347 rule). */
+    busy() {
+        let total = 0;
+        for (const participant of this.participants)
+            total += participant.busySlots();
+        return total;
+    }
+    /** Cached workspace-wide parallel cap. */
+    maxParallel() {
+        return this.limits.maxParallel;
+    }
+    maxMonitoringSessions() {
+        return this.limits.maxMonitoringSessions ?? 2;
+    }
+    /** Cadence for automatic monitoring re-checks, or null when the operator chose "park
+     *  until resumed". Deliberately NOT `?? DEFAULT`: `null` is a real user choice and
+     *  `null ?? 5` would silently override it (#810). Only an ABSENT key — an older `load`
+     *  stub, a partial `initial` — falls back to the shipped default. */
+    monitoringWakeIntervalMinutes() {
+        const configured = this.limits.monitoringWakeIntervalMinutes;
+        return configured === undefined ? DEFAULT_MONITORING_WAKE_MINUTES : configured;
+    }
+    /** Whether a usage-limit stop schedules its own resume. Absent (an older `load` stub, a config
+     *  written before the key existed) reads as ON — the shipped default. */
+    autoResumeOnUsageLimit() {
+        return this.limits.autoResumeOnUsageLimit ?? true;
+    }
+    /** Cached per-task memory ceiling (MiB), or null for no limit. */
+    memoryLimitMb() {
+        return this.limits.memoryLimitMb;
+    }
+    /**
+     * Every agent account held across the WHOLE workspace, by kind — the union of what each manager
+     * reports (spec 2026-08-03-auto-resume-after-usage-limit). A `pump()` consults this before
+     * starting a queued run, so a limit hit in one project also stops the same account being walked
+     * into the wall from another.
+     *
+     * Asked live rather than cached: the underlying answer is derived from run records that change
+     * on every schedule, resume and cancel, and a stale snapshot here would either stall a queue
+     * whose window has reopened or leak a stampede through one that has not.
+     */
+    accountHolds() {
+        const deadline = new Set();
+        const inFlight = new Set();
+        for (const participant of this.participants) {
+            const holds = participant.accountHolds?.();
+            if (!holds)
+                continue;
+            for (const key of holds.deadline)
+                deadline.add(key);
+            for (const key of holds.inFlight)
+                inFlight.add(key);
+        }
+        return { deadline, inFlight };
+    }
+    /**
+     * A slot came free somewhere in the workspace: pump EVERY manager,
+     * longest-waiting-queue first.
+     *
+     * This is the counterpart to `busy()` being workspace-wide. A `RunManager`
+     * only ever pumps itself, so before this existed a freed slot reached
+     * exactly one project's queue: a run queued in project B stayed `queued`
+     * while project A's runs came and went, until B happened to start or finish
+     * a run of its own (or someone saved the workspace config). Every
+     * slot-freeing transition — a run settling, a session parking at `waiting`
+     * — routes here instead.
+     *
+     * Pumps are awaited in turn so the manager that takes the slot has it
+     * counted (`starting`) before the next manager evaluates capacity — two
+     * managers pumping concurrently could both read the same free slot and
+     * overshoot `maxParallel`. Ordering is best-effort fairness, not a global
+     * FIFO gate: a manager whose head-of-queue can't start (non-git root,
+     * spec 006 degradation) must never block the rest of the workspace.
+     */
+    async release() {
+        if (this.broadcasting) {
+            this.pendingRelease = true;
+            return;
+        }
+        this.broadcasting = true;
+        try {
+            do {
+                this.pendingRelease = false;
+                const ordered = [...this.participants]
+                    .map((participant) => ({
+                    participant,
+                    // Empty queues sort last — they have nothing to claim the slot with.
+                    since: participant.oldestQueuedAt() ?? Number.MAX_SAFE_INTEGER,
+                }))
+                    .sort((a, b) => a.since - b.since);
+                for (const { participant } of ordered)
+                    await participant.pump();
+            } while (this.pendingRelease);
+        }
+        finally {
+            this.broadcasting = false;
+        }
+    }
+    /**
+     * The effective per-project concurrency cap for a manager's repo root: the
+     * project's own `maxParallel` if set in the registry, else the workspace cap
+     * (`maxParallel()`). Answered from the cached snapshot — the class's
+     * no-per-tick-file-read invariant is preserved; the only syscall is a
+     * `realpathSync` to key the lookup the same way the registry normalizes
+     * `root` (once per `pump()`, alongside the existing `getRepoInfo` stat). A
+     * root with no registry entry (an ad-hoc run outside the registry) has no
+     * override and inherits the workspace cap.
+     */
+    projectMaxParallel(repoRoot) {
+        const override = this.limits.projectLimits?.get(normalizeRootSync(repoRoot));
+        return override ?? this.maxParallel();
+    }
+    /**
+     * The workspace resource-cache hook: re-read the config and pump every
+     * registered manager, so a config change takes effect without a restart.
+     * Called at boot and by `PUT /api/workspace/config` (step 2.7). A failed
+     * read keeps the last good cache — enforcement never degrades to unlimited
+     * because the file was momentarily unreadable.
+     */
+    async refresh() {
+        try {
+            this.limits = await this.load();
+        }
+        catch {
+            // keep the last good snapshot
+        }
+        // A raised cap is capacity appearing everywhere at once — same sweep.
+        await this.release();
+    }
+}
+//# sourceMappingURL=semaphore.js.map

package/dist/workspace/semaphore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semaphore.js","sourceRoot":"","sources":["../../src/workspace/semaphore.ts"],"names":[],"mappings":"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"}