fix: key workspace by relative path instead of branch name

Author: jonathanlab

apps/twig/src/main/index.ts

@@ -43,7 +43,8 @@ import {
 } from "./services/posthog-analytics.js";
 import type { TaskLinkService } from "./services/task-link/service";
 import type { UpdatesService } from "./services/updates/service.js";
-import { migrateStoredWorktreePaths } from "./utils/store.js";
+import type { WorkspaceService } from "./services/workspace/service.js";
+import { migrateTaskAssociations } from "./utils/store.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -321,8 +322,7 @@ function createWindow(): void {
 }
 
 app.whenReady().then(() => {
-  // Migrate stored worktree paths from legacy directories (e.g., ~/.array -> ~/.twig)
-  migrateStoredWorktreePaths();
+  migrateTaskAssociations();
 
   createWindow();
   ensureClaudeConfigDir();
@@ -348,6 +348,12 @@ app.whenReady().then(() => {
   // Preload external app icons in background
   container.get<ExternalAppsService>(MAIN_TOKENS.ExternalAppsService);
 
+  // Initialize workspace branch watcher for live branch rename detection
+  const workspaceService = container.get<WorkspaceService>(
+    MAIN_TOKENS.WorkspaceService,
+  );
+  workspaceService.initBranchWatcher();
+
   // Handle case where app was launched by a deep link
   if (process.platform === "darwin") {
     // On macOS, the open-url event may have fired before app was ready

apps/twig/src/main/services/agent/schemas.ts

@@ -93,7 +93,6 @@ export const cancelSessionInput = z.object({
 export const interruptReasonSchema = z.enum([
   "user_request",
   "moving_to_worktree",
-  "moving_to_local",
 ]);
 export type InterruptReason = z.infer<typeof interruptReasonSchema>;
 
@@ -198,13 +197,24 @@ export const listSessionsInput = z.object({
   taskId: z.string(),
 });
 
-export const notifyCwdChangeInput = z.object({
+export const detachedHeadContext = z.object({
+  type: z.literal("detached_head"),
+  branchName: z.string(),
+  isDetached: z.boolean(),
+});
+
+export const sessionContextChangeSchema = detachedHeadContext;
+
+export type SessionContextChange = z.infer<typeof sessionContextChangeSchema>;
+
+export const notifySessionContextInput = z.object({
   sessionId: z.string(),
-  newPath: z.string(),
-  reason: z.enum(["moving_to_worktree", "moving_to_local"]),
+  context: sessionContextChangeSchema,
 });
 
-export type NotifyCwdChangeInput = z.infer<typeof notifyCwdChangeInput>;
+export type NotifySessionContextInput = z.infer<
+  typeof notifySessionContextInput
+>;
 
 export const sessionInfoSchema = z.object({
   taskRunId: z.string(),

apps/twig/src/main/services/agent/service.ts

@@ -151,7 +151,7 @@ interface ManagedSession {
   interruptReason?: InterruptReason;
   needsRecreation: boolean;
   promptPending: boolean;
-  pendingCwdContext?: string;
+  pendingContext?: string;
 }
 
 function getClaudeCliPath(): string {
@@ -450,7 +450,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
 
     // Preserve state that should survive recreation
     const config = existing.config;
-    const pendingCwdContext = existing.pendingCwdContext;
+    const pendingContext = existing.pendingContext;
 
     this.cleanupSession(taskRunId);
 
@@ -460,8 +460,8 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     }
 
     // Restore preserved state
-    if (pendingCwdContext) {
-      newSession.pendingCwdContext = pendingCwdContext;
+    if (pendingContext) {
+      newSession.pendingContext = pendingContext;
     }
 
     return newSession;
@@ -484,15 +484,19 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
       session = await this.recreateSession(sessionId);
     }
 
-    // Prepend pending CWD context if present
+    // Prepend pending context if present
     let finalPrompt = prompt;
-    if (session.pendingCwdContext) {
-      log.info("Prepending CWD context to prompt", { sessionId });
+    if (session.pendingContext) {
+      log.info("Prepending context to prompt", { sessionId });
       finalPrompt = [
-        { type: "text", text: `_${session.pendingCwdContext}_\n\n` },
+        {
+          type: "text",
+          text: `_${session.pendingContext}_\n\n`,
+          _meta: { ui: { hidden: true } },
+        },
         ...prompt,
       ];
-      session.pendingCwdContext = undefined;
+      session.pendingContext = undefined;
     }
 
     session.lastActivityAt = Date.now();
@@ -652,25 +656,21 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
   }
 
   /**
-   * Notify a session that its working directory context has changed.
+   * Notify a session of a context change (CWD moved, detached HEAD, etc).
    * Used when focusing/unfocusing worktrees - the agent doesn't need to respawn
    * because it has additionalDirectories configured, but it should know about the change.
    */
-  async notifyCwdChange(
+  async notifySessionContext(
     sessionId: string,
-    newPath: string,
-    reason: "moving_to_worktree" | "moving_to_local",
+    context: import("./schemas.js").SessionContextChange,
   ): Promise<void> {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      log.warn("Session not found for CWD notification", { sessionId });
+      log.warn("Session not found for context notification", { sessionId });
       return;
     }
 
-    const contextMessage =
-      reason === "moving_to_worktree"
-        ? `Your working directory has been moved to a worktree at ${newPath} because the user focused on another task.`
-        : `Your working directory has been returned to the main repository at ${newPath}.`;
+    const contextMessage = this.buildContextMessage(context);
 
     // Check if session is currently busy
     if (session.promptPending) {
@@ -679,21 +679,35 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
         {
           type: "text",
           text: `${contextMessage} Continue where you left off.`,
+          _meta: { ui: { hidden: true } },
         },
       ]);
     } else {
       // Idle session: store for prepending to next user message
-      session.pendingCwdContext = contextMessage;
+      session.pendingContext = contextMessage;
     }
 
-    log.info("Notified session of CWD change", {
+    log.info("Notified session of context change", {
       sessionId,
-      newPath,
-      reason,
+      context,
       wasPromptPending: session.promptPending,
     });
   }
 
+  private buildContextMessage(
+    context: import("./schemas.js").SessionContextChange,
+  ): string {
+    if (context.isDetached) {
+      return `Your worktree is now on detached HEAD while the user edits in their main repo. The branch is \`${context.branchName}\`.
+
+For git operations while detached:
+- Commit: works normally
+- Push: \`git push origin HEAD:refs/heads/${context.branchName}\`
+- Pull: \`git fetch origin ${context.branchName} && git merge FETCH_HEAD\``;
+    }
+    return `Your worktree is back on branch \`${context.branchName}\`. Normal git commands work again.`;
+  }
+
   async cleanupAll(): Promise<void> {
     log.info("Cleaning up all agent sessions", {
       sessionCount: this.sessions.size,

apps/twig/src/main/services/file-watcher/service.ts

@@ -217,7 +217,10 @@ export class FileWatcherService extends TypedEventEmitter<FileWatcherEvents> {
           return;
         }
         const isRelevant = events.some(
-          (e) => e.path.endsWith("/HEAD") || e.path.endsWith("/index"),
+          (e) =>
+            e.path.endsWith("/HEAD") ||
+            e.path.endsWith("/index") ||
+            e.path.includes("/refs/heads/"),
         );
         if (isRelevant) {
           this.emit(FileWatcherEvent.GitStateChanged, { repoPath });

apps/twig/src/main/services/focus/schemas.ts

@@ -14,24 +14,16 @@ export const stashResultSchema = focusResultSchema.extend({
 
 export type StashResult = z.infer<typeof stashResultSchema>;
 
-export const focusRefDataSchema = z.object({
-  status: z.enum(["focusing", "focused", "unfocusing"]),
+export const focusSessionSchema = z.object({
+  mainRepoPath: z.string(),
+  worktreePath: z.string(),
+  branch: z.string(),
   originalBranch: z.string(),
-  targetBranch: z.string(),
   mainStashRef: z.string().nullable(),
-  localWorktreePath: z.string().nullable(),
+  commitSha: z.string(),
 });
 
-export type FocusRefData = z.infer<typeof focusRefDataSchema>;
-
-export interface FocusSession {
-  mainRepoPath: string;
-  worktreePath: string;
-  branch: string;
-  originalBranch: string;
-  mainStashRef: string | null;
-  localWorktreePath: string | null;
-}
+export type FocusSession = z.infer<typeof focusSessionSchema>;
 
 export const repoPathInput = z.object({ repoPath: z.string() });
 export const mainRepoPathInput = z.object({ mainRepoPath: z.string() });
@@ -48,10 +40,6 @@ export const reattachInput = z.object({
   worktreePath: z.string(),
   branch: z.string(),
 });
-export const writeRefInput = z.object({
-  mainRepoPath: z.string(),
-  data: focusRefDataSchema,
-});
 export const syncInput = z.object({
   mainRepoPath: z.string(),
   worktreePath: z.string(),
@@ -60,8 +48,3 @@ export const findWorktreeInput = z.object({
   mainRepoPath: z.string(),
   branch: z.string(),
 });
-
-export const getCurrentStateOutput = z.object({
-  refData: focusRefDataSchema.nullable(),
-  currentBranch: z.string().nullable(),
-});