@kitman-sh/sdk 0.9.0 → 0.10.53

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

@@ -18,6 +18,8 @@ export declare const NotificationPayload: Schema.Struct<{
     readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
     /** What a Run needs that Kitman could not choose, such as its Loop or repository. */
     readonly missing: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    /** The ChangeRequests a person can choose between for a missing `changeRequestId`, as links. */
+    readonly choices: Schema.optionalKey<Schema.$Array<Schema.String>>;
     readonly projectId: Schema.optionalKey<Schema.String>;
     readonly projectName: Schema.optionalKey<Schema.String>;
     /** What a drafted Project Update was written from, since the Update before it. */
@@ -63,6 +65,8 @@ export declare const Notification: Schema.Struct<{
         readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
         /** What a Run needs that Kitman could not choose, such as its Loop or repository. */
         readonly missing: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        /** The ChangeRequests a person can choose between for a missing `changeRequestId`, as links. */
+        readonly choices: Schema.optionalKey<Schema.$Array<Schema.String>>;
         readonly projectId: Schema.optionalKey<Schema.String>;
         readonly projectName: Schema.optionalKey<Schema.String>;
         /** What a drafted Project Update was written from, since the Update before it. */
@@ -125,6 +129,8 @@ export declare const InboxItem: Schema.Struct<{
             readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
             /** What a Run needs that Kitman could not choose, such as its Loop or repository. */
             readonly missing: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            /** The ChangeRequests a person can choose between for a missing `changeRequestId`, as links. */
+            readonly choices: Schema.optionalKey<Schema.$Array<Schema.String>>;
             readonly projectId: Schema.optionalKey<Schema.String>;
             readonly projectName: Schema.optionalKey<Schema.String>;
             /** What a drafted Project Update was written from, since the Update before it. */
@@ -185,6 +191,8 @@ export declare const InboxList: Schema.Struct<{
                 readonly changeRequestUrl: Schema.optionalKey<Schema.String>;
                 /** What a Run needs that Kitman could not choose, such as its Loop or repository. */
                 readonly missing: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                /** The ChangeRequests a person can choose between for a missing `changeRequestId`, as links. */
+                readonly choices: Schema.optionalKey<Schema.$Array<Schema.String>>;
                 readonly projectId: Schema.optionalKey<Schema.String>;
                 readonly projectName: Schema.optionalKey<Schema.String>;
                 /** What a drafted Project Update was written from, since the Update before it. */

package/types/packages/core/src/npm-registry.d.ts

@@ -0,0 +1,65 @@
+import * as Config from 'effect/Config';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+/** The `kitman` field `kitman kit build` writes into a Kit's `package.json`: its built files, by path in the package. */
+export declare const KitManifest: Schema.Struct<{
+    readonly bundle: Schema.String;
+    readonly digest: Schema.String;
+    readonly protocolVersion: Schema.Int;
+    readonly declarations: Schema.String;
+    readonly setup: Schema.$Record<Schema.String, Schema.String>;
+}>;
+export type KitManifest = typeof KitManifest.Type;
+/** A Kit as one npm version publishes it, its tarball checked against npm's integrity. */
+export type PublishedKit = {
+    readonly name: string;
+    readonly version: string;
+    readonly integrity: string;
+    readonly bundle: Uint8Array;
+    readonly digest: string;
+    readonly protocolVersion: number;
+    readonly declarations: unknown;
+    readonly setupArchives: readonly {
+        readonly digest: string;
+        readonly archive: Uint8Array;
+    }[];
+};
+declare const NpmRegistryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NpmRegistryError";
+} & Readonly<A>;
+/** `unreachable` may succeed when tried again; the others name a version that never will. */
+export declare class NpmRegistryError extends NpmRegistryError_base<{
+    readonly kind: 'unreachable' | 'not_found' | 'integrity' | 'not_a_kit';
+    readonly message: string;
+}> {
+}
+type NpmRegistryService = {
+    /** The version npm's `latest` dist-tag names. */
+    readonly latest: (name: string) => Effect.Effect<string, NpmRegistryError>;
+    /** The built Kit `version` (a version or dist-tag) of `name` carries. */
+    readonly kit: (name: string, version: string) => Effect.Effect<PublishedKit, NpmRegistryError>;
+};
+declare const Dist: Schema.Struct<{
+    readonly tarball: Schema.String;
+    readonly integrity: Schema.optionalKey<Schema.String>;
+    readonly shasum: Schema.optionalKey<Schema.String>;
+}>;
+/** An npm package's metadata; old versions may carry only a `shasum`. */
+export declare const Packument: Schema.Struct<{
+    readonly 'dist-tags': Schema.$Record<Schema.String, Schema.String>;
+    readonly versions: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly dist: Schema.Struct<{
+            readonly tarball: Schema.String;
+            readonly integrity: Schema.optionalKey<Schema.String>;
+            readonly shasum: Schema.optionalKey<Schema.String>;
+        }>;
+    }>>;
+}>;
+/** Whether `tarball` matches its `dist`: the strongest algorithm its integrity names, else its sha1 `shasum`. */
+export declare const tarballMatches: (tarball: Uint8Array, dist: typeof Dist.Type) => boolean;
+/** The registry at `url`, or at `NPM_CONFIG_REGISTRY` read on each call. */
+export declare const npmRegistryAt: (url?: string | Config.Config<string>) => NpmRegistryService;
+/** npm, as Kitman reads Kits and latest versions from it; tests point it at a local fake. */
+export declare const NpmRegistry: Context.Reference<NpmRegistryService>;
+export {};

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

@@ -1,7 +1,6 @@
 import * as Schema from 'effect/Schema';
 export declare const ProposalStatuses: readonly ['proposed', 'in_review', 'approved', 'rejected', 'applied', 'reverted', 'superseded', 'canceled'];
 export declare const KitMarketplaceProposalTargetTypes: readonly ['kit_source', 'kit_version', 'kit_installation', 'kit_activation', 'kit_trust_policy'];
-export declare const KitMarketplaceProposalActions: readonly ['source_publish', 'version_publish', 'source_update', 'trust_change', 'visibility_change', 'broad_activation', 'risky_agent_environment_effect', 'rollback'];
 export declare const ProposalTargetTypes: readonly ["memory", "kit", "agent_environment_policy", "decision", "task", "team_context", "context_relevance", "kit_source", "kit_version", "kit_installation", "kit_activation", "kit_trust_policy"];
 export declare const ProposalRiskLevels: readonly ['low', 'medium', 'high'];
 export declare const ProposalApprovalPolicyModes: readonly ['auto_approve_low_risk', 'require_other_team_member', 'require_workspace_owner_or_admin'];
@@ -76,71 +75,6 @@ export declare const ProposalRiskSummary: Schema.Struct<{
     readonly summary: Schema.String;
     readonly reasons: Schema.$Array<Schema.String>;
 }>;
-export declare const KitMarketplaceProposalReview: Schema.Struct<{
-    readonly action: Schema.Literals<readonly ["source_publish", "version_publish", "source_update", "trust_change", "visibility_change", "broad_activation", "risky_agent_environment_effect", "rollback"]>;
-    readonly target: Schema.Struct<{
-        readonly type: Schema.Literals<readonly ["memory", "kit", "agent_environment_policy", "decision", "task", "team_context", "context_relevance", "kit_source", "kit_version", "kit_installation", "kit_activation", "kit_trust_policy"]>;
-        readonly id: Schema.optionalKey<Schema.String>;
-        readonly scopeType: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"team">, Schema.Literal<"task">, Schema.Literal<"kit">]>>;
-        readonly scopeId: Schema.optionalKey<Schema.String>;
-    }>;
-    readonly payload: Schema.Struct<{
-        readonly memory: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly kit: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly kit_source: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly kit_version: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly kit_installation: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly kit_activation: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly kit_trust_policy: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly agent_environment_policy: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly decision: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly task: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly team_context: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-        readonly context_relevance: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-    }>;
-    readonly renderedDiff: Schema.Struct<{
-        readonly format: Schema.Literals<readonly ["summary", "field_diff", "markdown"]>;
-        readonly title: Schema.String;
-        readonly summary: Schema.String;
-        readonly sections: Schema.$Array<Schema.Struct<{
-            readonly title: Schema.String;
-            readonly beforeSummary: Schema.optionalKey<Schema.String>;
-            readonly afterSummary: Schema.optionalKey<Schema.String>;
-            readonly risk: Schema.Literals<readonly ["low", "medium", "high"]>;
-        }>>;
-        readonly refs: Schema.$Array<Schema.Struct<{
-            readonly kind: Schema.Literals<readonly ["memory", "kit", "loop", "agent", "agent_environment_policy", "decision", "task", "team_context", "context_relevance", "kit_source", "kit_version", "kit_installation", "kit_activation", "kit_trust_policy", "session", "step_attempt", "change_request"]>;
-            readonly id: Schema.optionalKey<Schema.String>;
-            readonly externalId: Schema.optionalKey<Schema.String>;
-            readonly url: Schema.optionalKey<Schema.String>;
-            readonly title: Schema.optionalKey<Schema.String>;
-        }>>;
-    }>;
-    readonly riskSummary: Schema.Struct<{
-        readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
-        readonly summary: Schema.String;
-        readonly reasons: Schema.$Array<Schema.String>;
-    }>;
-    readonly validationFindings: Schema.$Array<Schema.Struct<{
-        readonly code: Schema.Literals<readonly ["autonomous_self_approval", "self_capability_escalation", "missing_required_approval", "unsafe_payload", "target_conflict"]>;
-        readonly severity: Schema.Literals<readonly ["warning", "blocking"]>;
-        readonly message: Schema.String;
-        readonly actorId: Schema.optionalKey<Schema.String>;
-        readonly target: Schema.optionalKey<Schema.Struct<{
-            readonly type: Schema.Literals<readonly ["memory", "kit", "agent_environment_policy", "decision", "task", "team_context", "context_relevance", "kit_source", "kit_version", "kit_installation", "kit_activation", "kit_trust_policy"]>;
-            readonly id: Schema.optionalKey<Schema.String>;
-            readonly scopeType: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"team">, Schema.Literal<"task">, Schema.Literal<"kit">]>>;
-            readonly scopeId: Schema.optionalKey<Schema.String>;
-        }>>;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-    }>>;
-    readonly approvalPolicy: Schema.Struct<{
-        readonly mode: Schema.Literals<readonly ["auto_approve_low_risk", "require_other_team_member", "require_workspace_owner_or_admin"]>;
-        readonly requireDifferentApprover: Schema.optionalKey<Schema.Boolean>;
-        readonly autonomousAgentApprovalAllowed: Schema.Literal<false>;
-        readonly deniedViolationCodes: Schema.$Array<Schema.Literals<readonly ["autonomous_self_approval", "self_capability_escalation", "missing_required_approval", "unsafe_payload", "target_conflict"]>>;
-    }>;
-}>;
 export declare const Proposal: Schema.Struct<{
     readonly id: Schema.String;
     readonly workspaceId: Schema.String;
@@ -261,15 +195,6 @@ export declare const ProposalApplication: Schema.Struct<{
 }>;
 export declare function findForbiddenProposalPayloadPath<ValueType>(value: ValueType, path?: readonly string[]): readonly string[] | undefined;
 export declare function isKitMarketplaceProposalTargetType(value: ProposalTargetType): value is (typeof KitMarketplaceProposalTargetTypes)[number];
-export declare function validateKitMarketplaceProposalReview(input: {
-    readonly action: (typeof KitMarketplaceProposalActions)[number];
-    readonly target: ProposalTargetRef;
-    readonly payload: ProposalPayload;
-    readonly renderedDiff: ProposalRenderedDiff;
-    readonly riskSummary: ProposalRiskSummary;
-    readonly proposedByActorId?: string;
-    readonly approvingActorId?: string;
-}): ProposalPolicyViolation[];
 export type ProposalStatus = (typeof ProposalStatus)['Type'];
 export type ProposalTargetType = (typeof ProposalTargetType)['Type'];
 export type ProposalRiskLevel = (typeof ProposalRiskLevel)['Type'];
@@ -283,7 +208,6 @@ export type ProposalApprovalPolicy = (typeof ProposalApprovalPolicy)['Type'];
 export type ProposalPolicyViolation = (typeof ProposalPolicyViolation)['Type'];
 export type ProposalRenderedDiff = (typeof ProposalRenderedDiff)['Type'];
 export type ProposalRiskSummary = (typeof ProposalRiskSummary)['Type'];
-export type KitMarketplaceProposalReview = (typeof KitMarketplaceProposalReview)['Type'];
 export type Proposal = (typeof Proposal)['Type'];
 export type ProposalRevision = (typeof ProposalRevision)['Type'];
 export type ProposalCommentAnchor = (typeof ProposalCommentAnchor)['Type'];

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

@@ -0,0 +1,68 @@
+import * as Schema from 'effect/Schema';
+import type { NotificationKind } from './notification';
+/** What a device can be pushed about; a Question is on by default, the others are opt-in. */
+export declare const PushEvents: readonly ['question_asked', 'run_failed', 'run_done'];
+export type PushEvent = (typeof PushEvents)[number];
+export declare const defaultPushEvents: readonly PushEvent[];
+export declare const pushEventOf: (kind: NotificationKind) => PushEvent | undefined;
+/** A browser's PushSubscription as `toJSON()` gives it, with what the person chose for that device. */
+export declare const PushDeviceInput: Schema.Struct<{
+    readonly endpoint: Schema.String;
+    readonly keys: Schema.Struct<{
+        readonly p256dh: Schema.String;
+        readonly auth: Schema.String;
+    }>;
+    /** How the person tells their devices apart, such as the browser and platform. */
+    readonly label: Schema.optionalKey<Schema.String>;
+    readonly events: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["question_asked", "run_failed", "run_done"]>>>;
+}>;
+export type PushDeviceInput = (typeof PushDeviceInput)['Type'];
+export declare const PushDeviceChange: Schema.Struct<{
+    readonly enabled: Schema.optionalKey<Schema.Boolean>;
+    readonly events: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["question_asked", "run_failed", "run_done"]>>>;
+}>;
+export type PushDeviceChange = (typeof PushDeviceChange)['Type'];
+/** One of a person's devices; its endpoint and keys stay on the server. */
+export declare const PushDevice: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly label: Schema.String;
+    readonly enabled: Schema.Boolean;
+    readonly events: Schema.$Array<Schema.Literals<readonly ["question_asked", "run_failed", "run_done"]>>;
+    /** Lets a browser find its own device among the person's. */
+    readonly endpointHash: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly lastPushedAt: Schema.optionalKey<Schema.String>;
+}>;
+export type PushDevice = (typeof PushDevice)['Type'];
+export declare const PushSettings: Schema.Struct<{
+    /** The VAPID public key a browser subscribes with; absent when this Kitman cannot send pushes. */
+    readonly publicKey: Schema.optionalKey<Schema.String>;
+    readonly devices: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly enabled: Schema.Boolean;
+        readonly events: Schema.$Array<Schema.Literals<readonly ["question_asked", "run_failed", "run_done"]>>;
+        /** Lets a browser find its own device among the person's. */
+        readonly endpointHash: Schema.String;
+        readonly createdAt: Schema.String;
+        readonly lastPushedAt: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type PushSettings = (typeof PushSettings)['Type'];
+/** What a push carries to the service worker: a short summary and a link, never source, Outputs or secrets. */
+export type PushMessage = {
+    readonly title: string;
+    readonly body: string;
+    /** Same tag, same notification: a later push about the Run replaces the earlier one on the device. */
+    readonly tag: string;
+    /** The page that tapping opens, relative to the web app. */
+    readonly url: string;
+    /** Replaces the device's notification without alerting again: one within the minute already did. */
+    readonly quiet?: true;
+    /** Offered as "Accept recommendation" where the platform shows notification actions. */
+    readonly accept?: {
+        readonly runId: string;
+        readonly questionId: string;
+        readonly value: string;
+    };
+};

package/types/packages/core/src/question-recommendation.d.ts

@@ -0,0 +1,28 @@
+/** An answer to choose from, with the trade-off beside it. */
+export type QuestionOption = string | {
+    readonly value: string;
+    readonly description?: string;
+};
+export declare const optionValue: (option: QuestionOption) => string;
+/** The option values, and each option's description by value; none when no option has one. */
+export declare const splitQuestionOptions: (options: readonly QuestionOption[]) => {
+    options: string[];
+    optionDescriptions?: {
+        [k: string]: string;
+    };
+};
+/** A Question's recommendation as its asker gives it; `Question` in loop.ts says what each field means. */
+export type QuestionRecommendation = {
+    readonly options?: readonly QuestionOption[];
+    readonly recommended?: string;
+    readonly recommendationReason?: string;
+    readonly informationOnly?: boolean;
+};
+/** Why a Question cannot be put as it is, written for the agent or author who asked it; undefined when it can. */
+export declare const recommendationProblem: (question: QuestionRecommendation) => string | undefined;
+/** What a Question carries beside its prompt and options to help a person answer. */
+export type QuestionAdvice = Omit<QuestionRecommendation, 'options'> & {
+    readonly optionDescriptions?: Readonly<Record<string, string>>;
+};
+/** The advice fields that are set, so they can be spread into a record that leaves unset keys out. */
+export declare const questionAdvice: (question: { readonly [Field in keyof QuestionAdvice]?: QuestionAdvice[Field] | undefined; }) => QuestionAdvice;

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

@@ -58,16 +58,28 @@ export declare class DurableSurfaceScanError extends DurableSurfaceScanError_bas
 }> {
     constructor(findings: readonly RedactionFinding[]);
 }
