@h-rig/contracts 0.0.6-alpha.157 → 0.0.6-alpha.159

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

@@ -0,0 +1,239 @@
+/**
+ * The TASK-DATA capability seam.
+ *
+ * Floor-neutral vocab + a single `CapabilityId<TaskDataService>` describing the
+ * task-DATA reads and task-command behaviours the lifecycle, scheduler,
+ * isolation provisioning, repos, workspace, and CLI surfaces consume. The
+ * READ/normalize/validate POLICY behind each method (synchronize task-config,
+ * strip metadata, tracker projection, validator dispatch, artifact IO) is owned
+ * by `@rig/task-sources-plugin`, which `defineCapability(TASK_DATA_SERVICE_CAPABILITY).provide`s
+ * the impl. Consumers `resolve`/`require` it off a built plugin host (or read the
+ * boot-installed singleton) WITHOUT importing the provider plugin — this is the
+ * seam that replaces the cross-plugin `import("@rig/task-sources-plugin/...")`
+ * impl imports (SEAM-ONLY §6.4).
+ *
+ * Pure: types + one branded id, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { TaskConfigEntry, TaskRecord, RegisteredTaskSource, TaskSourceUpdate } from "./task-source";
+import type { TaskRecordReader } from "./isolation";
+import type { RuntimeInstructionProvider } from "./provider-instructions";
+import type { CanonicalTaskLifecycleStatus, TaskStateMetadataEnvelope } from "./task-state-metadata";
+/** Result of a bounded artifact-file read (preview + truncation metadata). */
+export type TaskArtifactReadResult = {
+    path: string;
+    sizeBytes: number;
+    contents: string;
+    truncated: boolean;
+    maxBytes: number;
+};
+/** One validation category outcome inside a {@link TaskValidationSummary}. */
+export type TaskValidationCategoryResult = {
+    category: string;
+    status: "pass" | "fail";
+    exit_code?: number;
+    duration_seconds: number;
+};
+/**
+ * The aggregate task-validation outcome a task closeout reads/accepts (the
+ * category-rollup shape written to `validation-summary.json` by `taskValidate`).
+ * Distinct from the schema-typed run-level `ValidationSummary` in `./validation`.
+ */
+export type TaskValidationSummary = {
+    status: "pass" | "fail" | "skipped";
+    total: number;
+    passed: number;
+    failed: number;
+    categories: TaskValidationCategoryResult[];
+};
+/** A `bd-`/source-id lifecycle status projected from the synced tracker. */
+export type SyncedTrackerStatus = CanonicalTaskLifecycleStatus | "unknown";
+export type SyncedTrackerDependency = {
+    issueId: string | null;
+    dependsOnId: string | null;
+    id?: string | null;
+    type: string | null;
+};
+export type SyncedTrackerIssue = {
+    id: string;
+    title: string | null;
+    description: string | null;
+    acceptanceCriteria: string | null;
+    issueType: string | null;
+    status: SyncedTrackerStatus;
+    rawStatus: string | null;
+    priority: number | null;
+    dependencies: SyncedTrackerDependency[];
+};
+export type SyncedTrackerSnapshot = {
+    source: "remote" | "local";
+    baseOid: string | null;
+    issues: SyncedTrackerIssue[];
+    taskState: TaskStateMetadataEnvelope;
+};
+/** Optional fallback toggle for synced-tracker reads. */
+export type ReadSyncedTrackerOptions = {
+    allowLocalFallback?: boolean;
+};
+/** Result of resolving a single task through the configured task source. */
+export type TaskSourceTaskReadResult = {
+    configured: boolean;
+    sourceKind: string | null;
+    task: TaskRecord | null;
+};
+/** Summary of a `task reopen` operation. */
+export type TaskReopenSummary = {
+    mode: "all" | "single";
+    requestedTaskId: string | null;
+    dryRun: boolean;
+    closedFound: number;
+    reopened: string[];
+    failed: string[];
+    skipped: string[];
+};
+/** Identity fields used to resolve a task's source issue. */
+export type SourceTaskIdentity = {
+    id?: unknown;
+    sourceIssueId?: unknown;
+    source_issue_id?: unknown;
+};
+/** Result of pushing a task lifecycle update through the configured source. */
+export type TaskSourceLifecycleUpdateResult = {
+    taskId: string;
+    updated: boolean;
+    source: "plugin" | "compat" | "none" | "server";
+    sourceKind: string | null;
+    status: unknown;
+    projectSync?: unknown;
+};
+/** Input for rendering a task-run lifecycle status comment. */
+export type TaskRunLifecycleCommentInput = {
+    runId: string;
+    status: string;
+    summary: string;
+    runtimeWorkspace?: string | null;
+    logsDir?: string | null;
+    sessionDir?: string | null;
+    errorText?: string | null;
+};
+/** Boundary subset of the source-aware task-config reader options. */
+export type SourceAwareTaskConfigReadOptions = {
+    configPath?: string;
+    allowLocalTaskConfigStatusFallback?: boolean;
+};
+/**
+ * The lifecycle status values a run reflects to the task source.
+ * Mirrors the type defined in @rig/task-sources-plugin/source-lifecycle —
+ * lives here so @rig/run-exec can use it through the TaskDataService seam
+ * without a cross-plugin impl import.
+ */
+export type RunTaskSourceLifecycleStatus = "running" | "under_review" | "ci_fixing" | "merging" | "closed" | "cancelled" | "needs_attention";
+/**
+ * The run identity fields passed when reflecting a run lifecycle event to the
+ * task source.
+ */
+export type RunTaskSourceLifecycleRun = {
+    runId?: string | null;
+    taskId?: string | null;
+    sourceTask?: unknown;
+    worktreePath?: string | null;
+    logRoot?: string | null;
+    sessionPath?: string | null;
+    errorText?: string | null;
+};
+/** Optional overrides for a run lifecycle update. */
+export type RunTaskSourceLifecycleOptions = {
+    errorText?: string | null;
+};
+/** Context for building a plugin-backed task-record reader. */
+export type PluginTaskRecordReaderContext = {
+    taskSourceRegistry: {
+        list(): readonly RegisteredTaskSource[];
+        resolveById(id: string): RegisteredTaskSource;
+        resolveByKind(kind: string): RegisteredTaskSource;
+    };
+};
+/** Options selecting a source for a plugin-backed task-record reader. */
+export type PluginTaskRecordReaderOptions = {
+    projectRoot: string;
+    sourceId?: string;
+    sourceKind?: string;
+};
+/**
+ * The task-DATA service contributed by `@rig/task-sources-plugin`. Every method
+ * is keyed by `projectRoot` (the service is stateless), so it is safe to install
+ * as a boot singleton and read synchronously by substrate consumers.
+ */
+export interface TaskDataService {
+    currentTaskId(projectRoot: string): string;
+    readTaskConfig(projectRoot: string): Record<string, TaskConfigEntry>;
+    readSourceTaskConfig(projectRoot: string): Record<string, TaskConfigEntry>;
+    lookupTask(projectRoot: string, input: string): string;
+    artifactDirForId(projectRoot: string, id: string): string;
+    taskInfo(projectRoot: string, taskId?: string, runtimeProviderOverride?: RuntimeInstructionProvider): Promise<void>;
+    taskDeps(projectRoot: string, taskId?: string): Promise<void>;
+    taskStatus(projectRoot: string): void;
+    taskScope(projectRoot: string, expandFiles: boolean, taskId?: string): Promise<void>;
+    taskReady(projectRoot: string): Promise<void>;
+    taskLookup(projectRoot: string, id: string): string;
+    taskRecord(projectRoot: string, type: "decision" | "failure", text: string, taskId?: string): void;
+    taskReopen(projectRoot: string, options: {
+        all: boolean;
+        taskId?: string;
+        dryRun?: boolean;
+    }): TaskReopenSummary;
+    taskValidate(projectRoot: string, taskId?: string, validatorRegistry?: unknown): Promise<boolean>;
+    taskArtifacts(projectRoot: string, taskId?: string): void;
+    taskArtifactDir(projectRoot: string, taskId?: string): string;
+    taskArtifactWrite(projectRoot: string, filename: string, content: string, taskId?: string): void;
+    taskArtifactRead(projectRoot: string, filename: string, options?: {
+        taskId?: string;
+        maxBytes?: number;
+    }): TaskArtifactReadResult;
+    taskDependencyIds(projectRoot: string, taskId: string): string[];
+    changedFilesForTask(projectRoot: string, taskId: string, scoped: boolean): string[];
+    pendingFilesForTask(projectRoot: string, taskId: string, scoped: boolean): string[];
+    readSourceAwareTaskStatus(projectRoot: string, taskId: string, options?: SourceAwareTaskConfigReadOptions): Promise<unknown>;
+    readConfiguredTaskSourceTask(projectRoot: string, taskId: string): Promise<TaskSourceTaskReadResult>;
+    updateConfiguredTaskSourceTask(projectRoot: string, input: {
+        taskId: string;
+        sourceTask?: SourceTaskIdentity | null;
+        update: TaskSourceUpdate;
+    }): Promise<TaskSourceLifecycleUpdateResult>;
+    buildTaskRunLifecycleComment(input: TaskRunLifecycleCommentInput): string;
+    /**
+     * Compat fallback: push an update to a github-issues-backed task by parsing
+     * its `owner/repo#n` source-issue id. Returns false when the id does not match
+     * the taskId. Exposed on the seam so the kernel agent-launch executor can apply
+     * the source-aware compatibility update without importing the provider plugin.
+     */
+    updateGithubIssueTaskBySourceIssueId(sourceIssueId: string | null | undefined, taskId: string, update: TaskSourceUpdate): boolean;
+    /**
+     * Compat fallback: push a status/comment update through the source-aware
+     * task-config (github-issues, files, or legacy task-config). Returns false when
+     * no writable source is configured. Seam-exposed for the kernel executor.
+     */
+    updateSourceAwareTaskConfigTask(projectRoot: string, taskId: string, update: TaskSourceUpdate): boolean;
+    /**
+     * Reflect a run lifecycle event (start/stop/closeout) to the configured task
+     * source. Returns null when no taskId is present or no source is configured.
+     * Exposed on the seam so @rig/run-exec can call it without importing
+     * @rig/task-sources-plugin impl files directly (SEAM-ONLY §6.4).
+     */
+    updateRunTaskSourceLifecycle(projectRoot: string, run: RunTaskSourceLifecycleRun, status: RunTaskSourceLifecycleStatus, summary: string, options?: RunTaskSourceLifecycleOptions): Promise<TaskSourceLifecycleUpdateResult | null>;
+    createLegacyTaskConfigRecordReader(projectRoot: string, options?: {
+        configPath?: string;
+    }): TaskRecordReader;
+    createSourceAwareTaskConfigRecordReader(projectRoot: string, options?: SourceAwareTaskConfigReadOptions): TaskRecordReader;
+    createPluginTaskRecordReader(context: PluginTaskRecordReaderContext, options: PluginTaskRecordReaderOptions): TaskRecordReader;
+    readSyncedTrackerState(projectRoot: string, deps?: unknown, options?: ReadSyncedTrackerOptions): SyncedTrackerSnapshot;
+    listReadyTaskIdsFromTracker(snapshot: SyncedTrackerSnapshot): string[];
+    normalizeTaskLifecycleStatus(status: unknown): CanonicalTaskLifecycleStatus | null;
+}
+/** Stable id string for the task-data service capability. */
+export declare const TASK_DATA_SERVICE_CAPABILITY_ID = "task-sources.task-data";
+/**
+ * The branded task-data capability id. `defineCapability(TASK_DATA_SERVICE_CAPABILITY)`
+ * (provider and consumers, independently) resolves to a `TaskDataService`.
+ */
+export declare const TASK_DATA_SERVICE_CAPABILITY: CapabilityId<TaskDataService>;

