@h-rig/task-io-plugin 0.0.0-e2e-live.20260630085347

package/README.md

@@ -0,0 +1 @@
+# @h-rig/task-io-plugin

package/dist/src/plugin.d.ts

@@ -0,0 +1,5 @@
+import { type RigPlugin } from "@rig/core/config";
+export declare const TASK_IO_PLUGIN_NAME = "@rig/task-io-plugin";
+export declare const taskIoPlugin: RigPlugin;
+export declare function createTaskIoPlugin(): RigPlugin;
+export default taskIoPlugin;

package/dist/src/plugin.js

@@ -0,0 +1,696 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/task-io-plugin/src/service.ts
+var exports_service = {};
+__export(exports_service, {
+  createTaskIoService: () => createTaskIoService
+});
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import {
+  REPO_CHANGE_SET,
+  TASK_ARTIFACTS,
+  TASK_STATE_STORE
+} from "@rig/contracts";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function taskText(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function taskUrl(record) {
+  const metadata = record;
+  return taskText(metadata.url) ?? taskText(metadata.html_url) ?? taskText(metadata.webUrl);
+}
+function taskBody(record) {
+  const metadata = record;
+  return taskText(metadata.body) ?? taskText(metadata.description);
+}
+function taskTitle(record) {
+  const metadata = record;
+  return taskText(metadata.title) ?? taskText(metadata.name) ?? record.id;
+}
+function taskStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function taskDependencies(record) {
+  const raw = record;
+  const dependencies = taskStringList(raw.dependencies);
+  if (dependencies.length > 0)
+    return dependencies;
+  const deps = taskStringList(raw.deps);
+  return deps.length > 0 ? deps : null;
+}
+function taskParentChildDeps(record) {
+  const raw = record;
+  const parentChildDeps = taskStringList(raw.parentChildDeps);
+  if (parentChildDeps.length > 0)
+    return parentChildDeps;
+  const parents = taskStringList(raw.parents);
+  return parents.length > 0 ? parents : null;
+}
+function readTaskStatus(task) {
+  return typeof task.status === "string" ? task.status.trim().toLowerCase() : "";
+}
+function currentLogin(env = process.env) {
+  for (const key of ["RIG_GITHUB_LOGIN", "GITHUB_ACTOR", "GH_USER", "USER", "USERNAME"]) {
+    const value = env[key]?.trim();
+    if (value)
+      return value;
+  }
+  return;
+}
+function resolveAssignee(value, env = process.env) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  const lowered = trimmed.toLowerCase();
+  if (lowered === "me" || lowered === "@me")
+    return currentLogin(env) ?? "@me";
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+function taskMatchesState(task, state) {
+  if (!state)
+    return true;
+  const closed = CLOSED_STATUSES[readTaskStatus(task)] === true;
+  return state === "closed" ? closed : !closed;
+}
+function taskMatchesSearch(task, search) {
+  const needle = search?.trim().toLowerCase();
+  if (!needle)
+    return true;
+  const record = task;
+  const title = typeof task.title === "string" ? task.title : "";
+  const body = typeof record.body === "string" ? record.body : "";
+  const description = typeof record.description === "string" ? record.description : "";
+  return `${task.id}
+${title}
+${body}
+${description}`.toLowerCase().includes(needle);
+}
+function collectAssigneeLogins(value) {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value.flatMap((entry) => collectAssigneeLogins(entry));
+  if (isRecord(value))
+    return [value.login, value.username, value.name, value.id].flatMap((entry) => collectAssigneeLogins(entry));
+  return [];
+}
+function taskAssignees(task) {
+  const record = task;
+  const raw = isRecord(record.raw) ? record.raw : null;
+  return [
+    record.assignee,
+    record.assignees,
+    record.assignedTo,
+    record.owner,
+    raw?.assignee,
+    raw?.assignees,
+    raw?.assignedTo,
+    raw?.owner
+  ].flatMap((value) => collectAssigneeLogins(value));
+}
+function taskMatchesAssignee(task, assignee) {
+  if (!assignee)
+    return true;
+  const needle = assignee.startsWith("@") ? assignee.slice(1) : assignee;
+  return taskAssignees(task).some((login) => {
+    const normalized = login.startsWith("@") ? login.slice(1) : login;
+    return normalized.localeCompare(needle, undefined, { sensitivity: "accent" }) === 0;
+  });
+}
+function applyTaskIoFilters(tasks, filters = {}) {
+  const filtered = tasks.filter((task) => taskMatchesAssignee(task, resolveAssignee(filters.assignee))).filter((task) => taskMatchesState(task, filters.state)).filter((task) => taskMatchesSearch(task, filters.search));
+  return filters.limit === undefined ? filtered : filtered.slice(0, filters.limit);
+}
+function taskCreateInput(task) {
+  const deps = Array.isArray(task.dependencies) ? task.dependencies.filter((entry) => typeof entry === "string") : Array.isArray(task.deps) ? task.deps.filter((entry) => typeof entry === "string") : [];
+  const parents = Array.isArray(task.parents) ? task.parents.filter((entry) => typeof entry === "string") : [];
+  return {
+    title: taskText(task.title) ?? taskText(task.name) ?? "Untitled task",
+    body: taskText(task.body) ?? taskText(task.description) ?? "",
+    ...deps.length > 0 ? { deps } : {},
+    ...parents.length > 0 ? { parents } : {},
+    metadata: { ...task }
+  };
+}
+function toRigTask(record, sourceKind) {
+  const dependencies = taskDependencies(record);
+  const parentChildDeps = taskParentChildDeps(record);
+  return {
+    ...record,
+    id: record.id,
+    title: taskTitle(record),
+    status: typeof record.status === "string" ? record.status : null,
+    source: sourceKind,
+    url: taskUrl(record),
+    body: taskBody(record),
+    ...dependencies ? { dependencies } : {},
+    ...parentChildDeps ? { parentChildDeps } : {}
+  };
+}
+async function loadTaskSource(projectRoot) {
+  const { config, host: pluginHost } = await resolvePluginHost(projectRoot);
+  const factory = pluginHost.resolveTaskSourceFactoryByKind(config.taskSource.kind);
+  if (!factory) {
+    const kinds = pluginHost.listExecutableTaskSources().map((entry) => entry.kind).join(", ") || "none";
+    throw new Error(`No task source factory registered for kind ${config.taskSource.kind}. Registered task sources: ${kinds}.`);
+  }
+  return { kind: config.taskSource.kind, source: factory.factory(config.taskSource, { projectRoot }) };
+}
+function getTaskCreator(source) {
+  const record = source;
+  if (typeof record.createTask === "function")
+    return record.createTask.bind(source);
+  if (typeof record.create === "function")
+    return (task) => record.create?.(taskCreateInput(task));
+  return null;
+}
+async function loadTaskArtifacts(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, TaskArtifactsCap, "No task artifacts capability provides task artifact writes for this project root.");
+}
+async function loadTaskStateStore(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, TaskStateStoreCap, "No task state store capability provides task fact writes for this project root.");
+}
+async function loadRepoChangeSet(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RepoChangeSetCap, "No repo change-set capability provides task artifact change manifests for this project root.");
+}
+async function repoChangeSetPaths(result) {
+  const entries = await Promise.resolve(result);
+  return Array.from(new Set(entries.map((entry) => entry.path).filter(Boolean)));
+}
+async function resolveActiveTaskId(projectRoot, taskId) {
+  const stateStore = await loadTaskStateStore(projectRoot);
+  const activeTask = taskId ?? stateStore.readCurrentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  return activeTask;
+}
+function createTaskIoService() {
+  return {
+    async listTasks(projectRoot, filters) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      return applyTaskIoFilters((await source.list()).map((task) => toRigTask(task, kind)), filters);
+    },
+    async getTask(projectRoot, taskId) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      const task = source.get ? await source.get(taskId) ?? null : (await source.list()).find((entry) => entry.id === taskId) ?? null;
+      return task ? toRigTask(task, kind) : null;
+    },
+    async createTask(projectRoot, task) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      const creator = getTaskCreator(source);
+      if (!creator)
+        throw new Error(`The configured ${kind} task source does not expose a task creation API.`);
+      const result = await creator(task);
+      const taskId = typeof result === "string" ? result : isRecord(result) && typeof result.id === "string" ? result.id : null;
+      return { taskId, source: kind, result };
+    },
+    async recordTaskFact(projectRoot, input) {
+      const taskId = await resolveActiveTaskId(projectRoot, input.taskId);
+      if (input.type === "decision") {
+        const result2 = await (await loadTaskArtifacts(projectRoot)).appendDecision({ projectRoot, taskId, text: input.text });
+        return { taskId: result2.taskId, message: result2.message };
+      }
+      const result = (await loadTaskStateStore(projectRoot)).recordFailedApproach({ projectRoot, taskId, text: input.text });
+      return { taskId: result.taskId, message: result.message };
+    },
+    async prepareTaskArtifacts(projectRoot, taskId) {
+      const activeTask = await resolveActiveTaskId(projectRoot, taskId);
+      const repoChangeSet = await loadRepoChangeSet(projectRoot);
+      const changedFiles = await repoChangeSetPaths(repoChangeSet.changedFiles({ projectRoot, selector: { kind: "task", taskId: activeTask, scoped: true } }));
+      return (await loadTaskArtifacts(projectRoot)).prepareCompletionArtifacts({ projectRoot, taskId: activeTask, changedFiles });
+    }
+  };
+}
+var CLOSED_STATUSES, RepoChangeSetCap, TaskArtifactsCap, TaskStateStoreCap;
+var init_service = __esm(() => {
+  CLOSED_STATUSES = {
+    closed: true,
+    completed: true,
+    complete: true,
+    done: true,
+    cancelled: true,
+    canceled: true,
+    merged: true,
+    resolved: true
+  };
+  RepoChangeSetCap = defineCapability(REPO_CHANGE_SET);
+  TaskArtifactsCap = defineCapability(TASK_ARTIFACTS);
+  TaskStateStoreCap = defineCapability(TASK_STATE_STORE);
+});
+
+// packages/task-io-plugin/src/task-projection.ts
+var exports_task_projection = {};
+__export(exports_task_projection, {
+  createTaskProjectionCapability: () => createTaskProjectionCapability
+});
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function taskId(task) {
+  const id = task?.id.trim();
+  return id && id.length > 0 ? id : null;
+}
+function taskTitle2(task) {
+  const title = task?.title?.trim();
+  return title && title.length > 0 ? title : taskId(task) ?? "Untitled task";
+}
+function taskStatus(task) {
+  const status = task?.status?.trim();
+  return status && status.length > 0 ? status : "unknown";
+}
+function taskDescription(task) {
+  return [task.source, task.url, task.body].flatMap((part) => {
+    const text = part?.trim();
+    return text ? [text] : [];
+  }).join(" \xB7 ");
+}
+function normalizeTaskStatus(value) {
+  const normalized = value?.trim().replace(/\s+/g, "_").replace(/-/g, "_");
+  return normalized && TASK_STATUSES.has(normalized) ? normalized : "unknown";
+}
+function normalizeTaskPriority(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function taskBadgeProjection(task) {
+  const metadata = isRecord2(task.metadata) ? task.metadata : {};
+  return {
+    id: task.id,
+    title: taskTitle2(task),
+    status: normalizeTaskStatus(task.status),
+    priority: normalizeTaskPriority(task.priority ?? (typeof metadata.priority === "number" || typeof metadata.priority === "string" ? metadata.priority : null)),
+    metadata,
+    source: task.source,
+    url: task.url,
+    body: task.body,
+    assignedTo: task.assignedTo,
+    assignees: task.assignees,
+    dependencies: [...stringList(task.dependencies), ...stringList(metadata.dependencies)],
+    parentChildDeps: [...stringList(task.parentChildDeps), ...stringList(metadata.parentChildDeps)]
+  };
+}
+function taskAssigneeText(task) {
+  const assignees = [
+    ...stringList(task.assignees),
+    ...typeof task.assignedTo === "string" ? [task.assignedTo] : stringList(task.assignedTo),
+    ...stringList(task.metadata?.assignees),
+    ...stringList(task.metadata?.assignedTo)
+  ];
+  return assignees.length > 0 ? `assigned ${assignees.join(",")}` : "unassigned";
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = stringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isRecord2(task.metadata) ? task.metadata : null;
+  const metadataList = stringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  return key === "dependencies" ? stringList(metadata?.deps) : [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0)
+    return task.sourceIssueId;
+  const metadata = isRecord2(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0)
+    return metadata.sourceIssueId;
+  const rigMetadata = isRecord2(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskIdValue, stack) => {
+    const cached = memo.get(taskIdValue);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskIdValue))
+      return 0;
+    const task = tasksById.get(taskIdValue);
+    if (!task)
+      return 0;
+    stack.add(taskIdValue);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskIdValue);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskIdValue);
+    memo.set(taskIdValue, depth);
+    return depth;
+  };
+  for (const task of tasks)
+    visit(task.id, new Set);
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (!status)
+    return false;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks)
+          blocks.push(task.id);
+        else
+          blocksByTask.set(dependencyId, [task.id]);
+      } else if (ref !== task.id) {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({ kind: "ready", label: "ready", description: "No open dependencies block this task." });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `depends on ${dependencyIds.join(", ")}` : null,
+          blocks.length > 0 ? `blocks ${blocks.join(", ")}` : null,
+          unresolvedDependencyRefs.length > 0 ? `unresolved ${unresolvedDependencyRefs.join(", ")}` : null
+        ].filter(Boolean).join(" \xB7 "),
+        count: dependencyIds.length + blocks.length + unresolvedDependencyRefs.length,
+        taskIds: [...dependencyIds, ...blocks]
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+function projectTaskStatusForGrouping(status) {
+  switch (status) {
+    case "failed":
+      return "ready";
+    case "closed":
+      return "completed";
+    case "running":
+    case "in_progress":
+      return "running";
+    case "blocked":
+      return "blocked";
+    case "completed":
+    case "cancelled":
+    case "draft":
+    case "queued":
+    case "ready":
+    case "open":
+      return status;
+    default:
+      return "unknown";
+  }
+}
+function groupTasksByProjectedStatus(tasks) {
+  const byStatus = new Map;
+  for (const task of tasks) {
+    const projectedStatus = projectTaskStatusForGrouping(task.status);
+    const group = byStatus.get(projectedStatus);
+    if (group)
+      group.push(task);
+    else
+      byStatus.set(projectedStatus, [task]);
+  }
+  const result = [];
+  for (const status of TASK_GROUP_STATUS_PRIORITY) {
+    const group = byStatus.get(status);
+    if (group && group.length > 0)
+      result.push({ status, tasks: group });
+  }
+  const overflowStatuses = Array.from(byStatus.keys()).filter((status) => !TASK_GROUP_STATUS_PRIORITY.includes(status)).sort();
+  for (const status of overflowStatuses) {
+    const group = byStatus.get(status);
+    if (group && group.length > 0)
+      result.push({ status, tasks: group });
+  }
+  return result;
+}
+function assigneeLoginsFromValue(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [entry.trim().replace(/^@/, "").toLowerCase()];
+    if (isRecord2(entry) && typeof entry.login === "string" && entry.login.trim())
+      return [entry.login.trim().replace(/^@/, "").toLowerCase()];
+    return [];
+  });
+}
+function normalizeTaskAssigneeFilter(assignee, currentUserLogin) {
+  const trimmed = assignee?.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "@me" || trimmed.toLowerCase() === "me")
+    return currentUserLogin?.trim() ? currentUserLogin.trim().replace(/^@/, "").toLowerCase() : null;
+  return trimmed.replace(/^@/, "").toLowerCase();
+}
+function readTaskAssigneeLogins(task) {
+  const taskRecord = task;
+  const metadata = isRecord2(task.metadata) ? task.metadata : null;
+  const raw = isRecord2(metadata?.raw) ? metadata.raw : null;
+  return Array.from(new Set([
+    ...assigneeLoginsFromValue(taskRecord.assignees),
+    ...assigneeLoginsFromValue(metadata?.assignees),
+    ...assigneeLoginsFromValue(raw?.assignees)
+  ]));
+}
+function taskMatchesAssigneeFilter(task, assignee, options = {}) {
+  const normalized = normalizeTaskAssigneeFilter(assignee, options.currentUserLogin);
+  if (!normalized)
+    return false;
+  return readTaskAssigneeLogins(task).includes(normalized);
+}
+function selectTasksAssignedToMe(tasks, currentUserLogin) {
+  return tasks.filter((task) => taskMatchesAssigneeFilter(task, "@me", currentUserLogin === undefined ? {} : { currentUserLogin }));
+}
+function listRows(input) {
+  const tasks = input.tasks;
+  if (!tasks)
+    return [];
+  const projected = tasks.map((task) => taskBadgeProjection(task));
+  const visible = input.assignedToMe ? selectTasksAssignedToMe(projected, input.currentUserLogin ?? null) : projected;
+  const sourceById = new Map(tasks.map((task) => [task.id, task]));
+  const badgesByTaskId = computeTaskDependencyBadges(visible);
+  const groups = groupTasksByProjectedStatus(visible);
+  const ordered = groups.flatMap((group) => group.tasks).slice(0, input.limit ?? 20);
+  return ordered.flatMap((task) => {
+    const sourceTask = sourceById.get(task.id);
+    if (!sourceTask)
+      return [];
+    const summary = badgesByTaskId.get(task.id);
+    const badge = summary?.badges.find((entry) => entry.kind === "blocked" || entry.kind === "ready")?.label ?? taskStatus(sourceTask);
+    return [{
+      id: task.id,
+      label: taskTitle2(sourceTask),
+      currentValue: badge,
+      description: [input.nextReadyTaskId === task.id ? "next-ready" : null, taskAssigneeText(sourceTask), summary?.badges.map((entry) => entry.description).join("; "), taskDescription(sourceTask) || task.id].filter(Boolean).join(" \xB7 ")
+    }];
+  });
+}
+function boardTasks(input) {
+  const sourceById = new Map((input.tasks ?? []).map((task) => [task.id, task]));
+  return listRows(input).flatMap((row) => {
+    const sourceTask = sourceById.get(row.id);
+    if (!sourceTask)
+      return [];
+    return [{
+      id: row.id,
+      status: taskStatus(sourceTask),
+      title: row.label,
+      ...row.currentValue ? { badge: row.currentValue } : {},
+      ...row.description ? { description: row.description } : {}
+    }];
+  });
+}
+function stats(tasks) {
+  if (!tasks)
+    return null;
+  return {
+    total: tasks.length,
+    ready: tasks.filter((task) => taskStatus(task) === "ready").length,
+    running: tasks.filter((task) => taskStatus(task) === "running").length
+  };
+}
+function createTaskProjectionCapability() {
+  return {
+    normalizeStatus: normalizeTaskStatus,
+    normalizePriority: normalizeTaskPriority,
+    project: taskBadgeProjection,
+    assigneeText: taskAssigneeText,
+    title: taskTitle2,
+    id: taskId,
+    status: taskStatus,
+    description: taskDescription,
+    listRows,
+    boardTasks,
+    stats
+  };
+}
+var TASK_STATUSES, TASK_GROUP_STATUS_PRIORITY;
+var init_task_projection = __esm(() => {
+  TASK_STATUSES = new Set([
+    "draft",
+    "open",
+    "ready",
+    "queued",
+    "running",
+    "in_progress",
+    "under_review",
+    "blocked",
+    "unknown",
+    "completed",
+    "failed",
+    "cancelled",
+    "closed"
+  ]);
+  TASK_GROUP_STATUS_PRIORITY = ["running", "blocked", "queued", "ready", "open", "draft", "unknown", "cancelled", "completed"];
+});
+
+// packages/task-io-plugin/src/plugin.ts
+import { defineCapability as defineCapability2, defineServiceCapability } from "@rig/core/capability";
+import { definePlugin } from "@rig/core/config";
+import { TASK_IO_SERVICE_CAPABILITY, TASK_PROJECTION_CAPABILITY_ID } from "@rig/contracts";
+var TASK_IO_PLUGIN_NAME = "@rig/task-io-plugin";
+var TaskIoCap = defineCapability2(TASK_IO_SERVICE_CAPABILITY);
+var TaskProjectionCap = defineServiceCapability(TASK_PROJECTION_CAPABILITY_ID);
+var taskIoPlugin = definePlugin({
+  name: TASK_IO_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  contributes: {
+    capabilities: [
+      TaskIoCap.provide(async () => (await Promise.resolve().then(() => (init_service(), exports_service))).createTaskIoService(), {
+        title: "Task IO",
+        description: "Normalized task-source list/get/create operations for CLI and cockpit consumers. Target owner for the legacy TASK_DATA compatibility facade once provider factories receive host/resolver context."
+      }),
+      TaskProjectionCap.provideService(async () => (await Promise.resolve().then(() => (init_task_projection(), exports_task_projection))).createTaskProjectionCapability(), {
+        title: "Task projection",
+        description: "Task-owned title/status/priority/assignee projection for cockpit and CLI surfaces."
+      })
+    ]
+  }
+});
+function createTaskIoPlugin() {
+  return taskIoPlugin;
+}
+var plugin_default = taskIoPlugin;
+export {
+  taskIoPlugin,
+  plugin_default as default,
+  createTaskIoPlugin,
+  TASK_IO_PLUGIN_NAME
+};

