kennel 0.2.0 → 0.2.2

package/kernel/plugins/projects/src/ui/project-card.tsx

@@ -0,0 +1,61 @@
+import { Link } from "lucide-react"
+
+import { folderPathId } from "@raggle-ai/folder-plugin/client"
+import { Button } from "@raggle-ai/ui/components/button"
+import {
+  Card,
+  CardAction,
+  CardHeader,
+  CardTitle,
+} from "@raggle-ai/ui/components/card"
+import { CopyContextButton } from "@raggle-ai/ui/components/copy-context"
+import { FolderContextIcon } from "@raggle-ai/ui/components/folder-filter-bar"
+import { FolderMetadata } from "@raggle-ai/ui/components/folder-metadata"
+
+import type { ConnectedProject } from "../data/model.ts"
+
+/** One connected-project card: identity, relation badges, and paths. */
+export type ProjectCardProps = {
+  readonly project: ConnectedProject
+}
+
+export function ProjectCard({ project }: ProjectCardProps) {
+  const hostPathId = folderPathId(project.worktree)
+  const folderHref = `/folder/${hostPathId}/notes`
+  return (
+    <article className="min-w-0">
+      <Card className="h-full min-h-48 py-5">
+        <CardHeader className="min-w-0 gap-1.5">
+          <CardTitle className="min-w-0 break-words">
+            <FolderMetadata
+              href={folderHref}
+              icon={<FolderContextIcon folder={project.worktree} />}
+              path={project.worktree}
+              size="large"
+            />
+          </CardTitle>
+          <CardAction className="flex items-center gap-1">
+            {project.repository ? (
+              <Button asChild size="icon-sm" variant="ghost">
+                <a
+                  aria-label="Open Git repository"
+                  href={project.repository}
+                  rel="noreferrer"
+                  target="_blank"
+                  title="Open Git repository"
+                >
+                  <Link className="size-4" />
+                </a>
+              </Button>
+            ) : null}
+            <CopyContextButton
+              context={project.worktree}
+              label="Copy folder path"
+              size="icon-sm"
+            />
+          </CardAction>
+        </CardHeader>
+      </Card>
+    </article>
+  )
+}

package/kernel/plugins/projects/src/ui/projects-page.tsx

@@ -0,0 +1,102 @@
+import { useQuery } from "@tanstack/react-query"
+
+import type { FolderPluginViewProps } from "@raggle-ai/folder-plugin/client"
+import { CopyContextButton } from "@raggle-ai/ui/components/copy-context"
+
+import type { ProjectsPayload } from "../data/model.ts"
+import { decodeProjectsPayload } from "../data/model.ts"
+import { projectsErrorContext } from "../project-context.ts"
+import { ProjectCard } from "./project-card.tsx"
+
+/** Projects plugin page: one card per connected project. */
+export type ProjectsPluginProps = FolderPluginViewProps
+
+export function ProjectsPage(props: ProjectsPluginProps) {
+  const { folder, folderId, request, subpath } = props
+  const query = useQuery({
+    queryKey: ["folder", folderId, "projects", subpath],
+    queryFn: ({ signal }) =>
+      request(subpath, { signal }) as Promise<ProjectsPayload>,
+    staleTime: 30_000,
+  })
+  const payload = query.data
+    ? (() => {
+        try {
+          return decodeProjectsPayload(query.data)
+        } catch (error) {
+          return {
+            folder,
+            message:
+              error instanceof Error && error.message
+                ? error.message
+                : "Could not parse the projects payload.",
+            projects: [],
+            status: "error" as const,
+          }
+        }
+      })()
+    : undefined
+  const fetchError =
+    query.error instanceof Error && query.error.message
+      ? query.error.message
+      : undefined
+  const failure =
+    fetchError ??
+    (payload?.status === "error" ? payload.message : undefined) ??
+    undefined
+  const loading = !query.error && !payload && query.isPending
+
+  return (
+    <main className="min-h-full bg-transparent text-slate-950">
+      <section
+        className="mx-auto grid w-full max-w-5xl min-w-0 grid-cols-1 gap-4 px-4
+          py-5"
+      >
+        <h2 className="m-0 text-lg font-semibold">Connected projects</h2>
+
+        {loading ? (
+          <p className="text-muted-foreground m-0 text-sm">
+            Loading connected projects…
+          </p>
+        ) : null}
+
+        {failure ? (
+          <div
+            className="rounded-lg border border-red-200 bg-red-50 px-3 py-2
+              text-sm text-red-700"
+          >
+            <p className="m-0" role="alert">
+              {failure}
+            </p>
+            <button
+              className="mt-2 underline underline-offset-2"
+              onClick={() => void query.refetch()}
+              type="button"
+            >
+              Retry
+            </button>
+            <CopyContextButton
+              className="mt-2"
+              context={() => projectsErrorContext(folder, failure)}
+              label="Copy full context for the Projects failure"
+            />
+          </div>
+        ) : null}
+
+        {payload?.status === "available" ? (
+          payload.projects.length ? (
+            <div className="grid min-w-0 grid-cols-1 gap-4">
+              {payload.projects.map((project) => (
+                <ProjectCard key={project.worktree} project={project} />
+              ))}
+            </div>
+          ) : (
+            <p className="text-muted-foreground m-0 text-sm">
+              No connected projects found.
+            </p>
+          )
+        ) : null}
+      </section>
+    </main>
+  )
+}

