@h-rig/contracts 0.0.6-alpha.9 → 0.0.6-alpha.91

package/dist/src/run-status.d.ts

@@ -0,0 +1,12 @@
+/** Operator-facing active-run classification.
+ *
+ * The canonical run-journal vocabulary intentionally keeps `needs-attention` as
+ * non-terminal so resume/steer/closeout state machines can still act on it.
+ * OpenTUI/task projections need a narrower meaning: only runs that are actively
+ * occupying a task slot should render as the task's active run. Legacy/closeout
+ * statuses from older authority files are treated conservatively as inactive so
+ * merged/closed runs do not pin task rows forever.
+ */
+export declare const OPERATOR_INACTIVE_RUN_STATUSES: ReadonlySet<string>;
+export declare function normalizeRunStatusToken(status: unknown): string;
+export declare function isOperatorActiveRunStatus(status: unknown): boolean;

package/dist/src/run-status.js

@@ -0,0 +1,38 @@
+// @bun
+// packages/contracts/src/run-status.ts
+var OPERATOR_INACTIVE_RUN_STATUSES = new Set([
+  "completed",
+  "complete",
+  "done",
+  "success",
+  "succeeded",
+  "passed",
+  "failed",
+  "failure",
+  "error",
+  "errored",
+  "stopped",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "abort",
+  "merged",
+  "closed",
+  "skipped",
+  "needs-attention",
+  "needs_attention"
+]);
+function normalizeRunStatusToken(status) {
+  return String(status ?? "").trim().toLowerCase().replace(/\s+/g, "-");
+}
+function isOperatorActiveRunStatus(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (!normalized)
+    return false;
+  return !OPERATOR_INACTIVE_RUN_STATUSES.has(normalized);
+}
+export {
+  normalizeRunStatusToken,
+  isOperatorActiveRunStatus,
+  OPERATOR_INACTIVE_RUN_STATUSES
+};

package/dist/src/runtime.d.ts

