borgmcp 4.6.1 → 4.7.0

package/src/index.ts

@@ -67,6 +67,7 @@ import {
   formatDocumentMetadata,
 } from './document-render.js';
 import {
+  NEW_CUBE_TEMPLATE_PRESENTATIONS,
   getTemplate,
   listTemplateNames,
   resolveCubeDirectiveForCreate,
@@ -153,7 +154,7 @@ import {
   writeOpenCodeStartupDiagnostic,
 } from './opencode-drone.js';
 import { installBorgPlugin } from './opencode-plugin.js';
-import { openCodeApiPasswordFromEnv } from './opencode-launch-trust.js';
+import { openCodeApiPasswordFromEnv, openCodeLaunchCorrelationFromEnv } from './opencode-launch-trust.js';
 import { setModuleInjectOpenCode } from './log-stream.js';
 import {
   lifecycleSignalForMessage,
@@ -176,27 +177,6 @@ import {
 
 const OPEN_CODE_IDENTITY_HANDSHAKE_TIMEOUT_MS = 5_000;
 
-/**
- * Apply a template's roles + message_taxonomy to a cube.
- *
- * Client-orchestrated through the server's non-clobbering role and taxonomy
- * primitives. New roles are inserted; existing template-named roles get ADD
- * fragments (template sections/classes the cube lacks) auto-applied, but
- * EVOLVED (conflicting) fragments are kept — never silently overwritten. The
- * old per-role blanket `updateRole`/whole-taxonomy `updateCube` overwrite path
- * is removed. Operators who want to take the template version of a conflicting
- * fragment use `borg_sync-roles` with a `decisions` map. Primitive operations
- * are sequential, so a later failure can leave earlier changes committed.
- * Returns `{ created, updated }` for the caller's toast.
- */
-async function applyTemplateToCube(
-  cubeId: string,
-  template: Template,
-  authority?: LocalManageAuthority,
-): Promise<{ created: number; updated: number }> {
-  return await applyTemplate(cubeId, template.name, authority);
-}
-
 export async function runApplyTemplateTool(
   cubeId: string,
   template: Template,
@@ -312,6 +292,11 @@ export async function connectOpenCodeRuntime(
     console.error('OpenCode API credential is missing or unverifiable; skipping OpenCode entry injection. Relaunch through borg.');
     return false;
   }
+  const launchIdentity = openCodeLaunchCorrelationFromEnv(env);
+  if (launchIdentity === null) {
+    console.error('OpenCode launch identity is missing or unverifiable; skipping OpenCode entry injection. Relaunch through borg.');
+    return false;
+  }
   const binding = openCodeLaunchBinding(configuredPort);
   await (deps.connect ?? connectOpenCodeDrone)({
     serverUrl: binding.serverUrl,
@@ -319,6 +304,7 @@ export async function connectOpenCodeRuntime(
     directory: active.worktree ?? findProjectRoot(),
     droneLabel: active.droneLabel,
     cubeName: active.name,
+    launchIdentity,
   });
   return true;
 }
@@ -1251,18 +1237,15 @@ export async function main() {
         case 'borg_create-cube': {
           const name = args?.name as string;
           const cubeDirective = args?.cube_directive as string;
-          const templateName = args?.template as string | undefined;
+          const templateName = (args?.template as string | undefined) ?? NEW_CUBE_TEMPLATE_PRESENTATIONS[0].name;
           if (!name) throw new Error('name is required');
           if (cubeDirective === undefined) throw new Error('cube_directive is required (pass empty string if none)');
 
           // Resolve template (validates name early so the cube isn't
           // created in a partial state if the template name is wrong).
-          let template = null;
-          if (templateName) {
-            template = getTemplate(templateName);
-            if (!template) {
-              throw new Error(`Unknown template "${templateName}". Available: ${listTemplateNames().join(', ')}`);
-            }
+          const template = getTemplate(templateName);
+          if (!template) {
+            throw new Error(`Unknown template "${templateName}". Available: ${listTemplateNames().join(', ')}`);
           }
 
           // client#499: the cube binds to an EXPLICIT repository (no cwd
@@ -1280,6 +1263,7 @@ export async function main() {
           const resolvedCubeDirective = resolveCubeDirectiveForCreate(cubeDirective, template);
           const resolvedMessageTaxonomy = resolveMessageTaxonomyForCreate(undefined, template);
           const { result, cube } = await createCube(name, resolvedCubeDirective, {
+            template: template.name,
             message_taxonomy: resolvedMessageTaxonomy,
             repository,
             workingRepoName,
@@ -1296,30 +1280,19 @@ export async function main() {
             };
           }
 
-          // Apply template roles if requested. Merges by name: any role the
-          // server auto-seeded (e.g. "Drone") that the template doesn't
-          // also include stays put; templated roles upsert.
-          if (template) {
-            const summary = await applyTemplateToCube(cube.id, template);
-            const cubeDirectiveNote = resolvedCubeDirective !== cubeDirective
-              ? ' Template cube directive applied (operator passed empty).'
-              : '';
-            const text = `Created cube **${cube.name}** (id: ${cube.id}) with template **${templateName}** applied — ${summary.created} role(s) created, ${summary.updated} updated.${cubeDirectiveNote} Use borg_assimilate ${cube.name} to join as a drone.`;
-            return {
-              content: [{ type: 'text', text }],
-              structuredContent: {
-                cube,
-                result: 'created',
-                template: templateName,
-                roles_created: summary.created,
-                roles_updated: summary.updated,
-              },
-            };
-          }
-          const text = `Created cube **${cube.name}** (id: ${cube.id}). A default "Drone" role was seeded — rename or replace it via borg_update-role / borg_create-role / borg_delete-role. Use borg_assimilate ${cube.name} to join as a drone.`;
+          const cubeDirectiveNote = resolvedCubeDirective !== cubeDirective
+            ? ' Template cube directive applied (operator passed empty).'
+            : '';
+          const text = `Created cube **${cube.name}** (id: ${cube.id}) with template **${templateName}** applied atomically — ${cube.roles.length} role(s) created.${cubeDirectiveNote} Use borg_assimilate ${cube.name} to join as a drone.`;
           return {
             content: [{ type: 'text', text }],
-            structuredContent: { cube, result: 'created', template: null, roles_created: null, roles_updated: null },
+            structuredContent: {
+              cube,
+              result: 'created',
+              template: templateName,
+              roles_created: cube.roles.length,
+              roles_updated: 0,
+            },
           };
         }
 

package/src/log-stream.ts

@@ -34,7 +34,7 @@ import {
   ErrorCode,
   type DocumentCitation,
 } from 'borgmcp-shared/protocol';
-import { getActiveCube, inboxPathForDrone } from './cubes.js';
+import { getActiveCube, inboxPathForDrone, type ActiveCube } from './cubes.js';
 import { assertUuidShape } from './evict-drone.js';
 import { loadBorgServerTrust } from './server-trust.js';
 import {
@@ -56,7 +56,6 @@ import {
   CODEX_HEARTBEAT_CADENCE_MS,
   fireCodexHeartbeatTick,
   formatCodexWakePrompt,
-  resolveSessionAgentKind,
   startCodexHeartbeat,
   wakeCodexViaAppServer,
 } from './codex-app-wake.js';
@@ -420,7 +419,7 @@ export interface StreamDeps {
     isSourcePending?: () => Promise<boolean>,
   ) => Promise<boolean>;
   /** Inspect whether one retry source remains beyond the durable unread cursor. */
-  hasPendingWakeEntry?: (active: ActiveCube, entryId: string) => Promise<boolean>;
+  hasPendingWakeEntry?: (active: StreamActiveCube, entryId: string) => Promise<boolean>;
   /** Clear in-process retry diagnostics after the durable entry is consumed. */
   settleOpenCodeEntry?: (sourceEntryId: string) => void;
 }
@@ -671,21 +670,17 @@ export function __runLoopForTest(testDeps: RunLoopTestDeps): Promise<void> {
 // Single SSE session (exported for tests)
 // ------------------------------------------------------------------
 
-export interface ActiveCube {
-  cubeId: string;
-  droneId: string;
-  sessionToken: string;
-  apiUrl: string;
-  serverTrustIdentity?: string;
-  localSessionCredentialRef?: string;
-  localSessionExpiresAt?: string | null;
-  worktree?: string;
-  droneLabel?: string;
-  name?: string;
-}
+/** Direct stream controls may omit metadata or omit trust to exercise fail-closed validation. */
+export type StreamActiveCube = Pick<
+  ActiveCube,
+  'cubeId' | 'droneId' | 'sessionToken' | 'apiUrl'
+> & Partial<Pick<
+  ActiveCube,
+  'serverTrustIdentity' | 'localSessionCredentialRef' | 'worktree' | 'droneLabel' | 'name'
+>>;
 
 export async function streamOnce(
-  active: ActiveCube,
+  active: StreamActiveCube,
   lastEventId: string | null,
   onEventId: (id: string) => void,
   deps: StreamDeps = {}
@@ -1271,7 +1266,7 @@ export async function streamOnce(
 }
 
 export async function streamOnceIfOwner(
-  active: ActiveCube,
+  active: StreamActiveCube,
   lastEventId: string | null,
   onEventId: (id: string) => void,
   deps: StreamDeps = {}

package/src/opencode-drone.ts

@@ -14,7 +14,7 @@ import {
 } from 'fs';
 import { createHash, randomUUID } from 'crypto';
 import { createServer } from 'node:net';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import {
   borgConfigRoot,
@@ -44,8 +44,9 @@ const OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES = 64 * 1024;
 const diagnosticLogPathsForTests = new Set<string>();
 
 function stateIdentityDigest(current: OpenCodeDroneState): string {
-  const key = [current.directory, current.cubeName, current.droneLabel].join('\0');
-  return createHash('sha256').update(key).digest('hex').slice(0, 24);
+  // Diagnostic files follow the stable worktree location; launch placeholders
+  // must not select a second log before session identity resolves.
+  return createHash('sha256').update(resolve(current.directory)).digest('hex').slice(0, 24);
 }
 
 export function openCodeStartupDiagnosticLogPath(): string {
@@ -166,6 +167,7 @@ interface OpenCodeDroneState {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  launchIdentity: string;
   connected: boolean;
   totalEntriesInjected: number;
   totalEntriesRetried: number;
@@ -204,6 +206,7 @@ interface ConnectDeps {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  launchIdentity: string;
 }
 
 interface OCSession {
@@ -270,7 +273,7 @@ const OPEN_CODE_RECONCILIATION_ATTEMPTS = 20;
 const OPEN_CODE_DELIVERY_HISTORY_LIMIT = 256;
 
 interface SessionBinding {
-  version: 4;
+  version: 5;
   sessionId: string;
   sessionCreatedAt: number;
   knownRootSessionIds: string[];
@@ -278,6 +281,7 @@ interface SessionBinding {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  launchIdentity: string;
   pendingSubmissions: Array<{
     entryId: string;
     sourceEntryId: string;
@@ -285,6 +289,13 @@ interface SessionBinding {
   }>;
 }
 
+interface SessionBindingClaim {
+  version: 1;
+  directory: string;
+  droneLabel: string;
+  cubeName: string;
+}
+
 export interface OpenCodeLaunchKickoff {
   prompt: string;
   apiPassword: string;
@@ -323,6 +334,9 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
   if (!isOpenCode256BitIdentity(deps.apiPassword)) {
     throw new OpenCodeAuthenticationError('OpenCode API password is missing or unverifiable');
   }
+  if (!isOpenCode256BitIdentity(deps.launchIdentity)) {
+    throw new OpenCodeAuthenticationError('OpenCode launch identity is missing or unverifiable');
+  }
   await ensurePrivateBorgConfigRoot(borgConfigRoot());
   abandonOpenCodeDeliveries(state);
   state = {
@@ -334,6 +348,7 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
     directory: deps.directory,
     droneLabel: deps.droneLabel,
     cubeName: deps.cubeName,
+    launchIdentity: deps.launchIdentity,
     connected: true,
     totalEntriesInjected: 0,
     totalEntriesRetried: 0,
@@ -546,17 +561,28 @@ async function promptSession(id: string, bodyObj: Record<string, unknown>): Prom
 
 function bindingPath(): string {
   const current = state!;
-  const path = join(tmpdir(), `borg-opencode-session-${stateIdentityDigest(current)}.json`);
+  const identity = createHash('sha256').update(current.launchIdentity).digest('hex').slice(0, 24);
+  const path = join(tmpdir(), `borg-opencode-session-${identity}.json`);
   bindingPathsForTests.add(path);
   return path;
 }
 
+function bindingClaimPath(): string {
+  return `${bindingPath()}.claim`;
+}
+
 function bindingMatchesState(binding: SessionBinding): boolean {
   const current = state!;
-  return binding.version === 4
+  const sameResolvedSeat = binding.droneLabel === current.droneLabel
+    && binding.cubeName === current.cubeName;
+  // The 256-bit launch identity lets the resolved MCP child claim only its
+  // launcher's placeholder binding; resolved ownership still requires labels.
+  const unclaimedLaunch = binding.droneLabel === 'opencode'
+    && binding.cubeName === 'borg';
+  return binding.version === 5
     && binding.directory === current.directory
-    && binding.droneLabel === current.droneLabel
-    && binding.cubeName === current.cubeName
+    && binding.launchIdentity === current.launchIdentity
+    && (sameResolvedSeat || unclaimedLaunch)
     && typeof binding.sessionId === 'string'
     && typeof binding.sessionCreatedAt === 'number'
     && Array.isArray(binding.knownRootSessionIds)
@@ -599,15 +625,14 @@ function clearBinding(): void {
 
 function writeBinding(binding: SessionBinding): boolean {
   const current = state!;
-  current.sessionId = binding.sessionId;
-  current.sessionCreatedAt = binding.sessionCreatedAt;
-  current.knownRootSessionIds = binding.knownRootSessionIds;
-
   try {
     const path = bindingPath();
     const temporary = `${path}.${process.pid}.tmp`;
     writeFileSync(temporary, JSON.stringify(binding), { mode: 0o600 });
     renameSync(temporary, path);
+    current.sessionId = binding.sessionId;
+    current.sessionCreatedAt = binding.sessionCreatedAt;
+    current.knownRootSessionIds = binding.knownRootSessionIds;
     return true;
   } catch (err) {
     log(`session binding write failed: ${err}`);
@@ -615,10 +640,46 @@ function writeBinding(binding: SessionBinding): boolean {
   }
 }
 
+function claimPlaceholderBinding(): boolean {
+  const current = state!;
+  const claim: SessionBindingClaim = {
+    version: 1,
+    directory: current.directory,
+    droneLabel: current.droneLabel,
+    cubeName: current.cubeName,
+  };
+  const path = bindingClaimPath();
+  try {
+    writeFileSync(path, JSON.stringify(claim), { mode: 0o600, flag: 'wx' });
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+      log(`session binding claim failed: ${error}`);
+      return false;
+    }
+  }
+  try {
+    const existing = JSON.parse(readFileSync(path, 'utf8')) as SessionBindingClaim;
+    return existing.version === 1
+      && existing.directory === claim.directory
+      && existing.droneLabel === claim.droneLabel
+      && existing.cubeName === claim.cubeName;
+  } catch {
+    return false;
+  }
+}
+
+function dropCachedBinding(): void {
+  if (!state) return;
+  state.sessionId = null;
+  state.sessionCreatedAt = null;
+  state.knownRootSessionIds = [];
+}
+
 function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
   const current = state!;
   const binding: SessionBinding = {
-    version: 4,
+    version: 5,
     sessionId: session.id,
     sessionCreatedAt: session.time.created,
     knownRootSessionIds,
@@ -626,6 +687,7 @@ function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
     directory: current.directory,
     droneLabel: current.droneLabel,
     cubeName: current.cubeName,
+    launchIdentity: current.launchIdentity,
     pendingSubmissions: [...current.pendingSubmissions].map(([entryId, pending]) => ({
       entryId,
       sourceEntryId: pending.sourceEntryId,
@@ -639,7 +701,7 @@ function persistCurrentBinding(): boolean {
   const current = state;
   if (!current?.sessionId || current.sessionCreatedAt === null) return false;
   return writeBinding({
-    version: 4,
+    version: 5,
     sessionId: current.sessionId,
     sessionCreatedAt: current.sessionCreatedAt,
     knownRootSessionIds: current.knownRootSessionIds,
@@ -647,6 +709,7 @@ function persistCurrentBinding(): boolean {
     directory: current.directory,
     droneLabel: current.droneLabel,
     cubeName: current.cubeName,
+    launchIdentity: current.launchIdentity,
     pendingSubmissions: [...current.pendingSubmissions].map(([entryId, pending]) => ({
       entryId,
       sourceEntryId: pending.sourceEntryId,
@@ -658,25 +721,34 @@ function persistCurrentBinding(): boolean {
 function restoreBinding(): SessionBinding | null {
   if (!state) return null;
   if (state.sessionId && state.sessionCreatedAt !== null) {
-    return {
-      version: 4,
-      sessionId: state.sessionId,
-      sessionCreatedAt: state.sessionCreatedAt,
-      knownRootSessionIds: state.knownRootSessionIds,
-      serverUrl: state.serverUrl,
-      directory: state.directory,
-      droneLabel: state.droneLabel,
-      cubeName: state.cubeName,
-      pendingSubmissions: [...state.pendingSubmissions].map(([entryId, pending]) => ({
-        entryId,
-        sourceEntryId: pending.sourceEntryId,
-        sessionId: pending.sessionId,
-      })),
-    };
+    const persisted = readBinding();
+    if (
+      persisted?.droneLabel === state.droneLabel
+      && persisted.cubeName === state.cubeName
+    ) return persisted;
+    dropCachedBinding();
+    return null;
   }
 
-  const binding = readBinding();
+  let binding = readBinding();
   if (!binding) return null;
+  if (binding.droneLabel === 'opencode' && binding.cubeName === 'borg') {
+    if (!claimPlaceholderBinding()) return null;
+    if (!writeBinding({
+      ...binding,
+      droneLabel: state.droneLabel,
+      cubeName: state.cubeName,
+    })) return null;
+    binding = readBinding();
+    if (
+      !binding
+      || binding.droneLabel !== state.droneLabel
+      || binding.cubeName !== state.cubeName
+    ) {
+      dropCachedBinding();
+      return null;
+    }
+  }
   state.sessionId = binding.sessionId;
   state.sessionCreatedAt = binding.sessionCreatedAt;
   state.knownRootSessionIds = binding.knownRootSessionIds;
@@ -1560,6 +1632,11 @@ export function __getOpenCodeDiagnosticLogPathForTests(): string {
   return diagnosticLogPath(state);
 }
 
+export function __getOpenCodeBindingPathForTests(): string {
+  if (!state) throw new Error('OpenCode drone is not connected');
+  return bindingPath();
+}
+
 export function __getOpenCodeLastObservationForTests(): OpenCodeLastObservation {
   if (!state) throw new Error('OpenCode drone is not connected');
   return { ...state.lastObservation };
@@ -1649,6 +1726,11 @@ export function __resetOpenCodeDroneForTests(): void {
     } catch {
       // Already removed.
     }
+    try {
+      unlinkSync(`${path}.claim`);
+    } catch {
+      // Already removed.
+    }
   }
   bindingPathsForTests.clear();
   for (const path of diagnosticLogPathsForTests) {

package/src/opencode-launch-trust.ts

@@ -44,3 +44,8 @@ export function openCodeApiPasswordFromEnv(env: NodeJS.ProcessEnv): string | nul
   const password = env[OPENCODE_SERVER_PASSWORD_ENV];
   return isOpenCode256BitIdentity(password) ? password : null;
 }
+
+export function openCodeLaunchCorrelationFromEnv(env: NodeJS.ProcessEnv): string | null {
+  const identity = env[BORG_OPENCODE_LAUNCH_CORRELATION_ENV];
+  return isOpenCode256BitIdentity(identity) ? identity : null;
+}

package/src/quickstart-cmd.ts

@@ -13,6 +13,7 @@ import { LAUNCH_ALL_NO_DISPATCH_EXIT_CODE, runLaunchAll } from './launch-all-cmd
 import type { QuickstartArgs } from './parse-quickstart-args.js';
 import { roleSlug, type Role } from './role-resolver.js';
 import { DEFAULT_LOCAL_SERVER_ORIGIN } from './server-handshake.js';
+import { repositoryDiscoveryFailureMessage } from './repository-identity.js';
 
 interface PlannedRole {
   name: string;
@@ -178,8 +179,15 @@ export async function runQuickstart(
   let context;
   try {
     context = await assimilate.resolveRepositoryContext(assimilate.cwd());
-  } catch {
-    context = null;
+  } catch (error) {
+    if (error instanceof Error && error.message === 'BARE_REPOSITORY') {
+      context = null;
+    } else {
+      deps.stderr(
+        `borg quickstart: could not inspect this Git repository: ${repositoryDiscoveryFailureMessage(error)}\n`,
+      );
+      return 1;
+    }
   }
   if (!context) {
     deps.stderr('borg quickstart: run this command inside a non-bare Git repository.\n');

package/src/regen-format.ts

@@ -21,6 +21,7 @@ import { formatDocumentCitations } from './document-render.js';
 import { shellEscape } from './shell-escape.js';
 import { OPENCODE_WAKE_PATH_GUIDANCE } from './opencode-wake-copy.js';
 import { isBorgSession } from './launch-gate.js';
+import type { AgentKind } from './agent-runtime.js';
 
 /**
  * Extract the SessionStart `source` from a Claude Code hook payload (gh#926).
@@ -72,9 +73,6 @@ export function shouldRelayPlainSessionReminder(args: {
   );
 }
 
-/** The agent runtime a session runs under — drives the wake-path branch. */
-export type AgentKind = 'claude' | 'codex' | 'opencode';
-
 /**
  * The agent-branched WAKE-PATH ARMING sub-block (gh#929/gh#927) — the single
  * shared "re-establish your wake path" instruction reused by the launch

package/src/regen.ts

@@ -24,10 +24,9 @@ import {
   formatLeanOrientation,
   formatPlainSessionReminder,
   shouldRelayPlainSessionReminder,
-  type AgentKind,
 } from './regen-format.js';
 import { resolveSessionAgentKind } from './codex-app-wake.js';
-import { resolveReportableSessionAgentKind } from './agent-runtime.js';
+import { resolveReportableSessionAgentKind, type AgentKind } from './agent-runtime.js';
 import { handleVersionFlag } from './version.js';
 import {
   BORG_LAUNCH_REMINDER_DISABLED_ENV,
@@ -177,7 +176,7 @@ async function emitUnassimilatedNotice(): Promise<void> {
   lines.push('');
   lines.push('## Tools you can call once the user has chosen');
   lines.push('- Join an existing cube: `borg_assimilate cube_name="<their choice>"`');
-  lines.push('- Create a new cube: `borg_create-cube name="<name>" cube_directive="<markdown>"` (optionally `template="software-dev"`)');
+  lines.push('- Create a new cube: `borg_create-cube name="<name>" cube_directive="<markdown>"` (defaults to `template="software-dev"`)');
   lines.push('- See available templates: `borg_list-templates`');
   process.stdout.write(lines.join('\n') + '\n');
 }

package/src/remote-client.ts

@@ -60,7 +60,6 @@ import {
 } from 'borgmcp-shared/protocol';
 import { Buffer } from 'node:buffer';
 import { canonicalizeWorkingRepoIdentity } from './working-repo.js';
-import { consolePrefix } from './console-prefix.js';
 import { debugLog } from './debug.js';
 import { assertUuidShape } from './evict-drone.js';
 import {
@@ -70,7 +69,11 @@ import {
   DRONE_EVICTED_CODE,
 } from './drone-lifecycle.js';
 import type { MessageTaxonomy, MessageTaxonomyClass } from 'borgmcp-shared/templates';
-import { getTemplate, type Template, type TemplateRole } from 'borgmcp-shared/templates';
+import {
+  NEW_CUBE_TEMPLATE_PRESENTATIONS,
+  getTemplate,
+  type TemplateRole,
+} from 'borgmcp-shared/templates';
 import { parseRoleSections } from 'borgmcp-shared/role-section';
 import type { FragmentView, NonClobberSyncResult } from './sync-roles-render.js';
 import type { WorkingRepo } from './working-repo.js';
@@ -1521,10 +1524,8 @@ export async function listCubes(connection?: RemoteConnection): Promise<{ cubes:
  * to surface the interactive template prompt on first-drone bootstrap.
  */
 /**
- * Create a new cube. Server-side seeds a default "Drone" role atomically
- * so the cube is assimilatable immediately, OR applies the named template
- * atomically when `opts.template` is set (single-withUserId transaction —
- * skips the auto-Drone insert to avoid is_default partial-index conflict).
+ * Create a new cube. Server-side seeds the selected named template atomically
+ * so the cube is assimilatable immediately.
  *
  * Returns `{ cube, roles }` — the roles array lets the assimilate
  * orchestrator pick a default role without a follow-up `getCube` call.
@@ -1612,8 +1613,10 @@ export async function createCube(
   connection?: RemoteConnection,
 ): Promise<{ result: 'created' | 'resolved'; cube: { id: string; name: string; cube_directive?: string; roles: any[]; drones?: any[]; [k: string]: any } }> {
   if (!name?.trim()) throw new Error('Local Borg server cube creation requires a cube name');
-  if (opts?.template !== undefined && opts.template !== 'default') {
-    throw new Error('Local Borg server supports only the default cube seed');
+  const templateName = opts?.template ?? NEW_CUBE_TEMPLATE_PRESENTATIONS[0].name;
+  const template = getTemplate(templateName);
+  if (!template) {
+    throw new Error(`Unknown template "${templateName}". Available: ${NEW_CUBE_TEMPLATE_PRESENTATIONS.map(({ name }) => name).join(', ')}`);
   }
   if (!opts?.repository || !opts?.workingRepoName) {
     throw new Error('Local Borg server cube creation requires an explicit repository identity');
@@ -1628,7 +1631,7 @@ export async function createCube(
     name: name.trim(),
     working_repo_name: opts.workingRepoName,
     repository: opts.repository,
-    template: 'default',
+    template: template.name,
   }));
   // client#499: the server homes one cube per repository. A 'resolved' result
   // means this repository already has a cube — report it honestly and DO NOT

package/src/repository-cube-init.ts

@@ -1,6 +1,6 @@
 import {
   NEW_CUBE_TEMPLATE_PRESENTATIONS,
-  LEGACY_DEFAULT_TEMPLATE_LABEL,
+  getTemplate,
 } from 'borgmcp-shared/templates';
 import type {
   AssociateRepositoryCubeResponse,
@@ -33,7 +33,7 @@ export interface RepositoryCubeCreation {
   cube: RepositoryCubeDetail;
 }
 
-type NewCubeTemplate = Exclude<CubeTemplate, 'default'>;
+type NewCubeTemplate = CubeTemplate;
 
 const NEW_CUBE_TEMPLATE_NAMES: readonly NewCubeTemplate[] =
   NEW_CUBE_TEMPLATE_PRESENTATIONS.map(({ name }) => name);
@@ -110,10 +110,7 @@ export function validRepositoryCubeName(value: string): boolean {
 }
 
 function presentation(template: CubeTemplate) {
-  if (template === 'default') {
-    return { name: template, label: LEGACY_DEFAULT_TEMPLATE_LABEL };
-  }
-  return NEW_CUBE_TEMPLATE_PRESENTATIONS.find((candidate) => candidate.name === template)!;
+  return getTemplate(template)!;
 }
 
 async function ask(