@loicngr/kobo 2.1.24 → 2.1.26

package/AGENTS.md

@@ -149,6 +149,30 @@ src/
 
 Tasks have `role` (`work | finalization`) and structured `verification`. MCP and HTTP share transactional task mutations. An auto-loop task cannot become done without passing reported checks. Finalization runs after all other tasks/criteria, is invalidated by scope changes, and is mandatory before completion. The proof is agent-reported evidence, not server-side execution of arbitrary commands.
 
+## Provider account switching
+
+The usage popover integrates optional `ccswap` for Claude Code and Codex. Select
+accounts for the viewed session's engine, falling back to the workspace engine.
+Missing executable hides account controls; it must not hide existing Claude
+usage. Codex account support is separate from quota snapshot support.
+
+`provider-accounts-service.ts` owns subprocess invocation and sanitization. Use
+provider allowlists, numeric slots and bounded `execFile`, never shell text. Keep
+credential mutations serialized with their validation. Return only display
+metadata; do not forward raw CLI JSON, stderr, tokens or credential paths. Inherit
+the Kōbō process user, HOME, PATH and credential-directory environment: in Docker,
+the CLI must run inside that container, not on the host. Do not install tools or
+perform real switches in tests.
+
+A switch changes the provider-wide credential store, not a workspace identity.
+Do not automatically stop agents, migrate conversations, copy settings/skills or
+promise that an existing process hot-reloads authentication. Invalidate Claude
+quota data around switches and reject results from earlier in-flight polls.
+Keep frontend requests scoped across provider/session changes and handle missing,
+empty, disabled, unrecognized and failed account states without automatic retries.
+See [configuration](./CONFIGURATION.md#switch-claude-code-and-codex-accounts-with-ccswap)
+and [VPS setup](./docs/vps-projects-and-skills.md#switch-engine-accounts-inside-the-container).
+
 ## Persistent memory
 
 Kōbō memory is independent of provider chat history/native memory and shared by Claude Code and Codex. `memoryMode` is a global setting defaulting to `hybrid`: Manual permits reads only; Hybrid applies workspace writes and proposes project/global writes; Automatic applies writes to the explicitly targeted scope. Mode is checked per operation, so a setting change affects existing agent sessions; pending/rejected proposals are never automatically approved or revived. Plan/review/report-only capabilities cannot write.
@@ -223,6 +247,13 @@ reopen a closed database. Startup reconciles lost internal reporters while
 preserving external ones. An interrupted reporter is not proof of cancelled
 background work. Operational reporting never satisfies auto-loop verification.
 
+Progress without measured counts is labelled explicitly, and the panel shows the
+age of a report after two minutes without a newer one. This local clock must not
+poll or mutate progress. Claude's per-launch PostToolUse advisory tracks only
+observed managed progress responses, separates parent/subagent producers, and
+limits reminders by action count and elapsed time. Do not infer percentages,
+automatically complete bars, or block agent shutdown for missing reports.
+
 Retain scoped activity-key fingerprints, producer sequences and dismissed rows
 for retries; subsequent updates cannot resurrect a dismissed indicator or undo a
 terminal state. Bound labels, steps, page size, active/retained records and update
@@ -747,6 +778,14 @@ Snapshot each target and its delivery mode before scheduling: auto-loop uses `ne
 
 ### File editing in the diff viewer
 
+The diff defaults to inline view. Busy workspace status or known live controller disables
+Edit with an explanatory tooltip, and updates Monaco to read-only without discarding
+the current buffer. Historical commit comparisons remain read-only. Unpushed mode
+lists local commits plus working-tree changes (including non-ignored untracked files)
+against the branch remote ref, falling back to the source branch before the first push.
+The list and file-content routes must use the same baseline semantics; failed Git
+reads must not be reported as an empty, clean diff.
+
 The right panel of `DiffViewer.vue` is editable when the workspace agent is stopped and the file is not in `deleted` status. `Ctrl/Cmd+S` or the explicit Save button persists the file via `POST /api/workspaces/:id/save-file`, sending `{ path, content, baseSha }` where `baseSha` is the sha256 captured at `GET /diff-file` time. The route refuses with **412 Precondition Failed** + `{ currentSha }` if the on-disk content has changed; the client shows a Reload / Keep mine dialog. Worktree-traversal guards (including parent-symlink escapes) and a 1 MB size cap live in `file-editor-service.ts`. Changing files in the tree while dirty pops an "Unsaved changes" prompt.
 
 ## Code conventions

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 2.1.26
+
+- feat: switch Claude and Codex accounts with ccswap
+
+## 2.1.25
+
+- feat: improve merge options, diff controls and progress reporting
+
 ## 2.1.24
 
 - feat: add MCP attachments and immediate chat delivery

package/CONFIGURATION.md

@@ -949,6 +949,20 @@ resume, not retroactively to an already running agent.
 
 The service retains at most 1,000 indicators per session, with at most 32 running
 at once. Hidden records are retained so retries cannot recreate dismissed bars.
+When a bar has no numeric total, the UI explicitly says **Progress not quantified**.
+After two minutes without a newer report it shows **No update for N min**. This
+is the age of the last received report, not proof that work stopped. The display
+clock does not poll the server or manufacture progress.
+
+Claude launches with progress tools also receive a bounded `PostToolUse` reminder:
+once on creation, then after at least eight subsequent tool completions and one
+minute without a report. Reminders are scoped to the producing agent/subagent,
+use the last observed sequence, and follow an explicit reporting handoff. They
+are advisory: no extra tool calls, automatic percentages or blocking stop hooks.
+Codex and external clients retain the shared MCP reporting guidance. Agents must
+supply measured counts when a real test total or fixed checklist is available;
+step-only updates correctly change the description without filling the gauge.
+
 The [MCP progress guide](src/mcp-server/README.md#session-progress-tools) documents
 arguments, ordering, retry behavior and update limits.
 
@@ -1535,6 +1549,65 @@ When a Codex session is already working, **Send now** sends a queued chat messag
 
 The selector reads [`src/shared/codex-models.ts`](./src/shared/codex-models.ts). This checkout lists GPT-6 Astra, GPT-5.6 Sol/Terra/Luna, GPT-5.5 and older variants; availability depends on your account and authentication. Kōbō exposes effort values `auto`, `none`, `low`, `medium`, `high`, `xhigh`, and `max`, as declared in the engine's capabilities. The runtime must support the selected model/effort combination. Both selectors switch when you change the engine.
 
+### Switch Claude Code and Codex accounts with ccswap
+
+The usage popover in the chat footer can show the current **managed account**
+and switch to another account registered in [ccswap](https://github.com/errhythm/ccswap).
+It follows the selected session's engine, falling back to the workspace engine.
+Choose an account and explicitly click **Switch account**. Claude Code and Codex
+have separate account lists; switching one does not switch the other.
+
+ccswap is optional and is not bundled with Kōbō. Without its executable, Kōbō
+shows no account selector or installation notice; existing Claude usage indicators
+continue to work. Codex account controls do not imply that Claude-style quota
+buckets are available for Codex.
+
+Install and register accounts **as the same operating-system user and in the
+same environment as the Kōbō server**. The integration uses ccswap's JSON CLI
+(tested with 0.37.0). With `uv` already installed:
+
+```bash
+uv tool install ccswap
+# After logging into Claude Code with each account:
+ccswap add
+# After `codex login` with each Codex account:
+ccswap codex add
+ccswap list --provider claude
+ccswap codex list
+```
+
+Register the current login before switching so ccswap can preserve it. Account
+registration, login renewal, aliases and removal remain CLI operations. A disabled
+account cannot be selected in Kōbō. If no managed account matches the current
+login, the panel reports an unknown account rather than guessing from a slot.
+
+**Scope:** switching changes that provider's active credentials for the server
+user, shared by all Kōbō workspaces and other tools using that same login store.
+It is not a per-workspace account assignment. Kōbō keeps its worktrees, conversation
+history, settings and skills; it does not copy profiles or automatically restart
+agents. The displayed account identifies the active credential store, not proof
+that an already-running process has adopted it. Stop and resume the affected
+sessions if they still use the previous account, especially with Codex. Existing
+API-key or custom-provider authentication can take precedence over a saved login.
+
+The adapter inherits absolute `CLAUDE_CONFIG_DIR` on Linux and `CODEX_HOME`.
+Empty or relative authentication-directory overrides are refused: server and workspace
+processes can have different working directories. Claude switching is also refused
+with `CLAUDE_SECURESTORAGE_CONFIG_DIR` set, or with any nonempty `CLAUDE_CONFIG_DIR`
+on macOS (even the explicit default path), because the corresponding Keychain
+write is not verified by this integration. Use the native login workflow for
+those configurations.
+
+Claude usage is invalidated and refreshed after a switch. A failed refresh is
+not shown as the new account's old quota. Switching failures do not trigger an
+automatic retry: refresh the account list to check the actual state before trying
+again. The server exposes display metadata only, never ccswap's credential files
+or raw command output.
+
+For Docker/VPS, installing ccswap on your PC or on the VPS host is insufficient:
+it must be reachable on **Kōbō's container PATH**, with the same runtime home and
+credential-directory environment. See [VPS account setup](./docs/vps-projects-and-skills.md#switch-engine-accounts-inside-the-container).
+
 ### Permission modes
 
 Claude Code uses SDK permission modes; Codex uses sandbox and approval flags. These controls differ by engine. A Git worktree itself is not a security boundary.
@@ -1788,6 +1861,40 @@ Adapt the port stride, the `APP_NAME`, and any extra `*_PORT` keys to your stack
 
 Kōbō can open pull requests (GitHub or Bitbucket) or merge requests (GitLab) directly from the Git panel. The **forge** setting controls which service is used for a given project.
 
+### Review and edit a diff
+
+The diff viewer opens in **Inline** view. Use **Side by side** to change the layout.
+While an agent is working, **Edit** is disabled and its tooltip explains why;
+the diff remains readable and review comments remain available. The editor also
+becomes read-only if an agent starts while the diff is open. Stop the agent to
+resume editing. Server-side save checks remain in force.
+
+**Unpushed** compares the current working tree with `origin/<workingBranch>`:
+it includes local commits, staged and unstaged changes, deletions, and non-ignored
+untracked files. Before the first push, it uses the source branch instead. The
+header shows the comparison base. **Branch** retains its separate opt-in for
+untracked files. Comparing historical commits remains read-only.
+
+### Merge a pull request
+
+In the Git panel, **Merge PR** opens a confirmation. For GitHub, choose:
+
+- **Merge commit** (default): preserve the commits and create a merge commit.
+- **Squash and merge**: combine the changes into one commit on the target branch.
+- **Rebase and merge**: replay the commits on the target branch without a merge commit.
+
+The selection applies to this operation only. Kōbō rechecks PR readiness before
+calling the forge. Repository policies still apply: a disallowed method is
+reported as an error, with no automatic fallback or protection bypass. The
+source branch is kept; after a confirmed merge, remote deletion remains a
+separate confirmation. GitLab and Bitbucket retain their existing merge behavior.
+
+`POST /api/workspaces/:id/merge-pr` accepts optional JSON
+`{ "method": "merge" | "squash" | "rebase" }` for integrations advertising the
+corresponding `forge.capabilities.mergeMethods`. An omitted body keeps the
+existing provider default. Invalid values return 400; unsupported methods return
+409 before any merge command runs.
+
 ### Modes
 
 | Value | Behaviour |

package/README.md

@@ -64,7 +64,8 @@ Kōbō's production build is an installable PWA — use your browser's **Install
 - **Interactive Q&A**: an agent can pause mid-session to ask you a question through the UI instead of guessing.
 
   ![Agent asking a clarifying question, awaiting the user's answer](docs/assets/images/agent-question.png)
-- **Quota-aware**: 5-hour / 7-day Claude usage and Codex rate-limit buckets live in the footer; auto-loops can resume after a reset. Explicit cron/wakeup schedules can also resume work; a manual workspace does not restart solely because its quota resets.
+- **Quota-aware**: 5-hour / 7-day Claude usage is shown in the footer; engine-reported rate limits guide quota waits; auto-loops can resume after a reset. Explicit cron/wakeup schedules can also resume work; a manual workspace does not restart solely because its quota resets.
+- **Account switching**: with optional [ccswap](https://github.com/errhythm/ccswap), view and switch the active Claude Code or Codex account from the usage popover. Credentials are shared across workspaces using that engine; [setup and session behavior](./CONFIGURATION.md#switch-claude-code-and-codex-accounts-with-ccswap).
 - **Disk-space purge**: reclaim a merged workspace's `node_modules`/`vendor` weight without losing its chat history — see [`CONFIGURATION.md`](./CONFIGURATION.md#auto-purge-worktree-on-pr-merged).
 - **Lifecycle scripts**: shell scripts run on setup, cleanup, archive, session end, PR merge, or auto-loop stop, with output streamed into the chat.
 - **Observability**: a per-session timeline (duration, tools, tokens, errors) and a downloadable redacted diagnostic JSON.

package/dist/server/routes/usage.js

@@ -1,5 +1,6 @@
 import { Hono } from 'hono';
 import { getDb } from '../db/index.js';
+import { listProviderAccounts, ProviderAccountsError, switchProviderAccount, validateAccountId, } from '../services/provider-accounts-service.js';
 import { refreshNow } from '../services/usage/poller.js';
 import { clearReliabilityReset, computeEngineReliability, getReliabilityResetAt, resetReliability, } from '../services/usage/reliability.js';
 const app = new Hono();
@@ -39,6 +40,29 @@ app.delete('/reliability/reset', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+function accountError(error) {
+    return error instanceof ProviderAccountsError ? error : new ProviderAccountsError('accounts_command_failed');
+}
+app.get('/:providerId/accounts', async (c) => {
+    try {
+        return c.json(await listProviderAccounts(c.req.param('providerId')));
+    }
+    catch (error) {
+        const safe = accountError(error);
+        return c.json({ error: safe.message, code: safe.code }, safe.status);
+    }
+});
+app.post('/:providerId/accounts/switch', async (c) => {
+    try {
+        const body = await c.req.json().catch(() => null);
+        const accountId = validateAccountId(typeof body === 'object' && body !== null && 'accountId' in body ? body.accountId : undefined);
+        return c.json(await switchProviderAccount(c.req.param('providerId'), accountId));
+    }
+    catch (error) {
+        const safe = accountError(error);
+        return c.json({ error: safe.message, code: safe.code }, safe.status);
+    }
+});
 app.post('/:providerId/refresh', async (c) => {
     const providerId = c.req.param('providerId');
     try {

package/dist/server/routes/workspaces.js

@@ -1,6 +1,7 @@
 import { execFile as execFileCb, execFileSync, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { nanoid } from 'nanoid';
+import { isMergeMethod } from '../../shared/forge-merge.js';
 import { isWorkflowPolicy, resolveWorkflowPolicy, WORKFLOW_ACTIONS, } from '../../shared/workflow-policy.js';
 import * as finalReviewService from '../services/auto-loop-final-review-service.js';
 import { getReviewReturnStatus } from '../services/review-return-service.js';
@@ -3483,15 +3484,14 @@ app.get('/:id/git-stats', async (c) => {
 //   `origin/<sourceBranch>` (which can be ahead of the local ref when
 //   upstream landed merges Kōbō hasn't pulled). The handler refreshes
 //   `origin/<sourceBranch>` synchronously so the diff is never stale.
-// - `unpushed`: committed-only changes vs `origin/<workingBranch>`,
-//   i.e. what the next `git push` will send.
+// - `unpushed`: local commits + current worktree changes (including untracked)
+//   vs `origin/<workingBranch>`, falling back to the source branch before the first push.
 app.get('/:id/diff', async (c) => {
     try {
         const id = c.req.param('id');
         const rawMode = c.req.query('mode');
         const mode = rawMode === 'unpushed' ? 'unpushed' : rawMode === 'commits' ? 'commits' : 'branch';
-        // Opt-in flag from the diff viewer toggle. Only meaningful in `branch`
-        // mode — `unpushed` is committed-only by definition.
+        // Branch mode keeps its untracked opt-in; unpushed always includes local untracked files.
         const includeUntracked = c.req.query('includeUntracked') === '1';
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace) {
@@ -3525,7 +3525,7 @@ app.get('/:id/diff', async (c) => {
             await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
         }
         const files = mode === 'unpushed'
-            ? await gitOps.getUnpushedChangedFilesAsync(worktreePath, workspace.workingBranch)
+            ? await gitOps.getUnpushedChangedFilesAsync(worktreePath, workspace.workingBranch, 'origin', workspace.sourceBranch)
             : await gitOps.getChangedFilesAsync(worktreePath, workspace.sourceBranch, includeUntracked);
         c.header('Cache-Control', 'no-store');
         return c.json({
@@ -3533,6 +3533,11 @@ app.get('/:id/diff', async (c) => {
             mode,
             sourceBranch: workspace.sourceBranch,
             workingBranch: workspace.workingBranch,
+            ...(mode === 'unpushed'
+                ? {
+                    baseRef: await gitOps.resolveUnpushedBaseAsync(worktreePath, workspace.workingBranch, workspace.sourceBranch),
+                }
+                : {}),
         });
     }
     catch (err) {
@@ -3591,7 +3596,9 @@ app.get('/:id/diff-file', async (c) => {
                 to,
             });
         }
-        const baseRef = mode === 'unpushed' ? `origin/${workspace.workingBranch}` : workspace.sourceBranch;
+        const baseRef = mode === 'unpushed'
+            ? await gitOps.resolveUnpushedBaseAsync(worktreePath, workspace.workingBranch, workspace.sourceBranch)
+            : workspace.sourceBranch;
         const original = await gitOps.getFileAtRefAsync(worktreePath, baseRef, filePath);
         const modified = gitOps.getFileContent(worktreePath, filePath);
         c.header('Cache-Control', 'no-store');
@@ -4211,10 +4218,32 @@ app.post('/:id/merge-pr', async (c) => {
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace)
             return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const rawBody = await c.req.text();
+        let body = {};
+        if (rawBody.length > 0) {
+            let parsed;
+            try {
+                parsed = JSON.parse(rawBody);
+            }
+            catch {
+                return c.json({ error: 'Request body must be valid JSON' }, 400);
+            }
+            if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                return c.json({ error: 'Request body must be a JSON object' }, 400);
+            }
+            body = parsed;
+        }
+        const method = body.method;
+        if (method !== undefined && !isMergeMethod(method)) {
+            return c.json({ error: 'method must be merge, squash or rebase' }, 400);
+        }
         const provider = getForgeProvider(resolveForge(workspace.projectPath));
         if (!provider.capabilities.canMergeRequest) {
             return c.json({ error: 'This project has no forge that can merge the PR', code: 'forge_unsupported' }, 409);
         }
+        if (method !== undefined && !provider.capabilities.mergeMethods?.includes(method)) {
+            return c.json({ error: 'This forge does not support the requested merge method', code: 'merge_method_unsupported' }, 409);
+        }
         const availability = await provider.isAvailable(workspace.worktreePath);
         if (!availability.available) {
             return c.json({
@@ -4229,7 +4258,12 @@ app.post('/:id/merge-pr', async (c) => {
         if (!snapshot.readyToMerge) {
             return c.json({ error: 'This PR is not ready to merge', code: 'pr_not_ready' }, 409);
         }
-        await provider.mergeRequest(workspace.worktreePath, snapshot.number);
+        if (method === undefined) {
+            await provider.mergeRequest(workspace.worktreePath, snapshot.number);
+        }
+        else {
+            await provider.mergeRequest(workspace.worktreePath, snapshot.number, method);
+        }
         const merged = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
         return c.json({ success: true, merged: merged?.state === 'MERGED', branch: workspace.workingBranch });
     }

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -14,6 +14,7 @@ import { CLAUDE_CODE_CAPABILITIES } from './capabilities.js';
 import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from './event-mapper.js';
 import { buildClaudeOptions } from './options-builder.js';
 import { buildCompactionSessionStartOutput } from './precompact-hook.js';
+import { createProgressReportingHook } from './progress-reporting-hook.js';
 import { resolveClaudeBinaryPath } from './resolve-binary.js';
 import { buildStopHookOutput } from './stop-hook.js';
 /**
@@ -341,6 +342,7 @@ export function createClaudeCodeEngine() {
             const hooks = {
                 ...(options.mcpServers?.some((server) => server.name === 'kobo-tasks' && server.env.KOBO_PROGRESS_SESSION_TOKEN)
                     ? {
+                        PostToolUse: [{ hooks: [createProgressReportingHook()] }],
                         SubagentStart: [
                             {
                                 hooks: [

package/dist/server/services/agent/engines/claude-code/progress-reporting-hook.js

@@ -0,0 +1,99 @@
+import { PROGRESS_MAX_RETAINED, PROGRESS_MAX_RUNNING } from '../../../../../shared/progress-bars.js';
+function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function progressResponse(value) {
+    if (typeof value === 'string') {
+        if (value.length > 16_384)
+            return null;
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    const result = object(value);
+    if (result?.isError === true)
+        return null;
+    if (result && object(result.structuredContent))
+        return object(result.structuredContent);
+    const blocks = Array.isArray(value) ? value : result?.content;
+    if (Array.isArray(blocks)) {
+        for (const entry of blocks.slice(0, 4)) {
+            const item = object(entry);
+            if (item?.type !== 'text' || typeof item.text !== 'string' || item.text.length > 16_384)
+                continue;
+            try {
+                return object(JSON.parse(item.text));
+            }
+            catch {
+                /* Not a JSON progress response. */
+            }
+        }
+        return null;
+    }
+    return result;
+}
+/** Per-launch advisory only: no timers, tool calls, writes or stop-blocking loops. */
+export function createProgressReportingHook() {
+    const bars = new Map();
+    const retired = new Set();
+    const reminder = (entries) => ({
+        hookSpecificOutput: {
+            hookEventName: 'PostToolUse',
+            additionalContext: `Kōbō progress reporting: keep these existing activities current at actual milestones. Next update arguments: ${entries.map(([id, state]) => JSON.stringify({ progress_id: id, sequence: state.sequence + 1 })).join('; ')}. Add step and measured current/total when known; otherwise report step only. Call update_progress_bar after meaningful work, and finish_progress_bar with the known outcome before your final report. Do not invent progress, poll, repeat unchanged updates, recreate dismissed bars or finish background work that is still running.`,
+        },
+    });
+    return async (input) => {
+        if (input.hook_event_name !== 'PostToolUse' || retired.size >= PROGRESS_MAX_RETAINED)
+            return {};
+        const producer = JSON.stringify([input.session_id, input.agent_id ?? null]);
+        const tool = input.tool_name;
+        if (/^mcp__kobo-tasks__(create|update|finish)_progress_bar$/.test(tool)) {
+            const bar = progressResponse(input.tool_response);
+            if (!bar ||
+                typeof bar.id !== 'string' ||
+                !/^[\w-]{1,200}$/.test(bar.id) ||
+                !Number.isSafeInteger(bar.sequence) ||
+                bar.sequence < 0 ||
+                !['running', 'succeeded', 'failed', 'interrupted'].includes(bar.status))
+                return {};
+            if (retired.has(bar.id))
+                return {};
+            const existing = bars.get(bar.id);
+            if (existing && bar.sequence < existing.sequence)
+                return {};
+            if (bar.dismissed === true || bar.status !== 'running') {
+                bars.delete(bar.id);
+                // Parallel hook results may arrive after completion; never resurrect a reporter.
+                retired.add(bar.id);
+                return {};
+            }
+            // A retry is not progress. A real update may hand reporting to a delegate.
+            if (existing && bar.sequence <= existing.sequence)
+                return {};
+            if (!existing && !tool.endsWith('create_progress_bar'))
+                return {};
+            if (!existing && bars.size >= PROGRESS_MAX_RUNNING)
+                return {};
+            const state = { producer, sequence: bar.sequence, actions: 0, remindedAt: Date.now() };
+            bars.set(bar.id, state);
+            return existing ? {} : reminder([[bar.id, state]]);
+        }
+        if (tool.startsWith('mcp__kobo-tasks__') && tool.endsWith('progress_bars'))
+            return {};
+        const due = [];
+        for (const [id, state] of bars) {
+            if (state.producer !== producer)
+                continue;
+            state.actions++;
+            if (state.actions >= 8 && Date.now() - state.remindedAt >= 60_000 && due.length < 3) {
+                state.actions = 0;
+                state.remindedAt = Date.now();
+                due.push([id, state]);
+            }
+        }
+        return due.length ? reminder(due) : {};
+    };
+}

package/dist/server/services/forge/github/provider.js

@@ -1,6 +1,7 @@
 // src/server/services/forge/github/provider.ts
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { MERGE_METHODS } from '../../../../shared/forge-merge.js';
 import { parseCliJson } from '../parse-cli-json.js';
 import { deriveReadyToMerge, truncatePrBody } from '../types.js';
 const execFileAsync = promisify(execFile);
@@ -157,6 +158,7 @@ export const githubProvider = {
         canCreatePr: true,
         canChangePrBase: true,
         canMergeRequest: true,
+        mergeMethods: MERGE_METHODS,
         canDeleteRemoteBranch: true,
         canListPullRequests: true,
         requestTermShort: 'PR',
@@ -192,8 +194,8 @@ export const githubProvider = {
     async changePrBase(repoPath, base) {
         await execFileAsync('gh', ['pr', 'edit', '--base', base], cliOptions(repoPath));
     },
-    async mergeRequest(repoPath, number) {
-        await execFileAsync('gh', ['pr', 'merge', String(number), '--merge'], cliOptions(repoPath));
+    async mergeRequest(repoPath, number, method = 'merge') {
+        await execFileAsync('gh', ['pr', 'merge', String(number), `--${method}`], cliOptions(repoPath));
     },
     async deleteRemoteBranch(repoPath, branch) {
         await execFileAsync('git', ['push', 'origin', '--delete', branch], cliOptions(repoPath));

package/dist/server/services/forge/types.js

@@ -1,4 +1,3 @@
-// src/server/services/forge/types.ts
 /**
  * True when nothing blocks merging the PR: it is open, CI is not failing or
  * in-flight (green `SUCCESS` or absent `null` — matching GitHub's "Ready to