borgmcp 2.0.11 → 2.1.0

package/src/assimilate-deps.ts

@@ -61,8 +61,47 @@ import { prepareCodexRemoteLaunch, defaultCodexRemoteDeps } from './codex-remote
 import { findLoadedCodexThread } from './codex-app-server.js';
 import { defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
 import { ensurePrivateBorgConfigRoot } from './private-root.js';
+import {
+  getOrCreateRepositoryIdentity,
+  getRepositoryAssociation,
+  resolveGitRepositoryContext,
+  saveRepositoryAssociation,
+} from './repository-identity.js';
+import { PromptInterruptedError } from './repository-cube-init.js';
 
-export function buildDefaultAssimilateDeps(): AssimilateDeps {
+/**
+ * Wraps the readline question operation with the production interruption
+ * mapping. Tests inject the question operation; production uses readline.
+ */
+export type PromptQuestion = (message: string) => Promise<string>;
+
+async function defaultPromptQuestion(message: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(message);
+  } finally {
+    rl.close();
+  }
+}
+
+export function createPromptAdapter(
+  question: PromptQuestion = defaultPromptQuestion,
+): (message: string) => Promise<string> {
+  return async (message: string): Promise<string> => {
+    try {
+      return await question(message);
+    } catch (err) {
+      if (err instanceof Error && (err.message === 'SIGINT' || err.message === 'Interrupted by signal.')) {
+        throw new PromptInterruptedError();
+      }
+      throw err;
+    }
+  };
+}
+
+export function buildDefaultAssimilateDeps(
+  question: PromptQuestion = defaultPromptQuestion,
+): AssimilateDeps {
   return {
     runSync: (cmd, args, cwd) => {
       const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8' });
@@ -97,14 +136,7 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
 
     stderr: (line) => process.stderr.write(line),
     stdout: (line) => process.stdout.write(line),
-    prompt: async (message: string): Promise<string> => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      try {
-        return await rl.question(message);
-      } finally {
-        rl.close();
-      }
-    },
+    prompt: createPromptAdapter(question),
     promptSecret: async (message: string): Promise<string> => {
       const result = await prompts({
         type: 'password',
@@ -178,6 +210,10 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
         : { committed: false, reason: 'activation-failed' };
     },
     findProjectRoot: (cwd) => cubesFindProjectRoot(cwd),
+    resolveRepositoryContext: resolveGitRepositoryContext,
+    getRepositoryIdentity: getOrCreateRepositoryIdentity,
+    getRepositoryAssociation,
+    saveRepositoryAssociation,
 
     // gh#673 P2 (WI-1): project-local SessionStart hook for the launch root.
     installProjectSessionHook: (projectRoot) => {
@@ -237,14 +273,16 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
         throw new Error('Selected Borg server authority state is missing or unreadable');
       }
       {
-        if (!params.name || !params.projectRoot) {
-          throw new Error('Local Borg server cube creation requires a repository name and root');
-        }
         const created = await createLocalBorgServerCube(
           apiUrl,
           serverTrustIdentity,
           token,
-          { projectRoot: params.projectRoot, name: params.name },
+          {
+            name: params.name,
+            workingRepoName: params.workingRepoName,
+            repository: params.repository,
+            template: params.template,
+          },
         );
         const cube = await remoteGetCube(created.cube_id, {
           apiUrl,
@@ -253,16 +291,20 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
         });
         if (
           cube.id !== created.cube_id ||
+          cube.name !== created.name ||
           !Array.isArray(cube.roles) ||
           !cube.roles.some((role: { id?: string }) => role.id === created.default_worker_role_id)
         ) {
           throw new Error('Borg server returned cube details outside the creation result');
         }
         return {
-          id: cube.id,
-          name: cube.name,
-          roles: cube.roles,
-          drones: cube.drones ?? [],
+          response: created,
+          cube: {
+            id: cube.id,
+            name: cube.name,
+            roles: cube.roles,
+            drones: cube.drones ?? [],
+          },
         };
       }
     },

package/src/claude.ts

@@ -19,8 +19,10 @@
 
 import { spawn } from 'child_process';
 import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
 import { basename } from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import { findProjectRoot, getActiveCube, inboxPathForDrone, setCodexWakeTarget, pruneDeadCodexWakeTargets } from './cubes.js';
 import { monitorStateRootForWorktree } from './inbox-monitor.js';
@@ -81,6 +83,23 @@ import { connectOpenCodeDrone, computeOpenCodePort, createOpenCodeLaunchKickoff,
 import { buildOpenCodeLaunchArgs, defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
 import { runEarlyServerFacade } from './server-facade.js';
 
+export type AssimilateDepsBuilder = typeof buildDefaultAssimilateDeps;
+
+export async function runAssimilateEntry(
+  args: readonly string[],
+  buildDeps: AssimilateDepsBuilder = buildDefaultAssimilateDeps,
+): Promise<number> {
+  const parsed = parseAssimilateArgs([...args]);
+  if (!parsed.ok) {
+    process.stderr.write(
+      chalk.red(`${consolePrefix()}◼ borg assimilate: ${parsed.error}\n`)
+    );
+    process.stderr.write(`Run \`borg --help\` for usage.\n`);
+    return 1;
+  }
+  return runAssimilate({ role: parsed.role, flags: parsed.flags }, buildDeps());
+}
+
 async function main() {
   const serverExitCode = await runEarlyServerFacade(process.argv);
   if (serverExitCode !== null) process.exit(serverExitCode);
@@ -128,16 +147,7 @@ async function main() {
       process.stdout.write(assimilateHelpText(getPackageVersion()));
       process.exit(0);
     }
-    const parsed = parseAssimilateArgs(process.argv.slice(3));
-    if (!parsed.ok) {
-      process.stderr.write(
-        chalk.red(`${consolePrefix()}◼ borg assimilate: ${parsed.error}\n`)
-      );
-      process.stderr.write(`Run \`borg --help\` for usage.\n`);
-      process.exit(1);
-    }
-    const deps = buildDefaultAssimilateDeps();
-    const code = await runAssimilate({ role: parsed.role, flags: parsed.flags }, deps);
+    const code = await runAssimilateEntry(process.argv.slice(3));
     process.exit(code);
   }
   if (process.argv[2] === 'reset-local-seat') {
@@ -560,7 +570,17 @@ function ensureDetectedCliConfigured(): void {
   }
 }
 
-main().catch((error) => {
-  console.error(`${consolePrefix()}${chalk.red(`\n◼ Error: ${error.message}\n`)}`);
-  process.exit(1);
-});
+function isEntryInvocation(): boolean {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+
+if (isEntryInvocation()) {
+  main().catch((error) => {
+    console.error(`${consolePrefix()}${chalk.red(`\n◼ Error: ${error.message}\n`)}`);
+    process.exit(1);
+  });
+}

package/src/cli-help.ts

@@ -30,6 +30,7 @@ export function topLevelHelpText(version: string): string {
     `  borg assimilate [role]   Join or create a cube\n` +
     `  borg assimilate --host <host>   Join or create on an explicit server\n` +
     `  borg assimilate --worktree <name>   Spawn a worktree drone (in ~/.borg/worktrees/<repo>/<name>)\n` +
+    `  borg server cube init   Initialize this repository's cube without creating a drone\n` +
     `  borg reset-local-seat    Clear ONLY this worktree's saved local seat (offline; after a rejection)\n` +
     `  borg sync [--prune]      Sync this worktree's branch to origin/main\n` +
     `  borg cleanup [--prune]   Report (or --prune) worktrees orphaned by evicted drones\n` +
@@ -53,11 +54,28 @@ export function serverHelpText(): string {
     `  stop     Stop the managed local server.\n` +
     `  status   Report verified runtime evidence.\n` +
     `  update   Verify and activate a local server artifact.\n` +
-    `  invite   Create a single-use invitation in an interactive terminal.\n\n` +
+    `  invite   Create a single-use invitation in an interactive terminal.\n` +
+    `  cube init   Initialize this Git repository's cube; does not create a drone.\n\n` +
     `Run borg server <command> --help for server command options.\n`
   );
 }
 
+/** Client-owned help for repository cube initialization without a drone. */
+export function cubeInitHelpText(): string {
+  return (
+    `borg server cube init — initialize this Git repository's cube without creating a drone\n\n` +
+    `Usage:\n` +
+    `  borg server cube init [options]\n\n` +
+    `Options:\n` +
+    `  --host <host>                    Borg server host or URL (bare hosts default to HTTPS)\n` +
+    `  --enroll                         Prompt for a hidden enrollment invitation\n` +
+    `  --cube-name <name>               Repository cube name (otherwise edit the proposed name)\n` +
+    `  --template software-dev|starter  New-cube template (default: software-dev)\n` +
+    `  --yes, -y                        Skip confirmation prompts\n` +
+    `  --help, -h                       Show this help\n`
+  );
+}
+
 /**
  * Help text for `borg assimilate --help` — the home for the full assimilate flag
  * set. Model/provider configuration belongs to the selected agent CLI.
@@ -76,15 +94,17 @@ export function assimilateHelpText(version: string): string {
     `Flags:\n` +
     `  --worktree <name>          Create + launch the drone in a sibling git worktree\n` +
     `  --here                     Stay in the current worktree (no sibling spawn)\n` +
-    `  --cube-name <name>         Cube to join/create (otherwise confirm repo basename)\n` +
+    `  --cube-name <name>         Repository cube name (otherwise edit the proposed name)\n` +
     `  --host <host>              Borg server host or URL (bare hosts default to HTTPS)\n` +
     `  --enroll                   Prompt for a hidden enrollment invitation in the operator terminal\n` +
-    `  --template <name>          Bootstrap a new cube from a bundled role template\n` +
-    `  --no-template              Create the cube with no template roles\n` +
+    `  --template software-dev|starter   New-cube template (default: software-dev)\n` +
+    `  --no-template              Unsupported for repository cube creation\n` +
     `  --cli claude|codex|opencode         Agent CLI to launch (default: claude)\n` +
     `  --model claude:<model>   Legacy Claude model override (configure models in the agent CLI)\n` +
     `  --yes, -y                  Skip confirmation prompts\n\n` +
-    `An enrolled owner client may create an idempotent repository cube; ordinary clients\n` +
+    `Creation shows repository context, name, template, and one confirmation. An existing\n` +
+    `repository association skips all prompts. An enrolled owner client may create an\n` +
+    `idempotent repository cube; ordinary clients\n` +
     `require an explicit cube grant. Agent seats begin only after enrollment. Preview only.\n` +
     `See docs/LOCAL_SERVER.md for self-hosted setup and current status.\n\n` +
     `For local or provider-specific models, configure the selected agent CLI directly.\n` +

package/src/config.ts

@@ -7,7 +7,7 @@
  * read-compare-write shared by client enrollment and same-machine server setup.
  */
 import { createHash, randomBytes, randomUUID } from 'crypto';
-import type { ServerCapability } from 'borgmcp-shared/protocol';
+import type { CreateCubeRepository, CubeTemplate, ServerCapability } from 'borgmcp-shared/protocol';
 import { withStoreLock } from './seat-store.js';
 import {
   makeFileBackend,
@@ -17,7 +17,7 @@ import { BORG_USER_ROOT, SERVER_CREDENTIALS_FILE } from './credential-paths.js';
 
 const SERVER_CREDENTIAL_RECORD_VERSION = 2 as const;
 const SERVER_PENDING_ENROLLMENT_RECORD_VERSION = 1 as const;
-const SERVER_CUBE_RETRY_RECORD_VERSION = 1 as const;
+const SERVER_CUBE_RETRY_RECORD_VERSION = 2 as const;
 // The 0600 credential store (Queen rescope: replaces the OS keychain). A single
 // file holds every parent credential/enrollment record; a single flock
 // serializes every mutator + observer that must (SR-seven #4).
@@ -57,7 +57,9 @@ export interface PendingServerCubeCreationRecord {
   repositoryBinding: string;
   retryKey: string;
   name: string;
-  template: 'default';
+  workingRepoName: string;
+  repository: CreateCubeRepository;
+  template: CubeTemplate;
 }
 
 /**
@@ -510,21 +512,29 @@ export async function getOrCreatePendingServerCubeCreation(
     origin: string;
     trustIdentity: string;
     clientId: string;
-    projectRoot: string;
     name: string;
-    template: 'default';
+    workingRepoName: string;
+    repository: CreateCubeRepository;
+    template: CubeTemplate;
   },
 ): Promise<PendingServerCubeCreationRecord> {
   validateServerCredentialBinding(input.origin, input.trustIdentity);
   validateUuid(input.clientId, 'client identity');
-  if (input.projectRoot.length < 1 || input.projectRoot.length > 4096 || /[\u0000-\u001f\u007f]/.test(input.projectRoot)) {
+  if (
+    (input.repository.kind !== 'origin' && input.repository.kind !== 'local') ||
+    typeof input.repository.value !== 'string' || input.repository.value.length < 1
+  ) {
     throw new Error('invalid Borg server repository binding');
   }
   if (Buffer.byteLength(input.name, 'utf8') < 1 || Buffer.byteLength(input.name, 'utf8') > 120 ||
       !/^[A-Za-z0-9][A-Za-z0-9 ._-]*$/.test(input.name)) {
     throw new Error('invalid Borg server cube name');
   }
-  const repositoryBinding = createHash('sha256').update(input.projectRoot).digest('hex');
+  const repositoryBinding = createHash('sha256')
+    .update(input.repository.kind)
+    .update('\0')
+    .update(input.repository.value)
+    .digest('hex');
   const backend = await getServerCredentialBackend();
   const account = serverCubeRetryAccount(
     input.origin,
@@ -548,6 +558,7 @@ export async function getOrCreatePendingServerCubeCreation(
           record.clientId !== input.clientId ||
           record.repositoryBinding !== repositoryBinding ||
           record.name !== input.name ||
+          record.workingRepoName !== input.workingRepoName ||
           record.template !== input.template ||
           typeof record.retryKey !== 'string' || !UUID_RE.test(record.retryKey)
         ) {
@@ -560,6 +571,8 @@ export async function getOrCreatePendingServerCubeCreation(
           repositoryBinding,
           retryKey: record.retryKey,
           name: input.name,
+          workingRepoName: input.workingRepoName,
+          repository: input.repository,
           template: input.template,
         };
       } catch {
@@ -573,12 +586,21 @@ export async function getOrCreatePendingServerCubeCreation(
       repositoryBinding,
       retryKey: randomUUID(),
       name: input.name,
+      workingRepoName: input.workingRepoName,
+      repository: input.repository,
       template: input.template,
     };
     await backend.set(account, JSON.stringify({
       version: SERVER_CUBE_RETRY_RECORD_VERSION,
       state: 'pending',
-      ...record,
+      origin: record.origin,
+      trustIdentity: record.trustIdentity,
+      clientId: record.clientId,
+      repositoryBinding: record.repositoryBinding,
+      retryKey: record.retryKey,
+      name: record.name,
+      workingRepoName: record.workingRepoName,
+      template: record.template,
     }));
     return record;
   });

package/src/remote-client.ts

@@ -712,7 +712,7 @@ async function authedFetch(
           parsed.error !== null && typeof parsed.error === 'object' &&
           parsed.error.code === ROLE_SECTION_CONFLICT_CODE
         ) {
-          // Shared 0.6.2 intentionally omits this server-local code. Re-validate the whole
+          // Shared 0.6.3 intentionally omits this server-local code. Re-validate the whole
           // envelope through the strict shared decoder with only the recognized
           // code substituted; no server-provided diagnostic is ever surfaced.
           decodeProtocolErrorEnvelope({

package/src/repository-cube-init.ts

@@ -0,0 +1,273 @@
+import {
+  NEW_CUBE_TEMPLATE_PRESENTATIONS,
+  LEGACY_DEFAULT_TEMPLATE_LABEL,
+} from 'borgmcp-shared/templates';
+import type {
+  CreateCubeRepository,
+  CreateCubeResponse,
+  CubeTemplate,
+} from 'borgmcp-shared/protocol';
+import { shellEscape } from './shell-escape.js';
+import type {
+  GitRepositoryContext,
+  RepositoryAssociation,
+} from './repository-identity.js';
+
+export interface RepositoryCubeDetail {
+  id: string;
+  name: string;
+  roles: any[];
+  drones?: Array<{ role_id: string }>;
+}
+
+export interface RepositoryCubeCreation {
+  response: CreateCubeResponse;
+  cube: RepositoryCubeDetail;
+}
+
+export interface RepositoryCubeInitFlags {
+  cubeName?: string;
+  template?: string;
+  noTemplate?: boolean;
+  yes?: boolean;
+}
+
+export interface RepositoryCubeInitDeps {
+  isTTY(): boolean;
+  prompt(message: string): Promise<string>;
+  write(text: string): void;
+  getIdentity(context: GitRepositoryContext): Promise<CreateCubeRepository>;
+  getAssociation(repository: CreateCubeRepository): Promise<RepositoryAssociation | null>;
+  saveAssociation(repository: CreateCubeRepository, association: RepositoryAssociation): Promise<void>;
+  getCube(cubeId: string): Promise<RepositoryCubeDetail>;
+  createCube(input: {
+    name: string;
+    workingRepoName: string;
+    repository: CreateCubeRepository;
+    template: Exclude<CubeTemplate, 'default'>;
+  }): Promise<RepositoryCubeCreation>;
+}
+
+export type RepositoryCubeInitResult =
+  | { kind: 'success'; creation: RepositoryCubeCreation; existing: boolean }
+  | { kind: 'stop'; code: number };
+
+export class RepositoryAssociationSaveError extends Error {
+  constructor() {
+    super('repository association could not be saved');
+    this.name = 'RepositoryAssociationSaveError';
+  }
+}
+
+export class PromptInterruptedError extends Error {
+  constructor() {
+    super('prompt interrupted');
+    this.name = 'PromptInterruptedError';
+  }
+}
+
+const NAME_ERROR = 'Use 1-120 letters, digits, spaces, dots, underscores, or hyphens, starting with a letter or digit.';
+
+export function validRepositoryCubeName(value: string): boolean {
+  return Buffer.byteLength(value, 'utf8') <= 120 && /^[A-Za-z0-9][A-Za-z0-9 ._-]*$/.test(value);
+}
+
+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)!;
+}
+
+async function ask(deps: RepositoryCubeInitDeps, message: string): Promise<{ value: string } | { stop: number }> {
+  try {
+    return { value: await deps.prompt(message) };
+  } catch (error) {
+    if (error instanceof PromptInterruptedError) {
+      deps.write('\nCube creation cancelled. Nothing was changed.\n');
+      return { stop: 130 };
+    }
+    deps.write('Input ended before cube creation. Nothing was changed.\n');
+    return { stop: 1 };
+  }
+}
+
+function renderResult(
+  deps: RepositoryCubeInitDeps,
+  input: {
+    existing: boolean;
+    response: Pick<CreateCubeResponse, 'name' | 'working_repo_name' | 'template'>;
+    root: string;
+    serverOrigin: string;
+    mode: 'assimilate' | 'cube-init';
+    creationOptionsUnused: boolean;
+  },
+): void {
+  const lines = [
+    input.existing ? 'Cube already initialized.' : 'Cube created.',
+    `  Name: ${input.response.name}`,
+    `  Template: ${presentation(input.response.template).label}`,
+    `  Repository: ${input.root}`,
+    `  Server: ${input.serverOrigin}`,
+  ];
+  if (input.creationOptionsUnused) {
+    lines.push('Creation options were not used because this repository is already initialized.');
+  }
+  if (input.mode === 'cube-init') {
+    lines.push(
+      'No drone was created.',
+      `Next: borg assimilate --host ${shellEscape(input.serverOrigin)}`,
+    );
+  } else {
+    lines.push('Continuing with role and seat setup...');
+  }
+  deps.write(`${lines.join('\n')}\n`);
+}
+
+export async function initializeRepositoryCube(input: {
+  mode: 'assimilate' | 'cube-init';
+  context: GitRepositoryContext;
+  serverOrigin: string;
+  flags: RepositoryCubeInitFlags;
+}, deps: RepositoryCubeInitDeps): Promise<RepositoryCubeInitResult> {
+  const repository = await deps.getIdentity(input.context);
+  const association = await deps.getAssociation(repository);
+  const creationOptionsUnused = association !== null && (
+    input.flags.cubeName !== undefined || input.flags.template !== undefined || input.flags.yes === true
+  );
+  if (association) {
+    const cube = await deps.getCube(association.cubeId);
+    const authoritativeAssociation = { ...association, name: cube.name };
+    if (cube.name !== association.name) {
+      try {
+        await deps.saveAssociation(repository, authoritativeAssociation);
+      } catch {
+        throw new RepositoryAssociationSaveError();
+      }
+    }
+    const response: CreateCubeResponse = {
+      result: 'resolved',
+      cube_id: association.cubeId,
+      name: cube.name,
+      working_repo_name: association.workingRepoName,
+      repository,
+      template: association.template,
+      human_seat_role_id: cube.roles.find((role) => role.is_human_seat)?.id ?? '',
+      default_worker_role_id: cube.roles.find((role) => role.is_default)?.id ?? '',
+      access: 'manage',
+    };
+    renderResult(deps, {
+      existing: true,
+      response,
+      root: input.context.root,
+      serverOrigin: input.serverOrigin,
+      mode: input.mode,
+      creationOptionsUnused,
+    });
+    return { kind: 'success', creation: { response, cube }, existing: true };
+  }
+
+  if (input.flags.noTemplate) {
+    deps.write('--no-template is not supported for repository cube creation. Use --template software-dev or --template starter.\n');
+    return { kind: 'stop', code: 1 };
+  }
+  if (input.flags.template !== undefined && input.flags.template !== 'software-dev' && input.flags.template !== 'starter') {
+    const safe = input.flags.template.replace(/[\u0000-\u001f\u007f]/g, '?').slice(0, 120);
+    deps.write(`Unknown template '${safe}'. Use software-dev or starter.\n`);
+    return { kind: 'stop', code: 1 };
+  }
+  if (!deps.isTTY() && !input.flags.yes && (!input.flags.cubeName || !input.flags.template)) {
+    deps.write('Non-interactive cube creation requires --cube-name <name> and --template software-dev|starter, or --yes to use repository defaults.\n');
+    return { kind: 'stop', code: 1 };
+  }
+
+  deps.write(
+    `Create a cube for this repository\n` +
+    `Repository: ${input.context.root}\n` +
+    `Server: ${input.serverOrigin}\n`,
+  );
+
+  let name = input.flags.cubeName?.trim() ?? input.context.derivedName;
+  if (!input.flags.cubeName && deps.isTTY() && !input.flags.yes) {
+    while (true) {
+      const answer = await ask(deps, `Cube name [${input.context.derivedName}]: `);
+      if ('stop' in answer) return { kind: 'stop', code: answer.stop };
+      name = answer.value.trim() || input.context.derivedName;
+      if (validRepositoryCubeName(name)) break;
+      deps.write(`${NAME_ERROR}\n`);
+    }
+  }
+  if (!validRepositoryCubeName(name)) {
+    deps.write(`${NAME_ERROR}\n`);
+    return { kind: 'stop', code: 1 };
+  }
+
+  let template = input.flags.template as 'software-dev' | 'starter' | undefined;
+  if (!template && deps.isTTY() && !input.flags.yes) {
+    let menu = 'Choose a template:\n';
+    for (let i = 0; i < NEW_CUBE_TEMPLATE_PRESENTATIONS.length; i += 1) {
+      const p = NEW_CUBE_TEMPLATE_PRESENTATIONS[i];
+      const suffix = i === 0 ? ' (recommended)' : '';
+      menu += `  ${i + 1}. ${p.label}${suffix}\n`;
+      menu += `     ${p.short_description}\n`;
+    }
+    deps.write(menu);
+    while (!template) {
+      const answer = await ask(deps, 'Template [1]: ');
+      if ('stop' in answer) return { kind: 'stop', code: answer.stop };
+      const selected = answer.value.trim();
+      if (selected === '' || selected === '1') template = 'software-dev';
+      else if (selected === '2') template = 'starter';
+      else deps.write('Choose 1 or 2.\n');
+    }
+  }
+  template ??= 'software-dev';
+
+  if (deps.isTTY() && !input.flags.yes) {
+    deps.write(
+      `Create this cube?\n` +
+      `  Name: ${name}\n` +
+      `  Template: ${presentation(template).label}\n` +
+      `  Repository: ${input.context.root}\n` +
+      `  Server: ${input.serverOrigin}\n`,
+    );
+    let confirmed = false;
+    while (!confirmed) {
+      const answer = await ask(deps, 'Create cube? [Y/n]: ');
+      if ('stop' in answer) return { kind: 'stop', code: answer.stop };
+      const confirmation = answer.value.trim().toLowerCase();
+      if (confirmation === '' || confirmation === 'y' || confirmation === 'yes') {
+        confirmed = true;
+        break;
+      }
+      if (confirmation === 'n' || confirmation === 'no') {
+        deps.write('Cube creation cancelled. Nothing was changed.\n');
+        return { kind: 'stop', code: 0 };
+      }
+      deps.write('Enter y or n.\n');
+    }
+  }
+
+  deps.write('Creating cube...\n');
+  const workingRepoName = input.context.derivedName;
+  const creation = await deps.createCube({ name, workingRepoName, repository, template });
+  try {
+    await deps.saveAssociation(repository, {
+      cubeId: creation.response.cube_id,
+      name: creation.response.name,
+      workingRepoName: creation.response.working_repo_name,
+      template: creation.response.template,
+    });
+  } catch {
+    throw new RepositoryAssociationSaveError();
+  }
+  renderResult(deps, {
+    existing: creation.response.result === 'resolved',
+    response: creation.response,
+    root: input.context.root,
+    serverOrigin: input.serverOrigin,
+    mode: input.mode,
+    creationOptionsUnused: false,
+  });
+  return { kind: 'success', creation, existing: creation.response.result === 'resolved' };
+}