startup-builder 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,448 +1,678 @@
-import * as xstate from 'xstate';
-import { AnyActorRef } from 'xstate';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 
-interface StartupBuilderContext {
-    startupId: string;
-    ideaId: string;
-    sprintId: string;
-    icpCount: number;
-    competitorCount: number;
-    leanCanvasCount: number;
-    hypothesisCount: number;
-    positioningSet: boolean;
-    differentiatorCount: number;
-    storyBrandCount: number;
-    serviceCount: number;
-    agentCount: number;
-    domainCount: number;
-    pageCount: number;
-    servicesBuilderRef?: AnyActorRef;
-    siteBuilderRef?: AnyActorRef;
-    salesBuilderRef?: AnyActorRef;
-    result?: 'validated' | 'invalidated' | 'inconclusive';
-    skipReason?: string;
-}
-type StartupBuilderEvent = {
-    type: 'ARTIFACT_CREATED';
-    collection: string;
-    count: number;
-} | {
-    type: 'ADVANCE';
-} | {
-    type: 'SKIP';
-    reason: string;
-} | {
-    type: 'SERVICES_COMPLETE';
-} | {
-    type: 'SITE_COMPLETE';
-} | {
-    type: 'SALES_COMPLETE';
-    result: 'validated' | 'invalidated' | 'inconclusive';
-} | {
-    type: 'PIVOT';
-    reason: string;
-} | {
-    type: 'ARCHIVE';
-    reason: string;
+interface Res<T = any> {
+    status: number;
+    ok: boolean;
+    url: string;
+    json: T;
+    text: string;
+    headers: Record<string, string>;
+}
+interface ApiOpts {
+    base: string;
+    token?: string;
+    bind?: string;
+    fetch?: typeof fetch;
+    userAgent?: string;
+}
+declare class Api {
+    readonly base: string;
+    readonly token?: string;
+    readonly origin: string;
+    readonly reads: string[];
+    private f;
+    private ua;
+    constructor(o: ApiOpts);
+    url(pathOrUrl: string): string;
+    sameOrigin(url: string): boolean;
+    private headers;
+    get<T = any>(pathOrUrl: string, accept?: string): Promise<Res<T>>;
+    post<T = any>(pathOrUrl: string, body: unknown, o?: {
+        idempotencyKey?: string;
+        prefer?: string;
+    }): Promise<Res<T> & {
+        idempotencyKey: string;
+    }>;
+}
+
+interface Stored {
+    issuer: string;
+    client_id: string;
+    access_token: string;
+    refresh_token?: string;
+    expires_at?: number;
+    api: string;
+}
+interface AuthDeps {
+    api: string;
+    file: string;
+    issuer?: string;
+    fetch?: typeof fetch;
+    openBrowser?: (url: string) => boolean;
+    log?: (line: string) => void;
+    now?: () => number;
+    ports?: number[];
+    timeoutMs?: number;
+    clientId?: string;
+}
+type J$5 = Record<string, any>;
+declare function pkce(verifier?: string): {
+    verifier: string;
+    challenge: string;
 };
-declare const startupBuilderMachine: xstate.StateMachine<StartupBuilderContext, {
-    type: "ARTIFACT_CREATED";
-    collection: string;
-    count: number;
-} | {
-    type: "ADVANCE";
-} | {
-    type: "SKIP";
-    reason: string;
-} | {
-    type: "SERVICES_COMPLETE";
-} | {
-    type: "SITE_COMPLETE";
-} | {
-    type: "SALES_COMPLETE";
-    result: "validated" | "invalidated" | "inconclusive";
-} | {
-    type: "PIVOT";
-    reason: string;
-} | {
-    type: "ARCHIVE";
-    reason: string;
-}, {}, never, {
-    type: "recordSkip";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "updateArtifactCount";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setPositioning";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setResult";
-    params: xstate.NonReducibleUnknown;
-}, {
-    type: "hasResearchArtifacts";
-    params: unknown;
-} | {
-    type: "hasCanvasArtifacts";
-    params: unknown;
-} | {
-    type: "hasPositioningArtifacts";
-    params: unknown;
-} | {
-    type: "hasMessagingArtifacts";
-    params: unknown;
-} | {
-    type: "hasServicesComplete";
-    params: unknown;
-} | {
-    type: "hasTeamArtifacts";
-    params: unknown;
-} | {
-    type: "hasSiteComplete";
-    params: unknown;
-} | {
-    type: "isSkipping";
-    params: unknown;
-}, never, "complete" | "research" | "canvas" | "positioning" | "messaging" | "services" | "team" | "site" | "sales", string, {
-    startupId: string;
-    ideaId: string;
-    sprintId: string;
-}, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
-    id: "startup-builder";
-    states: {
-        readonly research: {};
-        readonly canvas: {};
-        readonly positioning: {};
-        readonly messaging: {};
-        readonly services: {};
-        readonly team: {};
-        readonly site: {};
-        readonly sales: {};
-        readonly complete: {};
-    };
-}>;
+declare function unwrapState(s: string | null): string | null;
+declare class Auth {
+    readonly api: string;
+    readonly file: string;
+    readonly issuer: string;
+    private f;
+    private open;
+    private log;
+    private now;
+    private ports;
+    private timeoutMs;
+    private fixedClient?;
+    constructor(d: AuthDeps);
+    stored(): Promise<Stored | undefined>;
+    private save;
+    clientId(): Promise<string>;
+    private token;
+    loopback(client: string): Promise<J$5 | undefined>;
+    device(client: string): Promise<J$5>;
+    current(): Promise<Stored | undefined>;
+    login(opts?: {
+        device?: boolean;
+        force?: boolean;
+    }): Promise<{
+        stored: Stored;
+        fresh: boolean;
+    }>;
+    logout(): Promise<void>;
+}
+
+declare const DEFAULT_API = "https://api.sb";
+type Env$1 = Record<string, string | undefined>;
+declare function apiBase(flag?: string, env?: Env$1): string;
+declare function tokenFile(env?: Env$1): string;
 
