trekoon 0.1.7 → 0.1.9

package/src/commands/quickstart.ts

@@ -4,34 +4,69 @@ import { type CliContext, type CliResult } from "../runtime/command-types";
 const QUICKSTART_TEXT = [
   "Trekoon quickstart",
   "",
+  "This quickstart is aligned with .agents/skills/trekoon/SKILL.md.",
+  "For agents: always use --toon for every command.",
+  "",
   "1) Local DB and worktree model",
   "- Every worktree stores tracker state at .trekoon/trekoon.db.",
   "- This DB stays local; it is not merged by Git automatically.",
   "",
-  "2) Pre-merge sync flow",
-  "- Run: trekoon sync status",
-  "- Pull upstream tracker events: trekoon sync pull --from main",
-  "- Resolve conflicts if needed: trekoon sync resolve <id> --use ours",
-  "- Run sync status again before opening or merging a PR.",
+  "2) Agent session-start checklist (verify setup + current state)",
+  "- 1. Verify tracker exists (or initialize once): trekoon --toon init",
+  "- 2. Check sync baseline: trekoon --toon sync status",
+  "- 3. Load active context: trekoon --toon epic list",
+  "- 4. Load active tasks: trekoon --toon task list",
+  "- 5. Load deterministic candidates: trekoon --toon task ready --limit 5",
+  "- 6. If blocked, inspect downstream impact: trekoon --toon dep reverse <task-or-subtask-id>",
+  "",
+  "3) AI execution loop (deterministic, dependency-aware)",
+  "- 1. Sync branch/worktree state: trekoon --toon sync status",
+  "- 2. Select ready work: trekoon --toon task ready --limit 5",
+  "- 3. Pick top candidate when needed: trekoon --toon task next",
+  "- 4. Check downstream blockers: trekoon --toon dep reverse <task-or-subtask-id>",
+  "- 5. Claim work and update status: trekoon --toon task update <task-id> --status in_progress",
+  "- 6. Complete with context: trekoon --toon task update <task-id> --append \"Completed implementation\" --status done",
+  "- 7. Or report block: trekoon --toon task update <task-id> --append \"Blocked by <reason>\" --status blocked",
   "",
-  "3) Task details and description",
+  "4) Power-user command patterns (aligned with skill)",
+  "- Inspect full epic tree: trekoon --toon epic show <epic-id> --all",
+  "- Inspect full task payload: trekoon --toon task show <task-id> --all",
+  "- Check direct dependencies before starting: trekoon --toon dep list <task-id>",
+  "- Find what this item unblocks: trekoon --toon dep reverse <task-or-subtask-id>",
+  "- Filter list explicitly: trekoon --toon task list --status in_progress,todo --limit 20",
+  "- Paginate deterministically: trekoon --toon task list --cursor <n>",
+  "- Bulk append/status update: trekoon --toon task update --ids id1,id2 --append \"...\" --status in_progress",
+  "",
+  "5) Task details and description",
   "- Human list and show views default to table format.",
   "- Alternate list view: add --view compact.",
   "- task/epic/subtask list defaults: open work only (in_progress/in-progress, todo), max 10.",
   "- Filter list by status: --status in_progress,todo (CSV).",
   "- Change page size: --limit <n>. Show all statuses and all rows with --all.",
-  "- --all cannot be combined with --status or --limit.",
+  "- Continue pagination with --cursor <n> (offset-like list position).",
+  "- --all cannot be combined with --status, --limit, or --cursor.",
   "- Bulk update: use --all or --ids <csv> with --append and/or --status.",
   "- Bulk update rejects positional id, and --all/--ids cannot be combined.",
-  "- Full tree + descriptions: trekoon epic show <epic-id> --all --json",
-  "- For full task payload (including description), use --json:",
-  "  trekoon task show <task-id> --all --json",
-  "",
-  "4) Machine output examples",
-  "- trekoon quickstart --json",
-  "- trekoon task show <task-id> --all --json",
-  "- trekoon epic show <epic-id> --all --json",
-  "- trekoon sync status --toon",
+  "- Ready queue: trekoon task ready [--limit <n>] [--epic <id>] (deterministic order).",
+  "- Next execution candidate: trekoon task next [--epic <id>]",
+  "- Full tree + descriptions (canonical): trekoon --toon epic show <epic-id> --all",
+  "- Full task payload (including description): trekoon --toon task show <task-id> --all",
+  "- Optional integration format: trekoon --json task show <task-id> --all",
+  "",
+  "6) Pre-merge sync flow",
+  "- Run: trekoon --toon sync status",
+  "- Pull upstream tracker events: trekoon --toon sync pull --from main",
+  "- Resolve conflicts if needed: trekoon --toon sync resolve <id> --use ours",
+  "- Run sync status again before opening or merging a PR.",
+  "",
+  "7) Machine output examples",
+  "- trekoon --toon quickstart",
+  "- trekoon --toon task show <task-id> --all",
+  "- trekoon --toon epic show <epic-id> --all",
+  "- trekoon --toon sync status",
+  "- trekoon --toon task ready --limit 5",
+  "- trekoon --toon task next",
+  "- trekoon --toon dep reverse <task-or-subtask-id>",
 ].join("\n");
 
 export async function runQuickstart(_: CliContext): Promise<CliResult> {
@@ -44,17 +79,46 @@ export async function runQuickstart(_: CliContext): Promise<CliResult> {
         databaseFile: ".trekoon/trekoon.db",
         mergeBehavior: "manual-sync",
       },
+      alignedSkill: ".agents/skills/trekoon/SKILL.md",
+      requiresToonForAgents: true,
+      agentStartupChecklist: [
+        "trekoon --toon init",
+        "trekoon --toon sync status",
+        "trekoon --toon epic list",
+        "trekoon --toon task list",
+        "trekoon --toon task ready --limit 5",
+        "trekoon --toon dep reverse <task-or-subtask-id>",
+      ],
       preMergeFlow: [
-        "trekoon sync status",
-        "trekoon sync pull --from main",
-        "trekoon sync resolve <id> --use ours",
-        "trekoon sync status",
+        "trekoon --toon sync status",
+        "trekoon --toon sync pull --from main",
+        "trekoon --toon sync resolve <id> --use ours",
+        "trekoon --toon sync status",
+      ],
+      executionLoop: [
+        "trekoon --toon sync status",
+        "trekoon --toon task ready --limit 5",
+        "trekoon --toon task next",
+        "trekoon --toon dep reverse <task-or-subtask-id>",
+        "trekoon --toon task update <task-id> --status in_progress",
+      ],
+      powerUserCommands: [
+        "trekoon --toon epic show <epic-id> --all",
+        "trekoon --toon task show <task-id> --all",
+        "trekoon --toon dep list <task-id>",
+        "trekoon --toon dep reverse <task-or-subtask-id>",
+        "trekoon --toon task list --status in_progress,todo --limit 20",
+        "trekoon --toon task list --cursor <n>",
+        "trekoon --toon task update --ids id1,id2 --append \"...\" --status in_progress",
       ],
       machineExamples: [
-        "trekoon quickstart --json",
-        "trekoon task show <task-id> --all --json",
-        "trekoon epic show <epic-id> --all --json",
-        "trekoon sync status --toon",
+        "trekoon --toon quickstart",
+        "trekoon --toon task show <task-id> --all",
+        "trekoon --toon epic show <epic-id> --all",
+        "trekoon --toon sync status",
+        "trekoon --toon task ready --limit 5",
+        "trekoon --toon task next",
+        "trekoon --toon dep reverse <task-or-subtask-id>",
       ],
     },
   });

