Support Radicle as canonical workspace org

Author: Hex

README.md

@@ -16,7 +16,7 @@ Sovereign is built on a handful of non-negotiable ideas:
 
 ### Orgs & Projects
 
-Multi-org workspace with shared context across projects. Each org contains git repositories as first-class projects with branches, worktrees, and cross-project synchronisation. A global workspace spans all orgs for personal notes, memory, and coordination.
+Multi-org workspace with shared context across projects. Each org is the canonical workspace membrane and contains git repositories as first-class projects with branches, worktrees, and cross-project synchronisation. Projects can expose multiple remotes (for example Radicle as canonical plus secondary GitHub remotes) without forcing a 1:1 mapping between workspace orgs and GitHub orgs. A global workspace spans all orgs for personal notes, memory, and coordination.
 
 ### Code
 

packages/server/src/drafts/routes.test.ts

@@ -271,6 +271,24 @@ describe('Draft REST API', () => {
       expect(callArgs[2].title).toBe('My Issue')
     })
 
+    it('4.1 MUST publish to the canonical remote when Radicle is ordered first', async () => {
+      const issueTracker = createMockIssueTracker()
+      const getRemotes = vi.fn().mockReturnValue([
+        { name: 'rad', provider: 'radicle' },
+        { name: 'origin', provider: 'github' }
+      ])
+      const { app, store } = createApp(dataDir, { issueTracker, getRemotes })
+      const draft = store.create({ title: 'My Radicle Issue' })
+
+      await request(app).post(`/api/drafts/${draft.id}/publish`).send({ orgId: 'org1', projectId: 'proj1' })
+
+      expect(issueTracker.create).toHaveBeenCalledWith(
+        'org1',
+        'proj1',
+        expect.objectContaining({ remote: 'rad', title: 'My Radicle Issue' })
+      )
+    })
+
     it('4.1 MUST set draft status to published and set publishedAs', async () => {
       const { app, store } = createApp(dataDir)
       const draft = store.create({ title: 'Test' })

packages/server/src/index.ts

@@ -59,6 +59,7 @@ import { createReviewSystem } from './review/review.js'
 import { createReviewRouter } from './review/routes.js'
 import { createRadicleManager } from './radicle/radicle.js'
 import { createRadicleRouter } from './radicle/routes.js'
+import { orderRemotes, parseGitRemotes } from './remotes/discovery.js'
 
 // --- Phase 5: Planning ---
 import { createPlanningService } from './planning/planning.js'
@@ -254,8 +255,10 @@ function getRemotes(
     projectId?: string
   }> = []
 
+  const org = orgManager.getOrg(orgId)
+
   // Determine which projects to scan
-  let projects: Array<{ id: string; repoPath: string }> = []
+  let projects: Array<{ id: string; repoPath: string; remote?: string }> = []
   if (projectId) {
     const project = orgManager.getProject(orgId, projectId)
     if (project) projects = [project]
@@ -269,55 +272,17 @@ function getRemotes(
   }
 
   for (const project of projects) {
-    const remotes = parseGitRemotes(project.repoPath)
+    const remotes = orderRemotes(parseGitRemotes(project.repoPath), {
+      preferredRemoteName: project.remote,
+      preferredProvider: org?.provider
+    })
     for (const remote of remotes) {
       allRemotes.push({ ...remote, projectId: project.id })
     }
   }
 
   return allRemotes
 }
-
-function parseGitRemotes(
-  repoPath: string
-): Array<{ name: string; provider: 'github' | 'radicle'; repo?: string; rid?: string }> {
-  try {
-    const gitConfigPath = path.join(repoPath, '.git', 'config')
-    if (!fs.existsSync(gitConfigPath)) return []
-    const config = fs.readFileSync(gitConfigPath, 'utf-8')
-    const remotes: Array<{ name: string; provider: 'github' | 'radicle'; repo?: string; rid?: string }> = []
-
-    const remoteRegex = /\[remote\s+"([^"]+)"\]\s*\n([\s\S]*?)(?=\n\[|\n*$)/g
-    let match
-    while ((match = remoteRegex.exec(config)) !== null) {
-      const remoteName = match[1]
-      const section = match[2]
-      const urlMatch = section.match(/url\s*=\s*(.+)/)
-      if (!urlMatch) continue
-      const url = urlMatch[1].trim()
-
-      // GitHub: git@github.com:owner/repo.git or https://github.com/owner/repo.git
-      const ghSsh = url.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?\/?$/)
-      const ghHttps = url.match(/github\.com\/([^/]+\/[^/.]+?)(?:\.git)?\/?$/)
-      if (ghSsh || ghHttps) {
-        const repo = (ghSsh || ghHttps)![1]
-        remotes.push({ name: remoteName, provider: 'github', repo })
-        continue
-      }
-
-      // Radicle: rad:z... or similar
-      const radMatch = url.match(/^rad:(.+)$/)
-      if (radMatch) {
-        remotes.push({ name: remoteName, provider: 'radicle', rid: radMatch[1] })
-        continue
-      }
-    }
-
-    return remotes
-  } catch {
-    return []
-  }
-}
 const issueTracker = createIssueTracker(bus, dataDir, getRemotes)
 app.use(createIssueRouter(issueTracker))
 

