@open-mercato/cezar 0.9.0-pr609.613 → 0.9.0-pr609.615

package/dist/server/server.d.ts

@@ -114,6 +114,14 @@ export interface RemoveProjectResponse {
     removed: true;
     id: string;
 }
+/** `PATCH /api/projects/:projectId` (spec 2026-07-22-per-project-concurrency)
+ *  — sets or clears a project's per-project `maxParallel`. The entry carries
+ *  the same `status`/`branch` probe `GET /api/projects` attaches, so the
+ *  cockpit sees one project shape. `null` in the request clears the override
+ *  back to "inherit the workspace cap". */
+export interface UpdateProjectResponse {
+    project: ProjectListEntry;
+}
 /** `GET/PUT /api/workspace/config` (multi-project spec, step 2.7) — the
  *  settings slice of `~/.cezar/config.json`: global knobs ONLY, never the
  *  project registry (that is `GET /api/projects`' job). */

package/dist/server/server.js

@@ -1053,6 +1053,60 @@ export function createApp(deps) {
         const body = { removed: true, id };
         return c.json(body);
     });
+    // Edit one field of an existing registry entry (spec
+    // 2026-07-22-per-project-concurrency): the per-project concurrency ceiling.
+    // A PATCH (not PUT) because it touches a single field, and a distinct route
+    // from POST (register-a-folder) to keep register vs. edit semantics clear.
+    // `maxParallel: null` clears the override back to "inherit the workspace
+    // cap". Bounds mirror `workspaceProjectSchema` (config.ts) exactly, so a
+    // value this route accepts can never be degraded away by the next load's
+    // `.catch`.
+    const updateProjectSchema = z.object({
+        maxParallel: z.number().int().min(1).max(16).nullable(),
+    });
+    app.patch('/api/projects/:projectId', async (c) => {
+        const raw = c.req.param('projectId');
+        // Same gate + 404 wording as DELETE: a malformed id is an unknown project.
+        if (!projectIdSchema.safeParse(raw).success) {
+            return c.json({ error: `unknown project: ${raw}` }, 404);
+        }
+        const parsed = updateProjectSchema.safeParse(await c.req.json().catch(() => null));
+        if (!parsed.success) {
+            return c.json({ error: parsed.error.issues.map((i) => i.message).join('; ') }, 400);
+        }
+        // `default` is the boot alias the cockpit is allowed to use everywhere else.
+        const id = raw === 'default' ? await resolveBootProject() : raw;
+        const { maxParallel } = parsed.data;
+        let updated;
+        try {
+            await mergeWriteWorkspaceConfig((config) => {
+                const entry = config.projects.find((p) => p.id === id);
+                if (!entry)
+                    return; // unknown id — persisted nothing; answered 404 below
+                // null clears the override; a number sets it. Mutated in place so
+                // `.passthrough()` keys on the entry survive.
+                if (maxParallel === null)
+                    delete entry.maxParallel;
+                else
+                    entry.maxParallel = maxParallel;
+                updated = entry;
+            });
+        }
+        catch (err) {
+            // e.g. a read-only home — nothing was persisted (atomic tmp+rename).
+            return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+        if (!updated)
+            return c.json({ error: `unknown project: ${id}` }, 404);
+        // The new ceiling takes effect WITHOUT a restart: refresh the shared
+        // semaphore's snapshot and pump every manager — the same live-apply hook
+        // `PUT /api/workspace/config` fires for a workspace-cap change.
+        await deps.semaphore?.refresh();
+        const body = {
+            project: { ...updated, ...(await probeProjectStatus(updated.root)) },
+        };
+        return c.json(body);
+    });
     // ---- GUI clone (multi-project spec, step 4.3) ----------------------------
     // "Add project → Clone from GitHub": clone into the checkout root, then
     // register the result through `registerFolder` above (same guards, same