@otto-code/cli 0.8.19 → 0.9.2

package/dist/commands/artifact/ls.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const artifactListSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 16 },
+        { header: "NAME", field: "name", width: 28 },
+        { header: "PROJECT", field: "project", width: 28 },
+        { header: "STORED", field: "stored", width: 14 },
+        { header: "SOURCE", field: "source", width: 12 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+function storageLabel(location) {
+    switch (location) {
+        case "repository":
+            return "Repository";
+        case "host":
+            return "This host";
+        default:
+            return "Legacy";
+    }
+}
+function sourceLabel(source) {
+    if (!source)
+        return "-";
+    switch (source.kind) {
+        case "chat":
+            return "Chat";
+        case "schedule":
+            return "Schedule";
+        case "workflow":
+            return "Workflow";
+    }
+}
+export function toArtifactRow(artifact) {
+    return {
+        id: artifact.id,
+        name: artifact.name,
+        project: artifact.projectId,
+        stored: storageLabel(artifact.storageLocation),
+        source: sourceLabel(artifact.source),
+        status: artifact.status,
+        updatedAt: artifact.updatedAt,
+    };
+}
+export async function runArtifactListCommand(options, _command) {
+    // The daemon filters by project root path, not registry id. A registry id
+    // would be resolved as a relative path under the daemon's cwd and silently
+    // match nothing, so refuse anything that is not an absolute path up front.
+    if (options.project !== undefined && !path.isAbsolute(options.project)) {
+        throw {
+            code: "ARTIFACT_PROJECT_INVALID",
+            message: `--project must be an absolute project root path, received ${JSON.stringify(options.project)}`,
+        };
+    }
+    const client = await connectArtifactClient(options.host, "artifacts");
+    try {
+        const payload = await client.artifactList(options.project === undefined ? undefined : { projectId: options.project });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact list is unavailable");
+        return { type: "list", data: payload.artifacts.map(toArtifactRow), schema: artifactListSchema };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_LIST_FAILED", "list artifacts", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/artifact/move.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+interface MoveArtifactOptions extends ArtifactCommandOptions {
+    to?: string;
+}
+interface MoveArtifactResult {
+    id: string;
+    storageLocation: "repository" | "host" | null;
+    status: string;
+    updatedAt: string;
+}
+export declare function runMoveCommand(id: string, options: MoveArtifactOptions, _command: Command): Promise<SingleResult<MoveArtifactResult>>;
+export {};
+//# sourceMappingURL=move.d.ts.map

package/dist/commands/artifact/move.js

@@ -0,0 +1,41 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const moveArtifactSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 12 },
+        { header: "STORED", field: "storageLocation", width: 14 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+export async function runMoveCommand(id, options, _command) {
+    if (options.to !== "repository" && options.to !== "host") {
+        throw {
+            code: "INVALID_ARTIFACT_STORAGE_LOCATION",
+            message: "--to must be repository or host.",
+        };
+    }
+    const client = await connectArtifactClient(options.host, "move");
+    try {
+        const payload = await client.artifactMoveStore({ artifactId: id, destination: options.to });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact move failed");
+        return {
+            type: "single",
+            data: {
+                id: payload.artifact.id,
+                storageLocation: payload.artifact.storageLocation ?? null,
+                status: payload.artifact.status,
+                updatedAt: payload.artifact.updatedAt,
+            },
+            schema: moveArtifactSchema,
+        };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_MOVE_FAILED", "move artifact", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=move.js.map

package/dist/commands/artifact/regenerate.d.ts

@@ -0,0 +1,12 @@
+import type { ArtifactMetadata } from "@otto-code/protocol/artifacts/types";
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+export interface RegeneratedArtifactResult {
+    id: string;
+    status: string;
+    updatedAt: string;
+}
+export declare function toRegeneratedArtifactResult(artifact: ArtifactMetadata): RegeneratedArtifactResult;
+export declare function runRegenerateCommand(id: string, options: ArtifactCommandOptions, _command: Command): Promise<SingleResult<RegeneratedArtifactResult>>;
+//# sourceMappingURL=regenerate.d.ts.map

package/dist/commands/artifact/regenerate.js

@@ -0,0 +1,32 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const regeneratedArtifactSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 16 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+export function toRegeneratedArtifactResult(artifact) {
+    return { id: artifact.id, status: artifact.status, updatedAt: artifact.updatedAt };
+}
+export async function runRegenerateCommand(id, options, _command) {
+    const client = await connectArtifactClient(options.host, "artifacts");
+    try {
+        const payload = await client.artifactRegenerate({ artifactId: id });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact regeneration failed");
+        return {
+            type: "single",
+            data: toRegeneratedArtifactResult(payload.artifact),
+            schema: regeneratedArtifactSchema,
+        };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_REGENERATE_FAILED", "regenerate artifact", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=regenerate.js.map

package/dist/commands/artifact/repair.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+import type { ArtifactMetadata } from "@otto-code/protocol/artifacts/types";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+export interface RepairedArtifactResult {
+    id: string;
+    status: string;
+    updatedAt: string;
+    repairAvailable: boolean;
+}
+export declare function toRepairedArtifactResult(artifact: ArtifactMetadata): RepairedArtifactResult;
+export declare function runRepairCommand(id: string, options: ArtifactCommandOptions, _command: Command): Promise<SingleResult<RepairedArtifactResult>>;
+//# sourceMappingURL=repair.d.ts.map

package/dist/commands/artifact/repair.js

@@ -0,0 +1,38 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const repairedArtifactSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 16 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+        { header: "REPAIR AVAILABLE", field: "repairAvailable", width: 18 },
+    ],
+};
+export function toRepairedArtifactResult(artifact) {
+    return {
+        id: artifact.id,
+        status: artifact.status,
+        updatedAt: artifact.updatedAt,
+        repairAvailable: artifact.repairAvailable ?? false,
+    };
+}
+export async function runRepairCommand(id, options, _command) {
+    const client = await connectArtifactClient(options.host, "repair");
+    try {
+        const payload = await client.artifactRepair({ artifactId: id });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact repair failed");
+        return {
+            type: "single",
+            data: toRepairedArtifactResult(payload.artifact),
+            schema: repairedArtifactSchema,
+        };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_REPAIR_FAILED", "repair artifact", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=repair.js.map

package/dist/commands/artifact/shared.d.ts

@@ -0,0 +1,10 @@
+import type { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import type { CommandError, CommandOptions } from "../../output/index.js";
+export interface ArtifactCommandOptions extends CommandOptions {
+    host?: string;
+}
+type ArtifactCommandCapability = "artifacts" | "data" | "move" | "repair";
+export declare function connectArtifactClient(host?: string, capability?: ArtifactCommandCapability): Promise<DaemonClient>;
+export declare function toArtifactCommandError(code: string, action: string, error: unknown): CommandError;
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/artifact/shared.js

@@ -0,0 +1,62 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+function supportsArtifactCapability(capability, features) {
+    switch (capability) {
+        case "artifacts":
+            return features?.artifacts;
+        case "data":
+            return features?.artifactDataUpdate;
+        case "move":
+            return features?.artifactStoreMove;
+        case "repair":
+            return features?.artifactRepair;
+    }
+}
+function artifactCapabilityUpgradeMessage(capability) {
+    switch (capability) {
+        case "artifacts":
+            return "Update the host to list artifacts.";
+        case "data":
+            return "Update the host to read or update artifact data.";
+        case "move":
+            return "Update the host to move artifacts between storage locations.";
+        case "repair":
+            return "Update the host to repair artifact output.";
+    }
+}
+export async function connectArtifactClient(host, capability = "data") {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        const supportsCapability = supportsArtifactCapability(capability, client.getLastServerInfoMessage()?.features);
+        // COMPAT(artifactDataUpdate): added in v0.9.0, remove after 2027-02-28.
+        // COMPAT(artifactStoreMove): added in v0.9.0, remove after 2027-02-28.
+        // COMPAT(artifactRepair): added in v0.9.0, remove after 2027-02-28.
+        if (!supportsCapability) {
+            await client.close().catch(() => { });
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: artifactCapabilityUpgradeMessage(capability),
+            };
+        }
+        return client;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && "message" in error) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+}
+export function toArtifactCommandError(code, action, error) {
+    if (error && typeof error === "object" && "code" in error && "message" in error) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { code, message: `Failed to ${action}: ${message}` };
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/artifact/update-data.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+interface UpdateDataOptions extends ArtifactCommandOptions {
+    data?: unknown;
+}
+export declare function runUpdateDataCommand(id: string, options: UpdateDataOptions, _command: Command): Promise<SingleResult<{
+    id: string;
+    status: string;
+    updatedAt: string;
+}>>;
+export {};
+//# sourceMappingURL=update-data.d.ts.map

package/dist/commands/artifact/update-data.js

@@ -0,0 +1,43 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const artifactDataUpdateSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 12 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+export async function runUpdateDataCommand(id, options, _command) {
+    let data;
+    try {
+        if (typeof options.data !== "string") {
+            throw new Error("--data JSON is required");
+        }
+        data = JSON.parse(options.data);
+    }
+    catch (error) {
+        throw toArtifactCommandError("INVALID_ARTIFACT_DATA", "parse --data JSON", error);
+    }
+    const client = await connectArtifactClient(options.host, "data");
+    try {
+        const payload = await client.artifactUpdateData({ artifactId: id, data });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact data update failed");
+        return {
+            type: "single",
+            data: {
+                id: payload.artifact.id,
+                status: payload.artifact.status,
+                updatedAt: payload.artifact.updatedAt,
+            },
+            schema: artifactDataUpdateSchema,
+        };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_DATA_UPDATE_FAILED", "update artifact data", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=update-data.js.map

package/dist/commands/daemon/index.js

@@ -5,8 +5,9 @@ import { runStopCommand } from "./stop.js";
 import { runRestartCommand } from "./restart.js";
 import { runSetPasswordCommand } from "./set-password.js";
 import { pairCommand } from "./pair.js";
+import { runDaemonReloadCommand } from "./reload.js";
 import { withOutput } from "../../output/index.js";
-import { addJsonOption } from "../../utils/command-options.js";
+import { addJsonAndDaemonHostOptions, addJsonOption } from "../../utils/command-options.js";
 function resolveHostnamesOption(hostnames, allowedHosts) {
     if (typeof hostnames === "string")
         return hostnames;
@@ -18,6 +19,7 @@ export function createDaemonCommand() {
     const daemon = new Command("daemon").description("Manage the Otto daemon");
     daemon.addCommand(startCommand());
     daemon.addCommand(pairCommand());
+    addJsonAndDaemonHostOptions(daemon.command("reload").description("Reload config.json without restarting the daemon")).action(withOutput(runDaemonReloadCommand));
     addJsonOption(daemon.command("status").description("Show local daemon status"))
         .option("--home <path>", "Otto home directory (default: ~/.otto)")
         .action(withOutput(runStatusCommand));

package/dist/commands/daemon/reload.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { CommandOptions, OutputSchema, SingleResult } from "../../output/index.js";
+export interface DaemonReloadResult {
+    appliedPaths: string[];
+    restartRequiredPaths: string[];
+    overrideControlledPaths: string[];
+}
+export declare const daemonReloadSchema: OutputSchema<DaemonReloadResult>;
+export declare function runDaemonReloadCommand(options: CommandOptions, _command: Command): Promise<SingleResult<DaemonReloadResult>>;
+//# sourceMappingURL=reload.d.ts.map

package/dist/commands/daemon/reload.js

@@ -0,0 +1,36 @@
+import { connectToDaemon } from "../../utils/client.js";
+export const daemonReloadSchema = {
+    idField: () => "daemon-config",
+    columns: [],
+    renderHuman(result) {
+        if (result.type !== "single")
+            return "";
+        const lines = ["Configuration reloaded."];
+        if (result.data.restartRequiredPaths.length > 0) {
+            lines.push("", "Warning: These changes require a daemon restart:", ...result.data.restartRequiredPaths.map((path) => `  ${path}`), "", "Run: otto daemon restart");
+        }
+        if (result.data.overrideControlledPaths.length > 0) {
+            lines.push("", "Warning: These settings are controlled by daemon launch overrides:", ...result.data.overrideControlledPaths.map((path) => `  ${path}`));
+        }
+        return lines.join("\n");
+    },
+};
+export async function runDaemonReloadCommand(options, _command) {
+    const client = await connectToDaemon({ host: options.host });
+    try {
+        const payload = await client.reloadDaemonConfig();
+        return {
+            type: "single",
+            data: {
+                appliedPaths: payload.appliedPaths,
+                restartRequiredPaths: payload.restartRequiredPaths,
+                overrideControlledPaths: payload.overrideControlledPaths,
+            },
+            schema: daemonReloadSchema,
+        };
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=reload.js.map

package/dist/commands/hub/daemon-client.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderSnapshotEntry } from "@otto-code/protocol/agent-types";
 export interface HubStatus {
     state: string;
     daemonId: string | null;
@@ -6,6 +7,9 @@ export interface HubStatus {
     connectedAt: string | null;
     lastError: string | null;
 }
+export interface HubProvidersSnapshotOptions {
+    cwd?: string;
+}
 export interface HubDaemonClient {
     connectHub(url: string, token: string): Promise<{
         status: HubStatus;
@@ -17,6 +21,9 @@ export interface HubDaemonClient {
         status: HubStatus;
         warning?: string;
     }>;
+    getProvidersSnapshot(options?: HubProvidersSnapshotOptions): Promise<{
+        entries: ProviderSnapshotEntry[];
+    }>;
     close(): Promise<void>;
 }
 export interface HubDaemonConnection {

package/dist/commands/hub/hub-client/index.d.ts

@@ -1,6 +1,6 @@
 import type { HubBundleFile } from "../deploy-bundle.js";
-import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubConfigurationResources, type HubProject, type HubValidationResult } from "./internal/contracts.js";
-export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubProject, HubValidationResult, } from "./internal/contracts.js";
+import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubConfigurationResources, type HubSetupResources, type HubProject, type HubValidationResult } from "./internal/contracts.js";
+export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubSetupResources, HubProject, HubValidationResult, } from "./internal/contracts.js";
 interface HubConfigurationInput {
     origin: string;
     apiKey: string;
@@ -12,6 +12,7 @@ export declare class HubHttpClient {
     pollCliAuthorization(origin: string, deviceCode: string, timeoutMilliseconds: number): Promise<CliAuthorizationPoll>;
     listProjects(origin: string, apiKey: string): Promise<HubProject[]>;
     listConfigurationResources(origin: string, apiKey: string): Promise<HubConfigurationResources>;
+    listSetupResources(origin: string, apiKey: string): Promise<HubSetupResources>;
     installConfiguration(input: HubConfigurationInput): Promise<HubInstallResult>;
     validateConfiguration(input: HubConfigurationInput): Promise<HubValidationResult>;
     issueEnrollmentToken(origin: string, apiKey: string): Promise<string>;

package/dist/commands/hub/hub-client/index.js

@@ -1,5 +1,5 @@
 import { HubCommandError } from "../error.js";
-import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
+import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, setupResourcesSchema, } from "./internal/contracts.js";
 import { requestHub } from "./internal/transport.js";
 export class HubHttpClient {
     startCliAuthorization(origin) {
@@ -56,6 +56,17 @@ export class HubHttpClient {
             failureMessage: "Hub configuration resource listing failed",
         });
     }
+    listSetupResources(origin, apiKey) {
+        return requestHub({
+            origin,
+            path: "/api/v1/setup-resources",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: setupResourcesSchema,
+            failureMessage: "Hub guided setup resource listing failed",
+        });
+    }
     installConfiguration(input) {
         return requestHub({
             origin: input.origin,

package/dist/commands/hub/hub-client/internal/contracts.d.ts

@@ -62,6 +62,22 @@ export declare const configurationResourcesSchema: z.ZodObject<{
         teamName: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const setupResourcesSchema: z.ZodObject<{
+    github: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        accountLogin: z.ZodString;
+        accountType: z.ZodString;
+        repositories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    discord: z.ZodArray<z.ZodObject<{
+        guildId: z.ZodString;
+        guildName: z.ZodString;
+    }, z.core.$strict>>;
+    slack: z.ZodArray<z.ZodObject<{
+        teamId: z.ZodString;
+        teamName: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const installResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     version: z.ZodNumber;
@@ -80,6 +96,7 @@ export type CliAuthorization = z.infer<typeof authorizationSchema>;
 export type CliAuthorizationPoll = z.infer<typeof authorizationPollSchema>;
 export type HubProject = z.infer<typeof projectSchema>;
 export type HubConfigurationResources = z.infer<typeof configurationResourcesSchema>;
+export type HubSetupResources = z.infer<typeof setupResourcesSchema>;
 export type HubInstallResult = z.infer<typeof installResponseSchema>;
 export type HubValidationResult = z.infer<typeof validationResponseSchema>;
 export {};

package/dist/commands/hub/hub-client/internal/contracts.js

@@ -45,6 +45,20 @@ export const configurationResourcesSchema = z
     slack: z.array(z.object({ slug: z.string().min(1), teamName: z.string().min(1) }).strict()),
 })
     .strict();
+export const setupResourcesSchema = z
+    .object({
+    github: z.array(z
+        .object({
+        slug: z.string().min(1),
+        accountLogin: z.string().min(1),
+        accountType: z.string().min(1),
+        repositories: z.array(z.string().min(1)),
+    })
+        .strict()),
+    discord: z.array(z.object({ guildId: z.string().min(1), guildName: z.string().min(1) }).strict()),
+    slack: z.array(z.object({ teamId: z.string().min(1), teamName: z.string().min(1) }).strict()),
+})
+    .strict();
 export const installResponseSchema = z
     .object({
     projectSlug: z.string().min(1),

package/dist/commands/hub/index.js

@@ -14,7 +14,7 @@ import { addHubProjectsCommand } from "./projects.js";
 import { processHubReporter } from "./reporter.js";
 import { hubStatusResult } from "./status-output.js";
 import { addHubResolutionHelp } from "./help.js";
-import { addHubInitCommand } from "./init.js";
+import { addHubInitCommand, continueHubGuidedSetup } from "./init.js";
 function productionEnvironment() {
     const env = process.env;
     const hub = new HubHttpClient();
@@ -37,6 +37,8 @@ export function createHubCommand(overrides = {}) {
         credentials: environment.credentials,
         flow: environment.login,
         reporter: environment.reporter,
+        isInteractive: environment.isInteractive,
+        continueGuidedSetup: (origin) => continueHubGuidedSetup(origin, environment),
     });
     addHubInitCommand(hub, environment);
     addHubConnectCommand(hub, {

package/dist/commands/hub/init-plan.d.ts

@@ -1,6 +1,7 @@
 import type { HubDeployBundle } from "./deploy-bundle.js";
 import type { HubProject } from "./hub-client/index.js";
 import type { HubStatus } from "./daemon-client.js";
+import type { HubStarterAgentRuntime } from "./starter-agent-runtime.js";
 export type HubInitProvider = "github" | "slack" | "discord";
 export type HubInitProjectResolution = {
     kind: "none";
@@ -30,6 +31,7 @@ export interface HubInitOpeningPlan {
 export interface HubInitScaffoldInput {
     cwd: string;
     daemonSlug: string;
+    agent: HubStarterAgentRuntime;
     provider: HubInitProvider;
     providerFilters: Readonly<Record<string, string>>;
 }
@@ -39,6 +41,7 @@ export interface HubInitScaffold {
     workflow: string;
     testAction: string;
 }
+export declare function hubLoginResumeCommand(step: "connect" | "init", origin: string): string;
 export declare function planHubInitOpening(input: {
     loggedIn: boolean;
     ottoDirectoryExists: boolean;

package/dist/commands/hub/init-plan.js

@@ -1,5 +1,8 @@
 import path from "node:path";
 import YAML from "yaml";
+export function hubLoginResumeCommand(step, origin) {
+    return step === "connect" ? `otto hub connect ${origin}` : "otto hub init";
+}
 export function planHubInitOpening(input) {
     return {
         replaceExisting: input.ottoDirectoryExists,
@@ -47,9 +50,10 @@ export function createHubInitScaffold(input) {
             },
         },
         agents: {
-            codex: {
-                provider: "codex",
-                mode: "full-access",
+            starter: {
+                provider: input.agent.provider,
+                model: input.agent.model,
+                ...(input.agent.mode === undefined ? {} : { mode: input.agent.mode }),
             },
         },
     }, { lineWidth: 0 });
@@ -114,7 +118,7 @@ function workflow(input) {
                 environment: input.environment,
                 max_runtime: "90m",
                 idle_timeout: "10m",
-                agent: "codex",
+                agent: "starter",
                 prompt: [
                     {
                         text: `${replyInstruction}complete this request and call hub.finish_execution when done.\n\n<user-prompt>\n\${{ otto.prompt }}\n</user-prompt>\n`,