+/**
+ * What Kitman may not keep at all, or may not send out. Kitman keeps what its own readers may read, so only secrets,
+ * credentials and values it cannot read are classified; `leavesKitman` adds everything else a third party should not get.
+ */
 export declare function classifyDurableSurfaceValue<ValueType>(key: string, value: ValueType, options?: DurableSurfaceScanOptions): RedactionClassification | undefined;
 export type DurableSurfaceScanOptions = {
     readonly allowCanonicalIds?: boolean;
-    /** Lets text cite plain https links, as an agent's Output does. */
-    readonly allowPlainUrls?: boolean;
+    /** Also classifies personal data, links, paths and pasted content, for what a third party receives. */
+    readonly leavesKitman?: boolean;
+    /** The longest text kept unread as unknown (default 1024); a surface bounded elsewhere passes its own bound. */
+    readonly maxTextLength?: number;
 };
 export declare function scanDurableSurface<ValueType>(value: ValueType, path?: string, options?: DurableSurfaceScanOptions): DurableSurfaceScan;
 export declare function assertDurableSurfaceClean<ValueType>(value: ValueType, path?: string): void;
-export declare function redactDurableSurface<ValueType>(value: ValueType, path?: string): RedactedDurableSurface;
+export declare function redactDurableSurface<ValueType>(value: ValueType, path?: string, options?: DurableSurfaceScanOptions): RedactedDurableSurface;
 export declare function sha256Hex(input: string): string;
