trekoon 0.3.4 → 0.3.5

package/.agents/skills/trekoon/SKILL.md

@@ -171,7 +171,10 @@ trekoon --toon --compact session
 2. **`behind > 0`?** → Sync first: `trekoon --toon sync pull --from main`.
    This pulls tracker events (not git commits) so task states are current.
 3. **`pendingConflicts > 0`?** → Resolve before claiming work:
-   `trekoon --toon sync conflicts list`.
+   `trekoon --toon sync conflicts list`. For uniform conflicts, batch resolve:
+   `trekoon --toon sync resolve --all --use ours` (or `--use theirs`). For
+   mixed conflicts, inspect individually with `sync conflicts show <id>` and
+   resolve per-conflict.
 4. **Session returned a next task?** → Proceed to step 2 (claim work).
 5. **No next task and unsure what to do?** → Run `trekoon --toon suggest` for
    priority-ranked recommendations (see step 1b below).
@@ -556,6 +559,44 @@ field `status`:
 Always inspect conflicts with `sync conflicts show` before resolving. Choosing
 `theirs` without inspection can overwrite in-progress work in the shared DB.
 
+### Understanding why conflicts happen
+
+| Scenario | Typical resolution | Why |
+|---|---|---|
+| Completed work vs stale main state | ours | Your branch has the latest progress |
+| Enriched descriptions vs original | ours | Your descriptions are more detailed |
+| Upstream updates from another agent | theirs | Accept the newer upstream state |
+| User-intentional reset | theirs | Respect the user's explicit action |
+
+### Agent decision framework
+
+1. List conflicts: `trekoon --toon sync conflicts list`
+2. Group by pattern — are conflicts on the same field or direction?
+3. If uniform pattern, batch resolve: `trekoon --toon sync resolve --all --use ours`
+4. If mixed, narrow by entity or field, or inspect individually
+5. When unsure, ask the user
+
+### Batch resolve patterns
+
+Common scenarios:
+
+```bash
+# Resolve all conflicts at once (most common after completing work)
+trekoon --toon sync resolve --all --use ours
+
+# Preview before resolving
+trekoon --toon sync resolve --all --use ours --dry-run
+
+# Narrow to status field conflicts only
+trekoon --toon sync resolve --all --use ours --field status
+
+# Narrow to a specific entity
+trekoon --toon sync resolve --all --use theirs --entity <id>
+
+# Combine filters
+trekoon --toon sync resolve --all --use ours --entity <id> --field description
+```
+
 ## Shared-database model
 
 Trekoon uses **one live SQLite database per repository**. The file lives at

package/docs/commands.md

@@ -20,6 +20,7 @@ the quickest way to get started, read [Quickstart](quickstart.md) first.
 - `trekoon sync status [--from <branch>]`
 - `trekoon sync pull --from <branch>`
 - `trekoon sync resolve <conflict-id> --use ours|theirs [--dry-run]`
+- `trekoon sync resolve --all --use ours|theirs [--entity <id>] [--field <name>] [--dry-run]`
 - `trekoon sync conflicts <list|show> [--mode pending|all]`
 - `trekoon skills install [--link --editor opencode|claude|pi] [--to <path>] [--allow-outside-repo]`
 - `trekoon skills install -g|--global [--editor opencode|claude|pi]`
@@ -244,14 +245,21 @@ conflicts when the same field was modified on both sides. `--from` is required.
 
 ```bash
 trekoon --toon sync resolve <conflict-id> --use ours|theirs [--dry-run]
+trekoon --toon sync resolve --all --use ours|theirs [--entity <id>] [--field <name>] [--dry-run]
 ```
 
 Resolves a pending conflict. `--use ours` keeps the current DB value.
-`--use theirs` overwrites with the source-branch value.
+`--use theirs` applies the source-branch value (or deletes the entity for
+delete conflicts).
 
 - `--dry-run` previews the resolution without mutating the database
-- In human mode, `--use theirs` shows a 30-second confirmation prompt (defaults
-  to rejection). Toon mode skips the prompt.
+- In human mode, `--use theirs` shows a 30-second confirmation prompt. Single-
+  conflict prompts include the field, current value, and incoming value.
+- In human mode, batch `sync resolve --all --use theirs` shows a count-only
+  confirmation prompt (`Resolve N conflict(s) using ...? [y/N]`). `--use ours`
+  does not prompt. Toon mode skips all confirmation prompts.
+- `--all` batch-resolves all pending conflicts. `--entity` and `--field` narrow
+  the batch. `--all` and a positional conflict ID are mutually exclusive.
 
 ### `sync conflicts`
 