package/kernel/plugins/projects/test/package.test.mjs

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict"
+import { readFile } from "node:fs/promises"
+import test from "node:test"
+
+const packageJson = JSON.parse(
+  await readFile(new URL("../package.json", import.meta.url), "utf8"),
+)
+
+test("projects package is ready for public npm publishing", () => {
+  assert.equal(packageJson.private, undefined)
+  assert.equal(packageJson.version, "0.1.0")
+  assert.equal(packageJson.license, "MIT")
+  assert.equal(packageJson.publishConfig?.access, "public")
+  assert.equal(packageJson.repository?.directory, "plugins/projects")
+  assert.deepEqual(packageJson.files, ["src"])
+})
+
+test("projects package ships the standard plugin script set", () => {
+  for (const script of [
+    "test",
+    "typecheck",
+    "format",
+    "lint",
+    "clean",
+    "pack:check",
+    "publish:public:dry-run",
+  ]) {
+    assert.ok(
+      typeof packageJson.scripts?.[script] === "string",
+      `missing script "${script}"`,
+    )
+  }
+})
+
+test("projects package exposes manifest, model, and split server/client entry points", () => {
+  assert.deepEqual(Object.keys(packageJson.exports).sort(), [
+    ".",
+    "./client",
+    "./manifest",
+    "./model",
+    "./server",
+  ])
+})
+
+test("projects client entry does not import the Node server entry", async () => {
+  const clientSource = await readFile(
+    new URL("../src/client.tsx", import.meta.url),
+    "utf8",
+  )
+  assert.doesNotMatch(clientSource, /node:|\/server"/)
+})

package/kernel/plugins/projects/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@raggle-ai/tsconfig/base.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "jsx": "preserve",
+    "baseUrl": ".",
+    "allowImportingTsExtensions": true,
+    // local copy: bun doesn't read paths inherited via `extends`
+    "paths": {
+      "~/*": ["${configDir}/../../packages/*/src"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "eslint.config.mjs"]
+}

package/kernel/plugins/tasks/SKILL.md

@@ -0,0 +1,341 @@
+---
+name: kennel-tasks
+description: Open and read a folder's `todo.json` task file in the Kennel viewer — valid detection, task dataset shaping (workspace-merged across nested folders), folder filter chips, agent and tag filter areas, open/completed summaries, validation errors and warnings, or scaffold a starter file with `kennel init`. Also covers how to write todos well — note linking through the task `notes` field, accompanying note files with their linked sections, and soft warnings for todos that have no notes. Use when the user asks to view tasks or a todo list for a folder in Kennel, open a workspace's backend `todo.json`, see open or completed task counts, list tasks by status, priority, tag, or assignee, create or update tasks, create a starter task file, or verify a tasks view loads.
+---
+
+# Kennel Tasks Plugin
+
+The Tasks plugin (`@raggle-ai/tasks`) renders a folder's `todo.json` task file
+in the Kennel web viewer: a compact open-task list with title + status/key
+rows, and an individual task page per task (title, description, steps,
+acceptance criteria, badges, links). The file is a repository-native task
+format intended to cover Jira/Linear-style planning from one JSON file.
+
+This skill covers the agent-facing parts of that plugin: where the task file
+lives, how detection works, how the dataset is shaped, and how to open and
+verify the view. For the plugin package's implementation contract, see
+`plugins/README.md` in the Kennel repo.
+
+## When to use
+
+- The user asks to view tasks or a todo list for a folder in Kennel.
+- The user wants open/completed counts, or which tasks exist for a workspace.
+- The user asks to create, update, or organize tasks — the writing guidance
+  below is what makes a task useful later.
+- Preview or verification work needs the Tasks plugin tab to be available and
+  populated for a target folder.
+
+## Workflow
+
+1. **Identify the folder** whose tasks the user wants. The plugin reads
+   exactly one file: `todo.json` at the root of the served folder.
+2. **Check for a task file.** Confirm `todo.json` exists at the folder root,
+   or open the folder in the viewer and check the **Tasks** plugin tab. The
+   tab is always present on a folder; its badge shows the task count when the
+   file is valid and a warning marker when `todo.json` exists but is invalid
+   (hover for the first validation problem). There is no recursive scan — a
+   `todo.json` in a subfolder does not count for the parent.
+
+   If no `todo.json` exists and the user wants to start tracking tasks, run
+   `kennel init` (or `kennel init --plugin tasks`) in the folder to scaffold
+   a valid v2 starter file — it passes detection immediately and the tab
+   gains a badge right away. Only scaffold when the user asks for it or when
+   creating a task file is clearly in scope; never modify an existing file.
+
+3. **Read the tasks.** Read and summarize tasks from the source `todo.json`
+   itself — names, statuses, priorities, assignees, deadlines. Do not invent
+   tasks or states. The completion rule is: a task is complete when
+   `done: true` **or** `status: "done"`.
+
+   **Write tags for grouped todos.** When creating or editing `todo.json`
+   tasks, add a short lowercase `tags` entry to every task that belongs to a
+   group (subtasks of an epic, tasks for the same project, cycle, or batch,
+   related bugs) — for example `"tags": ["auth"]`. One tag per group is
+   enough; the viewer renders one filter chip per tag, so tagging is what
+   makes grouped todos filterable together.
+
+   **Link notes to every todo.** A todo is only half the work — the
+   context lives in notes. When creating or updating a task, set a
+   `notes` array on the task with at least one entry: a note path relative
+   to the folder that owns the `todo.json` (for example
+   `"notes": ["company-records/finance/vat-registration-submission.md"]`),
+   optionally with a `#section` heading, or an https URL for external
+   references. Create or update the accompanying note in the same pass —
+   put the related file references (specs, evidence, other notes, the task
+   key itself) into the note's linked sections so the link works in both
+   directions. The viewer renders local note refs as chips that open the
+   note in the same view, and https refs as external links. Note that the
+   path is relative to the owning `todo.json` folder, so nested task files
+   use paths relative to their own directory.
+
+4. **Handle validation errors.** If the badge is a warning marker (or the
+   view shows the red error panel), the file exists but is not valid. Read
+   the exact issues — either from the view's `path: message` lines or from
+   the API: `curl -fsS "$URL/api/plugins/tasks?path=<folder>"` returns
+   `status: "error"` with an `issues` array (for example
+   `tasks[2].status: must be one of …; got "in-progress"`). Report what is
+   wrong and where; do not report counts or summarize an invalid file as if
+   it worked.
+5. **Open the view.** `kennel serve <folder>` (or `kennel view <folder>` in a
+   source checkout), then point at the Tasks tab. Launch, port, watch, and
+   link verification mechanics come from the `kennel-preview` skill — install
+   it alongside this one so the full workflow works.
+6. **Verify before reporting.** Confirm the server is alive
+   (`curl -fsS "$URL/api/health"`), the printed URL serves the exact requested
+   folder root, the Tasks tab is present, and the rendered open/completed
+   counts match the `todo.json` tasks (or, for an invalid file, that the
+   shown issues match the validation output).
+
+## Views
+
+- **Task list** (`/folder/<id>/views/tasks`) — one compact row per task:
+  a complete/reopen tick button, the title (linked to the task page), and a
+  status/key meta line. The description is intentionally not repeated here.
+  All filter areas share one wrapping horizontal line above the list, so
+  done tasks appear with their checkmark while filtered: the **folder**
+  filter bar (skims workspace-merged `todo.json` files), a **Status**
+  dropdown (All / Open / Done / Blocked / Late with counts), and two
+  expand/collapse multi-select chip panels — **Agent** (assignees used by
+  the tasks, from `people` plus raw assignee ids) and **Tag** (one chip per
+  tag, each with its task count). Each panel opens on button click, reveals its chip wall,
+  and filters the list in real time as chips are toggled; the button shows
+  a count badge while selections are active. Status, agent, and tag
+  filters combine; the Agent and Tag panels disappear when the dataset has
+  no assignees or no tags.
+- **Task page** (`/folder/<id>/views/tasks/<taskAddress>`) — the full single
+  task: description, steps/acceptance criteria checklists, status/priority/
+  due/tags badges, a Notes strip (local note refs and https references, with
+  local refs clickable into the viewer's document view when the host serves
+  documents), external links, a complete/reopen toggle, and a
+  copy-context action. "Back to Tasks" returns to the list. An unknown id
+  returns `status: "error"` with a `message` like `Task not found: …`.
+  Advisory warnings stay hidden: a compact amber "Warnings (n)" button — at
+  the right end of the filter bar on the list and top-right on the task
+  page — opens them in a modal, so they never push the task list around.
+  The red error panel stays for hard errors that replace the view.
+
+  A workspace view merges several `todo.json` files, and file-local ids
+  (`todo:1`) repeat across files. The task address therefore qualifies the
+  task id with its owning folder: `<folderPathId(source folder)>@<taskId|key>`
+  (the same base64url folder id scheme as the `/folder/<id>` route, so the
+  address stays one URL-safe segment). Every link the plugin builds is
+  qualified. A bare `<taskId|key>` still works as a legacy address and
+  resolves to the first matching source; a qualified address that names a
+  real source but a missing task is an error, never a different task.
+
+## Completing tasks
+
+The tick buttons are write operations: `POST /api/tasks/toggle` with body
+`{ "path": "<folder>", "id": "<taskAddress>" }` flips a task between
+`todo` and `done`. The id accepts the same qualified
+`<folderPathId(source folder)>@<taskId|key>` address as task page URLs, so
+the write lands in the exact `todo.json` that owns the task even when ids
+repeat across the workspace's files. Completing sets `status: "done"`, `done: true`,
+`resolution: "completed"`, `completedAt`, and refreshes `updatedAt`;
+reopening restores `status: "todo"` and clears `resolution`/`completedAt`.
+The edit is written back to the owning `todo.json` preserving the file's
+indent and trailing newline. The API enforces same-origin, rejects unknown
+ids with `Task not found: …`, and is disabled entirely (403) on remote/
+restricted hosts. Tasks in linked folders are read-only and never
+editable.
+
+## Content shape
+
+### Source file (`todo.json`)
+
+Located at the root of the served folder. Shape (`schema.json` in the
+plugin source mirrors the published
+`https://raggle.co/schemas/tasks.json`):
+
+| Field     | Meaning                                                          |
+| --------- | ---------------------------------------------------------------- |
+| `id`      | Source id; default `"todo"` when absent                          |
+| `title`   | Project name; default `"<folder name> tasks"` when absent        |
+| `version` | `1` \| `2`; default `1` when absent                              |
+| `$schema` | Schema reference; default `https://raggle.co/schemas/tasks.json` |
+| `tasks`   | Array of tasks                                                   |
+
+Optional plan structures (`people`, `projects`, `cycles`, `milestones`,
+`components`, `areas`, `integrations`, `customFields`, `automations`) are
+carried through to the dataset.
+
+### Task
+
+| Field                                                                          | Meaning                                                                                                                                                                                                                          |
+| ------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`                                                                         | Required task title                                                                                                                                                                                                              |
+| `id`, `key`, `index`, `rank`                                                   | Identity/ordering                                                                                                                                                                                                                |
+| `status`                                                                       | `todo` \| `in_progress` \| `blocked` \| `review` \| `done` \| `canceled`                                                                                                                                                         |
+| `done`                                                                         | Legacy boolean; `status: "done"` is authoritative in v2. Either marks the task complete                                                                                                                                          |
+| `type`                                                                         | `task` \| `bug` \| `feature` \| `chore` \| `spike` \| `epic` \| `milestone`                                                                                                                                                      |
+| `priority`                                                                     | Integer `1`–`5`                                                                                                                                                                                                                  |
+| `deadline`                                                                     | `YYYY-MM-DD`                                                                                                                                                                                                                     |
+| `assigneeIds`, `tags`                                                          | Assignment and labels. Tag every grouped todo: related or grouped tasks (subtasks of one epic, tasks in the same project or batch) share one short lowercase tag so the viewer groups them under that tag chip                   |
+| `parentId`, `cycleId`, `milestoneIds`, `projectIds`, `componentIds`, `areaIds` | Links to plan structures                                                                                                                                                                                                         |
+| `estimate`                                                                     | `points`, `minutes`, `confidence`                                                                                                                                                                                                |
+| `notes`                                                                        | Accompanying notes and file references. Each entry is a path relative to the owning `todo.json` folder (optionally `path.md#Section`) or an https URL. Give every task at least one note — the viewer warns when a task has none |
+| `relations`, `links`, `comments`, `decisions`                                  | Rich task metadata                                                                                                                                                                                                               |
+| `acceptanceCriteria`, `steps`                                                  | Check items (`id`, `text`, `done`)                                                                                                                                                                                               |
+| `createdAt`, `updatedAt`, `startedAt`, `completedAt`, `canceledAt`             | Timestamps                                                                                                                                                                                                                       |
+
+### Dataset shaping
+
+The plugin normalizes every discovered `todo.json` into one task dataset for
+the viewed folder (recursively, like the calendar plugin): each file becomes
+a `sources` entry (`[{ id, title, total, open }]`) keyed by the absolute
+folder that owns it, every task is tagged with that `source`, and `summary`
+(`{ completed, open, sources }`) aggregates them. The viewer renders a
+compact open-task list with **folder filter chips** (shown when more than
+one folder has tasks) — like mail — so a workspace root can narrow to a
+nested project. An unparseable root file shows a clear error instead of a
+broken view. A task subpath (`?subpath=<taskId|key>` or the task page URL)
+returns the same dataset filtered to exactly that task.
+
+### Note linking (`notes`)
+
+Note linking is the core of a well-written todo: task data is small, and
+the context lives in the accompanying notes. The convention:
+
+- Every task carries at least one `notes` entry.
+- An entry is either a note path **relative to the folder that owns the
+  `todo.json`** — optionally with a `#section` heading
+  (`notes/spec.md#Plan`) — or an https URL.
+- Create or update the accompanying note in the same pass, and put the
+  related file references (specs, evidence, other notes, the task key —
+  for example "Tracked as `office/todo.json` TODO-7") into the note's
+  linked sections, so task and note point at each other.
+- In the task view, local note chips open the note in the same viewer (the
+  web app passes a document-route builder; on hosts without one, chips are
+  labels), and https chips open externally.
+
+### Warnings (soft validation)
+
+Advisory problems stay out of the view until wanted: a compact amber
+"Warnings (n)" button (right of the filter bar; on a task page, top-right)
+opens the full list in a modal. Warnings never invalidate the file —
+the badge keeps its count and the API stays `status: "available"`. Today's
+warnings (`todoFileWarnings()` in `src/data/parse.ts` plus a server-side pass
+in `src/server.ts`):
+
+- `tasks[i].notes: no notes; link the accompanying note file or https
+reference` — a task with an empty or absent `notes` array.
+- `tasks[i].notes[j]: references a missing note file: <path>` — a
+  folder-relative entry that does not resolve to a file next to its owning
+  `todo.json` (checked by the server, not the synchronous file validator).
+
+Warning paths use the same `tasks[i]` convention as validation issues,
+relative to the file the task lives in. Warnings travel in the `warnings`
+array of an available payload (separate from `issues`) and surface only
+when the user opens the warnings modal. The modal has a "Copy fix
+instructions for an agent" button: it copies a ready-made prompt that
+lists the exact warnings and tells an agent to fix them — create or update
+the accompanying notes, set the `notes` entries, connect file references
+in the note's linked sections, repair dead paths, and keep `todo.json`
+valid. Use it to hand the whole warning list to an agent in one step.
+
+### Linked folders
+
+When the served folder is connected to other repositories by Raggle links
+(the same relation graph that powers linked notes in the Notes tab — for
+example a `type: "notes"` entry in a workspace `raggle.json`), the host
+passes those folders to the plugin and their `todo.json` files merge into
+the same dataset as their own `sources` entries and folder chips. A folder
+with no local `todo.json` still shows connected team to-dos, and detail
+subpaths resolve across linked sources. Linked content is read-only and
+never appears for remote or restricted hosts.
+
+### Validation errors
+
+Files that exist but are not valid show their problems instead of a generic
+error: the Tasks tab gets a warning badge and the view lists each issue as
+`path: message` lines (for example
+`tasks[2].status: must be one of todo, in_progress, blocked, review, done,
+canceled; got "in-progress"`). The same rules live in `src/data/parse.ts` and
+are
+exported as `@raggle-ai/tasks/parse`; `validateTodoFile()` returns the issue
+list and `parseTodoSource()` turns invalid JSON into an issue rather than
+throwing. Advisory (warning-severity) problems never produce this badge —
+see the "Warnings (soft validation)" section above.
+
+### Schema decode failures ("Task data is not valid.")
+
+There are two validation layers, and a file can pass one and fail the other:
+
+1. **File validation** (`validateTodoFile()` in `src/data/parse.ts`) checks
+   JSON
+   well-formedness and basic field rules. Its issues render as `path:
+message` lines and reach the API as `status: "error"`.
+2. **Strict schema decode** — the viewer decodes the merged dataset against
+   the schema in `src/data/todo-model.ts`, mirrored by `schema.json` and
+   the published `https://raggle.co/schemas/tasks.json`. When this fails the
+   view shows a red "Task data is not valid." panel with a failure tree, but
+   `/api/plugins/tasks` still returns `status: "available"` — so the API
+   issues check alone does not prove the file renders.
+
+The failure tree is an Effect Schema tree. Read its bracketed keys as a JSON
+path into `todo.json`: `"tasks" -> [7] -> "resolution"` means
+`tasks[7].resolution` in the source file. The number is the task's position
+in the `tasks` array; tasks from linked folders follow the local file's. The
+leaves list every accepted value, and `Expected X, actual Y` shows the
+current value.
+
+Common causes and fixes:
+
+- Enum fields given free text: `resolution` accepts only `completed`,
+  `duplicate`, `wont_do`, `not_reproducible`, `moved`, or null; `status` and
+  `type` are enums too. Move the sentence into a `comments` entry (`id` +
+  `body` + `createdAt`) or into `description`, then set the field to an
+  allowed value (finished work uses `resolution: "completed"`).
+- Missing required fields: each `comments` entry needs `id`, `body`, and
+  `createdAt` (ISO date-time); each task needs `name`.
+- Shape mismatches: `null` where a string is required or the reverse, dates
+  not in `YYYY-MM-DD`, timestamps not ISO.
+
+To validate a fix, either re-open the Tasks tab (no red panel and counts
+match the file = valid), or decode the same payload the viewer uses:
+
+```sh
+curl -fsS "$URL/api/plugins/tasks?path=<folder>" | jq -c '.dataset' > /tmp/dataset.json
+bun -e 'const { decodeTodoDataset } = await import("@raggle-ai/tasks/todo-model");
+decodeTodoDataset(await Bun.file("/tmp/dataset.json").json());
+console.log("decode ok")'
+```
+
+The decode import resolves inside the Kennel checkout, or anywhere
+`@raggle-ai/tasks` is installed.
+
+## Verification
+
+- Server alive: `curl -fsS --connect-timeout 3 --max-time 5 "$URL/api/health"`
+- Folder root: request `/api/documents` and confirm `root` is the requested
+  absolute folder.
+- Tasks availability: the Tasks plugin tab is present and its badge equals the
+  number of tasks in the root `todo.json` plus any linked folders' task
+  files; an invalid file (local or linked) shows a warning marker instead of
+  a badge.
+- Invalid file: `/api/plugins/tasks?path=<folder>` returns `status: "error"`
+  with the `issues` array (`path` + `message` per problem) and the view shows
+  them; it never 404s or renders a broken/empty list for a file that exists.
+  Note that `status: "available"` does not prove the file renders — the
+  strict client-side decode can still fail (see the "Schema decode failures"
+  section); re-open the Tasks tab or decode `dataset` with
+  `decodeTodoDataset` from `@raggle-ai/tasks/todo-model` to be sure.
+- Counts: `summary.completed` equals the count of tasks with `done: true` or
+  `status: "done"`; `summary.open` equals the remainder. Task names and
+  statuses in the view match the source file.
+- Warnings: tasks with no `notes` entries (or dead folder-relative note
+  paths) produce an amber "Warnings (n)" button on the Tasks view; open it
+  for the full lines, and `/api/plugins/tasks?path=<folder>` returns the
+  same lines in its `warnings` array. Warnings never change `status`, the
+  badge, or the counts; a valid file with warnings is still valid.
+
+## Boundaries
+
+- This plugin is read-only: it detects and renders `todo.json`. Editing tasks
+  follows the repo's normal `todo.json` conventions (for example the 2do CLI
+  or direct file edits), not this plugin — except `kennel init`, which only
+  scaffolds a starter file when none exists (or with `--force`).
+- Do not invent tasks, statuses, counts, or validation fixes — read the file
+  and report exact issues.
+- The tasks view only exists inside the Kennel viewer (server + web app); the
+  `@raggle-ai/tasks` package is not a standalone CLI.