+/**
+ * A response to a caller already authorized to read it, such as a Code Mode result: every secret and credential
+ * is replaced where it stands, by its key or by its text, and everything else stays readable. A failure that names
+ * a path, a host or `git@…` is the caller's to read; what is stored durably goes through `redactDurableSurface`.
+ */
+export declare function redactResponseSurface<ValueType>(value: ValueType): JsonValue;
 /** Command output with secrets and credentials replaced; other content stays readable. */
 export declare function redactCredentials(output: string): string;
 export declare function redactedOutputTail(output: string, maxChars?: number): string;

package/types/packages/core/src/resource-claim.d.ts

@@ -0,0 +1,79 @@
+import * as Schema from 'effect/Schema';
+/** A shared resource's name in its Workspace, such as `stage` or `deploy:production`. */
+export declare const ResourceName: Schema.String;
+/**
+ * The Run that kept a resource after it settled without completing, and why. A Run of a private Team the asking Run is
+ * not in is `private`, with nothing else about it.
+ */
+export declare const ClaimHolder: Schema.Struct<{
+    readonly runId: Schema.optionalKey<Schema.String>;
+    readonly loopId: Schema.optionalKey<Schema.String>;
+    readonly status: Schema.optionalKey<Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>>;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly private: Schema.optionalKey<Schema.Literal<true>>;
+    /** The same Loop on the same repository as the Run asking, which makes a takeover the default. */
+    readonly sameLoop: Schema.Boolean;
+}>;
+export type ClaimHolder = typeof ClaimHolder.Type;
+/**
+ * What a claim came to: `granted`, possibly after waiting or by taking it over from a kept holder; or `kept`, held by
+ * a settled Run the claimant may take over.
+ */
+export declare const ClaimResult: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"granted">;
+    readonly resource: Schema.String;
+    readonly takenOverFrom: Schema.optionalKey<Schema.Struct<{
+        readonly runId: Schema.optionalKey<Schema.String>;
+        readonly loopId: Schema.optionalKey<Schema.String>;
+        readonly status: Schema.optionalKey<Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>>;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly private: Schema.optionalKey<Schema.Literal<true>>;
+        /** The same Loop on the same repository as the Run asking, which makes a takeover the default. */
+        readonly sameLoop: Schema.Boolean;
+    }>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"kept">;
+    readonly resource: Schema.String;
+    readonly holder: Schema.Struct<{
+        readonly runId: Schema.optionalKey<Schema.String>;
+        readonly loopId: Schema.optionalKey<Schema.String>;
+        readonly status: Schema.optionalKey<Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>>;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly private: Schema.optionalKey<Schema.Literal<true>>;
+        /** The same Loop on the same repository as the Run asking, which makes a takeover the default. */
+        readonly sameLoop: Schema.Boolean;
+    }>;
+}>]>;
+export type ClaimResult = typeof ClaimResult.Type;
+/** A held resource as a person sees it. */
+export declare const ResourceClaim: Schema.Struct<{
+    readonly resource: Schema.String;
+    readonly runId: Schema.String;
+    readonly loopId: Schema.String;
+    readonly runStatus: Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>;
+    readonly claimedAt: Schema.String;
+    readonly keptAt: Schema.optionalKey<Schema.String>;
+    readonly keptReason: Schema.optionalKey<Schema.String>;
+    /** Runs waiting for it, oldest first. */
+    readonly waiting: Schema.$Array<Schema.String>;
+}>;
+export type ResourceClaim = typeof ResourceClaim.Type;
+export declare const ResourceClaimList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly resource: Schema.String;
+        readonly runId: Schema.String;
+        readonly loopId: Schema.String;
+        readonly runStatus: Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>;
+        readonly claimedAt: Schema.String;
+        readonly keptAt: Schema.optionalKey<Schema.String>;
+        readonly keptReason: Schema.optionalKey<Schema.String>;
+        /** Runs waiting for it, oldest first. */
+        readonly waiting: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+export type ResourceClaimList = typeof ResourceClaimList.Type;
+/** A person letting a resource go, with why; the oldest waiting Run gets it. */
+export declare const ClaimRelease: Schema.Struct<{
+    readonly reason: Schema.String;
+}>;
+export type ClaimRelease = typeof ClaimRelease.Type;

