borgmcp 4.6.2 → 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,
@@ -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,
@@ -1257,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
@@ -1286,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,
@@ -1302,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/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(

package/src/repository-identity.ts

@@ -37,39 +37,132 @@ interface RepositoryIdentityState {
 }
 
 export interface RepositoryIdentityDeps {
-  runGit?: (cwd: string, args: string[]) => { status: number | null; stdout?: string | null };
+  runGit?: (cwd: string, args: string[]) => GitCommandResult;
   canonicalPath?: (path: string) => Promise<string>;
   root?: string;
 }
 
+interface GitCommandResult {
+  status: number | null;
+  stdout?: string | null;
+  stderr?: string | null;
+  error?: Error;
+}
+
+export class RepositoryDiscoveryError extends Error {
+  readonly name = 'RepositoryDiscoveryError';
+
+  constructor(
+    readonly kind: 'git-execution' | 'git-query' | 'canonical-path',
+    message: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+  }
+}
+
+export function repositoryDiscoveryFailureMessage(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/[\x00-\x1F\x7F]/g, '').trim() || 'Unknown repository discovery failure';
+}
+
 function defaultRunGit(cwd: string, args: string[]) {
-  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
-  return { status: result.status, stdout: result.stdout };
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    env: { ...process.env, LC_ALL: 'C' },
+  });
+  return { status: result.status, stdout: result.stdout, stderr: result.stderr, error: result.error };
 }
 