package/src/commands/subtask.ts

@@ -1,4 +1,12 @@
-import { hasFlag, parseArgs, parseStrictPositiveInt, readEnumOption, readMissingOptionValue, readOption } from "./arg-parser";
+import {
+  hasFlag,
+  parseArgs,
+  parseStrictNonNegativeInt,
+  parseStrictPositiveInt,
+  readEnumOption,
+  readMissingOptionValue,
+  readOption,
+} from "./arg-parser";
 
 import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
@@ -54,16 +62,44 @@ function filterSortAndLimitSubtasks(
   subtasks: readonly SubtaskRecord[],
   statuses: readonly string[] | undefined,
   limit: number | undefined,
-): SubtaskRecord[] {
+  cursor: number,
+): { subtasks: SubtaskRecord[]; pagination: { hasMore: boolean; nextCursor: string | null } } {
   const allowedStatuses = statuses === undefined ? undefined : new Set(statuses);
   const filtered = allowedStatuses === undefined ? [...subtasks] : subtasks.filter((subtask) => allowedStatuses.has(subtask.status));
-  const sorted = [...filtered].sort((left, right) => subtaskStatusPriority(left.status) - subtaskStatusPriority(right.status));
+  const sorted = [...filtered].sort((left, right) => {
+    const byStatus = subtaskStatusPriority(left.status) - subtaskStatusPriority(right.status);
+    if (byStatus !== 0) {
+      return byStatus;
+    }
+
+    const byCreatedAt = left.createdAt - right.createdAt;
+    if (byCreatedAt !== 0) {
+      return byCreatedAt;
+    }
+
+    return left.id.localeCompare(right.id);
+  });
 
   if (limit === undefined) {
-    return sorted;
+    return {
+      subtasks: sorted,
+      pagination: {
+        hasMore: false,
+        nextCursor: null,
+      },
+    };
   }
 
-  return sorted.slice(0, limit);
+  const pagedSubtasks = sorted.slice(cursor, cursor + limit);
+  const nextIndex = cursor + pagedSubtasks.length;
+  const hasMore = nextIndex < sorted.length;
+  return {
+    subtasks: pagedSubtasks,
+    pagination: {
+      hasMore,
+      nextCursor: hasMore ? `${nextIndex}` : null,
+    },
+  };
 }
 
 function appendLine(existing: string, line: string): string {
@@ -161,6 +197,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
           readMissingOptionValue(parsed.missingOptionValues, "view") ??
           readMissingOptionValue(parsed.missingOptionValues, "status", "s") ??
           readMissingOptionValue(parsed.missingOptionValues, "limit", "l") ??
+          readMissingOptionValue(parsed.missingOptionValues, "cursor") ??
           readMissingOptionValue(parsed.missingOptionValues, "task", "t");
         if (missingListOption !== undefined) {
           return failMissingOptionValue("subtask.list", missingListOption);
@@ -171,6 +208,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
         const includeAll = hasFlag(parsed.flags, "all");
         const rawStatuses = readOption(parsed.options, "status", "s");
         const rawLimit = readOption(parsed.options, "limit", "l");
+        const rawCursor = readOption(parsed.options, "cursor");
 
         if (rawView !== undefined && view === undefined) {
           return failResult({
@@ -208,6 +246,18 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
           });
         }
 
+        if (includeAll && rawCursor !== undefined) {
+          return failResult({
+            command: "subtask.list",
+            human: "Use either --all or --cursor, not both.",
+            data: { code: "invalid_input", flags: ["all", "cursor"] },
+            error: {
+              code: "invalid_input",
+              message: "--all and --cursor are mutually exclusive",
+            },
+          });
+        }
+
         const statuses = parseStatusCsv(rawStatuses);
         if (rawStatuses !== undefined && statuses !== undefined && statuses.length === 0) {
           return failResult({
@@ -234,6 +284,19 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
           });
         }
 
+        const parsedCursor = parseStrictNonNegativeInt(rawCursor);
+        if (Number.isNaN(parsedCursor)) {
+          return failResult({
+            command: "subtask.list",
+            human: "Invalid --cursor value. Use an integer >= 0.",
+            data: { code: "invalid_input", cursor: rawCursor },
+            error: {
+              code: "invalid_input",
+              message: "Invalid --cursor value",
+            },
+          });
+        }
+
         const taskId: string | undefined = readOption(parsed.options, "task", "t") ?? parsed.positional[1];
         const selectedStatuses = includeAll
           ? undefined
@@ -241,7 +304,13 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
         const selectedLimit = includeAll
           ? undefined
           : parsedLimit ?? DEFAULT_SUBTASK_LIST_LIMIT;
-        const subtasks = filterSortAndLimitSubtasks(domain.listSubtasks(taskId), selectedStatuses, selectedLimit);
+        const listed = filterSortAndLimitSubtasks(
+          domain.listSubtasks(taskId),
+          selectedStatuses,
+          selectedLimit,
+          parsedCursor ?? 0,
+        );
+        const subtasks = listed.subtasks;
         const listView = view ?? "table";
         const human =
           subtasks.length === 0
@@ -254,6 +323,29 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
           command: "subtask.list",
           human,
           data: { subtasks },
+          ...(context.mode === "human"
+            ? {}
+            : {
+                meta: {
+                  pagination: listed.pagination,
+                  defaults: {
+                    statuses: !includeAll && statuses === undefined ? [...DEFAULT_OPEN_SUBTASK_STATUSES] : null,
+                    limit: !includeAll && parsedLimit === undefined ? DEFAULT_SUBTASK_LIST_LIMIT : null,
+                    cursor: parsedCursor === undefined ? 0 : null,
+                    view: view === undefined ? "table" : null,
+                  },
+                  filters: {
+                    taskId: taskId ?? null,
+                    statuses: selectedStatuses ?? null,
+                    includeAll,
+                  },
+                  truncation: {
+                    applied: listed.pagination.hasMore,
+                    returned: subtasks.length,
+                    limit: selectedLimit ?? null,
+                  },
+                },
+              }),
         });
       }
       case "update": {

package/src/commands/sync.ts

@@ -1,22 +1,48 @@
+import { findUnknownOption, parseArgs, readMissingOptionValue, readOption, suggestOptions } from "./arg-parser";
+
 import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
 import { MissingBranchDatabaseError } from "../sync/branch-db";
 import { getSyncConflict, listSyncConflicts, syncPull, syncResolve, syncStatus } from "../sync/service";
-import { type SyncConflictMode, type SyncResolution } from "../sync/types";
+import { type SyncResolution } from "../sync/types";
+
+const STATUS_OPTIONS = ["from"] as const;
+const PULL_OPTIONS = ["from"] as const;
+const RESOLVE_OPTIONS = ["use"] as const;
+const CONFLICTS_LIST_OPTIONS = ["mode"] as const;
+const CONFLICTS_SHOW_OPTIONS: readonly string[] = [];
+
+function resolveSyncCommandId(subcommand: string | undefined, conflictsSubcommand: string | undefined): string {
+  if (subcommand === "status") {
+    return "sync.status";
+  }
+
+  if (subcommand === "pull") {
+    return "sync.pull";
+  }
+
+  if (subcommand === "resolve") {
+    return "sync.resolve";
+  }
+
+  if (subcommand !== "conflicts") {
+    return "sync";
+  }
+
+  if (conflictsSubcommand === "list") {
+    return "sync.conflicts.list";
+  }
 
-function parseOption(args: readonly string[], option: string): string | null {
-  const index: number = args.indexOf(option);
-  if (index < 0) {
-    return null;
+  if (conflictsSubcommand === "show") {
+    return "sync.conflicts.show";
   }
 
-  const value: string | undefined = args[index + 1];
-  return value && !value.startsWith("--") ? value : null;
+  return "sync.conflicts";
 }
 
-function usage(message: string): CliResult {
+function usage(message: string, command = "sync"): CliResult {
   return failResult({
-    command: "sync",
+    command,
     human: `${message}\nUsage: trekoon sync <status|pull|resolve|conflicts> [options]`,
     data: { message },
     error: {
@@ -26,6 +52,28 @@ function usage(message: string): CliResult {
   });
 }
 
+function prefixedOptions(options: readonly string[]): string[] {
+  return options.map((option) => `--${option}`);
+}
+
+function unknownOption(command: string, option: string, allowedOptions: readonly string[]): CliResult {
+  const suggestions = suggestOptions(option, allowedOptions).map((suggestion) => `--${suggestion}`);
+  const suggestionMessage = suggestions.length > 0 ? ` Did you mean ${suggestions.join(" or ")}?` : "";
+  return failResult({
+    command,
+    human: `Unknown option --${option}.${suggestionMessage}`,
+    data: {
+      option: `--${option}`,
+      allowedOptions: prefixedOptions(allowedOptions),
+      suggestions,
+    },
+    error: {
+      code: "unknown_option",
+      message: `Unknown option --${option}`,
+    },
+  });
+}
+
 function statusMessage(sourceBranch: string, ahead: number, behind: number, conflicts: number): string {
   return [
     `Sync status against '${sourceBranch}'`,
@@ -61,26 +109,11 @@ function formatConflictList(
     .join("\n");
 }
 
-function parseConflictMode(args: readonly string[]): SyncConflictMode | null {
-  const modeIndex = args.indexOf("--mode");
-  if (modeIndex < 0) {
-    return "pending";
-  }
-
-  const explicitMode = args[modeIndex + 1];
-  if (!explicitMode || explicitMode.startsWith("--")) {
-    return null;
-  }
-
-  if (explicitMode === "pending" || explicitMode === "all") {
-    return explicitMode;
-  }
-
-  return null;
-}
-
 export async function runSync(context: CliContext): Promise<CliResult> {
-  const subcommand: string | undefined = context.args[0];
+  const parsed = parseArgs(context.args);
+  const subcommand: string | undefined = parsed.positional[0];
+  const conflictsSubcommand: string | undefined = subcommand === "conflicts" ? parsed.positional[1] : undefined;
+  const resolvedCommand: string = resolveSyncCommandId(subcommand, conflictsSubcommand);
 
   if (!subcommand) {
     return usage("Missing sync subcommand.");
@@ -88,26 +121,46 @@ export async function runSync(context: CliContext): Promise<CliResult> {
 
   try {
     if (subcommand === "status") {
-      const sourceBranch: string = parseOption(context.args, "--from") ?? "main";
+      const statusUnknownOption = findUnknownOption(parsed, STATUS_OPTIONS);
+      if (statusUnknownOption !== undefined) {
+        return unknownOption("sync.status", statusUnknownOption, STATUS_OPTIONS);
+      }
+
+      const missingFromOption = readMissingOptionValue(parsed.missingOptionValues, "from");
+      if (missingFromOption !== undefined) {
+        return usage("sync status requires --from <branch> when provided.", "sync.status");
+      }
+
+      const sourceBranch: string = readOption(parsed.options, "from") ?? "main";
       const summary = syncStatus(context.cwd, sourceBranch);
 
       return okResult({
-        command: "sync status",
+        command: "sync.status",
         human: statusMessage(summary.sourceBranch, summary.ahead, summary.behind, summary.pendingConflicts),
         data: summary,
       });
     }
 
     if (subcommand === "pull") {
-      const sourceBranch: string | null = parseOption(context.args, "--from");
-      if (!sourceBranch) {
-        return usage("sync pull requires --from <branch>.");
+      const pullUnknownOption = findUnknownOption(parsed, PULL_OPTIONS);
+      if (pullUnknownOption !== undefined) {
+        return unknownOption("sync.pull", pullUnknownOption, PULL_OPTIONS);
+      }
+
+      const missingFromOption = readMissingOptionValue(parsed.missingOptionValues, "from");
+      if (missingFromOption !== undefined) {
+        return usage("sync pull requires --from <branch>.", "sync.pull");
+      }
+
+      const sourceBranch: string | undefined = readOption(parsed.options, "from");
+      if (sourceBranch === undefined) {
+        return usage("sync pull requires --from <branch>.", "sync.pull");
       }
 
       const summary = syncPull(context.cwd, sourceBranch);
 
       return okResult({
-        command: "sync pull",
+        command: "sync.pull",
         human: [
           `Pulled from '${summary.sourceBranch}'`,
           `Scanned events: ${summary.scannedEvents}`,
@@ -123,42 +176,62 @@ export async function runSync(context: CliContext): Promise<CliResult> {
     }
 
     if (subcommand === "resolve") {
-      const conflictId: string | undefined = context.args[1];
-      const rawResolution: string | null = parseOption(context.args, "--use");
+      const resolveUnknownOption = findUnknownOption(parsed, RESOLVE_OPTIONS);
+      if (resolveUnknownOption !== undefined) {
+        return unknownOption("sync.resolve", resolveUnknownOption, RESOLVE_OPTIONS);
+      }
+
+      const conflictId: string | undefined = parsed.positional[1];
+      const missingResolutionOption = readMissingOptionValue(parsed.missingOptionValues, "use");
+      if (missingResolutionOption !== undefined) {
+        return usage("sync resolve requires <conflict-id> --use ours|theirs.", "sync.resolve");
+      }
+
+      const rawResolution: string | undefined = readOption(parsed.options, "use");
 
       if (!conflictId || !rawResolution) {
-        return usage("sync resolve requires <conflict-id> --use ours|theirs.");
+        return usage("sync resolve requires <conflict-id> --use ours|theirs.", "sync.resolve");
       }
 
       if (rawResolution !== "ours" && rawResolution !== "theirs") {
-        return usage("sync resolve --use only accepts ours|theirs.");
+        return usage("sync resolve --use only accepts ours|theirs.", "sync.resolve");
       }
 
       const summary = syncResolve(context.cwd, conflictId, rawResolution as SyncResolution);
 
       return okResult({
-        command: "sync resolve",
+        command: "sync.resolve",
         human: `Resolved ${summary.conflictId} using ${summary.resolution}.`,
         data: summary,
       });
     }
 
     if (subcommand === "conflicts") {
-      const conflictsCommand: string | undefined = context.args[1];
+      const conflictsCommand: string | undefined = parsed.positional[1];
       if (!conflictsCommand) {
-        return usage("sync conflicts requires list|show.");
+          return usage("sync conflicts requires list|show.", "sync.conflicts");
       }
 
       if (conflictsCommand === "list") {
-        const mode = parseConflictMode(context.args);
-        if (!mode) {
-          return usage("sync conflicts list --mode only accepts pending|all.");
+        const listUnknownOption = findUnknownOption(parsed, CONFLICTS_LIST_OPTIONS);
+        if (listUnknownOption !== undefined) {
+          return unknownOption("sync.conflicts.list", listUnknownOption, CONFLICTS_LIST_OPTIONS);
+        }
+
+        const missingModeOption = readMissingOptionValue(parsed.missingOptionValues, "mode");
+        if (missingModeOption !== undefined) {
+            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");
         }
 
         const conflicts = listSyncConflicts(context.cwd, mode);
 
         return okResult({
-          command: "sync conflicts list",
+          command: "sync.conflicts.list",
           human: formatConflictList(conflicts),
           data: {
             mode,
@@ -168,15 +241,20 @@ export async function runSync(context: CliContext): Promise<CliResult> {
       }
 
       if (conflictsCommand === "show") {
-        const conflictId: string | undefined = context.args[2];
-        if (!conflictId) {
-          return usage("sync conflicts show requires <conflict-id>.");
+        const showUnknownOption = findUnknownOption(parsed, CONFLICTS_SHOW_OPTIONS);
+        if (showUnknownOption !== undefined) {
+          return unknownOption("sync.conflicts.show", showUnknownOption, CONFLICTS_SHOW_OPTIONS);
         }
 
+        const conflictId: string | undefined = parsed.positional[2];
+          if (!conflictId) {
+            return usage("sync conflicts show requires <conflict-id>.", "sync.conflicts.show");
+          }
+
         const conflict = getSyncConflict(context.cwd, conflictId);
 
         return okResult({
-          command: "sync conflicts show",
+          command: "sync.conflicts.show",
           human: [
             `Conflict: ${conflict.id}`,
             `Entity: ${conflict.entityKind} ${conflict.entityId}`,
@@ -191,14 +269,14 @@ export async function runSync(context: CliContext): Promise<CliResult> {
         });
       }
 
-      return usage(`Unknown sync conflicts subcommand '${conflictsCommand}'.`);
+        return usage(`Unknown sync conflicts subcommand '${conflictsCommand}'.`, "sync.conflicts");
     }
 
     return usage(`Unknown sync subcommand '${subcommand}'.`);
   } catch (error) {
     if (error instanceof MissingBranchDatabaseError) {
       return failResult({
-        command: "sync",
+        command: resolvedCommand,
         human: error.message,
         data: {
           reason: "missing_branch_db",
@@ -213,7 +291,7 @@ export async function runSync(context: CliContext): Promise<CliResult> {
     const message = error instanceof Error ? error.message : "Unknown sync error.";
 
     return failResult({
-      command: "sync",
+      command: resolvedCommand,
       human: message,
       data: {
         reason: "sync_failed",