borgmcp 2.0.10 → 2.1.0

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/index.ts

@@ -139,14 +139,15 @@ import {
 /**
  * Apply a template's roles + message_taxonomy to a cube.
  *
- * gh#473 PR2 — delegates to the NON-CLOBBERING server route. New roles
- * are inserted; existing template-named roles get ADD fragments (template
- * sections/classes the cube lacks) auto-applied, but EVOLVED (conflicting)
- * fragments are surfaced server-side and 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. Returns `{ created, updated }` for the caller's toast.
+ * 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,

package/src/local-manage-tool-result.ts

@@ -1,6 +1,53 @@
 import { LocalManageRequiredError } from './server-errors.js';
 
+export interface RoleSectionConflictOperation {
+  roleId: string;
+  action: 'replace' | 'insert' | 'delete';
+  heading: string;
+  after?: string | null;
+}
+
+export class RoleSectionConflictError extends Error {
+  constructor(public readonly operation: RoleSectionConflictOperation) {
+    super('The role section patch conflicted with the current role text.');
+    this.name = 'RoleSectionConflictError';
+  }
+}
+
+const UNSAFE_OPERATION_CHARACTER =
+  /["\\`*_[\]()<>#!|~\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/u;
+
+function safeOperationValue(value: string): string {
+  const escaped = Array.from(value, (character) =>
+    UNSAFE_OPERATION_CHARACTER.test(character)
+      ? `\\u{${character.codePointAt(0)!.toString(16)}}`
+      : character).join('');
+  return `"${escaped}"`;
+}
+
 export function formatLocalManageToolResult(error: unknown) {
+  if (error instanceof RoleSectionConflictError) {
+    const { roleId, action, heading, after } = error.operation;
+    const context = [
+      `action=${action}`,
+      `heading=${safeOperationValue(heading)}`,
+      ...(action === 'insert'
+        ? [`after=${after == null ? '<end>' : safeOperationValue(after)}`]
+        : []),
+    ].join(', ');
+    return {
+      content: [{
+        type: 'text' as const,
+        text:
+          `[ROLE-SECTION-CONFLICT] The requested role section operation conflicts with the current role text.\n\n` +
+          `Requested operation: ${context}\n\n` +
+          'No role text was changed by this request. ' +
+          `Read the current role with \`borg_role\` using role id ${safeOperationValue(roleId)}, ` +
+          'then retry `borg_patch-role-section` against that current text.',
+      }],
+      isError: true as const,
+    };
+  }
   if (!(error instanceof LocalManageRequiredError)) return null;
 
   return {

package/src/remote-client.ts

@@ -54,6 +54,7 @@ import {
 } from './local-server-cursor.js';
 import { readBoundedResponseBody } from './server-response.js';
 import { resolveLocalLogRecipients } from './local-log-routing.js';
+import { RoleSectionConflictError } from './local-manage-tool-result.js';
 
 export interface RemoteConnection {
   apiUrl: string;
@@ -71,6 +72,7 @@ export const LOCAL_SERVER_RESPONSE_LIMIT_BYTES = 32 * 1024 * 1024;
 // A typed auth-error envelope is tiny; anything larger is hostile and the
 // bounded read throws → the 401 fails closed to non-destructive CREDENTIAL_REJECTED.
 const AUTH_ERROR_ENVELOPE_LIMIT_BYTES = 64 * 1024;
+const ROLE_SECTION_CONFLICT_CODE = 'ROLE_SECTION_CONFLICT';
 export const LOCAL_SERVER_REQUEST_TIMEOUT_MS = 5_000;
 const LOCAL_SERVER_RESPONSE_LIMIT_MESSAGE =
   'Local Borg server response exceeded the response limit';
@@ -701,7 +703,30 @@ async function authedFetch(
         AUTH_ERROR_ENVELOPE_LIMIT_BYTES,
         'Local Borg server error response exceeded the response limit',
       );
-      code = decodeProtocolErrorEnvelope(JSON.parse(body)).error.code;
+      const parsed = JSON.parse(body);
+      try {
+        code = decodeProtocolErrorEnvelope(parsed).error.code;
+      } catch {
+        if (
+          parsed !== null && typeof parsed === 'object' &&
+          parsed.error !== null && typeof parsed.error === 'object' &&
+          parsed.error.code === ROLE_SECTION_CONFLICT_CODE
+        ) {
+          // 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({
+            ...parsed,
+            error: {
+              ...parsed.error,
+              code: ErrorCode.INVALID_INPUT,
+              message: 'Role section conflict.',
+              ...(Object.hasOwn(parsed.error, 'details') ? { details: 'Redacted.' } : {}),
+            },
+          });
+          code = ROLE_SECTION_CONFLICT_CODE as ErrorCode;
+        }
+      }
     } catch {
       code = undefined;
     }
@@ -1410,19 +1435,36 @@ export async function patchRoleSection(
   if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');
   const cubeId = targetCubeId ?? active.cubeId;
   assertUuidShape(cubeId, 'cube_id');
-  const result = await localManageRequest<{ role: any }>(
-    active,
-    `/api/cubes/${cubeId}/roles/${roleId}/section-patch`,
-    'POST',
-    {
-      operation: `${op.action} section ${manageCopyValue(op.heading)} ${op.action === 'delete' ? 'from' : 'in'} role ${manageCopyValue(roleId)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
-      cubeName: cubeId === active.cubeId ? active.name : cubeId,
-      noMutation: `No role section was ${op.action === 'insert' ? 'inserted' : op.action === 'replace' ? 'replaced' : 'deleted'}.`,
-    },
-    { ...op },
-    undefined,
-    connectionOverride,
-  );
+  let result: { role: any } | null;
+  try {
+    result = await localManageRequest<{ role: any }>(
+      active,
+      `/api/cubes/${cubeId}/roles/${roleId}/section-patch`,
+      'POST',
+      {
+        operation: `${op.action} section ${manageCopyValue(op.heading)} ${op.action === 'delete' ? 'from' : 'in'} role ${manageCopyValue(roleId)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
+        noMutation: `No role section was ${op.action === 'insert' ? 'inserted' : op.action === 'replace' ? 'replaced' : 'deleted'}.`,
+      },
+      { ...op },
+      undefined,
+      connectionOverride,
+    );
+  } catch (error) {
+    if (
+      error instanceof BorgServerHttpError &&
+      error.status === 409 &&
+      String(error.code) === ROLE_SECTION_CONFLICT_CODE
+    ) {
+      throw new RoleSectionConflictError({
+        roleId,
+        action: op.action,
+        heading: op.heading,
+        ...(op.action === 'insert' ? { after: op.after } : {}),
+      });
+    }
+    throw error;
+  }
   if (!result) throw new Error('Local Borg server returned an empty role response');
   return result;
 }
@@ -1554,11 +1596,12 @@ export async function getCube(cubeId: string, connection?: RemoteConnection): Pr
 }
 
 /**
- * gh#473 PR2 — apply a named template to an existing cube via the
- * NON-CLOBBERING server route. New roles are inserted; existing
+ * Apply a named template through client-orchestrated, non-clobbering role and
+ * taxonomy primitives. New roles are inserted; existing
  * template-named roles get ADD fragments auto-applied (template
  * sections/classes the cube lacks) but their EVOLVED (conflicting)
- * fragments are surfaced server-side and KEPT, never overwritten. Returns
+ * fragments are kept, never overwritten. Primitive operations are sequential,
+ * so earlier changes may remain committed if a later operation fails. Returns
  * `{ created, updated }` counts. To selectively take template versions of
  * conflicting fragments, use `syncRoles` with a `decisions` map instead.
  */
@@ -1605,7 +1648,7 @@ export async function applyTemplate(
 }
 
 /**
- * gh#473 PR2 — NON-CLOBBERING sync of a cube's roles + message_taxonomy
+ * Client-orchestrated, non-clobbering sync of a cube's roles and taxonomy
  * against the current built-in template. Dry-run by default classifies
  * each fragment (role-text SECTION / short_description / flags / taxonomy
  * CLASS) as ADD / UNCHANGED / CONFLICT. Pass apply=true to commit:
@@ -1613,7 +1656,9 @@ export async function applyTemplate(
  * ONLY when their stable key appears in `decisions` as 'accept'.
  * Unspecified conflicts DEFAULT TO REJECT — the cube's evolved text is
  * never silently overwritten. Custom roles (names not in template) are
- * never touched. Returns a NonClobberSyncResult.
+ * never touched. Applied primitives are sequential rather than atomic, so an
+ * earlier operation may remain committed if a later operation fails. Returns a
+ * NonClobberSyncResult.
  */
 export async function syncRoles(
   cubeId: string,

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' };
+}