@kitman-sh/sdk 0.7.4 → 0.8.0

package/types/packages/sdk/src/loop/activities.d.ts

@@ -21,12 +21,30 @@ export declare const WriteBackRequest: Schema.Struct<{
     readonly milestone: Schema.optional<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
     readonly changeRequestUrl: Schema.optional<Schema.String>;
 }>;
+/** A file kept on the Run, by id. */
+export declare const RunFile: Schema.decodeTo<Schema.Struct<{
+    readonly id: Schema.String;
+}>, Schema.Struct<{
+    readonly runFile: Schema.String;
+}>, never, never>;
+export type RunFile = typeof RunFile.Type;
+/** A file the program wrote, by its path from the program's working directory. */
+export declare const FileRequest: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly caption: Schema.optional<Schema.String>;
+}>;
 /** A document stored in Kitman with the Run, such as a plan, findings or a conclusion; later Runs retrieve it. */
 export declare const ArtifactRequest: Schema.Struct<{
     readonly kind: Schema.String;
     readonly title: Schema.String;
     readonly text: Schema.String;
     readonly data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    /** Run Files the artifact shows. */
+    readonly files: Schema.optional<Schema.$Array<Schema.decodeTo<Schema.Struct<{
+        readonly id: Schema.String;
+    }>, Schema.Struct<{
+        readonly runFile: Schema.String;
+    }>, never, never>>>;
 }>;
 export declare const ArtifactResult: Schema.Struct<{
     readonly artifactId: Schema.String;
@@ -54,7 +72,7 @@ export declare const CreateTasksResult: Schema.Struct<{
         readonly taskId: Schema.String;
     }>>;
 }>;
-/** The Project's default RepoBinding when left out. */
+/** The Team's default RepoBinding when left out. */
 export declare const IntegrationBranchRequest: Schema.Struct<{
     readonly repoBindingId: Schema.optional<Schema.String>;
 }>;
@@ -93,6 +111,112 @@ export declare const ReleaseResult: Schema.Struct<{
     readonly url: Schema.String;
 }>;
 export type ReleaseResult = typeof ReleaseResult.Type;
