@h-rig/contracts 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/task-source.js

@@ -1 +1,13 @@
 // @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-source.ts
+var TASK_IO_SERVICE_CAPABILITY_ID = "task-sources.task-io";
+var TASK_IO_SERVICE_CAPABILITY = makeCapabilityId(TASK_IO_SERVICE_CAPABILITY_ID);
+export {
+  TASK_IO_SERVICE_CAPABILITY_ID,
+  TASK_IO_SERVICE_CAPABILITY
+};

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

@@ -0,0 +1,21 @@
+export type CanonicalTaskLifecycleStatus = "draft" | "open" | "ready" | "queued" | "in_progress" | "under_review" | "blocked" | "completed" | "cancelled";
+export type TaskStateMetadata = {
+    claimId?: string;
+    status: CanonicalTaskLifecycleStatus;
+    ownerId?: string;
+    claimedAt?: string;
+    lastEvidenceAt?: string;
+    runId?: string;
+    branchName?: string;
+    prNumber?: number;
+    prUrl?: string;
+    reviewState?: string;
+    blockerReason?: string;
+    sourceCommit?: string;
+};
+export type TaskStateMetadataEnvelope = {
+    schemaVersion: number;
+    supported: boolean;
+    baseTrackerCommit: string | null;
+    tasks: Record<string, TaskStateMetadata>;
+};

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

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

package/dist/src/tool-materializer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tool-materializer capability seam.
+ *
+ * Defines the TOOL_MATERIALIZER service port that @rig/isolation-plugin
+ * consumes to build the runtime tool binaries (tool gateway, file tools,
+ * claude router, browser tools) without importing @rig/provider-plugin impl
+ * files directly. @rig/provider-plugin provides the capability; isolation-plugin
+ * resolves it via requireInstalledCapability — the SEAM-ONLY replacement for
+ * the four cross-plugin impl imports (§6.4).
+ *
+ * Pure: types + one branded id, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * The tool-materializer service: builds provider-plugin-owned runtime tool
+ * binaries into the given bin directory.
+ */
+export interface ToolMaterializerService {
+    /** Materialize the runtime tool gateway binary. Returns the path. */
+    materializeRuntimeToolGateway(binDir: string): Promise<string>;
+    /** Materialize the runtime file-tools binary. Returns the path. */
+    materializeRuntimeFileTools(targetDir: string): Promise<string>;
+    /** Materialize the Claude tool-router binary. Returns the path. */
+    materializeClaudeToolRouterBinary(projectRoot: string, targetDir: string): Promise<string>;
+    /** Materialize the runtime browser-tools binary. Returns the path. */
+    materializeRuntimeBrowserTools(targetDir: string): Promise<string>;
+    /** Synchronously resolve the runtime browser-tool binary name. */
+    runtimeBrowserToolBinaryName(): string;
+}
+/** Stable id string for the tool-materializer service capability. */
+export declare const TOOL_MATERIALIZER_CAPABILITY_ID = "provider.tool-materializer";
+/**
+ * The branded tool-materializer capability id. `defineCapability(TOOL_MATERIALIZER)`
+ * (provider and consumers independently) resolves to a `ToolMaterializerService`.
+ */
+export declare const TOOL_MATERIALIZER: CapabilityId<ToolMaterializerService>;

package/dist/src/tool-materializer.js

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

package/dist/src/tool-registry.d.ts

@@ -0,0 +1,3 @@
+export declare const RUNTIME_SHELL_TOOL_NAMES: readonly string[];
+export declare const RUNTIME_FILE_TOOL_NAMES: readonly string[];
+export declare const RUNTIME_BROWSER_TOOL_NAMES: readonly string[];

package/dist/src/tool-registry.js

@@ -0,0 +1,58 @@
+// @bun
+// packages/contracts/src/tool-registry.ts
+var RUNTIME_SHELL_TOOL_NAMES = [
+  "bash",
+  "sh",
+  "zsh",
+  "git",
+  "bun",
+  "node",
+  "python3",
+  "rg",
+  "grep",
+  "sed",
+  "cat",
+  "ls",
+  "find",
+  "tsc",
+  "gh",
+  "mkdir",
+  "rm",
+  "mv",
+  "cp",
+  "touch",
+  "pwd",
+  "head",
+  "tail",
+  "wc",
+  "sort",
+  "uniq",
+  "awk",
+  "xargs",
+  "dirname",
+  "basename",
+  "realpath",
+  "env",
+  "jq",
+  "tee",
+  "which"
+];
+var RUNTIME_FILE_TOOL_NAMES = [
+  "rig-read",
+  "rig-write",
+  "rig-edit",
+  "rig-glob",
+  "rig-grep"
+];
+var RUNTIME_BROWSER_TOOL_NAMES = [
+  "rig-browser-launch",
+  "rig-browser-check",
+  "rig-browser-attach-info",
+  "rig-browser-e2e",
+  "rig-browser-reset-profile"
+];
+export {
+  RUNTIME_SHELL_TOOL_NAMES,
+  RUNTIME_FILE_TOOL_NAMES,
+  RUNTIME_BROWSER_TOOL_NAMES
+};

