@kitman-sh/sdk 0.7.5 → 0.8.0

package/dist/{chunk-72z6zbfz.js → chunk-160ww64c.js}

@@ -1,6 +1,8 @@
 // @bun
 import {
   AgentSandboxNetwork,
+  Numeric,
+  isWholeNumber,
   guard,
   Id,
   Timestamp,
@@ -19,15 +21,14 @@ import {
   executeLoop2,
   LoopCheckError2,
   checkLoop2
-} from "./chunk-8byx9rx2.js";
+} from "./chunk-36jhc745.js";
 // packages/core/src/repo-binding.ts
 import * as Schema from "effect/Schema";
+var ForgeKinds = ["github", "gitlab", "forgejo", "gitea", "gitee", "bitbucket", "azure-devops"];
+var ForgeKind = Schema.Literals(ForgeKinds);
+var RepoBindingProviders = [...ForgeKinds, "generic_git"];
 var RepoBindingPathPrefixPattern = "^(?!/)(?!.*\\\\)(?!.*(?:^|/)\\.\\.?(?:/|$))(?!.*//)\\S+$";
-var RepoBindingProvider = Schema.Union([
-  Schema.Literal("github"),
-  Schema.Literal("gitlab"),
-  Schema.Literal("generic_git")
-]);
+var RepoBindingProvider = Schema.Literals(RepoBindingProviders);
 var RepoBindingStatus = Schema.Union([Schema.Literal("active"), Schema.Literal("disabled")]);
 var RepoBindingCredentialProviderType = Schema.Union([
   Schema.Literal("env"),
@@ -52,7 +53,7 @@ var RepoBindingCredentialRef = Schema.Union([
 var RepoBinding = Schema.Struct({
   id: Id,
   workspaceId: Id,
-  projectId: Id,
+  teamId: Schema.optionalKey(Id),
   provider: RepoBindingProvider,
   host: Schema.String.check(Schema.isMinLength(1)),
   owner: Schema.String.check(Schema.isMinLength(1)),
@@ -65,13 +66,14 @@ var RepoBinding = Schema.Struct({
   credentialRefs: Schema.Array(RepoBindingCredentialRef),
   status: RepoBindingStatus,
   webhook: Schema.optionalKey(Schema.Struct({
-    status: Schema.Literals(["active", "missing"]),
+    status: Schema.Literals(["active", "missing", "unavailable"]),
     message: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(240)))
   })),
   createdAt: Timestamp,
   updatedAt: Timestamp
 });
 var RepoBindingCreate = Schema.Struct({
+  teamId: Schema.optionalKey(Id),
   provider: RepoBindingProvider,
   host: Schema.String.check(Schema.isMinLength(1)),
   owner: Schema.String.check(Schema.isMinLength(1)),
@@ -96,6 +98,7 @@ var RunnerRepoBindingCapability = Schema.Struct({
   authenticated: Schema.Boolean,
   canPush: Schema.optionalKey(Schema.Boolean)
 });
+
 // packages/core/src/work-unit.ts
 import * as Schema2 from "effect/Schema";
 import * as Struct3 from "effect/Struct";
@@ -142,10 +145,11 @@ var WorkUnitStatus = Schema2.Union([
   Schema2.Literal("expired")
 ]);
 var LoopCheckout = Schema2.Union([Schema2.Literal("none"), Schema2.Literal("read"), Schema2.Literal("write")]);
+var StorageOrigin = Schema2.optionalKey(Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(2048)));
 var AgentStepWorkUnit = Schema2.Struct({
   kind: Schema2.Literal("agent_step"),
   id: Id,
-  projectId: Schema2.optionalKey(Id),
+  teamId: Schema2.optionalKey(Id),
   runId: Id,
   stepKey: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
   attempt: Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(1)),
@@ -159,7 +163,8 @@ var AgentStepWorkUnit = Schema2.Struct({
   network: Schema2.optionalKey(AgentSandboxNetwork),
   sandbox: Schema2.optionalKey(Schema2.Literal("docker")),
   secrets: Schema2.optionalKey(Schema2.Record(Schema2.String, Schema2.String)),
-  runBaseRevision: Schema2.optionalKey(Schema2.String.check(Schema2.isMinLength(1)))
+  runBaseRevision: Schema2.optionalKey(Schema2.String.check(Schema2.isMinLength(1))),
+  storageOrigin: StorageOrigin
 });
 var RunJournal = Schema2.Struct({
   activities: Schema2.Record(Schema2.String, Schema2.Unknown),
@@ -168,7 +173,7 @@ var RunJournal = Schema2.Struct({
 var OrchestrationWorkUnit = Schema2.Struct({
   kind: Schema2.Literal("orchestration"),
   id: Id,
-  projectId: Schema2.optionalKey(Id),
+  teamId: Schema2.optionalKey(Id),
   runId: Id,
   loopDigest: Schema2.String.check(Schema2.isMinLength(64), Schema2.isMaxLength(64), Schema2.isPattern(new RegExp("^[a-f0-9]{64}$", "u"))),
   input: Schema2.Unknown,
@@ -176,6 +181,7 @@ var OrchestrationWorkUnit = Schema2.Struct({
   lease: WorkUnitLease,
   journal: RunJournal,
   network: Schema2.optionalKey(AgentSandboxNetwork),
+  storageOrigin: StorageOrigin,
   program: Schema2.Struct({
     loopId: Schema2.String.check(Schema2.isMinLength(1)),
     credential: Schema2.String.check(Schema2.isMinLength(1))
@@ -190,18 +196,19 @@ var ApprovedCheck = Schema2.Struct({
 var VerificationWorkUnit = Schema2.Struct({
   kind: Schema2.Literal("verification"),
   id: Id,
-  projectId: Id,
+  teamId: Schema2.optionalKey(Id),
   runId: Id,
   stepKey: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
   lease: WorkUnitLease,
   repoBinding: WorkUnitRepoBinding,
   revision: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
-  checks: Schema2.Array(ApprovedCheck).check(Schema2.isMinLength(1), Schema2.isMaxLength(50))
+  checks: Schema2.Array(ApprovedCheck).check(Schema2.isMinLength(1), Schema2.isMaxLength(50)),
+  storageOrigin: StorageOrigin
 });
 var WorkUnit = Schema2.Union([OrchestrationWorkUnit, AgentStepWorkUnit, VerificationWorkUnit]);
 var WorkUnitClaimResult = Schema2.Struct({ workUnit: Schema2.optionalKey(WorkUnit) });
 var WorkUnitClaimInput = Schema2.Struct({
-  projectId: Schema2.optionalKey(Id),
+  teamId: Schema2.optionalKey(Id),
   runnerReplicaId: Id,
   capacitySlot: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
   idempotencyKey: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
@@ -226,7 +233,8 @@ var CheckEvidence = Schema2.Struct({
   status: Schema2.Union([Schema2.Literal("passed"), Schema2.Literal("failed")]),
   exitCode: Schema2.optionalKey(Schema2.Int),
   durationMs: Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0)),
-  outputTail: Schema2.String.check(Schema2.isMaxLength(8000))
+  outputTail: Schema2.String.check(Schema2.isMaxLength(8000)),
+  fileIds: Schema2.optionalKey(Schema2.Array(Schema2.String).check(Schema2.isMaxLength(51)))
 });
 var TreeEvidence = Schema2.Struct({
   revision: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
@@ -265,43 +273,292 @@ var WorkUnitCompletion = Schema2.Struct({
   idempotencyKey: Schema2.String.check(Schema2.isMinLength(1), Schema2.isMaxLength(240)),
   outcome: WorkUnitOutcome
 });
+// packages/core/src/run-file.ts
+import * as Schema4 from "effect/Schema";
+
+// packages/core/src/storage.ts
+import * as Schema3 from "effect/Schema";
+var units = ["B", "KiB", "MiB", "GiB", "TiB"];
+var formatBytes = (bytes) => {
+  const exponent = Math.min(units.length - 1, Math.floor(Math.log(Math.max(bytes, 1)) / Math.log(1024)));
+  return `${Number((bytes / 1024 ** exponent).toFixed(1))} ${units[exponent]}`;
+};
+var storageLimitWords = {
+  quota: (quotaBytes) => `${formatBytes(quotaBytes)} in all`,
+  file: (fileBytes) => `${formatBytes(fileBytes)} per file`,
+  run: (filesPerRun) => `${filesPerRun} files per Run`
+};
+var maxRunFileRetentionDays = 3650;
+var RunFileRetentionDays = Schema3.NullOr(Schema3.Int.check(Schema3.isGreaterThanOrEqualTo(1), Schema3.isLessThanOrEqualTo(maxRunFileRetentionDays)));
+var WorkspaceStorageSettings = Schema3.Struct({
+  usedBytes: Schema3.Int,
+  quotaBytes: Schema3.Int,
+  byPurpose: Schema3.Struct({ runFile: Schema3.Int, taskAsset: Schema3.Int, checkpoint: Schema3.Int }),
+  limits: Schema3.Struct({ fileBytes: Schema3.Int, filesPerRun: Schema3.Int }),
+  runFileRetentionDays: RunFileRetentionDays
+});
+var WorkspaceStorageUpdate = Schema3.Struct({ runFileRetentionDays: RunFileRetentionDays });
+var WorkspaceStorageSaved = Schema3.Struct({ ...WorkspaceStorageSettings.fields, willExpire: Schema3.Int });
+
+// packages/core/src/run-file.ts
+var RunFileRefusalReasons = ["type", "too_large", "too_many", "quota", "name_taken"];
+var runFileRefusalWords = (refusal) => {
+  switch (refusal.reason) {
+    case "type":
+      return "Kitman keeps images, videos, HTML, text, logs, PDFs and archives as Run Files; return structured data in an Output or an artifact";
+    case "too_large":
+      return `Over ${storageLimitWords.file(refusal.limit ?? 0)}: ${formatBytes(refusal.actual ?? 0)}`;
+    case "too_many":
+      return `Over ${storageLimitWords.run(refusal.limit ?? 0)}: this would be file ${refusal.actual}`;
+    case "quota":
+      return `Over the Workspace's ${storageLimitWords.quota(refusal.limit ?? 0)}: it would hold ${formatBytes(refusal.actual ?? 0)}`;
+    case "name_taken":
+      return "The Step already kept a different file under this name";
+  }
+};
+
+class RunFileRefused extends Schema4.TaggedError()("RunFileRefused", {
+  reason: Schema4.Literals(RunFileRefusalReasons),
+  limit: Schema4.optionalKey(Schema4.Int),
+  actual: Schema4.optionalKey(Schema4.Int)
+}) {
+  get message() {
+    return runFileRefusalWords(this);
+  }
+}
+var contentTypes = new Map([
+  ["png", "image/png"],
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["webp", "image/webp"],
+  ["gif", "image/gif"],
+  ["webm", "video/webm"],
+  ["mp4", "video/mp4"],
+  ["html", "text/html"],
+  ["htm", "text/html"],
+  ["txt", "text/plain"],
+  ["log", "text/x-log"],
+  ["pdf", "application/pdf"],
+  ["zip", "application/zip"],
+  ["gz", "application/gzip"],
+  ["tgz", "application/gzip"],
+  ["tar", "application/x-tar"],
+  ["json", "application/json"]
+]);
+var runFileContentType = (name) => contentTypes.get(name.split(".").at(-1)?.toLowerCase() ?? "") ?? "application/octet-stream";
+var RunFileKinds = ["image", "video", "html", "text", "other"];
+var RunFileStatuses = [
+  "uploading",
+  "available",
+  "rejected",
+  "refused",
+  "removing",
+  "removed",
+  "expired"
+];
+var RunFileRecord = Schema4.Struct({
+  id: Schema4.String,
+  runId: Schema4.String,
+  step: Schema4.String,
+  name: Schema4.String,
+  caption: Schema4.optionalKey(Schema4.String),
+  contentType: Schema4.String,
+  kind: Schema4.Literals(RunFileKinds),
+  byteSize: Schema4.Int,
+  sha256: Schema4.String,
+  status: Schema4.Literals(RunFileStatuses)
+});
+var RunFileMakers = ["program", "agent", "check"];
+var RunFileView = Schema4.Struct({
+  id: Schema4.String,
+  runId: Schema4.String,
+  step: Schema4.String,
+  stepAttemptId: Schema4.optionalKey(Schema4.String),
+  verificationId: Schema4.optionalKey(Schema4.String),
+  madeBy: Schema4.Literals(RunFileMakers),
+  name: Schema4.String,
+  caption: Schema4.optionalKey(Schema4.String),
+  kind: Schema4.Literals(RunFileKinds),
+  contentType: Schema4.String,
+  byteSize: Schema4.Int,
+  sha256: Schema4.String,
+  status: Schema4.Literals(RunFileStatuses),
+  reason: Schema4.optionalKey(Schema4.String),
+  limit: Schema4.optionalKey(Schema4.Int),
+  actual: Schema4.optionalKey(Schema4.Int),
+  removedBy: Schema4.optionalKey(Schema4.String),
+  removedAt: Schema4.optionalKey(Timestamp),
+  createdAt: Timestamp
+});
+var RunFileList = Schema4.Union([
+  Schema4.Struct({ files: Schema4.Array(RunFileView) }),
+  Schema4.Struct({ count: Schema4.Int })
+]);
+var RunFileUrlsRequest = Schema4.Struct({
+  ids: Schema4.Array(Id).check(Schema4.isMinLength(1), Schema4.isMaxLength(200)),
+  use: Schema4.Literals(["view", "download"])
+});
+var RunFileRemoveRequest = Schema4.Struct({
+  note: Schema4.optionalKey(Schema4.String.check(Schema4.isMaxLength(500)))
+});
+var RunFileUrl = Schema4.Struct({ id: Schema4.String, url: Schema4.String, expiresAt: Timestamp });
+var RunFileUrls = Schema4.Struct({ urls: Schema4.Array(RunFileUrl) });
+var PresignedRequest = {
+  url: Schema4.String,
+  headers: Schema4.optionalKey(Schema4.Record(Schema4.String, Schema4.String)),
+  expiresAt: Schema4.String
+};
+var RunFilePartUrl = Schema4.Struct({ partNumber: Schema4.Int, ...PresignedRequest });
+var RunFileUpload = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("single"), ...PresignedRequest }),
+  Schema4.Struct({ kind: Schema4.Literal("multipart"), partSize: Schema4.Int, parts: Schema4.Array(RunFilePartUrl) })
+]);
+var UploadedRunFilePart = Schema4.Struct({ partNumber: Schema4.Int, etag: Schema4.String });
+var StepRunFileRequest = Schema4.Struct({
+  name: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(255)),
+  caption: Schema4.optionalKey(Schema4.String.check(Schema4.isMaxLength(1000))),
+  contentType: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(255)),
+  byteSize: Schema4.Int.check(Schema4.isGreaterThanOrEqualTo(0)),
+  sha256: Schema4.String.check(Schema4.isPattern(/^[0-9a-f]{64}$/))
+});
+var RunFileSlotted = Schema4.Struct({ file: RunFileRecord, upload: Schema4.optionalKey(RunFileUpload) });
+// packages/core/src/crypto.ts
+import { createHash, createHmac, createSign, randomBytes, timingSafeEqual } from "crypto";
+function digestSha256(data, encoding) {
+  const hash = createHash("sha256");
+  for (const part of [data].flat())
+    hash.update(part);
+  return hash.digest(encoding);
+}
+function sha256Hasher() {
+  const hash = createHash("sha256");
+  return {
+    update: (data) => {
+      hash.update(data);
+    },
+    digest: (encoding) => hash.digest(encoding)
+  };
+}
+// packages/core/src/transcript.ts
+import * as Schema5 from "effect/Schema";
+var Text = Schema5.String.check(Schema5.isMaxLength(200000));
+var AgentEvent = Schema5.Union([
+  Schema5.Struct({ kind: Schema5.Literal("message"), role: Schema5.Literals(["assistant", "user"]), text: Text }),
+  Schema5.Struct({
+    kind: Schema5.Literal("tool_call"),
+    callId: Schema5.String,
+    name: Schema5.String.check(Schema5.isMinLength(1), Schema5.isMaxLength(240)),
+    arguments: Schema5.Json
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("tool_result"),
+    callId: Schema5.String,
+    output: Text,
+    isError: Schema5.optionalKey(Schema5.Boolean)
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("file"),
+    path: Schema5.String.check(Schema5.isMinLength(1), Schema5.isMaxLength(4096)),
+    change: Schema5.Literals(["read", "changed"])
+  }),
+  Schema5.Struct({ kind: Schema5.Literal("question"), text: Text }),
+  Schema5.Struct({
+    kind: Schema5.Literal("answer"),
+    callId: Schema5.optionalKey(Schema5.String),
+    questionId: Schema5.optionalKey(Schema5.String),
+    text: Text
+  }),
+  Schema5.Struct({ kind: Schema5.Literal("steer"), messageId: Id, text: Text }),
+  Schema5.Struct({
+    kind: Schema5.Literal("lifecycle"),
+    state: Schema5.Literals(["started", "resumed", "finished", "failed", "canceled"])
+  })
+]);
+var TranscriptAppendEntry = Schema5.Struct({
+  sequence: Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1)),
+  event: AgentEvent
+});
+var TranscriptEntry = Schema5.Struct({
+  stepAttemptId: Id,
+  sequence: Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1)),
+  event: AgentEvent,
+  createdAt: Timestamp
+});
+var TranscriptPage = Schema5.Struct({
+  items: Schema5.Array(TranscriptEntry),
+  next: Schema5.optionalKey(Schema5.Int),
+  previous: Schema5.optionalKey(Schema5.Int)
+});
+var TranscriptRetention = Schema5.Struct({
+  days: Schema5.NullOr(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1)))
+});
+var MaxTranscriptSearchLimit = 50;
+var TranscriptSearchQuery = Schema5.Struct({
+  q: Schema5.String.check(Schema5.isMinLength(1), Schema5.isMaxLength(200)),
+  limit: Schema5.optionalKey(Numeric.check(isWholeNumber, Schema5.isGreaterThanOrEqualTo(1), Schema5.isLessThanOrEqualTo(MaxTranscriptSearchLimit)))
+});
+var TranscriptSearchHit = Schema5.Struct({
+  runId: Id,
+  loop: Schema5.String,
+  task: Schema5.optionalKey(Schema5.Struct({ id: Id, key: Schema5.String, title: Schema5.String })),
+  stepAttemptId: Id,
+  node: Schema5.optionalKey(Schema5.String),
+  step: Schema5.String,
+  attempt: Schema5.Int,
+  agent: Schema5.optionalKey(Schema5.String),
+  ranAt: Timestamp,
+  sequence: Schema5.Int,
+  matches: Schema5.Int,
+  excerpt: Schema5.String
+});
+var TranscriptSearchResult = Schema5.Struct({
+  items: Schema5.Array(TranscriptSearchHit),
+  total: Schema5.Int
+});
 // packages/core/src/run-journal.ts
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
-import * as Schema3 from "effect/Schema";
+import * as Schema6 from "effect/Schema";
 var journalEntryMaxBytes = 256 * 1024;
-var JournalExit = Schema3.toCodecJson(Schema3.Exit(Schema3.Json, Schema3.Json, Schema3.Defect()));
-var encodeJournalExit = (exit) => Schema3.encodeUnknownEffect(JournalExit)(Exit.map(exit, (value) => value ?? null));
-var decodeJournalExit = Schema3.decodeUnknownEffect(JournalExit);
-var JournalStepFailed = Schema3.TaggedStruct("StepFailed", { step: Schema3.String, reason: Schema3.String });
-var JournalChildFailed = Schema3.TaggedStruct("ChildFailed", {
-  step: Schema3.String,
-  loop: Schema3.String,
-  reason: Schema3.String
+var JournalExit = Schema6.toCodecJson(Schema6.Exit(Schema6.Json, Schema6.Json, Schema6.Defect()));
+var encodeJournalExit = (exit) => Schema6.encodeUnknownEffect(JournalExit)(Exit.map(exit, (value) => value ?? null));
+var decodeJournalExit = Schema6.decodeUnknownEffect(JournalExit);
+var JournalStepFailed = Schema6.TaggedStruct("StepFailed", { step: Schema6.String, reason: Schema6.String });
+var JournalChildFailed = Schema6.TaggedStruct("ChildFailed", {
+  step: Schema6.String,
+  loop: Schema6.String,
+  reason: Schema6.String
 });
-var JournalWaitTimedOut = Schema3.TaggedStruct("WaitTimedOut", { step: Schema3.String, event: Schema3.String });
+var JournalWaitTimedOut = Schema6.TaggedStruct("WaitTimedOut", { step: Schema6.String, event: Schema6.String });
 var journalEntryBytes = (entry) => new TextEncoder().encode(JSON.stringify(entry)).byteLength;
 // packages/sdk/src/program/engine.ts
 import * as Cause from "effect/Cause";
+import * as Clock from "effect/Clock";
 import * as Data from "effect/Data";
 import * as Duration from "effect/Duration";
 import * as Effect2 from "effect/Effect";
 import * as Exit3 from "effect/Exit";
 import * as Fiber from "effect/Fiber";
+import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Schema5 from "effect/Schema";
+import { isPlatformError } from "effect/PlatformError";
+import * as Schema8 from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
 
 // packages/live/src/rpc/runner-group.ts
-import * as Schema4 from "effect/Schema";
+import * as Schema7 from "effect/Schema";
 import { Rpc, RpcGroup, RpcMiddleware } from "effect/rpc";
 var RunnerHeaders = { runnerId: "x-kitman-runner-id", protocolVersion: "x-kitman-rpc-protocol" };
-var RunnerRpcProtocolVersion = 1;
+var RunnerRpcProtocolVersion = 4;
 
-class RunnerRpcError extends Schema4.TaggedError()("RunnerRpcError", {
-  code: Schema4.String,
-  message: Schema4.String,
-  status: Schema4.Finite
+class RunnerRpcError extends Schema7.TaggedError()("RunnerRpcError", {
+  code: Schema7.String,
+  message: Schema7.String,
+  status: Schema7.Finite
 }) {
 }
 
@@ -309,55 +566,68 @@ class RunnerAuthentication extends RpcMiddleware.Service()("RunnerAuthentication
   error: RunnerRpcError
 }) {
 }
-var EventFilterValue = Schema4.Union([Schema4.String, Schema4.Finite, Schema4.Boolean, Schema4.Null]);
-var WorkAvailable = Schema4.TaggedStruct("WorkAvailable", {});
-var LeaseRevoked = Schema4.TaggedStruct("LeaseRevoked", { workUnitId: Schema4.String });
-var Settled = Schema4.TaggedStruct("Settled", { workUnitId: Schema4.String });
-var Canceled = Schema4.TaggedStruct("Canceled", { workUnitId: Schema4.String });
-var RunSettled = Schema4.TaggedStruct("RunSettled", { runId: Schema4.String });
-var Steer = Schema4.TaggedStruct("Steer", {
-  workUnitId: Schema4.String,
-  messageId: Schema4.String,
-  text: Schema4.String
+var EventFilterValue = Schema7.Union([Schema7.String, Schema7.Finite, Schema7.Boolean, Schema7.Null]);
+var WorkAvailable = Schema7.TaggedStruct("WorkAvailable", {});
+var LeaseRevoked = Schema7.TaggedStruct("LeaseRevoked", { workUnitId: Schema7.String });
+var Settled = Schema7.TaggedStruct("Settled", { workUnitId: Schema7.String });
+var Canceled = Schema7.TaggedStruct("Canceled", { workUnitId: Schema7.String });
+var RunSettled = Schema7.TaggedStruct("RunSettled", { runId: Schema7.String });
+var Steer = Schema7.TaggedStruct("Steer", {
+  workUnitId: Schema7.String,
+  messageId: Schema7.String,
+  text: Schema7.String
 });
-var SessionUpdated = Schema4.TaggedStruct("SessionUpdated", { workUnitId: Schema4.String });
-var RunnerSignal = Schema4.Union([
+var SessionUpdated = Schema7.TaggedStruct("SessionUpdated", { workUnitId: Schema7.String });
+var UpdateAvailable = Schema7.TaggedStruct("UpdateAvailable", { version: Schema7.String });
+var RunnerSignal = Schema7.Union([
   WorkAvailable,
   LeaseRevoked,
   Settled,
   Canceled,
   RunSettled,
   Steer,
-  SessionUpdated
+  SessionUpdated,
+  UpdateAvailable
 ]);
-var ProgramLease = Schema4.Struct({
-  workUnitId: Schema4.String,
-  leaseOwnerId: Schema4.String,
-  runnerReplicaId: Schema4.String,
-  leaseId: Schema4.String,
-  attempt: Schema4.Int,
-  fencingToken: Schema4.String,
-  capacitySlot: Schema4.String
+var ProgramLease = Schema7.Struct({
+  workUnitId: Schema7.String,
+  leaseOwnerId: Schema7.String,
+  runnerReplicaId: Schema7.String,
+  leaseId: Schema7.String,
+  attempt: Schema7.Int,
+  fencingToken: Schema7.String,
+  capacitySlot: Schema7.String
 });
-var CheckpointSession = Schema4.Struct({
-  harness: Schema4.String,
-  id: Schema4.String,
-  name: Schema4.String,
-  content: Schema4.Uint8ArrayFromBase64
+var CheckpointSession = Schema7.Struct({
+  harness: Schema7.String,
+  id: Schema7.String,
+  name: Schema7.String,
+  fileId: Schema7.String
 });
-var StepCheckpoint = Schema4.Struct({
-  ref: Schema4.optionalKey(Schema4.String),
-  revision: Schema4.optionalKey(Schema4.String),
-  session: Schema4.optionalKey(CheckpointSession)
+var StepCheckpoint = Schema7.Struct({
+  ref: Schema7.optionalKey(Schema7.String),
+  revision: Schema7.optionalKey(Schema7.String),
+  session: Schema7.optionalKey(CheckpointSession)
 });
-var SuggestedVerification = Schema4.Struct({
-  name: Schema4.String,
-  command: Schema4.String,
-  workingDirectory: Schema4.optional(Schema4.String)
+var ResumedCheckpoint = Schema7.Struct({
+  ref: Schema7.optionalKey(Schema7.String),
+  revision: Schema7.optionalKey(Schema7.String),
+  session: Schema7.optionalKey(Schema7.Struct({
+    harness: Schema7.String,
+    id: Schema7.String,
+    name: Schema7.String,
+    url: Schema7.String,
+    headers: Schema7.optionalKey(Schema7.Record(Schema7.String, Schema7.String))
+  }))
+});
+var SuggestedVerification = Schema7.Struct({
+  name: Schema7.String,
+  command: Schema7.String,
+  workingDirectory: Schema7.optional(Schema7.String)
 });
-var ProgramOutcome = Schema4.Union([
-  Schema4.Struct({ status: Schema4.Literal("completed"), output: Schema4.Json }),
-  Schema4.Struct({ status: Schema4.Literal("failed"), failureSummary: Schema4.String })
+var ProgramOutcome = Schema7.Union([
+  Schema7.Struct({ status: Schema7.Literal("completed"), output: Schema7.Json }),
+  Schema7.Struct({ status: Schema7.Literal("failed"), failureSummary: Schema7.String })
 ]);
 
 class RunnerRpcs extends RpcGroup.make(Rpc.make("Claim", {
@@ -375,185 +645,299 @@ class RunnerRpcs extends RpcGroup.make(Rpc.make("Claim", {
   payload: WorkUnitReleaseInput,
   error: RunnerRpcError
 }), Rpc.make("RecordActivity", {
-  payload: { lease: ProgramLease, name: Schema4.String, attempt: Schema4.Int, exit: Schema4.Json },
+  payload: { lease: ProgramLease, name: Schema7.String, attempt: Schema7.Int, exit: Schema7.Json },
   error: RunnerRpcError
 }), Rpc.make("DeferredDone", {
-  payload: { lease: ProgramLease, name: Schema4.String, exit: Schema4.Json },
+  payload: { lease: ProgramLease, name: Schema7.String, exit: Schema7.Json },
   error: RunnerRpcError
 }), Rpc.make("ScheduleClock", {
-  payload: { lease: ProgramLease, name: Schema4.String, deferredName: Schema4.String, durationMillis: Schema4.Int },
+  payload: { lease: ProgramLease, name: Schema7.String, deferredName: Schema7.String, durationMillis: Schema7.Int },
   error: RunnerRpcError
 }), Rpc.make("PutQuestion", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    prompt: Schema4.String,
-    options: Schema4.optional(Schema4.Array(Schema4.String)),
-    verification: Schema4.optional(SuggestedVerification),
-    deferredName: Schema4.String
+    step: Schema7.String,
+    prompt: Schema7.String,
+    options: Schema7.optional(Schema7.Array(Schema7.String)),
+    verification: Schema7.optional(SuggestedVerification),
+    deferredName: Schema7.String
   },
-  success: Schema4.Struct({ questionId: Schema4.String }),
+  success: Schema7.Struct({ questionId: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("StartAgentStep", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    deferredName: Schema4.String,
-    role: Schema4.String,
-    agentId: Schema4.String,
-    prompt: Schema4.String,
-    outputSchema: Schema4.Json,
-    secrets: Schema4.optionalKey(Schema4.Array(Schema4.String))
+    step: Schema7.String,
+    deferredName: Schema7.String,
+    role: Schema7.String,
+    agentId: Schema7.String,
+    prompt: Schema7.String,
+    outputSchema: Schema7.Json,
+    secrets: Schema7.optionalKey(Schema7.Array(Schema7.String))
   },
-  success: Schema4.Struct({ stepAttemptId: Schema4.String }),
+  success: Schema7.Struct({ stepAttemptId: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("StartVerification", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    deferredName: Schema4.String,
-    revision: Schema4.optionalKey(Schema4.String),
-    checks: Schema4.optional(Schema4.Array(Schema4.String))
+    step: Schema7.String,
+    deferredName: Schema7.String,
+    revision: Schema7.optionalKey(Schema7.String),
+    checks: Schema7.optional(Schema7.Array(Schema7.String))
   },
-  success: Schema4.Struct({ verificationId: Schema4.String }),
+  success: Schema7.Struct({ verificationId: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("KnownEvidence", {
-  payload: { lease: ProgramLease, trees: Schema4.Array(Schema4.String) },
-  success: Schema4.Array(Schema4.Struct({ tree: Schema4.String, name: Schema4.String, command: Schema4.String })),
+  payload: { lease: ProgramLease, trees: Schema7.Array(Schema7.String) },
+  success: Schema7.Array(Schema7.Struct({ tree: Schema7.String, name: Schema7.String, command: Schema7.String })),
   error: RunnerRpcError
 }), Rpc.make("AwaitEvent", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    deferredName: Schema4.String,
-    event: Schema4.String,
-    filter: Schema4.optional(Schema4.Record(Schema4.String, Schema4.Union([EventFilterValue, Schema4.Array(EventFilterValue)]))),
-    timeoutMillis: Schema4.Int
+    step: Schema7.String,
+    deferredName: Schema7.String,
+    event: Schema7.String,
+    filter: Schema7.optional(Schema7.Record(Schema7.String, Schema7.Union([EventFilterValue, Schema7.Array(EventFilterValue)]))),
+    timeoutMillis: Schema7.Int
   },
   error: RunnerRpcError
 }), Rpc.make("AdmitChild", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    loop: Schema4.String,
-    input: Schema4.Json,
-    deferredName: Schema4.String
+    step: Schema7.String,
+    loop: Schema7.String,
+    input: Schema7.Json,
+    deferredName: Schema7.String
   },
-  success: Schema4.Struct({ runId: Schema4.String }),
+  success: Schema7.Struct({ runId: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("StoreArtifact", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    kind: Schema4.String,
-    title: Schema4.String,
-    text: Schema4.String,
-    data: Schema4.optional(Schema4.Json)
+    step: Schema7.String,
+    kind: Schema7.String,
+    title: Schema7.String,
+    text: Schema7.String,
+    data: Schema7.optional(Schema7.Json),
+    fileIds: Schema7.optional(Schema7.Array(Schema7.String))
   },
-  success: Schema4.Struct({ artifactId: Schema4.String }),
+  success: Schema7.Struct({ artifactId: Schema7.String }),
+  error: RunnerRpcError
+}), Rpc.make("CreateRunFile", {
+  payload: {
+    lease: ProgramLease,
+    step: Schema7.String,
+    name: Schema7.String,
+    caption: Schema7.optional(Schema7.String),
+    contentType: Schema7.String,
+    byteSize: Schema7.Int,
+    sha256: Schema7.String
+  },
+  success: Schema7.Struct({ file: RunFileRecord, upload: Schema7.optional(RunFileUpload) }),
+  error: Schema7.Union([RunnerRpcError, RunFileRefused])
+}), Rpc.make("RunFileParts", {
+  payload: { lease: ProgramLease, fileId: Schema7.String, partNumbers: Schema7.Array(Schema7.Int) },
+  success: Schema7.Struct({ parts: Schema7.Array(RunFilePartUrl) }),
+  error: RunnerRpcError
+}), Rpc.make("CompleteRunFile", {
+  payload: { lease: ProgramLease, fileId: Schema7.String, parts: Schema7.optional(Schema7.Array(UploadedRunFilePart)) },
+  success: RunFileRecord,
   error: RunnerRpcError
 }), Rpc.make("RecordNote", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    text: Schema4.String,
-    artifactId: Schema4.optional(Schema4.String)
+    step: Schema7.String,
+    text: Schema7.String,
+    artifactId: Schema7.optional(Schema7.String)
   },
   error: RunnerRpcError
 }), Rpc.make("PerformHostEffect", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    effect: Schema4.Union([
-      Schema4.Struct({ kind: Schema4.Literal("post_comment"), changeRequestId: Schema4.String, body: Schema4.String }),
-      Schema4.Struct({
-        kind: Schema4.Literal("change_request"),
-        title: Schema4.String,
-        body: Schema4.String,
-        integration: Schema4.optionalKey(Schema4.String)
+    step: Schema7.String,
+    effect: Schema7.Union([
+      Schema7.Struct({ kind: Schema7.Literal("post_comment"), changeRequestId: Schema7.String, body: Schema7.String }),
+      Schema7.Struct({
+        kind: Schema7.Literal("change_request"),
+        title: Schema7.String,
+        body: Schema7.String,
+        integration: Schema7.optionalKey(Schema7.String)
+      }),
+      Schema7.Struct({
+        kind: Schema7.Literal("write_back"),
+        milestone: Schema7.optionalKey(Schema7.Literals(["started", "change_request_opened", "merged", "failed"])),
+        changeRequestUrl: Schema7.optionalKey(Schema7.String)
+      })
+    ])
+  },
+  success: Schema7.UndefinedOr(Schema7.Struct({ id: Schema7.String, number: Schema7.String, url: Schema7.String })),
+  error: RunnerRpcError
+}), Rpc.make("ReadTranscripts", {
+  payload: { lease: ProgramLease, step: Schema7.String, days: Schema7.Int },
+  success: Schema7.Struct({
+    runs: Schema7.Array(Schema7.Struct({
+      runId: Schema7.String,
+      loopId: Schema7.String,
+      teamId: Schema7.optionalKey(Schema7.String),
+      failure: Schema7.optionalKey(Schema7.String),
+      entries: Schema7.Array(Schema7.Struct({
+        stepAttemptId: Schema7.String,
+        sequence: Schema7.Int,
+        kind: Schema7.String,
+        text: Schema7.String
+      }))
+    }))
+  }),
+  error: RunnerRpcError
+}), Rpc.make("Propose", {
+  payload: {
+    lease: ProgramLease,
+    step: Schema7.String,
+    proposal: Schema7.Union([
+      Schema7.Struct({
+        kind: Schema7.Literal("memory"),
+        teamId: Schema7.String,
+        content: Schema7.String,
+        citations: Schema7.NonEmptyArray(Schema7.Struct({ runId: Schema7.String, stepAttemptId: Schema7.String, sequence: Schema7.Int }))
       }),
-      Schema4.Struct({
-        kind: Schema4.Literal("write_back"),
-        milestone: Schema4.optionalKey(Schema4.Literals(["started", "change_request_opened", "merged", "failed"])),
-        changeRequestUrl: Schema4.optionalKey(Schema4.String)
+      Schema7.Struct({
+        kind: Schema7.Literal("task"),
+        title: Schema7.String,
+        description: Schema7.String,
+        teamId: Schema7.optionalKey(Schema7.String),
+        citations: Schema7.NonEmptyArray(Schema7.Struct({ runId: Schema7.String, stepAttemptId: Schema7.String, sequence: Schema7.Int }))
       })
     ])
   },
-  success: Schema4.UndefinedOr(Schema4.Struct({ id: Schema4.String, number: Schema4.String, url: Schema4.String })),
+  success: Schema7.Struct({ kind: Schema7.Literals(["memory", "task"]), id: Schema7.String }),
+  error: RunnerRpcError
+}), Rpc.make("ReadProject", {
+  payload: { lease: ProgramLease, step: Schema7.String, projectId: Schema7.String },
+  success: Schema7.Struct({
+    project: Schema7.Struct({ id: Schema7.String, name: Schema7.String }),
+    health: Schema7.optionalKey(Schema7.Literals(["on_track", "at_risk", "off_track"])),
+    since: Schema7.optionalKey(Schema7.String),
+    runs: Schema7.Array(Schema7.Struct({
+      runId: Schema7.String,
+      loopId: Schema7.String,
+      status: Schema7.String,
+      taskKey: Schema7.optionalKey(Schema7.String),
+      taskTitle: Schema7.optionalKey(Schema7.String),
+      summary: Schema7.optionalKey(Schema7.String),
+      entries: Schema7.Array(Schema7.Struct({
+        stepAttemptId: Schema7.String,
+        sequence: Schema7.Int,
+        kind: Schema7.String,
+        text: Schema7.String
+      }))
+    })),
+    taskChanges: Schema7.Array(Schema7.Struct({ taskKey: Schema7.String, title: Schema7.String, change: Schema7.String, at: Schema7.String }))
+  }),
+  error: RunnerRpcError
+}), Rpc.make("DraftUpdate", {
+  payload: {
+    lease: ProgramLease,
+    step: Schema7.String,
+    projectId: Schema7.String,
+    health: Schema7.Literals(["on_track", "at_risk", "off_track"]),
+    note: Schema7.String,
+    writtenFrom: Schema7.Struct({
+      runs: Schema7.Int,
+      taskChanges: Schema7.Int,
+      since: Schema7.optionalKey(Schema7.String)
+    })
+  },
+  success: Schema7.Struct({ id: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("CreatePlanTasks", {
   payload: {
     lease: ProgramLease,
-    tickets: Schema4.Array(Schema4.Struct({
-      key: Schema4.String,
-      title: Schema4.String,
-      body: Schema4.String,
-      acceptanceCriteria: Schema4.Array(Schema4.String),
-      blockedBy: Schema4.Array(Schema4.String),
-      outcome: Schema4.optionalKey(Schema4.Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"]))
+    tickets: Schema7.Array(Schema7.Struct({
+      key: Schema7.String,
+      title: Schema7.String,
+      body: Schema7.String,
+      acceptanceCriteria: Schema7.Array(Schema7.String),
+      blockedBy: Schema7.Array(Schema7.String),
+      outcome: Schema7.optionalKey(Schema7.Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"]))
     }))
   },
-  success: Schema4.Array(Schema4.Struct({ key: Schema4.String, taskId: Schema4.String })),
+  success: Schema7.Array(Schema7.Struct({ key: Schema7.String, taskId: Schema7.String })),
   error: RunnerRpcError
 }), Rpc.make("IntegrationBranch", {
-  payload: { lease: ProgramLease, repoBindingId: Schema4.optionalKey(Schema4.String) },
-  success: Schema4.Struct({ repoBindingId: Schema4.String, branch: Schema4.String, revision: Schema4.String }),
+  payload: { lease: ProgramLease, repoBindingId: Schema7.optionalKey(Schema7.String) },
+  success: Schema7.Struct({ repoBindingId: Schema7.String, branch: Schema7.String, revision: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("MergeChangeRequest", {
-  payload: { lease: ProgramLease, step: Schema4.String, changeRequestId: Schema4.String },
-  success: Schema4.Union([
-    Schema4.Struct({ status: Schema4.Literal("merged"), revision: Schema4.String }),
-    Schema4.Struct({ status: Schema4.Literal("conflict") })
+  payload: { lease: ProgramLease, step: Schema7.String, changeRequestId: Schema7.String },
+  success: Schema7.Union([
+    Schema7.Struct({ status: Schema7.Literal("merged"), revision: Schema7.String }),
+    Schema7.Struct({ status: Schema7.Literal("conflict") })
   ]),
   error: RunnerRpcError
 }), Rpc.make("PublishRelease", {
   payload: {
     lease: ProgramLease,
-    step: Schema4.String,
-    tag: Schema4.String,
-    revision: Schema4.optionalKey(Schema4.String),
-    title: Schema4.String,
-    notes: Schema4.String
+    step: Schema7.String,
+    tag: Schema7.String,
+    revision: Schema7.optionalKey(Schema7.String),
+    title: Schema7.String,
+    notes: Schema7.String
   },
-  success: Schema4.Struct({ tag: Schema4.String, revision: Schema4.String, url: Schema4.String }),
+  success: Schema7.Struct({ tag: Schema7.String, revision: Schema7.String, url: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("ReportSteer", {
-  payload: { workUnitId: Schema4.String, messageId: Schema4.String, delivered: Schema4.Boolean },
-  success: Schema4.Void,
+  payload: { workUnitId: Schema7.String, messageId: Schema7.String, delivered: Schema7.Boolean },
+  success: Schema7.Void,
+  error: RunnerRpcError
+}), Rpc.make("AppendTranscript", {
+  payload: { workUnitId: Schema7.String, entries: Schema7.Array(TranscriptAppendEntry).check(Schema7.isMaxLength(100)) },
+  success: Schema7.Void,
+  error: RunnerRpcError
+}), Rpc.make("CreateCheckpointFile", {
+  payload: { lease: ProgramLease, byteSize: Schema7.Int, sha256: Schema7.String },
+  success: Schema7.Struct({ file: RunFileRecord, upload: Schema7.optional(RunFileUpload) }),
+  error: Schema7.Union([RunnerRpcError, RunFileRefused])
+}), Rpc.make("CheckpointFileParts", {
+  payload: { lease: ProgramLease, fileId: Schema7.String, partNumbers: Schema7.Array(Schema7.Int) },
+  success: Schema7.Struct({ parts: Schema7.Array(RunFilePartUrl) }),
+  error: RunnerRpcError
+}), Rpc.make("CompleteCheckpointFile", {
+  payload: { lease: ProgramLease, fileId: Schema7.String, parts: Schema7.optional(Schema7.Array(UploadedRunFilePart)) },
+  success: RunFileRecord,
   error: RunnerRpcError
 }), Rpc.make("SaveCheckpoint", {
   payload: { lease: ProgramLease, checkpoint: StepCheckpoint },
-  success: Schema4.Void,
+  success: Schema7.Void,
   error: RunnerRpcError
 }), Rpc.make("ResumeCheckpoint", {
   payload: { lease: ProgramLease },
-  success: Schema4.UndefinedOr(StepCheckpoint),
+  success: Schema7.UndefinedOr(ResumedCheckpoint),
   error: RunnerRpcError
 }), Rpc.make("SettledCheckpoints", {
-  success: Schema4.Array(Schema4.Struct({
-    stepAttemptId: Schema4.String,
-    ref: Schema4.optionalKey(Schema4.String),
-    repoBinding: Schema4.optionalKey(WorkUnitRepoBinding)
+  success: Schema7.Array(Schema7.Struct({
+    stepAttemptId: Schema7.String,
+    ref: Schema7.optionalKey(Schema7.String),
+    repoBinding: Schema7.optionalKey(WorkUnitRepoBinding)
   })),
   error: RunnerRpcError
 }), Rpc.make("ForgetCheckpoints", {
-  payload: { stepAttemptIds: Schema4.Array(Schema4.String) },
-  success: Schema4.Void,
+  payload: { stepAttemptIds: Schema7.Array(Schema7.String) },
+  success: Schema7.Void,
   error: RunnerRpcError
 }), Rpc.make("Bundle", {
-  payload: { digest: Schema4.String },
-  success: Schema4.Struct({ bundle: Schema4.String }),
+  payload: { digest: Schema7.String },
+  success: Schema7.Struct({ bundle: Schema7.String }),
   error: RunnerRpcError
 }), Rpc.make("SettledRuns", {
-  payload: { runIds: Schema4.Array(Schema4.String) },
-  success: Schema4.Array(Schema4.String),
+  payload: { runIds: Schema7.Array(Schema7.String) },
+  success: Schema7.Array(Schema7.String),
   error: RunnerRpcError
 }), Rpc.make("ProgramSecrets", {
   payload: { lease: ProgramLease },
-  success: Schema4.Record(Schema4.String, Schema4.String),
+  success: Schema7.Record(Schema7.String, Schema7.String),
   error: RunnerRpcError
 }), Rpc.make("Suspend", { payload: { lease: ProgramLease }, error: RunnerRpcError }), Rpc.make("FinishProgram", { payload: { lease: ProgramLease, outcome: ProgramOutcome }, error: RunnerRpcError }), Rpc.make("Signals", {
-  payload: { runnerReplicaId: Schema4.String },
+  payload: { runnerReplicaId: Schema7.String },
   success: RunnerSignal,
   error: RunnerRpcError,
   stream: true
@@ -577,11 +961,11 @@ var entryFor = (name, exit) => Effect2.gen(function* () {
   return entry;
 });
 var decoded = (entry) => Effect2.orDie(decodeJournalExit(entry));
-var JournalEntries = Schema5.Record(Schema5.String, Schema5.Json);
-var isSuspended = Schema5.is(Workflow.Suspended);
+var JournalEntries = Schema8.Record(Schema8.String, Schema8.Json);
+var isSuspended = Schema8.is(Workflow.Suspended);
 var makeEncodedEngine = (recorded, journal) => Effect2.gen(function* () {
   const scope2 = yield* Effect2.scope;
-  const entries = (journalPart) => Effect2.map(Effect2.orDie(Schema5.decodeUnknownEffect(JournalEntries)(journalPart)), Object.entries);
+  const entries = (journalPart) => Effect2.map(Effect2.orDie(Schema8.decodeUnknownEffect(JournalEntries)(journalPart)), Object.entries);
   const activities = new Map(yield* entries(recorded.activities));
   const deferreds = new Map(yield* entries(recorded.deferreds));
   const workflows = new Map;
@@ -658,8 +1042,11 @@ var makeEncodedEngine = (recorded, journal) => Effect2.gen(function* () {
 });
 var emptyWorkflow = Workflow.make("kitman-loop/none", { payload: {}, idempotencyKey: () => "none" });
 var replayStatuses = new Set([401, 403, 409, 429]);
-var isRunnerRpcError = Schema5.is(RunnerRpcError);
+var isRunnerRpcError = Schema8.is(RunnerRpcError);
+var isRunFileRefused = Schema8.is(RunFileRefused);
 var refusedStep2 = (cause) => {
+  if (isRunFileRefused(cause))
+    return true;
   if ("code" in cause && (cause.code === "capability_denied" || cause.code === "step_refused"))
     return true;
   return isRunnerRpcError(cause) && cause.status >= 400 && cause.status < 500 && !replayStatuses.has(cause.status);
@@ -702,7 +1089,49 @@ var runnerHost = (journal) => ({
     timeoutMillis: launch.timeoutMillis
   }))
 });
-var runnerActivities = (journal) => ({
+var put2 = (target, contentType, body) => Effect2.gen(function* () {
+  const response = yield* (yield* HttpClient.HttpClient).execute(HttpClientRequest.put(target.url).pipe(HttpClientRequest.bodyUint8Array(body, contentType), HttpClientRequest.setHeaders(target.headers ?? {})));
+  return (yield* HttpClientResponse.filterStatusOk(response)).headers.etag ?? "";
+});
+var readRange = (path, offset, size) => Effect2.scoped(Effect2.gen(function* () {
+  const file = yield* (yield* FileSystem.FileSystem).open(path);
+  return Option.getOrElse(yield* file.readAlloc(size, { position: BigInt(offset) }), () => new Uint8Array);
+}));
+var partUrlMarginMillis = 60000;
+var uploadParts = (files, path, contentType, fileId, upload) => Effect2.forEach(upload.parts, (part) => Effect2.gen(function* () {
+  const now = yield* Clock.currentTimeMillis;
+  const fresh = Date.parse(part.expiresAt) - now > partUrlMarginMillis ? part : (yield* files.runFileParts({ fileId, partNumbers: [part.partNumber] }))[0] ?? part;
+  const body = yield* readRange(path, (part.partNumber - 1) * upload.partSize, upload.partSize);
+  return { partNumber: part.partNumber, etag: yield* put2(fresh, contentType, body) };
+}));
+var uploadRunFile2 = (files, file) => Effect2.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const contentType = runFileContentType(file.name);
+  const byteSize = Number((yield* fs.stat(file.path)).size);
+  const hash = sha256Hasher();
+  yield* Stream.runForEach(fs.stream(file.path), (chunk) => Effect2.sync(() => hash.update(chunk)));
+  const { file: slotted, upload } = yield* files.createRunFile({
+    step: file.step,
+    name: file.name,
+    ...file.caption === undefined ? undefined : { caption: file.caption },
+    contentType,
+    byteSize,
+    sha256: hash.digest("hex")
+  });
+  if (upload === undefined)
+    return slotted;
+  return yield* upload.kind === "single" ? readRange(file.path, 0, byteSize).pipe(Effect2.flatMap((body) => put2(upload, contentType, body)), Effect2.andThen(files.completeRunFile({ fileId: slotted.id }))) : Effect2.flatMap(uploadParts(files, file.path, contentType, slotted.id, upload), (parts) => files.completeRunFile({ fileId: slotted.id, parts }));
+});
+var keepFile = (journal, step, { path, caption }) => Effect2.gen(function* () {
+  const kept = yield* uploadRunFile2(journal, { step, name: path.split("/").at(-1) ?? path, path, caption }).pipe(Effect2.catch((cause) => isPlatformError(cause) ? Effect2.fail(new StepFailed2({ step, reason: `Could not read ${path}: ${cause.message}` })) : requested(step, Effect2.fail(cause))));
+  if (kept.status !== "available")
+    return yield* new StepFailed2({
+      step,
+      reason: `Kitman rejected ${path}: storage holds bytes that do not match its size, digest or type`
+    });
+  return { id: kept.id };
+});
+var runnerActivities = (journal, services) => ({
   changeRequest: {
     run: (request, step) => requested(step, journal.performHostEffect({
       step,
@@ -724,7 +1153,14 @@ var runnerActivities = (journal) => ({
       }
     })).pipe(Effect2.asVoid)
   },
-  artifact: { run: (request, step) => requested(step, journal.storeArtifact({ step, ...request })) },
+  artifact: {
+    run: ({ files, ...request }, step) => requested(step, journal.storeArtifact({
+      step,
+      ...request,
+      ...files === undefined ? undefined : { fileIds: files.map((shown) => shown.id) }
+    }))
+  },
+  file: { run: (request, step) => keepFile(journal, step, request).pipe(Effect2.provideContext(services)) },
   note: { run: (request, step) => requested(step, journal.recordNote({ step, ...request })) },
   createTasks: {
     run: (request, step) => requested(step, Effect2.map(journal.createPlanTasks(request.tickets), (tasks) => ({ tasks })))
@@ -732,6 +1168,10 @@ var runnerActivities = (journal) => ({
   integrationBranch: {
     run: (request, step) => requested(step, journal.integrationBranch(request.repoBindingId))
   },
+  transcripts: { run: (request, step) => requested(step, journal.readTranscripts({ step, ...request })) },
+  propose: { run: (proposal, step) => requested(step, journal.propose({ step, proposal })) },
+  projectActivity: { run: (request, step) => requested(step, journal.readProject({ step, ...request })) },
+  draftUpdate: { run: (request, step) => requested(step, journal.draftUpdate({ step, ...request })) },
   mergeChangeRequest: {
     run: (request, step) => requested(step, journal.mergeChangeRequest({ step, ...request }))
   },
@@ -749,11 +1189,12 @@ var describeFailure = (cause) => {
 };
 var journalLoss = (cause) => cause.reasons.flatMap((reason) => Cause.isDieReason(reason) && reason.defect instanceof JournalWriteFailed2 ? [reason.defect] : [])[0];
 var runProgram2 = (loop, work, journal) => Effect2.scoped(Effect2.gen(function* () {
+  const services = yield* Effect2.context();
   const { engine, encoded } = yield* makeEncodedEngine(work.journal, journal);
   const workflow = loopWorkflow2(loop);
   const execute = executeLoop2(loop, {
     host: runnerHost(journal),
-    activities: runnerActivities(journal),
+    activities: runnerActivities(journal, services),
     granted: new Set(loop.capabilities.filter((capability) => work.granted.includes(capability)))
   });
   yield* Layer.build(workflow.toLayer(execute).pipe(Layer.provide(Layer.succeed(WorkflowEngine.WorkflowEngine)(engine))));
@@ -767,7 +1208,7 @@ var runProgram2 = (loop, work, journal) => Effect2.scoped(Effect2.gen(function*
     return "suspended";
   }
   if (Exit3.isSuccess(result.exit)) {
-    const output = yield* Schema5.encodeUnknownEffect(Schema5.toCodecJson(loop.output))(result.exit.value).pipe(Effect2.flatMap(Schema5.decodeUnknownEffect(Schema5.Json)), Effect2.option);
+    const output = yield* Schema8.encodeUnknownEffect(Schema8.toCodecJson(loop.output))(result.exit.value).pipe(Effect2.flatMap(Schema8.decodeUnknownEffect(Schema8.Json)), Effect2.option);
     if (Option.isSome(output)) {
       yield* written(journal.finish({ status: "completed", output: output.value }));
       return "completed";
@@ -790,6 +1231,11 @@ var programLease2 = (work) => ({
   fencingToken: work.lease.fencingToken,
   capacitySlot: work.lease.capacitySlot
 });
+var rpcRunFiles2 = (rpc, lease) => ({
+  createRunFile: (file) => rpc.createRunFile({ lease, ...file }),
+  runFileParts: (request) => Effect2.map(rpc.runFileParts({ lease, ...request, partNumbers: [...request.partNumbers] }), ({ parts }) => parts),
+  completeRunFile: ({ parts, ...request }) => rpc.completeRunFile({ lease, ...request, ...parts === undefined ? undefined : { parts: [...parts] } })
+});
 var rpcProgramJournal2 = (rpc, work) => {
   const lease = programLease2(work);
   return {
@@ -814,7 +1260,8 @@ var rpcProgramJournal2 = (rpc, work) => {
     startAgentStep: ({ secrets, ...step }) => rpc.startAgentStep({ lease, ...step, ...secrets === undefined ? undefined : { secrets: [...secrets] } }),
     awaitEvent: (wait) => rpc.awaitEvent({ lease, ...wait }),
     admitChild: (child) => rpc.admitChild({ lease, ...child }),
-    storeArtifact: (artifact) => rpc.storeArtifact({ lease, ...artifact }),
+    storeArtifact: ({ fileIds, ...artifact }) => rpc.storeArtifact({ lease, ...artifact, ...fileIds === undefined ? undefined : { fileIds: [...fileIds] } }),
+    ...rpcRunFiles2(rpc, lease),
     recordNote: (note) => rpc.recordNote({ lease, ...note }),
     performHostEffect: (request) => rpc.performHostEffect({ lease, ...request }),
     createPlanTasks: (tickets) => rpc.createPlanTasks({
@@ -829,6 +1276,28 @@ var rpcProgramJournal2 = (rpc, work) => {
       }))
     }),
     integrationBranch: (repoBindingId) => rpc.integrationBranch({ lease, ...repoBindingId === undefined ? undefined : { repoBindingId } }),
+    readTranscripts: (request) => rpc.readTranscripts({ lease, ...request }),
+    propose: ({ step, proposal }) => rpc.propose({
+      lease,
+      step,
+      proposal: proposal.kind === "memory" ? { ...proposal, citations: [...proposal.citations] } : {
+        kind: "task",
+        title: proposal.title,
+        description: proposal.description,
+        ...proposal.teamId === undefined ? undefined : { teamId: proposal.teamId },
+        citations: [...proposal.citations]
+      }
+    }),
+    readProject: (request) => rpc.readProject({ lease, ...request }),
+    draftUpdate: ({ writtenFrom, ...request }) => rpc.draftUpdate({
+      lease,
+      ...request,
+      writtenFrom: {
+        runs: writtenFrom.runs,
+        taskChanges: writtenFrom.taskChanges,
+        ...writtenFrom.since === undefined ? undefined : { since: writtenFrom.since }
+      }
+    }),
     mergeChangeRequest: (request) => rpc.mergeChangeRequest({ lease, ...request }),
     publishRelease: (request) => rpc.publishRelease({ lease, ...request }),
     suspend: rpc.suspend({ lease }),
@@ -839,7 +1308,7 @@ var rpcProgramJournal2 = (rpc, work) => {
 // packages/live/src/rpc/runner-client.ts
 import * as Effect3 from "effect/Effect";
 import * as Layer2 from "effect/Layer";
-import * as Stream from "effect/Stream";
+import * as Stream2 from "effect/Stream";
 import { RpcClient, RpcSerialization } from "effect/rpc";
 import * as Socket from "effect/socket/Socket";
 var proxiedWebSocket = (proxy) => Layer2.succeed(Socket.WebSocketConstructor)((target) => {
@@ -878,44 +1347,58 @@ var makeRunnerRpcClient = (options) => Effect3.gen(function* () {
     awaitEvent: (input) => authorized(client.AwaitEvent(input)),
     admitChild: (input) => authorized(client.AdmitChild(input)),
     storeArtifact: (input) => authorized(client.StoreArtifact(input)),
+    createRunFile: (input) => authorized(client.CreateRunFile(input)),
+    runFileParts: (input) => authorized(client.RunFileParts(input)),
+    completeRunFile: (input) => authorized(client.CompleteRunFile(input)),
     recordNote: (input) => authorized(client.RecordNote(input)),
     performHostEffect: (input) => authorized(client.PerformHostEffect(input)),
     createPlanTasks: (input) => authorized(client.CreatePlanTasks(input)),
+    readTranscripts: (input) => authorized(client.ReadTranscripts(input)),
+    propose: (input) => authorized(client.Propose(input)),
+    readProject: (input) => authorized(client.ReadProject(input)),
+    draftUpdate: (input) => authorized(client.DraftUpdate(input)),
     integrationBranch: (input) => authorized(client.IntegrationBranch(input)),
     mergeChangeRequest: (input) => authorized(client.MergeChangeRequest(input)),
     publishRelease: (input) => authorized(client.PublishRelease(input)),
     bundle: (digest) => authorized(client.Bundle({ digest })),
     settledRuns: (runIds) => authorized(client.SettledRuns({ runIds })),
     reportSteer: (input) => authorized(client.ReportSteer(input)),
+    appendTranscript: (input) => authorized(client.AppendTranscript(input)),
+    createCheckpointFile: (input) => authorized(client.CreateCheckpointFile(input)),
+    checkpointFileParts: (input) => authorized(client.CheckpointFileParts(input)),
+    completeCheckpointFile: (input) => authorized(client.CompleteCheckpointFile(input)),
     saveCheckpoint: (input) => authorized(client.SaveCheckpoint(input)),
     resumeCheckpoint: (input) => authorized(client.ResumeCheckpoint(input)),
     settledCheckpoints: authorized(client.SettledCheckpoints()),
     forgetCheckpoints: (stepAttemptIds) => authorized(client.ForgetCheckpoints({ stepAttemptIds })),
-    listen: (runnerReplicaId, onSignal) => authorized(Stream.runForEach(client.Signals({ runnerReplicaId }), onSignal))
+    listen: (runnerReplicaId, onSignal) => authorized(Stream2.runForEach(client.Signals({ runnerReplicaId }), onSignal))
   };
 });
 
 // packages/sdk/src/program/host.ts
 import * as BunRuntime from "@effect/platform-bun/BunRuntime";
+import * as BunServices from "@effect/platform-bun/BunServices";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect4 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
 import * as Option2 from "effect/Option";
 import * as Redacted2 from "effect/Redacted";
-import * as Schema6 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
 var describeFlag2 = "--kitman-describe";
-var Described2 = Schema6.Union([
-  Schema6.TaggedStruct("Described", {
-    loops: Schema6.Array(LoopManifest),
-    agents: Schema6.Record(Schema6.String, Schema6.Json),
-    schedules: Schema6.optionalKey(Schema6.Record(Schema6.String, Schema6.Json)),
-    kits: Schema6.optionalKey(Schema6.Record(Schema6.String, Schema6.Json))
+var Described2 = Schema9.Union([
+  Schema9.TaggedStruct("Described", {
+    loops: Schema9.Array(LoopManifest),
+    agents: Schema9.Record(Schema9.String, Schema9.Json),
+    schedules: Schema9.optionalKey(Schema9.Record(Schema9.String, Schema9.Json)),
+    kits: Schema9.optionalKey(Schema9.Record(Schema9.String, Schema9.Json))
   }),
-  Schema6.TaggedStruct("Refused", { error: Schema6.Union([ManifestInvalid2, LoopCheckError2]) })
+  Schema9.TaggedStruct("Refused", { error: Schema9.Union([ManifestInvalid2, LoopCheckError2]) })
 ]);
-var encodeDescribed = Schema6.encodeEffect(Schema6.fromJsonString(Schema6.toCodecJson(Described2)));
+var encodeDescribed = Schema9.encodeEffect(Schema9.fromJsonString(Schema9.toCodecJson(Described2)));
 
-class ProgramRefused extends Schema6.TaggedError()("ProgramRefused", { reason: Schema6.String }) {
+class ProgramRefused extends Schema9.TaggedError()("ProgramRefused", { reason: Schema9.String }) {
   get message() {
     return this.reason;
   }
@@ -1018,7 +1501,7 @@ var host = (config) => Effect4.gen(function* () {
   const loopId = yield* Config.String("KITMAN_LOOP_ID");
   const apiUrl = yield* Config.String("KITMAN_API_URL");
   const credential = yield* Config.Redacted("KITMAN_PROGRAM_CREDENTIAL");
-  const work = yield* Schema6.decodeEffect(Schema6.fromJsonString(Schema6.Unknown))(yield* readStdin);
+  const work = yield* Schema9.decodeEffect(Schema9.fromJsonString(Schema9.Unknown))(yield* readStdin);
   if (!isWorkUnit(work))
     return yield* new ProgramRefused({ reason: "stdin holds no orchestration Work Unit" });
   const loop = config.loops.find((candidate) => candidate.id === loopId);
@@ -1045,11 +1528,11 @@ var host = (config) => Effect4.gen(function* () {
   if (guard !== undefined)
     globalThis.fetch = Object.assign(guard.fetch, { preconnect: globalThis.fetch.preconnect });
   const journal = rpcProgramJournal2(rpc, work);
-  return yield* runProgram2(loop, work, guard === undefined ? journal : guard.journal(journal)).pipe(Effect4.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(secrets.value)), Effect4.as(0), Effect4.catchTag("JournalWriteFailed", (error) => Effect4.as(Effect4.logError(error.message), 1)));
+  return yield* runProgram2(loop, work, guard === undefined ? journal : guard.journal(journal)).pipe(Effect4.provide(Layer3.merge(BunServices.layer, FetchHttpClient.layer)), Effect4.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(secrets.value)), Effect4.as(0), Effect4.catchTag("JournalWriteFailed", (error) => Effect4.as(Effect4.logError(error.message), 1)));
 }).pipe(Effect4.scoped, Effect4.catch((error) => Effect4.as(Effect4.logError(error.message), 2)));
 var runPackage2 = (config) => {
   const program = process.argv.includes(describeFlag2) ? describe(config) : host(config);
   BunRuntime.runMain(program.pipe(Effect4.flatMap((code) => Effect4.sync(() => process.exit(code)))));
 };
 
-export { RunnerRpcProtocolVersion, JournalWriteFailed2, refusedStep2, runProgram2, programLease2, rpcProgramJournal2, describeFlag2, Described2, programSecrets2, programHostsEnv2, undeclaredHostsEnv2, networkGuard2, runPackage2 };
+export { digestSha256, RunnerRpcProtocolVersion, JournalWriteFailed2, refusedStep2, uploadRunFile2, runProgram2, programLease2, rpcRunFiles2, rpcProgramJournal2, describeFlag2, Described2, programSecrets2, programHostsEnv2, undeclaredHostsEnv2, networkGuard2, runPackage2 };