+/** An entry of a Run's Transcript. */
+export declare const TranscriptPoint: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly stepAttemptId: Schema.String;
+    readonly sequence: Schema.Int;
+}>;
+export type TranscriptPoint = typeof TranscriptPoint.Type;
+export declare const TranscriptsRequest: Schema.Struct<{
+    readonly days: Schema.Int;
+}>;
+/** The Workspace's failed Runs of the window that the person the Run acts for may read, with their Transcripts. */
+export declare const TranscriptsResult: Schema.Struct<{
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly loopId: Schema.String;
+        readonly teamId: Schema.optional<Schema.String>;
+        readonly failure: Schema.optional<Schema.String>;
+        readonly entries: Schema.$Array<Schema.Struct<{
+            readonly stepAttemptId: Schema.String;
+            readonly sequence: Schema.Int;
+            readonly kind: Schema.String;
+            readonly text: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type TranscriptsResult = typeof TranscriptsResult.Type;
+/** Memory for a Team, or a Task, for people to accept; it cites the Transcript points it came from. */
+export declare const ProposeRequest: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"memory">;
+    readonly teamId: Schema.String;
+    readonly content: Schema.String;
+    readonly citations: Schema.NonEmptyArray<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly stepAttemptId: Schema.String;
+        readonly sequence: Schema.Int;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"task">;
+    readonly title: Schema.String;
+    readonly description: Schema.String;
+    /** The Team the approver is offered first. */
+    readonly teamId: Schema.optional<Schema.String>;
+    readonly citations: Schema.NonEmptyArray<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly stepAttemptId: Schema.String;
+        readonly sequence: Schema.Int;
+    }>>;
+}>]>;
+export type ProposeRequest = typeof ProposeRequest.Type;
+export declare const ProposeResult: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["memory", "task"]>;
+    readonly id: Schema.String;
+}>;
+export declare const ProjectActivityRequest: Schema.Struct<{
+    readonly projectId: Schema.String;
+}>;
+/**
+ * A Project's Runs and Task changes since its latest Update, as the person the Run acts for may read them: a Run's
+ * Transcript entries only where that person may read its repositories.
+ */
+export declare const ProjectActivityResult: Schema.Struct<{
+    readonly project: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+    }>;
+    /** The latest Update's health; left out while the Project has none. */
+    readonly health: Schema.optional<Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>>;
+    /** When the latest Update was posted; left out while there is none. */
+    readonly since: Schema.optional<Schema.String>;
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly loopId: Schema.String;
+        readonly status: Schema.String;
+        readonly taskKey: Schema.optional<Schema.String>;
+        readonly taskTitle: Schema.optional<Schema.String>;
+        readonly summary: Schema.optional<Schema.String>;
+        readonly entries: Schema.$Array<Schema.Struct<{
+            readonly stepAttemptId: Schema.String;
+            readonly sequence: Schema.Int;
+            readonly kind: Schema.String;
+            readonly text: Schema.String;
+        }>>;
+    }>>;
+    readonly taskChanges: Schema.$Array<Schema.Struct<{
+        readonly taskKey: Schema.String;
+        readonly title: Schema.String;
+        readonly change: Schema.String;
+        readonly at: Schema.String;
+    }>>;
+}>;
+export type ProjectActivityResult = typeof ProjectActivityResult.Type;
+/** A draft Project Update for the person the Run acts for, who reviews and posts it. */
+export declare const DraftUpdateRequest: Schema.Struct<{
+    readonly projectId: Schema.String;
+    readonly health: Schema.Literals<readonly ["on_track", "at_risk", "off_track"]>;
+    readonly note: Schema.String;
+    readonly writtenFrom: Schema.Struct<{
+        readonly runs: Schema.Int;
+        readonly taskChanges: Schema.Int;
+        readonly since: Schema.optional<Schema.String>;
+    }>;
+}>;
+export type DraftUpdateRequest = typeof DraftUpdateRequest.Type;
+export declare const DraftUpdateResult: Schema.Struct<{
+    readonly id: Schema.String;
+}>;
 declare const ChangeRequestActivity_base: Context.ServiceClass<ChangeRequestActivity, "@kitman-sh/sdk/loop/ChangeRequestActivity", {
     /** A Run has one ChangeRequest: it opens once, and a later Step updates it. */
     readonly run: (request: typeof ChangeRequestRequest.Type, step: string) => Effect.Effect<ChangeRequestResult, StepFailed>;
@@ -113,6 +237,12 @@ declare const ArtifactActivity_base: Context.ServiceClass<ArtifactActivity, "@ki
 /** Stores a Run artifact in Kitman, indexed for later Runs' ContextPacks and search. */
 export declare class ArtifactActivity extends ArtifactActivity_base {
 }
+declare const FileActivity_base: Context.ServiceClass<FileActivity, "@kitman-sh/sdk/loop/FileActivity", {
+    readonly run: (request: typeof FileRequest.Type, step: string) => Effect.Effect<RunFile, StepFailed>;
+}>;
+/** Keeps a file on the Run, counted against the Workspace's storage. */
+export declare class FileActivity extends FileActivity_base {
+}
 declare const NoteActivity_base: Context.ServiceClass<NoteActivity, "@kitman-sh/sdk/loop/NoteActivity", {
     readonly run: (request: typeof NoteRequest.Type, step: string) => Effect.Effect<void, StepFailed>;
 }>;
@@ -150,6 +280,30 @@ declare const ReleaseActivity_base: Context.ServiceClass<ReleaseActivity, "@kitm
 /** Tags and publishes a release on the Run's repository through the external-effect ledger; a Step releases once. */
 export declare class ReleaseActivity extends ReleaseActivity_base {
 }
+declare const TranscriptsActivity_base: Context.ServiceClass<TranscriptsActivity, "@kitman-sh/sdk/loop/TranscriptsActivity", {
+    readonly run: (request: typeof TranscriptsRequest.Type, step: string) => Effect.Effect<TranscriptsResult, StepFailed>;
+}>;
+/** Reads Transcripts through the Transcript access rule, as the person the Run acts for. */
+export declare class TranscriptsActivity extends TranscriptsActivity_base {
+}
+declare const ProposeActivity_base: Context.ServiceClass<ProposeActivity, "@kitman-sh/sdk/loop/ProposeActivity", {
+    readonly run: (request: ProposeRequest, step: string) => Effect.Effect<typeof ProposeResult.Type, StepFailed>;
+}>;
+/** Proposes Memory or a Task; a Step proposes once. */
+export declare class ProposeActivity extends ProposeActivity_base {
+}
+declare const ProjectActivityActivity_base: Context.ServiceClass<ProjectActivityActivity, "@kitman-sh/sdk/loop/ProjectActivityActivity", {
+    readonly run: (request: typeof ProjectActivityRequest.Type, step: string) => Effect.Effect<ProjectActivityResult, StepFailed>;
+}>;
+/** Reads a Project's activity since its latest Update, as the person the Run acts for. */
+export declare class ProjectActivityActivity extends ProjectActivityActivity_base {
+}
+declare const DraftUpdateActivity_base: Context.ServiceClass<DraftUpdateActivity, "@kitman-sh/sdk/loop/DraftUpdateActivity", {
+    readonly run: (request: DraftUpdateRequest, step: string) => Effect.Effect<typeof DraftUpdateResult.Type, StepFailed>;
+}>;
+/** Drafts a Project Update for the person the Run acts for; a Run drafts once. Nothing a Loop calls posts one. */
+export declare class DraftUpdateActivity extends DraftUpdateActivity_base {
+}
 export declare const changeRequest: (name: string, request: typeof ChangeRequestRequest.Type) => Effect.Effect<{
     readonly id: string;
     readonly number: string;
@@ -159,6 +313,10 @@ export declare const writeBack: (name: string, request: typeof WriteBackRequest.
 export declare const artifact: (name: string, request: typeof ArtifactRequest.Type) => Effect.Effect<{
     readonly artifactId: string;
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ArtifactActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/** The file is uploaded once; a replay returns the Run File it kept. */
+export declare const file: (name: string, request: typeof FileRequest.Type) => Effect.Effect<{
+    readonly id: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, FileActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 export declare const note: (name: string, request: typeof NoteRequest.Type) => Effect.Effect<void, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | NoteActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 export declare const comment: (name: string, request: typeof CommentRequest.Type) => Effect.Effect<void, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, CommentActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 export declare const createTasks: (name: string, request: typeof CreateTasksRequest.Type) => Effect.Effect<{
@@ -184,4 +342,53 @@ export declare const release: (name: string, request: typeof ReleaseRequest.Type
     readonly revision: string;
     readonly url: string;
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | ReleaseActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const transcripts: (name: string, request: typeof TranscriptsRequest.Type) => Effect.Effect<{
+    readonly runs: readonly {
+        readonly runId: string;
+        readonly loopId: string;
+        readonly teamId?: string | undefined;
+        readonly failure?: string | undefined;
+        readonly entries: readonly {
+            readonly stepAttemptId: string;
+            readonly sequence: number;
+            readonly kind: string;
+            readonly text: string;
+        }[];
+    }[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | TranscriptsActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const propose: (name: string, request: ProposeRequest) => Effect.Effect<{
+    readonly kind: "memory" | "task";
+    readonly id: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | ProposeActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const projectActivity: (name: string, request: typeof ProjectActivityRequest.Type) => Effect.Effect<{
+    readonly project: {
+        readonly id: string;
+        readonly name: string;
+    };
+    readonly health?: "at_risk" | "off_track" | "on_track" | undefined;
+    readonly since?: string | undefined;
+    readonly runs: readonly {
+        readonly runId: string;
+        readonly loopId: string;
+        readonly status: string;
+        readonly taskKey?: string | undefined;
+        readonly taskTitle?: string | undefined;
+        readonly summary?: string | undefined;
+        readonly entries: readonly {
+            readonly stepAttemptId: string;
+            readonly sequence: number;
+            readonly kind: string;
+            readonly text: string;
+        }[];
+    }[];
+    readonly taskChanges: readonly {
+        readonly taskKey: string;
+        readonly title: string;
+        readonly change: string;
+        readonly at: string;
+    }[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | ProjectActivityActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const draftUpdate: (name: string, request: DraftUpdateRequest) => Effect.Effect<{
+    readonly id: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, DraftUpdateActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 export {};

package/types/packages/sdk/src/loop/config.d.ts

@@ -18,7 +18,7 @@ export type AgentConfig = {
     readonly network?: {
         readonly hosts: readonly string[];
     } | 'open';
-    /** Runs its Steps only on Runners that run agents in docker, for services or a project image. */
+    /** Runs its Steps only on Runners that run agents in docker, for services or a team image. */
     readonly sandbox?: 'docker';
 };
 /** A Kit written from the Package's files: its context, and skill directories each holding a `SKILL.md`. */

package/types/packages/sdk/src/loop/define.d.ts

@@ -1,10 +1,11 @@
 import { LoopCapabilities, type LoopManifest } from '../../../core/src/package-declarations';
+import type { ScheduleRule } from '../../../core/src/schedule';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 import type { WorkflowEngine } from 'effect/workflow';
 import type { LoopHost, LoopRun } from './steps';
 import type { LoopCheck } from './test-loop';
-import type { ArtifactActivity, ChangeRequestActivity, CommentActivity, CreateTasksActivity, IntegrationBranchActivity, MergeChangeRequestActivity, NoteActivity, ReleaseActivity, WriteBackActivity } from './activities';
+import type { ArtifactActivity, ChangeRequestActivity, CommentActivity, CreateTasksActivity, FileActivity, IntegrationBranchActivity, MergeChangeRequestActivity, NoteActivity, ProjectActivityActivity, DraftUpdateActivity, ProposeActivity, ReleaseActivity, TranscriptsActivity, WriteBackActivity } from './activities';
 export { LoopCapabilities, type LoopManifest };
 /** What a Loop's program may ask Kitman for; the control plane checks each request against them. */
 export type LoopCapability = (typeof LoopCapabilities)[number];
@@ -31,7 +32,7 @@ export type LoopOffer = {
     readonly loop: string;
 };
 /** The services a Loop's program runs with; a Runner or `testLoop` provides them. */
-export type LoopServices = LoopRun | LoopHost | ChangeRequestActivity | WriteBackActivity | ArtifactActivity | NoteActivity | CommentActivity | CreateTasksActivity | IntegrationBranchActivity | MergeChangeRequestActivity | ReleaseActivity | WorkflowEngine.WorkflowEngine | WorkflowEngine.WorkflowInstance;
+export type LoopServices = LoopRun | LoopHost | ChangeRequestActivity | WriteBackActivity | ArtifactActivity | FileActivity | NoteActivity | CommentActivity | CreateTasksActivity | IntegrationBranchActivity | MergeChangeRequestActivity | ReleaseActivity | TranscriptsActivity | ProposeActivity | ProjectActivityActivity | DraftUpdateActivity | WorkflowEngine.WorkflowEngine | WorkflowEngine.WorkflowInstance;
 /** A schema a Loop can decode and encode with no services. */
 export type LoopSchema<T> = Schema.Codec<T, unknown>;
 export type LoopDefinition<In, Out, E> = {
@@ -57,6 +58,11 @@ export type LoopDefinition<In, Out, E> = {
     readonly network?: {
         readonly hosts: readonly string[];
     } | 'open';
+    /** A Schedule a Workspace can turn on in one click; off until someone does. */
+    readonly schedule?: {
+        readonly rule: ScheduleRule;
+        readonly timezone: string;
+    };
     readonly run: (input: In) => Effect.Effect<Out, E, LoopServices>;
     /** Scripts a build runs twice, the second time from the journal; not part of the manifest. */
     readonly checks?: readonly LoopCheck[];

package/types/packages/sdk/src/loop/plan.d.ts

@@ -7,7 +7,7 @@ export declare const PlanTicket: Schema.Struct<{
     readonly title: Schema.String;
     readonly body: Schema.String;
     readonly acceptanceCriteria: Schema.$Array<Schema.String>;
-    /** The repository it changes; the Project's default when left out. */
+    /** The repository it changes; the Team's default when left out. */
     readonly repoBindingId: Schema.optional<Schema.String>;
     /** Keys of the tickets that must be built first. */
     readonly blockedBy: Schema.$Array<Schema.String>;
@@ -22,7 +22,7 @@ export declare const PlanTickets: Schema.$Array<Schema.Struct<{
     readonly title: Schema.String;
     readonly body: Schema.String;
     readonly acceptanceCriteria: Schema.$Array<Schema.String>;
-    /** The repository it changes; the Project's default when left out. */
+    /** The repository it changes; the Team's default when left out. */
     readonly repoBindingId: Schema.optional<Schema.String>;
     /** Keys of the tickets that must be built first. */
     readonly blockedBy: Schema.$Array<Schema.String>;

package/types/packages/sdk/src/loop/steps.d.ts

@@ -41,7 +41,7 @@ export declare class ChildFailed extends ChildFailed_base {
 }
 declare const CapabilityDenied_base: Schema.Class<CapabilityDenied, Schema.TaggedStruct<"CapabilityDenied", {
     readonly step: Schema.String;
-    readonly capability: Schema.Literals<readonly ["agent_work", "ask", "call", "verify", "change_request", "write_back", "post_comment", "create_tasks", "merge_change_request", "publish_release"]>;
+    readonly capability: Schema.Literals<readonly ["agent_work", "ask", "call", "verify", "change_request", "write_back", "post_comment", "create_tasks", "merge_change_request", "publish_release", "read_transcripts", "propose", "read_project", "draft_update"]>;
     /** A Secret the Step names that its Loop does not declare. */
     readonly secret: Schema.optionalKey<Schema.String>;
 }>, Cause.YieldableError>;
@@ -64,7 +64,7 @@ export declare const LoopEvent: Schema.Struct<{
     readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 }>;
 export type LoopEvent = typeof LoopEvent.Type;
-export type StepKind = 'agent_work' | 'ask' | 'call' | 'wait_for' | 'verify' | 'change_request' | 'write_back' | 'artifact' | 'note' | 'comment' | 'create_tasks' | 'integration_branch' | 'merge_change_request' | 'release';
+export type StepKind = 'agent_work' | 'ask' | 'call' | 'wait_for' | 'verify' | 'change_request' | 'write_back' | 'artifact' | 'file' | 'note' | 'comment' | 'create_tasks' | 'integration_branch' | 'merge_change_request' | 'release' | 'transcripts' | 'propose' | 'project_activity' | 'draft_update';
 /** A Step a Run took, as its program saw it. */
 export type StepRecord = {
     readonly name: string;

package/types/packages/sdk/src/loop/test-loop.d.ts

@@ -2,7 +2,7 @@ import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
 import * as Schema from 'effect/Schema';
 import { Workflow, WorkflowEngine } from 'effect/workflow';
-import { ArtifactActivity, ChangeRequestActivity, CommentActivity, CreateTasksActivity, IntegrationBranchActivity, MergeChangeRequestActivity, NoteActivity, ReleaseActivity, WriteBackActivity } from './activities';
+import { ArtifactActivity, ChangeRequestActivity, CommentActivity, CreateTasksActivity, FileActivity, IntegrationBranchActivity, MergeChangeRequestActivity, NoteActivity, ProjectActivityActivity, DraftUpdateActivity, ProposeActivity, ReleaseActivity, TranscriptsActivity, WriteBackActivity } from './activities';
 import type { LoopCapability, LoopDefinition } from './define';
 import type { VerifyResult } from './evidence';
 import { InputInvalid, LoopHost, LoopRun, type LoopEvent, type StepRecord } from './steps';
@@ -26,12 +26,17 @@ export type HostActivities = {
     readonly changeRequest: ChangeRequestActivity['Service'];
     readonly writeBack: WriteBackActivity['Service'];
     readonly artifact: ArtifactActivity['Service'];
+    readonly file: FileActivity['Service'];
     readonly note: NoteActivity['Service'];
     readonly comment: CommentActivity['Service'];
     readonly createTasks: CreateTasksActivity['Service'];
     readonly integrationBranch: IntegrationBranchActivity['Service'];
     readonly mergeChangeRequest: MergeChangeRequestActivity['Service'];
     readonly release: ReleaseActivity['Service'];
+    readonly transcripts: TranscriptsActivity['Service'];
+    readonly propose: ProposeActivity['Service'];
+    readonly projectActivity: ProjectActivityActivity['Service'];
+    readonly draftUpdate: DraftUpdateActivity['Service'];
 };
 export type TestLoopScript = {
     /** The Loop Input as JSON, as a Run receives it. */

package/types/packages/sdk/src/program/engine.d.ts

@@ -1,8 +1,10 @@
-import { type OrchestrationWorkUnit, type ProgramWorkUnit } from '../../../core/src/index';
-import { type ChangeRequestResult, type EventFilter, type IntegrationBranch, type LoopDefinition, type MergeResult, type ReleaseResult, type PlanTicket, type WriteBackMilestones, type SuggestedVerification } from '../loop';
+import { type OrchestrationWorkUnit, type ProgramWorkUnit, type RunFilePartUrl, type RunFileRecord, type RunFileUpload } from '../../../core/src/index';
+import { type ChangeRequestResult, type EventFilter, type IntegrationBranch, type LoopDefinition, type MergeResult, type ReleaseResult, type PlanTicket, type ProposeRequest, type TranscriptsResult, type DraftUpdateRequest, type ProjectActivityResult, type WriteBackMilestones, type SuggestedVerification } from '../loop';
 import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
+import * as FileSystem from 'effect/FileSystem';
 import * as Schema from 'effect/Schema';
+import * as HttpClient from 'effect/http/HttpClient';
 import { type ProgramLease } from '../../../live/src/rpc/runner-group';
 import type { RunnerRpcClient } from '../../../live/src/rpc/runner-client';
 type WriteBackMilestone = (typeof WriteBackMilestones)[number];
@@ -71,9 +73,32 @@ export type ProgramJournal = {
         readonly title: string;
         readonly text: string;
         readonly data?: Schema.Json | undefined;
+        readonly fileIds?: readonly string[];
     }) => Effect.Effect<{
         readonly artifactId: string;
     }, Error>;
+    readonly createRunFile: (file: {
+        readonly step: string;
+        readonly name: string;
+        readonly caption?: string;
+        readonly contentType: string;
+        readonly byteSize: number;
+        readonly sha256: string;
+    }) => Effect.Effect<{
+        readonly file: RunFileRecord;
+        readonly upload?: RunFileUpload | undefined;
+    }, Error>;
+    readonly runFileParts: (request: {
+        readonly fileId: string;
+        readonly partNumbers: readonly number[];
+    }) => Effect.Effect<readonly (typeof RunFilePartUrl.Type)[], Error>;
+    readonly completeRunFile: (request: {
+        readonly fileId: string;
+        readonly parts?: readonly {
+            readonly partNumber: number;
+            readonly etag: string;
+        }[];
+    }) => Effect.Effect<RunFileRecord, Error>;
     readonly recordNote: (note: {
         readonly step: string;
         readonly text: string;
@@ -100,6 +125,26 @@ export type ProgramJournal = {
         readonly key: string;
         readonly taskId: string;
     }[], Error>;
+    readonly readTranscripts: (request: {
+        readonly step: string;
+        readonly days: number;
+    }) => Effect.Effect<TranscriptsResult, Error>;
+    readonly propose: (request: {
+        readonly step: string;
+        readonly proposal: ProposeRequest;
+    }) => Effect.Effect<{
+        readonly kind: 'memory' | 'task';
+        readonly id: string;
+    }, Error>;
+    readonly readProject: (request: {
+        readonly step: string;
+        readonly projectId: string;
+    }) => Effect.Effect<ProjectActivityResult, Error>;
+    readonly draftUpdate: (request: DraftUpdateRequest & {
+        readonly step: string;
+    }) => Effect.Effect<{
+        readonly id: string;
+    }, Error>;
     readonly integrationBranch: (repoBindingId?: string) => Effect.Effect<IntegrationBranch, Error>;
     readonly mergeChangeRequest: (request: {
         readonly step: string;
@@ -132,13 +177,36 @@ export declare class JournalWriteFailed extends JournalWriteFailed_base<{
 }
 /** A refusal of the request itself, as opposed to a lost lease or a failure of Kitman's. */
 export declare const refusedStep: (cause: Error) => boolean;
+/** What uploading a Run File asks of Kitman, under whichever lease its maker holds. */
+export type RunFileClient = Pick<ProgramJournal, 'createRunFile' | 'runFileParts' | 'completeRunFile'>;
+type FileServices = FileSystem.FileSystem | HttpClient.HttpClient;
+/** Hashes the file at `path`, uploads it straight to storage and completes it; its status says whether Kitman kept it. */
+export declare const uploadRunFile: (files: RunFileClient, file: {
+    readonly step: string;
+    readonly name: string;
+    readonly path: string;
+    readonly caption?: string | undefined;
+}) => Effect.Effect<{
+    readonly id: string;
+    readonly runId: string;
+    readonly step: string;
+    readonly name: string;
+    readonly caption?: string;
+    readonly contentType: string;
+    readonly kind: "html" | "image" | "other" | "text" | "video";
+    readonly byteSize: number;
+    readonly sha256: string;
+    readonly status: "available" | "expired" | "refused" | "rejected" | "removed" | "removing" | "uploading";
+}, Error | import("effect/http/HttpClientError").HttpClientError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | HttpClient.HttpClient>;
 /**
  * Runs or replays a Run's program for one orchestration lease, and reports what became of it: suspended, with the
  * lease given back; completed; or failed. A refused journal write means the lease is gone, so nothing is reported.
  */
-export declare const runProgram: <In, Out, E>(loop: LoopDefinition<In, Out, E>, work: ProgramWorkUnit, journal: ProgramJournal) => Effect.Effect<'suspended' | 'completed' | 'failed', JournalWriteFailed>;
+export declare const runProgram: <In, Out, E>(loop: LoopDefinition<In, Out, E>, work: ProgramWorkUnit, journal: ProgramJournal) => Effect.Effect<'suspended' | 'completed' | 'failed', JournalWriteFailed, FileServices>;
 /** A Work Unit's lease as the Runner RPC calls carry it. */
 export declare const programLease: (work: Pick<OrchestrationWorkUnit, 'id' | 'lease'>) => ProgramLease;
+/** Run File uploads over the Runner RPC channel, under `lease`. */
+export declare const rpcRunFiles: (rpc: Pick<RunnerRpcClient, 'createRunFile' | 'runFileParts' | 'completeRunFile'>, lease: ProgramLease) => RunFileClient;
 /** The journal over the Runner RPC channel, each write under the Work Unit's lease. */
 export declare const rpcProgramJournal: (rpc: RunnerRpcClient, work: ProgramWorkUnit) => ProgramJournal;
 export {};

package/types/packages/sdk/src/program/host.d.ts

@@ -27,11 +27,23 @@ export declare const Described: Schema.Union<readonly [Schema.TaggedStruct<"Desc
             readonly title: Schema.String;
             readonly loop: Schema.String;
         }>>;
-        readonly capabilities: Schema.$Array<Schema.Literals<readonly ["agent_work", "ask", "call", "verify", "change_request", "write_back", "post_comment", "create_tasks", "merge_change_request", "publish_release"]>>;
+        readonly capabilities: Schema.$Array<Schema.Literals<readonly ["agent_work", "ask", "call", "verify", "change_request", "write_back", "post_comment", "create_tasks", "merge_change_request", "publish_release", "read_transcripts", "propose", "read_project", "draft_update"]>>;
         readonly secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
         readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
             readonly hosts: Schema.$Array<Schema.String>;
         }>, Schema.Literal<"open">]>>;
+        readonly schedule: Schema.optionalKey<Schema.Struct<{
+            readonly rule: Schema.Union<readonly [Schema.Struct<{
+                readonly frequency: Schema.Literals<readonly ["daily", "weekly"]>;
+                readonly hour: Schema.Int;
+                readonly minute: Schema.Int;
+                readonly second: Schema.optionalKey<Schema.Int>;
+                readonly daysOfWeek: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+            }>, Schema.Struct<{
+                readonly cron: Schema.String;
+            }>]>;
+            readonly timezone: Schema.String;
+        }>>;
     }>>;
     readonly agents: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     readonly schedules: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;

package/types/packages/core/src/enterprise-code-host.d.ts

@@ -1,18 +0,0 @@
-import { type CodeHostCapability } from './integration';
-type EnterpriseCodeHostSetup = {
-    readonly provider: 'github' | 'gitlab';
-    readonly host: string;
-    readonly tls?: {
-        readonly customCaRef?: string;
-    };
-    readonly capabilities: readonly CodeHostCapability[];
-};
-type EnterpriseSupportEvidence = {
-    readonly provider: 'github' | 'gitlab';
-    readonly host: string;
-    readonly capability: CodeHostCapability;
-    readonly support: 'certified' | 'detected' | 'unsupported';
-    readonly evidenceDigest: string;
-};
-export declare function certifyEnterpriseCodeHostSetup(setup: EnterpriseCodeHostSetup): readonly EnterpriseSupportEvidence[];
-export {};

package/types/packages/core/src/project.d.ts

@@ -1,66 +0,0 @@
-import * as Schema from 'effect/Schema';
-export declare const ProjectDeliverySettings: Schema.Struct<{
-    readonly defaultRepoBindingId: Schema.optionalKey<Schema.String>;
-    readonly standardBranchTemplate: Schema.String;
-    readonly epicBranchTemplate: Schema.String;
-    readonly isolatedChildBranchTemplate: Schema.String;
-    readonly revision: Schema.Int;
-}>;
-export declare const ProjectDeliverySettingsUpdate: Schema.Struct<{
-    readonly defaultRepoBindingId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
-    readonly standardBranchTemplate: Schema.optionalKey<Schema.String>;
-    readonly epicBranchTemplate: Schema.optionalKey<Schema.String>;
-    readonly isolatedChildBranchTemplate: Schema.optionalKey<Schema.String>;
-    readonly expectedRevision: Schema.Int;
-}>;
-export declare const ProjectDirectoryItem: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly workspaceId: Schema.String;
-    readonly name: Schema.String;
-    readonly slug: Schema.String;
-    readonly description: Schema.optionalKey<Schema.String>;
-    readonly sourceType: Schema.Literal<"manual">;
-    readonly openTaskCount: Schema.Int;
-    readonly blockedTaskCount: Schema.Int;
-    readonly createdAt: Schema.String;
-    readonly updatedAt: Schema.String;
-}>;
-export declare const Project: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly workspaceId: Schema.String;
-    readonly name: Schema.String;
-    readonly slug: Schema.String;
-    readonly description: Schema.optionalKey<Schema.String>;
-    readonly sourceType: Schema.Literal<"manual">;
-    readonly openTaskCount: Schema.Int;
-    readonly blockedTaskCount: Schema.Int;
-    readonly createdAt: Schema.String;
-    readonly updatedAt: Schema.String;
-    readonly defaultStatusMapping: Schema.$Record<Schema.String, Schema.String>;
-}>;
-export declare const ProjectCreate: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly slug: Schema.optionalKey<Schema.String>;
-    readonly description: Schema.optionalKey<Schema.String>;
-    readonly sourceType: Schema.optionalKey<Schema.Literal<"manual">>;
-}>;
-export declare const ProjectList: Schema.Struct<{
-    readonly items: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.String;
-        readonly workspaceId: Schema.String;
-        readonly name: Schema.String;
-        readonly slug: Schema.String;
-        readonly description: Schema.optionalKey<Schema.String>;
-        readonly sourceType: Schema.Literal<"manual">;
-        readonly openTaskCount: Schema.Int;
-        readonly blockedTaskCount: Schema.Int;
-        readonly createdAt: Schema.String;
-        readonly updatedAt: Schema.String;
-    }>>;
-}>;
-export type Project = (typeof Project)['Type'];
-export type ProjectDirectoryItem = (typeof ProjectDirectoryItem)['Type'];
-export type ProjectCreate = (typeof ProjectCreate)['Type'];
-export type ProjectList = (typeof ProjectList)['Type'];
-export type ProjectDeliverySettings = (typeof ProjectDeliverySettings)['Type'];
-export type ProjectDeliverySettingsUpdate = (typeof ProjectDeliverySettingsUpdate)['Type'];