package/docs/machine-contracts.md

@@ -365,6 +365,179 @@ data:
 
 No mutation occurs. The conflict stays pending.
 
+## Sync batch resolve
+
+```bash
+trekoon --toon sync resolve --all --use ours|theirs [--entity <id>] [--field <name>]
+```
+
+```text
+ok: true
+command: sync.resolve
+data:
+  resolution: ours|theirs
+  resolvedCount: <number>
+  resolvedIds: [<conflict-id>, ...]
+  filters:
+    entity: <entity-id> | null
+    field: <field-name> | null
+```
+
+Human-mode note: `sync resolve --all --use theirs` asks for confirmation before
+execution. Cancellation returns `error.code: cancelled` with the requested
+`resolution`, `cancelled: true`, and the normalized `filters`.
+
+When confirmation is required, execution is bound to the previewed conflict ID
+set. If another process resolves one of those conflicts before the confirmed
+write happens, the command fails with `error.code: conflict_set_changed`
+instead of partially resolving a drifted batch.
+
+## Sync batch resolve dry-run
+
+```bash
+trekoon --toon sync resolve --all --use ours|theirs [--entity <id>] [--field <name>] --dry-run
+```
+
+```text
+ok: true
+command: sync.resolve
+data:
+  resolution: ours|theirs
+  matchedCount: <number>
+  matchedIds: [<conflict-id>, ...]
+  filters:
+    entity: <entity-id> | null
+    field: <field-name> | null
+  dryRun: true
+```
+
+No mutation occurs. Returns `no_matching_conflicts` error when no pending
+conflicts match the filters.
+
+## Sync resolve hardening errors
+
+Recent `sync.resolve` hardening added explicit machine-visible failure modes for
+race conditions and invalid persisted conflict targets.
+
+### Single resolve — cancelled
+
+Returned in human mode when the user rejects or times out a confirmation prompt.
+Single-conflict prompts only appear for `--use theirs`.
+
+```text
+ok: false
+command: sync.resolve
+data:
+  conflictId: <conflict-id>
+  resolution: ours|theirs
+  cancelled: true
+error:
+  code: cancelled
+  message: "Resolution cancelled by user."
+```
+
+### Batch resolve — cancelled
+
+Returned in human mode when the user rejects or times out the batch prompt.
+
+```text
+ok: false
+command: sync.resolve
+data:
+  resolution: ours|theirs
+  cancelled: true
+  filters:
+    entity: <entity-id> | null
+    field: <field-name> | null
+error:
+  code: cancelled
+  message: "Batch resolution cancelled by user."
+```
+
+### Single resolve — already_resolved
+
+Returned when a conflict is still pending at preview time but another process
+resolves it before the confirmed write happens.
+
+```text
+ok: false
+command: sync.resolve
+data:
+  conflictId: <conflict-id>
+  resolution: ours|theirs
+  reason: already_resolved
+error:
+  code: already_resolved
+  message: "Conflict '<conflict-id>' already resolved."
+```
+
+### Resolve write hardening errors
+
+These surface as domain failures when persisted conflict metadata no longer maps
+to a valid writable target.
+
+```text
+ok: false
+command: sync.resolve
+data:
+  reason: unsupported_entity_kind | disallowed_field | row_not_found
+  ...details
+error:
+  code: unsupported_entity_kind | disallowed_field | row_not_found
+  message: <stable human-readable message>
+```
+
+Per-code details:
+
+- `unsupported_entity_kind`
+  - `data.entityKind`
+- `disallowed_field`
+  - `data.tableName`
+  - `data.fieldName`
+- `row_not_found`
+  - `data.tableName`
+  - `data.entityKind`
+  - `data.entityId`
+
+## Sync batch resolve — no_matching_conflicts error
+
+Applies to both the execute and dry-run variants of `sync resolve --all`.
+Returned when the given filters match zero pending conflicts.
+
+```text
+ok: false
+command: sync.resolve
+data:
+  filters:
+    entity: <entity-id> | null
+    field: <field-name> | null
+  reason: no_matching_conflicts
+error:
+  code: no_matching_conflicts
+  message: "No pending conflicts match the given filters."
+```
+
+## Sync batch resolve — conflict_set_changed error
+
+Returned in human mode when batch confirmation was based on one pending conflict
+set but one or more of those conflicts were resolved before the confirmed write
+was applied.
+
+```text
+ok: false
+command: sync.resolve
+data:
+  filters:
+    entity: <entity-id> | null
+    field: <field-name> | null
+  expectedConflictIds: [<conflict-id>, ...]
+  availableConflictIds: [<conflict-id>, ...]
+  reason: conflict_set_changed
+error:
+  code: conflict_set_changed
+  message: "Pending conflicts changed before batch resolution could be applied."
+```
+
 ## Related docs
 
 - [Quickstart](quickstart.md)

