@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/claude-usage-math.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, test } from "bun:test"
+import {
+  maxClaudeContextWindowFromModelUsage,
+  normalizeClaudeUsageSnapshot,
+  parseConfiguredContextWindowFromModelId,
+  resolveFinalTurnUsage,
+} from "./claude-usage-math"
+
+// ---------------------------------------------------------------------------
+// normalizeClaudeUsageSnapshot
+// ---------------------------------------------------------------------------
+
+describe("normalizeClaudeUsageSnapshot", () => {
+  test("returns null for null input", () => {
+    expect(normalizeClaudeUsageSnapshot(null)).toBeNull()
+  })
+
+  test("returns null for empty object (zero usedTokens)", () => {
+    expect(normalizeClaudeUsageSnapshot({})).toBeNull()
+  })
+
+  test("returns null for non-record input", () => {
+    expect(normalizeClaudeUsageSnapshot("string")).toBeNull()
+    expect(normalizeClaudeUsageSnapshot(42)).toBeNull()
+  })
+
+  test("normalizes basic input/output tokens", () => {
+    const result = normalizeClaudeUsageSnapshot({
+      input_tokens: 100,
+      output_tokens: 50,
+    })
+    expect(result).not.toBeNull()
+    expect(result!.usedTokens).toBe(150)
+    expect(result!.inputTokens).toBe(100)
+    expect(result!.outputTokens).toBe(50)
+  })
+
+  test("accepts camelCase field names", () => {
+    const result = normalizeClaudeUsageSnapshot({
+      inputTokens: 200,
+      outputTokens: 80,
+    })
+    expect(result).not.toBeNull()
+    expect(result!.usedTokens).toBe(280)
+    expect(result!.inputTokens).toBe(200)
+  })
+
+  test("includes cachedInputTokens when cache_read_input_tokens > 0", () => {
+    const result = normalizeClaudeUsageSnapshot({
+      input_tokens: 100,
+      output_tokens: 20,
+      cache_read_input_tokens: 30,
+    })
+    expect(result).not.toBeNull()
+    // usedTokens includes cached tokens (which are part of total input)
+    expect(result!.cachedInputTokens).toBe(30)
+  })
+
+  test("passes maxTokens through when provided and positive", () => {
+    const result = normalizeClaudeUsageSnapshot(
+      { input_tokens: 500, output_tokens: 100 },
+      200_000,
+    )
+    expect(result).not.toBeNull()
+    expect(result!.maxTokens).toBe(200_000)
+  })
+
+  test("omits maxTokens when not provided", () => {
+    const result = normalizeClaudeUsageSnapshot({ input_tokens: 500, output_tokens: 100 })
+    expect(result).not.toBeNull()
+    expect(result!.maxTokens).toBeUndefined()
+  })
+
+  test("includes reasoningOutputTokens when provided", () => {
+    const result = normalizeClaudeUsageSnapshot({
+      input_tokens: 100,
+      output_tokens: 50,
+      reasoning_output_tokens: 20,
+    })
+    expect(result).not.toBeNull()
+    expect(result!.reasoningOutputTokens).toBe(20)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveFinalTurnUsage
+// ---------------------------------------------------------------------------
+
+describe("resolveFinalTurnUsage", () => {
+  test("returns null when latestUsageSnapshot is null", () => {
+    expect(resolveFinalTurnUsage(null, null, undefined)).toBeNull()
+    expect(resolveFinalTurnUsage(null, normalizeClaudeUsageSnapshot({ input_tokens: 100, output_tokens: 10 }), 200_000)).toBeNull()
+  })
+
+  test("propagates maxTokens from lastKnownContextWindow", () => {
+    const live = normalizeClaudeUsageSnapshot({ input_tokens: 100, output_tokens: 50 })!
+    const result = resolveFinalTurnUsage(live, null, 200_000)
+    expect(result!.maxTokens).toBe(200_000)
+  })
+
+  test("enriches totalProcessedTokens when accumulated > live usedTokens", () => {
+    const live = normalizeClaudeUsageSnapshot({ input_tokens: 100, output_tokens: 50 })!
+    const accumulated = normalizeClaudeUsageSnapshot({ input_tokens: 500, output_tokens: 50 })!
+    expect(accumulated.usedTokens).toBeGreaterThan(live.usedTokens)
+
+    const result = resolveFinalTurnUsage(live, accumulated, undefined)
+    expect(result!.totalProcessedTokens).toBe(accumulated.usedTokens)
+  })
+
+  test("does NOT enrich totalProcessedTokens when accumulated <= live usedTokens", () => {
+    const live = normalizeClaudeUsageSnapshot({ input_tokens: 500, output_tokens: 50 })!
+    const accumulated = normalizeClaudeUsageSnapshot({ input_tokens: 100, output_tokens: 20 })!
+    expect(accumulated.usedTokens).toBeLessThanOrEqual(live.usedTokens)
+
+    const result = resolveFinalTurnUsage(live, accumulated, undefined)
+    expect(result!.totalProcessedTokens).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// maxClaudeContextWindowFromModelUsage
+// ---------------------------------------------------------------------------
+
+describe("maxClaudeContextWindowFromModelUsage", () => {
+  test("returns undefined for null", () => {
+    expect(maxClaudeContextWindowFromModelUsage(null)).toBeUndefined()
+  })
+
+  test("returns undefined for non-record input", () => {
+    expect(maxClaudeContextWindowFromModelUsage("string")).toBeUndefined()
+    expect(maxClaudeContextWindowFromModelUsage(42)).toBeUndefined()
+  })
+
+  test("returns undefined for empty object", () => {
+    expect(maxClaudeContextWindowFromModelUsage({})).toBeUndefined()
+  })
+
+  test("returns max contextWindow across multiple models", () => {
+    const modelUsage = {
+      "claude-opus": { contextWindow: 200_000, inputTokens: 100 },
+      "claude-sonnet": { context_window: 1_000_000, inputTokens: 200 },
+    }
+    expect(maxClaudeContextWindowFromModelUsage(modelUsage)).toBe(1_000_000)
+  })
+
+  test("accepts context_window (snake_case) field name", () => {
+    const modelUsage = {
+      model: { context_window: 150_000 },
+    }
+    expect(maxClaudeContextWindowFromModelUsage(modelUsage)).toBe(150_000)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// parseConfiguredContextWindowFromModelId
+// ---------------------------------------------------------------------------
+
+describe("parseConfiguredContextWindowFromModelId", () => {
+  test("returns 1_000_000 for model ids ending with [1m]", () => {
+    expect(parseConfiguredContextWindowFromModelId("claude-opus-4-6[1m]")).toBe(1_000_000)
+    expect(parseConfiguredContextWindowFromModelId("claude-sonnet-4-7[1m]")).toBe(1_000_000)
+  })
+
+  test("returns undefined for model ids without [1m] suffix", () => {
+    expect(parseConfiguredContextWindowFromModelId("claude-opus-4-6")).toBeUndefined()
+    expect(parseConfiguredContextWindowFromModelId("claude-sonnet-4-7")).toBeUndefined()
+    expect(parseConfiguredContextWindowFromModelId("")).toBeUndefined()
+  })
+})

package/src/server/claude-usage-math.ts

@@ -0,0 +1,132 @@
+/**
+ * claude-usage-math.ts
+ *
+ * Pure context-window usage math: normalises raw SDK token-count shapes into
+ * typed ContextWindowUsageSnapshot values. No IO, no side effects.
+ *
+ * Extracted from agent.ts — see decompose-large-files loop.
+ */
+import type { ContextWindowUsageSnapshot } from "../shared/types"
+import { isRecord } from "../shared/errors"
+
+// ---------------------------------------------------------------------------
+// Private narrowing helpers
+// ---------------------------------------------------------------------------
+
+function asRecord<T>(value: T): Record<string, unknown> | null {
+  return isRecord(value) ? value : null
+}
+
+function asNumber<T>(value: T): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}
+
+// ---------------------------------------------------------------------------
+// Public exports
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalise the raw `usage` object from a Claude SDK assistant/result message
+ * into a typed ContextWindowUsageSnapshot, returning null when the value is
+ * empty or contains no positive token counts.
+ *
+ * Accepts both camelCase (SDK internal) and snake_case (JSON-wire) field names.
+ */
+export function normalizeClaudeUsageSnapshot<T>(
+  value: T,
+  maxTokens?: number,
+): ContextWindowUsageSnapshot | null {
+  const usage = asRecord(value)
+  if (!usage) return null
+
+  const directInputTokens = asNumber(usage.input_tokens) ?? asNumber(usage.inputTokens) ?? 0
+  const cacheCreationInputTokens =
+    asNumber(usage.cache_creation_input_tokens) ?? asNumber(usage.cacheCreationInputTokens) ?? 0
+  const cacheReadInputTokens =
+    asNumber(usage.cache_read_input_tokens) ?? asNumber(usage.cacheReadInputTokens) ?? 0
+  const outputTokens = asNumber(usage.output_tokens) ?? asNumber(usage.outputTokens) ?? 0
+  const reasoningOutputTokens =
+    asNumber(usage.reasoning_output_tokens) ?? asNumber(usage.reasoningOutputTokens)
+  const toolUses = asNumber(usage.tool_uses) ?? asNumber(usage.toolUses)
+  const durationMs = asNumber(usage.duration_ms) ?? asNumber(usage.durationMs)
+
+  const inputTokens = directInputTokens + cacheCreationInputTokens + cacheReadInputTokens
+  const usedTokens = inputTokens + outputTokens
+  if (usedTokens <= 0) {
+    return null
+  }
+
+  return {
+    usedTokens,
+    inputTokens,
+    ...(cacheReadInputTokens > 0 ? { cachedInputTokens: cacheReadInputTokens } : {}),
+    ...(outputTokens > 0 ? { outputTokens } : {}),
+    ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+    lastUsedTokens: usedTokens,
+    lastInputTokens: inputTokens,
+    ...(cacheReadInputTokens > 0 ? { lastCachedInputTokens: cacheReadInputTokens } : {}),
+    ...(outputTokens > 0 ? { lastOutputTokens: outputTokens } : {}),
+    ...(reasoningOutputTokens !== undefined ? { lastReasoningOutputTokens: reasoningOutputTokens } : {}),
+    ...(toolUses !== undefined ? { toolUses } : {}),
+    ...(durationMs !== undefined ? { durationMs } : {}),
+    ...(typeof maxTokens === "number" && maxTokens > 0 ? { maxTokens } : {}),
+    compactsAutomatically: false,
+  }
+}
+
+// Resolve the single `context_window_updated` snapshot emitted at end of a
+// turn. `latestUsageSnapshot` is the last per-`assistant`-message usage — a
+// single-request view, the real live context size. `accumulatedUsage` is
+// derived from SDK `result.usage`, which is CUMULATIVE: it re-counts
+// `cache_read_input_tokens` on every tool round-trip, so its `usedTokens`
+// balloons to millions on long turns.
+//
+// The cumulative figure must never become `usedTokens` — proactive-compact
+// reads `usedTokens` and would trip far below the real threshold, then the
+// no-assistant-usage compact turn would re-inflate and force a second
+// compact (the double-compact bug). So cumulative only ever enriches
+// `totalProcessedTokens`. When no per-assistant snapshot exists (compact /
+// system turns), return null: the caller skips emission and proactive-compact
+// falls back to the prior live snapshot (or a compact_boundary → no compact).
+export function resolveFinalTurnUsage(
+  latestUsageSnapshot: ContextWindowUsageSnapshot | null,
+  accumulatedUsage: ContextWindowUsageSnapshot | null,
+  lastKnownContextWindow: number | undefined,
+): ContextWindowUsageSnapshot | null {
+  if (!latestUsageSnapshot) return null
+  return {
+    ...latestUsageSnapshot,
+    ...(typeof lastKnownContextWindow === "number" ? { maxTokens: lastKnownContextWindow } : {}),
+    ...(accumulatedUsage && accumulatedUsage.usedTokens > latestUsageSnapshot.usedTokens
+      ? { totalProcessedTokens: accumulatedUsage.usedTokens }
+      : {}),
+  }
+}
+
+/**
+ * Extracts the maximum context window reported across all models in the SDK's
+ * `result.modelUsage` map. Returns undefined when the value is not a
+ * record or contains no numeric contextWindow fields.
+ */
+export function maxClaudeContextWindowFromModelUsage<T>(modelUsage: T): number | undefined {
+  const record = asRecord(modelUsage)
+  if (!record) return undefined
+
+  let maxContextWindow: number | undefined
+  for (const value of Object.values(record)) {
+    const usage = asRecord(value)
+    const contextWindow = asNumber(usage?.contextWindow) ?? asNumber(usage?.context_window)
+    if (contextWindow === undefined) continue
+    maxContextWindow = Math.max(maxContextWindow ?? 0, contextWindow)
+  }
+  return maxContextWindow
+}
+
+// The SDK's `result.modelUsage[*].contextWindow` can lie: it reports 200_000 even
+// when the user opted into the 1M beta via the `[1m]` model id suffix
+// (claude-agent-sdk-typescript#238). Without this hint, proactive-compact would
+// trip at 167k tokens — ~17% of the real 1M window — and compact far too often.
+// We derive the configured window from the SDK model id and use it as a floor.
+export function parseConfiguredContextWindowFromModelId(modelId: string): number | undefined {
+  return modelId.endsWith("[1m]") ? 1_000_000 : undefined
+}

package/src/server/diff-store-branch-ops.adapter.test.ts

@@ -0,0 +1,332 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { runGit } from "./diff-store"
+import type { DiffStoreBranchOpsDeps } from "./diff-store-branch-ops.adapter"
+import {
+  checkoutBranch,
+  createBranch,
+  listBranches,
+  mergeBranch,
+  previewMergeBranch,
+  syncBranch,
+} from "./diff-store-branch-ops.adapter"
+
+async function makeRepo(): Promise<string> {
+  const dir = mkdtempSync(path.join(tmpdir(), "kanna-branch-ops-"))
+  await runGit(["init", "-b", "main"], dir)
+  await runGit(["config", "user.email", "test@kanna.local"], dir)
+  await runGit(["config", "user.name", "kanna-test"], dir)
+  writeFileSync(path.join(dir, "README.md"), "hello\n")
+  await runGit(["add", "README.md"], dir)
+  await runGit(["commit", "-m", "init"], dir)
+  return dir
+}
+
+function makeDeps(overrides: Partial<DiffStoreBranchOpsDeps> = {}): DiffStoreBranchOpsDeps {
+  return {
+    refreshSnapshot: async () => false,
+    ...overrides,
+  }
+}
+
+describe("listBranches", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(listBranches(makeDeps(), { projectPath: dir })).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("lists current branch in local branches", async () => {
+    const repo = await makeRepo()
+    const result = await listBranches(makeDeps(), { projectPath: repo })
+    expect(result.currentBranchName).toBe("main")
+    const localNames = result.local.map((b) => b.name)
+    expect(localNames).toContain("main")
+    expect(result.local[0]).toMatchObject({ kind: "local", displayName: "main" })
+  }, 30_000)
+
+  test("returns empty remote/pullRequests with no remote", async () => {
+    const repo = await makeRepo()
+    const result = await listBranches(makeDeps(), { projectPath: repo })
+    expect(result.remote).toHaveLength(0)
+    expect(result.pullRequests).toHaveLength(0)
+    expect(result.pullRequestsStatus).toBe("unavailable")
+  }, 30_000)
+
+  test("lists multiple local branches", async () => {
+    const repo = await makeRepo()
+    await runGit(["switch", "-c", "feature-a"], repo)
+    await runGit(["switch", "main"], repo)
+    await runGit(["switch", "-c", "feature-b"], repo)
+    await runGit(["switch", "main"], repo)
+
+    const result = await listBranches(makeDeps(), { projectPath: repo })
+    const localNames = result.local.map((b) => b.name)
+    expect(localNames).toContain("main")
+    expect(localNames).toContain("feature-a")
+    expect(localNames).toContain("feature-b")
+  }, 30_000)
+})
+
+describe("createBranch", () => {
+  test("throws for empty branch name", async () => {
+    const repo = await makeRepo()
+    await expect(
+      createBranch(makeDeps(), { projectId: "p1", projectPath: repo, name: "" })
+    ).rejects.toThrow("Branch name is required")
+  }, 15_000)
+
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      createBranch(makeDeps(), { projectId: "p1", projectPath: dir, name: "new-branch" })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("returns failure for duplicate branch name", async () => {
+    const repo = await makeRepo()
+    const result = await createBranch(makeDeps(), { projectId: "p1", projectPath: repo, name: "main" })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.title).toContain("Create branch failed")
+      expect(result.message).toContain("main")
+    }
+  }, 30_000)
+
+  test("creates a new branch and switches to it", async () => {
+    const repo = await makeRepo()
+    const result = await createBranch(makeDeps(), { projectId: "p1", projectPath: repo, name: "my-feature" })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.branchName).toBe("my-feature")
+      expect(result.snapshotChanged).toBe(false)
+    }
+  }, 30_000)
+
+  test("creates branch from explicit base branch", async () => {
+    const repo = await makeRepo()
+    const result = await createBranch(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      name: "from-main",
+      baseBranchName: "main",
+    })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.branchName).toBe("from-main")
+    }
+  }, 30_000)
+})
+
+describe("checkoutBranch", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      checkoutBranch(makeDeps(), {
+        projectId: "p1",
+        projectPath: dir,
+        branch: { kind: "local", name: "main" },
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("cancels when dirty paths and bringChanges is false", async () => {
+    const repo = await makeRepo()
+    // Create another branch to checkout
+    await runGit(["switch", "-c", "other"], repo)
+    await runGit(["switch", "main"], repo)
+    // Dirty the working tree
+    writeFileSync(path.join(repo, "dirty.txt"), "changes\n")
+
+    const result = await checkoutBranch(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      branch: { kind: "local", name: "other" },
+      bringChanges: false,
+    })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.cancelled).toBe(true)
+      expect(result.title).toContain("cancelled")
+    }
+  }, 30_000)
+
+  test("switches to a local branch", async () => {
+    const repo = await makeRepo()
+    await runGit(["switch", "-c", "feature-x"], repo)
+    await runGit(["switch", "main"], repo)
+
+    const result = await checkoutBranch(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      branch: { kind: "local", name: "feature-x" },
+    })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.branchName).toBe("feature-x")
+    }
+  }, 30_000)
+})
+
+describe("previewMergeBranch", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      previewMergeBranch(makeDeps(), {
+        projectPath: dir,
+        branch: { kind: "local", name: "main" },
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("returns up_to_date when targeting current branch", async () => {
+    const repo = await makeRepo()
+    const result = await previewMergeBranch(makeDeps(), {
+      projectPath: repo,
+      branch: { kind: "local", name: "main" },
+    })
+    expect(result.status).toBe("up_to_date")
+    expect(result.currentBranchName).toBe("main")
+    expect(result.targetBranchName).toBe("main")
+  }, 30_000)
+
+  test("returns up_to_date when branch has no new commits", async () => {
+    const repo = await makeRepo()
+    // Create a branch but don't add commits — so it has 0 commits ahead of main
+    await runGit(["switch", "-c", "empty-branch"], repo)
+    await runGit(["switch", "main"], repo)
+
+    const result = await previewMergeBranch(makeDeps(), {
+      projectPath: repo,
+      branch: { kind: "local", name: "empty-branch" },
+    })
+    expect(result.status).toBe("up_to_date")
+    expect(result.commitCount).toBe(0)
+  }, 30_000)
+
+  test("returns mergeable when branch has new commits", async () => {
+    const repo = await makeRepo()
+    // Create a branch with a commit
+    await runGit(["switch", "-c", "with-commits"], repo)
+    writeFileSync(path.join(repo, "new-file.txt"), "content\n")
+    await runGit(["add", "new-file.txt"], repo)
+    await runGit(["commit", "-m", "add new file"], repo)
+    await runGit(["switch", "main"], repo)
+
+    const result = await previewMergeBranch(makeDeps(), {
+      projectPath: repo,
+      branch: { kind: "local", name: "with-commits" },
+    })
+    expect(result.status).toBe("mergeable")
+    expect(result.commitCount).toBe(1)
+    expect(result.hasConflicts).toBe(false)
+  }, 30_000)
+})
+
+describe("mergeBranch", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      mergeBranch(makeDeps(), {
+        projectId: "p1",
+        projectPath: dir,
+        branch: { kind: "local", name: "main" },
+      })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("returns failure when working tree is dirty", async () => {
+    const repo = await makeRepo()
+    writeFileSync(path.join(repo, "dirty.txt"), "changes\n")
+    const result = await mergeBranch(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      branch: { kind: "local", name: "main" },
+    })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.title).toContain("Merge blocked")
+    }
+  }, 30_000)
+
+  test("returns failure when already up to date", async () => {
+    const repo = await makeRepo()
+    await runGit(["switch", "-c", "no-new-commits"], repo)
+    await runGit(["switch", "main"], repo)
+    const result = await mergeBranch(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      branch: { kind: "local", name: "no-new-commits" },
+    })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.title).toContain("Already up to date")
+    }
+  }, 30_000)
+
+  test("merges a branch with new commits", async () => {
+    const repo = await makeRepo()
+    await runGit(["switch", "-c", "to-merge"], repo)
+    writeFileSync(path.join(repo, "merged-file.txt"), "content\n")
+    await runGit(["add", "merged-file.txt"], repo)
+    await runGit(["commit", "-m", "add merged file"], repo)
+    await runGit(["switch", "main"], repo)
+
+    const result = await mergeBranch(makeDeps(), {
+      projectId: "p1",
+      projectPath: repo,
+      branch: { kind: "local", name: "to-merge" },
+    })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.branchName).toBe("main")
+    }
+  }, 30_000)
+})
+
+describe("syncBranch", () => {
+  test("throws when not a git repo", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "kanna-not-git-"))
+    await expect(
+      syncBranch(makeDeps(), { projectId: "p1", projectPath: dir, action: "fetch" })
+    ).rejects.toThrow("not in a git repository")
+  }, 15_000)
+
+  test("returns failure for push without upstream", async () => {
+    const repo = await makeRepo()
+    const result = await syncBranch(makeDeps(), { projectId: "p1", projectPath: repo, action: "push" })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.title).toContain("Push failed")
+      expect(result.message).toContain("upstream")
+    }
+  }, 30_000)
+
+  test("returns failure for pull without upstream", async () => {
+    const repo = await makeRepo()
+    const result = await syncBranch(makeDeps(), { projectId: "p1", projectPath: repo, action: "pull" })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.title).toContain("Pull failed")
+      expect(result.message).toContain("upstream")
+    }
+  }, 30_000)
+
+  test("fetch returns failure when no remote configured", async () => {
+    const repo = await makeRepo()
+    const result = await syncBranch(makeDeps(), { projectId: "p1", projectPath: repo, action: "fetch" })
+    // fetch --all --prune with no remotes: git either returns non-zero or returns ok with nothing to fetch
+    // Either is acceptable — just verify we get a response
+    expect(result.action).toBe("fetch")
+  }, 30_000)
+
+  test("publish returns failure when no remote configured", async () => {
+    const repo = await makeRepo()
+    const result = await syncBranch(makeDeps(), { projectId: "p1", projectPath: repo, action: "publish" })
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.action).toBe("publish")
+    }
+  }, 30_000)
+})