amalgm 0.1.175 → 0.1.176

package/runtime/scripts/amalgm-mcp/workspace/reducer.js

@@ -0,0 +1,582 @@
+'use strict';
+
+/**
+ * One reducer per repository, one materializer per checkout.
+ *
+ * The reducer reads the single rail-ordered wall and derives exactly:
+ *   - one winning card (highest official card version), and
+ *   - one checkpoint tree (checkpoint transitions folded in official order).
+ *
+ * The materializer has no peer branches. It obtains the winning commit,
+ * moves to that exact card when safe, advances the one held checkpoint tree
+ * to the newly reduced tree, and verifies on the next pass.
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { AMALGM_DIR } = require('../config');
+const { appendStateEvent, subscribeStateEvents } = require('../state/events');
+const { listRepoCards, refreshRepoCard, refreshRepoCards } = require('./cards');
+const {
+  captureCheckpoint,
+  hasCommit,
+  headAndDirty,
+  isAncestor,
+  localBranches,
+  mergeBase,
+  operationState,
+} = require('./git');
+const {
+  readCheckpointValue,
+  repoKeyOfCard,
+  revisionOf,
+} = require('./checkpoint');
+const merge = require('./merge');
+const transition = require('./transition');
+
+const STATE_DIR = path.join(AMALGM_DIR, 'state', 'repo-reducer');
+const REDUCE_QUIET_MS = 25;
+const REDUCE_INTERVAL_MS = 30_000;
+
+const service = {
+  started: false,
+  timer: null,
+  interval: null,
+  unsubscribe: null,
+  counters: { passes: 0, materialized: 0, waiting: 0, failures: 0 },
+  repos: new Map(),
+  lastPass: null,
+};
+
+function stateFile(repoKey) {
+  const digest = crypto.createHash('sha256').update(repoKey).digest('hex').slice(0, 24);
+  return path.join(STATE_DIR, `${digest}.json`);
+}
+
+function readRepoState(repoKey) {
+  try {
+    const state = JSON.parse(fs.readFileSync(stateFile(repoKey), 'utf8'));
+    return state?.repoKey === repoKey ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeRepoState(repoKey, state) {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+  const next = { repoKey, ...state, updatedAt: new Date().toISOString() };
+  fs.writeFileSync(stateFile(repoKey), `${JSON.stringify(next, null, 2)}\n`);
+  return next;
+}
+
+function validVersion(value) {
+  return Number.isInteger(value) && value > 0;
+}
+
+/**
+ * Pure wall reduction. Machine identity never chooses a winner; it only
+ * identifies the latest checkpoint transition each writer currently owns.
+ */
+function reduceWall(entries) {
+  const repos = new Map();
+  for (const wallEntry of entries) {
+    for (const card of wallEntry.cards || []) {
+      const repoKey = repoKeyOfCard(card);
+      if (
+        !repoKey
+        || card.kind !== 'primary'
+        || (card.health && card.health !== 'healthy')
+        || !validVersion(card.positionVersion)
+      ) continue;
+      let repo = repos.get(repoKey);
+      if (!repo) {
+        repo = { repoKey, card: null, transitions: [], parked: [], branchMap: new Map() };
+        repos.set(repoKey, repo);
+      }
+      if (!repo.card || card.positionVersion > repo.card.positionVersion) {
+        repo.card = { ...card, writer: wallEntry.machine };
+      }
+      for (const ref of card.branches || []) {
+        if (!ref?.name || !validVersion(ref.version)) continue;
+        const held = repo.branchMap.get(ref.name);
+        if (!held || ref.version > held.version) repo.branchMap.set(ref.name, ref);
+      }
+      if (
+        card.checkpoint
+        && validVersion(card.checkpointVersion)
+        && card.checkpoint.machine === wallEntry.machine
+      ) {
+        repo.transitions.push({
+          ...card.checkpoint,
+          version: card.checkpointVersion,
+          mutationId: card.checkpointMutationId,
+        });
+        repo.parked.push(...(card.checkpoint.parked || []));
+      }
+    }
+  }
+  for (const repo of repos.values()) {
+    repo.transitions = repo.transitions
+      .filter((entry) => (
+        entry.baseOid === repo.card.head?.oid
+        && entry.branch === repo.card.head?.branch
+      ))
+      .sort((left, right) => left.version - right.version);
+    if (repo.card.head?.branch) {
+      const held = repo.branchMap.get(repo.card.head.branch);
+      if (!held || repo.card.positionVersion > held.version) {
+        repo.branchMap.set(repo.card.head.branch, {
+          name: repo.card.head.branch,
+          oid: repo.card.head.oid,
+          objects: repo.card.objects,
+          mutationId: repo.card.positionMutationId,
+          version: repo.card.positionVersion,
+        });
+      }
+    }
+    repo.branches = [...repo.branchMap.values()].sort((left, right) => left.name.localeCompare(right.name));
+    delete repo.branchMap;
+  }
+  return repos;
+}
+
+function uniqueParked(entries) {
+  const byOid = new Map();
+  for (const entry of entries || []) {
+    if (typeof entry?.oid === 'string' && /^[0-9a-f]{40,64}$/.test(entry.oid)) {
+      byOid.set(entry.oid, entry);
+    }
+  }
+  return [...byOid.values()].sort((left, right) => left.oid.localeCompare(right.oid));
+}
+
+async function obtainCardObjects(localCard, targetCard) {
+  const oid = targetCard.head?.oid;
+  if (!oid || await hasCommit(localCard.path, oid)) return { state: 'ready' };
+  if (targetCard.objects?.kind === 'bundle') {
+    const imported = await require('./objects').importFromLocator(localCard.path, targetCard.objects);
+    if (imported.state !== 'imported') return { state: `objects-${imported.state}` };
+  } else if (targetCard.objects?.kind === 'pending') {
+    return { state: 'objects-uploading' };
+  } else {
+    const approved = localCard.repo?.remote
+      && localCard.repo.remote === targetCard.repo?.remote
+      && targetCard.head?.branch;
+    if (!approved) return { state: 'missing-objects-no-approved-source' };
+    await transition.fetchBranch(localCard.path, 'origin', targetCard.head.branch);
+  }
+  return await hasCommit(localCard.path, oid)
+    ? { state: 'ready' }
+    : { state: 'missing-objects-after-fetch' };
+}
+
+async function moveToWinningCard(localCard, targetCard) {
+  const current = await headAndDirty(localCard.path);
+  const operation = await operationState(localCard.path);
+  if (operation !== 'none') return { state: 'waiting', reason: 'local-operation-in-flight' };
+  if (
+    current.head.oid === targetCard.head?.oid
+    && current.head.branch === targetCard.head?.branch
+  ) return { state: 'ready', moved: false };
+
+  const objects = await obtainCardObjects(localCard, targetCard);
+  if (objects.state !== 'ready') return { state: 'waiting', reason: objects.state };
+
+  const forward = current.head.oid
+    && targetCard.head?.oid
+    && await isAncestor(localCard.path, current.head.oid, targetCard.head.oid);
+  if (!current.head.oid || !targetCard.head?.oid) {
+    return { state: 'waiting', reason: 'unborn-card-movement' };
+  }
+  const commonOid = forward
+    ? current.head.oid
+    : await mergeBase(localCard.path, current.head.oid, targetCard.head.oid);
+  if (!commonOid) return { state: 'waiting', reason: 'unrelated-card-histories' };
+
+  const captured = await captureCheckpoint(localCard.path);
+  if (captured.indexDiff === null || captured.baseOid !== current.head.oid) {
+    return { state: 'waiting', reason: 'local-state-moving' };
+  }
+  const repoKey = repoKeyOfCard(localCard);
+  const parked = [];
+  if (!forward && current.head.oid !== targetCard.head.oid) {
+    const parkedRef = await transition.parkCommit(localCard.path, current.head.oid);
+    parked.push({
+      oid: current.head.oid,
+      ref: parkedRef,
+      sourceBranch: current.head.branch,
+      objects: await require('./objects').bundleSourceFor(
+        localCard.path,
+        repoKey,
+        current.head.oid,
+      ),
+    });
+  }
+
+  const commonTree = await merge.treeOf(localCard.path, commonOid);
+  const winningTree = await merge.treeOf(localCard.path, targetCard.head.oid);
+  const oldTree = await merge.treeOf(localCard.path, current.head.oid);
+  const committed = forward || current.head.oid === targetCard.head.oid
+    ? { tree: winningTree, conflicts: [] }
+    : await merge.reduceTree(
+      localCard.path,
+      winningTree,
+      commonTree,
+      oldTree,
+      { label: `parked-${current.head.oid.slice(0, 12)}` },
+    );
+  const oldIndexTree = await merge.treeOfPatch(localCard.path, current.head.oid, captured.indexDiff);
+  const staged = await merge.reduceTree(
+    localCard.path,
+    committed.tree,
+    oldTree,
+    oldIndexTree,
+    { label: `staged-${current.head.oid.slice(0, 12)}` },
+  );
+  const oldWorktree = await merge.treeOfPatch(localCard.path, oldIndexTree, captured.worktreeDiff);
+  const working = await merge.reduceTree(
+    localCard.path,
+    staged.tree,
+    oldIndexTree,
+    oldWorktree,
+    { label: `working-${current.head.oid.slice(0, 12)}` },
+  );
+  const conflicts = [
+    ...committed.conflicts,
+    ...staged.conflicts,
+    ...working.conflicts,
+  ];
+
+  const rollbackDir = path.join(STATE_DIR, 'card-moves');
+  fs.mkdirSync(rollbackDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(rollbackDir, `${current.head.oid}-to-${targetCard.head.oid}.json`),
+    `${JSON.stringify({
+      baseOid: current.head.oid,
+      indexDiff: captured.indexDiff,
+      worktreeDiff: captured.worktreeDiff,
+    })}\n`,
+  );
+  await transition.forceMoveToCard(localCard.path, {
+    expectedBranch: current.head.branch,
+    expectedOid: current.head.oid,
+    targetBranch: targetCard.head.branch,
+    targetOid: targetCard.head.oid,
+  });
+  const applied = await merge.advance(localCard.path, winningTree, working.tree, {
+    label: `card-${targetCard.positionVersion}`,
+  });
+  await transition.setIndexTree(localCard.path, staged.tree);
+  return {
+    state: 'ready',
+    moved: true,
+    parked,
+    conflicts: [...conflicts, ...applied.conflicts],
+  };
+}
+
+async function materializeParked(localCard, entries) {
+  const waiting = [];
+  for (const entry of uniqueParked(entries)) {
+    if (!(await hasCommit(localCard.path, entry.oid))) {
+      if (entry.objects?.kind === 'bundle') {
+        const imported = await require('./objects').importFromLocator(localCard.path, entry.objects);
+        if (imported.state !== 'imported') {
+          waiting.push({ ...entry, state: imported.state });
+          continue;
+        }
+      } else {
+        waiting.push({ ...entry, state: entry.objects?.kind || 'objects-missing' });
+        continue;
+      }
+    }
+    await transition.parkCommit(localCard.path, entry.oid);
+  }
+  return waiting;
+}
+
+async function materializeBranches(localCard, plan) {
+  const current = new Map((await localBranches(localCard.path)).map((ref) => [ref.name, ref.oid]));
+  const waiting = [];
+  let moved = false;
+  for (const ref of plan.branches || []) {
+    if (ref.name === plan.card.head?.branch) {
+      if (ref.oid !== plan.card.head.oid) {
+        waiting.push({ name: ref.name, state: 'checked-out-ref-disagrees-with-card' });
+      }
+      continue;
+    }
+    if (ref.oid === null) {
+      if (current.has(ref.name)) {
+        await transition.deleteBranchRef(localCard.path, ref.name);
+        moved = true;
+      }
+      continue;
+    }
+    if (!(await hasCommit(localCard.path, ref.oid))) {
+      if (ref.objects?.kind === 'bundle') {
+        const imported = await require('./objects').importFromLocator(localCard.path, ref.objects);
+        if (imported.state !== 'imported') {
+          waiting.push({ name: ref.name, state: imported.state });
+          continue;
+        }
+      } else if (ref.objects?.kind === 'remote' && localCard.repo?.remote) {
+        await transition.fetchBranch(localCard.path, 'origin', ref.name);
+      } else {
+        waiting.push({ name: ref.name, state: ref.objects?.kind || 'objects-missing' });
+        continue;
+      }
+    }
+    if (!(await hasCommit(localCard.path, ref.oid))) {
+      waiting.push({ name: ref.name, state: 'objects-missing-after-import' });
+      continue;
+    }
+    if (current.get(ref.name) !== ref.oid) {
+      await transition.setBranchRef(localCard.path, ref.name, ref.oid);
+      moved = true;
+    }
+  }
+  return { moved, waiting };
+}
+
+async function reduceCheckpoint(localCard, plan) {
+  const baseOid = plan.card.head.oid;
+  const baseTree = await merge.treeOf(localCard.path, baseOid);
+  let indexTree = baseTree;
+  let worktreeTree = baseTree;
+  const conflicts = [];
+
+  for (const operation of plan.transitions) {
+    const from = readCheckpointValue(baseOid, operation.from);
+    const to = readCheckpointValue(baseOid, operation.to);
+    if (from.state !== 'ready' || to.state !== 'ready') {
+      return { state: 'waiting', reason: `checkpoint-${from.state !== 'ready' ? from.state : to.state}` };
+    }
+    const fromIndexTree = await merge.treeOfPatch(localCard.path, baseOid, from.indexDiff);
+    const toIndexTree = await merge.treeOfPatch(localCard.path, baseOid, to.indexDiff);
+    const reducedIndex = await merge.reduceTree(localCard.path, indexTree, fromIndexTree, toIndexTree, {
+      label: String(operation.version),
+    });
+    indexTree = reducedIndex.tree;
+    conflicts.push(...reducedIndex.conflicts.map((item) => ({ ...item, layer: 'index' })));
+
+    const fromWorktreeTree = await merge.treeOfPatch(localCard.path, fromIndexTree, from.worktreeDiff);
+    const toWorktreeTree = await merge.treeOfPatch(localCard.path, toIndexTree, to.worktreeDiff);
+    const reducedWorktree = await merge.reduceTree(
+      localCard.path,
+      worktreeTree,
+      fromWorktreeTree,
+      toWorktreeTree,
+      { label: String(operation.version) },
+    );
+    worktreeTree = reducedWorktree.tree;
+    conflicts.push(...reducedWorktree.conflicts.map((item) => ({ ...item, layer: 'worktree' })));
+  }
+
+  const indexDiff = await merge.diffOfTree(localCard.path, baseOid, indexTree);
+  const worktreeDiff = await merge.diffOfTree(localCard.path, indexTree, worktreeTree);
+  return {
+    state: 'ready',
+    indexTree,
+    worktreeTree,
+    indexDiff,
+    worktreeDiff,
+    checkpointRevision: revisionOf(baseOid, indexDiff, worktreeDiff),
+    conflicts,
+  };
+}
+
+async function materializeRepo(localCardInput, plan) {
+  const refreshed = await refreshRepoCard(localCardInput.replica) || localCardInput;
+  const cardResult = await moveToWinningCard(refreshed, plan.card);
+  if (cardResult.state !== 'ready') return cardResult;
+
+  const localCard = cardResult.moved
+    ? await refreshRepoCard(refreshed.replica) || refreshed
+    : refreshed;
+  const previous = readRepoState(plan.repoKey);
+  const parked = uniqueParked([
+    ...(previous?.parked || []),
+    ...(plan.parked || []),
+    ...(cardResult.parked || []),
+  ]);
+  const parkedWaiting = await materializeParked(localCard, parked);
+  const branchResult = await materializeBranches(localCard, plan);
+  const reduced = await reduceCheckpoint(localCard, plan);
+  if (reduced.state !== 'ready') return reduced;
+
+  const baseTree = await merge.treeOf(localCard.path, plan.card.head.oid);
+  const heldWorktree = previous?.baseOid === plan.card.head.oid
+    && previous.heldTree
+    && await merge.hasTree(localCard.path, previous.heldTree)
+    ? previous.heldTree
+    : baseTree;
+  const heldIndex = previous?.baseOid === plan.card.head.oid
+    && previous.heldIndexTree
+    && await merge.hasTree(localCard.path, previous.heldIndexTree)
+    ? previous.heldIndexTree
+    : baseTree;
+  const currentIndex = await merge.indexTree(localCard.path);
+  const reducedLocalIndex = await merge.reduceTree(
+    localCard.path,
+    currentIndex,
+    heldIndex,
+    reduced.indexTree,
+    { label: `index-${reduced.checkpointRevision || 'clean'}` },
+  );
+  const applied = await merge.advance(localCard.path, heldWorktree, reduced.worktreeTree, {
+    label: `checkpoint-${reduced.checkpointRevision || 'clean'}`,
+  });
+  await transition.setIndexTree(localCard.path, reducedLocalIndex.tree);
+  const state = writeRepoState(plan.repoKey, {
+    path: localCard.path,
+    replica: localCard.replica,
+    branch: plan.card.head.branch,
+    baseOid: plan.card.head.oid,
+    cardVersion: plan.card.positionVersion,
+    cardMutationId: plan.card.positionMutationId,
+    checkpointRevision: reduced.checkpointRevision,
+    indexDiff: reduced.indexDiff,
+    worktreeDiff: reduced.worktreeDiff,
+    checkpointVersions: plan.transitions.map((entry) => entry.version),
+    branches: plan.branches || [],
+    heldTree: applied.heldTree,
+    heldIndexTree: reduced.indexTree,
+    parked,
+    parkedWaiting: [...parkedWaiting, ...branchResult.waiting],
+    conflicts: [
+      ...(cardResult.conflicts || []),
+      ...reduced.conflicts,
+      ...reducedLocalIndex.conflicts.map((item) => ({ ...item, layer: 'index-materialize' })),
+      ...applied.conflicts,
+    ],
+    materialized: applied.heldTree === reduced.worktreeTree
+      && reducedLocalIndex.tree === reduced.indexTree,
+  });
+  appendStateEvent({
+    resource: 'workspace-reducer',
+    op: previous ? 'update' : 'insert',
+    id: localCard.replica,
+    value: state,
+    source: 'workspace-reducer',
+  });
+  return {
+    state: state.conflicts.length ? 'conflict' : 'in-sync',
+    reason: state.conflicts.length ? state.conflicts.map((item) => `${item.kind}:${item.path}`).join(', ') : null,
+    moved: cardResult.moved || branchResult.moved || applied.applied.length > 0,
+  };
+}
+
+async function runReducer() {
+  service.counters.passes += 1;
+  const startedAt = Date.now();
+  const plans = reduceWall(require('./wall').readWall());
+  const locals = new Map();
+  for (const card of listRepoCards()) {
+    if (card.kind !== 'primary' || card.health !== 'healthy') continue;
+    const repoKey = repoKeyOfCard(card);
+    if (repoKey && !locals.has(repoKey)) locals.set(repoKey, card);
+  }
+
+  let moved = false;
+  for (const [repoKey, plan] of plans) {
+    const local = locals.get(repoKey);
+    if (!local || !plan.card) continue;
+    try {
+      const outcome = await materializeRepo(local, plan);
+      service.repos.set(repoKey, { repoKey, path: local.path, ...outcome, at: new Date().toISOString() });
+      if (outcome.state === 'waiting') service.counters.waiting += 1;
+      if (outcome.moved) {
+        moved = true;
+        service.counters.materialized += 1;
+      }
+    } catch (error) {
+      service.counters.failures += 1;
+      service.repos.set(repoKey, {
+        repoKey,
+        path: local.path,
+        state: 'error',
+        reason: error.message,
+        at: new Date().toISOString(),
+      });
+      console.warn(`[WorkspaceReducer] ${local.path}:`, error.message);
+    }
+  }
+  service.lastPass = { at: new Date().toISOString(), durationMs: Date.now() - startedAt, moved };
+  if (moved) refreshRepoCards().catch(() => {});
+}
+
+let running = null;
+let queued = false;
+
+function reduceNow() {
+  if (running) {
+    queued = true;
+    return running;
+  }
+  running = (async () => {
+    do {
+      queued = false;
+      await runReducer();
+    } while (queued);
+  })().finally(() => {
+    running = null;
+  });
+  return running;
+}
+
+function scheduleReduce() {
+  if (!service.started || service.timer) return;
+  service.timer = setTimeout(() => {
+    service.timer = null;
+    reduceNow().catch((error) => console.warn('[WorkspaceReducer] pass failed:', error.message));
+  }, REDUCE_QUIET_MS);
+  service.timer.unref?.();
+}
+
+function startWorkspaceReducer() {
+  if (service.started) return;
+  service.started = true;
+  service.unsubscribe = subscribeStateEvents((event) => {
+    const wallPaths = require('./wall').wallStats().paths;
+    if (
+      event.resource === 'repo-cards'
+      || event.resource === 'repo-checkpoints'
+      || wallPaths.includes(event.id)
+    ) scheduleReduce();
+  });
+  service.interval = setInterval(scheduleReduce, REDUCE_INTERVAL_MS);
+  service.interval.unref?.();
+  scheduleReduce();
+}
+
+function stopWorkspaceReducer() {
+  if (!service.started) return;
+  service.started = false;
+  service.unsubscribe?.();
+  service.unsubscribe = null;
+  if (service.timer) clearTimeout(service.timer);
+  if (service.interval) clearInterval(service.interval);
+  service.timer = null;
+  service.interval = null;
+}
+
+function reducerStats() {
+  return {
+    started: service.started,
+    ...service.counters,
+    lastPass: service.lastPass,
+    repos: [...service.repos.values()],
+  };
+}
+
+module.exports = {
+  materializeRepo,
+  readRepoState,
+  reduceNow,
+  reduceWall,
+  reducerStats,
+  startWorkspaceReducer,
+  stopWorkspaceReducer,
+};

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -681,13 +681,26 @@ function handleWorkspaceSyncStats(sendJson) {
       service: repoCardServiceStats(),
       wall: wallStats(),
       checkpoints: require('./checkpoint').checkpointStats(),
-      reconciliation: require('./reconcile').reconciliationStats(),
+      reducer: require('./reducer').reducerStats(),
     });
   } catch (error) {
     sendJson(500, { error: error instanceof Error ? error.message : 'Failed to read sync stats' });
   }
 }
 
