fix(sync): Fix metadata merge bug, improve type safety, add tests

- Fix metadata replacement bug in importSubtasksFromIssueBody that would
  wipe integration metadata (github/shortcut keys) when updating existing
  subtasks — now merges with existing metadata
- Change createData type from Record<string, unknown> to CreateTaskInput
  for compile-time type safety, removing unsafe cast in saveMetadata
- Add end-to-end test for sync pull creating subtasks locally
- Add test for --update updating existing subtasks (not just creating)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dcramer

src/cli/import.test.ts

@@ -492,6 +492,65 @@ describe("import command", () => {
       expect(subtask!.parent_id).toBe("task600");
     });
 
+    it("updates existing subtasks during --update", async () => {
+      // First import: task with a subtask
+      githubMock.getIssue(
+        "test-owner",
+        "test-repo",
+        700,
+        createIssueFixture({
+          number: 700,
+          title: "Task With Sub",
+          body: createFullDexIssueBody({
+            context: "Has subtask",
+            rootMetadata: { id: "task700" },
+            subtasks: [{ id: "existsub1", name: "Original Name", priority: 1 }],
+          }),
+        }),
+      );
+      await runCli(["import", "#700"], { storage });
+
+      let tasks = await storage.readAsync();
+      expect(tasks.tasks).toHaveLength(2);
+      const originalSub = tasks.tasks.find((t) => t.id === "existsub1");
+      expect(originalSub).toBeDefined();
+      expect(originalSub!.name).toBe("Original Name");
+
+      // Second import with --update: subtask has changed
+      githubMock.getIssue(
+        "test-owner",
+        "test-repo",
+        700,
+        createIssueFixture({
+          number: 700,
+          title: "Task With Sub",
+          body: createFullDexIssueBody({
+            context: "Has subtask",
+            rootMetadata: { id: "task700" },
+            subtasks: [
+              {
+                id: "existsub1",
+                name: "Updated Name",
+                priority: 3,
+                completed: true,
+              },
+            ],
+          }),
+        }),
+      );
+      await runCli(["import", "#700", "--update"], { storage });
+
+      tasks = await storage.readAsync();
+      // Should still have 2 tasks, not 3 (no duplicate)
+      expect(tasks.tasks).toHaveLength(2);
+      const updatedSub = tasks.tasks.find((t) => t.id === "existsub1");
+      expect(updatedSub).toBeDefined();
+      expect(updatedSub!.name).toBe("Updated Name");
+      expect(updatedSub!.priority).toBe(3);
+      expect(updatedSub!.completed).toBe(true);
+      expect(updatedSub!.parent_id).toBe("task700");
+    });
+
     it("shows subtask counts in --all --dry-run", async () => {
       githubMock.listIssues("test-owner", "test-repo", [
         createIssueFixture({

src/cli/import.ts

@@ -498,7 +498,9 @@ async function importSubtasksFromIssueBody(
         completed: subtask.completed,
         started_at: subtask.started_at,
         result: subtask.result,
-        metadata: subtask.metadata,
+        metadata: subtask.metadata
+          ? { ...existing.metadata, ...subtask.metadata }
+          : existing.metadata,
       });
       idMapping.set(subtask.id, existing.id);
       updated++;

src/cli/sync.test.ts

@@ -11,6 +11,7 @@ import {
   setupGitHubMock,
   cleanupGitHubMock,
   createIssueFixture,
+  createFullDexIssueBody,
   setupShortcutMock,
   cleanupShortcutMock,
   createStoryFixture,
@@ -298,6 +299,74 @@ describe("sync command", () => {
       expect(out).toContain("1 task(s)");
       expect(out).toContain("1 updated");
     });
+
+    it("creates subtasks locally when pulling from remote", async () => {
+      const taskId = await createTask("Parent task", {
+        description: "context",
+      });
+
+      // First sync to create the issue
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({ number: 500, title: "Parent task" }),
+      );
+      await run(["sync", taskId]);
+      fixture.output.stdout.length = 0;
+
+      // Read the task to get its updated_at
+      const store = await fixture.storage.readAsync();
+      const parentTask = store.tasks.find((t) => t.id === taskId)!;
+
+      // Remote is newer and has a subtask that doesn't exist locally
+      const futureTime = new Date(
+        new Date(parentTask.updated_at).getTime() + 3600000,
+      ).toISOString();
+
+      const remoteBody = createFullDexIssueBody({
+        context: "context",
+        rootMetadata: {
+          id: taskId,
+          updated_at: futureTime,
+        },
+        subtasks: [
+          {
+            id: "remotesub1",
+            name: "Remote Subtask",
+            priority: 2,
+            created_at: futureTime,
+            updated_at: futureTime,
+          },
+        ],
+      });
+
+      // Page 1: issue with newer updated_at and subtask
+      githubMock.listIssues("test-owner", "test-repo", [
+        createIssueFixture({
+          number: 500,
+          title: "Parent task",
+          body: remoteBody,
+          labels: [{ name: "dex" }, { name: "dex:pending" }],
+        }),
+      ]);
+      // Page 2: empty (end of pagination)
+      githubMock.listIssues("test-owner", "test-repo", []);
+
+      await run(["sync"]);
+
+      // Verify the subtask was created locally
+      const updatedStore = await fixture.storage.readAsync();
+      const subtask = updatedStore.tasks.find((t) => t.id === "remotesub1");
+      expect(subtask).toBeDefined();
+      expect(subtask!.name).toBe("Remote Subtask");
+      expect(subtask!.parent_id).toBe(taskId);
+      expect(subtask!.priority).toBe(2);
+
+      // Verify summary includes pulled from remote
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("pulled from remote");
+    });
   });
 
   describe("error handling", () => {

src/cli/sync.ts

@@ -456,9 +456,7 @@ async function saveMetadata(
     for (const subtaskResult of result.subtaskResults) {
       if (subtaskResult.needsCreation && subtaskResult.createData) {
         // Create subtask that exists in remote but not locally
-        await service.create(
-          subtaskResult.createData as Parameters<typeof service.create>[0],
-        );
+        await service.create(subtaskResult.createData);
       } else {
         await saveMetadata(service, integrationId, subtaskResult);
       }

src/core/sync/registry.ts

@@ -1,4 +1,4 @@
-import type { Task, TaskStore } from "../../types.js";
+import type { Task, TaskStore, CreateTaskInput } from "../../types.js";
 import type { IntegrationId, SyncAllOptions } from "./interface.js";
 
 /**
@@ -20,7 +20,7 @@ export interface SyncResult {
   /** True if the task doesn't exist locally and needs to be created */
   needsCreation?: boolean;
   /** Full task data for creation (used when needsCreation is true) */
-  createData?: Record<string, unknown>;
+  createData?: CreateTaskInput;
 }
 
 /**