@hasna/loops 0.4.27 → 0.4.29

package/dist/lib/advancement.d.ts

@@ -0,0 +1,52 @@
+import type { Loop, LoopRun } from "../types.js";
+export declare const MAX_RETRY_DELAY_MS: number;
+export declare const DEFAULT_CIRCUIT_BREAKER_THRESHOLD = 5;
+export declare const CIRCUIT_BREAKER_REASON_PREFIX = "circuit breaker open";
+export type CircuitBreakerThreshold = number | ((loop: Loop) => number | undefined);
+export type LoopAdvancementPatch = Partial<Pick<Loop, "status" | "nextRunAt" | "retryScheduledFor">>;
+export type LoopAdvancementPlan = {
+    kind: "none";
+    reason: "running" | "missing" | "inactive" | "archived" | "stale" | "already_applied";
+} | {
+    kind: "update";
+    reason: "retry" | "deferred_retry" | "recurrence";
+    patch: LoopAdvancementPatch;
+} | {
+    kind: "circuit_breaker";
+    failures: number;
+    reason: string;
+    markerScheduledFor: string;
+    patch: LoopAdvancementPatch;
+};
+export declare function loopAdvancementPatchMatchesCurrent(current: Loop, patch: LoopAdvancementPatch): boolean;
+/**
+ * Exponential retry backoff with jitter:
+ * delay = retryDelayMs * 2^(attempt-1) * (0.5 + random), capped at 6h.
+ * Provider-gated failures back off 4x harder.
+ */
+export declare function retryBackoffDelayMs(loop: Loop, run: LoopRun, random?: () => number): number;
+export declare function resolveBreakerThreshold(loop: Loop, override?: CircuitBreakerThreshold): number;
+/**
+ * Count consecutive final failures from newest-first run history.
+ *
+ * Retryable failures are neutral, a success resets the streak, and the newest
+ * circuit-breaker marker is a watermark so a manual resume starts a fresh
+ * streak.
+ */
+export declare function consecutiveFailureCountFromRuns(runs: readonly LoopRun[], maxAttempts?: number): number;
+/**
+ * Pure scheduling policy shared by the local scheduler and hosted API.
+ * Callers gather current loop state, deferred retry state, and recent history,
+ * then apply the returned storage mutations using their native sync/async API.
+ */
+export declare function planLoopAdvancement(input: {
+    current: Loop | undefined;
+    run: LoopRun;
+    finishedAt: Date;
+    succeeded: boolean;
+    deferredRetry?: LoopRun;
+    retryIntentRun?: LoopRun;
+    recentRuns?: readonly LoopRun[];
+    retryRandom?: number;
+    circuitBreakerThreshold?: CircuitBreakerThreshold;
+}): LoopAdvancementPlan;

package/dist/lib/agent-adapter.d.ts