@@ -0,0 +1,103 @@
+import { Schema } from "effect";
+export declare const RunKind: Schema.Literals<readonly ["adhoc", "task", "batch", "validation", "review"]>;
+export type RunKind = typeof RunKind.Type;
+export declare const RunMode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+export type RunMode = typeof RunMode.Type;
+export declare const RunStatus: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+export type RunStatus = typeof RunStatus.Type;
+export declare const EngineSandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+export type EngineSandboxMode = typeof EngineSandboxMode.Type;
+export declare const IsolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+export type IsolationMode = typeof IsolationMode.Type;
+export declare const RuntimeStatus: Schema.Literals<readonly ["prepared", "starting", "running", "interrupted", "exited", "failed", "destroyed"]>;
+export type RuntimeStatus = typeof RuntimeStatus.Type;
+export declare const RunExecutionTarget: Schema.Literals<readonly ["local", "remote"]>;
+export type RunExecutionTarget = typeof RunExecutionTarget.Type;
+export declare const RunSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "RunId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly title: Schema.Trim;
+    readonly runKind: Schema.Literals<readonly ["adhoc", "task", "batch", "validation", "review"]>;
+    readonly mode: Schema.Literals<readonly ["interactive", "autonomous", "supervised"]>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly interactionMode: Schema.Literals<readonly ["default", "plan"]>;
+    readonly status: Schema.Literals<readonly ["created", "queued", "preparing", "running", "waiting-approval", "waiting-user-input", "paused", "validating", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"]>;
+    readonly runtimeAdapter: Schema.Trim;
+    readonly model: Schema.NullOr<Schema.Trim>;
+    readonly initialPrompt: Schema.NullOr<Schema.String>;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly remoteLeaseId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly remoteLeaseClaimedAt: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly activeRuntimeId: Schema.NullOr<Schema.brand<Schema.Trim, "EngineRuntimeId">>;
+    readonly latestMessageId: Schema.NullOr<Schema.Trim>;
+    readonly pendingApprovalCount: Schema.Int;
+    readonly pendingUserInputCount: Schema.Int;
+    readonly branch: Schema.NullOr<Schema.Trim>;
+    readonly worktreePath: Schema.NullOr<Schema.Trim>;
+    readonly errorText: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly startedAt: Schema.NullOr<Schema.String>;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RunSummary = typeof RunSummary.Type;
+export declare const RuntimeSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly adapterKind: Schema.Trim;
+    readonly executionTarget: Schema.optional<Schema.Literals<readonly ["local", "remote"]>>;
+    readonly remoteHostId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly status: Schema.Literals<readonly ["prepared", "starting", "running", "interrupted", "exited", "failed", "destroyed"]>;
+    readonly sandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+    readonly isolationMode: Schema.Literals<readonly ["none", "env", "worktree"]>;
+    readonly workspaceDir: Schema.NullOr<Schema.Trim>;
+    readonly homeDir: Schema.NullOr<Schema.Trim>;
+    readonly tmpDir: Schema.NullOr<Schema.Trim>;
+    readonly cacheDir: Schema.NullOr<Schema.Trim>;
+    readonly logsDir: Schema.NullOr<Schema.Trim>;
+    readonly stateDir: Schema.NullOr<Schema.Trim>;
+    readonly sessionDir: Schema.NullOr<Schema.Trim>;
+    readonly sessionLogPath: Schema.NullOr<Schema.Trim>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly startedAt: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.String;
+    readonly exitedAt: Schema.NullOr<Schema.String>;
+}>;
+export type RuntimeSummary = typeof RuntimeSummary.Type;
+export declare const ApprovalStatus: Schema.Literals<readonly ["pending", "resolved"]>;
+export type ApprovalStatus = typeof ApprovalStatus.Type;
+export declare const ApprovalSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.NullOr<Schema.Trim>;
+    readonly requestKind: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly resolvedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ApprovalSummary = typeof ApprovalSummary.Type;
+export declare const UserInputRequestSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+    readonly payload: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly resolvedAt: Schema.NullOr<Schema.String>;
+}>;
+export type UserInputRequestSummary = typeof UserInputRequestSummary.Type;
+export declare const WorktreeSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "WorktreeId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly branchName: Schema.Trim;
+    readonly path: Schema.Trim;
+    readonly status: Schema.Trim;
+    readonly createdAt: Schema.String;
+    readonly cleanedAt: Schema.NullOr<Schema.String>;
+}>;
+export type WorktreeSummary = typeof WorktreeSummary.Type;