+function handleCodeProjectJoin(body, sendJson) {
+  try {
+    const project = require('./wall').bindProject(
+      body?.repoKey,
+      body?.resourceId,
+      body?.ownerUserId,
+    );
+    sendJson(200, { project });
+  } catch (error) {
+    sendJson(400, { error: error instanceof Error ? error.message : 'Failed to join code project' });
+  }
+}
+
 /**
  * The whole wall: this machine's cards straight from the live store, every
  * peer's cards as last published. One call answers "what code does each of
@@ -875,6 +888,7 @@ module.exports = {
   handleRepoCardsRefresh,
   handleWorkspaceMachines,
   handleWorkspaceSyncStats,
+  handleCodeProjectJoin,
   handleTreeList,
   handleTreeEnroll,
   handleTreeMutation,

package/runtime/scripts/amalgm-mcp/workspace/store.js

@@ -103,12 +103,11 @@ function normalizeWorkspaceRecord(input, options = {}) {
 
 function workspaceRow(database, identifier) {
   return database.prepare(`
-    SELECT workspaces.*
+    SELECT *
     FROM workspaces
-    LEFT JOIN workspace_id_aliases ON workspace_id_aliases.workspace_id = workspaces.id
-    WHERE workspaces.id = ? OR workspaces.path = ? OR workspace_id_aliases.alias_id = ?
+    WHERE id = ? OR path = ?
     LIMIT 1
-  `).get(identifier, identifier, identifier) || null;
+  `).get(identifier, identifier) || null;
 }
 
 function ensureWorkspaceIdentityRows(database, workspace, options = {}) {
@@ -197,17 +196,14 @@ function upsertWorkspace(input, options = {}) {
 
   db.transaction(() => {
     workspace = normalizeWorkspaceRecord(input, options);
-    const requestedId = cleanString(input.id);
     const existing = db.prepare(`
-      SELECT workspaces.*
+      SELECT *
       FROM workspaces
-      LEFT JOIN workspace_id_aliases ON workspace_id_aliases.workspace_id = workspaces.id
-      WHERE workspaces.id = ?
-         OR workspaces.uri = ?
-         OR workspaces.path = ?
-         OR workspace_id_aliases.alias_id = ?
+      WHERE id = ?
+         OR uri = ?
+         OR path = ?
       LIMIT 1
-    `).get(workspace.id, workspace.uri, workspace.path, requestedId);
+    `).get(workspace.id, workspace.uri, workspace.path);
     if (existing) {
       const old = rowToWorkspace(existing);
       workspace = {
@@ -262,12 +258,6 @@ function upsertWorkspace(input, options = {}) {
       JSON.stringify(workspace),
     );
 
-    if (requestedId && requestedId !== workspace.id) {
-      db.prepare(`
-        INSERT OR IGNORE INTO workspace_id_aliases(alias_id, workspace_id)
-        VALUES (?, ?)
-      `).run(requestedId, workspace.id);
-    }
     ensureWorkspaceIdentityRows(db, workspace, options);
 
     events = publishWorkspaceEvents(db, existing ? 'update' : 'insert', workspace, options.source || 'workspace:upsert');