package/dist/src/toolchain-sources.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Toolchain-source contribution seam.
+ *
+ * @rig/isolation-plugin's runtime toolchain materializes per-run hook binaries
+ * (guard hooks, lifecycle hooks) and standalone helper binaries (controlled-bash)
+ * by compiling SOURCE files owned by OTHER plugins. Hardcoding those sibling
+ * `packages/<plugin>/src/...` paths inside the toolchain couples it to every
+ * owning plugin's file layout (and trips the rule-8b arch invariant).
+ *
+ * Instead, each owning plugin CONTRIBUTES its build sources as DATA through a
+ * typed capability id, and the toolchain RESOLVES them off the project's plugin
+ * host. Each contributor owns a DISTINCT capability id (the plugin host enforces
+ * one-provider-per-id, so the two contributors cannot share a single id) — the
+ * toolchain merges the contributions it finds.
+ *
+ * Pure: types + branded ids, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * One per-run hook binary build spec: the binary NAME (the basename the runtime
+ * dispatches by) and its `source` entrypoint, expressed RELATIVE to the rig
+ * source root (the same string the toolchain feeds to `buildBinary`).
+ */
+export interface ToolchainHookBinarySource {
+    readonly name: string;
+    readonly source: string;
+}
+/**
+ * A plugin's contribution of runtime-toolchain build sources.
+ *
+ * - `hookBinaries` are compiled uniformly into the runtime `hooks/` directory
+ *   with the shared hook defines.
+ * - `namedSources` are standalone source paths the toolchain compiles with its
+ *   own per-binary defines, keyed by a stable build id (e.g. `"controlled-bash"`).
+ *
+ * All paths are RELATIVE to the rig source root (unchanged from the literals the
+ * toolchain previously embedded), so resolution behaviour is identical.
+ */
+export interface ToolchainSourceContribution {
+    readonly hookBinaries?: ReadonlyArray<ToolchainHookBinarySource>;
+    readonly namedSources?: Readonly<Record<string, string>>;
+}
+/** Stable id for @rig/guard-plugin's toolchain-source contribution. */
+export declare const GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+/** Stable id for @rig/bundle-default-lifecycle's toolchain-source contribution. */
+export declare const LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+/**
+ * The guard-plugin toolchain-source capability id. `defineCapability(...)` (the
+ * provider and the isolation-plugin consumer construct it independently from the
+ * shared id) resolves to a `ToolchainSourceContribution`.
+ */
+export declare const GUARD_TOOLCHAIN_SOURCES: CapabilityId<ToolchainSourceContribution>;
+/** The bundle-default-lifecycle toolchain-source capability id. */
+export declare const LIFECYCLE_TOOLCHAIN_SOURCES: CapabilityId<ToolchainSourceContribution>;

package/dist/src/toolchain-sources.js