package/kernel/plugins/tasks/eslint.config.js

@@ -0,0 +1,10 @@
+import baseConfig from "@raggle-ai/eslint-config/base"
+import reactConfig from "@raggle-ai/eslint-config/react"
+
+export default [
+  ...baseConfig,
+  ...reactConfig,
+  {
+    ignores: ["dist/**", "**/_generated/", "vendor/**"],
+  },
+]

package/kernel/plugins/tasks/package.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@raggle-ai/tasks",
+  "version": "0.1.0",
+  "description": "Tasks folder plugin: valid todo.json detection and task dataset loading for Kennel folders.",
+  "type": "module",
+  "license": "MIT",
+  "prettier": "@raggle-ai/prettier-config",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raggle-ai/kennel.git",
+    "directory": "plugins/tasks"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./api": "./src/api.ts",
+    "./client": "./src/client.tsx",
+    "./manifest": "./src/manifest.ts",
+    "./parse": "./src/data/parse.ts",
+    "./server": "./src/server.ts",
+    "./todo-model": "./src/data/todo-model.ts",
+    "./todo-model/styles.css": "./src/styles.css"
+  },
+  "scripts": {
+    "test": "bun test test/*.test.mjs",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier . --check --cache --cache-location .cache/.prettiercache --ignore-path ../../.prettierignore",
+    "format:fix": "prettier . --write --cache --cache-location .cache/.prettiercache --ignore-path ../../.prettierignore",
+    "lint": "eslint . --cache --cache-location .cache/.eslintcache",
+    "lint:fix": "eslint . --fix --cache --cache-location .cache/.eslintcache",
+    "clean": "git clean -xdf dist node_modules .cache .turbo/cache",
+    "pack:check": "npm pack --dry-run",
+    "publish:public:dry-run": "npm --@raggle-ai:registry=https://registry.npmjs.org publish --dry-run --access public --registry=https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@raggle-ai/folder-plugin": "workspace:*",
+    "@raggle-ai/ui": "workspace:*",
+    "@tanstack/react-query": "catalog:tanstack",
+    "effect": "^3.19.7",
+    "lucide-react": "^0.562.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.3.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "catalog:eslint",
+    "@eslint/eslintrc": "catalog:eslint",
+    "@ianvs/prettier-plugin-sort-imports": "catalog:prettier",
+    "@prettier/plugin-oxc": "catalog:prettier",
+    "@raggle-ai/eslint-config": "workspace:*",
+    "@raggle-ai/prettier-config": "workspace:*",
+    "@raggle-ai/tsconfig": "workspace:*",
+    "@types/node": "catalog:",
+    "@types/react": "catalog:react19",
+    "@types/react-dom": "catalog:react19",
+    "eslint": "catalog:eslint",
+    "eslint-plugin-unused-imports": "catalog:eslint",
+    "prettier": "catalog:prettier",
+    "prettier-plugin-classnames": "catalog:prettier",
+    "prettier-plugin-merge": "catalog:prettier",
+    "prettier-plugin-tailwindcss": "catalog:prettier",
+    "react": "catalog:react19",
+    "react-dom": "catalog:react19",
+    "typescript": "catalog:",
+    "typescript-eslint": "catalog:eslint"
+  }
+}