@h-rig/core 0.0.6-alpha.14 → 0.0.6-alpha.141

package/dist/src/plugin-runtime.d.ts

@@ -0,0 +1,105 @@
+import type { BlockerClassifierRegistration, CliCommandRegistration, HookImplementation, PanelRegistration, ProductCapabilityRegistration, RegisteredTaskSource, RigConfig, RigPlugin, StageRun, TaskSourceConfig, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
+export interface ValidatorResult {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+}
+export interface ValidatorContext {
+    taskId: string;
+    workspaceRoot: string;
+    scope: readonly string[];
+    monorepoRoot?: string;
+    artifactsDir?: string;
+    taskConfig?: unknown;
+}
+export interface RegisteredValidator extends ValidatorRegistration {
+    run(ctx: ValidatorContext): Promise<ValidatorResult>;
+}
+/**
+ * Project context handed to task-source factories at instantiation. The
+ * server process's cwd is NOT necessarily the project root (workspace-spawned
+ * servers run from the engine checkout), so factories that touch the
+ * filesystem must resolve relative config paths against `projectRoot`,
+ * never cwd.
+ */
+export interface TaskSourceFactoryContext {
+    projectRoot: string;
+    /**
+     * Full project config for adapters that need source-adjacent top-level
+     * settings (for example github.projects). Factories should still treat
+     * TaskSourceConfig as the primary adapter config.
+     */
+    rigConfig?: RigConfig;
+}
+/**
+ * Executable task-source factory contributed by a plugin. A plugin
+ * registers a TaskSourceRegistration metadata entry (with `id` and `kind`)
+ * AND a factory here that turns a TaskSourceConfig into a RegisteredTaskSource.
+ *
+ * `kind` is matched against `config.taskSource.kind` at boot. The first
+ * matching plugin factory wins; if multiple plugins claim the same kind,
+ * `createPluginHost` throws a duplicate-kind error.
+ */
+export interface TaskSourceFactoryEntry extends TaskSourceRegistration {
+    factory(config: TaskSourceConfig, context?: TaskSourceFactoryContext): RegisteredTaskSource;
+}
+export interface RuntimeFeatureCapability extends ProductCapabilityRegistration {
+    run?: (input: unknown) => Promise<unknown> | unknown;
+}
+export interface RuntimePanelProducer extends PanelRegistration {
+    produce?: (context?: unknown) => Promise<unknown> | unknown;
+}
+export interface RuntimeBlockerClassifier extends BlockerClassifierRegistration {
+    classify(input: unknown): Promise<unknown> | unknown;
+}
+export interface RuntimeCliContext {
+    projectRoot: string;
+    outputMode?: string;
+    dryRun?: boolean;
+}
+export interface RuntimeCliCommand extends CliCommandRegistration {
+    run(context: RuntimeCliContext, args: readonly string[]): Promise<unknown> | unknown;
+}
+export interface RigPluginRuntime {
+    validators?: readonly RegisteredValidator[];
+    taskSources?: readonly TaskSourceFactoryEntry[];
+    /**
+     * Typed hook implementations keyed by hook id. Each key must match a
+     * declared `contributes.hooks` entry on the same plugin. A typed hook and
+     * a metadata `command` string are mutually exclusive per hook — and when
+     * this channel is present, every declared hook must be implemented one way
+     * or the other (same all-or-none rule as validators). The runtime's
+     * hook-materializer generates the shim command that routes Claude Code's
+     * hook invocation to the typed function (see
+     * `@rig/runtime/control-plane/hook-runner`).
+     */
+    hooks?: Record<string, HookImplementation>;
+    /**
+     * Executable stage implementations keyed by stage id — the runtime counterpart
+     * to `contributes.stageMutations` (which carries only the ordering descriptor).
+     * When a plugin inserts/replaces a stage, its `run(ctx)` lives here. The plugin
+     * host flattens these (`listStageExecutors()`) so the kernel's stage runner can
+     * execute plugin-contributed stages (e.g. the docs-drift pre-merge gate).
+     */
+    stages?: Record<string, StageRun>;
+    /**
+     * Executable product-capability registrations. This is deliberately separate
+     * from `capabilities`: that map is reserved for the five kernel provider
+     * capability tags resolved by `@rig/kernel-seed`.
+     */
+    featureCapabilities?: readonly RuntimeFeatureCapability[];
+    panels?: readonly RuntimePanelProducer[];
+    blockerClassifiers?: readonly RuntimeBlockerClassifier[];
+    cliCommands?: readonly RuntimeCliCommand[];
+    /**
+     * Executable kernel-capability providers keyed by **capability tag**
+     * (`transport`, `journal`, …) — the same shape the kernel-seed resolver reads
+     * via `plugin.runtime.capabilities[tag]`. Which tags a plugin provides is
+     * declared by the top-level `provides: CapabilityTag[]`; this holds the impls.
+     */
+    capabilities?: Record<string, unknown>;
+}
+export type RigPluginWithRuntime = RigPlugin & {
+    __runtime?: RigPluginRuntime;
+};

package/dist/src/rig-init-builder.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure builder that turns a small input shape into the source text of a
+ * `rig.config.ts` file. Shared between the CLI `rig init` wizard and the
+ * desktop app's in-app setup wizard so both surfaces produce identical
+ * output.
+ *
+ * Pure — no fs, no node, no imports outside this file. Safe to bundle into
+ * a renderer (Vite, esbuild, webpack).
+ */
+export type RigInitConfigInput = {
+    projectName: string;
+    projectRepo?: string;
+    taskSource: {
+        kind: "github-issues";
+        owner: string;
+        repo: string;
+        assignee?: string;
+    } | {
+        kind: "files";
+        path: string;
+    };
+    useStandardPlugin: boolean;
+    /**
+     * Remote run placement (ssh target, e.g. `ubuntu@host`). Omit / empty = local
+     * placement (runs execute where `rig` starts) — the default. Surfaced as a
+     * dedicated `rig init` step; written to `runtime.server.sshTarget`.
+     */
+    sshTarget?: string;
+};
+export declare function buildRigInitConfigSource(input: RigInitConfigInput): string;

package/dist/src/rig-init-builder.js

@@ -2,22 +2,25 @@
 // packages/core/src/rig-init-builder.ts
 function buildRigInitConfigSource(input) {
   const lines = [`import { defineConfig } from "@rig/core";`];
-  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`import standard, { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
-  } else if (input.useStandardPlugin) {
-    lines.push(`import standard from "@rig/standard-plugin";`);
+  if (input.useStandardPlugin) {
+    lines.push(`import { standardProjectPlugins } from "@rig/standard-plugin/bundle";`);
+    if (input.taskSource.kind === "github-issues") {
+      lines.push(`import { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
+    }
   }
   lines.push(``, `export default defineConfig({`);
   const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
   lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
   if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [standard({`);
-    lines.push(`    githubCredentialProvider: createStateGitHubCredentialProvider(),`);
-    lines.push(`    githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
-    lines.push(`    githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
+    lines.push(`  plugins: [...standardProjectPlugins({`);
+    lines.push(`    standard: {`);
+    lines.push(`      githubCredentialProvider: createStateGitHubCredentialProvider(),`);
+    lines.push(`      githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
+    lines.push(`      githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
+    lines.push(`    },`);
     lines.push(`  })],`);
   } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "standard()" : ""}],`);
+    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardProjectPlugins()" : ""}],`);
   }
   if (input.taskSource.kind === "github-issues") {
     lines.push(`  taskSource: {`);
@@ -37,7 +40,8 @@ function buildRigInitConfigSource(input) {
     lines.push(`  },`);
   }
   lines.push(`  workspace: { mainRepo: ".", isolation: "worktree" },`);
-  lines.push(`  runtime: { harness: "pi", mode: "yolo" },`);
+  const sshTarget = input.sshTarget?.trim();
+  lines.push(sshTarget ? `  runtime: { harness: "pi", mode: "yolo", server: { sshTarget: ${JSON.stringify(sshTarget)} } },` : `  runtime: { harness: "pi", mode: "yolo" },  // server.sshTarget unset = local placement`);
   lines.push(`  planning: { mode: "auto" },`);
   lines.push(`  github: {`);
   lines.push(`    issueUpdates: "lifecycle",`);

package/dist/src/rigSelectors.d.ts

@@ -0,0 +1,220 @@
+import type { ArtifactSummary, ApprovalSummary, EngineReadModel, GraphSummary, QueueEntry, RemoteConnectionSummary, RemoteEndpoint, RunId, RunJournalProjection, RunStatus, RunSummary, TaskId, TaskStatus, TaskSummary, UserInputRequestSummary, WorkspaceId, WorkspaceSummary } from "@rig/contracts";
+import type { TaskDependencyProjection } from "./taskGraph";
+export declare function selectWorkspaces(snapshot: EngineReadModel | null): readonly WorkspaceSummary[];
+export declare function selectPrimaryWorkspace(snapshot: EngineReadModel | null): WorkspaceSummary | null;
+export declare function pickDefaultWorkspaceId(snapshot: EngineReadModel | null): WorkspaceId | null;
+export declare function selectWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): WorkspaceSummary | null;
+export declare function selectTask(snapshot: EngineReadModel | null, taskId: TaskId | null): TaskSummary | null;
+export declare function selectTasksByWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): TaskSummary[];
+export declare const selectTasksForWorkspace: typeof selectTasksByWorkspace;
+export declare function selectTasksByStatus(snapshot: EngineReadModel | null, status: TaskStatus): TaskSummary[];
+export type RigTaskSessionProjection = Pick<RunJournalProjection, "record" | "status" | "lastEventAt"> & {
+    readonly taskId?: string | null;
+};
+export interface RigTaskStatusGroupingInput<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly tasks: readonly T[];
+    readonly sessions?: readonly RigTaskSessionProjection[];
+    readonly workspaceId?: string | null;
+}
+export interface RigTaskStatusGroup<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly status: string;
+    readonly tasks: readonly T[];
+}
+export declare function projectTaskStatusForGrouping(status: string | null | undefined): string;
+export declare function projectRunStatusForTaskGrouping(status: RunStatus | null | undefined): string | null;
+export declare function projectTaskStatusWithSessions(task: TaskDependencyProjection, sessionsByTask?: ReadonlyMap<string, RigTaskSessionProjection>): string;
+export declare function selectTasksGroupedByStatus(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): Array<{
+    status: string;
+    tasks: readonly TaskSummary[];
+}>;
+export declare function selectTasksGroupedByStatus<T extends TaskDependencyProjection>(input: RigTaskStatusGroupingInput<T>): Array<RigTaskStatusGroup<T>>;
+export declare function normalizeTaskAssigneeFilter(assignee: string | null | undefined, currentUserLogin?: string | null): string | null;
+export declare function readTaskAssigneeLogins(task: TaskDependencyProjection): readonly string[];
+export declare function taskMatchesAssigneeFilter(task: TaskDependencyProjection, assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): boolean;
+export declare function selectTasksAssignedTo<T extends TaskDependencyProjection>(tasks: readonly T[], assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): T[];
+export declare function selectTasksAssignedToMe<T extends TaskDependencyProjection>(tasks: readonly T[], currentUserLogin: string | null | undefined): T[];
+export declare function selectRun(snapshot: EngineReadModel | null, runId: RunId | null): RunSummary | null;
+export declare function selectRunsByTask(snapshot: EngineReadModel | null, taskId: TaskId | null): RunSummary[];
+export declare const selectRunsForTask: typeof selectRunsByTask;
+export declare function selectRunsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): RunSummary[];
+export declare function selectAdhocRuns(snapshot: EngineReadModel | null): RunSummary[];
+export declare function selectAdhocRunsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): RunSummary[];
+export declare function selectGraphsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): GraphSummary[];
+export declare function selectQueueForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): QueueEntry[];
+export declare function selectPendingApprovals(snapshot: EngineReadModel | null): ApprovalSummary[];
+export declare function selectApprovalsForRun(snapshot: EngineReadModel | null, runId: RunId | null): ApprovalSummary[];
+export declare function selectPendingApprovalsForRun(snapshot: EngineReadModel | null, runId: RunId | null): ApprovalSummary[];
+export declare function selectApprovalsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): ApprovalSummary[];
+export declare function selectUserInputsForRun(snapshot: EngineReadModel | null, runId: RunId | null): UserInputRequestSummary[];
+export declare function selectPendingUserInputs(snapshot: EngineReadModel | null): UserInputRequestSummary[];
+export declare function selectPendingUserInputsForRun(snapshot: EngineReadModel | null, runId: RunId | null): UserInputRequestSummary[];
+export declare function selectUserInputsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): UserInputRequestSummary[];
+export declare function selectRuntimeForRun(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"EngineRuntimeId">;
+    readonly updatedAt: string;
+    readonly status: "starting" | "running" | "interrupted" | "failed" | "prepared" | "exited" | "destroyed";
+    readonly startedAt: string | null;
+    readonly pid: number | null;
+    readonly stateDir: string | null;
+    readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+    readonly adapterKind: "pi";
+    readonly workspaceDir: string | null;
+    readonly homeDir: string | null;
+    readonly tmpDir: string | null;
+    readonly cacheDir: string | null;
+    readonly logsDir: string | null;
+    readonly sessionDir: string | null;
+    readonly sessionLogPath: string | null;
+    readonly exitedAt: string | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly sandboxMode: "read-only" | "workspace-write" | "danger-full-access";
+    readonly isolationMode: "none" | "env" | "worktree";
+    readonly executionTarget?: "remote" | "local" | undefined;
+    readonly remoteHostId?: string | null | undefined;
+} | null;
+export declare function selectLatestRuntimeForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"EngineRuntimeId">;
+    readonly updatedAt: string;
+    readonly status: "starting" | "running" | "interrupted" | "failed" | "prepared" | "exited" | "destroyed";
+    readonly startedAt: string | null;
+    readonly pid: number | null;
+    readonly stateDir: string | null;
+    readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+    readonly adapterKind: "pi";
+    readonly workspaceDir: string | null;
+    readonly homeDir: string | null;
+    readonly tmpDir: string | null;
+    readonly cacheDir: string | null;
+    readonly logsDir: string | null;
+    readonly sessionDir: string | null;
+    readonly sessionLogPath: string | null;
+    readonly exitedAt: string | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly sandboxMode: "read-only" | "workspace-write" | "danger-full-access";
+    readonly isolationMode: "none" | "env" | "worktree";
+    readonly executionTarget?: "remote" | "local" | undefined;
+    readonly remoteHostId?: string | null | undefined;
+} | null;
+export declare function selectActionsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ActionId">;
+    readonly title: string;
+    readonly completedAt: string | null;
+    readonly payload: unknown;
+    readonly startedAt: string;
+    readonly state: string;
+    readonly messageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly detail: string | null;
+    readonly actionType: string;
+}[];
+export declare function selectApprovalsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly status: "pending" | "resolved";
+    readonly payload: unknown;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly actionId: string | null;
+    readonly resolvedAt: string | null;
+    readonly requestKind: string;
+}[];
+export declare function selectUserInputsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly status: "pending" | "resolved";
+    readonly payload: unknown;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly resolvedAt: string | null;
+}[];
+export declare function selectValidationsForRun(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ValidationResultId">;
+    readonly status: "running" | "pending" | "failed" | "passed" | "skipped";
+    readonly completedAt: string | null;
+    readonly startedAt: string;
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly validatorKey: string;
+    readonly output: unknown;
+}[];
+export declare function selectValidationsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ValidationResultId">;
+    readonly status: "running" | "pending" | "failed" | "passed" | "skipped";
+    readonly completedAt: string | null;
+    readonly startedAt: string;
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly validatorKey: string;
+    readonly output: unknown;
+}[];
+export declare function selectFailedValidations(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ValidationResultId">;
+    readonly status: "running" | "pending" | "failed" | "passed" | "skipped";
+    readonly completedAt: string | null;
+    readonly startedAt: string;
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly validatorKey: string;
+    readonly output: unknown;
+}[];
+export declare function selectReviewsForRun(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ReviewResultId">;
+    readonly createdAt: string;
+    readonly status: "running" | "error" | "rejected" | "pending" | "approved";
+    readonly completedAt: string | null;
+    readonly summary: string | null;
+    readonly provider: string;
+    readonly mode: "required" | "off" | "advisory";
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly output: unknown;
+}[];
+export declare function selectReviewsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ReviewResultId">;
+    readonly createdAt: string;
+    readonly status: "running" | "error" | "rejected" | "pending" | "approved";
+    readonly completedAt: string | null;
+    readonly summary: string | null;
+    readonly provider: string;
+    readonly mode: "required" | "off" | "advisory";
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly output: unknown;
+}[];
+export declare function selectArtifactsForRun(snapshot: EngineReadModel | null, runId: RunId | null): ArtifactSummary[];
+export declare function selectArtifactsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): ArtifactSummary[];
+export declare function selectPolicyDecisionsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly decision: "allow" | "block" | "warn";
+    readonly mode: "observe" | "off" | "enforce";
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly actionId: (string & import("effect/Brand").Brand<"ActionId">) | null;
+    readonly reason: string;
+    readonly matchedRules: readonly string[];
+}[];
+export declare function selectRemoteEndpoints(snapshot: EngineReadModel | null): readonly RemoteEndpoint[];
+export declare function selectRemoteConnections(snapshot: EngineReadModel | null): readonly RemoteConnectionSummary[];
+export declare function selectRemoteEndpoint(snapshot: EngineReadModel | null, endpointId: string | null): {
+    readonly id: string & import("effect/Brand").Brand<"RemoteEndpointId">;
+    readonly port: number;
+    readonly host: string;
+    readonly lastConnectedAt: string | null;
+    readonly alias: string;
+    readonly token: string;
+    readonly addedAt: string;
+    readonly tokenConfigured?: boolean | undefined;
+    readonly autoConnect?: boolean | undefined;
+} | null;
+export declare function selectRemoteConnection(snapshot: EngineReadModel | null, endpointId: string | null): {
+    readonly error: string | null;
+    readonly status: "error" | "disconnected" | "connecting" | "authenticating" | "connected" | "reconnecting";
+    readonly endpointId: string & import("effect/Brand").Brand<"RemoteEndpointId">;
+    readonly connectedAt: string | null;
+    readonly tokenExpiresAt: string | null;
+    readonly latencyMs: number | null;
+    readonly subscribedEvents: readonly string[];
+} | null;
+export declare function selectConnectedRemoteCount(snapshot: EngineReadModel | null): number;