package/dist/src/runtime.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");
@@ -921,12 +924,14 @@ var RunStatus = Schema4.Literals([
   "running",
   "waiting-approval",
   "waiting-user-input",
+  "paused",
   "validating",
   "reviewing",
+  "closing-out",
+  "needs-attention",
   "completed",
   "failed",
-  "cancelled",
-  "paused"
+  "stopped"
 ]);
 var EngineSandboxMode = Schema4.Literals([
   "read-only",

package/dist/src/server.d.ts

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+export declare const ServerConfigIssue: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"keybindings.malformed-config">;
+    readonly message: Schema.Trim;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+    readonly message: Schema.Trim;
+    readonly index: Schema.Number;
+}>]>;
+export type ServerConfigIssue = typeof ServerConfigIssue.Type;
+export declare const ServerProviderStatusState: Schema.Literals<readonly ["ready", "warning", "error"]>;
+export type ServerProviderStatusState = typeof ServerProviderStatusState.Type;
+export declare const ServerProviderAuthStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+export type ServerProviderAuthStatus = typeof ServerProviderAuthStatus.Type;
+export declare const ServerProviderStatus: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+    readonly available: Schema.Boolean;
+    readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+    readonly checkedAt: Schema.String;
+    readonly message: Schema.optional<Schema.Trim>;
+}>;
+export type ServerProviderStatus = typeof ServerProviderStatus.Type;
+export declare const ServerConfig: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly rigRoot: Schema.NullOr<Schema.Trim>;
+    readonly keybindingsConfigPath: Schema.Trim;
+    readonly keybindings: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+        readonly shortcut: Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly metaKey: Schema.Boolean;
+            readonly ctrlKey: Schema.Boolean;
+            readonly shiftKey: Schema.Boolean;
+            readonly altKey: Schema.Boolean;
+            readonly modKey: Schema.Boolean;
+        }>;
+        readonly whenAst: Schema.optional<Schema.Schema<import("./keybindings").KeybindingWhenNode>>;
+    }>>;
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+    readonly providers: Schema.$Array<Schema.Struct<{
+        readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+        readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+        readonly available: Schema.Boolean;
+        readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+        readonly checkedAt: Schema.String;
+        readonly message: Schema.optional<Schema.Trim>;
+    }>>;
+    readonly availableEditors: Schema.$Array<Schema.Literals<("cursor" | "vscode" | "zed" | "file-manager")[]>>;
+}>;
+export type ServerConfig = typeof ServerConfig.Type;
+export declare const ServerUpsertKeybindingInput: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>;
+export type ServerUpsertKeybindingInput = typeof ServerUpsertKeybindingInput.Type;
+export declare const ServerUpsertKeybindingResult: Schema.Struct<{
+    readonly keybindings: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+        readonly shortcut: Schema.Struct<{
+            readonly key: Schema.Trim;
+            readonly metaKey: Schema.Boolean;
+            readonly ctrlKey: Schema.Boolean;
+            readonly shiftKey: Schema.Boolean;
+            readonly altKey: Schema.Boolean;
+            readonly modKey: Schema.Boolean;
+        }>;
+        readonly whenAst: Schema.optional<Schema.Schema<import("./keybindings").KeybindingWhenNode>>;
+    }>>;
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+}>;
+export type ServerUpsertKeybindingResult = typeof ServerUpsertKeybindingResult.Type;
+export declare const ServerConfigUpdatedPayload: Schema.Struct<{
+    readonly issues: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.malformed-config">;
+        readonly message: Schema.Trim;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"keybindings.invalid-entry">;
+        readonly message: Schema.Trim;
+        readonly index: Schema.Number;
+    }>]>>;
+    readonly providers: Schema.$Array<Schema.Struct<{
+        readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+        readonly status: Schema.Literals<readonly ["ready", "warning", "error"]>;
+        readonly available: Schema.Boolean;
+        readonly authStatus: Schema.Literals<readonly ["authenticated", "unauthenticated", "unknown"]>;
+        readonly checkedAt: Schema.String;
+        readonly message: Schema.optional<Schema.Trim>;
+    }>>;
+}>;
+export type ServerConfigUpdatedPayload = typeof ServerConfigUpdatedPayload.Type;

package/dist/src/server.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");

package/dist/src/serviceFabric.d.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+export declare const ServiceFabricWorkspaceInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+}>;
+export type ServiceFabricWorkspaceInput = typeof ServiceFabricWorkspaceInput.Type;
+export declare const ServiceFabricUpInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly services: Schema.optional<Schema.$Array<Schema.Trim>>;
+}>;
+export type ServiceFabricUpInput = typeof ServiceFabricUpInput.Type;
+export declare const ServiceFabricUpResult: Schema.Struct<{
+    readonly plan: Schema.Struct<{
+        readonly generatedAt: Schema.String;
+        readonly serviceCount: Schema.Number;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly absoluteRootPath: Schema.Trim;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly command: Schema.NullOr<Schema.String>;
+            readonly environment: Schema.Unknown;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>;
+    readonly state: Schema.Struct<{
+        readonly generatedAt: Schema.String;
+        readonly rootPath: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly pid: Schema.Number;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly relativeRootPath: Schema.Trim;
+            readonly logPath: Schema.Trim;
+        }>>;
+    }>;
+    readonly summary: Schema.Struct<{
+        readonly updatedAt: Schema.String;
+        readonly status: Schema.Literals<readonly ["empty", "booting", "ready", "degraded", "stopped"]>;
+        readonly serviceCount: Schema.Number;
+        readonly healthyServiceCount: Schema.Number;
+        readonly stateDir: Schema.Trim;
+        readonly services: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.Trim;
+            readonly relativeRootPath: Schema.Trim;
+            readonly mode: Schema.Literals<readonly ["stub", "process"]>;
+            readonly port: Schema.Number;
+            readonly healthcheck: Schema.Trim;
+            readonly routePrefix: Schema.NullOr<Schema.Trim>;
+            readonly status: Schema.Literals<readonly ["planned", "booting", "healthy", "degraded", "failed", "stopped"]>;
+            readonly pid: Schema.NullOr<Schema.Number>;
+            readonly logPath: Schema.NullOr<Schema.Trim>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.String>;
+    }>;
+}>;
+export type ServiceFabricUpResult = typeof ServiceFabricUpResult.Type;

