Add native SDK planner data adapter foundation

PRODUCT.md

@@ -0,0 +1,37 @@
+# Product
+
+## Register
+
+product
+
+## Users and purpose
+
+TaskNotes users planning task dates and dependencies on a timeline. The task
+ledger and timeline represent the same records, not a separate planning database.
+
+## Brand
+
+Use the existing TaskNotes family language: quiet paper, legible type, precise
+rules, restrained blue. Preserve the visual system in [DESIGN.md](DESIGN.md).
+
+## Anti-references
+
+Do not introduce a dashboard sidebar or decorative status cards. Do not expose
+internal identifiers or protocol terminology in ordinary sign-in messages.
+
+## Principles
+
+- Preserve one authoritative ledger/timeline scroll and task-row geometry.
+- Keep task edits and collection readiness honest; transport is not saved proof.
+- Sign-in follows the shared SDK lifecycle, with clear plain-language status.
+- Preserve the working runtime until native composition is qualified.
+
+## Accessibility
+
+Keep complete control names, keyboard operation, visible focus, light/dark
+appearance and reduced motion. Status must be written, not colour-only.
+
+## Sources
+
+Existing README.md and DESIGN.md; the coordinator's decided sign-in copy.
+This records existing product context, not a new visual direction.

README.md

@@ -38,7 +38,10 @@ Planner discovers Obsidian Bases views with `type: tasknotesPlanner`. Selecting
 one executes its standard Base filters and ordering through mdbase. Saving a
 view creates or updates a source under `TaskNotes/Views/`, with the current
 project, status, priority, completed-task preference, and zoom stored in the
-view. TaskNotes can show the same filtered result as a compact list and hand it
+view. The normal collection setup declares `md` and `base` in
+`settings.record_extensions`, preserving Markdown and existing extensions: the
+canonical `obsidian.base` type requires YAML document records, not opaque files.
+TaskNotes can show the same filtered result as a compact list and hand it
 off to Planner for timeline work.
 
 ## Timeline interactions
@@ -69,7 +72,10 @@ pnpm dev
 ```
 
 Open [http://127.0.0.1:4174/?demo=1](http://127.0.0.1:4174/?demo=1) for the
-sample plan, or remove `?demo=1` to connect an mdbase collection. Use
+sample plan, or remove `?demo=1` to connect an mdbase collection. The sample
+collection is labelled **Sample tasks**; its changes reset when you leave or
+reload. Choose its collection name to return to the connection screen. Leaving
+the sample also removes its URL flag, so reload does not reopen it. Use
 `127.0.0.1`, not the `localhost` alias: the manifest and callback share this
 single development origin.
 
@@ -134,6 +140,12 @@ signed release. This v2 draft must not deploy before the qualified v2 writer.
 The production declaration assumes `https://planner.tasknotes.dev/`. Update the
 homepage, icon, and redirect URI together if the deployment origin changes.
 