package/dist/src/rigSelectors.js

@@ -39,10 +39,40 @@ function projectTaskStatusForGrouping(status) {
     case "in_progress":
     case "under_review":
       return "running";
+    case null:
+    case undefined:
+    case "":
+      return "unknown";
     default:
       return status;
   }
 }
+function projectRunStatusForTaskGrouping(status) {
+  switch (status) {
+    case "created":
+    case "queued":
+    case "preparing":
+      return "queued";
+    case "running":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "running";
+    case "needs-attention":
+      return "blocked";
+    case "failed":
+    case "stopped":
+      return "ready";
+    case "completed":
+      return "completed";
+    case null:
+    case undefined:
+      return null;
+  }
+}
 var STATUS_PRIORITY = [
   "running",
   "blocked",
@@ -54,11 +84,31 @@ var STATUS_PRIORITY = [
   "cancelled",
   "completed"
 ];
-function selectTasksGroupedByStatus(snapshot, workspaceId) {
-  const tasks = selectTasksByWorkspace(snapshot, workspaceId);
+function taskIdFromSession(session) {
+  return session.taskId ?? session.record.taskId ?? null;
+}
+function latestSessionByTask(sessions) {
+  const byTask = new Map;
+  for (const session of sessions) {
+    const taskId = taskIdFromSession(session);
+    if (!taskId)
+      continue;
+    const existing = byTask.get(taskId);
+    if (!existing || (session.lastEventAt ?? "").localeCompare(existing.lastEventAt ?? "") >= 0) {
+      byTask.set(taskId, session);
+    }
+  }
+  return byTask;
+}
+function projectTaskStatusWithSessions(task, sessionsByTask = new Map) {
+  const sessionStatus = projectRunStatusForTaskGrouping(sessionsByTask.get(task.id)?.status);
+  return sessionStatus ?? projectTaskStatusForGrouping(task.status);
+}
+function groupTasksByProjectedStatus(tasks, sessions = []) {
+  const sessionsByTask = latestSessionByTask(sessions);
   const byStatus = new Map;
   for (const task of tasks) {
-    const projectedStatus = projectTaskStatusForGrouping(task.status);
+    const projectedStatus = projectTaskStatusWithSessions(task, sessionsByTask);
     const group = byStatus.get(projectedStatus);
     if (group) {
       group.push(task);
@@ -82,6 +132,69 @@ function selectTasksGroupedByStatus(snapshot, workspaceId) {
   }
   return result;
 }
+function isProjectionGroupingInput(value) {
+  return Boolean(value && typeof value === "object" && !("snapshotSequence" in value) && Array.isArray(value.tasks));
+}
+function selectTasksGroupedByStatus(input, workspaceId) {
+  if (isProjectionGroupingInput(input)) {
+    const filteredTasks = input.workspaceId ? input.tasks.filter((task) => {
+      const workspaceTask = task;
+      return workspaceTask.workspaceId === input.workspaceId;
+    }) : input.tasks;
+    return groupTasksByProjectedStatus(filteredTasks, input.sessions);
+  }
+  const tasks = selectTasksByWorkspace(input, workspaceId ?? null);
+  return groupTasksByProjectedStatus(tasks, []);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeLogin(value) {
+  return value.trim().replace(/^@+/, "").toLowerCase();
+}
+function assigneeLoginsFromValue(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [normalizeLogin(entry)];
+    if (isObjectRecord(entry) && typeof entry.login === "string" && entry.login.trim()) {
+      return [normalizeLogin(entry.login)];
+    }
+    return [];
+  });
+}
+function normalizeTaskAssigneeFilter(assignee, currentUserLogin) {
+  const trimmed = assignee?.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "@me" || trimmed.toLowerCase() === "me") {
+    return currentUserLogin?.trim() ? normalizeLogin(currentUserLogin) : null;
+  }
+  return normalizeLogin(trimmed);
+}
+function readTaskAssigneeLogins(task) {
+  const taskRecord = task;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord(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 selectTasksAssignedTo(tasks, assignee, options = {}) {
+  return tasks.filter((task) => taskMatchesAssigneeFilter(task, assignee, options));
+}
+function selectTasksAssignedToMe(tasks, currentUserLogin) {
+  return selectTasksAssignedTo(tasks, "@me", currentUserLogin === undefined ? {} : { currentUserLogin });
+}
 function selectRun(snapshot, runId) {
   if (!runId)
     return null;
@@ -247,6 +360,7 @@ function selectConnectedRemoteCount(snapshot) {
   return selectRemoteConnections(snapshot).filter((connection) => connection.status === "connected").length;
 }
 export {
+  taskMatchesAssigneeFilter,
   selectWorkspaces,
   selectWorkspace,
   selectValidationsForTask,
@@ -258,6 +372,8 @@ export {
   selectTasksForWorkspace,
   selectTasksByWorkspace,
   selectTasksByStatus,
+  selectTasksAssignedToMe,
+  selectTasksAssignedTo,
   selectTask,
   selectRuntimeForRun,
   selectRunsForWorkspace,
@@ -289,5 +405,10 @@ export {
   selectAdhocRunsForWorkspace,
   selectAdhocRuns,
   selectActionsForTask,
-  pickDefaultWorkspaceId
+  readTaskAssigneeLogins,
+  projectTaskStatusWithSessions,
+  projectTaskStatusForGrouping,
+  projectRunStatusForTaskGrouping,
+  pickDefaultWorkspaceId,
+  normalizeTaskAssigneeFilter
 };

package/dist/src/rollups.d.ts

@@ -0,0 +1,6 @@
+import type { AssigneeRollup as ContractAssigneeRollup, BlockerClass as ContractBlockerClass, EpicRollup as ContractEpicRollup, RunJournalProjection, TaskSummary } from "@rig/contracts";
+export type BlockerClass = ContractBlockerClass;
+export type EpicRollup = ContractEpicRollup;
+export type AssigneeRollup = ContractAssigneeRollup;
+export declare function rollupByEpic(tasks: readonly TaskSummary[], classifications?: ReadonlyMap<string, BlockerClass>): readonly EpicRollup[];
+export declare function rollupByAssignee(tasks: readonly TaskSummary[], runs: readonly RunJournalProjection[]): readonly AssigneeRollup[];