package/dist/src/serviceFabric.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");

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

@@ -0,0 +1,28 @@
+import type { TaskSourceRegistration } from "./plugin";
+/**
+ * A single task record returned by a task source adapter.
+ * Open-ended to allow adapters to include source-specific fields.
+ */
+export interface TaskRecord {
+    id: string;
+    deps: readonly string[];
+    status: "ready" | "in_progress" | "closed" | "blocked" | "open" | string;
+    [extra: string]: unknown;
+}
+/**
+ * A registered task source adapter — combines the plugin-level registration
+ * metadata with the runtime-callable interface.
+ */
+export interface TaskSourceUpdate {
+    status?: TaskRecord["status"];
+    title?: string;
+    body?: string;
+    comment?: string;
+    metadata?: Record<string, unknown>;
+}
+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>;
+}

package/dist/src/terminal.d.ts

@@ -0,0 +1,130 @@
+import { Schema } from "effect";
+export declare const DEFAULT_TERMINAL_ID = "default";
+export declare const TerminalThreadInput: Schema.Struct<{
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalThreadInput = Schema.Codec.Encoded<typeof TerminalThreadInput>;
+declare const TerminalSessionInput: Schema.Struct<{
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalSessionInput = Schema.Codec.Encoded<typeof TerminalSessionInput>;
+export declare const TerminalOpenInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly cols: Schema.optional<Schema.Int>;
+    readonly rows: Schema.optional<Schema.Int>;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalOpenInput = Schema.Codec.Encoded<typeof TerminalOpenInput>;
+export declare const TerminalWriteInput: Schema.Struct<{
+    readonly data: Schema.String;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalWriteInput = Schema.Codec.Encoded<typeof TerminalWriteInput>;
+export declare const TerminalResizeInput: Schema.Struct<{
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalResizeInput = Schema.Codec.Encoded<typeof TerminalResizeInput>;
+export declare const TerminalClearInput: Schema.Struct<{
+    readonly terminalId: Schema.withDecodingDefault<Schema.Trim>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalClearInput = Schema.Codec.Encoded<typeof TerminalClearInput>;
+export declare const TerminalRestartInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly threadId: Schema.Trim;
+}>;
+export declare const TerminalCloseInput: Schema.Struct<{
+    readonly terminalId: Schema.optional<Schema.Trim>;
+    readonly deleteHistory: Schema.optional<Schema.Boolean>;
+    readonly threadId: Schema.Trim;
+}>;
+export type TerminalCloseInput = Schema.Codec.Encoded<typeof TerminalCloseInput>;
+export declare const TerminalSessionStatus: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+export type TerminalSessionStatus = typeof TerminalSessionStatus.Type;
+export declare const TerminalSessionSnapshot: Schema.Struct<{
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly cwd: Schema.String;
+    readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly history: Schema.String;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.String>;
+    readonly updatedAt: Schema.String;
+}>;
+export type TerminalSessionSnapshot = typeof TerminalSessionSnapshot.Type;
+export declare const TerminalEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"started">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly data: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"exited">;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.String>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cleared">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"restarted">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.String>;
+        readonly updatedAt: Schema.String;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"activity">;
+    readonly hasRunningSubprocess: Schema.Boolean;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly createdAt: Schema.String;
+}>]>;
+export type TerminalEvent = typeof TerminalEvent.Type;
+export {};

package/dist/src/terminal.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");

package/dist/src/validation.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+export declare const ValidationStatus: Schema.Literals<readonly ["pending", "running", "passed", "failed", "skipped"]>;
+export type ValidationStatus = typeof ValidationStatus.Type;
+export declare const ValidationSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ValidationResultId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly validatorKey: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["pending", "running", "passed", "failed", "skipped"]>;
+    readonly output: Schema.Unknown;
+    readonly startedAt: Schema.String;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ValidationSummary = typeof ValidationSummary.Type;

package/dist/src/validation.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");