package/dist/src/service.d.ts

@@ -0,0 +1,6 @@
+import { type RegisteredTaskSource, type TaskIoService } from "@rig/contracts";
+export type TaskSourceHandle = {
+    readonly kind: string;
+    readonly source: RegisteredTaskSource;
+};
+export declare function createTaskIoService(): TaskIoService;

package/dist/src/service.js

@@ -0,0 +1,238 @@
+// @bun
+// packages/task-io-plugin/src/service.ts
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import {
+  REPO_CHANGE_SET,
+  TASK_ARTIFACTS,
+  TASK_STATE_STORE
+} from "@rig/contracts";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function taskText(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function taskUrl(record) {
+  const metadata = record;
+  return taskText(metadata.url) ?? taskText(metadata.html_url) ?? taskText(metadata.webUrl);
+}
+function taskBody(record) {
+  const metadata = record;
+  return taskText(metadata.body) ?? taskText(metadata.description);
+}
+function taskTitle(record) {
+  const metadata = record;
+  return taskText(metadata.title) ?? taskText(metadata.name) ?? record.id;
+}
+function taskStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function taskDependencies(record) {
+  const raw = record;
+  const dependencies = taskStringList(raw.dependencies);
+  if (dependencies.length > 0)
+    return dependencies;
+  const deps = taskStringList(raw.deps);
+  return deps.length > 0 ? deps : null;
+}
+function taskParentChildDeps(record) {
+  const raw = record;
+  const parentChildDeps = taskStringList(raw.parentChildDeps);
+  if (parentChildDeps.length > 0)
+    return parentChildDeps;
+  const parents = taskStringList(raw.parents);
+  return parents.length > 0 ? parents : null;
+}
+var CLOSED_STATUSES = {
+  closed: true,
+  completed: true,
+  complete: true,
+  done: true,
+  cancelled: true,
+  canceled: true,
+  merged: true,
+  resolved: true
+};
+function readTaskStatus(task) {
+  return typeof task.status === "string" ? task.status.trim().toLowerCase() : "";
+}
+function currentLogin(env = process.env) {
+  for (const key of ["RIG_GITHUB_LOGIN", "GITHUB_ACTOR", "GH_USER", "USER", "USERNAME"]) {
+    const value = env[key]?.trim();
+    if (value)
+      return value;
+  }
+  return;
+}
+function resolveAssignee(value, env = process.env) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  const lowered = trimmed.toLowerCase();
+  if (lowered === "me" || lowered === "@me")
+    return currentLogin(env) ?? "@me";
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+function taskMatchesState(task, state) {
+  if (!state)
+    return true;
+  const closed = CLOSED_STATUSES[readTaskStatus(task)] === true;
+  return state === "closed" ? closed : !closed;
+}
+function taskMatchesSearch(task, search) {
+  const needle = search?.trim().toLowerCase();
+  if (!needle)
+    return true;
+  const record = task;
+  const title = typeof task.title === "string" ? task.title : "";
+  const body = typeof record.body === "string" ? record.body : "";
+  const description = typeof record.description === "string" ? record.description : "";
+  return `${task.id}
+${title}
+${body}
+${description}`.toLowerCase().includes(needle);
+}
+function collectAssigneeLogins(value) {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value.flatMap((entry) => collectAssigneeLogins(entry));
+  if (isRecord(value))
+    return [value.login, value.username, value.name, value.id].flatMap((entry) => collectAssigneeLogins(entry));
+  return [];
+}
+function taskAssignees(task) {
+  const record = task;
+  const raw = isRecord(record.raw) ? record.raw : null;
+  return [
+    record.assignee,
+    record.assignees,
+    record.assignedTo,
+    record.owner,
+    raw?.assignee,
+    raw?.assignees,
+    raw?.assignedTo,
+    raw?.owner
+  ].flatMap((value) => collectAssigneeLogins(value));
+}
+function taskMatchesAssignee(task, assignee) {
+  if (!assignee)
+    return true;
+  const needle = assignee.startsWith("@") ? assignee.slice(1) : assignee;
+  return taskAssignees(task).some((login) => {
+    const normalized = login.startsWith("@") ? login.slice(1) : login;
+    return normalized.localeCompare(needle, undefined, { sensitivity: "accent" }) === 0;
+  });
+}
+function applyTaskIoFilters(tasks, filters = {}) {
+  const filtered = tasks.filter((task) => taskMatchesAssignee(task, resolveAssignee(filters.assignee))).filter((task) => taskMatchesState(task, filters.state)).filter((task) => taskMatchesSearch(task, filters.search));
+  return filters.limit === undefined ? filtered : filtered.slice(0, filters.limit);
+}
+function taskCreateInput(task) {
+  const deps = Array.isArray(task.dependencies) ? task.dependencies.filter((entry) => typeof entry === "string") : Array.isArray(task.deps) ? task.deps.filter((entry) => typeof entry === "string") : [];
+  const parents = Array.isArray(task.parents) ? task.parents.filter((entry) => typeof entry === "string") : [];
+  return {
+    title: taskText(task.title) ?? taskText(task.name) ?? "Untitled task",
+    body: taskText(task.body) ?? taskText(task.description) ?? "",
+    ...deps.length > 0 ? { deps } : {},
+    ...parents.length > 0 ? { parents } : {},
+    metadata: { ...task }
+  };
+}
+function toRigTask(record, sourceKind) {
+  const dependencies = taskDependencies(record);
+  const parentChildDeps = taskParentChildDeps(record);
+  return {
+    ...record,
+    id: record.id,
+    title: taskTitle(record),
+    status: typeof record.status === "string" ? record.status : null,
+    source: sourceKind,
+    url: taskUrl(record),
+    body: taskBody(record),
+    ...dependencies ? { dependencies } : {},
+    ...parentChildDeps ? { parentChildDeps } : {}
+  };
+}
+async function loadTaskSource(projectRoot) {
+  const { config, host: pluginHost } = await resolvePluginHost(projectRoot);
+  const factory = pluginHost.resolveTaskSourceFactoryByKind(config.taskSource.kind);
+  if (!factory) {
+    const kinds = pluginHost.listExecutableTaskSources().map((entry) => entry.kind).join(", ") || "none";
+    throw new Error(`No task source factory registered for kind ${config.taskSource.kind}. Registered task sources: ${kinds}.`);
+  }
+  return { kind: config.taskSource.kind, source: factory.factory(config.taskSource, { projectRoot }) };
+}
+function getTaskCreator(source) {
+  const record = source;
+  if (typeof record.createTask === "function")
+    return record.createTask.bind(source);
+  if (typeof record.create === "function")
+    return (task) => record.create?.(taskCreateInput(task));
+  return null;
+}
+var RepoChangeSetCap = defineCapability(REPO_CHANGE_SET);
+var TaskArtifactsCap = defineCapability(TASK_ARTIFACTS);
+var TaskStateStoreCap = defineCapability(TASK_STATE_STORE);
+async function loadTaskArtifacts(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, TaskArtifactsCap, "No task artifacts capability provides task artifact writes for this project root.");
+}
+async function loadTaskStateStore(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, TaskStateStoreCap, "No task state store capability provides task fact writes for this project root.");
+}
+async function loadRepoChangeSet(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RepoChangeSetCap, "No repo change-set capability provides task artifact change manifests for this project root.");
+}
+async function repoChangeSetPaths(result) {
+  const entries = await Promise.resolve(result);
+  return Array.from(new Set(entries.map((entry) => entry.path).filter(Boolean)));
+}
+async function resolveActiveTaskId(projectRoot, taskId) {
+  const stateStore = await loadTaskStateStore(projectRoot);
+  const activeTask = taskId ?? stateStore.readCurrentTaskId(projectRoot);
+  if (!activeTask)
+    throw new Error("No active task.");
+  return activeTask;
+}
+function createTaskIoService() {
+  return {
+    async listTasks(projectRoot, filters) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      return applyTaskIoFilters((await source.list()).map((task) => toRigTask(task, kind)), filters);
+    },
+    async getTask(projectRoot, taskId) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      const task = source.get ? await source.get(taskId) ?? null : (await source.list()).find((entry) => entry.id === taskId) ?? null;
+      return task ? toRigTask(task, kind) : null;
+    },
+    async createTask(projectRoot, task) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      const creator = getTaskCreator(source);
+      if (!creator)
+        throw new Error(`The configured ${kind} task source does not expose a task creation API.`);
+      const result = await creator(task);
+      const taskId = typeof result === "string" ? result : isRecord(result) && typeof result.id === "string" ? result.id : null;
+      return { taskId, source: kind, result };
+    },
+    async recordTaskFact(projectRoot, input) {
+      const taskId = await resolveActiveTaskId(projectRoot, input.taskId);
+      if (input.type === "decision") {
+        const result2 = await (await loadTaskArtifacts(projectRoot)).appendDecision({ projectRoot, taskId, text: input.text });
+        return { taskId: result2.taskId, message: result2.message };
+      }
+      const result = (await loadTaskStateStore(projectRoot)).recordFailedApproach({ projectRoot, taskId, text: input.text });
+      return { taskId: result.taskId, message: result.message };
+    },
+    async prepareTaskArtifacts(projectRoot, taskId) {
+      const activeTask = await resolveActiveTaskId(projectRoot, taskId);
+      const repoChangeSet = await loadRepoChangeSet(projectRoot);
+      const changedFiles = await repoChangeSetPaths(repoChangeSet.changedFiles({ projectRoot, selector: { kind: "task", taskId: activeTask, scoped: true } }));
+      return (await loadTaskArtifacts(projectRoot)).prepareCompletionArtifacts({ projectRoot, taskId: activeTask, changedFiles });
+    }
+  };
+}
+export {
+  createTaskIoService
+};

