@ctrl-spc/cli 1.3.2 → 1.3.4

package/dist/commands/link.js

@@ -1,19 +1,34 @@
 import { getMachineIdentity } from '../config.js';
+import { isLocalRepositoryKey, readLocalRepositoryIdentity, writeLocalRepositoryIdentity } from '../git.js';
+import { resolveRelinkRoots } from '../relink.js';
 import { getClient } from '../supabase.js';
 import { select } from '../prompt.js';
-import { observeLocalWorkspace, registerMachineWorkspace, } from './run.js';
+import { inspectLocalCheckout, observeLocalWorkspace, registerMachineWorkspace, } from './run.js';
 export function parseLinkArgs(argv) {
     const flags = {};
     for (let i = 0; i < argv.length; i++) {
         const flag = argv[i];
-        if (flag !== '--project')
+        if (flag !== '--project' && flag !== '--folder')
             throw new Error(`Unknown argument: ${flag}`);
         const value = argv[i + 1];
         if (!value || value.startsWith('--'))
             throw new Error(`${flag} requires a value`);
-        if (flags.project)
-            throw new Error('--project may only be provided once');
-        flags.project = value;
+        if (flag === '--project') {
+            if (flags.project)
+                throw new Error('--project may only be provided once');
+            flags.project = value;
+        }
+        else {
+            const equals = value.indexOf('=');
+            if (equals < 1 || equals === value.length - 1)
+                throw new Error('--folder requires <repository-id>=<path>');
+            const repositoryId = value.slice(0, equals);
+            const folders = flags.folders ?? {};
+            if (folders[repositoryId])
+                throw new Error(`--folder may only be provided once for ${repositoryId}`);
+            folders[repositoryId] = value.slice(equals + 1);
+            flags.folders = folders;
+        }
         i++;
     }
     return flags;
@@ -25,11 +40,12 @@ function one(value) {
 export async function listTopologyProjects(client) {
     const { data, error } = await client
         .from('project_repository_scopes')
-        .select('project_id,' +
+        .select('project_id,role_slug,role_label,' +
         'project:projects!project_repository_scopes_project_id_fkey(' +
-        'id,name,org:organizations!projects_org_id_fkey(name)),' +
+        'id,name,archived_at,org:organizations!projects_org_id_fkey(name)),' +
         'scope:repository_scopes!project_repository_scopes_repository_scope_id_fkey(' +
-        'repository:repositories!repository_scopes_repository_id_fkey(remote_key))')
+        'repository:repositories!repository_scopes_repository_id_fkey(' +
+        'id,name,remote_key,identity_key,prior_identity_key,root_commit_sha,source_kind))')
         .eq('active', true);
     if (error)
         throw new Error(`Could not load project repository topology: ${error.message}`);
@@ -38,26 +54,44 @@ export async function listTopologyProjects(client) {
         const project = one(raw.project);
         const scope = one(raw.scope);
         const repository = scope ? one(scope.repository) : null;
-        if (!project || !repository)
+        if (!project || project.archived_at || !repository)
             continue;
         const existing = projects.get(project.id) ?? {
             id: project.id,
             name: project.name,
             orgName: one(project.org)?.name ?? '',
             remoteKeys: [],
+            repositories: [],
         };
         if (!existing.remoteKeys.includes(repository.remote_key))
             existing.remoteKeys.push(repository.remote_key);
+        if (!existing.repositories.some((candidate) => candidate.id === repository.id)) {
+            existing.repositories.push({
+                id: repository.id,
+                name: repository.name,
+                remoteKey: repository.remote_key,
+                sourceKind: repository.source_kind ?? (isLocalRepositoryKey(repository.remote_key) ? 'local' : 'remote'),
+                identityKey: repository.identity_key ?? repository.remote_key,
+                priorIdentityKey: repository.prior_identity_key ?? null,
+                rootCommitSha: repository.root_commit_sha ?? null,
+                ...(raw.role_slug === undefined ? {} : { roleSlug: raw.role_slug }),
+                ...(raw.role_label === undefined ? {} : { roleLabel: raw.role_label }),
+            });
+        }
         projects.set(project.id, existing);
     }
     return [...projects.values()]
-        .map((project) => ({ ...project, remoteKeys: project.remoteKeys.sort() }))
+        .map((project) => ({
+        ...project,
+        remoteKeys: project.remoteKeys.sort(),
+        repositories: project.repositories.sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id)),
+    }))
         .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
 }
 export async function loadTopologyProject(client, projectId) {
     const { data, error } = await client
         .from('projects')
-        .select('id,name,org:organizations!projects_org_id_fkey(name)')
+        .select('id,name,archived_at,org:organizations!projects_org_id_fkey(name)')
         .eq('id', projectId)
         .maybeSingle();
     if (error)
@@ -65,6 +99,9 @@ export async function loadTopologyProject(client, projectId) {
     if (!data)
         return null;
     const row = data;
+    if (row.archived_at) {
+        throw new Error(`Project "${row.name}" is archived. Restore it in the web app before linking this machine.`);
+    }
     const all = await listTopologyProjects(client);
     const topology = all.find((project) => project.id === row.id);
     return topology ?? {
@@ -72,6 +109,7 @@ export async function loadTopologyProject(client, projectId) {
         name: row.name,
         orgName: one(row.org)?.name ?? '',
         remoteKeys: [],
+        repositories: [],
     };
 }
 export async function chooseTopologyProject(client, explicitProjectId, observedRemoteKeys, options = { action: 'link' }) {
@@ -79,6 +117,9 @@ export async function chooseTopologyProject(client, explicitProjectId, observedR
         const explicit = await loadTopologyProject(client, explicitProjectId);
         if (!explicit)
             throw new Error(`No accessible project found for id "${explicitProjectId}".`);
+        if (explicit.repositories.length === 0) {
+            throw new Error(`Project "${explicit.name}" has no codebases yet. Run \`ctrl-spc init --project ${explicit.id} --repo <path>\` first.`);
+        }
         return explicit;
     }
     const observed = new Set(observedRemoteKeys);
@@ -118,7 +159,7 @@ export async function link(argv = [], deps = {}) {
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
-        console.error('Usage: ctrl-spc link [--project <project-id>]');
+        console.error('Usage: ctrl-spc link [--project <project-id>] [--folder <repository-id>=<path>]');
         process.exitCode = 1;
         return;
     }
@@ -137,13 +178,73 @@ export async function link(argv = [], deps = {}) {
             .map((checkout) => checkout.remoteKey)
             .filter((remote) => remote !== null);
         const project = await chooseTopologyProject(client, flags.project, remoteKeys);
+        const chosenPaths = new Set();
+        for (const [repositoryId, path] of Object.entries(flags.folders ?? {})) {
+            if (chosenPaths.has(path))
+                throw new Error('Choose a different folder for each missing item.');
+            chosenPaths.add(path);
+            const repository = project.repositories.find(item => item.id === repositoryId);
+            if (!repository)
+                throw new Error('That folder is not part of this project.');
+            const inspection = (deps.inspectCheckout ?? inspectLocalCheckout)(path);
+            if (inspection.status !== 'observed')
+                throw new Error('CTRL+SPC could not open that folder.');
+            const checkout = inspection.checkout;
+            if (repository.sourceKind === 'local') {
+                writeLocalRepositoryIdentity(checkout.localPath, repository.remoteKey, repository.priorIdentityKey);
+            }
+            else if (checkout.remoteKey !== repository.remoteKey) {
+                throw new Error(`That is not the ${repository.roleLabel ?? repository.name} folder.`);
+            }
+            checkout.remoteKey = repository.remoteKey;
+            const existingIndex = observation.checkouts.findIndex(item => item.localPath === checkout.localPath);
+            if (existingIndex >= 0)
+                observation.checkouts.splice(existingIndex, 1, checkout);
+            else
+                observation.checkouts.push(checkout);
+        }
+        const resolutions = resolveRelinkRoots(project.repositories.map(repository => ({
+            repositoryId: repository.id,
+            remoteKey: repository.remoteKey,
+            identityKey: repository.identityKey ?? repository.remoteKey,
+            priorIdentityKey: repository.priorIdentityKey ?? null,
+            rootCommitSha: repository.rootCommitSha ?? null,
+        })), observation.checkouts.map(checkout => ({
+            path: checkout.localPath,
+            remoteKey: checkout.remoteKey,
+            stampedIdentityKey: readLocalRepositoryIdentity(checkout.localPath),
+            rootCommitSha: checkout.rootCommitSha ?? null,
+        })));
+        for (const resolution of resolutions) {
+            if (!resolution.candidate)
+                continue;
+            const checkout = observation.checkouts.find(item => item.localPath === resolution.candidate.path);
+            const repository = project.repositories.find(item => item.id === resolution.root.repositoryId);
+            if (repository.sourceKind === 'local') {
+                writeLocalRepositoryIdentity(checkout.localPath, repository.remoteKey, repository.priorIdentityKey);
+            }
+            checkout.remoteKey = repository.remoteKey;
+        }
+        console.log(`CTRL_SPC_LINK_RESULT=${JSON.stringify({
+            folders: resolutions.map((resolution) => {
+                const repository = project.repositories.find(item => item.id === resolution.root.repositoryId);
+                return {
+                    repositoryId: repository.id,
+                    label: repository.roleLabel ?? repository.name,
+                    status: resolution.candidate ? 'ready' : 'unresolved',
+                    sourceKind: repository.sourceKind,
+                    action: resolution.candidate
+                        ? null
+                        : resolution.manualReason === 'not_found' && repository.sourceKind === 'remote'
+                            ? 'fetch'
+                            : 'choose',
+                };
+            }),
+        })}`);
         const machine = getMachineIdentity();
         const result = await registerMachineWorkspace(client, userData.user.id, project.id, machine, cwd, { observeWorkspace: () => observation });
         await upsertProjectLink(client, userData.user.id, project.id, observation.workspaceRoot);
-        console.log(`Linked "${project.name}"${project.orgName ? ` (${project.orgName})` : ''} — ` +
-            `${result.availableRepositories} available` +
-            (result.missingRepositories > 0 ? `, ${result.missingRepositories} missing` : '') +
-            `; workspace ${observation.workspaceRoot}`);
+        console.log(`${result.availableRepositories} of ${project.repositories.length} folders ready.`);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/commands/run.js

@@ -2,9 +2,9 @@ import { execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { dirname, isAbsolute, join, parse, relative, sep } from 'node:path';
 import { getClient } from '../supabase.js';
-import { currentRepoRemote, normalizeRemoteUrl } from '../git.js';
+import { currentRepoIdentity, currentRepoRemote, normalizeRemoteUrl, readRootCommitSha } from '../git.js';
 import { detectAgents, resolveAgentCommand } from '../agents.js';
 import { claudeSkillPath, codexSkillPath, installSkills } from '../skills.js';
 import { startPresence } from '../presence.js';
@@ -61,6 +61,18 @@ export async function existingBrokerStatus(machineId, port = MCP_PORT, fetcher =
         return 'not_running';
     }
 }
+export function selectPrimaryCheckout(candidates, workspaceRoot, projectRootPaths = candidates.map(candidate => candidate.localPath)) {
+    const available = candidates.filter(candidate => candidate.availability === 'available');
+    const sticky = available.find(candidate => candidate.isPrimary);
+    if (sticky)
+        return sticky;
+    const nested = (candidate) => projectRootPaths.some(path => (path !== candidate.localPath && isWithin(path, candidate.localPath)));
+    return available.sort((left, right) => (Number(left.isWorktree) - Number(right.isWorktree)
+        || Number(isWithin(workspaceRoot, right.localPath)) - Number(isWithin(workspaceRoot, left.localPath))
+        || Number(nested(left)) - Number(nested(right))
+        || String(right.verifiedAt ?? '').localeCompare(String(left.verifiedAt ?? ''))
+        || left.localPath.localeCompare(right.localPath)))[0] ?? null;
+}
 function one(value) {
     return Array.isArray(value) ? value[0] ?? null : value;
 }
@@ -82,18 +94,52 @@ function gitText(cwd, args) {
     }
 }
 /** Inspect only a path already discovered or previously registered. */
-export function inspectLocalCheckout(path) {
-    if (!existsSync(path))
-        return null;
-    const remote = currentRepoRemote(path);
+const DEFAULT_MOUNT_PREFIXES = process.platform === 'darwin'
+    ? ['/Volumes']
+    : process.platform === 'linux'
+        ? ['/mnt', '/media', '/run/media']
+        : [];
+export function inspectLocalCheckout(path, options = {}) {
+    const inspectStat = options.stat ?? statSync;
+    try {
+        inspectStat(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'EACCES' || code === 'EPERM' || code === 'EIO' || code === 'ENOTDIR') {
+            return { status: 'unreachable', reason: 'permission' };
+        }
+        if (code !== 'ENOENT')
+            return { status: 'unreachable', reason: 'permission' };
+        let ancestor = dirname(path);
+        while (ancestor !== parse(ancestor).root) {
+            try {
+                inspectStat(ancestor);
+                break;
+            }
+            catch (ancestorError) {
+                const ancestorCode = ancestorError.code;
+                if (ancestorCode !== 'ENOENT')
+                    return { status: 'unreachable', reason: 'permission' };
+                ancestor = dirname(ancestor);
+            }
+        }
+        const parentExists = ancestor === dirname(path);
+        const underMount = (options.mountPrefixes ?? DEFAULT_MOUNT_PREFIXES).some(prefix => isWithin(prefix, path));
+        return parentExists || (!underMount && ancestor !== parse(path).root)
+            ? { status: 'missing' }
+            : { status: 'unreachable', reason: 'drive_missing' };
+    }
+    const identity = currentRepoIdentity(path);
     const gitDir = gitText(path, ['rev-parse', '--path-format=absolute', '--git-dir']);
     const commonDir = gitText(path, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
-    return {
-        localPath: path,
-        remoteKey: remote ? normalizeRemoteUrl(remote) : null,
-        headSha: gitText(path, ['rev-parse', 'HEAD']),
-        isWorktree: Boolean(gitDir && commonDir && gitDir !== commonDir),
-    };
+    return { status: 'observed', checkout: {
+            localPath: path,
+            remoteKey: identity,
+            headSha: gitText(path, ['rev-parse', 'HEAD']),
+            isWorktree: Boolean(gitDir && commonDir && gitDir !== commonDir),
+            rootCommitSha: readRootCommitSha(path),
+        } };
 }
 /**
  * Discovers checkouts from real Git roots only. Alternate linked worktrees are
@@ -112,8 +158,8 @@ export function observeLocalWorkspace(cwd) {
         workspaceRoot: topology.scanRoot,
         checkouts: [...paths]
             .sort((left, right) => left.localeCompare(right))
-            .map(inspectLocalCheckout)
-            .filter((checkout) => checkout !== null),
+            .map(path => inspectLocalCheckout(path))
+            .flatMap(result => result.status === 'observed' ? [result.checkout] : []),
     };
 }
 export async function registerMachineIdentity(client, userId, machine, now = new Date().toISOString()) {
@@ -129,7 +175,7 @@ export async function registerMachineIdentity(client, userId, machine, now = new
 export async function loadMachineProjects(client, userId, machineId) {
     const { data, error } = await client
         .from('machine_workspaces')
-        .select('project_id,project:projects!machine_workspaces_project_id_fkey(id,name)')
+        .select('project_id,project:projects!machine_workspaces_project_id_fkey(id,name,archived_at)')
         .eq('user_id', userId)
         .eq('machine_id', machineId);
     if (error)
@@ -137,11 +183,46 @@ export async function loadMachineProjects(client, userId, machineId) {
     const projects = new Map();
     for (const row of (data ?? [])) {
         const project = one(row.project);
-        if (project)
-            projects.set(project.id, project);
+        if (project && !project.archived_at)
+            projects.set(project.id, { id: project.id, name: project.name });
     }
     return [...projects.values()].sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
 }
+/** Only projects whose required repositories are currently usable should be
+ * advertised as available to remote agents. Connection state is separate. */
+export async function loadRunnableMachineProjects(client, userId, machineId) {
+    const projects = await loadMachineProjects(client, userId, machineId);
+    const { data, error } = await client.rpc('get_my_project_machine_availability');
+    if (error)
+        throw new Error(`Could not load project readiness: ${error.message}`);
+    const runnable = new Set((data ?? []).filter((row) => (row.machine_id === machineId && (row.readiness === 'ready' || row.readiness === 'partial'))).map((row) => row.project_id));
+    return projects.filter((project) => runnable.has(project.id));
+}
+/** Re-checks every folder registered on this machine. A missing workspace is
+ * represented by an empty observation so its prior checkouts become missing. */
+export async function reconcileMachineWorkspaces(client, userId, machine) {
+    const { data, error } = await client
+        .from('machine_workspaces')
+        .select('project_id,workspace_root,project:projects!machine_workspaces_project_id_fkey(archived_at)')
+        .eq('user_id', userId)
+        .eq('machine_id', machine.id);
+    if (error)
+        throw new Error(`Could not load machine workspaces for refresh: ${error.message}`);
+    for (const workspace of (data ?? [])) {
+        if (one(workspace.project)?.archived_at)
+            continue;
+        let observation;
+        try {
+            observation = observeLocalWorkspace(workspace.workspace_root);
+        }
+        catch {
+            observation = { workspaceRoot: workspace.workspace_root, checkouts: [] };
+        }
+        await registerMachineWorkspace(client, userId, workspace.project_id, machine, workspace.workspace_root, {
+            observeWorkspace: () => observation,
+        });
+    }
+}
 /** Legacy fallback only: multiple projects sharing one remote are deliberately
  * returned as multiple candidates, never collapsed to an arbitrary project. */
 export async function legacyCurrentProjectCandidates(client, cwd) {
@@ -150,11 +231,14 @@ export async function legacyCurrentProjectCandidates(client, cwd) {
         return [];
     const { data, error } = await client
         .from('projects')
-        .select('id,name')
+        .select('id,name,archived_at')
         .eq('git_remote_url', normalizeRemoteUrl(remote));
     if (error)
         throw new Error(`Could not resolve the current repository: ${error.message}`);
-    return (data ?? []).sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+    return (data ?? [])
+        .filter((project) => !project.archived_at)
+        .map(({ id, name }) => ({ id, name }))
+        .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
 }
 async function loadActiveProjectRemoteKeys(client, projectId) {
     const { data, error } = await client
@@ -183,7 +267,7 @@ async function loadActiveProjectRemoteKeys(client, projectId) {
 export async function recoverLegacyProjectLinks(client, userId, machine, initializedProjectIds, deps = {}) {
     const { data, error } = await client
         .from('project_links')
-        .select('project_id,local_path')
+        .select('project_id,local_path,project:projects!project_links_project_id_fkey(archived_at)')
         .eq('user_id', userId);
     if (error)
         throw new Error(`Could not load legacy project links: ${error.message}`);
@@ -194,6 +278,8 @@ export async function recoverLegacyProjectLinks(client, userId, machine, initial
     const links = [...(data ?? [])]
         .sort((left, right) => left.project_id.localeCompare(right.project_id) || left.local_path.localeCompare(right.local_path));
     for (const link of links) {
+        if (one(link.project ?? null)?.archived_at)
+            continue;
         if (initializedProjectIds.has(link.project_id))
             continue;
         let observation;
@@ -220,18 +306,28 @@ export async function recoverLegacyProjectLinks(client, userId, machine, initial
 function checkoutPlan(workspaceId, repositories, observation, existing, inspectCheckout, verifiedAt) {
     const rows = new Map();
     const availableRepositoryIds = new Set();
-    const record = (repositoryId, checkout, fallback) => {
+    const record = (repositoryId, inspection, fallback) => {
+        const checkout = inspection.status === 'observed' ? inspection.checkout : null;
         const localPath = checkout?.localPath ?? fallback?.local_path;
         if (!localPath)
             return; // A missing repository without a known path is not fabricated.
-        const expectedRemote = [...repositories.entries()].find(([, id]) => id === repositoryId)?.[0];
+        const repository = [...repositories.entries()].find(([, value]) => value.id === repositoryId);
+        const expectedRemote = repository?.[0];
         if (!expectedRemote)
             return;
-        const availability = checkout === null
+        const forked = checkout?.remoteKey === expectedRemote
+            && repository?.[1].rootCommitSha
+            && checkout.rootCommitSha
+            && repository[1].rootCommitSha !== checkout.rootCommitSha;
+        const availability = inspection.status === 'missing'
             ? 'missing'
-            : checkout.remoteKey === expectedRemote
-                ? 'available'
-                : 'mismatched';
+            : inspection.status === 'unreachable'
+                ? 'unreachable'
+                : forked
+                    ? 'mismatched'
+                    : checkout.remoteKey === expectedRemote
+                        ? 'available'
+                        : 'mismatched';
         if (availability === 'available')
             availableRepositoryIds.add(repositoryId);
         rows.set(`${repositoryId}\u0000${localPath}`, {
@@ -239,8 +335,16 @@ function checkoutPlan(workspaceId, repositories, observation, existing, inspectC
             repository_id: repositoryId,
             local_path: localPath,
             availability,
+            unavailable_reason: inspection.status === 'missing'
+                ? 'not_found'
+                : inspection.status === 'unreachable'
+                    ? inspection.reason
+                    : forked
+                        ? 'confirm_lineage'
+                        : null,
             verified_remote_key: checkout?.remoteKey ?? fallback?.verified_remote_key ?? null,
             head_sha: checkout?.headSha ?? fallback?.head_sha ?? null,
+            observed_root_commit_sha: checkout?.rootCommitSha ?? null,
             is_worktree: checkout?.isWorktree ?? fallback?.is_worktree ?? false,
             verified_at: verifiedAt,
         });
@@ -248,20 +352,25 @@ function checkoutPlan(workspaceId, repositories, observation, existing, inspectC
     for (const checkout of observation.checkouts) {
         if (!checkout.remoteKey)
             continue;
-        const repositoryId = repositories.get(checkout.remoteKey);
-        if (repositoryId)
-            record(repositoryId, checkout, null);
+        const repository = repositories.get(checkout.remoteKey);
+        if (repository)
+            record(repository.id, { status: 'observed', checkout }, null);
     }
     // A previous mapping is deterministic evidence for a now-missing checkout.
     // Re-inspect it instead of assuming that an absent discovery result means
     // the directory disappeared; it may simply sit outside today's scan root.
     for (const prior of existing) {
-        if (![...repositories.values()].includes(prior.repository_id))
+        if (![...repositories.values()].some(repository => repository.id === prior.repository_id))
             continue;
         const key = `${prior.repository_id}\u0000${prior.local_path}`;
         if (rows.has(key))
             continue;
-        record(prior.repository_id, inspectCheckout(prior.local_path), prior);
+        const inspected = inspectCheckout(prior.local_path);
+        record(prior.repository_id, inspected === null
+            ? { status: 'missing' }
+            : 'status' in inspected
+                ? inspected
+                : { status: 'observed', checkout: inspected }, prior);
     }
     return { rows: [...rows.values()], availableRepositoryIds };
 }
@@ -276,7 +385,7 @@ export async function registerMachineWorkspace(client, userId, projectId, machin
     const { data: scopeData, error: scopeError } = await client
         .from('project_repository_scopes')
         .select('required,scope:repository_scopes!project_repository_scopes_repository_scope_id_fkey(' +
-        'repository_id,repository:repositories!repository_scopes_repository_id_fkey(id,remote_key))')
+        'repository_id,repository:repositories!repository_scopes_repository_id_fkey(id,remote_key,root_commit_sha))')
         .eq('project_id', projectId)
         .eq('active', true);
     if (scopeError)
@@ -287,7 +396,7 @@ export async function registerMachineWorkspace(client, userId, projectId, machin
         const scope = one(row.scope);
         const repository = scope ? one(scope.repository) : null;
         if (repository) {
-            repositories.set(repository.remote_key, repository.id);
+            repositories.set(repository.remote_key, { id: repository.id, rootCommitSha: repository.root_commit_sha ?? null });
             if (row.required)
                 requiredRepositoryIds.add(repository.id);
         }
@@ -342,6 +451,41 @@ export async function registerMachineWorkspace(client, userId, projectId, machin
         if (error)
             throw new Error(`Could not register repository checkout ${row.local_path}: ${error.message}`);
     }
+    if (typeof client.rpc === 'function') {
+        const { data: reconciledData, error: reconciledError } = await client
+            .from('repository_checkouts')
+            .select('id,repository_id,local_path,availability,is_worktree,is_primary,verified_at')
+            .eq('machine_workspace_id', workspaceId);
+        if (reconciledError)
+            throw new Error(`Could not reconcile folder copies: ${reconciledError.message}`);
+        const reconciled = (reconciledData ?? []);
+        for (const repositoryId of new Set(reconciled.map(row => row.repository_id))) {
+            const rows = reconciled.filter(row => row.repository_id === repositoryId);
+            const primary = selectPrimaryCheckout(rows.map(row => ({
+                id: row.id,
+                localPath: row.local_path,
+                availability: row.availability,
+                isWorktree: row.is_worktree,
+                isPrimary: row.is_primary,
+                verifiedAt: row.verified_at,
+            })), workspaceRoot, reconciled
+                .filter(row => row.availability === 'available')
+                .map(row => row.local_path));
+            if (primary && !rows.find(row => row.id === primary.id)?.is_primary) {
+                const { error } = await client.rpc('set_primary_checkout', { p_checkout_id: primary.id });
+                if (error)
+                    throw new Error(`Could not choose the primary folder copy: ${error.message}`);
+            }
+            if (primary) {
+                const missingIds = rows.filter(row => row.availability === 'missing').map(row => row.id);
+                if (missingIds.length > 0) {
+                    const { error } = await client.from('repository_checkouts').delete().in('id', missingIds);
+                    if (error)
+                        throw new Error(`Could not remove stale folder copies: ${error.message}`);
+                }
+            }
+        }
+    }
     // Preserve a combine/separate relink marker until the entire reconciliation
     // succeeds and every repository used by a required scope is available.
     // Optional-only repositories are still inspected above, but do not make a
@@ -553,7 +697,9 @@ export function createProjectPresenceReconciler(client, userId, profileName, mac
     const intervalMs = deps.intervalMs ?? 30_000;
     let timer;
     let chain = Promise.resolve();
-    const runReconcile = async () => {
+    const runReconcile = async (refreshWorkspaces) => {
+        if (refreshWorkspaces)
+            await deps.refreshWorkspaces?.();
         const projects = await loadProjects(client, userId, machine.id);
         const currentIds = new Set(projects.map((project) => project.id));
         for (const project of projects) {
@@ -577,10 +723,10 @@ export function createProjectPresenceReconciler(client, userId, profileName, mac
         }
     };
     return {
-        reconcile() {
+        reconcile(options = {}) {
             // Recover the queue after a transient failed poll; the caller still
             // receives this run's rejection, but later intervals keep reconciling.
-            chain = chain.catch(() => { }).then(runReconcile);
+            chain = chain.catch(() => { }).then(() => runReconcile(options.refreshWorkspaces !== false));
             return chain;
         },
         start() {
@@ -692,8 +838,11 @@ export async function run() {
     }
     // Project channels reconcile independently from the one MCP listener, so
     // `ctrl-spc init` can add a project without restarting this broker.
-    const presence = createProjectPresenceReconciler(client, userId, profileName, machine, registeredAgents);
-    await presence.reconcile();
+    const presence = createProjectPresenceReconciler(client, userId, profileName, machine, registeredAgents, {
+        loadProjects: loadRunnableMachineProjects,
+        refreshWorkspaces: () => reconcileMachineWorkspaces(client, userId, machine),
+    });
+    await presence.reconcile({ refreshWorkspaces: false });
     presence.start();
     let mcpServer;
     try {
@@ -703,6 +852,10 @@ export async function run() {
             machineId: machine.id,
             presence,
             port: MCP_PORT,
+            runtime: {
+                kind: process.env.CTRL_SPC_RUNTIME_KIND || 'unlabeled',
+                label: process.env.CTRL_SPC_RUNTIME_LABEL || 'Unlabeled connection',
+            },
         });
     }
     catch (err) {
@@ -714,6 +867,7 @@ export async function run() {
     }
     console.log(`MCP: ${url} (tools: list_tasks, get_task, begin_work, heartbeat_work, reserve_work_paths, ` +
         'release_work_paths, transfer_coordination, acknowledge_unavailable_checkout, record_context_exploration, ' +
+        'set_task_role_slugs, ' +
         'ask_question, record_user_input, submit_workflow_stage, decide_workflow_review, ' +
         'end_work, create_task, update_task, create_artifact, add_comment)');
     console.log(`Projects: ${projects.length > 0 ? projects.map((project) => project.name).join(', ') : 'none initialized on this machine'}`);