-function output(result: { status: number | null; stdout?: string | null }): string | null {
+function output(result: GitCommandResult): string | null {
   const value = result.status === 0 ? result.stdout?.trim() : null;
   return value || null;
 }
 
+function runGitForDiscovery(
+  runGit: NonNullable<RepositoryIdentityDeps['runGit']>,
+  cwd: string,
+  args: string[],
+): GitCommandResult {
+  let result: GitCommandResult;
+  try {
+    result = runGit(cwd, args);
+  } catch (cause) {
+    throw new RepositoryDiscoveryError(
+      'git-execution',
+      `Git repository discovery could not run: ${repositoryDiscoveryFailureMessage(cause)}`,
+      { cause },
+    );
+  }
+  if (result.error) {
+    throw new RepositoryDiscoveryError(
+      'git-execution',
+      `Git repository discovery could not run: ${repositoryDiscoveryFailureMessage(result.error)}`,
+      { cause: result.error },
+    );
+  }
+  return result;
+}
+
+function gitQueryFailure(label: string, result: GitCommandResult): RepositoryDiscoveryError {
+  const detail = (result.stderr ?? '').replace(/[\x00-\x1F\x7F]/g, '').trim();
+  const suffix = detail ? `: ${detail}` : ` (Git exited with status ${result.status ?? 'unknown'})`;
+  return new RepositoryDiscoveryError(
+    'git-query',
+    `Git repository discovery failed while querying ${label}${suffix}`,
+  );
+}
+
+async function canonicalizeRepositoryPath(
+  canonicalPath: NonNullable<RepositoryIdentityDeps['canonicalPath']>,
+  path: string,
+  label: string,
+): Promise<string> {
+  try {
+    return await canonicalPath(path);
+  } catch (cause) {
+    throw new RepositoryDiscoveryError(
+      'canonical-path',
+      `Could not resolve the ${label}: ${repositoryDiscoveryFailureMessage(cause)}`,
+      { cause },
+    );
+  }
+}
+
 export async function resolveGitRepositoryContext(
   cwd: string,
   deps: RepositoryIdentityDeps = {},
 ): Promise<GitRepositoryContext | null> {
   const runGit = deps.runGit ?? defaultRunGit;
   const canonicalPath = deps.canonicalPath ?? realpath;
-  const rootRaw = output(runGit(cwd, ['rev-parse', '--show-toplevel']));
-  if (!rootRaw || !isAbsolute(rootRaw)) return null;
-  const bare = output(runGit(cwd, ['rev-parse', '--is-bare-repository']));
+  const bareResult = runGitForDiscovery(runGit, cwd, ['rev-parse', '--is-bare-repository']);
+  if (bareResult.status !== 0) {
+    if (/not a git repository/i.test(bareResult.stderr ?? '')) return null;
+    throw gitQueryFailure('whether the repository is bare', bareResult);
+  }
+  const bare = output(bareResult);
   if (bare === 'true') throw new Error('BARE_REPOSITORY');
-  const commonRaw = output(runGit(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']));
-  if (!commonRaw || !isAbsolute(commonRaw)) return null;
-  const root = await canonicalPath(rootRaw);
-  const commonDir = await canonicalPath(commonRaw);
+  if (bare !== 'false') throw gitQueryFailure('whether the repository is bare', bareResult);
+
+  const rootResult = runGitForDiscovery(runGit, cwd, ['rev-parse', '--show-toplevel']);
+  const rootRaw = output(rootResult);
+  if (!rootRaw || !isAbsolute(rootRaw)) throw gitQueryFailure('the repository root', rootResult);
+
+  const commonResult = runGitForDiscovery(runGit, cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  const commonRaw = output(commonResult);
+  if (!commonRaw || !isAbsolute(commonRaw)) throw gitQueryFailure('the Git common directory', commonResult);
+
+  const root = await canonicalizeRepositoryPath(canonicalPath, rootRaw, 'repository root path');
+  const commonDir = await canonicalizeRepositoryPath(canonicalPath, commonRaw, 'Git common directory path');
   const derivedName = normalizeCubeName(basename(root));
   if (!derivedName) return null;
 
-  const originRaw = output(runGit(root, ['config', '--get', 'remote.origin.url']));
+  const originResult = runGitForDiscovery(runGit, root, ['config', '--get', 'remote.origin.url']);
+  if (originResult.status !== 0 && (originResult.status !== 1 || originResult.stderr?.trim())) {
+    throw gitQueryFailure('the origin remote', originResult);
+  }
+  const originRaw = output(originResult);
   const canonical = originRaw ? canonicalizeWorkingRepoIdentity(originRaw) : null;
   return {
     root,
@@ -94,8 +187,8 @@ function emptyState(): RepositoryIdentityState {
   return { version: STORE_VERSION, localIdentities: {}, associations: {} };
 }
 
-function parseState(raw: string | null): RepositoryIdentityState {
-  if (raw === null) return emptyState();
+function parseState(raw: string | null): { state: RepositoryIdentityState; migrated: boolean } {
+  if (raw === null) return { state: emptyState(), migrated: false };
   const parsed = JSON.parse(raw) as Partial<RepositoryIdentityState>;
   if (
     parsed.version !== STORE_VERSION ||
@@ -109,7 +202,9 @@ function parseState(raw: string | null): RepositoryIdentityState {
       throw new Error('Borg repository identity store is malformed or unsupported');
     }
   }
-  for (const [key, value] of Object.entries(parsed.associations)) {
+  let migrated = false;
+  for (const [key, rawAssociation] of Object.entries(parsed.associations)) {
+    const value = rawAssociation as Omit<Partial<RepositoryAssociation>, 'template'> & { template?: unknown };
     if (
       !/^[a-f0-9]{64}$/.test(key) ||
       !value || typeof value !== 'object' || Array.isArray(value) ||
@@ -117,13 +212,22 @@ function parseState(raw: string | null): RepositoryIdentityState {
       typeof value.name !== 'string' || Buffer.byteLength(value.name, 'utf8') > 120 ||
       !DISPLAY_NAME_RE.test(value.name) ||
       typeof value.workingRepoName !== 'string' || Buffer.byteLength(value.workingRepoName, 'utf8') > 120 ||
-      !DISPLAY_NAME_RE.test(value.workingRepoName) ||
-      !CUBE_TEMPLATES.some((template) => template === value.template)
+      !DISPLAY_NAME_RE.test(value.workingRepoName)
     ) {
       throw new Error('Borg repository identity store is malformed or unsupported');
     }
+    // Tag 12 persisted the removed legacy seed. Dropping only this valid
+    // association makes the caller re-resolve authoritative state from tag 13.
+    if (value.template === 'default') {
+      delete parsed.associations[key];
+      migrated = true;
+      continue;
+    }
+    if (!CUBE_TEMPLATES.some((template) => template === value.template)) {
+      throw new Error('Borg repository identity store is malformed or unsupported');
+    }
   }
-  return parsed as RepositoryIdentityState;
+  return { state: parsed as RepositoryIdentityState, migrated };
 }
 
 function digest(secret: Buffer, purpose: string, value: string): string {
@@ -145,9 +249,10 @@ async function withIdentityState<T>(
       await atomicWrite0600(secretPath, `${secret.toString('hex')}\n`, options);
     }
     const statePath = join(root, STATE_FILE);
-    const state = parseState(await readStoreFile(statePath, options));
+    const parsed = parseState(await readStoreFile(statePath, options));
+    const state = parsed.state;
     const outcome = await operation(secret, state);
-    if (outcome.changed) {
+    if (parsed.migrated || outcome.changed) {
       await atomicWrite0600(statePath, `${JSON.stringify(state, null, 2)}\n`, options);
     }
     return outcome.result;

package/src/self-path.ts

@@ -9,7 +9,6 @@
  * under `dist/`. All bin targets are siblings in the same `dist/` directory.
  */
 
-import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 

package/src/server-handshake.ts

@@ -89,7 +89,6 @@ import type { EnrollmentArtifactBinding } from './enrollment-types.js';
 const HANDSHAKE_BODY_LIMIT = 64 * 1024;
 const HANDSHAKE_TIMEOUT_MS = 5_000;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const CLIENT_ATTACH_PATH = '/api/client/attach';
 export const DEFAULT_LOCAL_SERVER_ORIGIN = 'https://127.0.0.1:7091' as const;
 
 type FetchLike = typeof fetch;
@@ -215,7 +214,7 @@ export interface ServerAttachResult {
 }
 
 /**
- * Attach an enrolled client principal to one granted cube/role over protocol v12.
+ * Attach an enrolled client principal to one granted cube/role over protocol v13.
  * The client CSPRNG-generates the session bearer and persists it PENDING in the
  * local 0600 credential store (keyed by the stable per-seat identity) BEFORE
  * this request, so an interrupted/lost response is recovered by re-sending the

package/src/tool-manifest.ts

@@ -452,8 +452,8 @@ const BASE_TOOL_MANIFEST: ToolManifestEntry[] = [
         {
           name: 'borg_create-cube',
           description:
-            'Create a new cube bound to an explicit repository. The server homes ONE cube per repository: if the given repository already has a cube, this reports that existing cube and leaves its directive unchanged (it never overwrites it). The server seeds a default "Drone" role atomically so a newly-created cube is assimilatable immediately. ' +
-            'Pass an optional `template` name to apply a richer role set instead (see borg_list-templates / borg_apply-template).',
+            'Create a new cube bound to an explicit repository. The server homes ONE cube per repository: if the given repository already has a cube, this reports that existing cube and leaves its directive unchanged (it never overwrites it). The server seeds the selected named template atomically; `software-dev` is selected by default. ' +
+            'Pass an optional `template` name to select another role set (see borg_list-templates / borg_apply-template).',
           inputSchema: {
             type: 'object',
             properties: {
@@ -476,7 +476,7 @@ const BASE_TOOL_MANIFEST: ToolManifestEntry[] = [
               },
               template: {
                 type: 'string',
-                description: 'Optional template name to apply after cube creation (e.g. "software-dev"). Roles are merged by name; the default Drone role gets overwritten by the template if a same-named role is in the template. Only applied when a cube is newly created — never to an already-existing repository cube.',
+                description: 'Optional named template (default: "software-dev"). The server seeds its roles atomically when a cube is newly created; it is never applied to an already-existing repository cube.',
               },
             },
             required: ['name', 'cube_directive', 'repository'],

package/src/unknown-subcommand.ts

@@ -15,6 +15,7 @@
 export const KNOWN_SUBCOMMANDS = [
   'setup',
   'update',
+  'upgrade',
   'doctor',
   'clone',
   'quickstart',

package/src/update-cmd.ts

@@ -1370,7 +1370,7 @@ export async function runEarlyUpdate(
   argv: readonly string[],
   deps?: UpdateDeps,
 ): Promise<number | null> {
-  if (argv[2] !== 'update') return null;
+  if (argv[2] !== 'update' && argv[2] !== 'upgrade') return null;
   const parsed = parseUpdateArgs(argv.slice(3), process.env[REENTRY_ENV] === '1');
   const resolvedDeps = deps ?? buildDefaultUpdateDeps(parsed.ok ? parsed.registry : undefined);
   if (!parsed.ok) {

package/dist/postinstall-banner.d.ts

@@ -1,2 +0,0 @@
-export declare function composeInstallBanner(hasAgentCli: boolean): string;
-//# sourceMappingURL=postinstall-banner.d.ts.map

package/dist/postinstall-banner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postinstall-banner.d.ts","sourceRoot":"","sources":["../src/postinstall-banner.ts"],"names":[],"mappings":"AAWA,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,OAAO,GAAG,MAAM,CAyBjE"}

package/dist/postinstall-banner.js

@@ -1,27 +0,0 @@
-// Pure builder for the post-install banner text. Kept separate from
-// postinstall.ts (which is a side-effectful entry script that runs detection
-// + console output + process.exit on import) so the message content is unit-
-// testable without triggering those side effects.
-//
-// gh#653 B1: a non-expert who installs borgmcp WITHOUT an agent CLI (Claude
-// Code / Codex) present would otherwise be sent straight to "Next step: borg
-// setup", which dead-ends at "No supported agent CLI found". When no agent CLI
-// is detected, surface the install-an-agent-CLI step FIRST so the banner never
-// points the user into a wall.
-export function composeInstallBanner(hasAgentCli) {
-    const lines = [
-        '',
-        '╔════════════════════════════════════╗',
-        '║       ◼ Borg MCP Installed ◼       ║',
-        '╚════════════════════════════════════╝',
-        '',
-    ];
-    if (!hasAgentCli) {
-        lines.push('⚠ No agent CLI detected. Borg runs on top of Claude Code or Codex —', '  install one first:', '    Claude Code: https://claude.ai/download', '    Codex:       https://developers.openai.com/codex', '', 'Then run:', '  borg setup', '');
-    }
-    else {
-        lines.push('Next step:', '  borg setup', '');
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=postinstall-banner.js.map

package/dist/postinstall-banner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"postinstall-banner.js","sourceRoot":"","sources":["../src/postinstall-banner.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,6EAA6E;AAC7E,6EAA6E;AAC7E,kDAAkD;AAClD,EAAE;AACF,4EAA4E;AAC5E,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,+BAA+B;AAE/B,MAAM,UAAU,oBAAoB,CAAC,WAAoB;IACvD,MAAM,KAAK,GAAG;QACZ,EAAE;QACF,wCAAwC;QACxC,wCAAwC;QACxC,wCAAwC;QACxC,EAAE;KACH,CAAC;IAEF,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,KAAK,CAAC,IAAI,CACR,qEAAqE,EACrE,sBAAsB,EACtB,6CAA6C,EAC7C,sDAAsD,EACtD,EAAE,EACF,WAAW,EACX,cAAc,EACd,EAAE,CACH,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/postinstall.d.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-/**
- * Post-install script
- *
- * Detects local vs global installation and rejects local installs.
- * gh#653 B1: also detects whether an agent CLI (Claude Code / Codex) is present
- * and adjusts the "next step" banner so a user with no agent CLI is told to
- * install one FIRST rather than being sent into `borg setup`'s dead-end.
- */
-export {};
-//# sourceMappingURL=postinstall.d.ts.map