package/dist/src/task-projection.d.ts

@@ -0,0 +1,2 @@
+import type { TaskProjectionCapability } from "@rig/contracts";
+export declare function createTaskProjectionCapability(): TaskProjectionCapability;

package/dist/src/task-projection.js

@@ -0,0 +1,400 @@
+// @bun
+// packages/task-io-plugin/src/task-projection.ts
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function taskId(task) {
+  const id = task?.id.trim();
+  return id && id.length > 0 ? id : null;
+}
+function taskTitle(task) {
+  const title = task?.title?.trim();
+  return title && title.length > 0 ? title : taskId(task) ?? "Untitled task";
+}
+function taskStatus(task) {
+  const status = task?.status?.trim();
+  return status && status.length > 0 ? status : "unknown";
+}
+function taskDescription(task) {
+  return [task.source, task.url, task.body].flatMap((part) => {
+    const text = part?.trim();
+    return text ? [text] : [];
+  }).join(" \xB7 ");
+}
+var TASK_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+function normalizeTaskStatus(value) {
+  const normalized = value?.trim().replace(/\s+/g, "_").replace(/-/g, "_");
+  return normalized && TASK_STATUSES.has(normalized) ? normalized : "unknown";
+}
+function normalizeTaskPriority(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function taskBadgeProjection(task) {
+  const metadata = isRecord(task.metadata) ? task.metadata : {};
+  return {
+    id: task.id,
+    title: taskTitle(task),
+    status: normalizeTaskStatus(task.status),
+    priority: normalizeTaskPriority(task.priority ?? (typeof metadata.priority === "number" || typeof metadata.priority === "string" ? metadata.priority : null)),
+    metadata,
+    source: task.source,
+    url: task.url,
+    body: task.body,
+    assignedTo: task.assignedTo,
+    assignees: task.assignees,
+    dependencies: [...stringList(task.dependencies), ...stringList(metadata.dependencies)],
+    parentChildDeps: [...stringList(task.parentChildDeps), ...stringList(metadata.parentChildDeps)]
+  };
+}
+function taskAssigneeText(task) {
+  const assignees = [
+    ...stringList(task.assignees),
+    ...typeof task.assignedTo === "string" ? [task.assignedTo] : stringList(task.assignedTo),
+    ...stringList(task.metadata?.assignees),
+    ...stringList(task.metadata?.assignedTo)
+  ];
+  return assignees.length > 0 ? `assigned ${assignees.join(",")}` : "unassigned";
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = stringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isRecord(task.metadata) ? task.metadata : null;
+  const metadataList = stringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  return key === "dependencies" ? stringList(metadata?.deps) : [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0)
+    return task.sourceIssueId;
+  const metadata = isRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0)
+    return metadata.sourceIssueId;
+  const rigMetadata = isRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskIdValue, stack) => {
+    const cached = memo.get(taskIdValue);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskIdValue))
+      return 0;
+    const task = tasksById.get(taskIdValue);
+    if (!task)
+      return 0;
+    stack.add(taskIdValue);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskIdValue);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskIdValue);
+    memo.set(taskIdValue, depth);
+    return depth;
+  };
+  for (const task of tasks)
+    visit(task.id, new Set);
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (!status)
+    return false;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks)
+          blocks.push(task.id);
+        else
+          blocksByTask.set(dependencyId, [task.id]);
+      } else if (ref !== task.id) {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({ kind: "ready", label: "ready", description: "No open dependencies block this task." });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `depends on ${dependencyIds.join(", ")}` : null,
+          blocks.length > 0 ? `blocks ${blocks.join(", ")}` : null,
+          unresolvedDependencyRefs.length > 0 ? `unresolved ${unresolvedDependencyRefs.join(", ")}` : null
+        ].filter(Boolean).join(" \xB7 "),
+        count: dependencyIds.length + blocks.length + unresolvedDependencyRefs.length,
+        taskIds: [...dependencyIds, ...blocks]
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+function projectTaskStatusForGrouping(status) {
+  switch (status) {
+    case "failed":
+      return "ready";
+    case "closed":
+      return "completed";
+    case "running":
+    case "in_progress":
+      return "running";
+    case "blocked":
+      return "blocked";
+    case "completed":
+    case "cancelled":
+    case "draft":
+    case "queued":
+    case "ready":
+    case "open":
+      return status;
+    default:
+      return "unknown";
+  }
+}
+var TASK_GROUP_STATUS_PRIORITY = ["running", "blocked", "queued", "ready", "open", "draft", "unknown", "cancelled", "completed"];
+function groupTasksByProjectedStatus(tasks) {
+  const byStatus = new Map;
+  for (const task of tasks) {
+    const projectedStatus = projectTaskStatusForGrouping(task.status);
+    const group = byStatus.get(projectedStatus);
+    if (group)
+      group.push(task);
+    else
+      byStatus.set(projectedStatus, [task]);
+  }
+  const result = [];
+  for (const status of TASK_GROUP_STATUS_PRIORITY) {
+    const group = byStatus.get(status);
+    if (group && group.length > 0)
+      result.push({ status, tasks: group });
+  }
+  const overflowStatuses = Array.from(byStatus.keys()).filter((status) => !TASK_GROUP_STATUS_PRIORITY.includes(status)).sort();
+  for (const status of overflowStatuses) {
+    const group = byStatus.get(status);
+    if (group && group.length > 0)
+      result.push({ status, tasks: group });
+  }
+  return result;
+}
+function assigneeLoginsFromValue(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [entry.trim().replace(/^@/, "").toLowerCase()];
+    if (isRecord(entry) && typeof entry.login === "string" && entry.login.trim())
+      return [entry.login.trim().replace(/^@/, "").toLowerCase()];
+    return [];
+  });
+}
+function normalizeTaskAssigneeFilter(assignee, currentUserLogin) {
+  const trimmed = assignee?.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "@me" || trimmed.toLowerCase() === "me")
+    return currentUserLogin?.trim() ? currentUserLogin.trim().replace(/^@/, "").toLowerCase() : null;
+  return trimmed.replace(/^@/, "").toLowerCase();
+}
+function readTaskAssigneeLogins(task) {
+  const taskRecord = task;
+  const metadata = isRecord(task.metadata) ? task.metadata : null;
+  const raw = isRecord(metadata?.raw) ? metadata.raw : null;
+  return Array.from(new Set([
+    ...assigneeLoginsFromValue(taskRecord.assignees),
+    ...assigneeLoginsFromValue(metadata?.assignees),
+    ...assigneeLoginsFromValue(raw?.assignees)
+  ]));
+}
+function taskMatchesAssigneeFilter(task, assignee, options = {}) {
+  const normalized = normalizeTaskAssigneeFilter(assignee, options.currentUserLogin);
+  if (!normalized)
+    return false;
+  return readTaskAssigneeLogins(task).includes(normalized);
+}
+function selectTasksAssignedToMe(tasks, currentUserLogin) {
+  return tasks.filter((task) => taskMatchesAssigneeFilter(task, "@me", currentUserLogin === undefined ? {} : { currentUserLogin }));
+}
+function listRows(input) {
+  const tasks = input.tasks;
+  if (!tasks)
+    return [];
+  const projected = tasks.map((task) => taskBadgeProjection(task));
+  const visible = input.assignedToMe ? selectTasksAssignedToMe(projected, input.currentUserLogin ?? null) : projected;
+  const sourceById = new Map(tasks.map((task) => [task.id, task]));
+  const badgesByTaskId = computeTaskDependencyBadges(visible);
+  const groups = groupTasksByProjectedStatus(visible);
+  const ordered = groups.flatMap((group) => group.tasks).slice(0, input.limit ?? 20);
+  return ordered.flatMap((task) => {
+    const sourceTask = sourceById.get(task.id);
+    if (!sourceTask)
+      return [];
+    const summary = badgesByTaskId.get(task.id);
+    const badge = summary?.badges.find((entry) => entry.kind === "blocked" || entry.kind === "ready")?.label ?? taskStatus(sourceTask);
+    return [{
+      id: task.id,
+      label: taskTitle(sourceTask),
+      currentValue: badge,
+      description: [input.nextReadyTaskId === task.id ? "next-ready" : null, taskAssigneeText(sourceTask), summary?.badges.map((entry) => entry.description).join("; "), taskDescription(sourceTask) || task.id].filter(Boolean).join(" \xB7 ")
+    }];
+  });
+}
+function boardTasks(input) {
+  const sourceById = new Map((input.tasks ?? []).map((task) => [task.id, task]));
+  return listRows(input).flatMap((row) => {
+    const sourceTask = sourceById.get(row.id);
+    if (!sourceTask)
+      return [];
+    return [{
+      id: row.id,
+      status: taskStatus(sourceTask),
+      title: row.label,
+      ...row.currentValue ? { badge: row.currentValue } : {},
+      ...row.description ? { description: row.description } : {}
+    }];
+  });
+}
+function stats(tasks) {
+  if (!tasks)
+    return null;
+  return {
+    total: tasks.length,
+    ready: tasks.filter((task) => taskStatus(task) === "ready").length,
+    running: tasks.filter((task) => taskStatus(task) === "running").length
+  };
+}
+function createTaskProjectionCapability() {
+  return {
+    normalizeStatus: normalizeTaskStatus,
+    normalizePriority: normalizeTaskPriority,
+    project: taskBadgeProjection,
+    assigneeText: taskAssigneeText,
+    title: taskTitle,
+    id: taskId,
+    status: taskStatus,
+    description: taskDescription,
+    listRows,
+    boardTasks,
+    stats
+  };
+}
+export {
+  createTaskProjectionCapability
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@h-rig/task-io-plugin",
+  "version": "0.0.0-e2e-live.20260630085347",
+  "type": "module",
+  "description": "Rig package",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    },
+    "./plugin": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.0-e2e-live.20260630085347",
+    "@rig/core": "npm:@h-rig/core@0.0.0-e2e-live.20260630085347"
+  }
+}