farming-code 2.2.11 → 2.2.12

package/README.md

@@ -51,6 +51,13 @@ A keyboard-first control room for watching many agents, opening structured Chat
 
 Switching interfaces does not restart or duplicate an Agent. If Farming Code cannot start or render, its bounded diagnostic view leaves the live CRT surface available rather than hiding the running sessions.
 
+To switch without editing the URL:
+
+- **Farming Code → CRT:** click the gear at the bottom-left, open **Interface**, then choose **Farming CRT**.
+- **Farming CRT → Code:** press `S` (or choose **[S] SETTINGS**), then choose **Farming Code** under **UI Theme**.
+
+Farming carries the focused Agent into the other interface when possible. Both views keep using the same live Agent and provider session; this is an interface switch, not a restart.
+
 The complete current capability map and screenshot tour are in the [Farming 2 product overview](./docs/products/README.md). See the focused [Farming Code guide](./docs/products/code/README.md) and [Farming CRT guide](./docs/products/crt/README.md) for the full workflows.
 
 ## Farming Net: One Portal For Deployments
@@ -74,8 +81,6 @@ The portal keeps its token, signing identity, and private `instances.json` regis
 
 ![Farming Code project files and blame](./docs/products/code/assets/04-files-editor-blame.png)
 
-![Separate Review entry points for tracked and untracked workspace changes](./docs/products/code/assets/10-review-workflow.png)
-
 ## Supported Agent Paths
 
 Farming discovers installed CLIs on the host. The richer structured runtime currently applies to providers with ACP support; other detected coding agents remain first-class terminal sessions.
