@h-rig/contracts 0.0.6-alpha.175 → 0.0.6-alpha.177

package/dist/src/run-session-journal.js

@@ -1,4 +1,9 @@
 // @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/run-session-journal.ts
 var RIG_RUN_STATUS_CHANGED = "rig.run.status-changed";
 var RIG_RUN_RECORD_PATCH = "rig.run.record-patch";
@@ -52,8 +57,12 @@ var TYPE_FOR_CUSTOM = {
   [RIG_RUN_PIPELINE_RESOLVED]: "pipeline-resolved",
   [RIG_RUN_STAGE_OUTCOME]: "stage-outcome"
 };
+var RUN_SESSION_JOURNAL_CAPABILITY_ID = "rig.runs.session-journal";
+var RUN_SESSION_JOURNAL = makeCapabilityId(RUN_SESSION_JOURNAL_CAPABILITY_ID);
 export {
   TYPE_FOR_CUSTOM,
+  RUN_SESSION_JOURNAL_CAPABILITY_ID,
+  RUN_SESSION_JOURNAL,
   RIG_STOP_SENTINEL_END,
   RIG_STOP_SENTINEL,
   RIG_RUN_TIMELINE_ENTRY,

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

@@ -0,0 +1,10 @@
+import type { CapabilityId } from "./capability-id";
+export type RuntimeSecretKey = "ANTHROPIC_API_KEY" | "OPENAI_API_KEY" | "OPENROUTER_API_KEY" | "AI_REVIEW_MODE" | "AI_REVIEW_PROVIDER" | "GREPTILE_API_BASE" | "GREPTILE_REMOTE" | "GREPTILE_REPOSITORY" | "GREPTILE_CONTEXT_BRANCH" | "GREPTILE_DEFAULT_BRANCH" | "GREPTILE_API_KEY" | "GREPTILE_GITHUB_TOKEN" | "GREPTILE_POLL_ATTEMPTS" | "GREPTILE_POLL_INTERVAL_MS" | "GH_TOKEN" | "GITHUB_TOKEN" | "GITHUB_SSH_KEY" | "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" | "AWS_REGION" | "LINEAR_API_KEY" | "LINEAR_WEBHOOK_SECRET";
+export type RuntimeSecrets = Partial<Record<RuntimeSecretKey, string>>;
+export interface RuntimeSecretsService {
+    resolveRuntimeSecrets(env: Record<string, string | undefined>, baked?: RuntimeSecrets): RuntimeSecrets;
+    loadDotEnvSecrets(projectRoot: string, env?: Record<string, string | undefined>): RuntimeSecrets;
+    secretDefinesFromEnv(env?: Record<string, string | undefined>, projectRoot?: string): Record<string, string>;
+}
+export declare const RUNTIME_SECRETS_CAPABILITY_ID = "provider.runtime-secrets";
+export declare const RUNTIME_SECRETS: CapabilityId<RuntimeSecretsService>;

package/dist/src/runtime-secrets.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/runtime-secrets.ts
+var RUNTIME_SECRETS_CAPABILITY_ID = "provider.runtime-secrets";
+var RUNTIME_SECRETS = makeCapabilityId(RUNTIME_SECRETS_CAPABILITY_ID);
+export {
+  RUNTIME_SECRETS_CAPABILITY_ID,
+  RUNTIME_SECRETS
+};

package/dist/src/session-hook-materializer.d.ts

@@ -0,0 +1,41 @@
+import type { CapabilityId } from "./capability-id";
+import type { HookEvent, HookRegistration } from "./plugin";
+/** Stable id string for provider/runtime-owned session hook materialization. */
+export declare const SESSION_HOOK_MATERIALIZER_CAPABILITY_ID = "provider.session-hook-materializer";
+/**
+ * A plugin hook contribution prepared for the active session host.
+ *
+ * `typed` means the hook has a runtime implementation attached to the authored
+ * plugin object. Concrete materializers decide how their session host invokes
+ * that implementation; metadata-only hooks (no command and not typed) can be
+ * skipped by implementations.
+ */
+export interface PluginHookEntry {
+    readonly pluginName: string;
+    readonly hook: HookRegistration;
+    readonly typed?: boolean;
+}
+/** Alias naming the entries by the capability they are handed to. */
+export type SessionHookEntry = PluginHookEntry;
+/** Provider-owned materialization result; adapter ids are intentionally open. */
+export type SessionHookMaterializerResult = {
+    readonly adapterId: string;
+    readonly status: "materialized";
+    readonly path?: string;
+    readonly events?: readonly HookEvent[];
+} | {
+    readonly adapterId: string;
+    readonly status: "skipped";
+    readonly reason: string;
+};
+/**
+ * Materializes plugin-contributed hooks into whatever session host is active
+ * (Claude Code settings, Pi/OMP session integration, or another provider-owned
+ * substrate). The floor runtime resolves this capability and invokes it; it
+ * does not know adapter names, settings paths, or provider/session policy.
+ */
+export interface SessionHookMaterializerService {
+    materializeSessionHooks(projectRoot: string, entries: readonly PluginHookEntry[]): Promise<readonly SessionHookMaterializerResult[]> | readonly SessionHookMaterializerResult[];
+}
+/** Branded capability id for the session-hook materializer service. */
+export declare const SESSION_HOOK_MATERIALIZER: CapabilityId<SessionHookMaterializerService>;

package/dist/src/session-hook-materializer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/session-hook-materializer.ts
+var SESSION_HOOK_MATERIALIZER_CAPABILITY_ID = "provider.session-hook-materializer";
+var SESSION_HOOK_MATERIALIZER = makeCapabilityId(SESSION_HOOK_MATERIALIZER_CAPABILITY_ID);
+export {
+  SESSION_HOOK_MATERIALIZER_CAPABILITY_ID,
+  SESSION_HOOK_MATERIALIZER
+};

package/dist/src/setup.d.ts

@@ -8,7 +8,7 @@
  * function-laden deps (those are the impl's concern, not the cross-plugin seam).
  */
 import type { CapabilityId } from "./capability-id";
-import type { GitHubAuthStatus } from "./github";
+import type { GitHubAuthStatus, GitHubProjectStatusField, GitHubProjectSummary } from "./github";
 /** Capability id the init/setup plugin registers its setup runner under. */
 export declare const PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
 /**
@@ -34,6 +34,66 @@ export type ProjectSetupInput = {
     readonly githubToken?: string | null;
     readonly importGhToken?: boolean;
 };
+export type ProjectInitAuthMethod = "gh" | "token" | "device" | "skip";
+export type ProjectInitTaskSource = {
+    readonly kind: "github-issues";
+    readonly owner: string;
+    readonly repo: string;
+    readonly assignee?: string | undefined;
+} | {
+    readonly kind: "files";
+    readonly path: string;
+};
+export type ProjectInitInput = {
+    readonly projectRoot: string;
+    readonly demo?: boolean | undefined;
+    readonly repoSlug?: string | undefined;
+    readonly taskSource?: ProjectInitTaskSource | undefined;
+    readonly githubToken?: string | undefined;
+    readonly githubAuthMethod?: ProjectInitAuthMethod | undefined;
+    readonly githubProject?: "off" | string | undefined;
+    readonly githubProjectStatusField?: string | undefined;
+    readonly githubProjectStatuses?: Readonly<Record<string, string>> | undefined;
+    readonly yes?: boolean | undefined;
+    readonly repair?: boolean | undefined;
+    readonly privateStateOnly?: boolean | undefined;
+    readonly server?: "local" | "remote" | undefined;
+    readonly remoteAlias?: string | undefined;
+    readonly remoteHost?: string | undefined;
+    readonly remotePort?: number | undefined;
+    readonly remoteCheckout?: string | undefined;
+};
+export type ProjectInitResult = {
+    readonly mode: "control-plane" | "local-files" | "demo" | "task-source";
+    readonly projectRoot: string;
+    readonly messages: readonly string[];
+    readonly details: Record<string, unknown>;
+};
+export type ProjectInitGitHubProjectsInput = {
+    readonly projectRoot: string;
+    readonly owner: string;
+    readonly token?: string | null | undefined;
+};
+export type ProjectInitGitHubProjectsResult = {
+    readonly ok: true;
+    readonly projects: readonly GitHubProjectSummary[];
+} | {
+    readonly ok: false;
+    readonly error: string;
+    readonly projects: readonly [];
+};
+export type ProjectInitProjectStatusFieldInput = {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly token?: string | null | undefined;
+};
+export type ProjectInitProjectStatusFieldResult = {
+    readonly ok: true;
+    readonly field: GitHubProjectStatusField;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
 export type ProjectRepoSlug = {
     readonly owner: string;
     readonly repo: string;
@@ -79,10 +139,16 @@ export type ProjectSetupResult = {
 /** The cohesive project-setup operation the CLI surface depends on. Async methods do IO. */
 export interface ProjectSetupService {
     parseRepoSlug(value: string): ProjectRepoSlug;
+    detectOriginRepoSlug(input: {
+        readonly projectRoot: string;
+    }): string | null;
     detectStartupStatus(input: {
         readonly projectRoot: string;
     }): Promise<RigSetupStatus>;
     runSetup(input: ProjectSetupInput): Promise<ProjectSetupResult>;
+    listGitHubProjectsForInit(input: ProjectInitGitHubProjectsInput): Promise<ProjectInitGitHubProjectsResult>;
+    getGitHubProjectStatusFieldForInit(input: ProjectInitProjectStatusFieldInput): Promise<ProjectInitProjectStatusFieldResult>;
+    runInit(input: ProjectInitInput): Promise<ProjectInitResult>;
 }
 /** Typed capability id; string value is {@link PROJECT_SETUP_CAPABILITY_ID}. */
 export declare const PROJECT_SETUP: CapabilityId<ProjectSetupService>;

package/dist/src/supervisor-journal.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-export declare const SupervisorStopReason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+export declare const SupervisorStopReason: Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
 export type SupervisorStopReason = typeof SupervisorStopReason.Type;
 export declare const SupervisorSelectionPolicy: Schema.Literals<readonly ["rank", "max-unblock", "blocking-only"]>;
 export type SupervisorSelectionPolicy = typeof SupervisorSelectionPolicy.Type;
@@ -85,13 +85,13 @@ export type SupervisorSkippedEvent = typeof SupervisorSkippedEvent.Type;
 export declare const SupervisorIdleEvent: Schema.Struct<{
     readonly kind: Schema.Literal<"supervisor.idle">;
     readonly at: Schema.String;
-    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
 }>;
 export type SupervisorIdleEvent = typeof SupervisorIdleEvent.Type;
 export declare const SupervisorStoppedEvent: Schema.Struct<{
     readonly kind: Schema.Literal<"supervisor.stopped">;
     readonly at: Schema.String;
-    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
 }>;
 export type SupervisorStoppedEvent = typeof SupervisorStoppedEvent.Type;
 export declare const SupervisorFinishedEvent: Schema.Struct<{
@@ -101,7 +101,7 @@ export declare const SupervisorFinishedEvent: Schema.Struct<{
     readonly succeeded: Schema.Int;
     readonly failed: Schema.Int;
     readonly skipped: Schema.optional<Schema.Int>;
-    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
 }>;
 export type SupervisorFinishedEvent = typeof SupervisorFinishedEvent.Type;
 export declare const SupervisorEvent: Schema.Union<readonly [Schema.Struct<{
@@ -158,11 +158,11 @@ export declare const SupervisorEvent: Schema.Union<readonly [Schema.Struct<{
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"supervisor.idle">;
     readonly at: Schema.String;
-    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"supervisor.stopped">;
     readonly at: Schema.String;
-    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
+    readonly reason: Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"supervisor.finished">;
     readonly at: Schema.String;
@@ -170,7 +170,7 @@ export declare const SupervisorEvent: Schema.Union<readonly [Schema.Struct<{
     readonly succeeded: Schema.Int;
     readonly failed: Schema.Int;
     readonly skipped: Schema.optional<Schema.Int>;
-    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
 }>]>;
 export type SupervisorEvent = typeof SupervisorEvent.Type;
 export declare const SupervisorProjection: Schema.Struct<{
@@ -186,8 +186,8 @@ export declare const SupervisorProjection: Schema.Struct<{
     readonly plannedOrder: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
     readonly selectionPolicy: Schema.NullOr<Schema.Literals<readonly ["rank", "max-unblock", "blocking-only"]>>;
     readonly concurrency: Schema.NullOr<Schema.Int>;
-    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
-    readonly stopReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly idleReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
+    readonly stopReason: Schema.NullOr<Schema.Literals<readonly ["all-done", "all-human-blocked", "blocked", "work-pending", "max-tasks", "budget", "judge-stop", "operator-stop", "source-error"]>>;
     readonly closures: Schema.$Array<Schema.Struct<{
         readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
         readonly runId: Schema.brand<Schema.Trim, "RunId">;

package/dist/src/supervisor-journal.js

@@ -201,6 +201,8 @@ var WorktreeSummary = Schema3.Struct({
 var SupervisorStopReason = Schema4.Literals([
   "all-done",
   "all-human-blocked",
+  "blocked",
+  "work-pending",
   "max-tasks",
   "budget",
   "judge-stop",

package/dist/src/supervisor-loop.d.ts

@@ -0,0 +1,40 @@
+/**
+ * supervisor-loop.ts — typed service boundary for autonomous supervisor control.
+ *
+ * The supervisor plugin owns loop orchestration. Its implementation resolves the
+ * scheduler RUN_QUEUE, run read-model, and transport dispatch capabilities rather
+ * than making CLI surfaces assemble those cross-package decisions.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { SupervisorEvent, SupervisorProjection, SupervisorSelectionPolicy } from "./supervisor-journal";
+export interface SupervisorLoopRunInput {
+    readonly projectRoot: string;
+    readonly maxTasks?: number;
+    readonly concurrency?: number;
+    readonly selectionPolicy?: SupervisorSelectionPolicy;
+    readonly candidateTaskIds?: Iterable<string>;
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly dryRun?: boolean;
+    readonly model?: string | null;
+    readonly force?: boolean;
+    readonly timeoutMs?: number;
+}
+export interface SupervisorLoopUnblockInput {
+    readonly projectRoot: string;
+    readonly taskId?: string | null;
+    readonly dryRun?: boolean;
+    readonly timeoutMs?: number;
+}
+export interface SupervisorLoopResult {
+    readonly ok: boolean;
+    readonly dryRun: boolean;
+    readonly plannedOrder: readonly string[];
+    readonly events: readonly SupervisorEvent[];
+    readonly projection: SupervisorProjection;
+}
+export interface SupervisorLoopService {
+    readonly runLoop: (input: SupervisorLoopRunInput) => Promise<SupervisorLoopResult>;
+    readonly unblock: (input: SupervisorLoopUnblockInput) => Promise<SupervisorLoopResult>;
+}
+export declare const SUPERVISOR_LOOP_CAPABILITY_ID = "rig.supervisor.loop";
+export declare const SUPERVISOR_LOOP: CapabilityId<SupervisorLoopService>;

package/dist/src/supervisor-loop.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/supervisor-loop.ts
+var SUPERVISOR_LOOP_CAPABILITY_ID = "rig.supervisor.loop";
+var SUPERVISOR_LOOP = makeCapabilityId(SUPERVISOR_LOOP_CAPABILITY_ID);
+export {
+  SUPERVISOR_LOOP_CAPABILITY_ID,
+  SUPERVISOR_LOOP
+};

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

@@ -22,12 +22,32 @@ export type TaskArtifactWriteResult = {
     readonly path: string;
     readonly sizeBytes: number;
 };
+export type TaskDecisionAppendInput = TaskArtifactRef & {
+    readonly text: string;
+    readonly timestamp?: string;
+};
+export type TaskDecisionAppendResult = {
+    readonly taskId: string;
+    readonly path: string;
+    readonly message: string;
+};
+export type TaskCompletionArtifactsPrepareInput = TaskArtifactRef & {
+    readonly changedFiles: readonly string[];
+    readonly completedAt?: string;
+};
+export type TaskCompletionArtifactsPrepareResult = {
+    readonly taskId: string;
+    readonly artifactDir: string;
+    readonly message: string;
+};
 /** Task artifact directory/list/read/write vocabulary. */
 export interface TaskArtifactsService {
     artifactDir(input: TaskArtifactRef): string;
     listArtifacts(input: TaskArtifactRef): Promise<readonly TaskArtifactListEntry[]>;
     readArtifact(input: TaskArtifactReadInput): Promise<TaskArtifactReadResult>;
     writeArtifact(input: TaskArtifactWriteInput): Promise<TaskArtifactWriteResult>;
+    appendDecision(input: TaskDecisionAppendInput): Promise<TaskDecisionAppendResult>;
+    prepareCompletionArtifacts(input: TaskCompletionArtifactsPrepareInput): Promise<TaskCompletionArtifactsPrepareResult>;
 }
 export declare const TASK_ARTIFACTS_CAPABILITY_ID = "task-state.artifacts";
 export declare const TASK_ARTIFACTS: CapabilityId<TaskArtifactsService>;

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

@@ -0,0 +1,22 @@
+/**
+ * task-config.ts - floor-neutral local task config entry vocabulary.
+ *
+ * The shape is shared by task-state/task-io compatibility paths, but read,
+ * write, normalization, and source materialization policy are owned by plugins.
+ */
+import type { TaskBrowserConfig } from "./browser";
+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;
+};

package/dist/src/task-config.js

@@ -0,0 +1 @@
+// @bun

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

@@ -26,7 +26,8 @@
  * Pure: types + one branded legacy id, no behaviour.
  */
 import type { CapabilityId } from "./capability-id";
-import type { TaskConfigEntry, TaskRecord, RegisteredTaskSource, TaskSourceUpdate } from "./task-source";
+import type { TaskConfigEntry } from "./task-config";
+import type { TaskRecord, RegisteredTaskSource, TaskSourceUpdate } from "./task-source";
 import type { TaskRecordReader } from "./isolation";
 import type { CanonicalTaskLifecycleStatus, TaskStateMetadataEnvelope } from "./task-state-metadata";
 /** Result of a bounded artifact-file read (preview + truncation metadata). */
@@ -88,7 +89,6 @@ export type ReadSyncedTrackerOptions = {
 export type SourceAwareTaskConfigReadOptions = {
     readonly configPath?: string;
     readonly ghBinary?: string;
-    readonly allowLocalTaskConfigStatusFallback?: boolean;
 };
 /** Result of resolving a single task through the configured task source. */
 export type TaskSourceTaskReadResult = {
@@ -112,14 +112,13 @@ export type SourceTaskIdentity = {
     sourceIssueId?: unknown;
     source_issue_id?: unknown;
 };
-/** Result of pushing a task lifecycle update through the configured source. */
-export type TaskSourceLifecycleUpdateResult = {
+/** Result of pushing an explicit source writeback through the configured source. */
+export type TaskSourceWritebackResult = {
     taskId: string;
     updated: boolean;
-    source: "plugin" | "compat" | "none" | "server";
+    source: "plugin" | "none";
     sourceKind: string | null;
     status: unknown;
-    projectSync?: unknown;
 };
 /** Context for building a plugin-backed task-record reader. */
 export type PluginTaskRecordReaderContext = {
@@ -179,14 +178,13 @@ export interface TaskDataService {
         taskId: string;
         sourceTask?: SourceTaskIdentity | null;
         update: TaskSourceUpdate;
-    }): Promise<TaskSourceLifecycleUpdateResult>;
+    }): Promise<TaskSourceWritebackResult>;
     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 legacy id string for the TASK_DATA compatibility facade. */

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

@@ -1,26 +1,7 @@
 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. Read/normalize/local-state policy is intentionally
- * outside this contract and belongs to the plugin that provides that domain.
- */
-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;
-};
+import type { TaskConfigEntry } from "./task-config";
+export type { TaskConfigEntry } from "./task-config";
 /**
  * A single task record returned by a task source adapter.
  * Open-ended to allow adapters to include source-specific fields.
@@ -70,8 +51,6 @@ export interface TaskSourceProjectedUpdate {
 }
 /** Generic provider-owned source update payload. */
 export interface TaskSourceUpdate extends TaskSourceProjectedUpdate {
-    /** @deprecated Prefer explicit projected update fields for source writeback. */
-    status?: TaskRecord["status"];
     title?: string;
     body?: string;
     comment?: string;
@@ -92,12 +71,16 @@ export type TaskSourceUpdateRequest = {
     readonly sourceKind?: string | null;
     readonly update: TaskSourceUpdate;
 };
+export type TaskSourceUpdateWriteResult = "applied" | "not-configured" | "unsupported";
 export type TaskSourceUpdateResult = {
     readonly taskId: string;
     readonly updated: boolean;
+    /** Authoritative source write outcome. `updated` is retained as a boolean compatibility projection. */
+    readonly writeResult: TaskSourceUpdateWriteResult;
     readonly sourceId?: string | null;
     readonly sourceKind?: string | null;
-    readonly result?: unknown;
+    /** Best-effort status read back from the source after the write; absent/null when the adapter cannot read back. */
+    readonly sourceStatus?: unknown;
 };
 /**
  * Generic source-adapter writeback port. The legacy id string is retained, but
@@ -108,12 +91,37 @@ export type TaskSourceUpdateResult = {
 export interface TaskSourceUpdateService {
     updateTask(input: TaskSourceUpdateRequest): Promise<TaskSourceUpdateResult>;
 }
+/**
+ * Synchronous projection seam for task-source-owned task config materialization.
+ *
+ * The service owns source adapter/config-path semantics (for example files-backed
+ * task directories and source task-config locations) while legacy sync state-store
+ * callers keep the existing `TaskStateStoreService` surface.
+ */
+export interface TaskSourceConfigProjectionService {
+    /** Resolve the sync TaskStateStoreService readTaskConfig path, including source-owned fallback paths. */
+    resolveTaskConfigPath(projectRoot: string): string;
+    readSourceTaskConfig(projectRoot: string): Record<string, TaskConfigEntry>;
+    writeSourceTaskConfig(projectRoot: string, entries: Record<string, TaskConfigEntry>): void;
+    readSourceValidationDescriptions(projectRoot: string): Record<string, string>;
+}
+export declare const TASK_SOURCE_CONFIG_PROJECTION_CAPABILITY_ID = "task-sources.config-projection";
+export declare const TASK_SOURCE_CONFIG_PROJECTION: CapabilityId<TaskSourceConfigProjectionService>;
+export type TaskTerminalStateInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+};
+/** Source-owned task terminal-state projection, including source config and Beads fallback. */
+export interface TaskSourceTerminalStateService {
+    isTaskTerminal(input: TaskTerminalStateInput): Promise<boolean>;
+}
+export declare const TASK_SOURCE_TERMINAL_STATE_CAPABILITY_ID = "task-sources.terminal-state";
+export declare const TASK_SOURCE_TERMINAL_STATE: CapabilityId<TaskSourceTerminalStateService>;
 export declare const TASK_SOURCE_UPDATE_CAPABILITY_ID = "task-sources.update";
 export declare const TASK_SOURCE_UPDATE: CapabilityId<TaskSourceUpdateService>;
 export interface RegisteredTaskSource extends TaskSourceRegistration {
     list(): Promise<readonly TaskRecord[]>;
     get?(id: string): Promise<TaskRecord | undefined>;
-    updateStatus?(id: string, status: TaskRecord["status"]): Promise<void>;
     updateTask?(id: string, update: TaskSourceUpdate): Promise<void>;
     create?(input: TaskSourceCreateInput): Promise<TaskSourceCreateResult>;
 }
@@ -122,15 +130,38 @@ export type TaskIoCreateResult = {
     readonly source: string;
     readonly result: unknown;
 };
+export type TaskFactRecordInput = {
+    readonly type: "decision" | "failure";
+    readonly text: string;
+    readonly taskId?: string;
+};
+export type TaskFactRecordResult = {
+    readonly taskId: string;
+    readonly message: string;
+};
+export type TaskArtifactsPrepareResult = {
+    readonly taskId: string;
+    readonly artifactDir: string;
+    readonly message: string;
+};
+export type TaskIoStateFilter = "open" | "closed";
+export interface TaskIoListFilters {
+    readonly assignee?: string;
+    readonly state?: TaskIoStateFilter;
+    readonly limit?: number;
+    readonly search?: string;
+}
 /**
  * Normalized task IO projection seam. The historical id string is retained for
  * compatibility, but this capability is owned/provided by @rig/task-io-plugin;
  * source-adapter plugins should contribute adapters and source writeback only.
  */
 export interface TaskIoService {
-    listTasks(projectRoot: string): Promise<readonly RigTask[]>;
+    listTasks(projectRoot: string, filters?: TaskIoListFilters): Promise<readonly RigTask[]>;
     getTask(projectRoot: string, taskId: string): Promise<RigTask | null>;
     createTask(projectRoot: string, task: Record<string, unknown>): Promise<TaskIoCreateResult>;
+    recordTaskFact(projectRoot: string, input: TaskFactRecordInput): Promise<TaskFactRecordResult>;
+    prepareTaskArtifacts(projectRoot: string, taskId?: string): Promise<TaskArtifactsPrepareResult>;
 }
-export declare const TASK_IO_SERVICE_CAPABILITY_ID = "task-sources.task-io";
+export declare const TASK_IO_SERVICE_CAPABILITY_ID = "rig.tasks.io";
 export declare const TASK_IO_SERVICE_CAPABILITY: CapabilityId<TaskIoService>;

package/dist/src/task-source.js

@@ -5,13 +5,21 @@ function makeCapabilityId(id) {
 }
 
 // packages/contracts/src/task-source.ts
+var TASK_SOURCE_CONFIG_PROJECTION_CAPABILITY_ID = "task-sources.config-projection";
+var TASK_SOURCE_CONFIG_PROJECTION = makeCapabilityId(TASK_SOURCE_CONFIG_PROJECTION_CAPABILITY_ID);
+var TASK_SOURCE_TERMINAL_STATE_CAPABILITY_ID = "task-sources.terminal-state";
+var TASK_SOURCE_TERMINAL_STATE = makeCapabilityId(TASK_SOURCE_TERMINAL_STATE_CAPABILITY_ID);
 var TASK_SOURCE_UPDATE_CAPABILITY_ID = "task-sources.update";
 var TASK_SOURCE_UPDATE = makeCapabilityId(TASK_SOURCE_UPDATE_CAPABILITY_ID);
-var TASK_IO_SERVICE_CAPABILITY_ID = "task-sources.task-io";
+var TASK_IO_SERVICE_CAPABILITY_ID = "rig.tasks.io";
 var TASK_IO_SERVICE_CAPABILITY = makeCapabilityId(TASK_IO_SERVICE_CAPABILITY_ID);
 export {
   TASK_SOURCE_UPDATE_CAPABILITY_ID,
   TASK_SOURCE_UPDATE,
+  TASK_SOURCE_TERMINAL_STATE_CAPABILITY_ID,
+  TASK_SOURCE_TERMINAL_STATE,
+  TASK_SOURCE_CONFIG_PROJECTION_CAPABILITY_ID,
+  TASK_SOURCE_CONFIG_PROJECTION,
   TASK_IO_SERVICE_CAPABILITY_ID,
   TASK_IO_SERVICE_CAPABILITY
 };

package/dist/src/task-state-paths.d.ts

@@ -0,0 +1,14 @@
+import type { CapabilityId } from "./capability-id";
+/** Task-state-owned local path layout for task config/session/artifacts/metadata files. */
+export interface TaskStatePaths {
+    readonly stateDir: string;
+    readonly artifactsDir: string;
+    readonly taskConfigPath: string;
+    readonly sessionPath: string;
+    readonly failedApproachesPath: string;
+}
+export interface TaskStatePathsService {
+    resolvePaths(projectRoot: string): TaskStatePaths;
+}
+export declare const TASK_STATE_PATHS_CAPABILITY_ID = "task-state.paths";
+export declare const TASK_STATE_PATHS: CapabilityId<TaskStatePathsService>;

package/dist/src/task-state-paths.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-state-paths.ts
+var TASK_STATE_PATHS_CAPABILITY_ID = "task-state.paths";
+var TASK_STATE_PATHS = makeCapabilityId(TASK_STATE_PATHS_CAPABILITY_ID);
+export {
+  TASK_STATE_PATHS_CAPABILITY_ID,
+  TASK_STATE_PATHS
+};