package/dist/src/task-data.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-data.ts
+var TASK_DATA_SERVICE_CAPABILITY_ID = "task-sources.task-data";
+var TASK_DATA_SERVICE_CAPABILITY = makeCapabilityId(TASK_DATA_SERVICE_CAPABILITY_ID);
+export {
+  TASK_DATA_SERVICE_CAPABILITY_ID,
+  TASK_DATA_SERVICE_CAPABILITY
+};

package/dist/src/task-graph-primitives.d.ts

@@ -44,25 +44,4 @@ export interface TaskDependencyBadgeSummary {
     readonly dependentCount: number;
     readonly badges: readonly TaskDependencyBadge[];
 }
-export declare function readTaskMetadataStringList(task: TaskDependencyProjection, key: "dependencies" | "parentChildDeps" | "labels"): string[];
-export declare function readTaskBlockingDependencyRefs(task: TaskDependencyProjection): string[];
-export declare function readTaskDependencyRefs(task: TaskDependencyProjection): string[];
-export declare function readTaskSourceIssueId(task: TaskDependencyProjection): string | null;
-export declare function readTaskScope(task: TaskDependencyProjection): string[];
 export type TaskScopeInput = readonly string[] | TaskDependencyProjection;
-export declare function disjointScope(left: TaskScopeInput, right: TaskScopeInput): boolean;
-export declare function resolveTaskReference(ref: string, tasksById: ReadonlyMap<string, TaskDependencyProjection>, taskIdByExternalRef: ReadonlyMap<string, string>, taskIdBySourceIssueId: ReadonlyMap<string, string>): string | null;
-export declare function buildTaskReferenceIndex<T extends TaskDependencyProjection>(tasks: readonly T[]): {
-    readonly tasksById: Map<string, T>;
-    readonly taskIdByExternalRef: Map<string, string>;
-    readonly taskIdBySourceIssueId: Map<string, string>;
-};
-export declare function computeTaskBlockingDepths<T extends TaskDependencyProjection>(tasks: readonly T[]): Map<string, number>;
-export declare function isTaskTerminalStatus(status: string | null | undefined): boolean;
-export declare function computeTaskDependencyBadges(tasks: readonly TaskDependencyProjection[]): Map<string, TaskDependencyBadgeSummary>;
-export declare function normalizeTaskStatus(status: unknown): TaskSummary["status"];
-export declare function toTaskDependencyProjection(task: TaskProjectionInput): ClientTaskProjection;
-export declare function toTaskSummary(task: TaskProjectionInput, defaults?: {
-    readonly workspaceId?: string;
-    readonly graphId?: string | null;
-}): TaskSummary;

