@telora/daemon 0.15.2 → 0.15.4

package/dist/{strategy-lifecycle.js → focus-lifecycle.js}

@@ -1,45 +1,45 @@
 /**
- * Strategy lifecycle management.
+ * Focus lifecycle management.
  *
- * Handles persistent worktree provisioning for active strategies and
- * coordinated teardown when strategies are deactivated. Replaces the
- * separate detectDeactivatedStrategies() and checkQaForDeactivatedStrategies()
+ * Handles persistent worktree provisioning for active focuses and
+ * coordinated teardown when focuses are deactivated. Replaces the
+ * separate detectDeactivatedFocuses() and checkQaForDeactivatedFocuses()
  * flows with a single unified lifecycle.
  */
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { installAuditPreCommitHook } from './audit-hooks.js';
-import { getReadyStrategies, getActiveStrategies, reportGitState } from './supabase.js';
-import { createWorktree, syncIntegrationWithMain, runGitSync, safeRemoveStrategyWorktree, commitWipChanges, generateMcpConfigInWorktree, ensureIntegrationBranch, ensureMergeWorktree } from './git.js';
-import { generateStrategyBranchName, terminateTeam, waitForTeamExit } from './strategy-executor.js';
-import { getActiveTeams } from './strategy-team-state.js';
-import { recordStrategyTeardown } from './spawn-cooldown.js';
-import { getStrategyWorktree, setStrategyWorktree, removeStrategyWorktree, getAllStrategyWorktrees, hasStrategyWorktree, } from './strategy-worktree-state.js';
-import { getStrategyDeliveries } from './queries/strategies.js';
+import { getReadyFocuses, getActiveFocuses, reportGitState } from './supabase.js';
+import { createWorktree, syncIntegrationWithMain, runGitSync, safeRemoveFocusWorktree, commitWipChanges, generateMcpConfigInWorktree, ensureIntegrationBranch, ensureMergeWorktree } from './git.js';
+import { generateFocusBranchName, terminateTeam, waitForTeamExit } from './focus-executor.js';
+import { getActiveTeams } from './focus-team-state.js';
+import { recordFocusTeardown } from './spawn-cooldown.js';
+import { getFocusWorktree, setFocusWorktree, removeFocusWorktree, getAllFocusWorktrees, hasFocusWorktree, } from './focus-worktree-state.js';
+import { getFocusDeliveries } from './queries/focuses.js';
 import { isStatusAgentActionable } from './stage-classifier.js';
-import { escalateMergeConflict } from './strategy-merge.js';
+import { escalateMergeConflict } from './focus-merge.js';
 import { getQaEnvironment, removeQaEnvironment } from './qa-state.js';
 import { stopQaDevServer } from './qa-dev-server.js';
 import { updateQaStatus } from './supabase.js';
 // ── Persistent worktree provisioning ─────────────────────────────────
 /**
- * Ensure persistent worktrees exist for all active strategies.
+ * Ensure persistent worktrees exist for all active focuses.
  *
- * Called each poll cycle BEFORE processReadyStrategies(). Creates
- * worktrees for active strategies that don't have one yet.
- * Syncs integration with main once per cycle (not per strategy).
+ * Called each poll cycle BEFORE processReadyFocuses(). Creates
+ * worktrees for active focuses that don't have one yet.
+ * Syncs integration with main once per cycle (not per focus).
  */