packages/server/src/orgs/orgs.test.ts

@@ -20,6 +20,12 @@ function fakeGitRepo(base: string, name: string = 'repo'): string {
   return p
 }
 
+function fakeGitRepoWithConfig(base: string, name: string, config: string): string {
+  const p = fakeGitRepo(base, name)
+  fs.writeFileSync(path.join(p, '.git', 'config'), config)
+  return p
+}
+
 let dataDir: string
 let tempBase: string
 let bus: ReturnType<typeof createEventBus>
@@ -128,6 +134,18 @@ describe('Org Manager', () => {
     expect(updated.name).toBe('renamed')
   })
 
+  it('derives project preferred remote from canonical org provider when remotes are discovered', () => {
+    const org = manager.createOrg({ name: 'Test', path: tempBase, provider: 'radicle' })
+    const repo = fakeGitRepoWithConfig(
+      tempBase,
+      'repo-with-remotes',
+      `[remote "origin"]\n  url = git@github.com:secondary/repo.git\n[remote "rad"]\n  url = rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5\n`
+    )
+
+    const project = manager.addProject(org.id, { name: 'proj', repoPath: repo })
+    expect(project.remote).toBe('rad')
+  })
+
   it('removes a project from an org', () => {
     const org = manager.createOrg({ name: 'Test', path: tempBase })
     const repo = fakeGitRepo(tempBase)

packages/server/src/orgs/orgs.ts

@@ -5,6 +5,7 @@ import type { EventBus } from '@sovereign/core'
 import type { Org, Project } from './types.js'
 import { createOrgStore, type OrgStore, type OrgStoreData } from './store.js'
 import { detectMonorepo } from './monorepo.js'
+import { getProjectPreferredRemote } from '../remotes/discovery.js'
 
 export interface OrgManager {
   createOrg(data: { id?: string; name: string; path: string; provider?: 'radicle' | 'github' }): Org
@@ -109,11 +110,13 @@ export function createOrgManager(bus: EventBus, dataDir: string): OrgManager {
     if (existing) throw new Error(`repoPath already belongs to org ${existing.orgId}`)
 
     const mono = detectMonorepo(data.repoPath)
+    const org = getOrg(orgId)
     const project: Project = {
       id: id(),
       orgId,
       name: data.name,
       repoPath: data.repoPath,
+      remote: getProjectPreferredRemote(org, undefined, data.repoPath),
       defaultBranch: 'main',
       monorepo: mono || undefined,
       createdAt: now(),

packages/server/src/remotes/discovery.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest'
+import { orderRemotes, selectPreferredRemote } from './discovery.js'
+import type { Remote } from '../issues/types.js'
+
+describe('remote discovery ordering', () => {
+  const remotes: Remote[] = [
+    { name: 'origin', provider: 'github', repo: 'secondary/repo' },
+    { name: 'rad', provider: 'radicle', rid: 'z3gqcJUoA1n9HaHKufZs5FCSGazv5' }
+  ]
+
+  it('prefers explicit project remote over provider ordering', () => {
+    const ordered = orderRemotes(remotes, { preferredRemoteName: 'origin', preferredProvider: 'radicle' })
+    expect(ordered.map((remote) => remote.name)).toEqual(['origin', 'rad'])
+  })
+
+  it('prefers canonical provider when no explicit project remote is set', () => {
+    const ordered = orderRemotes(remotes, { preferredProvider: 'radicle' })
+    expect(ordered.map((remote) => remote.name)).toEqual(['rad', 'origin'])
+  })
+
+  it('selects canonical provider remote for default write flows', () => {
+    const selected = selectPreferredRemote(remotes, { preferredProvider: 'radicle' })
+    expect(selected?.name).toBe('rad')
+  })
+})

packages/server/src/remotes/discovery.ts

@@ -0,0 +1,75 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { Org, Project } from '../orgs/types.js'
+import type { Remote } from '../issues/types.js'
+
+export function parseGitRemotes(repoPath: string): Remote[] {
+  try {
+    const gitConfigPath = path.join(repoPath, '.git', 'config')
+    if (!fs.existsSync(gitConfigPath)) return []
+    const config = fs.readFileSync(gitConfigPath, 'utf-8')
+    const remotes: Remote[] = []
+
+    const remoteRegex = /\[remote\s+"([^"]+)"\]\s*\n([\s\S]*?)(?=\n\[|\n*$)/g
+    let match: RegExpExecArray | null
+
+    while ((match = remoteRegex.exec(config)) !== null) {
+      const remoteName = match[1]
+      const section = match[2]
+      const urlMatch = section?.match(/url\s*=\s*(.+)/)
+      if (!urlMatch) continue
+      const url = urlMatch[1].trim()
+
+      const ghSsh = url.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?\/?$/)
+      const ghHttps = url.match(/github\.com\/([^/]+\/[^/.]+?)(?:\.git)?\/?$/)
+      if (ghSsh || ghHttps) {
+        remotes.push({ name: remoteName, provider: 'github', repo: (ghSsh || ghHttps)![1] })
+        continue
+      }
+
+      const radMatch = url.match(/^rad:(.+)$/)
+      if (radMatch) {
+        remotes.push({ name: remoteName, provider: 'radicle', rid: radMatch[1] })
+      }
+    }
+
+    return remotes
+  } catch {
+    return []
+  }
+}
+
+export function orderRemotes(
+  remotes: Remote[],
+  opts?: { preferredRemoteName?: string; preferredProvider?: Org['provider'] }
+): Remote[] {
+  if (remotes.length <= 1) return [...remotes]
+
+  const preferredByName = opts?.preferredRemoteName ? remotes.findIndex((r) => r.name === opts.preferredRemoteName) : -1
+  const preferredIndex =
+    preferredByName >= 0 ? preferredByName : remotes.findIndex((r) => r.provider === opts?.preferredProvider)
+
+  if (preferredIndex <= 0) return [...remotes]
+
+  const preferred = remotes[preferredIndex]!
+  return [preferred, ...remotes.slice(0, preferredIndex), ...remotes.slice(preferredIndex + 1)]
+}
+
+export function selectPreferredRemote(
+  remotes: Remote[],
+  opts?: { preferredRemoteName?: string; preferredProvider?: Org['provider'] }
+): Remote | undefined {
+  return orderRemotes(remotes, opts)[0]
+}
+
+export function getProjectPreferredRemote(
+  org: Org | undefined,
+  project: Pick<Project, 'remote'> | undefined,
+  repoPath: string
+): string | undefined {
+  const remotes = parseGitRemotes(repoPath)
+  return selectPreferredRemote(remotes, {
+    preferredRemoteName: project?.remote,
+    preferredProvider: org?.provider
+  })?.name
+}