@@ -1,8 +1,10 @@
-import type { AgentProvider, AgentSandbox, AgentTarget } from "../types.js";
+import type { AgentAllowlistEnforcement, AgentProvider, AgentSandbox, AgentSessionContract, AgentTarget, WorkflowStep } from "../types.js";
 export type ProviderPromptChannel = "stdin" | "argv";
 export interface ProviderCapabilities {
     /** Sandbox values the provider CLI accepts; empty when sandboxing is unsupported. */
     sandbox: readonly AgentSandbox[];
+    /** Tool/command restrictions exposed by this adapter. Metadata-only means advisory, not provider-enforced. */
+    allowlist: ProviderAllowlistCapabilities;
     /** Whether the provider runs as a durable background agent instead of a one-shot process. */
     durable: boolean;
     /** Whether the provider can be dispatched to a remote machine transport. */
@@ -10,6 +12,10 @@ export interface ProviderCapabilities {
     /** How the prompt reaches the provider process. */
     promptChannel: ProviderPromptChannel;
 }
+export interface ProviderAllowlistCapabilities {
+    tools: AgentAllowlistEnforcement;
+    commands: AgentAllowlistEnforcement;
+}
 export interface AgentInvocation {
     command: string;
     args: string[];
@@ -18,16 +24,28 @@ export interface AgentInvocation {
     /** Executables of which at least one must exist besides the command itself. */
     preflightAnyOf?: string[];
 }
+export interface PreparedAgentInvocation {
+    /** Invocation built from the first validated snapshot. */
+    invocation: AgentInvocation;
+    /** Rebuild only cwd-dependent fields while reusing that same snapshot. */
+    forCwd(cwd: string): AgentInvocation;
+}
 export interface ProviderAdapter {
     provider: AgentProvider;
     capabilities: ProviderCapabilities;
     validate(target: AgentTarget, label?: string): void;
     buildInvocation(target: AgentTarget): AgentInvocation;
+    prepareInvocation(target: AgentTarget): PreparedAgentInvocation;
 }
-export declare const UNSAFE_CODEWITH_EXEC_EXTRA_ARGS: Set<string>;
+export declare function effectiveAgentSandbox(target: AgentTarget): AgentSandbox | "provider-default";
+export declare function agentSessionContract(target: AgentTarget, cwd?: string | undefined): AgentSessionContract | undefined;
+export declare function workflowStepAgentSessionContract(step: WorkflowStep): AgentSessionContract | undefined;
+export declare function agentSessionContractPrompt(target: AgentTarget, cwd?: string | undefined): string | undefined;
 export declare const PROVIDER_ADAPTERS: Record<AgentProvider, ProviderAdapter>;
 export declare const AGENT_PROVIDERS: AgentProvider[];
 export declare function providerAdapter(provider: AgentProvider): ProviderAdapter;
+/** Validate an untrusted or persisted agent target without relying on TypeScript-only shape guarantees. */
+export declare function validateAgentTarget(target: unknown, label?: string): asserts target is AgentTarget;
 export interface SpawnCaptureOptions {
     cwd?: string;
     env?: NodeJS.ProcessEnv;

package/dist/lib/auth/route-policy.d.ts

@@ -0,0 +1,14 @@
+export type TenantRole = "admin" | "operator" | "member" | "readonly" | "service" | "worker";
+export type TokenKind = "api_key" | "service" | "machine";
+export interface RoutePolicy {
+    operationId: string;
+    method: string;
+    pathTemplate: string;
+    path: RegExp;
+    scopes: readonly string[];
+    roles: readonly TenantRole[];
+    tokenKinds: readonly TokenKind[];
+    risk: "read" | "write" | "destructive" | "runner";
+}
+export declare const ROUTE_POLICIES: readonly RoutePolicy[];
+export declare function routePolicy(method: string, path: string): RoutePolicy | undefined;

package/dist/lib/auth/tenant-auth.d.ts

@@ -0,0 +1,38 @@
+import { type ApiKeyClaims } from "@hasna/contracts/auth";
+import type { TypedQueryClient } from "../../generated/storage-kit/query.js";
+import type { RoutePolicy, TenantRole, TokenKind } from "./route-policy.js";
+export interface TenantAuthContext {
+    tenantId: string;
+    principalId: string;
+    requestId: string;
+    kid: string;
+    agent: string | null;
+    scopes: string[];
+    roles: TenantRole[];
+    tokenKind: TokenKind;
+    claims: ApiKeyClaims;
+}
+export type TenantAuthDecision = {
+    ok: true;
+    status: 200;
+    principal: TenantAuthContext;
+} | {
+    ok: false;
+    status: 401 | 403 | 503;
+    reason: string;
+    message: string;
+    requestId: string;
+};
+export declare class TenantApiAuthenticator {
+    private readonly client;
+    private readonly signingSecret;
+    private readonly now;
+    constructor(client: TypedQueryClient, signingSecret: string | Buffer, now?: () => number);
+    authenticate(headers: Headers, context: {
+        method: string;
+        path: string;
+        policy: RoutePolicy;
+    }): Promise<TenantAuthDecision>;
+    private deny;
+    private audit;
+}

package/dist/lib/cloud/mode.d.ts

@@ -1,16 +1,10 @@
-export type StorageMode = "local" | "cloud";
-/** Deprecated mode aliases that all normalize to `cloud`. */
-export declare const DEPRECATED_STORAGE_MODE_ALIASES: readonly ["remote", "hybrid", "self_hosted"];
+export type StorageMode = "local" | "self_hosted" | "cloud";
 export type Env = Record<string, string | undefined>;
 export interface StorageModeNormalization {
     mode: StorageMode;
-    /** The deprecated alias that was normalized to `cloud`, if any. */
-    deprecatedAlias: string | null;
 }
 /**
- * Normalize a raw storage-mode string to the `local | cloud` runtime enum.
- * Accepts deprecated aliases (`remote`, `hybrid`, `self_hosted`) and maps them
- * to `cloud`. Throws on any other value.
+ * Normalize a raw storage-mode string to the canonical deployment vocabulary.
  */
 export declare function normalizeStorageMode(value: string): StorageModeNormalization;
 /** Upper-snake env token for an app name, e.g. `todos` -> `TODOS`. */

package/dist/lib/cloud/storage.d.ts

@@ -76,7 +76,6 @@ export type ResolveStorageClientResult = {
  * `name`; when it resolves to `cloud-http` (mode=cloud/self_hosted + API_URL +
  * API_KEY), returns a ready {@link HasnaStorageClient}. Otherwise returns
  * `{ transport: 'local', client: null }` so the app uses its local store.
- * Throws if cloud was requested but is misconfigured (so callers never silently
- * read the wrong dataset).
+ * Incomplete remote configuration throws so callers never read the wrong dataset.
  */
 export declare function resolveStorageClient(name: string, env?: Env, overrides?: Parameters<typeof createClientTransport>[2]): ResolveStorageClientResult;

package/dist/lib/cloud/transport.d.ts

@@ -1,7 +1,5 @@
 import { type Env } from "./mode.js";
 import type { StorageMode } from "./mode.js";
-/** Default cloud host template. `<app>` is the app slug. */
-export declare function defaultCloudBaseUrl(name: string): string;
 export interface ClientTransportEnvKeys {
     /** Mode keys, in precedence order. */
     modeKeys: string[];
@@ -18,10 +16,8 @@ export type ClientTransportKind = "local" | "cloud-http";
 export interface ClientTransportResolution {
     /** Where the client should read/write from. */
     transport: ClientTransportKind;
-    /** Resolved storage mode (`local` | `cloud`). */
+    /** Resolved canonical deployment mode. */
     mode: StorageMode;
-    /** Deprecated mode alias that was normalized (e.g. `self_hosted`), if any. */
-    deprecatedAlias: string | null;
     /** Env key the mode was read from, or `"default"`. */
     modeSource: string;
     /** `<origin>/v1` base for the cloud API when transport is cloud-http, else null. */
@@ -32,20 +28,11 @@ export interface ClientTransportResolution {
     apiKeyPresent: boolean;
     /** Env key the API key came from, or null. */
     apiKeySource: string | null;
-    /**
-     * True when the operator asked for cloud but the config is incomplete (no API
-     * key), so we fell back to local. Callers SHOULD treat this as an error rather
-     * than silently reading local data.
-     */
-    misconfigured: boolean;
-    /** Human-readable warning, or null. Never contains secret values. */
-    warning: string | null;
 }
 /**
  * Resolve how a client should reach an app's data given the environment.
  *
- * Precedence for the mode: the first present of `HASNA_<NAME>_STORAGE_MODE`,
- * `HASNA_<NAME>_MODE`, `<NAME>_STORAGE_MODE`, `<NAME>_MODE`, else `local`.
+ * The only mode key is `HASNA_<NAME>_STORAGE_MODE`; unset means `local`.
  */
 export declare function resolveClientTransport(name: string, env?: Env): ClientTransportResolution;
 /** Thrown when a cloud HTTP request returns a non-2xx status. */
@@ -132,9 +119,8 @@ export declare function createHasnaHttpTransport(options: HasnaHttpTransportOpti
 /**
  * Convenience: resolve transport from env and, when cloud-http, build the HTTP
  * client in one call. Returns `{ transport: 'local', resolution }` for local, or
- * `{ transport: 'cloud-http', client, resolution }` for cloud. Throws if the
- * config is `misconfigured` (cloud requested but unusable) so callers can't drift
- * onto local data by accident.
+ * `{ transport: 'cloud-http', client, resolution }` for self_hosted/cloud.
+ * Incomplete remote configuration throws before a client is built.
  */
 export declare function createClientTransport(name: string, env?: Env, overrides?: Partial<Pick<HasnaHttpTransportOptions, "fetchImpl" | "headers" | "timeoutMs" | "retry" | "sleepImpl">>): {
     transport: "local";

package/dist/lib/errors.d.ts

@@ -13,9 +13,51 @@ export declare class LoopNotFoundError extends CodedError {
 export declare class LoopArchivedError extends CodedError {
     constructor(idOrName: string);
 }
+export declare class LoopAdvancementConflictError extends CodedError {
+    constructor(loopId: string, runId: string);
+}
+export type RunFinalizationConflictReason = "stale_claim" | "run_not_running";
+export declare class RunFinalizationConflictError extends CodedError {
+    readonly reason: RunFinalizationConflictReason;
+    constructor(reason: RunFinalizationConflictReason, runId: string);
+}
 export declare class AmbiguousNameError extends CodedError {
     constructor(name: string);
 }
+export type AgentExtraArgsValidationReason = "not_array" | "invalid_array" | "invalid_item" | "option_not_allowed";
+/**
+ * Deliberately public, bounded validation metadata. API boundaries may expose
+ * this object, but must never expose the accompanying Error.message.
+ */
+export interface PublicValidationDetails {
+    code: "agent_extra_args_invalid";
+    reason: AgentExtraArgsValidationReason;
+    path: string;
+    index?: number;
+    option?: string;
+}
+export declare function publicValidationDetails(value: unknown): Readonly<PublicValidationDetails> | undefined;
 export declare class ValidationError extends CodedError {
-    constructor(message: string);
+    readonly publicDetails?: Readonly<PublicValidationDetails>;
+    constructor(message: string, publicDetails?: PublicValidationDetails);
+}
+/** Safely capture and re-project even forged/subclass validation errors. */
+export declare function validationErrorPublicDetails(error: ValidationError): Readonly<PublicValidationDetails> | undefined;
+export declare class DuplicateWorkflowEventError extends CodedError {
+    constructor(workflowRunId: string, eventType: string, stepId?: string);
+}
+export declare class LegacyWorkflowRunProvenanceError extends CodedError {
+    constructor(workflowRunId: string);
+}
+export declare class WorkflowRunDefinitionConflictError extends CodedError {
+    constructor(workflowRunId: string);
+}
+export declare class WorkflowRunHasLiveStepsError extends CodedError {
+    constructor();
+}
+export declare class WorkflowRunStepOwnershipUnverifiableError extends CodedError {
+    constructor();
+}
+export declare class WorkflowRunNotRunningError extends CodedError {
+    constructor();
 }

package/dist/lib/executor.d.ts

@@ -56,6 +56,15 @@ interface MachineCommandPlan {
 }
 /** Exported for tests: resolves the default idle watchdog for agent targets. */
 export declare function defaultAgentIdleTimeoutMs(target: AgentTarget, opts: ExecuteOptions): number | undefined;
+/**
+ * Detects git's "missing but already registered worktree" error: the target
+ * path is recorded in `.git/worktrees/` but its directory was deleted out from
+ * under it, so `git worktree add` refuses. git's own prescribed remedy is
+ * `git worktree prune` (or `add -f`). Left unhandled this terminal-fails worktree
+ * prep on every attempt and the drain dedupes the failed item into a silent
+ * wedge — historically the single biggest burner of the redispatch cap.
+ */
+export declare function isStaleWorktreeRegistration(detail: string | undefined): boolean;
 export declare function preflightTarget(target: ExecutableTarget, metadata?: ExecutionMetadata, opts?: ExecuteOptions): PreflightResult;
 export declare function executeTarget(target: ExecutableTarget, metadata?: ExecutionMetadata, opts?: ExecuteOptions): Promise<ExecutorResult>;
 export declare function executeLoop(loop: Loop, run: LoopRun, opts?: ExecuteOptions): Promise<ExecutorResult>;

package/dist/lib/format.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutorResult, Goal, GoalRun, Loop, LoopRun, RunReceipt, WorkflowEvent, WorkflowInvocation, WorkflowRun, WorkflowSpec, WorkflowStepRun, WorkflowWorkItem } from "../types.js";
+import type { ExecutorResult, Goal, GoalRun, Loop, LoopRun, RunReceipt, PublicWorkflowEvent, StoredWorkflowEvent, WorkflowInvocation, WorkflowRun, WorkflowSpec, WorkflowStepRun, WorkflowWorkItem } from "../types.js";
 export declare function redact(value: string | undefined, visible?: number): string | undefined;
 export declare function textOutputBlocks(value: Pick<LoopRun | WorkflowStepRun, "stdout" | "stderr">, opts?: {
     indent?: string;
@@ -14,6 +14,6 @@ export declare function publicWorkflowRun(run: WorkflowRun): Record<string, unkn
 export declare function publicWorkflowInvocation(invocation: WorkflowInvocation): Record<string, unknown>;
 export declare function publicWorkflowWorkItem(item: WorkflowWorkItem): Record<string, unknown>;
 export declare function publicWorkflowStepRun(run: WorkflowStepRun, showOutput?: boolean): Record<string, unknown>;
-export declare function publicWorkflowEvent(event: WorkflowEvent): Record<string, unknown>;
+export declare function publicWorkflowEvent(event: StoredWorkflowEvent | PublicWorkflowEvent): Record<string, unknown>;
 export declare function publicGoal(goal: Goal): Record<string, unknown>;
 export declare function publicGoalRun(run: GoalRun): Record<string, unknown>;

package/dist/lib/goal/runner.d.ts

@@ -1,3 +1,36 @@
-import type { Store } from "../store.js";
-import type { GoalExecutorResult, GoalSpec, RunGoalOptions } from "./types.js";
-export declare function runGoal(store: Store, input: GoalSpec, opts?: RunGoalOptions): Promise<GoalExecutorResult>;
+import type { CreateGoalInput, CreateGoalPlanNodeInput, RecordGoalEventInput } from "../store.js";
+import type { Goal, GoalExecutorResult, GoalPlanNode, GoalRun, GoalSpec, GoalStatus, RunGoalOptions } from "./types.js";
+type MaybePromise<T> = T | Promise<T>;
+export interface GoalRunnerStore {
+    findGoalByContext(context: {
+        loopRunId?: string;
+        workflowRunId?: string;
+        workflowStepId?: string;
+        sourceType?: string;
+        sourceId?: string;
+    }): MaybePromise<Goal | undefined>;
+    createGoal(input: CreateGoalInput, opts?: {
+        daemonLeaseId?: string;
+        now?: Date;
+    }): MaybePromise<Goal>;
+    requireGoal(id: string): MaybePromise<Goal>;
+    createGoalPlanNodes(goalId: string, nodes: CreateGoalPlanNodeInput[], opts?: {
+        daemonLeaseId?: string;
+        now?: Date;
+    }): MaybePromise<GoalPlanNode[]>;
+    listGoalPlanNodes(goalIdOrPlanId: string): MaybePromise<GoalPlanNode[]>;
+    updateGoalStatus(goalId: string, status: GoalStatus, opts?: {
+        daemonLeaseId?: string;
+        now?: Date;
+    }): MaybePromise<Goal>;
+    updateGoalPlanNode(goalId: string, key: string, patch: Partial<Pick<GoalPlanNode, "status" | "tokensUsed" | "timeUsedSeconds" | "ready">>, opts?: {
+        daemonLeaseId?: string;
+        now?: Date;
+    }): MaybePromise<GoalPlanNode>;
+    recordGoalEvent(input: RecordGoalEventInput, opts?: {
+        daemonLeaseId?: string;
+        now?: Date;
+    }): MaybePromise<GoalRun>;
+}
+export declare function runGoal(store: GoalRunnerStore, input: GoalSpec, opts?: RunGoalOptions): Promise<GoalExecutorResult>;
+export {};

package/dist/lib/health.d.ts

@@ -2,7 +2,7 @@ import type { Loop, LoopRun, LoopStatus } from "../types.js";
 import type { DaemonStatus } from "../daemon/control.js";
 import type { DoctorCheck, DoctorReport } from "./doctor.js";
 import type { Store } from "./store.js";
-export type RunFailureClassification = "rate_limit" | "auth" | "provider_unavailable" | "model_not_found" | "context_length" | "schema_response_format" | "node_init" | "preflight" | "route_functional" | "timeout" | "sigsegv" | "restart_interrupted" | "skipped_previous_active" | "circuit_breaker" | "unknown";
+export type RunFailureClassification = "rate_limit" | "auth" | "provider_capacity" | "provider_unavailable" | "model_not_found" | "context_length" | "schema_response_format" | "node_init" | "preflight" | "route_functional" | "timeout" | "sigsegv" | "restart_interrupted" | "skipped_previous_active" | "circuit_breaker" | "unknown";
 export interface RunFailureSignal {
     classification: RunFailureClassification;
     fingerprint: string;

package/dist/lib/labels.d.ts

@@ -0,0 +1,4 @@
+export declare const LOOP_LABEL_MAX_COUNT = 32;
+export declare function normalizeLoopLabels(value: string | string[] | undefined, label?: string): string[];
+export declare function mergeLoopLabels(current: string[] | undefined, added: string | string[]): string[];
+export declare function removeLoopLabels(current: string[] | undefined, removed: string | string[]): string[];

package/dist/lib/loop-status.d.ts

@@ -0,0 +1,4 @@
+import type { LoopStatus } from "../types.js";
+export declare const LOOP_STATUSES: readonly ["active", "paused", "stopped", "expired"];
+export declare function isLoopStatus(value: unknown): value is LoopStatus;
+export declare function assertLoopStatus(value: unknown): asserts value is LoopStatus;

package/dist/lib/migration.d.ts

@@ -1,6 +1,7 @@
 import type { Loop, LoopRun, WorkflowSpec } from "../types.js";
 import type { Store, StoreMigrationChecks } from "./store.js";
 export declare const LOOPS_MIGRATION_SCHEMA = "open-loops.migration/v1";
+export declare const LOOPS_SELF_HOSTED_PUSH_MANIFEST_SCHEMA = "open-loops.self-hosted-push-manifest/v1";
 export type LoopsMigrationResource = "workflow" | "loop" | "run" | "remote";
 export type LoopsMigrationAction = "insert" | "update" | "skip" | "conflict" | "blocked";
 export interface LoopsMigrationBundle {
@@ -67,6 +68,7 @@ export interface LoopsMigrationPlan {
     summary: LoopsMigrationPlanSummary;
     rows: LoopsMigrationPlanRow[];
     warnings: string[];
+    manifest?: SelfHostedPushManifest;
 }
 export interface ApplyLoopsMigrationResult {
     plan: LoopsMigrationPlan;
@@ -79,24 +81,12 @@ export interface ApplyLoopsMigrationResult {
 export interface SelfHostedPlanOptions {
     operation: "self-hosted-push" | "self-hosted-pull" | "self-hosted-migrate";
     apiUrl?: string;
-    apiToken?: string;
+    apiKey?: string;
+    timeoutMs?: number;
     fetchImpl?: typeof fetch;
     env?: NodeJS.ProcessEnv;
     includeRuns?: boolean;
-}
-export interface RunnerRegistrationOptions {
-    apiUrl?: string;
-    apiToken?: string;
-    runnerId: string;
-    machineId?: string;
-    labels?: Record<string, string>;
-    capabilities?: Record<string, unknown>;
-    fetchImpl?: typeof fetch;
-    env?: NodeJS.ProcessEnv;
-}
-export interface RunnerRegistrationResult {
-    ok: boolean;
-    runner: Record<string, unknown>;
+    replace?: boolean;
 }
 export declare function migrationHash(value: unknown): string;
 export declare function exportLoopsMigrationBundle(store: Store, opts?: ExportLoopsMigrationOptions): LoopsMigrationBundle;
@@ -106,7 +96,8 @@ export declare function applyImportMigrationBundle(store: Store, bundle: LoopsMi
 export declare function buildSelfHostedMigrationPlan(store: Store, opts: SelfHostedPlanOptions): Promise<LoopsMigrationPlan>;
 export interface SelfHostedPushOptions {
     apiUrl?: string;
-    apiToken?: string;
+    apiKey?: string;
+    timeoutMs?: number;
     includeRuns?: boolean;
     replace?: boolean;
     fetchImpl?: typeof fetch;
@@ -134,6 +125,69 @@ export interface SelfHostedPushResult {
         orphanRuns: number;
     };
     requests: number;
+    manifest: SelfHostedPushManifest;
+}
+export interface SelfHostedPushManifest {
+    schema: typeof LOOPS_SELF_HOSTED_PUSH_MANIFEST_SCHEMA;
+    generatedAt: string;
+    apiUrl?: string;
+    dryRun: boolean;
+    replace: boolean;
+    includeRuns: boolean;
+    safety: {
+        forcedLoopStatus: "paused";
+        clearedLoopRunPointers: true;
+        forcedWorkflowStatus: "archived";
+        resumesLoops: false;
+    };
+    counts: {
+        source: {
+            workflows: number;
+            loops: number;
+            runs: number;
+        };
+        remoteBefore: {
+            workflows?: number;
+            loops?: number;
+            runs?: number;
+        };
+        remoteAfter?: {
+            workflows?: number;
+            loops?: number;
+            runs?: number;
+        };
+        plan: LoopsMigrationPlanSummary;
+        applied?: {
+            workflows: number;
+            loops: number;
+            runs: number;
+        };
+        skipped?: {
+            runningRuns: number;
+            orphanRuns: number;
+        };
+        requests?: number;
+    };
+    missingIds: {
+        workflows: string[];
+        loops: string[];
+        runs: string[];
+    };
+    existingIds: {
+        workflows: string[];
+        loops: string[];
+        runs: string[];
+    };
+    unsafe: {
+        blocked: LoopsMigrationPlanRow[];
+        conflicts: LoopsMigrationPlanRow[];
+        unsupported: string[];
+        warnings: string[];
+    };
+    rollback: {
+        notes: string[];
+        commands: string[];
+    };
 }
 /**
  * Apply a local->self-hosted backfill through the control plane's id-preserving
@@ -144,6 +198,5 @@ export interface SelfHostedPushResult {
  * endpoint upserts by id, so re-running never duplicates rows.
  */
 export declare function applySelfHostedPush(store: Store, opts: SelfHostedPushOptions): Promise<SelfHostedPushResult>;
-export declare function registerSelfHostedRunner(opts: RunnerRegistrationOptions): Promise<RunnerRegistrationResult>;
 export declare function publicMigrationBundle(bundle: LoopsMigrationBundle): Record<string, unknown>;
 export declare function selfHostedControlPlaneSummary(env?: NodeJS.ProcessEnv): Record<string, unknown>;

package/dist/lib/mode.d.ts

@@ -11,11 +11,8 @@ export interface LoopModeResolution {
 }
 export interface LoopControlPlaneConfig {
     apiUrl?: string;
-    cloudApiUrl?: string;
     databaseUrlPresent: boolean;
-    apiAuthTokenPresent: boolean;
-    cloudAuthTokenPresent: boolean;
-    authTokenPresent: boolean;
+    apiKeyPresent: boolean;
 }
 export interface LoopDeploymentStatus {
     packageVersion: string;
@@ -32,7 +29,7 @@ export interface LoopDeploymentStatus {
         configured: boolean;
         apiUrl?: string;
         databaseUrlPresent: boolean;
-        authTokenPresent: boolean;
+        apiKeyPresent: boolean;
     };
     runner: {
         required: boolean;