@@ -119,10 +124,6 @@ The first authenticated start stores a readable random token in `~/.farming/.ses
 
 Desktop keeps the project, conversation, files, and review close together. Mobile focuses one conversation, terminal, or file at a time and moves navigation into a drawer, making it useful for checking progress and sending a short intervention.
 
-<p align="center">
-  <img src="./docs/products/code/assets/05-mobile-agent-chat.jpg" alt="Farming Code on mobile" width="320">
-</p>
-
 Farming CRT is currently a desktop interface. Use Farming Code from a phone; CRT mobile concepts are not part of the supported product yet.
 
 ## Installation And Updates
@@ -157,7 +158,7 @@ Development host
 
 The backend owns lifecycle, authentication, session routing, workspace boundaries, history, and configuration. Interactive terminal sessions use a separate native PTY host by default, allowing browser and server reconnection without replacing the live process. The browser terminal renderer defaults to xterm.js WebGL as its single supported product path; the Ghostty web adapter remains an explicit debug path, not a runtime fallback.
 
-Runtime settings live in `~/.farming/settings.json`. Farming session metadata, the project membership index, archived runs, theme settings, update state, logs, and the startup token use separate files under `~/.farming/`. External provider histories remain read-only integrations.
+Runtime settings live in `~/.farming/settings.json`. Farming session metadata, the project membership index, archived runs, theme settings, update state, logs, and the startup token use separate files under `~/.farming/`. External provider histories remain read-only integrations except for explicit Codex archive and unarchive lifecycle actions.
 
 ## Security
 

package/README.zh_cn.md

@@ -51,6 +51,13 @@ Farming 2 在同一批 Agent 和 Session 上提供两套完整的浏览器界面
 
 切换界面不会重启或复制 Agent。如果 Farming Code 启动或渲染失败，有限范围的诊断层仍会保留后面的实时 CRT 界面，而不是把正在运行的 Session 一起遮掉。
 
+不修改地址也可以直接切换：
+
+- **Farming Code → CRT：**点击左下角齿轮，打开**界面**，再选择 **Farming CRT**。
+- **Farming CRT → Code：**按 `S`（或点击 **[S] SETTINGS**），在 **UI Theme** 中选择 **Farming Code**。
+
+条件允许时，Farming 会把当前聚焦的 Agent 一起带到另一套界面。两边继续使用同一个实时 Agent 和 Provider Session；这里只切换界面，不会重启会话。
+
 完整能力矩阵和截图导览见 [Farming 2 产品总览](./docs/products/README.zh_cn.md)。两套界面的完整流程分别见 [Farming Code 指南](./docs/products/code/README.zh_cn.md) 和 [Farming CRT 指南](./docs/products/crt/README.zh_cn.md)。
 
 ## Farming Net：部署门户
@@ -74,8 +81,6 @@ FARMING_NET_PORT=6693 FARMING_NET_BASE_PATH=/farming-net npm run start:net
 
 ![Farming Code 项目文件与 Blame](./docs/products/code/assets/04-files-editor-blame.png)
 
-![Files 中分开的已跟踪与未跟踪 Review 入口](./docs/products/code/assets/10-review-workflow.png)
-
 ## 支持的 Agent 路径
 
 Farming 会发现开发机上已经安装的 CLI。有 ACP 支持的 Provider 使用更完整的结构化运行时，其他检测到的 Coding Agent 仍然可以作为一等 Terminal Session 使用。
@@ -119,10 +124,6 @@ farming stop
 
 桌面端把项目、对话、文件和 Review 放在彼此靠近的位置。移动端一次聚焦一段对话、一个终端或一个文件，并把导航移入抽屉，更适合查看进度和发送短介入。
 
-<p align="center">
-  <img src="./docs/products/code/assets/05-mobile-agent-chat.jpg" alt="Farming Code 手机界面" width="320">
-</p>
-
 Farming CRT 当前只作为桌面界面使用。手机请使用 Farming Code；CRT 手机方案目前仍是概念设计，不属于已支持的产品能力。
 
 ## 安装与更新
@@ -157,7 +158,7 @@ Development host
 
 后端负责生命周期、鉴权、Session 路由、Workspace 边界、History 和配置。交互式 Terminal 默认由独立的原生 PTY Host 持有，因此浏览器和 Server 可以重新连接，而不需要替换实际进程。xterm.js WebGL 是唯一受支持的产品 Terminal Renderer；Ghostty Web Adapter 只保留为显式调试路径，不作为运行时 Fallback。
 
-运行时设置存放在 `~/.farming/settings.json`。Farming Session 元数据、项目成员索引、归档运行、主题设置、更新状态、日志和启动 Token 使用 `~/.farming/` 下彼此独立的文件。外部 Provider History 仍然只读。
+运行时设置存放在 `~/.farming/settings.json`。Farming Session 元数据、项目成员索引、归档运行、主题设置、更新状态、日志和启动 Token 使用 `~/.farming/` 下彼此独立的文件。外部 Provider History 保持只读，但明确的 Codex archive / unarchive 生命周期操作除外。
 
 ## 安全
 

package/backend/agent-manager.js

@@ -11,7 +11,7 @@ const {
   buildAgentSessionResumeCommand,
   findAgentSession,
 } = require('./agent-session-history');
-const { unarchiveCodexSession } = require('./codex-session-archive');
+const { archiveCodexSession, unarchiveCodexSession } = require('./codex-session-archive');
 const { buildAgentProviderSessionPlan, sessionFromExactResumeSource } = require('./agent-provider-session');
 const { resolveAgentExecutable, resolveCompatibleCodexExecutable } = require('./executable-discovery');
 const { ensureMainAgentSkillFiles, renderMainAgentBootstrap } = require('./main-agent-skills');
@@ -62,6 +62,7 @@ const {
 const { inspectGitWorktree } = require('./git-worktree-info');
 const { deserializeTerminalState } = require('./terminal-state-serialization');
 const { compareNativePtyRuntimeEpochs } = require('./native-pty-controller-generation');
+const { canonicalWorkspacePath } = require('./workspace-root-registry');
 
 const SESSION_OUTPUT_LIMIT = 10000;
 const AGENT_USAGE_RATE_WINDOW_MS = 5 * 60 * 1000;
@@ -581,6 +582,7 @@ class AgentManager extends EventEmitter {
           }
         : {}),
     });
+    this.archiveCodexSession = options.archiveCodexSession || archiveCodexSession;
     this.unarchiveCodexSession = options.unarchiveCodexSession || unarchiveCodexSession;
     this.heartbeatInterval = null;
     this.disposed = false;
@@ -4201,23 +4203,26 @@ class AgentManager extends EventEmitter {
       : this.markAgentReadCursor(agentId);
   }
 
-  async createForkWorktree(workspace) {
+  async resolveGitWorktreeSourceRoot(workspace) {
     const sourceWorkspace = this.expandWorkspacePath(workspace);
     if (!sourceWorkspace) {
       throw new Error('Source workspace is empty');
     }
 
-    let root;
     try {
       const { stdout } = await execFileAsync('git', ['-C', sourceWorkspace, 'rev-parse', '--show-toplevel'], {
         timeout: 15000,
         maxBuffer: 1024 * 1024,
       });
-      root = stdout.trim();
+      return stdout.trim();
     } catch (error) {
       const message = error && error.stderr ? String(error.stderr).trim() : '';
       throw new Error(message || 'Source workspace is not inside a git repository', { cause: error });
     }
+  }
+
+  async createForkWorktree(workspace) {
+    const root = await this.resolveGitWorktreeSourceRoot(workspace);
 
     const parentDir = path.dirname(root);
     const baseName = path.basename(root);
@@ -4242,6 +4247,70 @@ class AgentManager extends EventEmitter {
     return target;
   }
 
+  async createPermanentWorktree(workspace) {
+    const root = await this.resolveGitWorktreeSourceRoot(workspace);
+    const parentDir = path.dirname(root);
+    const baseName = path.basename(root);
+    const slug = timestampSlug();
+    let suffix = 1;
+
+    while (suffix < 1000) {
+      const suffixText = suffix === 1 ? '' : `-${suffix}`;
+      const target = path.join(parentDir, `${baseName}-farming-worktree-${slug}${suffixText}`);
+      const branch = `farming/worktree-${slug}${suffixText}`;
+      let branchExists = false;
+      try {
+        await execFileAsync('git', ['-C', root, 'show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+          timeout: 15000,
+          maxBuffer: 1024 * 1024,
+        });
+        branchExists = true;
+      } catch (error) {
+        if (error?.code !== 1) {
+          const message = error && error.stderr ? String(error.stderr).trim() : '';
+          throw new Error(message || 'Failed to inspect git branches', { cause: error });
+        }
+      }
+
+      if (!fs.existsSync(target) && !branchExists) {
+        try {
+          await execFileAsync('git', ['-C', root, 'worktree', 'add', '-b', branch, target, 'HEAD'], {
+            timeout: 60000,
+            maxBuffer: 1024 * 1024 * 4,
+          });
+        } catch (error) {
+          const message = error && error.stderr ? String(error.stderr).trim() : '';
+          throw new Error(message || 'Failed to create permanent git worktree', { cause: error });
+        }
+        return { workspace: target, branch, sourceWorkspace: root };
+      }
+      suffix += 1;
+    }
+
+    throw new Error('Unable to allocate a permanent worktree name');
+  }
+
+  async rollbackPermanentWorktree(created) {
+    if (!created?.workspace || !created?.sourceWorkspace) return;
+    try {
+      await execFileAsync('git', ['-C', created.sourceWorkspace, 'worktree', 'remove', '--force', created.workspace], {
+        timeout: 60000,
+        maxBuffer: 1024 * 1024 * 4,
+      });
+    } catch {
+      // Rollback is best-effort so the original create/persist failure remains visible.
+    }
+    if (!created.branch) return;
+    try {
+      await execFileAsync('git', ['-C', created.sourceWorkspace, 'branch', '-D', created.branch], {
+        timeout: 30000,
+        maxBuffer: 1024 * 1024 * 4,
+      });
+    } catch {
+      // The worktree removal may already have pruned the newly created branch.
+    }
+  }
+
   async inspectForkWorktreeProject(workspace) {
     const expanded = this.expandWorkspacePath(workspace);
     const resolvedWorkspace = expanded ? path.resolve(expanded) : '';
@@ -4537,8 +4606,38 @@ class AgentManager extends EventEmitter {
       reason: 'manual-archive',
       recordHistory: !isEphemeralShellAgent(agent),
     });
+    this.scheduleCodexSessionArchive(agent);
     return { agentId, archived: true, removed: true, removedMainPageSessionKeys };
   }
+
+  scheduleCodexSessionArchive(agent) {
+    if (
+      !agent
+      || agent.providerSessionProvider !== 'codex'
+      || !agent.providerSessionId
+      || agent.providerSessionTemporary === true
+    ) {
+      return;
+    }
+
+    const sessionId = agent.providerSessionId;
+    const session = {
+      cliVersion: agent.cliVersion || '',
+      cwd: agent.cwd || '',
+      workspace: agent.projectWorkspace || '',
+      providerHomePath: agent.providerHomePath || '',
+    };
+    void Promise.resolve()
+      .then(() => this.archiveCodexSession(sessionId, session))
+      .then(result => {
+        if (result?.error) {
+          console.error(`Failed to archive Codex session ${sessionId}: ${result.error}`);
+        }
+      })
+      .catch(error => {
+        console.error(`Failed to archive Codex session ${sessionId}:`, error);
+      });
+  }
   
   async killAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
@@ -4884,7 +4983,7 @@ class AgentManager extends EventEmitter {
         command: agent.command,
         engineName: agent.engineName || '',
         cwd: agent.cwd,
-        projectWorkspace: agent.projectWorkspace || '',
+        projectWorkspace: canonicalWorkspacePath(agent.projectWorkspace || ''),
         gitWorktree: publicAgentGitWorktree(agent),
         output: agent.output.slice(-2000),
         previewText: agent.previewText || '',

package/backend/codex-session-archive.js

@@ -5,7 +5,7 @@ const { resolveCompatibleCodexExecutable } = require('./executable-discovery');
 
 const execFileAsync = promisify(execFile);
 
-async function unarchiveCodexSession(sessionId, session = {}, options = {}) {
+async function runCodexSessionArchiveCommand(action, sessionId, session = {}, options = {}) {
   const resolveExecutable = options.resolveCompatibleCodexExecutable || resolveCompatibleCodexExecutable;
   const runExecFile = options.execFileAsync || execFileAsync;
   const processEnv = options.processEnv || process.env;
@@ -18,7 +18,7 @@ async function unarchiveCodexSession(sessionId, session = {}, options = {}) {
   }
 
   try {
-    await runExecFile(codexResolution.path || 'codex', ['unarchive', sessionId], {
+    await runExecFile(codexResolution.path || 'codex', [action, sessionId], {
       cwd: session.cwd || session.workspace || os.homedir(),
       env: session.providerHomePath
         ? { ...processEnv, CODEX_HOME: session.providerHomePath }
@@ -26,13 +26,13 @@ async function unarchiveCodexSession(sessionId, session = {}, options = {}) {
       timeout: 30_000,
       maxBuffer: 1024 * 1024,
     });
-    return { unarchived: true };
+    return { [action === 'archive' ? 'archived' : 'unarchived']: true };
   } catch (error) {
     const message = [
       error && error.stdout ? String(error.stdout).trim() : '',
       error && error.stderr ? String(error.stderr).trim() : '',
       error && error.message ? String(error.message).trim() : '',
-    ].filter(Boolean).join('\n') || 'failed to unarchive Codex session';
+    ].filter(Boolean).join('\n') || `failed to ${action} Codex session`;
     return {
       error: message,
       status: 409,
@@ -40,6 +40,15 @@ async function unarchiveCodexSession(sessionId, session = {}, options = {}) {
   }
 }
 
+async function archiveCodexSession(sessionId, session = {}, options = {}) {
+  return runCodexSessionArchiveCommand('archive', sessionId, session, options);
+}
+
+async function unarchiveCodexSession(sessionId, session = {}, options = {}) {
+  return runCodexSessionArchiveCommand('unarchive', sessionId, session, options);
+}
+
 module.exports = {
+  archiveCodexSession,
   unarchiveCodexSession,
 };

package/backend/config-manager.js

@@ -73,6 +73,7 @@ const PERSISTED_SETTING_KEYS = new Set([
   'lastMainWorkspace',
   'workspaceHistory',
   'projectWorkspaces',
+  'pinnedProjectWorkspaces',
   'projectNames',
   'theme',
   'appearance',
@@ -287,6 +288,7 @@ class ConfigManager {
         lastMainWorkspace: this.farmingDir,
         workspaceHistory: [],
         projectWorkspaces: [],
+        pinnedProjectWorkspaces: [],
         projectNames: {},
         theme: 'terminal',
         appearance: 'light',
@@ -322,6 +324,7 @@ class ConfigManager {
       lastMainWorkspace: this.farmingDir,
       workspaceHistory: [],
       projectWorkspaces: [],
+      pinnedProjectWorkspaces: [],
       projectNames: {},
       theme: 'terminal',
       appearance: 'light',
@@ -371,6 +374,7 @@ class ConfigManager {
     this.settings.lastMainWorkspace = this.normalizeMainWorkspace(this.settings.lastMainWorkspace, this.farmingDir);
     this.settings.workspaceHistory = this.normalizeWorkspaceHistory(this.settings.workspaceHistory);
     this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
+    this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
     this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
     this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
     if (this.settings.updateUrl === LEGACY_DEFAULT_UPDATE_URL || this.settings.updateUrl === API_DEFAULT_UPDATE_URL) {
@@ -813,6 +817,7 @@ class ConfigManager {
     this.settings.lastMainWorkspace = this.normalizeMainWorkspace(this.settings.lastMainWorkspace, previousMainWorkspace);
     this.settings.workspaceHistory = this.normalizeWorkspaceHistory(this.settings.workspaceHistory);
     this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
+    this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
     this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
     this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
     this.settings.updateUrl = this.normalizeUpdateUrl(this.settings.updateUrl);

package/backend/executable-discovery.js

@@ -4,6 +4,7 @@ const { execFileSync } = require('child_process');
 const { getUserLaunchAgents } = require('./cli-agents');
 
 const DEFAULT_CODEX_APP_BIN = '/Applications/Codex.app/Contents/Resources/codex';
+const DEFAULT_CHATGPT_APP_CODEX_BIN = '/Applications/ChatGPT.app/Contents/Resources/codex';
 const executableVersionCache = new Map();
 
 function getPathDirectories(pathEnv = process.env.PATH || '') {
@@ -90,6 +91,7 @@ function getPreferredExecutableCandidates(agentName, pathEnv = process.env.PATH
   return [
     process.env.FARMING_CODEX_BIN || '',
     DEFAULT_CODEX_APP_BIN,
+    DEFAULT_CHATGPT_APP_CODEX_BIN,
     ...pathCandidates,
   ].filter(Boolean);
 }

package/backend/server.js

@@ -5,6 +5,8 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const crypto = require('crypto');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
 const { URLSearchParams, pathToFileURL } = require('url');
 const AgentManager = require('./agent-manager');
 const { runtimeKind } = require('./agent-runtime-binding');
@@ -85,6 +87,7 @@ const WS_PATH = routePath(BASE_PATH, '/ws');
 const encodeCookieToken = TokenAuth.encodeCookieToken;
 const MAX_CODEX_TRANSCRIPT_TURNS = 1000;
 const INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS = 3_000;
+const execFileAsync = promisify(execFile);
 
 const app = express();
 const server = http.createServer(app);
@@ -1427,6 +1430,65 @@ app.post(routePath(BASE_PATH, '/api/agents/:agentId/fork'), express.json(), asyn
   res.status(201).json(result);
 });
 
+function resolveProjectActionRoot(rootId) {
+  const root = workspaceRootRegistry.resolve(rootId);
+  if (!root || root.kind === 'global') {
+    throw new WorkspaceFileError('project workspace is required', 400);
+  }
+  return root;
+}
+
+app.post(routePath(BASE_PATH, '/api/projects/reveal'), express.json(), async (req, res) => {
+  try {
+    const root = resolveProjectActionRoot(req.body?.rootId);
+    const command = process.platform === 'darwin'
+      ? 'open'
+      : process.platform === 'win32'
+        ? 'explorer'
+        : 'xdg-open';
+    await execFileAsync(command, [root.canonicalPath], {
+      timeout: 15000,
+      maxBuffer: 1024 * 1024,
+    });
+    res.json({ revealed: true, workspace: root.canonicalPath });
+  } catch (error) {
+    const status = error instanceof WorkspaceFileError ? error.statusCode : 500;
+    res.status(status).json({ error: error.message || 'Failed to reveal project workspace' });
+  }
+});
+
+app.post(routePath(BASE_PATH, '/api/projects/create-worktree'), express.json(), async (req, res) => {
+  let created = null;
+  let previousProjects = null;
+  try {
+    const root = resolveProjectActionRoot(req.body?.rootId);
+    created = await agentManager.createPermanentWorktree(root.canonicalPath);
+    previousProjects = configManager.getSettings().projectWorkspaces || [];
+    configManager.updateSettings({
+      projectWorkspaces: [
+        created.workspace,
+        ...previousProjects.filter(workspace => workspace !== created.workspace),
+      ],
+    });
+    res.status(201).json({
+      workspace: created.workspace,
+      branch: created.branch,
+      projectWorkspaces: configManager.getSettings().projectWorkspaces,
+    });
+  } catch (error) {
+    if (created) await agentManager.rollbackPermanentWorktree(created);
+    if (previousProjects) {
+      try {
+        configManager.updateSettings({ projectWorkspaces: previousProjects });
+      } catch {
+        // Keep the original error visible; the failed settings write is already the root cause.
+      }
+    }
+    const status = error instanceof WorkspaceFileError ? error.statusCode : 400;
+    res.status(status).json({ error: error.message || 'Failed to create permanent worktree' });
+  }
+});
+
 app.post(routePath(BASE_PATH, '/api/projects/delete-worktree'), express.json(), async (req, res) => {
   const body = req.body || {};
   const workspace = typeof body.workspace === 'string' ? body.workspace : '';

package/backend/usage-monitor.js

@@ -9,8 +9,8 @@ const { attachQuotaForecasts } = require('./usage-forecast');
 const execFileAsync = promisify(execFile);
 
 const USAGE_WINDOW_MS = 5 * 60 * 1000;
-const USAGE_TIMELINE_WINDOW_MS = 60 * 60 * 1000;
-const USAGE_TIMELINE_BUCKET_COUNT = 30;
+const USAGE_TIMELINE_WINDOW_MS = 24 * 60 * 60 * 1000;
+const USAGE_TIMELINE_BUCKET_COUNT = 24;
 const USAGE_DAILY_DAYS = 52 * 7;
 const USAGE_DAILY_CACHE_MS = 5 * 60 * 1000;
 const USAGE_LIVE_DAY_CACHE_MS = 5 * 1000;
@@ -152,6 +152,32 @@ function addTokenBreakdown(target, source) {
   return target;
 }
 
+function usageAgentIdFromFilePath(filePath) {
+  const basename = path.basename(String(filePath || ''), path.extname(String(filePath || '')));
+  const uuid = basename.match(/([0-9a-f]{8}-[0-9a-f-]{27})$/i);
+  return uuid?.[1] || basename || 'unattributed';
+}
+
+function usageAgentLabel(provider, agentId) {
+  const providerName = {
+    codex: 'Codex',
+    claude: 'Claude',
+    opencode: 'OpenCode',
+    qoder: 'Qoder',
+  }[provider] || provider;
+  if (!agentId || agentId === 'unattributed') return providerName;
+  const shortId = agentId.length > 12 ? `…${agentId.slice(-6)}` : agentId;
+  return `${providerName} · ${shortId}`;
+}
+
+function attributeUsageEvent(event, provider, agentId) {
+  return {
+    ...event,
+    agentId,
+    agentLabel: usageAgentLabel(provider, agentId),
+  };
+}
+
 function subtractTokenBreakdown(current, previous) {
   const result = emptyTokenBreakdown();
   for (const field of Object.keys(result)) {
@@ -268,7 +294,9 @@ function buildUsageTimeline(providerEvents, options = {}) {
   const windowMs = Math.max(60_000, options.windowMs ?? USAGE_TIMELINE_WINDOW_MS);
   const bucketCount = Math.max(1, Math.floor(options.bucketCount ?? USAGE_TIMELINE_BUCKET_COUNT));
   const bucketMs = windowMs / bucketCount;
-  const endAt = now;
+  const endAt = options.alignToBucket
+    ? Math.ceil(now / bucketMs) * bucketMs
+    : now;
   const startAt = endAt - windowMs;
   const providerNames = Object.keys(providerEvents || {});
   const points = Array.from({ length: bucketCount }, (_, index) => ({
@@ -652,11 +680,14 @@ function buildUsageDayDetail(providerEvents, options = {}) {
     hour,
     label: String(hour).padStart(2, '0'),
     ...emptyTokenBreakdown(),
+    agents: {},
   }));
   const providers = Object.fromEntries(
     providerNames.map(provider => [provider, emptyTokenBreakdown()]),
   );
   const total = emptyTokenBreakdown();
+  const agents = new Map();
+  const agentLabels = options.agentLabels instanceof Map ? options.agentLabels : new Map();
 
   for (const provider of providerNames) {
     for (const event of providerEvents[provider] || []) {
@@ -664,8 +695,24 @@ function buildUsageDayDetail(providerEvents, options = {}) {
       if (localDateKey(timestamp) !== date) continue;
       const hour = new Date(timestamp).getHours();
       if (!Number.isInteger(hour) || hour < 0 || hour > 23) continue;
+      const agentId = String(event?.agentId || 'unattributed');
+      const agentKey = `${provider}:${agentId}`;
+      let agent = agents.get(agentKey);
+      if (!agent) {
+        agent = {
+          key: agentKey,
+          provider,
+          sessionId: agentId === 'unattributed' ? '' : agentId,
+          label: agentLabels.get(agentKey) || event?.agentLabel || usageAgentLabel(provider, agentId),
+          ...emptyTokenBreakdown(),
+        };
+        agents.set(agentKey, agent);
+      }
+      if (!hours[hour].agents[agentKey]) hours[hour].agents[agentKey] = emptyTokenBreakdown();
       addTokenBreakdown(hours[hour], event);
+      addTokenBreakdown(hours[hour].agents[agentKey], event);
       addTokenBreakdown(providers[provider], event);
+      addTokenBreakdown(agent, event);
       addTokenBreakdown(total, event);
     }
   }
@@ -677,6 +724,9 @@ function buildUsageDayDetail(providerEvents, options = {}) {
     total,
     hours,
     providers,
+    agents: Array.from(agents.values()).sort((left, right) => (
+      right.totalTokens - left.totalTokens || left.label.localeCompare(right.label)
+    )),
   };
 }
 
@@ -709,9 +759,11 @@ async function readDailyFileEvents(filePath, provider, minimumMtimeMs = 0) {
     }
   }
 
+  const agentId = usageAgentIdFromFilePath(filePath);
+  const attributedEvents = events.map(event => attributeUsageEvent(event, provider, agentId));
   const truncated = stat.size > JSONL_TAIL_BYTES;
-  dailyFileEventCache.set(cacheKey, { signature, events, truncated });
-  return { events, mtimeMs: stat.mtimeMs, truncated };
+  dailyFileEventCache.set(cacheKey, { signature, events: attributedEvents, truncated });
+  return { events: attributedEvents, mtimeMs: stat.mtimeMs, truncated };
 }
 
 async function collectCodexDailyEventsWithRipgrep(roots, options = {}) {
@@ -765,7 +817,9 @@ async function collectCodexDailyEventsWithRipgrep(roots, options = {}) {
         states.set(filePath, state);
       }
       const event = codexTokenEventFromRecord(record, state);
-      if (event && event.timestamp >= cutoffMs && event.timestamp <= now + 60_000) events.push(event);
+      if (event && event.timestamp >= cutoffMs && event.timestamp <= now + 60_000) {
+        events.push(attributeUsageEvent(event, 'codex', usageAgentIdFromFilePath(filePath)));
+      }
     });
     child.once('close', code => {
       if (unavailable || (code !== 0 && code !== 1)) {
@@ -892,7 +946,8 @@ async function collectOpenCodeDailyEvents(homePaths, options = {}) {
           { openCodeHome: session.openCodeHome, timeoutMs: OPENCODE_COMMAND_TIMEOUT_MS },
         );
         const exported = JSON.parse(String(result?.stdout || '{}'));
-        const sessionEvents = openCodeTokenEventsFromExport(exported, { cutoffMs, now });
+        const sessionEvents = openCodeTokenEventsFromExport(exported, { cutoffMs, now })
+          .map(event => attributeUsageEvent(event, 'opencode', session.id));
         successfulExports += 1;
         openCodeSessionEventCache.set(cacheKey, { updatedAt: session.updatedAt, events: sessionEvents });
         events.push(...sessionEvents);
@@ -1212,6 +1267,33 @@ class UsageMonitor {
     this.liveDayCache.fetchedAt = 0;
   }
 
+  usageAgentLabels() {
+    const labels = new Map();
+    const agents = this.agentManager?.getState?.().agents;
+    if (!Array.isArray(agents)) return labels;
+    for (const agent of agents) {
+      const provider = String(agent?.providerSessionProvider || '').trim();
+      const sessionId = String(agent?.providerSessionId || '').trim();
+      if (!provider || !sessionId) continue;
+      const label = String(
+        agent.customTitle
+        || agent.task
+        || agent.sessionTitle
+        || agent.providerSessionTitle
+        || '',
+      ).trim();
+      if (label) labels.set(`${provider}:${sessionId}`, label);
+    }
+    return labels;
+  }
+
+  buildUsageDay(providerEvents, date) {
+    return buildUsageDayDetail(providerEvents, {
+      date,
+      agentLabels: this.usageAgentLabels(),
+    });
+  }
+
   getDailyUsage(options = {}) {
     const now = options.now ?? Date.now();
     if (
@@ -1247,7 +1329,7 @@ class UsageMonitor {
     if (options.live === true && String(date || '').trim() === localDateKey(now)) {
       const liveDate = String(date).trim();
       const dailyFallback = this.dailyCache.value?.providerEvents
-        ? buildUsageDayDetail(this.dailyCache.value.providerEvents, { date: liveDate })
+        ? this.buildUsageDay(this.dailyCache.value.providerEvents, liveDate)
         : null;
       const cachedFallback = this.liveDayCache.date === liveDate
         ? this.liveDayCache.value
@@ -1283,7 +1365,7 @@ class UsageMonitor {
         now,
         days: 1,
       }).then(history => {
-        const detail = buildUsageDayDetail(history.providerEvents, { date: liveDate });
+        const detail = this.buildUsageDay(history.providerEvents, liveDate);
         if (this.liveDayCache.date === liveDate) {
           this.liveDayCache.value = detail;
           this.liveDayCache.fetchedAt = now;
@@ -1299,7 +1381,7 @@ class UsageMonitor {
       now,
       force: options.fresh === true,
     });
-    return buildUsageDayDetail(history.providerEvents, { date });
+    return this.buildUsageDay(history.providerEvents, date);
   }
 
   async getUsageSummary(options = {}) {
@@ -1330,11 +1412,11 @@ class UsageMonitor {
       historyWindowMs,
       source: 'opencode session export',
     });
-    const timeline = buildUsageTimeline({
-      codex: codexUsage.tokenEvents,
-      claude: claudeUsage.tokenEvents,
-      opencode: openCodeUsage.tokenEvents,
-    }, { now, windowMs: historyWindowMs });
+    const timeline = buildUsageTimeline(history.providerEvents, {
+      now,
+      windowMs: historyWindowMs,
+      alignToBucket: true,
+    });
     const openCodeCoverage = history.coverage.find(entry => entry.provider === 'opencode');
     const qoderCoverage = history.coverage.find(entry => entry.provider === 'qoder');