package/types/packages/core/src/run-display.d.ts

@@ -1,4 +1,4 @@
-import type { RunDisplay, RunDisplayState, RunShow } from './loop';
+import type { Run, RunDisplay, RunDisplayState, RunShow } from './loop';
 export type RunDisplayInput = Pick<RunShow, 'run' | 'steps' | 'questions' | 'children' | 'waiting'> & {
     /** A Runner has leased one of the Run's orchestration Work Units. */
     readonly claimed: boolean;
@@ -8,5 +8,11 @@ export type RunDisplayInput = Pick<RunShow, 'run' | 'steps' | 'questions' | 'chi
     readonly failedChecks: readonly string[];
 };
 export declare const runDisplayLabels: Record<RunDisplayState, string>;
+/** What a Run's output says it left open: any Loop's `unsettled` list. `displayFacts` in run-list.ts reads the same. */
+export declare const reportedUnsettled: (output: Run['output']) => readonly string[] | undefined;
+/** What a Run and the Child Runs below it report left open. */
+export declare const unsettledItems: ({ run, children }: Pick<RunDisplayInput, 'run' | 'children'>) => string[];
+/** A display summary for a list row: one line, cut short. */
+export declare const listedSummary: (summary: string) => string;
 /** The one display state every surface shows for a Run (ADR-0072). */
 export declare const runDisplay: (input: RunDisplayInput) => RunDisplay;