-export async function ensureStrategyWorktrees(config, roles) {
-    let readyStrategies;
+export async function ensureFocusWorktrees(config, roles) {
+    let readyFocuses;
     try {
-        readyStrategies = await getReadyStrategies(config.organizationId, config.productId);
+        readyFocuses = await getReadyFocuses(config.organizationId, config.productId);
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to query ready strategies for worktree provisioning: ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to query ready focuses for worktree provisioning: ${err.message}`);
         return;
     }
-    // Find strategies that need worktrees
-    const needsWorktree = readyStrategies.filter(s => !hasStrategyWorktree(s.strategy_id));
+    // Find focuses that need worktrees
+    const needsWorktree = readyFocuses.filter(s => !hasFocusWorktree(s.focus_id));
     if (needsWorktree.length === 0)
         return;
     // Ensure git infrastructure exists (normally handled by initGit on startup,
@@ -49,29 +49,29 @@ export async function ensureStrategyWorktrees(config, roles) {
         ensureMergeWorktree(config);
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to ensure git infrastructure: ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to ensure git infrastructure: ${err.message}`);
         return;
     }
     // Sync integration with main once before creating any worktrees
     try {
         const syncResult = await syncIntegrationWithMain(config);
         if (syncResult.success) {
-            console.log(`[strategy-lifecycle] Synced integration with main before worktree provisioning`);
+            console.log(`[focus-lifecycle] Synced integration with main before worktree provisioning`);
         }
         else {
-            console.warn(`[strategy-lifecycle] Could not sync integration with main: ${syncResult.error}`);
+            console.warn(`[focus-lifecycle] Could not sync integration with main: ${syncResult.error}`);
         }
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Sync failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+        console.warn(`[focus-lifecycle] Sync failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
-    for (const strategy of needsWorktree) {
-        const role = roles.get(strategy.assigned_agent_role_id);
+    for (const focus of needsWorktree) {
+        const role = roles.get(focus.assigned_agent_role_id);
         if (!role) {
-            console.warn(`[strategy-lifecycle] Unknown agent role ${strategy.assigned_agent_role_id} for strategy "${strategy.strategy_name}", skipping worktree`);
+            console.warn(`[focus-lifecycle] Unknown agent role ${focus.assigned_agent_role_id} for focus "${focus.focus_name}", skipping worktree`);
             continue;
         }
-        const branchName = generateStrategyBranchName(role, strategy.strategy_name, strategy.strategy_id);
+        const branchName = generateFocusBranchName(role, focus.focus_name, focus.focus_id);
         const worktreePath = join(config.worktreeDir, branchName.replace(/\//g, '-'));
         // Check if a valid worktree already exists on disk (e.g., after daemon restart
         // or reactivation). Adopt it instead of destroying and rebuilding.
@@ -80,10 +80,10 @@ export async function ensureStrategyWorktrees(config, roles) {
             const branchResult = runGitSync(['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
             if (gitDirResult.success && branchResult.success && branchResult.output === branchName) {
                 // Valid worktree on the expected branch -- adopt it
-                console.log(`[strategy-lifecycle] Adopting existing worktree for "${strategy.strategy_name}": ${worktreePath}`);
-                setStrategyWorktree(strategy.strategy_id, {
-                    strategyId: strategy.strategy_id,
-                    strategyName: strategy.strategy_name,
+                console.log(`[focus-lifecycle] Adopting existing worktree for "${focus.focus_name}": ${worktreePath}`);
+                setFocusWorktree(focus.focus_id, {
+                    focusId: focus.focus_id,
+                    focusName: focus.focus_name,
                     worktreePath,
                     branchName,
                     createdAt: new Date(),
@@ -93,78 +93,78 @@ export async function ensureStrategyWorktrees(config, roles) {
                 const rebaseResult = runGitSync(['rebase', config.integrationBranch], worktreePath);
                 if (!rebaseResult.success) {
                     runGitSync(['rebase', '--abort'], worktreePath);
-                    console.warn(`[strategy-lifecycle] Could not rebase adopted worktree for "${strategy.strategy_name}" onto integration. Continuing with existing state.`);
+                    console.warn(`[focus-lifecycle] Could not rebase adopted worktree for "${focus.focus_name}" onto integration. Continuing with existing state.`);
                 }
                 else {
-                    console.log(`[strategy-lifecycle] Rebased adopted worktree for "${strategy.strategy_name}" onto ${config.integrationBranch}`);
+                    console.log(`[focus-lifecycle] Rebased adopted worktree for "${focus.focus_name}" onto ${config.integrationBranch}`);
                 }
                 // Generate .mcp.json with absolute path to MCP server
                 generateMcpConfigInWorktree(worktreePath, config);
-                // Install audit pre-commit hook for read-only strategies
-                if (strategy.read_only) {
+                // Install audit pre-commit hook for read-only focuses
+                if (focus.read_only) {
                     installAuditPreCommitHook(worktreePath);
-                    console.log(`[strategy-lifecycle] Installed audit pre-commit hook for "${strategy.strategy_name}"`);
+                    console.log(`[focus-lifecycle] Installed audit pre-commit hook for "${focus.focus_name}"`);
                 }
                 continue;
             }
             // Directory exists but is not a valid worktree for this branch -- fall through to createWorktree
-            console.log(`[strategy-lifecycle] Existing directory at ${worktreePath} is not a valid worktree for ${branchName}, recreating`);
+            console.log(`[focus-lifecycle] Existing directory at ${worktreePath} is not a valid worktree for ${branchName}, recreating`);
         }
         try {
             const createdPath = await createWorktree(config, branchName);
-            setStrategyWorktree(strategy.strategy_id, {
-                strategyId: strategy.strategy_id,
-                strategyName: strategy.strategy_name,
+            setFocusWorktree(focus.focus_id, {
+                focusId: focus.focus_id,
+                focusName: focus.focus_name,
                 worktreePath: createdPath,
                 branchName,
                 createdAt: new Date(),
                 hasQaDevServer: false,
             });
-            console.log(`[strategy-lifecycle] Created persistent worktree for "${strategy.strategy_name}": ${createdPath}`);
-            // Install audit pre-commit hook for read-only strategies
-            if (strategy.read_only) {
+            console.log(`[focus-lifecycle] Created persistent worktree for "${focus.focus_name}": ${createdPath}`);
+            // Install audit pre-commit hook for read-only focuses
+            if (focus.read_only) {
                 installAuditPreCommitHook(createdPath);
-                console.log(`[strategy-lifecycle] Installed audit pre-commit hook for "${strategy.strategy_name}"`);
+                console.log(`[focus-lifecycle] Installed audit pre-commit hook for "${focus.focus_name}"`);
             }
         }
         catch (err) {
-            console.error(`[strategy-lifecycle] Failed to create worktree for "${strategy.strategy_name}": ${err instanceof Error ? err.message : String(err)}`);
-            // Continue with other strategies
+            console.error(`[focus-lifecycle] Failed to create worktree for "${focus.focus_name}": ${err instanceof Error ? err.message : String(err)}`);
+            // Continue with other focuses
         }
     }
 }
 // ── Coordinated teardown ─────────────────────────────────────────────
 /**
- * Tear down a single strategy: stop QA, terminate team, remove worktree.
+ * Tear down a single focus: stop QA, terminate team, remove worktree.
  *
  * Each step is independently try/caught so a failure in one
  * does not prevent the others from running.
  */
-export async function teardownStrategy(config, strategyId, strategyName) {
-    console.log(`[strategy-lifecycle] Tearing down strategy "${strategyName}"`);
+export async function teardownFocus(config, focusId, focusName) {
+    console.log(`[focus-lifecycle] Tearing down focus "${focusName}"`);
     // Record teardown for spawn cooldown (prevents immediate respawn crash loops)
-    recordStrategyTeardown(strategyId);
+    recordFocusTeardown(focusId);
     // 1. Stop QA dev server if running
     try {
-        const qaState = getQaEnvironment(strategyId);
+        const qaState = getQaEnvironment(focusId);
         if (qaState?.pid) {
-            console.log(`[strategy-lifecycle] Stopping QA dev server for "${strategyName}" (PID: ${qaState.pid})`);
+            console.log(`[focus-lifecycle] Stopping QA dev server for "${focusName}" (PID: ${qaState.pid})`);
             await stopQaDevServer(qaState.pid);
         }
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to stop QA dev server for "${strategyName}": ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to stop QA dev server for "${focusName}": ${err.message}`);
     }
     // 2. Clear QA in-memory state
     try {
-        removeQaEnvironment(strategyId);
+        removeQaEnvironment(focusId);
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to clear QA state for "${strategyName}": ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to clear QA state for "${focusName}": ${err.message}`);
     }
     // 3. Clear QA DB state
     try {
-        await updateQaStatus(strategyId, {
+        await updateQaStatus(focusId, {
             qaStatus: null,
             qaUrl: null,
             qaPort: null,
@@ -174,204 +174,204 @@ export async function teardownStrategy(config, strategyId, strategyName) {
         });
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to clear QA DB state for "${strategyName}": ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to clear QA DB state for "${focusName}": ${err.message}`);
     }
     // 4. Terminate agent team and wait for process exit
     try {
         const activeTeams = getActiveTeams();
-        const team = activeTeams.get(strategyId);
+        const team = activeTeams.get(focusId);
         if (team && team.phase !== 'shutting_down' && team.phase !== 'terminated') {
-            console.log(`[strategy-lifecycle] Terminating team for "${strategyName}"`);
-            terminateTeam(strategyId);
+            console.log(`[focus-lifecycle] Terminating team for "${focusName}"`);
+            terminateTeam(focusId);
             // Wait for process to actually exit (default 30s, then SIGKILL)
-            const exited = await waitForTeamExit(strategyId);
+            const exited = await waitForTeamExit(focusId);
             if (!exited) {
-                console.warn(`[strategy-lifecycle] Team for "${strategyName}" did not exit cleanly after SIGKILL`);
+                console.warn(`[focus-lifecycle] Team for "${focusName}" did not exit cleanly after SIGKILL`);
             }
         }
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to terminate team for "${strategyName}": ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to terminate team for "${focusName}": ${err.message}`);
     }
     // 4b. Commit any uncommitted WIP changes left by the agent
     try {
-        const worktreeInfo = getStrategyWorktree(strategyId);
+        const worktreeInfo = getFocusWorktree(focusId);
         if (worktreeInfo) {
-            commitWipChanges(worktreeInfo.worktreePath, strategyName);
+            commitWipChanges(worktreeInfo.worktreePath, focusName);
         }
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] WIP commit failed for "${strategyName}": ${err.message}`);
+        console.warn(`[focus-lifecycle] WIP commit failed for "${focusName}": ${err.message}`);
     }