package/docs/quickstart.md

@@ -166,12 +166,17 @@ trekoon --toon sync conflicts list
 trekoon --toon sync conflicts show <id>
 trekoon --toon sync resolve <id> --use theirs --dry-run
 trekoon --toon sync resolve <id> --use ours|theirs
+trekoon --toon sync resolve --all --use ours          # batch: all pending at once
 trekoon --toon sync status
 ```
 
 Always run `sync conflicts show` before resolving so you know what you're
-overwriting. In human mode, `--use theirs` prompts for confirmation with a
-30-second timeout.
+overwriting. For uniform conflicts, `--all` resolves every pending conflict in
+one command. Optional `--entity <id>` and `--field <name>` narrow the batch.
+In human mode, `--use theirs` prompts for both single-conflict and batch
+resolve. Single-conflict prompts include field/value details; batch prompts use
+a count-only confirmation. All prompts time out after 30 seconds and default to
+rejection. Toon mode skips prompts.
 
 ## What to read next
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trekoon",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "AI-first local issue tracker CLI.",
   "keywords": [
     "ai",

package/src/commands/help.ts

@@ -300,11 +300,17 @@ const SYNC_HELP = [
   "      Show full details for one conflict.",
   "  resolve <conflict-id> --use ours|theirs [--dry-run]",
   "      Resolve a conflict. --dry-run previews without writing.",
+  "  resolve --all --use ours|theirs [--entity <id>] [--field <name>] [--dry-run]",
+  "      Batch-resolve all pending conflicts matching filters. In human mode,",
+  "      batch --use theirs prompts for confirmation before execution.",
   "",
   "Ours vs theirs:",
-  "  Conflicts are field-level (e.g., status, title, description on one entity).",
+  "  Conflicts are usually field-level (e.g., status, title, description on one entity).",
   "  --use ours   Keep the current DB value. Nothing is written.",
-  "  --use theirs  Overwrite the DB field with the source-branch value.",
+  "  --use theirs  Apply the source-branch value (or delete the entity for delete conflicts).",
+  "  Human prompts only apply to --use theirs.",
+  "  Single-conflict prompts show field/value details; batch prompts show counts.",
+  "  Batch human prompts apply only to --use theirs and only show the match count.",
   "",
   "  Example: epic abc123, field: status",
   "    ours (current DB): in_progress",
@@ -326,6 +332,9 @@ const SYNC_HELP = [
   "  trekoon sync conflicts list --mode all",
   "  trekoon sync conflicts show <conflict-id>",
   "  trekoon sync resolve <conflict-id> --use ours",
+  "  trekoon sync resolve --all --use ours",
+  "  trekoon sync resolve --all --use ours --field status",
+  "  trekoon sync resolve --all --use ours --entity <id> --dry-run",
 ].join("\n");
 
 const SESSION_HELP = [

package/src/commands/quickstart.ts

@@ -63,9 +63,14 @@ const QUICKSTART_TEXT = [
   "  trekoon --toon sync conflicts show <id>",
   "  trekoon --toon sync resolve <id> --use theirs --dry-run",
   "  trekoon --toon sync resolve <id> --use ours|theirs",
+  "  trekoon --toon sync resolve --all --use ours          # batch: all pending at once",
   "  trekoon --toon sync status",
-  "  Always inspect conflicts before resolving. In human mode, --use theirs",
-  "  prompts for confirmation (30s timeout, defaults to reject).",
+  "  Always inspect conflicts before resolving. For uniform conflicts, --all",
+  "  resolves every pending conflict in one command. Optional --entity <id>",
+  "  and --field <name> narrow the batch. In human mode, --use theirs prompts",
+  "  for both single-conflict and batch resolve. Single-conflict prompts show",
+  "  field/value details; batch prompts use a count-only confirmation (30s",
+  "  timeout, defaults to reject).",
   "",
   "8) Wipe (destructive recovery only)",
   "  trekoon wipe --yes",
@@ -107,6 +112,7 @@ export async function runQuickstart(_: CliContext): Promise<CliResult> {
         "trekoon --toon sync conflicts show <id>",
         "trekoon --toon sync resolve <id> --use theirs --dry-run",
         "trekoon --toon sync resolve <id> --use ours|theirs",
+        "trekoon --toon sync resolve --all --use ours",
         "trekoon --toon sync status",
       ],
       executionLoop: [

package/src/commands/sync.ts

@@ -8,12 +8,12 @@ import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
 import { resolveStorageResolutionDiagnostics } from "../storage/database";
 import { assertValidSourceRef } from "../sync/branch-db";
-import { getSyncConflict, listSyncConflicts, syncPull, syncResolve, syncResolvePreview, syncStatus } from "../sync/service";
+import { getSyncConflict, listSyncConflicts, syncPull, syncResolve, syncResolveAll, syncResolveAllPreview, syncResolvePreview, syncStatus } from "../sync/service";
 import { type ResolvePreviewSummary, type SyncResolution } from "../sync/types";
 
 const STATUS_OPTIONS = ["from"] as const;
 const PULL_OPTIONS = ["from"] as const;
-const RESOLVE_OPTIONS = ["use", "dry-run"] as const;
+const RESOLVE_OPTIONS = ["use", "dry-run", "all", "entity", "field"] as const;
 const CONFLICTS_LIST_OPTIONS = ["mode"] as const;
 const CONFLICTS_SHOW_OPTIONS: readonly string[] = [];
 
@@ -238,15 +238,46 @@ export async function runSync(context: CliContext): Promise<CliResult> {
       }
 
       const conflictId: string | undefined = parsed.positional[1];
+      const batchAll: boolean = hasFlag(parsed.flags, "all");
+      const resolveUsage: string = batchAll
+        ? "sync resolve --all requires --use ours|theirs."
+        : "sync resolve requires <conflict-id> --use ours|theirs.";
+
       const missingResolutionOption = readMissingOptionValue(parsed.missingOptionValues, "use");
       if (missingResolutionOption !== undefined) {
-        return usage("sync resolve requires <conflict-id> --use ours|theirs.", "sync.resolve");
+        return usage(resolveUsage, "sync.resolve");
+      }
+
+      const missingEntityOption = readMissingOptionValue(parsed.missingOptionValues, "entity");
+      if (missingEntityOption !== undefined) {
+        return usage("sync resolve --entity requires a value.", "sync.resolve");
+      }
+
+      const missingFieldOption = readMissingOptionValue(parsed.missingOptionValues, "field");
+      if (missingFieldOption !== undefined) {
+        return usage("sync resolve --field requires a value.", "sync.resolve");
       }
 
       const rawResolution: string | undefined = readOption(parsed.options, "use");
 
-      if (!conflictId || !rawResolution) {
-        return usage("sync resolve requires <conflict-id> --use ours|theirs.", "sync.resolve");
+      if (batchAll && conflictId) {
+        return usage("sync resolve --all cannot be combined with a positional conflict ID.", "sync.resolve");
+      }
+
+      if (!batchAll && !conflictId) {
+        return usage("sync resolve requires <conflict-id> or --all.", "sync.resolve");
+      }
+
+      if (!batchAll && readOption(parsed.options, "entity") !== undefined) {
+        return usage("sync resolve --entity is only supported with --all.", "sync.resolve");
+      }
+
+      if (!batchAll && readOption(parsed.options, "field") !== undefined) {
+        return usage("sync resolve --field is only supported with --all.", "sync.resolve");
+      }
+
+      if (!rawResolution) {
+        return usage(resolveUsage, "sync.resolve");
       }
 
       if (rawResolution !== "ours" && rawResolution !== "theirs") {
@@ -256,8 +287,62 @@ export async function runSync(context: CliContext): Promise<CliResult> {
       const resolution: SyncResolution = rawResolution;
       const dryRun: boolean = hasFlag(parsed.flags, "dry-run");
 
+      // --- Batch resolve (--all) ---
+      if (batchAll) {
+        const entityFilter: string | undefined = readOption(parsed.options, "entity");
+        const fieldFilter: string | undefined = readOption(parsed.options, "field");
+        const filters: { entityId?: string; fieldName?: string } = {};
+        if (entityFilter !== undefined) filters.entityId = entityFilter;
+        if (fieldFilter !== undefined) filters.fieldName = fieldFilter;
+
+        if (dryRun) {
+          const preview = syncResolveAllPreview(context.cwd, resolution, filters);
+
+          return okResult({
+            command: "sync.resolve",
+            human: `[dry-run] Would resolve ${preview.matchedCount} conflict(s) using ${preview.resolution}.`,
+            data: preview,
+          });
+        }
+
+        if (resolution === "theirs" && context.mode === "human") {
+          const preview = syncResolveAllPreview(context.cwd, resolution, filters);
+          const confirmed = await promptConfirmation(
+            `Resolve ${preview.matchedCount} conflict(s) using ${resolution}? [y/N] `,
+          );
+
+          if (!confirmed) {
+            return failResult({
+              command: "sync.resolve",
+              human: "Batch resolution cancelled by user.",
+              data: { resolution, cancelled: true, filters: preview.filters },
+              error: { code: "cancelled", message: "Batch resolution cancelled by user." },
+            });
+          }
+
+          const summary = syncResolveAll(context.cwd, resolution, filters, {
+            expectedConflictIds: preview.matchedIds,
+          });
+
+          return okResult({
+            command: "sync.resolve",
+            human: `Resolved ${summary.resolvedCount} conflict(s) using ${summary.resolution}.`,
+            data: summary,
+          });
+        }
+
+        const summary = syncResolveAll(context.cwd, resolution, filters);
+
+        return okResult({
+          command: "sync.resolve",
+          human: `Resolved ${summary.resolvedCount} conflict(s) using ${summary.resolution}.`,
+          data: summary,
+        });
+      }
+
+      // --- Single resolve (positional conflict ID) ---
       if (dryRun) {
-        const preview = syncResolvePreview(context.cwd, conflictId, resolution);
+        const preview = syncResolvePreview(context.cwd, conflictId!, resolution);
 
         return okResult({
           command: "sync.resolve",
@@ -275,8 +360,8 @@ export async function runSync(context: CliContext): Promise<CliResult> {
         });
       }
 
-      if (resolution === "theirs" && context.mode !== "toon") {
-        const preview = syncResolvePreview(context.cwd, conflictId, resolution);
+      if (resolution === "theirs" && context.mode === "human") {
+        const preview = syncResolvePreview(context.cwd, conflictId!, resolution);
         const confirmed = await promptConfirmation(formatTheirsConfirmation(preview));
 
         if (!confirmed) {
@@ -298,7 +383,7 @@ export async function runSync(context: CliContext): Promise<CliResult> {
 
       let summary;
       try {
-        summary = syncResolve(context.cwd, conflictId, resolution);
+        summary = syncResolve(context.cwd, conflictId!, resolution);
       } catch (resolveError: unknown) {
         if (resolveError instanceof Error && resolveError.message.includes("already resolved")) {
           return failResult({
@@ -321,7 +406,7 @@ export async function runSync(context: CliContext): Promise<CliResult> {
     if (subcommand === "conflicts") {
       const conflictsCommand: string | undefined = parsed.positional[1];
       if (!conflictsCommand) {
-          return usage("sync conflicts requires list|show.", "sync.conflicts");
+        return usage("sync conflicts requires list|show.", "sync.conflicts");
       }
 
       if (conflictsCommand === "list") {
@@ -332,12 +417,12 @@ export async function runSync(context: CliContext): Promise<CliResult> {
 
         const missingModeOption = readMissingOptionValue(parsed.missingOptionValues, "mode");
         if (missingModeOption !== undefined) {
-            return usage("sync conflicts list --mode only accepts pending|all.", "sync.conflicts.list");
+          return usage("sync conflicts list --mode only accepts pending|all.", "sync.conflicts.list");
         }
 
         const mode = readOption(parsed.options, "mode") ?? "pending";
         if (mode !== "pending" && mode !== "all") {
-            return usage("sync conflicts list --mode only accepts pending|all.", "sync.conflicts.list");
+          return usage("sync conflicts list --mode only accepts pending|all.", "sync.conflicts.list");
         }
 
         const conflicts = listSyncConflicts(context.cwd, mode);
@@ -359,9 +444,9 @@ export async function runSync(context: CliContext): Promise<CliResult> {
         }
 
         const conflictId: string | undefined = parsed.positional[2];
-          if (!conflictId) {
-            return usage("sync conflicts show requires <conflict-id>.", "sync.conflicts.show");
-          }
+        if (!conflictId) {
+          return usage("sync conflicts show requires <conflict-id>.", "sync.conflicts.show");
+        }
 
         const conflict = getSyncConflict(context.cwd, conflictId);
 
@@ -381,7 +466,7 @@ export async function runSync(context: CliContext): Promise<CliResult> {
         });
       }
 
-        return usage(`Unknown sync conflicts subcommand '${conflictsCommand}'.`, "sync.conflicts");
+      return usage(`Unknown sync conflicts subcommand '${conflictsCommand}'.`, "sync.conflicts");
     }
 
     return usage(`Unknown sync subcommand '${subcommand}'.`);

package/src/sync/service.ts

@@ -6,8 +6,13 @@ import { openTrekoonDatabase, writeTransaction } from "../storage/database";
 import { countBranchEventsSince, queryBranchEventsSince } from "./branch-db";
 import { nextEventTimestamp } from "./event-writes";
 import { persistGitContext, resolveGitContext } from "./git-context";
+import { DomainError } from "../domain/types";
 import {
   type PullSummary,
+  type ResolveAllOptions,
+  type ResolveAllFilters,
+  type ResolveAllPreviewSummary,
+  type ResolveAllSummary,
   type ResolvePreviewSummary,
   type ResolveSummary,
   type SyncConflictDetail,
@@ -101,6 +106,16 @@ interface ConflictRow {
   readonly updated_at: number;
 }
 
+interface ResolutionWriteContext {
+  readonly branchName: string | null;
+  readonly headSha: string | null;
+}
+
+interface ResolveAllQueryFilters {
+  readonly entityId?: string;
+  readonly fieldName?: string;
+}
+
 interface EventPayload {
   readonly fields: Record<string, unknown>;
 }
@@ -900,7 +915,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 }
 
 function parseConflictValue(value: string | null): unknown {
-  if (value === null || value === undefined) {
+  if (value === null) {
     return null;
   }
 
@@ -914,20 +929,86 @@ function parseConflictValue(value: string | null): unknown {
 function updateSingleField(db: Database, entityKind: string, entityId: string, fieldName: string, value: unknown): void {
   const tableName = tableForEntityKind(entityKind);
   if (!tableName) {
-    return;
+    throw new DomainError({
+      code: "unsupported_entity_kind",
+      message: `No table mapping for entity kind: ${entityKind}`,
+      details: { entityKind },
+    });
   }
 
   const validFields: readonly string[] = SYNC_ALLOWED_FIELDS[tableName] ?? [];
   if (!validFields.includes(fieldName)) {
-    return;
+    throw new DomainError({
+      code: "disallowed_field",
+      message: `Field '${fieldName}' is not allowed for table '${tableName}'`,
+      details: { tableName, fieldName },
+    });
   }
 
   const now: number = Date.now();
-  db.query(`UPDATE ${tableName} SET ${fieldName} = ?, updated_at = ?, version = version + 1 WHERE id = ?;`).run(
-    typeof value === "string" ? value : JSON.stringify(value),
+  const result = db
+    .query(`UPDATE ${tableName} SET ${fieldName} = ?, updated_at = ?, version = version + 1 WHERE id = ?;`)
+    .run(typeof value === "string" ? value : JSON.stringify(value), now, entityId);
+
+  if (result.changes === 0) {
+    throw new DomainError({
+      code: "row_not_found",
+      message: `No row updated: entity '${entityKind}' with id '${entityId}' not found in table '${tableName}'`,
+      details: { tableName, entityKind, entityId },
+    });
+  }
+}
+
+function deleteSingleEntity(db: Database, entityKind: string, entityId: string): void {
+  const tableName = tableForEntityKind(entityKind);
+  if (!tableName) {
+    throw new DomainError({
+      code: "unsupported_entity_kind",
+      message: `No table mapping for entity kind: ${entityKind}`,
+      details: { entityKind },
+    });
+  }
+
+  const result = db.query(`DELETE FROM ${tableName} WHERE id = ?;`).run(entityId);
+
+  if (result.changes === 0) {
+    throw new DomainError({
+      code: "row_not_found",
+      message: `No row deleted: entity '${entityKind}' with id '${entityId}' not found in table '${tableName}'`,
+      details: { tableName, entityKind, entityId },
+    });
+  }
+}
+
+function normalizeResolveAllFilters(filters: ResolveAllQueryFilters): ResolveAllFilters {
+  return {
+    entity: filters.entityId ?? null,
+    field: filters.fieldName ?? null,
+  };
+}
+
+function resolveConflictRow(
+  db: Database,
+  conflict: ConflictRow,
+  resolution: SyncResolution,
+  git: ResolutionWriteContext,
+): void {
+  if (resolution === "theirs") {
+    if (conflict.field_name === "__delete__") {
+      deleteSingleEntity(db, conflict.entity_kind, conflict.entity_id);
+    } else {
+      updateSingleField(db, conflict.entity_kind, conflict.entity_id, conflict.field_name, parseConflictValue(conflict.theirs_value));
+    }
+  }
+
+  const now: number = nextEventTimestamp(db);
+  db.query("UPDATE sync_conflicts SET resolution = ?, updated_at = ?, version = version + 1 WHERE id = ?;").run(
+    resolution,
     now,
-    entityId,
+    conflict.id,
   );
+
+  appendResolutionEvent(db, git.branchName, git.headSha, conflict, resolution, now);
 }
 
 function appendResolutionEvent(
@@ -1086,24 +1167,7 @@ export function syncResolve(cwd: string, conflictId: string, resolution: SyncRes
     // the check and double-resolve the same conflict.
     const conflict = writeTransaction(storage.db, (): ConflictRow => {
       const row = lookupPendingConflict(storage.db, conflictId);
-
-      if (resolution === "theirs") {
-        updateSingleField(
-          storage.db,
-          row.entity_kind,
-          row.entity_id,
-          row.field_name,
-          parseConflictValue(row.theirs_value),
-        );
-      }
-
-      const now: number = nextEventTimestamp(storage.db);
-      storage.db
-        .query("UPDATE sync_conflicts SET resolution = ?, updated_at = ?, version = version + 1 WHERE id = ?;")
-        .run(resolution, now, row.id);
-
-      appendResolutionEvent(storage.db, git.branchName, git.headSha, row, resolution, now);
-
+      resolveConflictRow(storage.db, row, resolution, git);
       return row;
     });
 
@@ -1145,3 +1209,146 @@ export function syncResolvePreview(cwd: string, conflictId: string, resolution:
     storage.close();
   }
 }
+
+function queryPendingConflicts(
+  db: Database,
+  filters: ResolveAllQueryFilters,
+): readonly ConflictRow[] {
+  const conditions: string[] = ["resolution = 'pending'"];
+  const params: string[] = [];
+
+  if (filters.entityId !== undefined) {
+    conditions.push("entity_id = ?");
+    params.push(filters.entityId);
+  }
+
+  if (filters.fieldName !== undefined) {
+    conditions.push("field_name = ?");
+    params.push(filters.fieldName);
+  }
+
+  const sql = `
+    SELECT c.id, c.event_id, c.entity_kind, c.entity_id, c.field_name, c.ours_value, c.theirs_value, c.resolution, c.created_at, c.updated_at
+    FROM sync_conflicts c
+    LEFT JOIN events e ON e.id = c.event_id
+    WHERE ${conditions.map((condition) => condition.replaceAll("resolution", "c.resolution").replaceAll("entity_id", "c.entity_id").replaceAll("field_name", "c.field_name")).join(" AND ")}
+    ORDER BY COALESCE(e.created_at, c.created_at) ASC, COALESCE(e.id, c.event_id) ASC, c.created_at ASC, c.id ASC;
+  `;
+
+  return db.query(sql).all(...params) as ConflictRow[];
+}
+
+function queryPendingConflictsByIds(db: Database, conflictIds: readonly string[]): readonly ConflictRow[] {
+  if (conflictIds.length === 0) {
+    return [];
+  }
+
+  const placeholders = conflictIds.map(() => "?").join(", ");
+  const rows = db
+    .query(
+      `
+      SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
+      FROM sync_conflicts
+      WHERE resolution = 'pending' AND id IN (${placeholders});
+      `,
+    )
+    .all(...conflictIds) as ConflictRow[];
+
+  const rowById = new Map(rows.map((row) => [row.id, row]));
+
+  return conflictIds.flatMap((conflictId) => {
+    const row = rowById.get(conflictId);
+    return row ? [row] : [];
+  });
+}
+
+export function syncResolveAll(
+  cwd: string,
+  resolution: SyncResolution,
+  filters: ResolveAllQueryFilters,
+  options: ResolveAllOptions = {},
+): ResolveAllSummary {
+  const storage = openTrekoonDatabase(cwd);
+  const git = resolveGitContext(cwd);
+  const normalizedFilters: ResolveAllFilters = normalizeResolveAllFilters(filters);
+
+  try {
+    persistGitContext(storage.db, git);
+
+    const resolvedIds: string[] = writeTransaction(storage.db, (): string[] => {
+      const expectedConflictIds = options.expectedConflictIds;
+      const conflicts = expectedConflictIds
+        ? queryPendingConflictsByIds(storage.db, expectedConflictIds)
+        : queryPendingConflicts(storage.db, filters);
+
+      if (conflicts.length === 0) {
+        throw new DomainError({
+          code: "no_matching_conflicts",
+          message: "No pending conflicts match the given filters.",
+          details: { filters: normalizedFilters },
+        });
+      }
+
+      if (expectedConflictIds && conflicts.length !== expectedConflictIds.length) {
+        throw new DomainError({
+          code: "conflict_set_changed",
+          message: "Pending conflicts changed before batch resolution could be applied.",
+          details: {
+            filters: normalizedFilters,
+            expectedConflictIds,
+            availableConflictIds: conflicts.map((conflict) => conflict.id),
+          },
+        });
+      }
+
+      const ids: string[] = [];
+
+      for (const conflict of conflicts) {
+        resolveConflictRow(storage.db, conflict, resolution, git);
+        ids.push(conflict.id);
+      }
+
+      return ids;
+    });
+
+    return {
+      resolution,
+      resolvedCount: resolvedIds.length,
+      resolvedIds,
+      filters: normalizedFilters,
+    };
+  } finally {
+    storage.close();
+  }
+}
+
+export function syncResolveAllPreview(
+  cwd: string,
+  resolution: SyncResolution,
+  filters: ResolveAllQueryFilters,
+): ResolveAllPreviewSummary {
+  const storage = openTrekoonDatabase(cwd);
+  const normalizedFilters: ResolveAllFilters = normalizeResolveAllFilters(filters);
+
+  try {
+    const conflicts = queryPendingConflicts(storage.db, filters);
+
+    if (conflicts.length === 0) {
+      throw new DomainError({
+        code: "no_matching_conflicts",
+        message: "No pending conflicts match the given filters.",
+        details: { filters: normalizedFilters },
+      });
+    }
+
+    return {
+      resolution,
+      matchedCount: conflicts.length,
+      matchedIds: conflicts.map((c) => c.id),
+      filters: normalizedFilters,
+      dryRun: true,
+    };
+  } finally {
+    storage.close();
+  }
+}

package/src/sync/types.ts

@@ -55,6 +55,30 @@ export interface ResolvePreviewSummary {
   readonly dryRun: true;
 }
 
+export interface ResolveAllFilters {
+  readonly entity: string | null;
+  readonly field: string | null;
+}
+
+export interface ResolveAllSummary {
+  readonly resolution: SyncResolution;
+  readonly resolvedCount: number;
+  readonly resolvedIds: readonly string[];
+  readonly filters: ResolveAllFilters;
+}
+
+export interface ResolveAllPreviewSummary {
+  readonly resolution: SyncResolution;
+  readonly matchedCount: number;
+  readonly matchedIds: readonly string[];
+  readonly filters: ResolveAllFilters;
+  readonly dryRun: true;
+}
+
+export interface ResolveAllOptions {
+  readonly expectedConflictIds?: readonly string[];
+}
+
 export interface SyncConflictListItem {
   readonly id: string;
   readonly event_id: string;