package/dist/src/task-graph-primitives.js

@@ -1,319 +1 @@
 // @bun
-// packages/contracts/src/task-graph-primitives.ts
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readStringList(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
-}
-function unique(values) {
-  return Array.from(new Set(values));
-}
-function readTaskMetadataStringList(task, key) {
-  const taskRecord = task;
-  const topLevel = readStringList(taskRecord[key]);
-  if (topLevel.length > 0)
-    return topLevel;
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const metadataList = readStringList(metadata?.[key]);
-  if (metadataList.length > 0)
-    return metadataList;
-  if (key === "dependencies") {
-    return readStringList(metadata?.deps);
-  }
-  return [];
-}
-function readTaskBlockingDependencyRefs(task) {
-  return readTaskMetadataStringList(task, "dependencies");
-}
-function readTaskDependencyRefs(task) {
-  return unique([
-    ...readTaskMetadataStringList(task, "dependencies"),
-    ...readTaskMetadataStringList(task, "parentChildDeps")
-  ]);
-}
-function readTaskSourceIssueId(task) {
-  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
-    return task.sourceIssueId;
-  }
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
-    return metadata.sourceIssueId;
-  }
-  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
-  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
-}
-function readTaskScope(task) {
-  const taskRecord = task;
-  const topLevel = readStringList(taskRecord.scope);
-  if (topLevel.length > 0)
-    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const metadataScope = readStringList(metadata?.scope);
-  if (metadataScope.length > 0)
-    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
-  return unique([
-    ...readStringList(metadata?.files),
-    ...readStringList(metadata?.paths)
-  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
-}
-function isScopeList(input) {
-  return Array.isArray(input);
-}
-function normalizeScopeInput(input) {
-  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
-}
-function disjointScope(left, right) {
-  const leftScope = new Set(normalizeScopeInput(left));
-  if (leftScope.size === 0)
-    return true;
-  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
-}
-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 = (taskId, stack) => {
-    const cached = memo.get(taskId);
-    if (cached !== undefined)
-      return cached;
-    if (stack.has(taskId))
-      return 0;
-    const task = tasksById.get(taskId);
-    if (!task)
-      return 0;
-    stack.add(taskId);
-    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
-    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
-    stack.delete(taskId);
-    memo.set(taskId, 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":
-    case "canceled":
-      return true;
-    default:
-      return false;
-  }
-}
-function isTaskBlockedStatus(status) {
-  return status === "blocked";
-}
-function isTaskRunnableStatus(status) {
-  if (status === null || status === undefined || status === "")
-    return true;
-  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 {
-        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 refs: ${unresolvedDependencyRefs.join(", ")}.` : null
-        ].filter((part) => part !== null).join(" "),
-        count: dependencyIds.length + blocks.length,
-        taskIds: unique([...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;
-}
-var TASK_STATUSES = new Set([
-  "draft",
-  "open",
-  "ready",
-  "queued",
-  "running",
-  "in_progress",
-  "under_review",
-  "blocked",
-  "unknown",
-  "completed",
-  "failed",
-  "cancelled",
-  "closed"
-]);
-function stringValue(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
-}
-function numberOrNull(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
-}
-function metadataOf(task) {
-  return isObjectRecord(task.metadata) ? task.metadata : {};
-}
-function normalizeTaskStatus(status) {
-  const token = typeof status === "string" ? status.trim().toLowerCase() : "";
-  if (token === "done")
-    return "completed";
-  if (token === "canceled")
-    return "cancelled";
-  return TASK_STATUSES.has(token) ? token : "unknown";
-}
-function toTaskDependencyProjection(task) {
-  const metadata = metadataOf(task);
-  return {
-    id: String(task.id),
-    title: stringValue(task.title),
-    status: normalizeTaskStatus(task.status),
-    priority: numberOrNull(task.priority),
-    metadata,
-    externalId: stringValue(task.externalId),
-    sourceIssueId: stringValue(task.sourceIssueId),
-    dependencies: stringArray(task.dependencies),
-    parentChildDeps: stringArray(task.parentChildDeps),
-    createdAt: stringValue(task.createdAt) ?? "",
-    updatedAt: stringValue(task.updatedAt) ?? "",
-    role: stringValue(task.role),
-    scope: stringArray(task.scope),
-    validationKeys: stringArray(task.validationKeys),
-    labels: stringArray(task.labels),
-    assignees: task.assignees,
-    assignedTo: task.assignedTo
-  };
-}
-function toTaskSummary(task, defaults = {}) {
-  const projection = toTaskDependencyProjection(task);
-  const metadata = metadataOf(task);
-  const createdAt = stringValue(task.createdAt) ?? "1970-01-01T00:00:00.000Z";
-  const updatedAt = stringValue(task.updatedAt) ?? createdAt;
-  return {
-    id: projection.id,
-    workspaceId: stringValue(task.workspaceId) ?? defaults.workspaceId ?? "workspace",
-    graphId: stringValue(task.graphId) ?? defaults.graphId ?? null,
-    externalId: projection.externalId,
-    title: projection.title ?? projection.id,
-    description: stringValue(task.description) ?? stringValue(task.body) ?? "",
-    status: projection.status,
-    priority: numberOrNull(task.priority),
-    role: projection.role,
-    scope: [...projection.scope ?? []],
-    validationKeys: [...projection.validationKeys ?? []],
-    ...projection.sourceIssueId ? { sourceIssueId: projection.sourceIssueId } : {},
-    dependencies: [...projection.dependencies ?? []],
-    parentChildDeps: [...projection.parentChildDeps ?? []],
-    metadata,
-    createdAt,
-    updatedAt
-  };
-}
-export {
-  toTaskSummary,
-  toTaskDependencyProjection,
-  resolveTaskReference,
-  readTaskSourceIssueId,
-  readTaskScope,
-  readTaskMetadataStringList,
-  readTaskDependencyRefs,
-  readTaskBlockingDependencyRefs,
-  normalizeTaskStatus,
-  isTaskTerminalStatus,
-  disjointScope,
-  computeTaskDependencyBadges,
-  computeTaskBlockingDepths,
-  buildTaskReferenceIndex
-};

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

@@ -1,4 +1,27 @@
+import type { CapabilityId } from "./capability-id";
 import type { TaskSourceRegistration } from "./plugin";
+import type { TaskBrowserConfig } from "./browser";
+/**
+ * A single entry in the on-disk task-config map (`.rig/task-config.json`).
+ * Floor-neutral DATA shape. The READ/normalize POLICY (synchronize, strip
+ * metadata, validation-description extraction) is owned by
+ * @rig/task-sources-plugin (`task-state`), NOT the floor.
+ */
+export type TaskConfigEntry = {
+    title?: string;
+    status?: string;
+    role?: string;
+    description?: string;
+    acceptance_criteria?: string;
+    scope?: string[];
+    validation?: string[];
+    browser?: TaskBrowserConfig;
+    repo_pins?: Record<string, string>;
+    criticality?: "core" | "high" | "normal";
+    queue_weight?: number;
+    creates_repo?: boolean;
+    auto_synced?: boolean;
+};
 /**
  * A single task record returned by a task source adapter.
  * Open-ended to allow adapters to include source-specific fields.
@@ -9,6 +32,30 @@ export interface TaskRecord {
     status: "ready" | "in_progress" | "closed" | "blocked" | "open" | string;
     [extra: string]: unknown;
 }
+/**
+ * The NORMALIZED, surface-facing task shape (the projection consumers read).
+ * The TYPE is floor-neutral vocab and lives here in contracts; the
+ * normalization POLICY that produces it (field-mapping a raw `TaskRecord` into
+ * this shape — title/body/url/dependency fallback chains) is owned by
+ * @rig/task-sources-plugin (`toRigTask`), NOT by the floor.
+ */
+export type RigTask = {
+    readonly id: string;
+    readonly title?: string | null;
+    readonly status?: string | null;
+    readonly source?: string | null;
+    readonly url?: string | null;
+    readonly body?: string | null;
+    readonly priority?: number | string | null;
+    readonly assignedTo?: string | readonly string[] | null;
+    readonly assignees?: readonly string[] | null;
+    readonly dependencies?: readonly string[] | null;
+    readonly parentChildDeps?: readonly string[] | null;
+    readonly metadata?: Record<string, unknown> | null;
+    readonly [key: string]: unknown;
+};
+/** Alias retained for call sites that accept any task-like projection. */
+export type TaskLike = RigTask;
 /**
  * A registered task source adapter — combines the plugin-level registration
  * metadata with the runtime-callable interface.
@@ -35,3 +82,21 @@ export interface RegisteredTaskSource extends TaskSourceRegistration {
     updateTask?(id: string, update: TaskSourceUpdate): Promise<void>;
     create?(input: TaskSourceCreateInput): Promise<TaskSourceCreateResult>;
 }
+export type TaskIoCreateResult = {
+    readonly taskId: string | null;
+    readonly source: string;
+    readonly result: unknown;
+};
+/**
+ * Source-owned task IO projection seam. Providers normalize raw task-source
+ * records into RigTask and adapt generic task creation payloads to the
+ * configured source; consumers resolve this instead of importing @rig/core
+ * task-source glue.
+ */
+export interface TaskIoService {
+    listTasks(projectRoot: string): Promise<readonly RigTask[]>;
+    getTask(projectRoot: string, taskId: string): Promise<RigTask | null>;
+    createTask(projectRoot: string, task: Record<string, unknown>): Promise<TaskIoCreateResult>;
+}
+export declare const TASK_IO_SERVICE_CAPABILITY_ID = "task-sources.task-io";
+export declare const TASK_IO_SERVICE_CAPABILITY: CapabilityId<TaskIoService>;