Fix peer-remote detection + pin DreamNode branch to main

Two related cross-machine bugs surfaced by the reverse-direction
(Windows-initiates) demo:

1. GitSyncService only recognized peer remotes whose URL was rad:// or
   interbrain://. But the clone-accept sovereignty handover renames the
   cloned origin to a peer remote keeping git's NATIVE https:// URL —
   so "Check for Updates" reported "No peer remotes found" and never
   fetched the peer's beacon. Fixed: a peer remote is simply any remote
   that isn't `origin`. The interbrain:// scheme is for .gitmodules
   (shared, portable content needing UUID indirection), not local
   remote config which is already concrete.

2. DreamNode creation did `git init` with no -b flag, inheriting the
   user's init.defaultBranch. Windows machines often still default to
   `master`; Mac to `main`. A master DreamNode and a main one can't see
   each other's commits. Fixed: all four `git init` call sites now use
   `git -c init.defaultBranch=main init`.

#76 (auto-link), #81 (branch pin) — #81 resolved here; #80, #78, #79
still pending for the next rc.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ProjectLiminality

src/features/dreamnode/services/dreamnode-conversion-service.ts

@@ -267,7 +267,9 @@ export class DreamNodeConversionService {
       'dreamnode',
       'DreamNode-template'
     );
-    await execAsync(`git init --template="${templatePath}" "${folderPath}"`);
+    // Pin default branch to `main` (the user's git config may default to
+    // `master`, which breaks peer fetch — see git-dreamnode-service.ts).
+    await execAsync(`git -c init.defaultBranch=main init --template="${templatePath}" "${folderPath}"`);
 
     // Make hooks executable (no-op on Windows; Git for Windows runs
     // `#!/bin/sh` hooks regardless of the +x bit).

src/features/dreamnode/services/git-dreamnode-service.ts

@@ -480,8 +480,12 @@ export class GitDreamNodeService {
       // Create directory
       await fsPromises.mkdir(repoPath, { recursive: true });
 
-      // Initialize git with template
-      await execAsync(`git init --template="${this.templatePath}" "${repoPath}"`);
+      // Initialize git with template. Pin the default branch to `main`
+      // via `-c init.defaultBranch=main` — the user's git config may
+      // still default to `master` (pre-2.28 git, or never changed),
+      // which would break peer fetch: a `master` DreamNode and a `main`
+      // one can't see each other's commits.
+      await execAsync(`git -c init.defaultBranch=main init --template="${this.templatePath}" "${repoPath}"`);
 
       // Make sure git can attribute the initial commit. Fresh Windows installs
       // usually have no global user.{name,email}; without these, `git commit`

src/features/dreamnode/utils/git-utils.ts

@@ -234,10 +234,13 @@ export async function commitAllChanges(repoPath: string, commitMessage: string):
  */
 export async function initRepo(repoPath: string, templatePath?: string): Promise<void> {
   try {
+    // `-c init.defaultBranch=main` pins the branch regardless of the
+    // user's git config (which may still default to `master`). A master
+    // DreamNode and a main one can't see each other's commits on fetch.
     if (templatePath) {
-      await execAsync(`git init --template="${templatePath}"`, { cwd: repoPath });
+      await execAsync(`git -c init.defaultBranch=main init --template="${templatePath}"`, { cwd: repoPath });
     } else {
-      await execAsync('git init', { cwd: repoPath });
+      await execAsync('git -c init.defaultBranch=main init', { cwd: repoPath });
     }
   } catch (error) {
     throw new Error(`Failed to init repo: ${error instanceof Error ? error.message : 'Unknown error'}`);

src/features/dreamnode/utils/repo-initializer.ts

@@ -45,7 +45,9 @@ export async function createRepoDirectory(repoPath: string): Promise<void> {
  * Initialize a git repository with a template
  */
 export async function initGitWithTemplate(repoPath: string, templatePath: string): Promise<void> {
-  await execAsync(`git init --template="${templatePath}" "${repoPath}"`);
+  // Pin default branch to `main` — see git-dreamnode-service.ts for why
+  // (peer fetch breaks when a master DreamNode meets a main one).
+  await execAsync(`git -c init.defaultBranch=main init --template="${templatePath}" "${repoPath}"`);
 
   // Make hooks executable (no-op on Windows; Git for Windows runs
   // `#!/bin/sh` hooks regardless of the +x bit).

src/features/social-resonance-filter/services/git-sync-service.ts

@@ -189,20 +189,27 @@ export class GitSyncService {
         throw fetchError;
       }
 
-      // ALSO fetch from peer remotes (for pure p2p collaboration)
+      // ALSO fetch from peer remotes (for pure p2p collaboration).
+      //
+      // A peer remote is simply "any remote that isn't `origin`". `origin`
+      // is the user's own sovereign outbox; every other remote is a peer
+      // whose version we may want to pull from. We do NOT sniff for a URL
+      // scheme: peer remotes are plain `https://github.com/...` URLs (the
+      // clone-accept sovereignty handover renames the cloned origin to a
+      // peer remote, keeping git's native URL). The `interbrain://` scheme
+      // is reserved for `.gitmodules` — shared, portable content that
+      // needs UUID indirection — not for local remote config, which is
+      // already concrete.
       console.log(`GitSyncService: Checking for peer remotes...`);
       const { stdout: remoteVerbose } = await execAsync('git remote -v', { cwd: fullPath });
       const peerRemotes = new Set<string>();
 
-      // Match either legacy rad:// URLs or v0.16+ interbrain:// URLs.
-      // Both are peer remotes; both go through the appropriate transport.
-      const peerRemoteRegex = /^(\S+)\s+(rad:\/\/\S+|interbrain:\/\/\S+)/;
+      // `git remote -v` lines: "<name>\t<url> (fetch|push)"
       for (const line of remoteVerbose.split('\n')) {
-        const match = line.match(peerRemoteRegex);
+        const match = line.match(/^(\S+)\s+\S+\s+\((?:fetch|push)\)$/);
         if (match) {
           const peerName = match[1];
-          // Skip `origin` if it happens to match (it shouldn't, but be safe).
-          if (peerName === 'origin') continue;
+          if (peerName === 'origin') continue; // origin = own outbox, not a peer
           peerRemotes.add(peerName);
         }
       }