@loicngr/kobo 1.7.1 → 1.7.3

package/dist/server/services/pr-watcher-service.js

@@ -2,7 +2,7 @@ import { getPrStatusAsync } from '../utils/git-ops.js';
 import { stopDevServer } from './dev-server-service.js';
 import { destroyTerminal } from './terminal-service.js';
 import { emitEphemeral } from './websocket-service.js';
-import { archiveWorkspace, listWorkspaces } from './workspace-service.js';
+import { archiveWorkspace, listWorkspaces, updateWorkspaceSourceBranch } from './workspace-service.js';
 // ── PR Watcher ────────────────────────────────────────────────────────────────
 // Polls GitHub every POLL_INTERVAL_MS to detect merged/closed PRs and
 // automatically archive the corresponding workspace.
@@ -14,8 +14,7 @@ import { archiveWorkspace, listWorkspaces } from './workspace-service.js';
 const POLL_INTERVAL_MS = 30 * 1000; // 30 seconds
 let timer = null;
 let checking = false;
-/** Tracks the last known PR state per workspace to detect transitions. */
-const lastKnownState = new Map();
+const lastKnownPr = new Map();
 /**
  * Read-only snapshot of PR states known to the watcher, keyed by workspace id.
  * Used by the drawer to show a small PR-open indicator without N separate
@@ -25,17 +24,24 @@ const lastKnownState = new Map();
  */
 export function getAllPrStates() {
     const out = {};
-    for (const [id, state] of lastKnownState) {
-        out[id] = state;
+    for (const [id, known] of lastKnownPr) {
+        out[id] = known.state;
     }
     return out;
 }
-async function checkPrStatuses() {
+/**
+ * Test-only escape hatch — drops the in-memory cache so each test starts
+ * from a clean slate. Not part of the public API.
+ */
+export function _resetForTest() {
+    lastKnownPr.clear();
+}
+export async function checkPrStatuses() {
     const workspaces = listWorkspaces(false); // non-archived only
     // Clean up entries for workspaces that no longer exist
-    for (const id of lastKnownState.keys()) {
+    for (const id of lastKnownPr.keys()) {
         if (!workspaces.some((ws) => ws.id === id)) {
-            lastKnownState.delete(id);
+            lastKnownPr.delete(id);
         }
     }
     for (const ws of workspaces) {
@@ -46,10 +52,15 @@ async function checkPrStatuses() {
             const pr = await getPrStatusAsync(ws.projectPath, ws.workingBranch);
             if (!pr)
                 continue;
-            const prev = lastKnownState.get(ws.id);
-            lastKnownState.set(ws.id, pr.state);
-            // Only archive on a transition FROM OPEN — not on first sight of CLOSED/MERGED
-            if (prev === 'OPEN' && (pr.state === 'MERGED' || pr.state === 'CLOSED')) {
+            const prev = lastKnownPr.get(ws.id);
+            // We delay updating `lastKnownPr` until after the actions succeed.
+            // Setting it eagerly would poison the cache: if updateWorkspaceSourceBranch
+            // throws (transient DB issue, race with workspace deletion), the cache
+            // already holds the new base and the user never sees the toast — the
+            // next tick computes `prev.base === pr.base` and treats it as no-op.
+            // Archive on a transition FROM OPEN to CLOSED/MERGED. Skips the
+            // base-change detection below — archiving wins.
+            if (prev?.state === 'OPEN' && (pr.state === 'MERGED' || pr.state === 'CLOSED')) {
                 console.log(`[pr-watcher] PR ${pr.state.toLowerCase()} for workspace '${ws.name}' — archiving`);
                 // Best-effort cleanup (same as manual archive): stop dev server + terminal.
                 // Agent is already not running here (guarded above).
@@ -66,12 +77,51 @@ async function checkPrStatuses() {
                     // Terminal may not exist — ignore
                 }
                 archiveWorkspace(ws.id);
-                lastKnownState.delete(ws.id);
+                lastKnownPr.delete(ws.id);
                 emitEphemeral(ws.id, 'workspace:archived', {
                     reason: `PR ${pr.state.toLowerCase()}`,
                     prUrl: pr.url,
                 });
+                continue; // do not run base-change detection on a workspace we just archived
+            }
+            // Base-branch change detection. Only relevant for OPEN PRs — closed/
+            // merged PRs don't accept base changes. Skip if the GitHub response
+            // didn't include a baseRefName (defensive against malformed data).
+            if (pr.state !== 'OPEN' || !pr.base) {
+                // Still update the cache for the state — keeps the OPEN→CLOSED/MERGED
+                // archiving logic working on the next tick.
+                lastKnownPr.set(ws.id, { state: pr.state, base: prev?.base });
+                continue;
+            }
+            // Comparison baseline:
+            //  - If we've seen this workspace before, use the previous `base`.
+            //  - Otherwise (first sight after boot/unarchive), compare with the
+            //    `sourceBranch` recorded in the database — that catches base changes
+            //    that happened while Kobo was offline.
+            const previousBase = prev?.base ?? ws.sourceBranch;
+            if (previousBase === pr.base) {
+                // No-op path: still record the base so subsequent ticks have a baseline.
+                lastKnownPr.set(ws.id, { state: pr.state, base: pr.base });
+                continue;
+            }
+            console.log(`[pr-watcher] PR base changed for workspace '${ws.name}': ${previousBase} → ${pr.base}`);
+            try {
+                updateWorkspaceSourceBranch(ws.id, pr.base);
+            }
+            catch (err) {
+                console.error(`[pr-watcher] updateWorkspaceSourceBranch failed for '${ws.name}':`, err instanceof Error ? err.message : err);
+                // Don't poison the cache: leave the previous entry (or absence) so
+                // the next tick retries the detection.
+                continue;
             }
+            // Both the persistence and the emit are part of "we successfully
+            // observed a base change" — only NOW commit the new state to the cache.
+            lastKnownPr.set(ws.id, { state: pr.state, base: pr.base });
+            emitEphemeral(ws.id, 'pr:base-changed', {
+                oldBase: previousBase,
+                newBase: pr.base,
+                prUrl: pr.url,
+            });
         }
         catch (err) {
             console.error(`[pr-watcher] Failed to check PR for workspace '${ws.name}':`, err instanceof Error ? err.message : err);

package/dist/server/services/review-template-service.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+export const DEFAULT_REVIEW_PROMPT_TEMPLATE = `You are reviewing code changes on workspace "{{workspace_name}}" in project {{project_name}}.
+
+Branch: {{branch_name}}  (base: {{source_branch}})
+Base commit: {{base_commit}}
+
+If a code-review skill is available (e.g. superpowers:requesting-code-review), invoke it to drive this review. Otherwise follow the steps below directly.
+
+## Scope
+
+Review ALL changes — both committed and uncommitted in the working tree:
+- \`git diff {{base_commit}}..HEAD\` — committed changes on this branch
+- \`git status\` and \`git diff\` — uncommitted changes (staged + unstaged)
+
+## Diff summary
+{{diff_stats}}
+
+## Commits
+{{commits}}
+
+## Additional instructions
+{{additional_instructions}}
+
+## Output
+
+If no review skill is available, structure your reply as:
+1. Summary — what changed and why
+2. Issues — bugs, regressions, security or perf concerns (with file:line)
+3. Suggestions — refactor / improvement opportunities
+4. Tests — coverage gaps
+5. Verdict — ship / fix-then-ship / blocked
+`;
+function buildVariableMap(ctx) {
+    return {
+        project_name: path.basename(ctx.workspace.projectPath),
+        workspace_name: ctx.workspace.name,
+        branch_name: ctx.workspace.workingBranch,
+        source_branch: ctx.workspace.sourceBranch,
+        base_commit: ctx.baseCommit,
+        commits: ctx.commits,
+        diff_stats: ctx.diffStats,
+        notion_url: ctx.workspace.notionUrl ?? '',
+        additional_instructions: ctx.additionalInstructions.length > 0 ? ctx.additionalInstructions : '(none)',
+    };
+}
+/**
+ * Render a review prompt template by substituting {{variable}} placeholders.
+ * Pure: no I/O, no side effects. Unknown variables are left intact.
+ */
+export function renderReviewTemplate(template, ctx) {
+    const vars = buildVariableMap(ctx);
+    return template.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+        if (Object.hasOwn(vars, name)) {
+            return vars[name];
+        }
+        return match;
+    });
+}

package/dist/server/services/settings-service.js

@@ -4,7 +4,9 @@ import { WORKTREES_PATH } from '../../shared/consts.js';
 import { listClaudeMcpEntries } from '../utils/mcp-client.js';
 import { getSettingsPath } from '../utils/paths.js';
 import { InvalidWorktreesPathError, resolveGlobalWorktreesRoot, sanitizeWorktreesPath, validateWorktreesPath, } from '../utils/worktree-paths.js';
-const DEFAULT_GIT_CONVENTIONS = `# Git conventions
+import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT } from './initial-prompt-template-service.js';
+import { DEFAULT_REVIEW_PROMPT_TEMPLATE } from './review-template-service.js';
+export const DEFAULT_GIT_CONVENTIONS = `# Git conventions
 
 ## Commits
 - Use Conventional Commits: \`type(scope): subject\`
@@ -29,7 +31,7 @@ const DEFAULT_GIT_CONVENTIONS = `# Git conventions
 - Never skip hooks (--no-verify) unless the user explicitly asks
 - Always inspect \`git status\` and \`git diff\` before staging
 `;
-const DEFAULT_PR_PROMPT_TEMPLATE = `A pull request has been opened: {{pr_url}} (#{{pr_number}})
+export const DEFAULT_PR_PROMPT_TEMPLATE = `A pull request has been opened: {{pr_url}} (#{{pr_number}})
 
 Context:
 - Workspace: {{workspace_name}}
@@ -200,6 +202,68 @@ const settingsMigrations = [
             global.worktreesPath = sanitizeWorktreesPath(global.worktreesPath);
         },
     },
+    {
+        version: 12,
+        name: 'add-audio-notification-sound',
+        migrate({ global }) {
+            if (typeof global.audioNotificationSound !== 'string' || global.audioNotificationSound.length === 0) {
+                global.audioNotificationSound = 'hey.mp3';
+            }
+        },
+    },
+    {
+        version: 13,
+        name: 'add-audio-notification-volume',
+        migrate({ global }) {
+            const v = global.audioNotificationVolume;
+            if (typeof v !== 'number' || Number.isNaN(v) || v < 0 || v > 1) {
+                global.audioNotificationVolume = 1;
+            }
+        },
+    },
+    {
+        version: 14,
+        name: 'add-worktrees-prefix-by-project',
+        migrate({ global }) {
+            if (typeof global.worktreesPrefixByProject !== 'boolean') {
+                global.worktreesPrefixByProject = false;
+            }
+        },
+    },
+    {
+        version: 15,
+        name: 'add-review-prompt-template',
+        migrate({ global, projects }) {
+            if (typeof global.reviewPromptTemplate !== 'string') {
+                global.reviewPromptTemplate = DEFAULT_REVIEW_PROMPT_TEMPLATE;
+            }
+            for (const p of projects) {
+                if (typeof p.reviewPromptTemplate !== 'string') {
+                    p.reviewPromptTemplate = '';
+                }
+            }
+        },
+    },
+    {
+        version: 16,
+        name: 'add-notion-sentry-initial-prompts',
+        migrate({ global, projects }) {
+            if (typeof global.notionInitialPromptTemplate !== 'string') {
+                global.notionInitialPromptTemplate = DEFAULT_NOTION_INITIAL_PROMPT;
+            }
+            if (typeof global.sentryInitialPromptTemplate !== 'string') {
+                global.sentryInitialPromptTemplate = DEFAULT_SENTRY_INITIAL_PROMPT;
+            }
+            for (const p of projects) {
+                if (typeof p.notionInitialPromptTemplate !== 'string') {
+                    p.notionInitialPromptTemplate = '';
+                }
+                if (typeof p.sentryInitialPromptTemplate !== 'string') {
+                    p.sentryInitialPromptTemplate = '';
+                }
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -230,10 +294,15 @@ function defaultSettings() {
             defaultModel: 'claude-opus-4-7',
             dangerouslySkipPermissions: true,
             prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
+            reviewPromptTemplate: DEFAULT_REVIEW_PROMPT_TEMPLATE,
+            notionInitialPromptTemplate: DEFAULT_NOTION_INITIAL_PROMPT,
+            sentryInitialPromptTemplate: DEFAULT_SENTRY_INITIAL_PROMPT,
             gitConventions: DEFAULT_GIT_CONVENTIONS,
             editorCommand: '',
             browserNotifications: true,
             audioNotifications: true,
+            audioNotificationSound: 'hey.mp3',
+            audioNotificationVolume: 1,
             notionStatusProperty: '',
             notionInProgressStatus: '',
             defaultPermissionMode: 'plan',
@@ -241,6 +310,7 @@ function defaultSettings() {
             sentryMcpKey: '',
             tags: [...DEFAULT_WORKSPACE_TAGS],
             worktreesPath: WORKTREES_PATH,
+            worktreesPrefixByProject: false,
         },
         projects: [],
     };
@@ -253,6 +323,9 @@ function defaultProjectSettings(projectPath) {
         defaultModel: '',
         dangerouslySkipPermissions: true,
         prPromptTemplate: '',
+        reviewPromptTemplate: '',
+        notionInitialPromptTemplate: '',
+        sentryInitialPromptTemplate: '',
         gitConventions: '',
         setupScript: '',
         devServer: {
@@ -426,6 +499,9 @@ export function getEffectiveSettings(projectPath) {
             model: settings.global.defaultModel,
             dangerouslySkipPermissions: settings.global.dangerouslySkipPermissions,
             prPromptTemplate: settings.global.prPromptTemplate,
+            reviewPromptTemplate: settings.global.reviewPromptTemplate,
+            notionInitialPromptTemplate: settings.global.notionInitialPromptTemplate,
+            sentryInitialPromptTemplate: settings.global.sentryInitialPromptTemplate,
             gitConventions: settings.global.gitConventions,
             sourceBranch: '',
             devServer: null,
@@ -438,6 +514,9 @@ export function getEffectiveSettings(projectPath) {
         model: project.defaultModel || settings.global.defaultModel,
         dangerouslySkipPermissions: project.dangerouslySkipPermissions ?? settings.global.dangerouslySkipPermissions,
         prPromptTemplate: project.prPromptTemplate || settings.global.prPromptTemplate,
+        reviewPromptTemplate: project.reviewPromptTemplate || settings.global.reviewPromptTemplate,
+        notionInitialPromptTemplate: project.notionInitialPromptTemplate || settings.global.notionInitialPromptTemplate,
+        sentryInitialPromptTemplate: project.sentryInitialPromptTemplate || settings.global.sentryInitialPromptTemplate,
         gitConventions: project.gitConventions || settings.global.gitConventions,
         sourceBranch: project.defaultSourceBranch,
         devServer: project.devServer,
@@ -453,10 +532,15 @@ export function updateGlobalSettings(data) {
         'defaultModel',
         'dangerouslySkipPermissions',
         'prPromptTemplate',
+        'reviewPromptTemplate',
+        'notionInitialPromptTemplate',
+        'sentryInitialPromptTemplate',
         'gitConventions',
         'editorCommand',
         'browserNotifications',
         'audioNotifications',
+        'audioNotificationSound',
+        'audioNotificationVolume',
         'notionStatusProperty',
         'notionInProgressStatus',
         'defaultPermissionMode',
@@ -464,6 +548,7 @@ export function updateGlobalSettings(data) {
         'sentryMcpKey',
         'tags',
         'worktreesPath',
+        'worktreesPrefixByProject',
     ];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     if (filtered.tags !== undefined) {
@@ -473,6 +558,10 @@ export function updateGlobalSettings(data) {
                 .filter((t) => t.length > 0 && t.length <= 50)))
             : settings.global.tags;
     }
+    if (filtered.audioNotificationVolume !== undefined) {
+        const v = Number(filtered.audioNotificationVolume);
+        filtered.audioNotificationVolume = Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 1;
+    }
     if (filtered.worktreesPath !== undefined) {
         filtered.worktreesPath = validateWorktreesPath(filtered.worktreesPath, { allowEmpty: false });
         ensureGlobalWorktreesRootExists(filtered.worktreesPath);
@@ -505,6 +594,9 @@ export function upsertProject(projectPath, data) {
         'defaultModel',
         'dangerouslySkipPermissions',
         'prPromptTemplate',
+        'reviewPromptTemplate',
+        'notionInitialPromptTemplate',
+        'sentryInitialPromptTemplate',
         'gitConventions',
         'setupScript',
         'devServer',

package/dist/server/services/wakeup-service.js

@@ -1,6 +1,8 @@
 import { getDb } from '../db/index.js';
+import { slugifyProjectName } from '../utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
+import * as settingsService from './settings-service.js';
 import { emitEphemeral } from './websocket-service.js';
 const MIN_DELAY_SECONDS = 60;
 const MAX_DELAY_SECONDS = 3600;
@@ -132,7 +134,13 @@ function fire(workspaceId) {
             emitEphemeral(workspaceId, 'wakeup:skipped', { reason: 'fire-failed' });
             return;
         }
-        const worktreePath = wsRow.worktree_path ?? resolveWorkspaceWorktreePath(wsRow.project_path, wsRow.working_branch);
+        const globalSettings = settingsService.getGlobalSettings();
+        const projectSettings = settingsService.getProjectSettings(wsRow.project_path);
+        const projectSlug = globalSettings.worktreesPrefixByProject
+            ? slugifyProjectName(projectSettings?.displayName ?? '', wsRow.project_path)
+            : undefined;
+        const worktreePath = wsRow.worktree_path ??
+            resolveWorkspaceWorktreePath(wsRow.project_path, wsRow.working_branch, globalSettings.worktreesPath, projectSlug);
         // Narrow against the four known values; unknowns → 'bypass'.
         const stored = wsRow.agent_permission_mode;
         const agentPermissionMode = stored === 'plan' || stored === 'strict' || stored === 'interactive' ? stored : 'bypass';

package/dist/server/services/workspace-service.js

@@ -217,6 +217,27 @@ export function updateWorkingBranch(id, workingBranch) {
     }
     return getWorkspace(id);
 }
+/**
+ * Update the source branch in the database. Called by the PR watcher when
+ * GitHub reports a different `baseRefName` for the workspace's PR.
+ * Does NOT touch the worktree — the user (or the agent) decides when to
+ * rebase the local branch onto the new base.
+ */
+export function updateWorkspaceSourceBranch(id, sourceBranch) {
+    const sanitized = sourceBranch.trim();
+    if (!sanitized) {
+        throw new Error('Source branch cannot be empty');
+    }
+    const db = getDb();
+    const now = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE workspaces SET source_branch = ?, updated_at = ? WHERE id = ?')
+        .run(sanitized, now, id);
+    if (result.changes === 0) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
+    return getWorkspace(id);
+}
 /** Update the on-disk worktree path. Used by rename / resync-branch on owned worktrees. */
 export function updateWorktreePath(id, newPath) {
     const db = getDb();

package/dist/server/services/worktree-service.js

@@ -49,12 +49,12 @@ function removeFromExclude(projectPath, worktreePath) {
     fs.writeFileSync(excludeFile, trimmed ? `${trimmed}\n` : '', 'utf-8');
 }
 /** Create a git worktree for the given branch. Returns the worktree path. */
-export function createWorktree(projectPath, branchName, sourceBranch, worktreesPath) {
+export function createWorktree(projectPath, branchName, sourceBranch, worktreesPath, projectSlug) {
     const worktreesDir = resolveWorktreesRoot(projectPath, worktreesPath);
     if (!fs.existsSync(worktreesDir)) {
         fs.mkdirSync(worktreesDir, { recursive: true });
     }
-    const worktreePath = resolveWorkspaceWorktreePath(projectPath, branchName, worktreesPath);
+    const worktreePath = resolveWorkspaceWorktreePath(projectPath, branchName, worktreesPath, projectSlug);
     try {
         // Use origin/<sourceBranch> as the base so the worktree starts from the
         // freshly-fetched remote ref (fetchSourceBranch is always called first).

package/dist/server/utils/git-ops.js

@@ -267,6 +267,22 @@ export function getCommitCount(repoPath, base, head) {
         return 0;
     }
 }
+/**
+ * Count commits in `base` that are not in `head` — i.e. how far `head` lags
+ * behind `base`. Mirrors `getCommitCount` but in reverse direction.
+ * Returns 0 on failure.
+ */
+export function getCommitsBehind(repoPath, base, head) {
+    try {
+        const ref = resolveBase(repoPath, base);
+        const output = git(repoPath, ['rev-list', '--count', `${head}..${ref}`]);
+        const n = parseInt(output.trim(), 10);
+        return Number.isFinite(n) ? n : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 /** Return structured diff shortstat between two refs (three-dot merge base). */
 export function getStructuredDiffStatsBetween(repoPath, base, head) {
     try {
@@ -340,6 +356,40 @@ export function listBranchCommits(repoPath, sourceBranch, workingBranch, limit =
     }
     return commits;
 }
+/**
+ * List commits on `sourceBranch` that are NOT yet on `workingBranch` —
+ * i.e. commits the working branch is "behind" by. Mirror of `listBranchCommits`
+ * in the opposite direction. Up to `limit` commits, most recent first.
+ */
+export function listCommitsBehind(repoPath, sourceBranch, workingBranch, limit = 50) {
+    const sourceRef = resolveBase(repoPath, sourceBranch);
+    const FORMAT = '--pretty=format:%H%x00%h%x00%s%x00%an%x00%aI';
+    let raw;
+    try {
+        raw = git(repoPath, ['log', `${workingBranch}..${sourceRef}`, `--max-count=${limit}`, FORMAT]);
+    }
+    catch {
+        return [];
+    }
+    if (!raw)
+        return [];
+    const commits = [];
+    for (const line of raw.split('\n')) {
+        if (!line)
+            continue;
+        const [sha, shortSha, subject, author, date] = line.split('\x00');
+        if (!sha)
+            continue;
+        commits.push({
+            sha,
+            shortSha: shortSha ?? '',
+            subject: subject ?? '',
+            author: author ?? '',
+            date: date ?? '',
+        });
+    }
+    return commits;
+}
 /** Get the GitHub PR URL for a branch using `gh pr view`. Returns null if no PR exists. */
 export function getPrUrl(repoPath, branchName) {
     try {
@@ -355,14 +405,18 @@ export function getPrUrl(repoPath, branchName) {
 /** Get the state and URL of the PR for a branch. Returns null if no PR exists. */
 export function getPrStatus(repoPath, branchName) {
     try {
-        const raw = execFileSync('gh', ['pr', 'view', branchName, '--json', 'state,url'], {
+        const raw = execFileSync('gh', ['pr', 'view', branchName, '--json', 'state,url,baseRefName'], {
             cwd: repoPath,
             encoding: 'utf-8',
         }).trim();
         if (!raw)
             return null;
         const parsed = JSON.parse(raw);
-        return { state: parsed.state, url: parsed.url };
+        return {
+            state: parsed.state,
+            url: parsed.url,
+            base: parsed.baseRefName || undefined,
+        };
     }
     catch {
         return null;
@@ -644,6 +698,21 @@ export function getDiffStatsBetween(repoPath, base, head) {
         return '';
     }
 }
+/**
+ * Return `git diff --stat HEAD` output (working tree vs HEAD) as a single string.
+ * Empty string if the working tree is clean or the command fails. Best-effort: never throws.
+ */
+export function getWorkingTreeDiffStats(repoPath) {
+    try {
+        return execFileSync('git', ['diff', '--stat', 'HEAD'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+    }
+    catch {
+        return '';
+    }
+}
 // ── Async versions ───────────────────────────────────────────────────────────
 // Non-blocking alternatives for hot paths (pr-watcher, route handlers).
 /** Async version of getPrUrl. Returns null if no PR exists. */
@@ -662,7 +731,7 @@ export async function getPrUrlAsync(repoPath, branchName) {
 /** Async version of getPrStatus. Returns null if no PR exists. */
 export async function getPrStatusAsync(repoPath, branchName) {
     try {
-        const { stdout } = await execFileAsync('gh', ['pr', 'view', branchName, '--json', 'state,url'], {
+        const { stdout } = await execFileAsync('gh', ['pr', 'view', branchName, '--json', 'state,url,baseRefName'], {
             cwd: repoPath,
             encoding: 'utf-8',
         });
@@ -670,7 +739,11 @@ export async function getPrStatusAsync(repoPath, branchName) {
         if (!raw)
             return null;
         const parsed = JSON.parse(raw);
-        return { state: parsed.state, url: parsed.url };
+        return {
+            state: parsed.state,
+            url: parsed.url,
+            base: parsed.baseRefName || undefined,
+        };
     }
     catch {
         return null;
@@ -689,3 +762,20 @@ export async function getUnpushedCountAsync(repoPath) {
         return -1; // no upstream
     }
 }
+/**
+ * Best-effort async `git fetch <remote> <branch>`. Never throws — by contract,
+ * suitable for both fire-and-forget and `await` use without try/catch at the
+ * call site. Logs a warning on failure but resolves cleanly.
+ *
+ * Mirrors the sync `fetchSourceBranch` sibling, including the optional `remote`
+ * parameter (defaults to `'origin'`).
+ */
+export async function fetchSourceBranchAsync(repoPath, branch, remote = 'origin') {
+    try {
+        await execFileAsync('git', ['fetch', remote, branch], { cwd: repoPath });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[git-ops] fetchSourceBranchAsync(${remote}/${branch}) failed: ${msg}`);
+    }
+}

package/dist/server/utils/project-slug.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+const WINDOWS_RESERVED = new Set([
+    'con',
+    'prn',
+    'aux',
+    'nul',
+    'com1',
+    'com2',
+    'com3',
+    'com4',
+    'com5',
+    'com6',
+    'com7',
+    'com8',
+    'com9',
+    'lpt1',
+    'lpt2',
+    'lpt3',
+    'lpt4',
+    'lpt5',
+    'lpt6',
+    'lpt7',
+    'lpt8',
+    'lpt9',
+]);
+function slugifyOne(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Produce a cross-OS-safe directory name (Linux + macOS + Windows) from a
+ * project's display name, falling back to the path basename and finally to
+ * the literal `'project'`. Output is guaranteed to be non-empty and to avoid
+ * Windows reserved names (CON, PRN, COM1..9, LPT1..9, AUX, NUL).
+ */
+export function slugifyProjectName(displayName, projectPath) {
+    const fromDisplay = slugifyOne((displayName ?? '').trim());
+    if (fromDisplay)
+        return guard(fromDisplay);
+    const basename = path.basename(projectPath ?? '');
+    const fromBasename = slugifyOne(basename);
+    if (fromBasename)
+        return guard(fromBasename);
+    return 'project';
+}
+function guard(slug) {
+    return WINDOWS_RESERVED.has(slug) ? `${slug}-project` : slug;
+}

package/dist/server/utils/worktree-paths.js

@@ -115,20 +115,22 @@ export function resolveGlobalWorktreesRoot(configuredPath) {
     return flavor.isAbsolute(expanded) ? flavor.normalize(expanded) : null;
 }
 /** Resolve the full on-disk path for a workspace worktree. */
-export function resolveWorkspaceWorktreePath(projectPath, workingBranch, configuredPath) {
+export function resolveWorkspaceWorktreePath(projectPath, workingBranch, configuredPath, projectSlug) {
     const root = resolveWorktreesRoot(projectPath, configuredPath);
-    return pathFlavor(projectPath, root).join(root, ...branchPathSegments(workingBranch));
+    const flavor = pathFlavor(projectPath, root);
+    const slugSegment = projectSlug && projectSlug.length > 0 ? [projectSlug] : [];
+    return flavor.join(root, ...slugSegment, ...branchPathSegments(workingBranch));
 }
 /** Resolve a renamed worktree next to its current path when the current path still matches its branch. */
-export function resolveSiblingWorkspaceWorktreePath(projectPath, worktreePath, currentBranch, nextBranch) {
+export function resolveSiblingWorkspaceWorktreePath(projectPath, worktreePath, currentBranch, nextBranch, projectSlug) {
     const flavor = pathFlavor(projectPath, worktreePath);
     const normalizedWorktreePath = flavor.normalize(worktreePath);
-    const currentBranchPath = flavor.join(...branchPathSegments(currentBranch));
-    const currentBranchSuffix = `${flavor.sep}${currentBranchPath}`;
-    const comparableWorktreePath = flavor === path.win32 ? normalizedWorktreePath.toLowerCase() : normalizedWorktreePath;
-    const comparableSuffix = flavor === path.win32 ? currentBranchSuffix.toLowerCase() : currentBranchSuffix;
-    const root = comparableWorktreePath.endsWith(comparableSuffix)
-        ? normalizedWorktreePath.slice(0, -currentBranchSuffix.length)
+    const slugSegment = projectSlug && projectSlug.length > 0 ? [projectSlug] : [];
+    const currentSuffix = `${flavor.sep}${flavor.join(...slugSegment, ...branchPathSegments(currentBranch))}`;
+    const comparablePath = flavor === path.win32 ? normalizedWorktreePath.toLowerCase() : normalizedWorktreePath;
+    const comparableSuffix = flavor === path.win32 ? currentSuffix.toLowerCase() : currentSuffix;
+    const root = comparablePath.endsWith(comparableSuffix)
+        ? normalizedWorktreePath.slice(0, -currentSuffix.length)
         : resolveWorktreesRoot(projectPath);
-    return flavor.join(root, ...branchPathSegments(nextBranch));
+    return flavor.join(root, ...slugSegment, ...branchPathSegments(nextBranch));
 }