+## New SDK migration
+
+The existing Connect session remains the default. A native SDK data adapter is
+being prepared separately; it is not yet a browser sign-in mode. See
+[its behavior, pinned artifact, and remaining dependencies](docs/new-sdk.md).
+
 ## Repository structure
 
 ```text

docs/capability-v2-migration.md

@@ -87,8 +87,10 @@ deletion. These are atomic group meanings, not independently requested operation
 permissions. Setup assessment/application is handled by Connect's separate
 setup flow, with the existing provisions unchanged.
 
-No `records.create`, `records.delete`, `offline.replica`, `files.*`, or
-`background.schedule` is requested. Full-collection authorization remains
+No `records.create`, `records.delete`, `offline.replica`, or
+`background.schedule` is requested. Collection file actions `list`, `read`,
+`replace` and `move` are declared because next accounts approve
+`collection.read` and `records.edit` together with their matching file actions. Full-collection authorization remains
 necessary for Bases, while the application continues to select and mutate task
 records through `tasknotes.task` only. No app capability aliases or fabricated
 SDK groups were introduced; session state handling remains SDK-owned.

docs/offline-shell.md

@@ -0,0 +1,11 @@
+# Offline app shell
+
+The production build uses `@mdbase-dev/sdk/offline-shell/build` to precache the
+public app shell, scripts, lazy chunks, fonts and packaged WASM as one release.
+A previously opened app can reload its shell without connectivity. This does
+not grant collection access or make uncached files and remote services available
+offline; collection recovery and sync remain the SDK's responsibility.
+
+Updates do not reload open tabs. An incomplete deployment does not replace the
+last successfully cached release. Shell caching never stores authentication or
+collection API responses.

docs/releases/unreleased.md

@@ -0,0 +1,15 @@
+# Unreleased
+
+- Stack schedule date and time controls on phone screens so the full date, including its year, remains readable.
+
+- Flag tasks scheduled after their due date in the ledger instead of displaying a reversed range. Their original dates remain available in the inspector, which also rejects adjacent reversed all-day dates.
+
+- Save schedule edits immediately after changing a task's priority or status, without requiring a reload when the collection's task bindings have not changed.
+
+- Keep the inspector's status, priority and projects in sync when a task changes, including completion from its ledger row, without discarding unsaved date edits.
+
+- Wrap phone-sized ledger titles onto two lines so similar task names can be distinguished. Ledger rows, task bars and dependency lines remain aligned.
+
+- Drag an unscheduled task by its title onto a date in the timeline or its header. Drops outside the timeline explain why the schedule stayed unchanged; clicking a title still opens the task editor.
+
+- Keep Save view available at phone widths as a labelled icon button, instead of hiding it.

e2e/fixtures/phone-ledger.html

@@ -0,0 +1,48 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Planner phone fixture</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">
+      // Development-only HTML entry. No account, SDK application or transport.
+      import React from "react";
+      import { createRoot } from "react-dom/client";
+      import "@fontsource/atkinson-hyperlegible/400.css";
+      import "@fontsource/atkinson-hyperlegible/700.css";
+      import "@fontsource/azeret-mono/400.css";
+      import "/src/styles.css";
+      import { Planner } from "/src/components/planner.tsx";
+      import { DemoPlannerRepository } from "/src/data/demo-repository.ts";
+
+      const repository = new DemoPlannerRepository();
+      const sample = await repository.load();
+      const open = sample.statuses.find((status) => status.value === "open");
+      if (!open) throw new Error("The fixture requires an open status");
+      for (const [index, task] of sample.tasks.slice(0, 2).entries()) {
+        await repository.updateSchedule(
+          {
+            ...task,
+            title: `[test] bugfix3 same-prefix phone task ${index ? "beta" : "alpha"}`,
+            status: open.value,
+            statusLabel: open.label,
+            statusColor: open.color,
+            completed: false,
+            projects: [],
+            blockedBy: [],
+          },
+          { scheduled: undefined, due: undefined },
+        );
+      }
+      createRoot(document.getElementById("root")).render(
+        React.createElement(Planner, {
+          repository,
+          onChangeCollection: async () => undefined,
+        }),
+      );
+    </script>
+  </body>
+</html>

e2e/phone-planner.spec.ts

@@ -0,0 +1,210 @@
+import { expect, test } from "@playwright/test";
+
+// These checks use only the in-memory sample collection, never a real account.
+test.beforeEach(async ({ context, baseURL }) => {
+  if (!baseURL) throw new Error("A loopback application URL is required");
+  const app = new URL(baseURL);
+  if (!["127.0.0.1", "localhost", "[::1]"].includes(app.hostname)) {
+    throw new Error("Sample checks must run against a loopback application");
+  }
+  await context.route("**/*", (route) =>
+    new URL(route.request().url()).origin === app.origin
+      ? route.continue()
+      : route.abort("blockedbyclient"),
+  );
+  await context.routeWebSocket("**/*", (socket) => {
+    if (new URL(socket.url()).host === app.host) socket.connectToServer();
+    else socket.close();
+  });
+});
+
+for (const width of [320, 390]) {
+  test(`Save view stays available at ${width}px`, async ({ page }) => {
+    await page.setViewportSize({ width, height: 844 });
+    await page.goto("/?demo=1");
+    await expect(page.locator(".gantt-scroll")).toBeVisible();
+    const save = page.getByRole("button", { name: "Save view", exact: true });
+    await expect(save).toBeVisible();
+    const bounds = await save.boundingBox();
+    expect(bounds).not.toBeNull();
+    expect(bounds!.width).toBeGreaterThanOrEqual(44);
+    expect(bounds!.x + bounds!.width).toBeLessThanOrEqual(width);
+    expect(
+      await page.evaluate(() => document.documentElement.scrollWidth),
+    ).toBeLessThanOrEqual(width);
+    await save.click();
+    const dialog = page.getByRole("dialog", { name: "Create Planner view" });
+    await expect(dialog).toBeVisible();
+    await dialog.getByLabel("View name").fill("[test] Phone plan");
+    await dialog
+      .getByRole("button", { name: "Save view", exact: true })
+      .click();
+    await expect(dialog).toBeHidden();
+    await expect(
+      page
+        .getByRole("combobox", { name: "Planner view" })
+        .locator("option:checked"),
+    ).toHaveText("[test] Phone plan");
+    await expect(
+      page.getByRole("button", { name: "Save changes", exact: true }),
+    ).toBeVisible();
+  });
+}
+
+test("schedule dates and times have full-width rows on phones", async ({
+  page,
+}) => {
+  for (const width of [320, 390]) {
+    await page.setViewportSize({ width, height: 844 });
+    await page.goto("/?demo=1");
+    await page
+      .getByRole("button", { name: /Select to edit or drag/ })
+      .first()
+      .click();
+    const inspector = page.locator(".task-inspector");
+    for (const field of ["Scheduled", "Due"]) {
+      const date = inspector.getByLabel(field, { exact: true });
+      const time = inspector.getByLabel(`${field} time`, { exact: true });
+      await date.fill("2026-11-07");
+      const dateBounds = await date.boundingBox();
+      const timeBounds = await time.boundingBox();
+      expect(dateBounds).not.toBeNull();
+      expect(timeBounds).not.toBeNull();
+      expect(dateBounds!.width).toBeGreaterThanOrEqual(240);
+      expect(timeBounds!.width).toBeGreaterThanOrEqual(240);
+      expect(timeBounds!.y).toBeGreaterThanOrEqual(
+        dateBounds!.y + dateBounds!.height,
+      );
+      expect(dateBounds!.x + dateBounds!.width).toBeLessThanOrEqual(width);
+    }
+    expect(
+      await page.evaluate(() => document.documentElement.scrollWidth),
+    ).toBeLessThanOrEqual(width);
+  }
+});
+
+test("an unscheduled title can drop onto a date header and still opens the editor on click", async ({
+  page,
+}) => {
+  await page.goto("/?demo=1");
+  const title = page
+    .getByRole("button", { name: /not scheduled. Select to edit or drag/ })
+    .first();
+  await expect(title).toBeVisible();
+  const name = await title.locator("strong").innerText();
+  const ledger = page.locator(".task-ledger-main").filter({ hasText: name });
+  const source = await title.boundingBox();
+  const header = await page.locator(".timeline-header").boundingBox();
+  const corner = await page.locator(".gantt-corner").boundingBox();
+  if (!source || !header || !corner)
+    throw new Error("Drag geometry unavailable");
+  await page.mouse.move(
+    source.x + source.width / 2,
+    source.y + source.height / 2,
+  );
+  await page.mouse.down();
+  await page.mouse.move(
+    corner.x + corner.width + 200,
+    header.y + header.height / 2,
+    {
+      steps: 12,
+    },
+  );
+  await page.mouse.up();
+  await expect(page.locator(".gantt-interaction-message")).toHaveText(
+    "Schedule saved",
+  );
+  await expect(ledger).not.toContainText("Not scheduled");
+  await expect(page.locator(".task-inspector")).toHaveCount(0);
+  await ledger.click();
+  await expect(page.locator(".task-inspector")).toBeVisible();
+});
+
+const phonePrefix = "[test] bugfix3 same-prefix phone task";
+
+for (const width of [320, 390]) {
+  test(`same-prefix titles remain distinguishable with aligned rows at ${width}px`, async ({
+    page,
+  }) => {
+    await page.setViewportSize({ width, height: 844 });
+    await page.goto("/e2e/fixtures/phone-ledger.html");
+    await page.getByLabel(/^Search tasks/).fill(phonePrefix);
+    await expect(page.locator(".task-row")).toHaveCount(2);
+    await page.evaluate(() => document.fonts.ready);
+    for (const suffix of ["alpha", "beta"]) {
+      const title = page
+        .locator(".ledger-title strong")
+        .filter({ hasText: `${phonePrefix} ${suffix}` });
+      await expect(title).toHaveCSS("white-space", "normal");
+      expect(
+        await title.evaluate((element, suffix) => {
+          const text = element.firstChild;
+          const start = element.textContent!.lastIndexOf(suffix);
+          if (!text || start < 0) throw new Error("Title suffix is missing");
+          const range = document.createRange();
+          range.setStart(text, start);
+          range.setEnd(text, start + suffix.length);
+          const glyphs = range.getBoundingClientRect();
+          const bounds = element.getBoundingClientRect();
+          return (
+            glyphs.top >= bounds.top - 1 &&
+            glyphs.bottom <= bounds.bottom + 1 &&
+            glyphs.left >= bounds.left - 1 &&
+            glyphs.right <= bounds.right + 1
+          );
+        }, suffix),
+      ).toBe(true);
+    }
+    for (const row of await page.locator(".task-row").all()) {
+      expect((await row.boundingBox())!.height).toBe(65);
+      expect((await row.locator(".task-ledger").boundingBox())!.height).toBe(
+        65,
+      );
+      expect((await row.locator(".timeline-row").boundingBox())!.height).toBe(
+        65,
+      );
+      const bounds = (await row.boundingBox())!;
+      const action = (await row
+        .locator(".unscheduled-row-action")
+        .boundingBox())!;
+      expect(
+        Math.abs(action.y + action.height / 2 - bounds.y - bounds.height / 2),
+      ).toBeLessThanOrEqual(1);
+    }
+    await expect(page.locator(".dependency-layer")).toHaveAttribute(
+      "height",
+      "165",
+    );
+    expect(
+      await page.evaluate(() => document.documentElement.scrollWidth),
+    ).toBeLessThanOrEqual(width);
+  });
+}
+
+test("row completion and reopening refresh the inspector without discarding a date draft", async ({
+  page,
+}) => {
+  await page.goto("/e2e/fixtures/phone-ledger.html");
+  await page.getByLabel(/^Search tasks/).fill(phonePrefix);
+  await page.getByRole("button", { name: "Completed", exact: true }).click();
+  const title = `${phonePrefix} alpha`;
+  await page.locator(".task-ledger-main").filter({ hasText: title }).click();
+  const inspector = page.locator(".task-inspector");
+  await inspector.getByLabel("Scheduled", { exact: true }).fill("2026-11-07");
+  await page
+    .getByRole("button", { name: `Complete ${title}`, exact: true })
+    .click();
+  await expect(inspector.getByLabel(/^Status/)).toHaveValue("done");
+  await expect(inspector.locator(".inspector-title p")).toContainText("Done");
+  await expect(inspector.getByLabel("Scheduled", { exact: true })).toHaveValue(
+    "2026-11-07",
+  );
+  await page
+    .getByRole("button", { name: `Reopen ${title}`, exact: true })
+    .click();
+  await expect(inspector.getByLabel(/^Status/)).toHaveValue("open");
+  await expect(inspector.locator(".inspector-title p")).toContainText("Open");
+  await expect(inspector.getByLabel("Scheduled", { exact: true })).toHaveValue(
+    "2026-11-07",
+  );
+});