@@ -0,0 +1,17 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/toolchain-sources.ts
+var GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
+var LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
+var GUARD_TOOLCHAIN_SOURCES = makeCapabilityId(GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+var LIFECYCLE_TOOLCHAIN_SOURCES = makeCapabilityId(LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+export {
+  LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  LIFECYCLE_TOOLCHAIN_SOURCES,
+  GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID,
+  GUARD_TOOLCHAIN_SOURCES
+};

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

@@ -76,36 +76,6 @@ export type RigWorkflowCustomEntry = {
     customType?: string;
     data?: unknown;
 };
-export declare function createWorkflowStarted(input: Omit<RigWorkflowStarted, "schemaVersion" | "createdAt"> & {
-    createdAt?: string;
-}): RigWorkflowStarted;
-export declare function createWorkflowTargetSelected(input: Omit<RigWorkflowTargetSelected, "schemaVersion" | "selectedAt"> & {
-    selectedAt?: string;
-}): RigWorkflowTargetSelected;
-export declare function createWorkflowTaskSelected(input: Omit<RigWorkflowTaskSelected, "schemaVersion" | "selectedAt"> & {
-    selectedAt?: string;
-}): RigWorkflowTaskSelected;
-export declare function createWorkflowStatusChanged(input: Omit<RigWorkflowStatusChanged, "schemaVersion" | "changedAt"> & {
-    changedAt?: string;
-}): RigWorkflowStatusChanged;
-export declare function createWorkflowOperatorNote(input: Omit<RigWorkflowOperatorNote, "schemaVersion" | "notedAt"> & {
-    notedAt?: string;
-}): RigWorkflowOperatorNote;
-export declare function createWorkflowInboxRequested(input: Omit<RigWorkflowInboxRequested, "schemaVersion" | "requestedAt"> & {
-    requestedAt?: string;
-}): RigWorkflowInboxRequested;
-export declare function createWorkflowInboxResolved(input: Omit<RigWorkflowInboxResolved, "schemaVersion" | "resolvedAt"> & {
-    resolvedAt?: string;
-}): RigWorkflowInboxResolved;
-export declare function parseWorkflowStarted(data: unknown): RigWorkflowStarted | null;
-export declare function parseWorkflowTargetSelected(data: unknown): RigWorkflowTargetSelected | null;
-export declare function parseWorkflowTaskSelected(data: unknown): RigWorkflowTaskSelected | null;
-export declare function parseWorkflowStatusChanged(data: unknown): RigWorkflowStatusChanged | null;
-export declare function parseWorkflowOperatorNote(data: unknown): RigWorkflowOperatorNote | null;
-export declare function parseWorkflowInboxRequested(data: unknown): RigWorkflowInboxRequested | null;
-export declare function parseWorkflowInboxResolved(data: unknown): RigWorkflowInboxResolved | null;
-export declare function collectPendingInboxRequests(entries: readonly RigWorkflowCustomEntry[]): RigWorkflowInboxRequested[];
-export declare function collectResolvedInboxRequests(entries: readonly RigWorkflowCustomEntry[]): RigWorkflowInboxResolved[];
 export type RigCollabWorkflowMarkerInput = {
     sessionId: string;
     sessionPath: string;
@@ -120,5 +90,3 @@ export type RigCollabWorkflowMarkerInput = {
     updatedAt: string;
     stale: boolean;
 };
-export declare function projectCollabWorkflowMarker(collab: RigCollabWorkflowMarkerInput): RigWorkflowProjection;
-export declare function projectWorkflowEntries(entries: readonly RigWorkflowCustomEntry[]): RigWorkflowProjection;

package/dist/src/workflow-journal.js

@@ -7,378 +7,7 @@ var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
 var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
 var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
 var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
-var EMPTY_PROJECTION = {
-  started: null,
-  target: null,
-  task: null,
-  status: null,
-  notes: [],
-  inbox: [],
-  resolvedInbox: [],
-  updatedAt: null
-};
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function optionalString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function requiredString(value) {
-  const text = optionalString(value);
-  return text ?? null;
-}
-function timestamp(value) {
-  const text = requiredString(value);
-  if (!text)
-    return null;
-  const millis = Date.parse(text);
-  return Number.isFinite(millis) ? text : null;
-}
-function newer(left, right) {
-  if (!right)
-    return false;
-  if (!left)
-    return true;
-  return Date.parse(right) >= Date.parse(left);
-}
-function isWorkflowTarget(value) {
-  return value === "local" || value === "remote";
-}
-function isWorkflowStatus(value) {
-  return value === "starting" || value === "running" || value === "waiting-approval" || value === "waiting-input" || value === "completed" || value === "failed" || value === "stopped";
-}
-function isInboxKind(value) {
-  return value === "approval" || value === "input";
-}
-function isInboxDecision(value) {
-  return value === "approved" || value === "rejected" || value === "answered";
-}
-function parseOwner(value) {
-  const record = asRecord(value);
-  if (!record)
-    return null;
-  const githubUserId = requiredString(record.githubUserId);
-  const login = requiredString(record.login);
-  const namespaceKey = requiredString(record.namespaceKey);
-  return githubUserId && login && namespaceKey ? { githubUserId, login, namespaceKey } : null;
-}
-function parseStringArray(value) {
-  if (!Array.isArray(value))
-    return;
-  const options = value.map(optionalString).filter((option) => option !== undefined);
-  return options.length > 0 ? options : undefined;
-}
-function hasOwn(record, key) {
-  return Object.prototype.hasOwnProperty.call(record, key);
-}
-function entryUpdatedAt(entry) {
-  if ("createdAt" in entry)
-    return entry.createdAt;
-  if ("selectedAt" in entry)
-    return entry.selectedAt;
-  if ("changedAt" in entry)
-    return entry.changedAt;
-  if ("notedAt" in entry)
-    return entry.notedAt;
-  if ("requestedAt" in entry)
-    return entry.requestedAt;
-  return entry.resolvedAt;
-}
-function createWorkflowStarted(input) {
-  return {
-    schemaVersion: 1,
-    workflowId: input.workflowId,
-    target: input.target,
-    selectedRepo: input.selectedRepo,
-    owner: input.owner,
-    createdAt: input.createdAt ?? new Date().toISOString()
-  };
-}
-function createWorkflowTargetSelected(input) {
-  return {
-    schemaVersion: 1,
-    target: input.target,
-    ...input.reason ? { reason: input.reason } : {},
-    selectedAt: input.selectedAt ?? new Date().toISOString()
-  };
-}
-function createWorkflowTaskSelected(input) {
-  return {
-    schemaVersion: 1,
-    taskId: input.taskId,
-    ...input.title ? { title: input.title } : {},
-    selectedAt: input.selectedAt ?? new Date().toISOString()
-  };
-}
-function createWorkflowStatusChanged(input) {
-  return {
-    schemaVersion: 1,
-    status: input.status,
-    ...input.detail ? { detail: input.detail } : {},
-    changedAt: input.changedAt ?? new Date().toISOString()
-  };
-}
-function createWorkflowOperatorNote(input) {
-  return {
-    schemaVersion: 1,
-    ...input.noteId ? { noteId: input.noteId } : {},
-    note: input.note,
-    notedAt: input.notedAt ?? new Date().toISOString()
-  };
-}
-function createWorkflowInboxRequested(input) {
-  return {
-    schemaVersion: 1,
-    requestId: input.requestId,
-    kind: input.kind,
-    title: input.title,
-    ...input.body ? { body: input.body } : {},
-    ...input.options && input.options.length > 0 ? { options: input.options } : {},
-    requestedAt: input.requestedAt ?? new Date().toISOString()
-  };
-}
-function createWorkflowInboxResolved(input) {
-  const base = {
-    schemaVersion: 1,
-    requestId: input.requestId,
-    decision: input.decision,
-    resolvedAt: input.resolvedAt ?? new Date().toISOString()
-  };
-  return hasOwn(input, "answer") ? { ...base, answer: input.answer } : base;
-}
-function parseWorkflowStarted(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const workflowId = requiredString(record.workflowId);
-  const target = optionalString(record.target);
-  const selectedRepo = requiredString(record.selectedRepo);
-  const owner = parseOwner(record.owner);
-  const createdAt = timestamp(record.createdAt);
-  if (!workflowId || !isWorkflowTarget(target) || !selectedRepo || !owner || !createdAt)
-    return null;
-  return {
-    schemaVersion: 1,
-    workflowId,
-    target,
-    selectedRepo,
-    owner,
-    createdAt
-  };
-}
-function parseWorkflowTargetSelected(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const target = optionalString(record.target);
-  const selectedAt = timestamp(record.selectedAt);
-  if (!isWorkflowTarget(target) || !selectedAt)
-    return null;
-  const reason = optionalString(record.reason);
-  return {
-    schemaVersion: 1,
-    target,
-    ...reason ? { reason } : {},
-    selectedAt
-  };
-}
-function parseWorkflowTaskSelected(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const taskId = requiredString(record.taskId);
-  const selectedAt = timestamp(record.selectedAt);
-  if (!taskId || !selectedAt)
-    return null;
-  const title = optionalString(record.title);
-  return { schemaVersion: 1, taskId, ...title ? { title } : {}, selectedAt };
-}
-function parseWorkflowStatusChanged(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const status = optionalString(record.status);
-  const changedAt = timestamp(record.changedAt);
-  if (!changedAt || !isWorkflowStatus(status))
-    return null;
-  const detail = optionalString(record.detail);
-  return { schemaVersion: 1, status, ...detail ? { detail } : {}, changedAt };
-}
-function parseWorkflowOperatorNote(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const note = requiredString(record.note);
-  const notedAt = timestamp(record.notedAt);
-  if (!note || !notedAt)
-    return null;
-  const noteId = optionalString(record.noteId);
-  return { schemaVersion: 1, ...noteId ? { noteId } : {}, note, notedAt };
-}
-function parseWorkflowInboxRequested(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const requestId = requiredString(record.requestId);
-  const kind = optionalString(record.kind);
-  const title = requiredString(record.title);
-  const requestedAt = timestamp(record.requestedAt);
-  if (!requestId || !isInboxKind(kind) || !title || !requestedAt)
-    return null;
-  const body = optionalString(record.body);
-  const options = parseStringArray(record.options);
-  return {
-    schemaVersion: 1,
-    requestId,
-    kind,
-    title,
-    ...body ? { body } : {},
-    ...options ? { options } : {},
-    requestedAt
-  };
-}
-function parseWorkflowInboxResolved(data) {
-  const record = asRecord(data);
-  if (!record || record.schemaVersion !== 1)
-    return null;
-  const requestId = requiredString(record.requestId);
-  const decision = optionalString(record.decision);
-  const resolvedAt = timestamp(record.resolvedAt);
-  if (!requestId || !isInboxDecision(decision) || !resolvedAt)
-    return null;
-  const base = { schemaVersion: 1, requestId, decision, resolvedAt };
-  return hasOwn(record, "answer") ? { ...base, answer: record.answer } : base;
-}
-function collectPendingInboxRequests(entries) {
-  const requested = new Map;
-  const resolved = new Map;
-  for (const entry of entries) {
-    if (entry.type !== "custom")
-      continue;
-    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
-      const request = parseWorkflowInboxRequested(entry.data);
-      if (request && newer(requested.get(request.requestId)?.requestedAt, request.requestedAt))
-        requested.set(request.requestId, request);
-    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
-      const resolution = parseWorkflowInboxResolved(entry.data);
-      if (resolution && newer(resolved.get(resolution.requestId), resolution.resolvedAt))
-        resolved.set(resolution.requestId, resolution.resolvedAt);
-    }
-  }
-  for (const [requestId, request] of requested) {
-    const resolvedAt = resolved.get(requestId);
-    if (resolvedAt && Date.parse(resolvedAt) >= Date.parse(request.requestedAt))
-      requested.delete(requestId);
-  }
-  return Array.from(requested.values()).sort((a, b) => Date.parse(b.requestedAt) - Date.parse(a.requestedAt));
-}
-function collectResolvedInboxRequests(entries) {
-  const requested = new Map;
-  const resolved = new Map;
-  for (const entry of entries) {
-    if (entry.type !== "custom")
-      continue;
-    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
-      const request = parseWorkflowInboxRequested(entry.data);
-      if (request && newer(requested.get(request.requestId), request.requestedAt))
-        requested.set(request.requestId, request.requestedAt);
-    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
-      const resolution = parseWorkflowInboxResolved(entry.data);
-      if (resolution && newer(resolved.get(resolution.requestId)?.resolvedAt, resolution.resolvedAt)) {
-        resolved.set(resolution.requestId, resolution);
-      }
-    }
-  }
-  for (const [requestId, resolution] of resolved) {
-    const requestedAt = requested.get(requestId);
-    if (requestedAt && Date.parse(requestedAt) > Date.parse(resolution.resolvedAt))
-      resolved.delete(requestId);
-  }
-  return Array.from(resolved.values()).sort((a, b) => Date.parse(b.resolvedAt) - Date.parse(a.resolvedAt));
-}
-function projectCollabWorkflowMarker(collab) {
-  const status = createWorkflowStatusChanged({
-    status: collab.stale ? "stopped" : "running",
-    detail: collab.stale ? "Stale OMP collab session discovered from the sanctioned collab registry." : "Live OMP collab session discovered from the sanctioned collab registry.",
-    changedAt: collab.updatedAt
-  });
-  return {
-    started: null,
-    target: null,
-    task: null,
-    status,
-    notes: [],
-    inbox: [],
-    resolvedInbox: [],
-    updatedAt: newer(collab.startedAt, collab.updatedAt) ? collab.updatedAt : collab.startedAt
-  };
-}
-function projectWorkflowEntries(entries) {
-  let started = null;
-  let target = null;
-  let task = null;
-  let status = null;
-  const notes = [];
-  let updatedAt = null;
-  for (const entry of entries) {
-    if (entry.type !== "custom")
-      continue;
-    if (entry.customType === RIG_WORKFLOW_STARTED) {
-      const parsed = parseWorkflowStarted(entry.data);
-      if (parsed && newer(started?.createdAt, parsed.createdAt))
-        started = parsed;
-    } else if (entry.customType === RIG_WORKFLOW_TARGET_SELECTED) {
-      const parsed = parseWorkflowTargetSelected(entry.data);
-      if (parsed && newer(target?.selectedAt, parsed.selectedAt))
-        target = parsed;
-    } else if (entry.customType === RIG_WORKFLOW_TASK_SELECTED) {
-      const parsed = parseWorkflowTaskSelected(entry.data);
-      if (parsed && newer(task?.selectedAt, parsed.selectedAt))
-        task = parsed;
-    } else if (entry.customType === RIG_WORKFLOW_STATUS_CHANGED) {
-      const parsed = parseWorkflowStatusChanged(entry.data);
-      if (parsed && newer(status?.changedAt, parsed.changedAt))
-        status = parsed;
-    } else if (entry.customType === RIG_WORKFLOW_OPERATOR_NOTE) {
-      const parsed = parseWorkflowOperatorNote(entry.data);
-      if (parsed)
-        notes.push(parsed);
-    }
-  }
-  notes.sort((a, b) => Date.parse(b.notedAt) - Date.parse(a.notedAt));
-  for (const value of [started, target, task, status, ...notes].map((entry) => entry ? entryUpdatedAt(entry) : null)) {
-    if (newer(updatedAt, value))
-      updatedAt = value;
-  }
-  const inbox = collectPendingInboxRequests(entries);
-  const resolvedInbox = collectResolvedInboxRequests(entries);
-  for (const entry of [...inbox, ...resolvedInbox]) {
-    if (newer(updatedAt, entryUpdatedAt(entry)))
-      updatedAt = entryUpdatedAt(entry);
-  }
-  if (!started && !target && !task && !status && notes.length === 0 && inbox.length === 0 && resolvedInbox.length === 0 && !updatedAt)
-    return EMPTY_PROJECTION;
-  return { started, target, task, status, notes, inbox, resolvedInbox, updatedAt };
-}
 export {
-  projectWorkflowEntries,
-  projectCollabWorkflowMarker,
-  parseWorkflowTaskSelected,
-  parseWorkflowTargetSelected,
-  parseWorkflowStatusChanged,
-  parseWorkflowStarted,
-  parseWorkflowOperatorNote,
-  parseWorkflowInboxResolved,
-  parseWorkflowInboxRequested,
-  createWorkflowTaskSelected,
-  createWorkflowTargetSelected,
-  createWorkflowStatusChanged,
-  createWorkflowStarted,
-  createWorkflowOperatorNote,
-  createWorkflowInboxResolved,
-  createWorkflowInboxRequested,
-  collectResolvedInboxRequests,
-  collectPendingInboxRequests,
   RIG_WORKFLOW_TASK_SELECTED,
   RIG_WORKFLOW_TARGET_SELECTED,
   RIG_WORKFLOW_STATUS_CHANGED,

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

@@ -0,0 +1,18 @@
+import type { CapabilityId } from "./capability-id";
+export type EnsureDeclarativeConfigInput = {
+    readonly projectRoot: string;
+    readonly repoSlug?: string;
+};
+export type EnsureDeclarativeConfigResult = {
+    /** True when this call wrote a new `.rig/rigfig.toml`. */
+    readonly created: boolean;
+    /** The rigfig path when one now exists (created or pre-existing), else null. */
+    readonly path: string | null;
+    /** Why nothing was created (code config present, no plugin produced a config, …). */
+    readonly reason?: string;
+};
+export interface WorkspaceConfigEnsureService {
+    ensureDeclarativeConfig(input: EnsureDeclarativeConfigInput): EnsureDeclarativeConfigResult;
+}
+export declare const WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+export declare const WORKSPACE_CONFIG_ENSURE: CapabilityId<WorkspaceConfigEnsureService>;

package/dist/src/workspace-config.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/workspace-config.ts
+var WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID = "workspace.config.ensure";
+var WORKSPACE_CONFIG_ENSURE = makeCapabilityId(WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID);
+export {
+  WORKSPACE_CONFIG_ENSURE_CAPABILITY_ID,
+  WORKSPACE_CONFIG_ENSURE
+};