aicodeman 1.4.0 → 1.5.0

package/dist/web/routes/case-routes.js

@@ -14,10 +14,11 @@ import { CreateCaseSchema, LinkCaseSchema, CaseOrderSchema, RemoteCaseLinkSchema
 import { exportDockerCase, importDockerBundle, listDockerExports, exportBundleName } from '../../docker-export.js';
 import { generateClaudeMd } from '../../templates/claude-md.js';
 import { writeHooksConfig } from '../../hooks-config.js';
-import { CASES_DIR, SETTINGS_PATH, validatePathWithinBase, parseBody, readJsonConfig } from '../route-helpers.js';
+import { canAccessOwned, getAuthUser, isAdmin, isWorkingDirAllowed, ownerFor, resolveCasesDir, SETTINGS_PATH, validatePathWithinBase, parseBody, readJsonConfig, } from '../route-helpers.js';
+import { isMultiUserMode } from '../../config/multiuser.js';
 import { SseEvent } from '../sse-events.js';
 import { dataPath, getDataDir } from '../../config/instance.js';
-import { checkDockerAvailable, checkDockerTmuxAvailable, DEFAULT_AGENT_IMAGE, dockerContainerName, dockerDisplayPath, readDockerCases, readDockerHosts, toSessionDocker, writeDockerCases, writeDockerHosts, } from '../../docker-hosts.js';
+import { checkDockerAvailable, checkDockerImagePresent, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, dockerContainerName, dockerDisplayPath, readDockerCases, readDockerHosts, toSessionDocker, writeDockerCases, writeDockerHosts, } from '../../docker-hosts.js';
 import { buildDockerRemoveCommand } from '../../tmux-manager.js';
 import { checkRemoteTmuxAvailable, readRemoteCases, readRemoteHosts, remoteDisplayPath, writeRemoteCases, writeRemoteHosts, } from '../../remote-hosts.js';
 const LINKED_CASES_FILE = dataPath('linked-cases.json');
@@ -40,58 +41,105 @@ const APP_VERSION = (() => {
 async function readLinkedCases() {
     return readJsonConfig(LINKED_CASES_FILE, 'linked cases', {});
 }
-/** Resolve a case name to its directory path, checking linked cases first, then CASES_DIR. */
-async function resolveCasePath(name) {
+/**
+ * Resolve a case name to its directory path, checking linked cases first, then the
+ * user's case space (per-user in multi-user mode, the shared CASES_DIR otherwise).
+ */
+async function resolveCasePath(name, user) {
     const linkedCases = await readLinkedCases();
-    if (linkedCases[name])
+    // Linked cases carry no owner (legacy/admin-only registry): a non-admin must not
+    // resolve arbitrary linked paths by name in multi-user mode (path-escape guard).
+    if (linkedCases[name] && (!isMultiUserMode() || user?.role === 'admin'))
         return linkedCases[name];
-    return join(CASES_DIR, name);
+    return join(resolveCasesDir(user), name);
+}
+/**
+ * Gate a docker case on its base image, AUTO-BUILDING the default image on first
+ * use so a missing image is never a blocker (the user's ask: "create it when it's
+ * used for the first time"). Present image → verify tmux (hard prerequisite).
+ * Default image missing → kick off a BACKGROUND build with SSE progress and return
+ * `imageBuilding: true` (the case is created regardless; first launch awaits the
+ * same dedup'd build). Custom image missing → a real error (we can't build a
+ * foreign ref, and `--pull=never` forbids pulling).
+ */
+async function ensureCaseImage(broadcast, sessionDocker, name) {
+    if (await checkDockerImagePresent(sessionDocker.engine, sessionDocker.image)) {
+        const tmuxCheck = await checkDockerTmuxAvailable(sessionDocker);
+        if (!tmuxCheck.ok)
+            return { ok: false, error: tmuxCheck.error || 'base image is missing tmux' };
+        return { ok: true, imageBuilding: false };
+    }
+    if (sessionDocker.image !== DEFAULT_AGENT_IMAGE) {
+        return {
+            ok: false,
+            error: `base image ${sessionDocker.image} not present; only ${DEFAULT_AGENT_IMAGE} is auto-built. Build or pull it first.`,
+        };
+    }
+    broadcast(SseEvent.DockerImageBuildStarted, { name, image: sessionDocker.image });
+    void ensureAgentBaseImage(sessionDocker.engine, sessionDocker.image, {
+        onProgress: (line) => broadcast(SseEvent.DockerImageBuildProgress, { name, line }),
+    })
+        .then((r) => broadcast(r.ok ? SseEvent.DockerImageBuildComplete : SseEvent.DockerImageBuildFailed, {
+        name,
+        image: sessionDocker.image,
+        error: r.error,
+    }))
+        .catch((err) => broadcast(SseEvent.DockerImageBuildFailed, { name, image: sessionDocker.image, error: getErrorMessage(err) }));
+    return { ok: true, imageBuilding: true };
 }
 export function registerCaseRoutes(app, ctx) {
     // ═══════════════════════════════════════════════════════════════
     // Case CRUD (list, create, link, detail, fix-plan)
     // ═══════════════════════════════════════════════════════════════
     // ========== List Cases ==========
-    app.get('/api/cases', async () => {
+    app.get('/api/cases', async (req) => {
         const cases = [];
-        // Get cases from CASES_DIR
+        const user = getAuthUser(req);
+        const admin = isAdmin(req);
+        // Non-admins enumerate their OWN case space; admins see the shared CASES_DIR.
+        const listBase = resolveCasesDir(user);
+        // Get cases from the user's (or shared) cases dir
         try {
-            const entries = await fs.readdir(CASES_DIR, { withFileTypes: true });
+            const entries = await fs.readdir(listBase, { withFileTypes: true });
             for (const e of entries) {
                 if (e.isDirectory() && SAFE_CASE_NAME.test(e.name)) {
                     cases.push({
                         name: e.name,
-                        path: join(CASES_DIR, e.name),
-                        hasClaudeMd: existsSync(join(CASES_DIR, e.name, 'CLAUDE.md')),
+                        path: join(listBase, e.name),
+                        hasClaudeMd: existsSync(join(listBase, e.name, 'CLAUDE.md')),
                         location: 'local',
                     });
                 }
             }
         }
         catch {
-            // CASES_DIR may not exist yet
+            // dir may not exist yet
         }
-        // Get linked cases
+        // Linked cases (v1 registry has no owner) are admin-only in multi-user mode.
         const linkedCases = await readLinkedCases();
         const existingNames = new Set(cases.map((c) => c.name));
-        for (const [name, path] of Object.entries(linkedCases)) {
-            if (!existingNames.has(name) && SAFE_CASE_NAME.test(name) && existsSync(path)) {
-                cases.push({
-                    name,
-                    path,
-                    hasClaudeMd: existsSync(join(path, 'CLAUDE.md')),
-                    linked: true,
-                    location: 'linked-local',
-                });
+        if (admin) {
+            for (const [name, path] of Object.entries(linkedCases)) {
+                if (!existingNames.has(name) && SAFE_CASE_NAME.test(name) && existsSync(path)) {
+                    cases.push({
+                        name,
+                        path,
+                        hasClaudeMd: existsSync(join(path, 'CLAUDE.md')),
+                        linked: true,
+                        location: 'linked-local',
+                    });
+                }
             }
         }
-        // Get remote cases
+        // Get remote cases (owner-scoped; legacy no-owner = admin-only)
         const remoteHosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
         const remoteHostMap = new Map(remoteHosts.map((host) => [host.id, host]));
         for (const remoteCase of await readRemoteCases(CODEMAN_CONFIG_DIR)) {
             const host = remoteHostMap.get(remoteCase.hostId);
             if (!host || !SAFE_CASE_NAME.test(remoteCase.name))
                 continue;
+            if (!admin && !canAccessOwned(user, remoteCase.owner))
+                continue;
             existingNames.add(remoteCase.name);
             const remoteCaseInfo = {
                 name: remoteCase.name,
@@ -120,6 +168,8 @@ export function registerCaseRoutes(app, ctx) {
             const host = dockerHostMap.get(dockerCase.hostId);
             if (!host || !SAFE_CASE_NAME.test(dockerCase.name))
                 continue;
+            if (!admin && !canAccessOwned(user, dockerCase.owner))
+                continue;
             existingNames.add(dockerCase.name);
             const container = dockerCase.container ?? dockerContainerName(dockerCase.name);
             const dockerCaseInfo = {
@@ -158,7 +208,7 @@ export function registerCaseRoutes(app, ctx) {
     });
     app.post('/api/cases', async (req) => {
         const { name, description } = parseBody(CreateCaseSchema, req.body);
-        const casePath = validatePathWithinBase(name, CASES_DIR);
+        const casePath = validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)));
         if (!casePath) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case path');
         }
@@ -181,8 +231,17 @@ export function registerCaseRoutes(app, ctx) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, getErrorMessage(err));
         }
     });
-    app.get('/api/remote-hosts', async () => readRemoteHosts(CODEMAN_CONFIG_DIR));
-    app.post('/api/remote-hosts', async (req) => {
+    // Hosts are machine-level infra config (ssh users/identity paths): non-admins get an
+    // empty list in multi-user mode, matching the admin-only write side. No-op otherwise.
+    app.get('/api/remote-hosts', async (req) => isMultiUserMode() && !isAdmin(req) ? [] : readRemoteHosts(CODEMAN_CONFIG_DIR));
+    // Hosts are machine-level resources: only admins may define them in multi-user mode.
+    const adminOnly = (req, reply) => isAdmin(req)
+        ? null
+        : (reply.code(403), createErrorResponse(ApiErrorCode.FORBIDDEN, 'Admin only in multi-user mode'));
+    app.post('/api/remote-hosts', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const host = parseBody(RemoteHostSchema, req.body);
         const hosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
         if (hosts.some((item) => item.id === host.id)) {
@@ -191,7 +250,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeRemoteHosts(CODEMAN_CONFIG_DIR, [...hosts, host]);
         return { success: true, data: { host } };
     });
-    app.put('/api/remote-hosts/:id', async (req) => {
+    app.put('/api/remote-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const host = parseBody(RemoteHostSchema, { ...req.body, id });
         const hosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
@@ -203,7 +265,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeRemoteHosts(CODEMAN_CONFIG_DIR, next);
         return { success: true, data: { host } };
     });
-    app.delete('/api/remote-hosts/:id', async (req) => {
+    app.delete('/api/remote-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const cases = await readRemoteCases(CODEMAN_CONFIG_DIR);
         if (cases.some((item) => item.hostId === id)) {
@@ -214,7 +279,7 @@ export function registerCaseRoutes(app, ctx) {
         return { success: true, data: { id } };
     });
     app.post('/api/cases/remote-link', async (req) => {
-        const remoteCase = { ...parseBody(RemoteCaseLinkSchema, req.body), type: 'remote' };
+        const remoteCase = { ...parseBody(RemoteCaseLinkSchema, req.body), type: 'remote', owner: ownerFor(req) };
         const hosts = await readRemoteHosts(CODEMAN_CONFIG_DIR);
         const host = hosts.find((item) => item.id === remoteCase.hostId);
         if (!host)
@@ -223,7 +288,7 @@ export function registerCaseRoutes(app, ctx) {
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
         if (remoteCases.some((item) => item.name === remoteCase.name) ||
             linkedCases[remoteCase.name] ||
-            existsSync(join(CASES_DIR, remoteCase.name))) {
+            existsSync(join(resolveCasesDir(getAuthUser(req)), remoteCase.name))) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
         // Courtesy validation: tmux is a hard prerequisite for durable remote sessions.
@@ -238,8 +303,13 @@ export function registerCaseRoutes(app, ctx) {
         return { success: true, data: { case: remoteCase } };
     });
     // ========== Docker hosts + docker cases (COD-Docker) ==========
-    app.get('/api/docker-hosts', async () => readDockerHosts(CODEMAN_CONFIG_DIR));
-    app.post('/api/docker-hosts', async (req) => {
+    // Hosts are machine-level infra config (images/mounts/env): non-admins get an empty
+    // list in multi-user mode, matching the admin-only write side. No-op otherwise.
+    app.get('/api/docker-hosts', async (req) => isMultiUserMode() && !isAdmin(req) ? [] : readDockerHosts(CODEMAN_CONFIG_DIR));
+    app.post('/api/docker-hosts', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const host = parseBody(DockerHostSchema, req.body);
         const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
         if (hosts.some((item) => item.id === host.id)) {
@@ -248,7 +318,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeDockerHosts(CODEMAN_CONFIG_DIR, [...hosts, host]);
         return { success: true, data: { host } };
     });
-    app.put('/api/docker-hosts/:id', async (req) => {
+    app.put('/api/docker-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const host = parseBody(DockerHostSchema, { ...req.body, id });
         const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
@@ -260,7 +333,10 @@ export function registerCaseRoutes(app, ctx) {
         await writeDockerHosts(CODEMAN_CONFIG_DIR, next);
         return { success: true, data: { host } };
     });
-    app.delete('/api/docker-hosts/:id', async (req) => {
+    app.delete('/api/docker-hosts/:id', async (req, reply) => {
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { id } = req.params;
         const cases = await readDockerCases(CODEMAN_CONFIG_DIR);
         if (cases.some((item) => item.hostId === id)) {
@@ -271,7 +347,11 @@ export function registerCaseRoutes(app, ctx) {
         return { success: true, data: { id } };
     });
     app.post('/api/cases/docker-link', async (req) => {
-        const dockerCase = { ...parseBody(DockerCaseLinkSchema, req.body), type: 'docker' };
+        const dockerCase = {
+            ...parseBody(DockerCaseLinkSchema, req.body),
+            type: 'docker',
+            owner: ownerFor(req),
+        };
         const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
         const host = hosts.find((item) => item.id === dockerCase.hostId);
         if (!host)
@@ -280,9 +360,14 @@ export function registerCaseRoutes(app, ctx) {
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
         if (dockerCases.some((item) => item.name === dockerCase.name) ||
             linkedCases[dockerCase.name] ||
-            existsSync(join(CASES_DIR, dockerCase.name))) {
+            existsSync(join(resolveCasesDir(getAuthUser(req)), dockerCase.name))) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
+        // Confine the bind-mounted workspace to the caller's own space BEFORE creating it
+        // (also removes the arbitrary-dir-creation primitive). No-op for admins/single-user.
+        if (!isWorkingDirAllowed(getAuthUser(req), dockerCase.hostWorkspacePath)) {
+            return createErrorResponse(ApiErrorCode.FORBIDDEN, 'hostWorkspacePath is outside your workspace');
+        }
         // The workspace is a REAL host directory (bind-mounted into the container), so
         // create it now if missing. Scaffolding (.claude/settings.local.json + CLAUDE.md)
         // is written by quick-start on first launch, matching local-case behaviour.
@@ -294,16 +379,16 @@ export function registerCaseRoutes(app, ctx) {
                 return createErrorResponse(ApiErrorCode.OPERATION_FAILED, `Could not create workspace: ${getErrorMessage(err)}`);
             }
         }
-        // Courtesy validation: docker daemon must be reachable AND the base image must
-        // contain tmux (a hard prerequisite for durable in-container sessions). Surfaces
-        // a clear error at link time instead of a dead pane on first launch.
+        // Courtesy validation: docker daemon must be reachable. The base image is
+        // auto-built on first use (default image) rather than being a link-time
+        // blocker, so a missing image kicks off a background build instead of erroring.
         const availability = await checkDockerAvailable(host.engine);
         if (!availability.ok) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, availability.error || 'docker daemon is not available');
         }
-        const tmuxCheck = await checkDockerTmuxAvailable(toSessionDocker(host, dockerCase));
-        if (!tmuxCheck.ok) {
-            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, tmuxCheck.error || 'base image is missing tmux');
+        const imageGate = await ensureCaseImage(ctx.broadcast, toSessionDocker(host, dockerCase), dockerCase.name);
+        if (!imageGate.ok) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, imageGate.error);
         }
         await writeDockerCases(CODEMAN_CONFIG_DIR, [...dockerCases, dockerCase]);
         ctx.broadcast(SseEvent.CaseLinked, {
@@ -313,7 +398,12 @@ export function registerCaseRoutes(app, ctx) {
         });
         return {
             success: true,
-            data: { case: dockerCase, capsEnforced: availability.capsEnforced, isDesktop: availability.isDesktop },
+            data: {
+                case: dockerCase,
+                capsEnforced: availability.capsEnforced,
+                isDesktop: availability.isDesktop,
+                imageBuilding: imageGate.imageBuilding,
+            },
         };
     });
     // One-click "Run in Docker": create a NORMAL case (folder in CASES_DIR, scaffolded)
@@ -322,7 +412,7 @@ export function registerCaseRoutes(app, ctx) {
     app.post('/api/cases/docker-quickcreate', async (req) => {
         const body = parseBody(DockerQuickCreateSchema, req.body);
         const { name, description } = body;
-        const casePath = validatePathWithinBase(name, CASES_DIR);
+        const casePath = validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)));
         if (!casePath)
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case path');
         // Collision across every case kind.
@@ -371,16 +461,23 @@ export function registerCaseRoutes(app, ctx) {
         else if (hasOverrides) {
             await writeDockerHosts(CODEMAN_CONFIG_DIR, hosts.map((h) => (h.id === desiredHost.id ? desiredHost : h)));
         }
-        // Probe the daemon + base image BEFORE scaffolding, so a missing docker/image
-        // surfaces a clear error instead of leaving an orphaned case folder.
+        // Probe the daemon BEFORE scaffolding so a missing docker surfaces a clear
+        // error instead of leaving an orphaned case folder. The base image is NOT a
+        // blocker: a missing default image auto-builds in the background on first use.
         const availability = await checkDockerAvailable(host.engine);
         if (!availability.ok) {
             return createErrorResponse(ApiErrorCode.OPERATION_FAILED, availability.error || 'docker daemon is not available');
         }
-        const dockerCase = { name, type: 'docker', hostId: host.id, hostWorkspacePath: casePath };
-        const tmuxCheck = await checkDockerTmuxAvailable(toSessionDocker(host, dockerCase));
-        if (!tmuxCheck.ok) {
-            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, tmuxCheck.error || 'base image is missing tmux (build it: node scripts/build-agent-image.mjs)');
+        const dockerCase = {
+            name,
+            type: 'docker',
+            hostId: host.id,
+            hostWorkspacePath: casePath,
+            owner: ownerFor(req),
+        };
+        const imageGate = await ensureCaseImage(ctx.broadcast, toSessionDocker(host, dockerCase), name);
+        if (!imageGate.ok) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, imageGate.error);
         }
         // Scaffold the case folder exactly like a normal case.
         try {
@@ -398,7 +495,12 @@ export function registerCaseRoutes(app, ctx) {
         ctx.broadcast(SseEvent.CaseLinked, { name, path: casePath, type: 'docker' });
         return {
             success: true,
-            data: { case: dockerCase, capsEnforced: availability.capsEnforced, isDesktop: availability.isDesktop },
+            data: {
+                case: dockerCase,
+                capsEnforced: availability.capsEnforced,
+                isDesktop: availability.isDesktop,
+                imageBuilding: imageGate.imageBuilding,
+            },
         };
     });
     // ========== Docker export / import ==========
@@ -480,9 +582,14 @@ export function registerCaseRoutes(app, ctx) {
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
         if (dockerCases.some((item) => item.name === newCaseName) ||
             linkedCases[newCaseName] ||
-            existsSync(join(CASES_DIR, newCaseName))) {
+            existsSync(join(resolveCasesDir(getAuthUser(req)), newCaseName))) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
         }
+        // Import extracts a tar into destWorkspacePath (later becomes Session.workingDir):
+        // confine it to the caller's own space. No-op for admins/single-user.
+        if (!isWorkingDirAllowed(getAuthUser(req), destWorkspacePath)) {
+            return createErrorResponse(ApiErrorCode.FORBIDDEN, 'destWorkspacePath is outside your workspace');
+        }
         const timestamp = Date.now();
         let result;
         try {
@@ -515,13 +622,19 @@ export function registerCaseRoutes(app, ctx) {
             hostId,
             hostWorkspacePath: destWorkspacePath,
             containerWorkdir: result.manifest.containerWorkdir,
+            owner: ownerFor(req),
         };
         await writeDockerCases(CODEMAN_CONFIG_DIR, [...dockerCases, newCase]);
         ctx.broadcast(SseEvent.DockerImportComplete, { name: newCaseName, path: destWorkspacePath, type: 'docker' });
         return { success: true, data: { case: newCase } };
     });
     // Link an existing folder as a case
-    app.post('/api/cases/link', async (req) => {
+    app.post('/api/cases/link', async (req, reply) => {
+        // Linking writes an arbitrary absolute path into the shared ownerless registry:
+        // admin-only in multi-user mode (mirrors host CRUD + the admin-only GET listing).
+        const denied = adminOnly(req, reply);
+        if (denied)
+            return denied;
         const { name, path: folderPath } = parseBody(LinkCaseSchema, req.body, 'Invalid request body');
         // Expand ~ to home directory
         const expandedPath = folderPath.startsWith('~') ? join(homedir(), folderPath.slice(1)) : folderPath;
@@ -530,7 +643,7 @@ export function registerCaseRoutes(app, ctx) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, `Folder not found: ${expandedPath}`);
         }
         // Check if case name already exists in CASES_DIR
-        const casePath = join(CASES_DIR, name);
+        const casePath = join(resolveCasesDir(getAuthUser(req)), name);
         if (existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'A case with this name already exists in codeman-cases.');
         }
@@ -558,36 +671,47 @@ export function registerCaseRoutes(app, ctx) {
     // ========== Delete / Unlink Case ==========
     app.delete('/api/cases/:name', async (req) => {
         const { name } = req.params;
-        if (!validatePathWithinBase(name, CASES_DIR)) {
+        const user = getAuthUser(req);
+        if (!validatePathWithinBase(name, resolveCasesDir(user))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
+        // Fold ownership INTO the match (don't early-return): a non-owned same-named remote/
+        // docker case is skipped so control falls through to the caller's own local delete.
+        // canAccessOwned is all-true for admins/single-user, so flag-OFF stays byte-identical.
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
-        if (remoteCases.some((item) => item.name === name)) {
-            await writeRemoteCases(CODEMAN_CONFIG_DIR, remoteCases.filter((item) => item.name !== name));
+        if (remoteCases.some((item) => item.name === name && canAccessOwned(user, item.owner))) {
+            await writeRemoteCases(CODEMAN_CONFIG_DIR, remoteCases.filter((item) => !(item.name === name && canAccessOwned(user, item.owner))));
             ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'remote-unlinked' });
             return { success: true, data: { name } };
         }
         const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
-        const dockerCase = dockerCases.find((item) => item.name === name);
+        const dockerCase = dockerCases.find((item) => item.name === name && canAccessOwned(user, item.owner));
         if (dockerCase) {
-            await writeDockerCases(CODEMAN_CONFIG_DIR, dockerCases.filter((item) => item.name !== name));
+            await writeDockerCases(CODEMAN_CONFIG_DIR, dockerCases.filter((item) => item !== dockerCase));
             // Best-effort `docker rm -f` the per-case container (case-delete is the
             // explicit teardown that removes it; the bind-mounted workspace survives).
             const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
             if (host) {
+                const sessionDocker = toSessionDocker(host, dockerCase);
                 try {
-                    exec(buildDockerRemoveCommand(toSessionDocker(host, dockerCase)), { timeout: 15_000 }, () => { });
+                    exec(buildDockerRemoveCommand(sessionDocker), { timeout: 15_000 }, () => { });
                 }
                 catch {
                     /* best-effort — never blocks the unlink */
                 }
+                // Remove the per-container claude-config seed file (account metadata copy).
+                await fs
+                    .rm(join(dataPath('docker-seeds'), `${sessionDocker.containerName}.json`), { force: true })
+                    .catch(() => { });
             }
             ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'docker-unlinked' });
             return { success: true, data: { name } };
         }
-        // Check linked cases first — unlink only, don't delete the actual directory
+        // Check linked cases first — unlink only, don't delete the actual directory.
+        // Linked cases carry no owner (admin-only WRITE in multi-user mode), so a non-admin
+        // must not unlink one either; skip so control falls through to their local delete.
         const linkedCases = await readLinkedCases();
-        if (linkedCases[name]) {
+        if (linkedCases[name] && (!isMultiUserMode() || isAdmin(req))) {
             delete linkedCases[name];
             try {
                 await fs.writeFile(LINKED_CASES_FILE, JSON.stringify(linkedCases, null, 2));
@@ -599,7 +723,7 @@ export function registerCaseRoutes(app, ctx) {
             }
         }
         // Case in CASES_DIR — delete the entire directory
-        const casePath = join(CASES_DIR, name);
+        const casePath = join(resolveCasesDir(getAuthUser(req)), name);
         if (!existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, `Case "${name}" not found`);
         }
@@ -638,11 +762,15 @@ export function registerCaseRoutes(app, ctx) {
     });
     app.get('/api/cases/:name', async (req) => {
         const { name } = req.params;
-        if (!validatePathWithinBase(name, CASES_DIR)) {
+        if (!validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
+        // Fold ownership INTO the match (don't early-return): a non-owned same-named remote/
+        // docker case is skipped so control falls through to the caller's own LOCAL case
+        // (remote/docker names are globally unique, local names per-user). No metadata is
+        // disclosed for a foreign case. canAccessOwned is allow-all for admins/single-user.
         const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
-        const remoteCase = remoteCases.find((item) => item.name === name);
+        const remoteCase = remoteCases.find((item) => item.name === name && canAccessOwned(getAuthUser(req), item.owner));
         if (remoteCase) {
             const host = (await readRemoteHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === remoteCase.hostId);
             if (!host)
@@ -660,7 +788,7 @@ export function registerCaseRoutes(app, ctx) {
                 },
             };
         }
-        const dockerCase = (await readDockerCases(CODEMAN_CONFIG_DIR)).find((item) => item.name === name);
+        const dockerCase = (await readDockerCases(CODEMAN_CONFIG_DIR)).find((item) => item.name === name && canAccessOwned(getAuthUser(req), item.owner));
         if (dockerCase) {
             const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
             if (!host)
@@ -680,11 +808,11 @@ export function registerCaseRoutes(app, ctx) {
                 },
             };
         }
-        const casePath = await resolveCasePath(name);
+        const casePath = await resolveCasePath(name, getAuthUser(req));
         if (!existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Case not found');
         }
-        const linked = casePath !== join(CASES_DIR, name);
+        const linked = casePath !== join(resolveCasesDir(getAuthUser(req)), name);
         return {
             name,
             path: casePath,
@@ -695,11 +823,11 @@ export function registerCaseRoutes(app, ctx) {
     // Read @fix_plan.md from a case directory (for wizard to detect existing plans)
     app.get('/api/cases/:name/fix-plan', async (req) => {
         const { name } = req.params;
-        if (!validatePathWithinBase(name, CASES_DIR)) {
+        if (!validatePathWithinBase(name, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
         // Get case path (check linked cases first, then CASES_DIR)
-        const casePath = await resolveCasePath(name);
+        const casePath = await resolveCasePath(name, getAuthUser(req));
         const fixPlanPath = join(casePath, '@fix_plan.md');
         if (!existsSync(fixPlanPath)) {
             return { exists: false, content: null, todos: [] };
@@ -784,10 +912,10 @@ export function registerCaseRoutes(app, ctx) {
     // ========== List Wizard Files ==========
     app.get('/api/cases/:caseName/ralph-wizard/files', async (req) => {
         const { caseName } = req.params;
-        if (!validatePathWithinBase(caseName, CASES_DIR)) {
+        if (!validatePathWithinBase(caseName, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
-        const casePath = await resolveCasePath(caseName);
+        const casePath = await resolveCasePath(caseName, getAuthUser(req));
         const wizardDir = join(casePath, 'ralph-wizard');
         if (!existsSync(wizardDir)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Ralph wizard directory not found');
@@ -818,14 +946,14 @@ export function registerCaseRoutes(app, ctx) {
     // Cache disabled to ensure fresh prompts when starting new plan generations
     app.get('/api/cases/:caseName/ralph-wizard/file/:filePath', async (req, reply) => {
         const { caseName, filePath } = req.params;
-        if (!validatePathWithinBase(caseName, CASES_DIR)) {
+        if (!validatePathWithinBase(caseName, resolveCasesDir(getAuthUser(req)))) {
             return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case name');
         }
         // Prevent browser caching - prompts change between plan generations
         reply.header('Cache-Control', 'no-store, no-cache, must-revalidate');
         reply.header('Pragma', 'no-cache');
         reply.header('Expires', '0');
-        const casePath = await resolveCasePath(caseName);
+        const casePath = await resolveCasePath(caseName, getAuthUser(req));
         const wizardDir = join(casePath, 'ralph-wizard');
         // Decode the file path (it may be URL encoded)
         const decodedPath = decodeURIComponent(filePath);