package/types/packages/core/src/run-graph.d.ts

@@ -31,7 +31,7 @@ export type RunGraphStep = (Reached & {
         readonly leased: boolean;
         readonly failureSummary?: string;
     };
-    /** Every check passed or already failed on the default branch. */
+    /** Every check passed or already failed on the baseline. */
     readonly passed?: boolean;
 }) | (Reached & {
     readonly kind: 'question';

package/types/packages/core/src/run-launch.d.ts

@@ -1,5 +1,5 @@
 import type { JsonObject } from './runtime-type';
-export type LaunchOutcome = 'feature' | 'bug' | 'refactor' | 'investigation' | 'docs' | 'migration';
+export type LaunchOutcome = 'feature' | 'bug' | 'refactor' | 'investigation' | 'docs' | 'migration' | 'performance';
 /** Where and how a developer launched: their checkout, and the words they typed. */
 export type LaunchContext = {
     /** The Team the request names; it wins over the repository's. */
@@ -27,6 +27,13 @@ export type LaunchCandidates = {
         readonly sourceBranch?: string;
     }[];
 };
+/** A Task's open ChangeRequest, as a launch names it to a person. */
+export type LaunchChangeRequest = {
+    readonly id: string;
+    readonly title: string;
+    readonly url: string;
+    readonly repoBindingId: string;
+};
 export type LaunchTask = {
     readonly kind: 'tracker';
     readonly key: string;
@@ -39,6 +46,8 @@ export type InferredLaunch = {
     readonly repoBindingId?: string;
     readonly branch?: string;
     readonly changeRequestId?: string;
+    /** The Task's open ChangeRequests, when the Loop needs one and only a person can say which. */
+    readonly changeRequestChoices?: readonly LaunchChangeRequest[];
     readonly trackerKeys: readonly string[];
     readonly task?: LaunchTask;
     readonly outcome?: LaunchOutcome;
@@ -56,7 +65,9 @@ export declare const launchInputSchema: (schema: JsonObject) => {
 };
 /**
  * What a launch means: the Team, repository, branch, open ChangeRequest, Task and Outcome its context points at,
- * and the Loop Input they fill. The words fill a `words` field, or else the one required text field left.
+ * and the Loop Input they fill. The words fill a `words` field, or else the one required text field left other than
+ * `taskId` and `changeRequestId`. A Loop that requires a ChangeRequest the launch does not point at takes the Task's
+ * only open one.
  */
 export declare const inferLaunch: (launch: {
     readonly context: LaunchContext;
@@ -65,5 +76,7 @@ export declare const inferLaunch: (launch: {
         readonly outcome?: LaunchOutcome;
     };
     readonly candidates: LaunchCandidates;
+    /** The open ChangeRequests of the Task the launch is for. */
+    readonly taskChangeRequests?: readonly LaunchChangeRequest[];
     readonly given?: JsonObject;
 }) => InferredLaunch;

package/types/packages/core/src/run-queue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What a Runner claims first: work of a Run already in progress, then a Run that finishes a ChangeRequest, then a new
+ * Run. A rank's index is the `claim_rank` a Work Unit stores.
+ */
+export declare const ClaimRanks: readonly ['in_progress', 'finishing', 'new'];
+export type ClaimRank = (typeof ClaimRanks)[number];
+/** What orders a Work Unit waiting for a Runner. */
+export interface ClaimOrdered {
+    readonly id: string;
+    readonly rank: ClaimRank;
+    /** The Run's Task priority: 1 urgent to 4 low, and 5 for none or no Task. */
+    readonly urgency: number;
+    readonly rootRunCreatedAt: Date;
+    readonly createdAt: Date;
+}
+export interface QueuedWork extends ClaimOrdered {
+    readonly runId: string;
+}
+export declare const compareClaimOrder: (a: ClaimOrdered, b: ClaimOrdered) => number;
+export interface QueuePlace {
+    /** 1 plus the other Runs with work ahead of it. */
+    readonly position: number;
+    /** Why it waits, as a clause: the other Runs ahead of it. */
+    readonly reason: string;
+}
+/** Each queued Work Unit's place in the claim order, and which other Runs have work ahead of it. */
+export declare const queuePlaces: (queue: readonly QueuedWork[]) => ReadonlyMap<string, QueuePlace>;
+export declare const queueWords: (place: QueuePlace) => string;

package/types/packages/core/src/runner-eligibility.d.ts

@@ -1,3 +1,5 @@
+import type { HarnessHoldReason, SkippedChoice } from './loop';
+import type { AgentChoice } from './loop-layers';
 import { type Runner, type RunnerCapabilities } from './runner';
 import type { RunnerExecutionRouting } from './runner-routing';
 export declare const RunnerEligibilityReasonCodes: readonly ['workspace_mismatch', 'team_access_denied', 'personal_owner_attribution_required', 'personal_owner_team_access_denied', 'agent_identity_authority_missing', 'foreground_target_required', 'foreground_target_mismatch', 'foreground_target_not_personal', 'runner_requirements_mismatch', 'runner_replica_unavailable'];
@@ -37,7 +39,24 @@ export interface RunnerEligibilityResult {
  * state before invoking this function.
  */
 export declare function evaluateRunnerEligibility(input: RunnerEligibilityInput): RunnerEligibilityResult;
+/** A (harness, model) this Runner cannot run until `until`, or, with no `until`, that this Step passes over. */
+export type RunnerHarnessHold = {
+    readonly harness: string;
+    readonly model: string;
+    readonly reason: HarnessHoldReason;
+    readonly until?: string;
+};
 /** The owner's choice while the Runner offers it, else the first offered of Pi, Claude Code and Codex. */
 export declare function runnerDefaultHarness(harnesses: readonly string[], chosen: string | undefined): string | undefined;
-/** The Harness this Runner would launch an Agent on, or undefined when the Agent's Step is not this Runner's. */
-export declare function agentStepHarness(capabilities: Pick<RunnerCapabilities, 'harnesses' | 'defaultHarness'>, agentHarness: string | undefined): string | undefined;
+/**
+ * The first choice this Runner offers, with its Harness resolved, and the choices before it as skipped; undefined when
+ * it offers none, so the Step is not this Runner's.
+ */
+export declare function offeredChoice(capabilities: Pick<RunnerCapabilities, 'harnesses' | 'defaultHarness'>, choices: readonly AgentChoice[], 
+/** The Runner's live Harness Holds; a held choice is skipped. `model` is `''` for the Harness's own. */
+holds?: readonly RunnerHarnessHold[]): {
+    readonly choice: AgentChoice & {
+        readonly harness: string;
+    };
+    readonly skipped: readonly SkippedChoice[];
+} | undefined;