-    // 5. Remove strategy worktree via canonical path (merge-before-remove + conditional state cleanup).
+    // 5. Remove focus worktree via canonical path (merge-before-remove + conditional state cleanup).
     // If the team was killed mid-work (OOM, signal, crash) before handleTeamCompletion ran,
-    // there may be commits that never got a merge attempt. safeRemoveStrategyWorktree closes that gap.
+    // there may be commits that never got a merge attempt. safeRemoveFocusWorktree closes that gap.
     try {
-        const worktreeInfo = getStrategyWorktree(strategyId);
+        const worktreeInfo = getFocusWorktree(focusId);
         if (worktreeInfo) {
-            console.log(`[strategy-lifecycle] Removing worktree for "${strategyName}": ${worktreeInfo.worktreePath}`);
-            const removeResult = await safeRemoveStrategyWorktree({
+            console.log(`[focus-lifecycle] Removing worktree for "${focusName}": ${worktreeInfo.worktreePath}`);
+            const removeResult = await safeRemoveFocusWorktree({
                 config,
                 worktreePath: worktreeInfo.worktreePath,
                 branchName: worktreeInfo.branchName,
-                deliveryName: strategyName,
-                deliveryId: strategyId,
-                strategyId,
+                deliveryName: focusName,
+                deliveryId: focusId,
+                focusId,
             });
             // Escalate if merge failed (worktree preserved with unmerged work)
             if (removeResult.merged && removeResult.mergeError) {
                 escalateMergeConflict({
                     organizationId: config.organizationId,
                     sessionId: '',
-                    deliveryId: strategyId,
-                    deliveryName: strategyName,
+                    deliveryId: focusId,
+                    deliveryName: focusName,
                     branchName: worktreeInfo.branchName,
                     integrationBranch: config.integrationBranch,
                     mergeError: removeResult.mergeError,
-                }).catch(err => console.warn(`[strategy-lifecycle] escalateMergeConflict failed for "${strategyName}": ${err.message}`));
+                }).catch(err => console.warn(`[focus-lifecycle] escalateMergeConflict failed for "${focusName}": ${err.message}`));
             }
         }
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to remove worktree for "${strategyName}": ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to remove worktree for "${focusName}": ${err.message}`);
     }
-    console.log(`[strategy-lifecycle] Teardown complete for "${strategyName}"`);
+    console.log(`[focus-lifecycle] Teardown complete for "${focusName}"`);
 }
 /**
- * Detect deactivated strategies and tear them down.
+ * Detect deactivated focuses and tear them down.
  *
- * Replaces both detectDeactivatedStrategies() from strategy-executor.ts
- * and checkQaForDeactivatedStrategies() from qa-orchestrator.ts.
+ * Replaces both detectDeactivatedFocuses() from focus-executor.ts
+ * and checkQaForDeactivatedFocuses() from qa-orchestrator.ts.
  * A single pass handles both team termination and QA cleanup.
  */
-export async function checkForDeactivatedStrategies(config) {
-    const allWorktrees = getAllStrategyWorktrees();
+export async function checkForDeactivatedFocuses(config) {
+    const allWorktrees = getAllFocusWorktrees();
     const activeTeams = getActiveTeams();
     // Nothing to check if no worktrees and no teams
     if (allWorktrees.size === 0 && activeTeams.size === 0)
         return;
-    let activeStrategyIds;
+    let activeFocusIds;
     try {
-        // Use getActiveStrategies (not getReadyStrategies) -- a strategy is "active" even
+        // Use getActiveFocuses (not getReadyFocuses) -- a focus is "active" even
         // when all deliveries are done. Worktrees must persist for QA and idle queues.
-        const activeStrategies = await getActiveStrategies(config.organizationId, config.productId);
-        activeStrategyIds = new Set(activeStrategies.map(s => s.strategy_id));
+        const activeFocuses = await getActiveFocuses(config.organizationId, config.productId);
+        activeFocusIds = new Set(activeFocuses.map(s => s.focus_id));
     }
     catch (err) {
         // If the endpoint isn't deployed yet, skip deactivation checks entirely.
         // Better to leave worktrees alive than to tear them down incorrectly.
-        console.warn(`[strategy-lifecycle] Cannot determine active strategies (skipping deactivation check): ${err.message}`);
+        console.warn(`[focus-lifecycle] Cannot determine active focuses (skipping deactivation check): ${err.message}`);
         return;
     }
-    // In multi-product setups, the global worktree/team maps contain strategies
-    // from ALL products. Only check strategies we can confirm belong to THIS
-    // product — otherwise Product B's poll tears down Product A's strategies.
+    // In multi-product setups, the global worktree/team maps contain focuses
+    // from ALL products. Only check focuses we can confirm belong to THIS
+    // product — otherwise Product B's poll tears down Product A's focuses.
     //
-    // Strategy ownership is determined by:
+    // Focus ownership is determined by:
     // 1. Active team with matching productId (definitive)
-    // 2. Worktree for a strategy that appears in this product's active set
-    //    (if it's active for this product, it's this product's strategy)
+    // 2. Worktree for a focus that appears in this product's active set
+    //    (if it's active for this product, it's this product's focus)
     //
     // Orphan worktrees (no team, not in active set) have unknown product
     // ownership and are left alone — startup recovery handles them.
-    const trackedStrategyIds = new Set();
+    const trackedFocusIds = new Set();
     for (const [id, team] of activeTeams) {
         if (team.productId === config.productId) {
-            trackedStrategyIds.add(id);
+            trackedFocusIds.add(id);
         }
     }
-    for (const strategyId of trackedStrategyIds) {
-        if (activeStrategyIds.has(strategyId))
+    for (const focusId of trackedFocusIds) {
+        if (activeFocusIds.has(focusId))
             continue;
-        const worktreeInfo = getStrategyWorktree(strategyId);
-        const team = activeTeams.get(strategyId);
-        const name = worktreeInfo?.strategyName ?? team?.strategyName ?? strategyId;
+        const worktreeInfo = getFocusWorktree(focusId);
+        const team = activeTeams.get(focusId);
+        const name = worktreeInfo?.focusName ?? team?.focusName ?? focusId;
         // Skip teams already shutting down
         if (team && (team.phase === 'shutting_down' || team.phase === 'terminated') && !worktreeInfo) {
             continue;
         }
         const reason = worktreeInfo && !team
-            ? 'worktree exists but strategy no longer active'
+            ? 'worktree exists but focus no longer active'
             : team && !worktreeInfo
-                ? 'team running but strategy no longer active'
-                : 'strategy no longer active';
-        console.log(`[strategy-lifecycle] Strategy "${name}" deactivated (${reason}) -- coordinated teardown`);
-        await teardownStrategy(config, strategyId, name);
+                ? 'team running but focus no longer active'
+                : 'focus no longer active';
+        console.log(`[focus-lifecycle] Focus "${name}" deactivated (${reason}) -- coordinated teardown`);
+        await teardownFocus(config, focusId, name);
     }
 }
 // ── Startup recovery ─────────────────────────────────────────────
 /**
- * Rebuild the strategy-worktree-state after a daemon restart.
+ * Rebuild the focus-worktree-state after a daemon restart.
  *
  * Two-phase approach:
  *   Phase 1 (DB-first): If hydrateFromDb() populated the Map, validate
- *     each entry against disk and enrich with strategy names. Removes
+ *     each entry against disk and enrich with focus names. Removes
  *     stale entries (worktree deleted from disk) and cleans up entries
- *     for deactivated strategies.
+ *     for deactivated focuses.
  *   Phase 2 (disk fallback): Scans for agent-* directories NOT already
  *     in the Map. Covers first-run after migration and manually created
- *     worktrees. Matches by ID prefix against active strategies.
+ *     worktrees. Matches by ID prefix against active focuses.
  *
  * Also removes legacy qa-* directories from the pre-persistent worktree era.
  *
  * Must run AFTER hydrateFromDb() and crash recovery but BEFORE startListeners().
  */
-export async function rebuildStrategyWorktreeState(config) {
+export async function rebuildFocusWorktreeState(config) {
     const { worktreeDir, repoPath, organizationId, productId } = config;
     if (!existsSync(worktreeDir)) {
-        console.log('[strategy-lifecycle] No worktree directory — nothing to rebuild');
+        console.log('[focus-lifecycle] No worktree directory — nothing to rebuild');
         return;
     }
-    // Query active strategies for enrichment and deactivation detection
-    let activeStrategies;
+    // Query active focuses for enrichment and deactivation detection
+    let activeFocuses;
     try {
-        activeStrategies = await getActiveStrategies(organizationId, productId);
+        activeFocuses = await getActiveFocuses(organizationId, productId);
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Cannot determine active strategies for state rebuild (preserving all): ${err.message}`);
+        console.warn(`[focus-lifecycle] Cannot determine active focuses for state rebuild (preserving all): ${err.message}`);
         return;
     }