-interface ServicesBuilderContext {
-    startupId: string;
-    hasStoryBrand: boolean;
-    deliveryModel?: 'saas' | 'iaas' | 'paas' | 'services-as-software';
-    serviceCount: number;
-    pricingSet: boolean;
-    productCount: number;
-    activationComplete: boolean;
-}
-type ServicesBuilderEvent = {
-    type: 'ARTIFACT_CREATED';
-    collection: string;
-    count: number;
-} | {
-    type: 'MODEL_SELECTED';
-    model: ServicesBuilderContext['deliveryModel'];
-} | {
-    type: 'PRICING_SET';
-} | {
-    type: 'ACTIVATION_COMPLETE';
-} | {
-    type: 'ADVANCE';
-} | {
-    type: 'SKIP';
-    reason: string;
+type J$4 = Record<string, any>;
+interface ClosesOn {
+    event: string;
+    verb: string;
+    url: string;
+    target?: string;
+    via: 'api.sb' | 'preview' | 'derived';
+    permission?: {
+        needs: string;
+        held: boolean;
+        heldBy: Record<string, string>;
+        assignee?: string;
+        why?: string;
+    };
+    approvalNeeded?: boolean;
+    refused?: string;
+    blocked?: string;
+    says?: string;
+}
+interface Task {
+    $id: string;
+    type: string;
+    name: string;
+    status: string;
+    reason?: string;
+    startup: string;
+    worker: string;
+    role?: string;
+    verb?: string;
+    object?: string;
+    about?: string;
+    conversation?: string;
+    due?: string;
+    overdue?: number;
+    age?: number;
+    since?: string;
+    priority: number;
+    priorityText?: string;
+    priorityWhy: string[];
+    step: string;
+    stepTitle?: string;
+    closesOn?: ClosesOn;
+}
+interface RoleDesk {
+    name: string;
+    $id: string;
+    owns?: string;
+    summary: string[];
+    permissions: string[];
+    mandates?: string[];
+    limits: {
+        name: string;
+        limit?: number;
+        used?: number;
+        text?: string;
+    }[];
+    tools: string[];
+}
+interface StartupDesk {
+    domain: string;
+    $id: string;
+    real?: string;
+    worker?: {
+        name: string;
+        kind?: string;
+        model?: string;
+        $id: string;
+        skills: string[];
+    };
+    roles: RoleDesk[];
+    open: number;
+    glossary?: string;
+    glossaryUrl: string;
+}
+interface Cluster {
+    worker: string;
+    startup: string;
+    step: string;
+    stepTitle?: string;
+    tasks: Task[];
+}
+interface Worklist {
+    source: 'api.sb' | 'stub';
+    worker: {
+        handle: string;
+        name: string;
+        kind?: string;
+        model?: string;
+        $id?: string;
+    };
+    startups: StartupDesk[];
+    open: number;
+    limit: number;
+    limitMax?: number;
+    limitAsked?: number;
+    page?: number;
+    pages?: number;
+    more?: number;
+    moreText?: string;
+    next?: string;
+    links?: {
+        next?: string;
+        prev?: string;
+        first?: string;
+        last?: string;
+        self?: string;
+    };
+    batch: Cluster[];
+    tasks: Task[];
+    planned?: J$4[];
+    gaps: string[];
+    sources: string[];
+    priorityBands?: Record<string, string>;
+    rules?: string[];
+    asOf?: string;
+    datesRelativeTo?: 'asOf';
+    clock?: string;
+    generatedAt: string;
+}
+declare class WorklistError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+interface WorklistOpts {
+    worker: string;
+    startups: string[];
+    limit?: number;
+    page?: number;
+    all?: boolean;
+    today?: string;
+    previews?: boolean;
+    stubOnly?: boolean;
+}
+declare function worklistPath(worker: string, startups: string[], limit: number, md?: boolean, page?: number): string;
+declare const heldByNames: (h: Record<string, string> | string[] | undefined) => string[];
+declare function fetchWorklistMarkdown(api: Api, o: {
+    worker: string;
+    startups: string[];
+    limit?: number;
+    page?: number;
+}): Promise<string>;
+declare function parseWorker(arg?: string): string | undefined;
+declare function derivePriority(t: J$4, today: string): {
+    priority: number;
+    why: string[];
 };
-declare const servicesBuilderMachine: xstate.StateMachine<ServicesBuilderContext, {
-    type: "ARTIFACT_CREATED";
-    collection: string;
-    count: number;
-} | {
-    type: "MODEL_SELECTED";
-    model: ServicesBuilderContext["deliveryModel"];
-} | {
-    type: "PRICING_SET";
-} | {
-    type: "ACTIVATION_COMPLETE";
-} | {
-    type: "ADVANCE";
-} | {
-    type: "SKIP";
-    reason: string;
-}, {}, never, {
-    type: "updateArtifactCount";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setModel";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setPricing";
-    params: xstate.NonReducibleUnknown;
-}, {
-    type: "needsMessaging";
-    params: unknown;
-} | {
-    type: "hasMessaging";
-    params: unknown;
-} | {
-    type: "hasModel";
-    params: unknown;
-} | {
-    type: "hasServices";
-    params: unknown;
-} | {
-    type: "hasPricing";
-    params: unknown;
-} | {
-    type: "hasProducts";
-    params: unknown;
-}, never, "complete" | "messaging" | "model" | "checkPrerequisites" | "definition" | "pricing" | "packaging" | "activation", string, {
-    startupId: string;
-    hasStoryBrand: boolean;
-}, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
-    id: "services-builder";
-    states: {
-        readonly checkPrerequisites: {};
-        readonly messaging: {};
-        readonly model: {};
-        readonly definition: {};
-        readonly pricing: {};
-        readonly packaging: {};
-        readonly activation: {};
-        readonly complete: {};
+declare function stepOf(t: J$4, domain: string): string;
+declare function selectBatch(tasks: Task[], limit: number): Cluster[];
+interface StartupGroup {
+    startup: string;
+    steps: {
+        step: string;
+        stepTitle?: string;
+        tasks: Task[];
+    }[];
+}
+declare function groupBatch(batch: Cluster[]): StartupGroup[];
+declare function buildWorklist(api: Api, o: WorklistOpts): Promise<Worklist>;
+
+type J$3 = Record<string, any>;
+type Mode = 'try' | 'send' | 'do';
+interface CloseOpts {
+    task: string;
+    mode?: Mode;
+    as?: string;
+    input?: J$3;
+    idempotencyKey?: string;
+    force?: boolean;
+    prepare?: (c: ClosesOn) => {
+        input?: J$3;
+        error?: string;
+    };
+}
+type Outcome = 'Done' | 'Pending' | 'Refused' | 'Replayed' | 'KeyReused' | 'Blocked' | 'NotSent' | 'Error';
+interface CloseResult {
+    task: {
+        $id: string;
+        name: string;
+        type: string;
+        status?: string;
+        startup: string;
+        worker: string;
+        priorityText?: string;
+        stepTitle?: string;
+    };
+    closesOn: ClosesOn;
+    mode: Mode;
+    as: string;
+    request: {
+        method: 'POST';
+        url: string;
+        prefer: string;
+        idempotencyKey: string;
+    };
+    status: number;
+    outcome: Outcome;
+    action?: J$3;
+    replayed: boolean;
+    tried: boolean;
+    sink?: string;
+    blocked?: {
+        code?: string;
+        message?: string;
     };
+    note?: string;
+    body: unknown;
+}
+interface ClosingTask {
+    $id: string;
+    name: string;
+    type: string;
+    status?: string;
+    startup: string;
+    worker: string;
+    priorityText?: string;
+    stepTitle?: string;
+    closesOn: ClosesOn;
+}
+declare function findClosesOn(api: Api, taskRef: string): Promise<{
+    task: ClosingTask;
+    thing: J$3;
+    worklist?: Worklist;
 }>;
+declare function closeTask(api: Api, o: CloseOpts): Promise<CloseResult>;
+declare const closesOf: (a: J$3 | undefined) => string[];
 
-interface SiteBuilderContext {
-    startupId: string;
-    hasStoryBrand: boolean;
-    hasServices: boolean;
-    pageCount: number;
-    pagesWithContent: number;
-    domainCount: number;
-    designApproved: boolean;
-    published: boolean;
-}
-type SiteBuilderEvent = {
-    type: 'ARTIFACT_CREATED';
-    collection: string;
-    count: number;
-} | {
-    type: 'CONTENT_COMPLETE';
-    pagesWithContent: number;
-} | {
-    type: 'DESIGN_APPROVED';
-} | {
-    type: 'PUBLISHED';
-} | {
-    type: 'ADVANCE';
-} | {
-    type: 'SKIP';
-    reason: string;
-};
-declare const siteBuilderMachine: xstate.StateMachine<SiteBuilderContext, {
-    type: "ARTIFACT_CREATED";
-    collection: string;
-    count: number;
-} | {
-    type: "CONTENT_COMPLETE";
-    pagesWithContent: number;
-} | {
-    type: "DESIGN_APPROVED";
-} | {
-    type: "PUBLISHED";
-} | {
-    type: "ADVANCE";
-} | {
-    type: "SKIP";
-    reason: string;
-}, {}, never, {
-    type: "updateArtifactCount";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setContentComplete";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setDesignApproved";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setPublished";
-    params: xstate.NonReducibleUnknown;
-}, {
-    type: "needsMessaging";
-    params: unknown;
-} | {
-    type: "needsServices";
-    params: unknown;
-} | {
-    type: "hasPrerequisites";
-    params: unknown;
-} | {
-    type: "hasPages";
-    params: unknown;
-} | {
-    type: "hasContent";
-    params: unknown;
-} | {
-    type: "hasDesign";
-    params: unknown;
-} | {
-    type: "hasDomain";
-    params: unknown;
-}, never, "complete" | "messaging" | "checkPrerequisites" | "servicesPrereq" | "structure" | "content" | "design" | "publish", string, {
-    startupId: string;
-    hasStoryBrand: boolean;
-    hasServices: boolean;
-}, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
-    id: "site-builder";
-    states: {
-        readonly checkPrerequisites: {};
-        readonly messaging: {};
-        readonly servicesPrereq: {};
-        readonly structure: {};
-        readonly content: {};
-        readonly design: {};
-        readonly publish: {};
-        readonly complete: {};
+declare function batchText(w: Worklist, o?: {
+    bin?: string;
+}): string;
+declare function closeText(r: CloseResult): string;
+
+declare function renderPrompt(w: Worklist, o?: {
+    bin?: string;
+}): string;
+
+interface CloudSession {
+    startup: string;
+    via: 'api.sb' | 'claude-runner' | 'none';
+    url?: string;
+    status?: number;
+    session?: string;
+    request: {
+        url: string;
+        body: Record<string, unknown>;
     };
-}>;
+    note?: string;
+}
+declare function runCloud(api: Api, w: Worklist, o: {
+    runner: string;
+    runnerToken?: string;
+    dryRun?: boolean;
+    bin?: string;
+    model?: string;
+    fetch?: typeof fetch;
+}): Promise<CloudSession[]>;
 
-interface SalesBuilderContext {
-    startupId: string;
-    experimentId?: string;
-    hasSite: boolean;
-    hasDomain: boolean;
-    channels: {
-        paidAds: {
-            ready: boolean;
-            reason?: string;
-        };
-        coldOutbound: {
-            ready: boolean;
-            reason?: string;
-        };
-        contentSocial: {
-            ready: boolean;
-            reason?: string;
-        };
-        blog: {
-            ready: boolean;
-        };
+type J$2 = Record<string, any>;
+declare function collectionOf(noun: string): string;
+declare function verbPath(spec: string, target: string | undefined, startup: string | undefined): string;
+interface VerbPreview {
+    url: string;
+    status: number;
+    name?: string;
+    does?: string;
+    event?: string;
+    mode?: string;
+    state?: string;
+    refused?: string;
+    permission?: {
+        needs: string;
+        heldBy: string[];
     };
-    campaignCount: number;
-    sequenceCount: number;
-    postCount: number;
-    hasExperiment: boolean;
-    hasMetrics: boolean;
-}
-type SalesBuilderEvent = {
-    type: 'ARTIFACT_CREATED';
-    collection: string;
-    count: number;
-} | {
-    type: 'EXPERIMENT_CREATED';
-    experimentId: string;
-} | {
-    type: 'METRICS_COLLECTED';
-} | {
-    type: 'ADVANCE';
-} | {
-    type: 'SKIP';
-    reason: string;
-};
-declare const salesBuilderMachine: xstate.StateMachine<SalesBuilderContext, {
-    type: "ARTIFACT_CREATED";
-    collection: string;
-    count: number;
-} | {
-    type: "EXPERIMENT_CREATED";
-    experimentId: string;
-} | {
-    type: "METRICS_COLLECTED";
-} | {
-    type: "ADVANCE";
-} | {
-    type: "SKIP";
-    reason: string;
-}, {}, never, {
-    type: "updateArtifactCount";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setExperiment";
-    params: xstate.NonReducibleUnknown;
-} | {
-    type: "setMetrics";
-    params: xstate.NonReducibleUnknown;
-}, {
-    type: "needsSite";
-    params: unknown;
-} | {
-    type: "hasSite";
-    params: unknown;
-} | {
-    type: "hasActiveChannel";
-    params: unknown;
-} | {
-    type: "hasMetrics";
-    params: unknown;
-}, never, "complete" | "checkPrerequisites" | "sitePrereq" | "launch" | "measure", string, {
-    startupId: string;
-    hasSite: boolean;
-    hasDomain: boolean;
-}, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
-    id: "sales-builder";
-    states: {
-        readonly checkPrerequisites: {};
-        readonly sitePrereq: {};
-        readonly launch: {};
-        readonly measure: {};
-        readonly complete: {};
+    approvalNeeded?: boolean;
+    inputs: string[];
+    error?: string;
+}
+interface DoResult {
+    preview: VerbPreview;
+    invoked: boolean;
+    post?: {
+        status: number;
+        idempotencyKey: string;
+        body: unknown;
+        action?: string;
+        actionStatus?: string;
+        says?: string;
+        note?: string;
     };
-}>;
+}
+declare function doVerb(api: Api, o: {
+    spec: string;
+    target?: string;
+    startup?: string;
+    input?: J$2;
+    mode?: string;
+    as?: string;
+    previewOnly?: boolean;
+    force?: boolean;
+    idempotencyKey?: string;
+}): Promise<DoResult>;
+
+type Env = Record<string, string | undefined>;
+interface Lease {
+    batch: string;
+    worker: string;
+    startup: string;
+    step: string;
+    priority?: number;
+    tasks: string[];
+    prompt: string;
+    until: string;
+    token: string;
+    session: string;
+    claimedAt: string;
+    leaseSeconds: number;
+    api: string;
+    closed: string[];
+    held?: 'dispatcher';
+}
+declare function leasesDir(env?: Env): string;
+declare class Leases {
+    readonly dir: string;
+    private now;
+    private env;
+    private memory?;
+    constructor(dir: string, now?: () => number, env?: Env);
+    private ensure;
+    private write;
+    file(batch: string): string;
+    save(l: Lease): Lease;
+    adopt(l: Lease): Lease;
+    get pin(): string | undefined;
+    needsAdoption(): boolean;
+    all(): Lease[];
+    live(l: Lease): boolean;
+    get(ref: string): Lease | undefined;
+    current(): Lease | undefined;
+    holding(task: string): Lease | undefined;
+    update(batch: string, patch: (l: Lease) => void): Lease | undefined;
+    markClosed(batch: string, task: string): Lease | undefined;
+    remove(batch: string): void;
+    remember(kind: 'queue' | 'worklist', ids: string[]): void;
+    recall(kind: 'queue' | 'worklist'): string[];
+}
 
-interface ArtifactCounts {
-    icpCount: number;
-    competitorCount: number;
-    leanCanvasCount: number;
-    hypothesisCount: number;
-    positioningSet: boolean;
-    differentiatorCount: number;
-    storyBrandCount: number;
-    serviceCount: number;
-    agentCount: number;
-    domainCount: number;
-    pageCount: number;
-}
-/**
- * Fetch artifact counts for a given startup from the API.
- * Uses `limit=0` to get only `totalDocs` without transferring documents.
- */
-declare function fetchArtifactCounts(startupId: string, apiBaseUrl: string, apiKey?: string): Promise<ArtifactCounts>;
+type J$1 = Record<string, any>;
+interface Out<T = unknown> {
+    text: string;
+    data: T;
+    exit: number;
+}
+interface Batch {
+    $id: string;
+    worker: string;
+    startup: string;
+    startups?: string[];
+    step: string;
+    stepTitle?: string;
+    priority: number;
+    tasks: string[];
+    prompt: string;
+    claim: string;
+    [k: string]: unknown;
+}
+interface Cred {
+    token: string;
+    api: string;
+}
+interface SessionDeps {
+    base: string;
+    leases: Leases;
+    token: () => Promise<string | Cred | undefined>;
+    login?: () => Promise<string | Cred | undefined>;
+    fetch?: typeof fetch;
+    userAgent?: string;
+    now?: () => number;
+    session?: string;
+    leaseSeconds?: number;
+    env?: Record<string, string | undefined>;
+}
+declare class Session {
+    readonly base: string;
+    readonly leases: Leases;
+    private d;
+    constructor(d: SessionDeps);
+    api(c?: string | Cred): Api;
+    private cred;
+    private leaseCred;
+    private now;
+    private get env();
+    private adopting?;
+    ensureLease(): Promise<Out<null> | undefined>;
+    private adopt;
+    private ended;
+    short(u: string | undefined): string;
+    when(iso: string | undefined): string;
+    private baseToken;
+    private fail;
+    private none;
+    resolve(ref: string, o?: {
+        kind?: 'task' | 'batch';
+    }): string;
+    private label;
+    private readToken;
+    batchLine(b: Batch, i: number, withWorker: boolean): string;
+    listQueue(o?: {
+        worker?: string;
+        limit?: number;
+    }): Promise<{
+        r: Res;
+        batches: Batch[];
+    }>;
+    queue(o?: {
+        worker?: string;
+        limit?: number;
+    }): Promise<Out<{
+        batches: Batch[];
+    }>>;
+    private batchOf;
+    private claimOne;
+    claim(o?: {
+        ref?: string;
+        worker?: string;
+        leaseSeconds?: number;
+        skip?: Set<string>;
+    }): Promise<Out<{
+        lease?: Omit<Lease, 'token'>;
+        taken: string[];
+    }>>;
+    private leaseOf;
+    private leasePost;
+    renew(o?: {
+        batch?: string | Lease;
+        leaseSeconds?: number;
+        notAfter?: number;
+    }): Promise<Out<{
+        until?: string;
+        lost?: boolean;
+        dispatcher?: boolean;
+        capped?: boolean;
+    }>>;
+    release(o?: {
+        batch?: string | Lease;
+    }): Promise<Out<{
+        closed: number;
+        returned: number;
+        already?: boolean;
+        dispatcher?: boolean;
+    }>>;
+    batchPrompt(l: Lease): Promise<Out<{
+        url: string;
+    }>>;
+    prompt(o?: {
+        name?: string;
+        set?: string;
+    }): Promise<Out<J$1>>;
+    private isLeaseToken;
+    promptSet(o: {
+        name: string;
+        text: string;
+        idempotencyKey?: string;
+    }): Promise<Out<J$1>>;
+    show(o: {
+        ref: string;
+        md?: boolean;
+    }): Promise<Out<J$1>>;
+    thingText(t: J$1): string;
+    value(v: unknown, max?: number): string;
+    diffText(a: J$1 | undefined): string;
+    closeLine(label: string, r: CloseResult, left?: number): string;
+    close(o: {
+        ref: string;
+        body?: unknown;
+        mode?: Mode;
+        as?: string;
+        force?: boolean;
+        idempotencyKey?: string;
+    }): Promise<Out<CloseResult | null>>;
+    closedOf(l: Lease): Promise<string[]>;
+    worklistText(w: Worklist): string;
+    taskLine(t: Task, n: number): string;
+    worklist(o: {
+        worker: string;
+        startups?: string[];
+        limit?: number;
+        page?: number;
+    }): Promise<Out<Worklist>>;
+    versions(o: {
+        ref: string;
+        limit?: number;
+    }): Promise<Out<J$1>>;
+    revert(o: {
+        ref: string;
+        to: string;
+        mode?: Mode;
+        idempotencyKey?: string;
+    }): Promise<Out<J$1>>;
+    changes(o?: {
+        worker?: string;
+        startup?: string;
+        limit?: number;
+    }): Promise<Out<J$1>>;
+}
+
+type J = Record<string, any>;
+declare const VERDICTS: readonly ["confirmed", "corrected", "unsure"];
+declare function checkBody(event: string, body: unknown): {
+    body?: J;
+    errors: string[];
+};
 
-interface ProgressEntry {
-    state: string;
-    label: string;
-    status: 'complete' | 'current' | 'pending';
+interface AgentRun {
+    prompt: string;
+    env: Record<string, string>;
+    cwd: string;
+    batch: string;
+    log: {
+        out: (chunk: string) => void;
+        err: (chunk: string) => void;
+    };
+    signal: AbortSignal;
+    done: () => Promise<boolean>;
 }
-interface NextCommand {
+interface AgentResult {
+    exitCode: number | null;
+    note?: string;
+}
+type AgentRunner = (r: AgentRun) => Promise<AgentResult>;
+interface WorkOpts {
+    agent: AgentRunner;
+    agentName: string;
+    worker?: string;
+    maxBatches?: number;
+    wait?: boolean;
+    pollMs?: number;
+    renewMs?: number;
+    watchMs?: number;
+    logDir: string;
+    line: (s: string) => void;
+    signal: AbortSignal;
+    env?: Record<string, string | undefined>;
+    selfCli?: string;
+    tmpRoot?: string;
+    now?: () => number;
+    wallMinutes?: number;
+}
+interface WorkSummary {
+    batches: number;
+    tasks: number;
+    closed: number;
+    errors: number;
+    ms: number;
+    stopped: 'empty' | 'max' | 'signal' | 'error';
+}
+declare function agentEnv(base: Record<string, string | undefined>, lease: Lease, api: string, binDir?: string, configHome?: string, workdir?: string): Record<string, string>;
+declare function agentPrompt(md: string, n: number): string;
+declare function work(s: Session, o: WorkOpts): Promise<WorkSummary>;
+
+declare function printRunner(o?: {
+    out?: (s: string) => void;
+    pollMs?: number;
+}): AgentRunner;
+
+type A = Record<string, any>;
+interface ToolDef {
     name: string;
-    collection: string;
-    operation: string;
-    command: string;
-    schema: Record<string, unknown>;
     description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    run: (s: Session, a: A) => Promise<Out>;
 }
-/**
- * Query the API for artifact counts, determine current state,
- * and return the reconciled state name plus the artifact counts.
- */
-declare function reconcileState(startupId: string, apiBaseUrl: string, apiKey?: string): Promise<{
-    currentState: string;
-    counts: ArtifactCounts;
-}>;
-/**
- * Return progress entries for every state in the machine.
- */
-declare function getProgress(currentState: string): ProgressEntry[];
-/**
- * Extract the `meta.commands` from the machine definition for the given state
- * and fill in the startup ID to produce ready-to-run CLI commands.
- */
-declare function getNextCommands(currentState: string, startupId: string): NextCommand[];
+declare const TOOLS: ToolDef[];
+declare function mcpServer(session: Session, version: string, o?: {
+    owner?: boolean;
+}): Server;
 
-export { type ArtifactCounts, type SalesBuilderContext, type SalesBuilderEvent, type ServicesBuilderContext, type ServicesBuilderEvent, type SiteBuilderContext, type SiteBuilderEvent, type StartupBuilderContext, type StartupBuilderEvent, fetchArtifactCounts, getNextCommands, getProgress, reconcileState, salesBuilderMachine, servicesBuilderMachine, siteBuilderMachine, startupBuilderMachine };
+export { type AgentRun, type AgentRunner, Api, Auth, type Batch, type CloseResult, type ClosesOn, type ClosingTask, type Cluster, DEFAULT_API, type Lease, Leases, type Mode, type Out, type Res, Session, type SessionDeps, type Stored, TOOLS, type Task, VERDICTS, type WorkOpts, type WorkSummary, type Worklist, WorklistError, agentEnv, agentPrompt, apiBase, batchText, buildWorklist, checkBody, closeTask, closeText, closesOf, collectionOf, derivePriority, doVerb, fetchWorklistMarkdown, findClosesOn, groupBatch, heldByNames, leasesDir, mcpServer, parseWorker, pkce, printRunner, renderPrompt, runCloud, selectBatch, stepOf, tokenFile, unwrapState, verbPath, work, worklistPath };