-    const strategyById = new Map(activeStrategies.map(s => [s.strategy_id, s]));
-    const strategyByPrefix = new Map(activeStrategies.map(s => [s.strategy_id.slice(0, 8), s]));
+    const focusById = new Map(activeFocuses.map(s => [s.focus_id, s]));
+    const focusByPrefix = new Map(activeFocuses.map(s => [s.focus_id.slice(0, 8), s]));
     let validated = 0;
     let removedStale = 0;
     let deactivatedCleaned = 0;
     // ── Phase 1: Validate DB-hydrated entries ──────────────────────
-    const allWorktrees = getAllStrategyWorktrees();
+    const allWorktrees = getAllFocusWorktrees();
     if (allWorktrees.size > 0) {
-        console.log(`[strategy-lifecycle] Validating ${allWorktrees.size} DB-hydrated worktree(s) against disk`);
-        for (const [strategyId, info] of [...allWorktrees]) {
+        console.log(`[focus-lifecycle] Validating ${allWorktrees.size} DB-hydrated worktree(s) against disk`);
+        for (const [focusId, info] of [...allWorktrees]) {
             if (!existsSync(info.worktreePath)) {
                 // Worktree was manually deleted — remove from state (also fires async DB remove)
-                console.log(`[strategy-lifecycle] DB-hydrated worktree no longer on disk: ${info.worktreePath}`);
-                removeStrategyWorktree(strategyId);
+                console.log(`[focus-lifecycle] DB-hydrated worktree no longer on disk: ${info.worktreePath}`);
+                removeFocusWorktree(focusId);
                 removedStale++;
                 continue;
             }
-            const strategy = strategyById.get(strategyId);
-            if (strategy) {
-                // Active — enrich with strategy name (not stored in DB)
-                info.strategyName = strategy.strategy_name;
+            const focus = focusById.get(focusId);
+            if (focus) {
+                // Active — enrich with focus name (not stored in DB)
+                info.focusName = focus.focus_name;
                 validated++;
-                console.log(`[strategy-lifecycle] Validated worktree for "${strategy.strategy_name}": ${info.worktreePath}`);
+                console.log(`[focus-lifecycle] Validated worktree for "${focus.focus_name}": ${info.worktreePath}`);
             }
             else {
                 // Deactivated — clean up via canonical path
-                console.log(`[strategy-lifecycle] DB-hydrated worktree for deactivated strategy: ${info.worktreePath}`);
+                console.log(`[focus-lifecycle] DB-hydrated worktree for deactivated focus: ${info.worktreePath}`);
                 try {
-                    const result = await safeRemoveStrategyWorktree({
+                    const result = await safeRemoveFocusWorktree({
                         config,
                         worktreePath: info.worktreePath,
                         branchName: info.branchName,
-                        deliveryName: info.strategyName || strategyId,
-                        deliveryId: strategyId,
-                        strategyId,
+                        deliveryName: info.focusName || focusId,
+                        deliveryId: focusId,
+                        focusId,
                     });
                     if (result.removed)
                         deactivatedCleaned++;
                 }
                 catch (err) {
-                    console.warn(`[strategy-lifecycle] Failed to clean up deactivated worktree: ${err.message}`);
+                    console.warn(`[focus-lifecycle] Failed to clean up deactivated worktree: ${err.message}`);
                 }
             }
         }
@@ -392,18 +392,18 @@ export async function rebuildStrategyWorktreeState(config) {
         });
     }
     catch (err) {
-        console.warn(`[strategy-lifecycle] Failed to scan worktree directory: ${err.message}`);
+        console.warn(`[focus-lifecycle] Failed to scan worktree directory: ${err.message}`);
         agentDirs = [];
     }
     // Filter to directories whose full path is NOT already tracked
-    const trackedPaths = new Set([...getAllStrategyWorktrees().values()].map(w => w.worktreePath));
+    const trackedPaths = new Set([...getAllFocusWorktrees().values()].map(w => w.worktreePath));
     const orphanDirs = agentDirs.filter(dirName => {
         const fullPath = resolve(join(worktreeDir, dirName));
         return !trackedPaths.has(fullPath);
     });
     let diskRegistered = 0;
     if (orphanDirs.length > 0) {
-        console.log(`[strategy-lifecycle] Found ${orphanDirs.length} untracked agent-* dir(s) on disk (migration fallback)`);
+        console.log(`[focus-lifecycle] Found ${orphanDirs.length} untracked agent-* dir(s) on disk (migration fallback)`);
         // Parse git worktree list for branch names
         const pathToBranch = new Map();
         const worktreeListResult = runGitSync(['worktree', 'list', '--porcelain'], repoPath);
@@ -427,24 +427,24 @@ export async function rebuildStrategyWorktreeState(config) {
             const branchName = pathToBranch.get(fullPath) ?? dirName.replace(/-/g, '/');
             const idMatch = dirName.match(/-([0-9a-f]{8})$/);
             const idPrefix = idMatch ? idMatch[1] : null;
-            const strategy = idPrefix ? strategyByPrefix.get(idPrefix) : undefined;
-            if (strategy) {
-                setStrategyWorktree(strategy.strategy_id, {
-                    strategyId: strategy.strategy_id,
-                    strategyName: strategy.strategy_name,
+            const focus = idPrefix ? focusByPrefix.get(idPrefix) : undefined;
+            if (focus) {
+                setFocusWorktree(focus.focus_id, {
+                    focusId: focus.focus_id,
+                    focusName: focus.focus_name,
                     worktreePath: fullPath,
                     branchName,
                     createdAt: new Date(),
                     hasQaDevServer: false,
                 });
                 diskRegistered++;
-                console.log(`[strategy-lifecycle] Registered orphan worktree for "${strategy.strategy_name}": ${fullPath}`);
+                console.log(`[focus-lifecycle] Registered orphan worktree for "${focus.focus_name}": ${fullPath}`);
             }
             else {
                 // Deactivated — canonical removal
-                console.log(`[strategy-lifecycle] Cleaning up orphan deactivated worktree: ${fullPath} [${branchName}]`);
+                console.log(`[focus-lifecycle] Cleaning up orphan deactivated worktree: ${fullPath} [${branchName}]`);
                 try {
-                    const result = await safeRemoveStrategyWorktree({
+                    const result = await safeRemoveFocusWorktree({
                         config,
                         worktreePath: fullPath,
                         branchName,
@@ -455,7 +455,7 @@ export async function rebuildStrategyWorktreeState(config) {
                         deactivatedCleaned++;
                 }
                 catch (err) {
-                    console.warn(`[strategy-lifecycle] Failed to clean up orphan worktree ${dirName}: ${err.message}`);
+                    console.warn(`[focus-lifecycle] Failed to clean up orphan worktree ${dirName}: ${err.message}`);
                 }
             }
         }
@@ -475,7 +475,7 @@ export async function rebuildStrategyWorktreeState(config) {
         });
         for (const qaDir of legacyQaDirs) {
             const qaPath = join(worktreeDir, qaDir);
-            console.log(`[strategy-lifecycle] Removing legacy qa-* directory: ${qaPath}`);
+            console.log(`[focus-lifecycle] Removing legacy qa-* directory: ${qaPath}`);
             try {
                 const removeResult = runGitSync(['worktree', 'remove', '--force', qaPath], repoPath);
                 if (!removeResult.success) {
@@ -486,7 +486,7 @@ export async function rebuildStrategyWorktreeState(config) {
                 legacyCleaned++;
             }
             catch (err) {
-                console.warn(`[strategy-lifecycle] Failed to remove legacy QA directory ${qaDir}: ${err.message}`);
+                console.warn(`[focus-lifecycle] Failed to remove legacy QA directory ${qaDir}: ${err.message}`);
             }
         }
     }
@@ -500,29 +500,29 @@ export async function rebuildStrategyWorktreeState(config) {
         deactivatedCleaned > 0 ? `${deactivatedCleaned} deactivated cleaned` : null,
         legacyCleaned > 0 ? `${legacyCleaned} legacy qa-* removed` : null,
     ].filter(Boolean);
-    console.log(`[strategy-lifecycle] State rebuild complete: ${parts.join(', ')}`);
+    console.log(`[focus-lifecycle] State rebuild complete: ${parts.join(', ')}`);
 }
 // ── Git state reconciliation ──────────────────────────────────────
 /**
- * Reconcile git state for active strategy worktrees after startup.
+ * Reconcile git state for active focus worktrees after startup.
  *
- * Checks all rebuilt strategy worktrees and re-reports `worktree_active`
+ * Checks all rebuilt focus worktrees and re-reports `worktree_active`
  * for deliveries in coding/queued status. This ensures the DB reflects
  * accurate git state even if previous reportGitState calls were lost
  * (network blip, circuit breaker, daemon crash).
  *
- * Must run AFTER rebuildStrategyWorktreeState().
+ * Must run AFTER rebuildFocusWorktreeState().
  */
 export async function reconcileGitState(_config) {
-    const worktrees = getAllStrategyWorktrees();
+    const worktrees = getAllFocusWorktrees();
     if (worktrees.size === 0) {
         return;
     }
-    console.log(`[strategy-lifecycle] Reconciling git state for ${worktrees.size} strategy worktree(s)...`);
+    console.log(`[focus-lifecycle] Reconciling git state for ${worktrees.size} focus worktree(s)...`);
     let reconciled = 0;
-    for (const [strategyId, worktree] of worktrees) {
+    for (const [focusId, worktree] of worktrees) {
         try {
-            const deliveries = await getStrategyDeliveries(strategyId);
+            const deliveries = await getFocusDeliveries(focusId);
             const activeDeliveries = deliveries.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
             for (const delivery of activeDeliveries) {
                 await reportGitState(delivery.id, 'worktree_active', worktree.branchName);
@@ -530,15 +530,15 @@ export async function reconcileGitState(_config) {
             }
         }
         catch (err) {
-            console.warn(`[strategy-lifecycle] Failed to reconcile git state for "${worktree.strategyName}": ` +
+            console.warn(`[focus-lifecycle] Failed to reconcile git state for "${worktree.focusName}": ` +
                 `${err.message}`);
         }
     }
     if (reconciled > 0) {
-        console.log(`[strategy-lifecycle] Reconciled git state for ${reconciled} delivery(ies)`);
+        console.log(`[focus-lifecycle] Reconciled git state for ${reconciled} delivery(ies)`);
     }
     else {
-        console.log('[strategy-lifecycle] No deliveries needed git state reconciliation');
+        console.log('[focus-lifecycle] No deliveries needed git state reconciliation');
     }
 }
-//# sourceMappingURL=strategy-lifecycle.js.map
+//# sourceMappingURL=focus-lifecycle.js.map