@stackbone/cli 0.1.0-alpha.1 → 0.1.0-alpha.3

package/CHANGELOG.md

@@ -7,6 +7,75 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0-alpha.3] - 2026-05-15
+
+### Added
+
+- `stackbone dev` sessions are now first-class `installation` rows
+  (`kind='local'`). The CLI registers the row via
+  `POST /api/v1/installations/local-dev` during `init`/`link`, `PATCH`es
+  `local_tunnel_url` on dev start, and nulls it on Ctrl-C. The dev
+  boot banner emits a path-aware deeplink
+  (`app.stackbone.ai/app/<orgSlug>/installations/<id>?stackbone-dev=<tunnel>`)
+  consumed in one shot by the `stackboneDevBootstrapGuard` so Studio
+  opens straight on the local installation. Local-dev rows skip the
+  provisioning saga and the tier-quota gate by construction and are
+  garbage-collected after 7 days of inactivity.
+
+### Changed
+
+- Unified agent runtime env contract under `STACKBONE_*`. The dev
+  emulator now injects `STACKBONE_AGENT_ID` (the agent slug) plus
+  `STACKBONE_S3_ACCESS_KEY` / `STACKBONE_S3_SECRET_KEY` /
+  `STACKBONE_S3_ENDPOINT` / `STACKBONE_S3_BUCKET` /
+  `STACKBONE_S3_REGION` / `STACKBONE_POSTGRES_URL` into the agent
+  process, replacing the previous mix of `AWS_*` / `S3_*` /
+  `DATABASE_URL` names. Agents that still read the legacy names must
+  migrate.
+- Emulator `/api/schema` now returns `{ input: null, output: null }`
+  (200) when the manifest declares neither schema or the agent is
+  unreachable — was 502 before. Mirrors the cloud `/studio/schema`
+  shape so the Studio Playground UI can boot before the agent is
+  healthy.
+- `dev/fixtures-store.ts` persists JSONL records using the canonical
+  `Fixture` wire schema (camelCase `createdAt`, typed as `Fixture`) so
+  list/create return the wire type directly.
+
+### Fixed
+
+- `protectedCommand` no longer triggers the device-code flow on the
+  user's behalf. When no valid session exists it fails fast with
+  `code: 'auth'` and the standard "Run stackbone login" hint, and it
+  no longer retries on a mid-flight 401. Reason: the HTTP adapter
+  caches `tokenStore.activeSession()` once per process, so the
+  pre-login `POST /api/auth/device/code` poisoned the cache with
+  `null` and every subsequent request from the same process went out
+  without an Authorization header.
+
+## [0.1.0-alpha.2] - 2026-05-12
+
+### Added
+
+- Per-stage spinners during `stackbone dev` (docker, platform/creator/rag
+  migrations, agent, emulator, tunnel) and a redesigned rounded-box Studio
+  banner that surfaces the actionable deeplink first. New global flag
+  `--verbose` (also `STACKBONE_VERBOSE=1`) restores the raw firehose of
+  docker compose stdout and pino logs for debugging.
+
+### Changed
+
+- `stackbone dev` Studio banner now prints
+  `app.stackbone.ai/app?stackbone-dev=<tunnel>` instead of the retired
+  `/studio?baseUrl=…` deeplink. The new URL is consumed in one shot by the
+  `stackboneDevBootstrapGuard` mounted on `/app`, which flips Studio to
+  local mode against the tunnel and opens the panel on Runs.
+
+### Fixed
+
+- `stackbone dev` boot banner no longer emits a leading newline or
+  duplicate `│` rail rows around the inlined Studio banner when running
+  under clack's left rail in human mode.
+
 ## [0.1.0-alpha.1] - 2026-05-12
 
 ### Changed

package/main.js

@@ -82,6 +82,7 @@ var installationStatusSchema = z.enum([
 	"deprovisioning",
 	"deprovisioned"
 ]);
+var installationKindSchema = z.enum(["cloud", "local"]);
 var installationProviderSchema = z.enum([
 	"neon",
 	"r2",
@@ -109,17 +110,30 @@ z.object({
 	slug: organizationSlugSchema,
 	id: z.uuid()
 });
-z.object({
+var installationResponseSchema = z.object({
 	id: z.uuid(),
 	organizationId: z.uuid(),
 	agentId: z.uuid(),
 	agentVersion: z.string(),
 	status: installationStatusSchema,
+	kind: installationKindSchema.default("cloud"),
+	localTunnelUrl: z.url().nullable().optional(),
+	lastActiveAt: z.iso.datetime().nullable().optional(),
 	config: jsonObject(),
 	createdByUserId: z.uuid(),
 	createdAt: z.iso.datetime(),
 	updatedAt: z.iso.datetime()
 });
+z.object({
+	creatorOrganizationSlug: organizationSlugSchema,
+	agentTemplateSlug: z.string().min(1).max(80),
+	endUserOrganizationSlug: organizationSlugSchema.optional()
+});
+z.object({ localTunnelUrl: z.url().nullable() });
+var localDevInstallationResponseSchema = installationResponseSchema.extend({
+	organizationSlug: organizationSlugSchema,
+	agentSlug: z.string().min(1).max(80)
+});
 z.object({
 	id: z.uuid(),
 	installationId: z.uuid(),
@@ -468,6 +482,11 @@ z.object({
 	nextCursor: z.string().nullable(),
 	prevCursor: z.string().nullable()
 });
+z.object({ fxtId: z.uuid() });
+z.object({
+	input: jsonObject().nullable(),
+	output: jsonObject().nullable()
+});
 //#endregion
 //#region ../../libs/validators/src/lib/auth/session.ts
 var sessionUserSchema = z.object({
@@ -931,12 +950,22 @@ var credentialsSchema = z.object({
 * Project-local config is written by `stackbone init`/`link` to
 * `<cwd>/.stackbone/project.json`. Tracks which agent in which organization this
 * directory points at. Excluded from git by the same `.gitignore` patch.
+*
+* Feature 42: `localDevInstallationId` + `organizationSlug` + `agentSlug` are
+* captured at `init`/`link` time so `stackbone dev` can build the path-aware
+* deeplink (`/app/<orgSlug>/installations/<id>?stackbone-dev=…`) and patch
+* the tunnel URL without a separate `GET` round-trip. They are optional so
+* old project.json files continue to load — a future `stackbone dev` against
+* a pre-feature-42 directory simply re-registers the local-dev row.
 */
 var projectConfigSchema = z.object({
 	schemaVersion: z.literal(1),
 	organizationId: z.uuid(),
 	agentId: z.uuid(),
-	controlPlaneUrl: z.url()
+	controlPlaneUrl: z.url(),
+	localDevInstallationId: z.uuid().optional(),
+	organizationSlug: z.string().optional(),
+	agentSlug: z.string().optional()
 });
 /**
 * Project-shared config at `<cwd>/stackbone.config.json` (committable, unlike
@@ -1263,13 +1292,16 @@ var createHttpAdapter = (opts) => {
 	};
 	return {
 		get: (path) => request("GET", path),
-		post: (path, body) => request("POST", path, body)
+		post: (path, body) => request("POST", path, body),
+		patch: (path, body) => request("PATCH", path, body)
 	};
 };
 //#endregion
 //#region src/infra/logger.ts
 var createLogger = (opts) => {
-	const level = opts.level ?? process.env["STACKBONE_LOG_LEVEL"] ?? "info";
+	const envLevel = process.env["STACKBONE_LOG_LEVEL"];
+	const defaultLevel = opts.json || opts.verbose ? "info" : "warn";
+	const level = opts.level ?? envLevel ?? defaultLevel;
 	if (opts.json) return pino({ level }, pino.destination(2));
 	const stream = pretty({
 		destination: 2,
@@ -1359,8 +1391,8 @@ var flagValue = (argv, flag) => {
 var parseFlags = (argv, env) => ({
 	json: detectJsonMode(argv, env),
 	yes: flagPresent(argv, "-y") || flagPresent(argv, "--yes"),
-	autoLogin: env["STACKBONE_AUTO_LOGIN"] !== "0" && !flagPresent(argv, "--no-auto-login"),
-	apiUrlOverride: flagValue(argv, "--api-url") ?? env["STACKBONE_API_URL"] ?? null
+	apiUrlOverride: flagValue(argv, "--api-url") ?? env["STACKBONE_API_URL"] ?? null,
+	verbose: flagPresent(argv, "--verbose") || env["STACKBONE_VERBOSE"] === "1"
 });
 /**
 * Builds the single `CliContext` value passed to every command.
@@ -1378,7 +1410,10 @@ var parseFlags = (argv, env) => ({
 */
 var createCliContext = async (opts) => {
 	const flags = parseFlags(opts.argv, opts.env);
-	const logger = createLogger({ json: flags.json });
+	const logger = createLogger({
+		json: flags.json,
+		verbose: flags.verbose
+	});
 	const projectConfig = createProjectConfigAdapter(opts.cwd);
 	const globalConfig = createGlobalConfigAdapter();
 	const tokenStore = createTokenStore();
@@ -1416,7 +1451,7 @@ var isVersionFlag = (rawArgs) => rawArgs.length === 1 && VERSION_FLAGS.has(rawAr
 var formatVersionOutput = (input) => `stackbone-cli ${input.cliVersion}\ncontract ${input.contractVersion}`;
 //#endregion
 //#region src/dev/contract.ts
-var STACKBONE_CLI_BUILD_VERSION = "0.1.0-alpha.1";
+var STACKBONE_CLI_BUILD_VERSION = "0.1.0-alpha.3";
 /**
 * Capabilities the local emulator advertises on `GET /api/contract`. Typed as
 * `readonly Capability[]` so the compiler refuses any string outside the
@@ -1737,55 +1772,25 @@ var clearSession = async (ctx) => {
 };
 //#endregion
 //#region src/commands/_shared/protected.ts
-var isAuthError = (err) => isStackboneCliError(err) && err.code === "auth";
-var refuseWithAuthError = () => {
-	throw new StackboneCliError({
-		code: "auth",
-		message: "Not authenticated",
-		suggestion: "Run `stackbone login`"
-	});
-};
-var ensureSession = async (ctx) => {
-	const existing = await getCurrentSession(ctx);
-	if (existing) return existing;
-	if (!ctx.flags.autoLogin) refuseWithAuthError();
-	await runLoginFlow(ctx);
-	return await getCurrentSession(ctx) ?? refuseWithAuthError();
-};
 /**
 * Wraps a command handler so it always receives a non-null `Session`.
 *
-* If the credentials store is empty or the session expired:
-*   - With auto-login enabled (default): runs the device-code flow inline,
-*     reloads the session, and runs the handler.
-*   - With auto-login disabled (`STACKBONE_AUTO_LOGIN=0` or `--no-auto-login`):
-*     refuses immediately with `code: 'auth'` and exit 2.
-*
-* Retries once if the handler itself throws an auth error mid-flight
-* (token expired between the pre-check and the request). If the retry
-* also fails with auth, the corrupt credentials are dropped from disk so
-* the next invocation does not loop through the same broken session.
+* If the credentials store is empty or the session has expired, refuses
+* immediately with `code: 'auth'` (exit 2) and points the user at
+* `stackbone login`. Auth flow and command flow are kept strictly separate
+* — protected commands never trigger the device-code dance on the user's
+* behalf, and a 401 mid-flight propagates as-is so the same `stackbone
+* login` instruction is the only path back.
 */
 var protectedCommand = (handler) => {
 	return async (ctx) => {
-		const session = await ensureSession(ctx);
-		try {
-			await handler(ctx, session);
-		} catch (err) {
-			if (!isAuthError(err) || !ctx.flags.autoLogin) throw err;
-			ctx.logger.debug("auth error mid-flight, retrying after re-login");
-			await runLoginFlow(ctx);
-			const refreshed = await getCurrentSession(ctx) ?? refuseWithAuthError();
-			try {
-				await handler(ctx, refreshed);
-			} catch (retryErr) {
-				if (isAuthError(retryErr)) {
-					ctx.logger.warn("auth still failing after re-login, clearing the stored session");
-					await clearSession(ctx);
-				}
-				throw retryErr;
-			}
-		}
+		const session = await getCurrentSession(ctx);
+		if (!session) throw new StackboneCliError({
+			code: "auth",
+			message: "Not authenticated",
+			suggestion: "Run `stackbone login`"
+		});
+		await handler(ctx, session);
 	};
 };
 //#endregion
@@ -2608,7 +2613,7 @@ var buildMigrateStatusCommand = (ctx) => defineCommand({
 			env: ctx.env,
 			json: ctx.flags.json
 		});
-	})({})
+	})()
 });
 /**
 * Pure handler for `stackbone db migrate add-rag`. Reads `agent.yaml` to
@@ -2696,7 +2701,7 @@ var buildStudioCommand = (ctx) => defineCommand({
 			env: ctx.env,
 			json: ctx.flags.json
 		});
-	})({})
+	})()
 });
 var createDbCommand = (ctx) => defineCommand({
 	meta: {
@@ -2741,22 +2746,108 @@ var createDeployCommand = (ctx) => buildStubCommand(ctx, {
 });
 //#endregion
 //#region src/dev/boot-banner.ts
-var STUDIO_CLOUD_BASE_URL = "https://app.stackbone.ai/studio";
-var BORDER = "─".repeat(72);
-var buildDeeplink = (tunnelUrl) => `${STUDIO_CLOUD_BASE_URL}?baseUrl=${encodeURIComponent(tunnelUrl)}`;
+var ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	cyan: "\x1B[36m",
+	underline: "\x1B[4m"
+};
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+var visibleLength = (s) => s.replace(ANSI_RE, "").length;
+var LABEL_WIDTH = 11;
+var renderRow = (row, colors) => {
+	const marker = colors && row.marker.trim() ? `${ANSI.cyan}${row.marker}${ANSI.reset}` : row.marker;
+	const labelText = row.label.padEnd(LABEL_WIDTH, " ");
+	return `${marker} ${colors ? `${ANSI.dim}${labelText}${ANSI.reset}` : labelText}  ${colors && row.primary ? `${ANSI.bold}${ANSI.cyan}${row.value}${ANSI.reset}` : row.value}`;
+};
+var TITLE = "stackbone studio";
 var formatBootBanner = (input) => {
+	const colors = input.colors ?? false;
+	const rows = [];
+	if (input.deeplink && input.tunnelUrl) {
+		rows.push({
+			marker: "▸",
+			label: "Open Studio",
+			value: input.deeplink,
+			primary: true
+		});
+		rows.push({
+			marker: " ",
+			label: "",
+			value: ""
+		});
+		rows.push({
+			marker: " ",
+			label: "Tunnel",
+			value: input.tunnelUrl
+		});
+		rows.push({
+			marker: " ",
+			label: "Local",
+			value: input.localUrl
+		});
+	} else if (input.tunnelUrl) {
+		rows.push({
+			marker: "▸",
+			label: "Tunnel",
+			value: input.tunnelUrl,
+			primary: true
+		});
+		rows.push({
+			marker: " ",
+			label: "",
+			value: ""
+		});
+		rows.push({
+			marker: " ",
+			label: "Local",
+			value: input.localUrl
+		});
+	} else rows.push({
+		marker: "▸",
+		label: "Local",
+		value: input.localUrl,
+		primary: true
+	});
+	rows.push({
+		marker: " ",
+		label: "",
+		value: ""
+	});
+	rows.push({
+		marker: " ",
+		label: "Agent",
+		value: input.agentName
+	});
+	rows.push({
+		marker: " ",
+		label: "Protocol",
+		value: `v${input.contractVersion}  ·  ${input.capabilityCount} capabilities`
+	});
+	const renderedRows = rows.map((row) => {
+		if (row.label === "" && row.value === "") return "";
+		return renderRow(row, colors);
+	});
+	const padding = 2;
+	const longestRow = renderedRows.reduce((max, line) => Math.max(max, visibleLength(line)), 0);
+	const innerWidth = Math.max(longestRow, 22);
+	const totalInner = innerWidth + padding * 2;
+	const titleSegment = ` ${TITLE} `;
+	const titleSegmentColored = colors ? ` ${ANSI.bold}${TITLE}${ANSI.reset} ` : titleSegment;
+	const dashesAfter = totalInner - 1 - titleSegment.length;
+	const top = `╭─${titleSegmentColored}${"─".repeat(Math.max(dashesAfter, 1))}╮`;
+	const bottom = `╰${"─".repeat(totalInner)}╯`;
+	const padRow = (line) => {
+		const trailing = innerWidth - visibleLength(line);
+		return `│  ${line}${" ".repeat(Math.max(trailing, 0))}  │`;
+	};
 	const lines = [];
-	lines.push(BORDER);
-	lines.push("  Stackbone Studio");
-	lines.push("");
-	if (input.tunnelUrl) {
-		lines.push(`  Tunnel:    ${input.tunnelUrl}`);
-		lines.push(`  Studio:    ${buildDeeplink(input.tunnelUrl)}`);
-		lines.push(`  Local:     ${input.localUrl}    (sin tunnel)`);
-	} else lines.push(`  Local:     ${input.localUrl}`);
-	lines.push(`  Contract version ${input.contractVersion} (capabilities: ${input.capabilityCount})`);
-	lines.push("");
-	lines.push(BORDER);
+	lines.push(top);
+	lines.push(padRow(""));
+	for (const line of renderedRows) lines.push(padRow(line));
+	lines.push(padRow(""));
+	lines.push(bottom);
 	return lines.join("\n");
 };
 //#endregion
@@ -2896,6 +2987,7 @@ var fetchActiveConfigValue = async (client) => {
 //#region src/dev/connections.ts
 var STACKBONE_ENV_KEYS = {
 	contractVersion: "STACKBONE_CONTRACT_VERSION",
+	agentId: "STACKBONE_AGENT_ID",
 	postgresUrl: "STACKBONE_POSTGRES_URL",
 	queueUrl: "STACKBONE_QUEUE_URL",
 	s3Endpoint: "STACKBONE_S3_ENDPOINT",
@@ -2910,6 +3002,7 @@ var buildAgentEnv = (base, injection, options = {}) => {
 	const env = {
 		...base,
 		[STACKBONE_ENV_KEYS.contractVersion]: String(10),
+		[STACKBONE_ENV_KEYS.agentId]: injection.agentId,
 		[STACKBONE_ENV_KEYS.postgresUrl]: injection.services.postgresUrl,
 		[STACKBONE_ENV_KEYS.queueUrl]: injection.services.queueUrl,
 		[STACKBONE_ENV_KEYS.s3Endpoint]: injection.services.s3Endpoint,
@@ -3477,21 +3570,34 @@ volumes:
 //#endregion
 //#region src/dev/compose.ts
 var DOCKER_BIN = process.env["STACKBONE_DOCKER_BIN"] ?? "docker";
-var runDocker = async (args, cwd, signal) => {
+var runDocker = async (args, cwd, opts = {}) => {
 	await new Promise((resolve, reject) => {
+		const captured = [];
 		const child = spawn(DOCKER_BIN, args, {
 			cwd,
-			stdio: [
+			stdio: opts.verbose ? [
 				"ignore",
 				"inherit",
 				"inherit"
+			] : [
+				"ignore",
+				"pipe",
+				"pipe"
 			],
-			signal
+			signal: opts.signal
 		});
+		if (!opts.verbose) {
+			child.stdout?.on("data", (chunk) => captured.push(chunk));
+			child.stderr?.on("data", (chunk) => captured.push(chunk));
+		}
 		child.once("error", reject);
 		child.once("close", (code) => {
-			if (code === 0) resolve();
-			else reject(new StackboneCliError({
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			if (!opts.verbose && captured.length > 0) process.stderr.write(Buffer.concat(captured));
+			reject(new StackboneCliError({
 				code: "generic",
 				message: `\`docker ${args.join(" ")}\` exited with code ${code}`,
 				suggestion: "Check Docker Desktop is running and that the embedded compose file in `.stackbone/dev/` is valid"
@@ -3519,12 +3625,13 @@ var writeComposeFiles = async (runtime) => {
 	await writeFile(join(runtime.workdir, "Dockerfile.postgres"), POSTGRES_DOCKERFILE);
 };
 var composeUp = async (runtime) => {
+	const verbose = runtime.verbose ?? false;
 	await runDocker([
 		"compose",
 		"up",
 		"-d",
 		"--wait"
-	], runtime.workdir);
+	], runtime.workdir, { verbose });
 	await runDocker([
 		"compose",
 		"--profile",
@@ -3532,11 +3639,11 @@ var composeUp = async (runtime) => {
 		"run",
 		"--rm",
 		"minio-bucket-init"
-	], runtime.workdir);
+	], runtime.workdir, { verbose });
 };
 var composeDown = async (runtime) => {
 	try {
-		await runDocker(["compose", "down"], runtime.workdir);
+		await runDocker(["compose", "down"], runtime.workdir, { verbose: runtime.verbose ?? false });
 	} catch {}
 };
 var buildComposeRuntime = (projectRoot, options) => {
@@ -4051,7 +4158,7 @@ var quoteIdent = (raw) => `"${raw.replace(/"/g, "\"\"")}"`;
 //#region src/dev/fixtures-store.ts
 var defaultFixturesDir = () => resolve(homedir(), ".stackbone", "dev", "fixtures");
 var filenameFor = (baseDir, agentSlug) => resolve(baseDir, `${agentSlug}.jsonl`);
-var isSerializedFixture = (value) => !!value && typeof value === "object" && typeof value.id === "string" && typeof value.name === "string" && typeof value.created_at === "string";
+var isSerializedFixture = (value) => !!value && typeof value === "object" && typeof value.id === "string" && typeof value.name === "string" && typeof value.createdAt === "string";
 var readJsonl = async (path) => {
 	let raw;
 	try {
@@ -4078,7 +4185,7 @@ var createFixturesStore = (opts) => {
 	};
 	return {
 		async list() {
-			return (await readJsonl(path)).sort((a, b) => a.created_at < b.created_at ? 1 : -1);
+			return (await readJsonl(path)).sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
 		},
 		async create(input) {
 			await ensureDir();
@@ -4088,7 +4195,7 @@ var createFixturesStore = (opts) => {
 				name: input.name,
 				input: input.input,
 				description: input.description ?? null,
-				created_at: (/* @__PURE__ */ new Date()).toISOString()
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
 			};
 			await appendFile(path, `${JSON.stringify(fixture)}\n`, "utf8");
 			return fixture;
@@ -5335,22 +5442,25 @@ var buildEmulatorApp = (opts) => {
 	app.get("/api/logs/stream", (c) => streamSSE(c, (stream) => {
 		return runLogTail(stream, parseLogFilters(new URL(c.req.url).searchParams), (emit) => tailJsonlDirectory(logsDir, emit));
 	}));
-	const proxyAgentJson = async (path) => {
+	app.get("/api/schema", async (c) => {
 		try {
-			const resp = await fetch(`${agentBaseUrl}${path}`);
-			const body = await resp.text();
-			return new Response(body, {
-				status: resp.status,
-				headers: { "content-type": "application/json" }
+			const resp = await fetch(`${agentBaseUrl}/schema`);
+			if (!resp.ok) return c.json({
+				input: null,
+				output: null
+			});
+			const raw = await resp.json().catch(() => null);
+			return c.json({
+				input: extractSchemaField(raw, "input"),
+				output: extractSchemaField(raw, "output")
 			});
 		} catch {
-			return new Response(JSON.stringify({ error: "agent_unreachable" }), {
-				status: 502,
-				headers: { "content-type": "application/json" }
+			return c.json({
+				input: null,
+				output: null
 			});
 		}
-	};
-	app.get("/api/schema", () => proxyAgentJson("/schema"));
+	});
 	const dbExplorerOptions = { connectionString: opts.injection.services.postgresUrl };
 	app.get("/api/db/schemas", async (c) => {
 		const response = await listSchemas(dbExplorerOptions);
@@ -5953,6 +6063,12 @@ var buildEmulatorApp = (opts) => {
 	}));
 	return app;
 };
+var extractSchemaField = (raw, field) => {
+	if (!raw) return null;
+	const value = raw[field];
+	if (value && typeof value === "object" && !Array.isArray(value)) return value;
+	return null;
+};
 var eventMatchesRunId = (event, runId) => {
 	const data = event.data;
 	if (!data || typeof data["run_id"] === "undefined") return true;
@@ -7080,10 +7196,12 @@ var autoMigrationName = () => {
 	return `auto_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/T/, "_").slice(0, 15)}`;
 };
 var startDevSession = async (input) => {
+	const onStage = input.onStage ?? (() => void 0);
 	await ensureDockerAvailable();
 	const bus = createEventBus();
 	const agentPort = await pickFreePort();
 	const injection = {
+		agentId: input.agent.slug,
 		agentPort,
 		services: DEFAULT_DEV_SERVICES
 	};
@@ -7099,13 +7217,40 @@ var startDevSession = async (input) => {
 		minioRootPassword: "stackbone-secret",
 		minioDefaultBucket: "stackbone-dev"
 	});
+	if (input.verbose) compose.verbose = true;
 	await writeComposeFiles(compose);
-	await composeUp(compose);
+	onStage({
+		stage: "docker",
+		status: "start"
+	});
+	try {
+		await composeUp(compose);
+		onStage({
+			stage: "docker",
+			status: "success",
+			detail: "postgres + minio ready"
+		});
+	} catch (err) {
+		onStage({
+			stage: "docker",
+			status: "fail",
+			detail: err instanceof Error ? err.message : String(err)
+		});
+		throw err;
+	}
 	const migrationsDir = resolve(dirname(fileURLToPath(import.meta.url)), "migrations");
+	onStage({
+		stage: "platform-migrations",
+		status: "start"
+	});
+	let platformApplied = 0;
+	let platformSkipped = 0;
 	try {
 		await applyMigrations(injection.services.postgresUrl, {
 			migrationsDir,
 			onMigration: (event) => {
+				if (event.action === "applied") platformApplied += 1;
+				else platformSkipped += 1;
 				input.ctx.logger.info({
 					migration: event.version,
 					action: event.action,
@@ -7113,7 +7258,17 @@ var startDevSession = async (input) => {
 				}, `stackbone_platform schema: ${event.action} ${String(event.version).padStart(4, "0")} in ${event.durationMs}ms`);
 			}
 		});
+		onStage({
+			stage: "platform-migrations",
+			status: "success",
+			detail: platformApplied > 0 ? `${platformApplied} applied, ${platformSkipped} skipped` : `${platformSkipped} already applied`
+		});
 	} catch (err) {
+		onStage({
+			stage: "platform-migrations",
+			status: "fail",
+			detail: err instanceof Error ? err.message : String(err)
+		});
 		await composeDown(compose);
 		throw new StackboneCliError({
 			code: "generic",
@@ -7122,39 +7277,67 @@ var startDevSession = async (input) => {
 			cause: err
 		});
 	}
+	onStage({
+		stage: "creator-migrations",
+		status: "start"
+	});
 	try {
 		await runPreBootMigrate({
 			agentRoot: input.projectRoot,
 			connectionString: injection.services.postgresUrl,
 			logger: input.ctx.logger
 		});
+		onStage({
+			stage: "creator-migrations",
+			status: "success"
+		});
 	} catch (err) {
+		onStage({
+			stage: "creator-migrations",
+			status: "fail",
+			detail: err instanceof Error ? err.message : String(err)
+		});
 		await composeDown(compose);
 		throw err;
 	}
 	const preBootRagManifest = readWatcherManifest(input.projectRoot);
-	if (preBootRagManifest !== null) try {
-		await runPreBootRag({
-			agentRoot: input.projectRoot,
-			migrationsDir: preBootRagManifest.migrations,
-			autoMigrate: preBootRagManifest.ragAutoMigrate,
-			logger: input.ctx.logger,
-			addRag,
-			runMigrateUp: () => migrateUp({
-				connectionString: injection.services.postgresUrl,
-				migrationsDir: preBootRagManifest.migrations,
-				onMigration: (event) => {
-					input.ctx.logger.info({
-						migration: event.tag,
-						action: event.action,
-						durationMs: event.durationMs
-					}, `RAG schema: ${event.action} ${event.tag}`);
-				}
-			})
+	if (preBootRagManifest !== null) {
+		onStage({
+			stage: "rag-migrations",
+			status: "start"
 		});
-	} catch (err) {
-		await composeDown(compose);
-		throw err;
+		try {
+			await runPreBootRag({
+				agentRoot: input.projectRoot,
+				migrationsDir: preBootRagManifest.migrations,
+				autoMigrate: preBootRagManifest.ragAutoMigrate,
+				logger: input.ctx.logger,
+				addRag,
+				runMigrateUp: () => migrateUp({
+					connectionString: injection.services.postgresUrl,
+					migrationsDir: preBootRagManifest.migrations,
+					onMigration: (event) => {
+						input.ctx.logger.info({
+							migration: event.tag,
+							action: event.action,
+							durationMs: event.durationMs
+						}, `RAG schema: ${event.action} ${event.tag}`);
+					}
+				})
+			});
+			onStage({
+				stage: "rag-migrations",
+				status: "success"
+			});
+		} catch (err) {
+			onStage({
+				stage: "rag-migrations",
+				status: "fail",
+				detail: err instanceof Error ? err.message : String(err)
+			});
+			await composeDown(compose);
+			throw err;
+		}
 	}
 	const invocations = createInvocationsStore({ connectionString: injection.services.postgresUrl });
 	const approvals = createApprovalsStore({
@@ -7199,6 +7382,10 @@ var startDevSession = async (input) => {
 		});
 	};
 	try {
+		onStage({
+			stage: "agent",
+			status: "start"
+		});
 		agent = startAgentProcess({
 			cwd: input.projectRoot,
 			env: input.ctx.env,
@@ -7207,6 +7394,11 @@ var startDevSession = async (input) => {
 			injection,
 			agentConfig: agentConfigEnv
 		});
+		onStage({
+			stage: "agent",
+			status: "success",
+			detail: `http://127.0.0.1:${agentPort}`
+		});
 		configWatcher = await startAgentConfigWatcher({
 			connectionString: injection.services.postgresUrl,
 			logger: input.ctx.logger,
@@ -7261,25 +7453,63 @@ var startDevSession = async (input) => {
 			envValue: input.ctx.env["STACKBONE_CORS_ALLOW_ORIGINS"],
 			fileValue: fileConfig?.studio?.corsOrigins
 		});
-		emulator = await startEmulatorServer({
-			port: input.emulatorPort,
-			bus,
-			invocations,
-			approvals,
-			injection,
-			agent: input.agent,
-			cors: corsAllowlist,
-			listen: input.listen
+		onStage({
+			stage: "emulator",
+			status: "start"
 		});
+		try {
+			emulator = await startEmulatorServer({
+				port: input.emulatorPort,
+				bus,
+				invocations,
+				approvals,
+				injection,
+				agent: input.agent,
+				cors: corsAllowlist,
+				listen: input.listen
+			});
+			onStage({
+				stage: "emulator",
+				status: "success",
+				detail: emulator.url
+			});
+		} catch (err) {
+			onStage({
+				stage: "emulator",
+				status: "fail",
+				detail: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		}
 		if (input.listen) input.ctx.logger.warn({
 			boundTo: "0.0.0.0",
 			port: input.emulatorPort
 		}, `WARNING: emulator bound to 0.0.0.0:${input.emulatorPort} — reachable from your LAN`);
-		if (input.tunnel) tunnel = await openDevTunnel({
-			targetUrl: emulator.url,
-			ctx: input.ctx,
-			projectRoot: input.projectRoot
-		});
+		if (input.tunnel) {
+			onStage({
+				stage: "tunnel",
+				status: "start"
+			});
+			try {
+				tunnel = await openDevTunnel({
+					targetUrl: emulator.url,
+					ctx: input.ctx,
+					projectRoot: input.projectRoot
+				});
+				onStage({
+					stage: "tunnel",
+					status: "success",
+					detail: tunnel.publicUrl
+				});
+			} catch (err) {
+				onStage({
+					stage: "tunnel",
+					status: "fail",
+					detail: err instanceof Error ? err.message : String(err)
+				});
+				throw err;
+			}
+		}
 		return {
 			emulatorUrl: emulator.url,
 			agentUrl: `http://127.0.0.1:${agentPort}`,
@@ -7299,6 +7529,24 @@ var startDevSession = async (input) => {
 	}
 };
 //#endregion
+//#region src/services/local-dev-installations.service.ts
+var parse$1 = (raw, context) => {
+	const parsed = localDevInstallationResponseSchema.safeParse(raw);
+	if (!parsed.success) throw new StackboneCliError({
+		code: "generic",
+		message: `Unexpected response shape from ${context}`,
+		cause: parsed.error
+	});
+	return parsed.data;
+};
+var upsertLocalDevInstallation = async (ctx, body) => {
+	return parse$1(await ctx.http.post("/api/v1/installations/local-dev", body), "POST /api/v1/installations/local-dev");
+};
+var patchLocalDevInstallation = async (ctx, id, body) => {
+	const path = `/api/v1/installations/local-dev/${encodeURIComponent(id)}`;
+	return parse$1(await ctx.http.patch(path, body), `PATCH ${path}`);
+};
+//#endregion
 //#region src/commands/dev/print-contract.ts
 var defaultWriteStdout = (chunk) => {
 	process.stdout.write(chunk);
@@ -7317,6 +7565,60 @@ var printContract = (deps = {}) => {
 };
 //#endregion
 //#region src/commands/dev/dev.command.ts
+var STAGE_LABELS = {
+	docker: {
+		start: "Starting docker services",
+		done: "Docker services ready"
+	},
+	"platform-migrations": {
+		start: "Applying platform migrations",
+		done: "Platform migrations applied"
+	},
+	"creator-migrations": {
+		start: "Applying agent migrations",
+		done: "Agent migrations applied"
+	},
+	"rag-migrations": {
+		start: "Preparing RAG schema",
+		done: "RAG schema ready"
+	},
+	agent: {
+		start: "Starting agent process",
+		done: "Agent process ready"
+	},
+	emulator: {
+		start: "Starting emulator",
+		done: "Emulator listening"
+	},
+	tunnel: {
+		start: "Opening tunnel",
+		done: "Tunnel ready"
+	}
+};
+/**
+* Wires `onStage` events from the orchestrator to a single rolling clack
+* spinner. Only one stage is in flight at a time (the orchestrator is
+* sequential), so we keep one handle and recycle it across stages.
+*/
+var createStageRenderer = () => {
+	let active = null;
+	let activeStage = null;
+	return (event) => {
+		const label = STAGE_LABELS[event.stage];
+		if (event.status === "start") {
+			active = spinner();
+			activeStage = event.stage;
+			active.start(label.start);
+			return;
+		}
+		if (active === null || activeStage !== event.stage) return;
+		const detail = event.detail ? ` (${event.detail})` : "";
+		if (event.status === "success") active.stop(`${label.done}${detail}`);
+		else active.error(`${label.start} failed${detail}`);
+		active = null;
+		activeStage = null;
+	};
+};
 var buildHandler$2 = (ctx, flags) => protectedCommand(async (innerCtx) => {
 	const config = await innerCtx.projectConfig.read();
 	if (!config) throw new StackboneCliError({
@@ -7332,6 +7634,7 @@ var buildHandler$2 = (ctx, flags) => protectedCommand(async (innerCtx) => {
 		message: "The agent linked to this directory no longer exists in the workspace",
 		suggestion: "Run `stackbone link --force --agent <slug>` to re-link to a different agent"
 	});
+	const renderStage = innerCtx.flags.json ? null : createStageRenderer();
 	const session = await startDevSession({
 		ctx: innerCtx,
 		projectRoot,
@@ -7340,13 +7643,37 @@ var buildHandler$2 = (ctx, flags) => protectedCommand(async (innerCtx) => {
 			name: agent.name
 		},
 		emulatorPort: flags.port,
-		tunnel: flags.tunnel,
-		listen: flags.listen
-	});
-	emit(innerCtx.flags, () => "", {
+		tunnel: true,
+		listen: flags.listen,
+		verbose: flags.verbose,
+		...renderStage ? { onStage: renderStage } : {}
+	});
+	const activeOrg = await getActiveOrganization(innerCtx);
+	let localDevId = config.localDevInstallationId;
+	let installationOrgSlug = config.organizationSlug ?? activeOrg.slug;
+	if (!localDevId) {
+		const upserted = await upsertLocalDevInstallation(innerCtx, {
+			creatorOrganizationSlug: activeOrg.slug,
+			agentTemplateSlug: agent.slug
+		});
+		localDevId = upserted.id;
+		installationOrgSlug = upserted.organizationSlug;
+	}
+	if (session.publicUrl) {
+		const patched = await patchLocalDevInstallation(innerCtx, localDevId, { localTunnelUrl: session.publicUrl }).catch((err) => {
+			innerCtx.logger.warn({ err: err.message }, "failed to PATCH local-dev tunnel URL (continuing)");
+			return null;
+		});
+		if (patched) installationOrgSlug = patched.organizationSlug;
+	}
+	const studioBaseUrl = innerCtx.apiUrl.includes("localhost") ? "http://localhost:4200/app" : "https://app.stackbone.ai/app";
+	const deeplink = session.publicUrl ? `${studioBaseUrl}/${installationOrgSlug}/installations/${localDevId}?stackbone-dev=${encodeURIComponent(session.publicUrl)}` : null;
+	if (innerCtx.flags.json) emit(innerCtx.flags, () => "", {
 		emulator_url: session.emulatorUrl,
 		agent_url: session.agentUrl,
 		public_url: session.publicUrl,
+		deeplink,
+		local_dev_installation_id: localDevId,
 		services: {
 			postgres_url: session.injection.services.postgresUrl,
 			queue_url: session.injection.services.queueUrl,
@@ -7354,18 +7681,29 @@ var buildHandler$2 = (ctx, flags) => protectedCommand(async (innerCtx) => {
 			s3_bucket: session.injection.services.s3Bucket
 		}
 	});
-	if (!innerCtx.flags.json) {
-		log.step(`Agent:     ${session.agentUrl}`);
-		console.log(`\n${formatBootBanner({
+	else {
+		const inlineLines = formatBootBanner({
 			tunnelUrl: session.publicUrl,
 			localUrl: session.emulatorUrl,
+			deeplink,
 			contractVersion: 10,
-			capabilityCount: EMULATOR_CAPABILITIES.length
-		})}\n`);
-		log.step("Press Ctrl-C to stop.");
+			capabilityCount: EMULATOR_CAPABILITIES.length,
+			agentName: agent.name,
+			colors: process.stdout.isTTY === true
+		}).split("\n").slice(1, -1).map((line) => line.replace(/^│ {2}/, "").replace(/ {2}│$/, "").trimEnd());
+		while (inlineLines.length > 0 && inlineLines[0] === "") inlineLines.shift();
+		while (inlineLines.length > 0 && inlineLines[inlineLines.length - 1] === "") inlineLines.pop();
+		log.message(inlineLines.join("\n"));
+		log.step("Press Ctrl-C to stop");
 	}
 	const sigintHandler = () => {
-		session.stop();
+		(async () => {
+			if (localDevId) await patchLocalDevInstallation(innerCtx, localDevId, { localTunnelUrl: null }).catch((err) => {
+				innerCtx.logger.debug({ err: err.message }, "failed to null local-dev tunnel URL on exit (safety net will catch up)");
+				return null;
+			});
+			await session.stop();
+		})();
 	};
 	process.once("SIGINT", sigintHandler);
 	process.once("SIGTERM", sigintHandler);
@@ -7383,12 +7721,6 @@ var createDevCommand = (ctx) => defineCommand({
 			description: `Emulator port. Defaults to ${DEFAULT_EMULATOR_PORT}.`,
 			default: String(DEFAULT_EMULATOR_PORT)
 		},
-		tunnel: {
-			type: "boolean",
-			description: "Open a public tunnel to the emulator (default: on).",
-			negativeDescription: "Skip the public tunnel and serve the emulator only on localhost.",
-			default: true
-		},
 		listen: {
 			type: "boolean",
 			description: "Bind the HTTP server to 0.0.0.0 (reachable from your LAN). Default binds to 127.0.0.1 only.",
@@ -7398,6 +7730,11 @@ var createDevCommand = (ctx) => defineCommand({
 			type: "boolean",
 			description: "Print the JSON contract this CLI advertises (the same payload the emulator serves at /api/contract) and exit without booting the dev session.",
 			default: false
+		},
+		verbose: {
+			type: "boolean",
+			description: "Stream every log line and docker compose output. Default UI uses per-stage spinners; --verbose switches back to the raw firehose.",
+			default: false
 		}
 	},
 	run: ({ args }) => safeRun(ctx.flags, async (a) => {
@@ -7413,8 +7750,8 @@ var createDevCommand = (ctx) => defineCommand({
 		});
 		await buildHandler$2(ctx, {
 			port,
-			tunnel: Boolean(a.tunnel),
-			listen: Boolean(a.listen)
+			listen: Boolean(a.listen),
+			verbose: Boolean(a.verbose)
 		});
 	})(args)
 });
@@ -7449,10 +7786,6 @@ several exploratory calls.
 - \`-y, --yes\`
   Skip every confirmation prompt. Required in CI / non-TTY contexts.
 
-- \`--no-auto-login\` (or \`STACKBONE_AUTO_LOGIN=0\`)
-  When a protected command finds no valid session, fail fast with exit
-  code 2 instead of triggering the device-code flow inline.
-
 ## Exit codes
 
 - \`0\` ok
@@ -7745,7 +8078,6 @@ Branch on these instead of parsing stack traces.
 
 - \`STACKBONE_JSON=1\` — same as \`--json\`
 - \`STACKBONE_API_URL\` — same as \`--api-url <url>\`
-- \`STACKBONE_AUTO_LOGIN=0\` — same as \`--no-auto-login\`
 - \`STACKBONE_LOG_LEVEL\` — \`debug\`, \`info\`, \`warn\`, \`error\` (logger goes
   to stderr, never pollutes the JSON payload on stdout)
 
@@ -7890,12 +8222,15 @@ var writeTemplateFiles = async (files, input) => {
 var writeAgentManifest = async (agentName, input) => {
 	await writeFileSafe(join(input.root, "agent.yaml"), renderAgentYaml({ name: agentName }), input.force);
 };
-var writeProjectConfig = async (ctx, agent, input) => {
+var writeProjectConfig = async (ctx, agent, input, extras = {}) => {
 	const config = {
 		schemaVersion: 1,
 		organizationId: agent.organizationId,
 		agentId: agent.id,
-		controlPlaneUrl: ctx.apiUrl
+		controlPlaneUrl: ctx.apiUrl,
+		...extras.localDevInstallationId !== void 0 ? { localDevInstallationId: extras.localDevInstallationId } : {},
+		...extras.organizationSlug !== void 0 ? { organizationSlug: extras.organizationSlug } : {},
+		...extras.agentSlug !== void 0 ? { agentSlug: extras.agentSlug } : {}
 	};
 	await mkdir(join(input.root, ".stackbone"), { recursive: true });
 	await writeFile(join(input.root, ".stackbone", "project.json"), JSON.stringify(config, null, 2));
@@ -8229,7 +8564,7 @@ var resolveInputs = async (ctx, flags, namePositional) => {
 		targetDir
 	};
 };
-var writeProject = async (ctx, resolved, agent, force) => {
+var writeProject = async (ctx, resolved, agent, force, localDev) => {
 	const writeInput = {
 		root: resolved.targetDir,
 		force
@@ -8241,7 +8576,11 @@ var writeProject = async (ctx, resolved, agent, force) => {
 	});
 	await writeTemplateFiles(templateFiles, writeInput);
 	await writeAgentManifest(resolved.agentName, writeInput);
-	const projectConfig = await writeProjectConfig(ctx, agent, writeInput);
+	const projectConfig = await writeProjectConfig(ctx, agent, writeInput, {
+		localDevInstallationId: localDev.id,
+		organizationSlug: localDev.organizationSlug,
+		agentSlug: localDev.agentSlug
+	});
 	await ensureGitignore(resolved.targetDir);
 	const skillFiles = await writeSkillFiles(ctx, agent, projectConfig, writeInput);
 	return { filesWritten: [
@@ -8264,13 +8603,22 @@ var buildHandler$1 = (ctx, args) => protectedCommand(async (innerCtx) => {
 	const resolved = await resolveInputs(innerCtx, flags, args.name);
 	await ensureEmptyOrForce(resolved.targetDir, flags.force);
 	if (!innerCtx.flags.json) log.step(`Creating "${resolved.agentName}" (template: ${resolved.templateId})`);
+	const activeOrg = await getActiveOrganization(innerCtx);
 	const agent = await createAgent(innerCtx, {
-		organizationSlug: (await getActiveOrganization(innerCtx)).slug,
+		organizationSlug: activeOrg.slug,
 		name: resolved.agentName,
 		...resolved.agentSlug !== void 0 ? { slug: resolved.agentSlug } : {},
 		...resolved.description !== void 0 ? { description: resolved.description } : {}
 	});
-	const { filesWritten } = await writeProject(innerCtx, resolved, agent, flags.force);
+	const localDev = await upsertLocalDevInstallation(innerCtx, {
+		creatorOrganizationSlug: activeOrg.slug,
+		agentTemplateSlug: agent.slug
+	});
+	const { filesWritten } = await writeProject(innerCtx, resolved, agent, flags.force, {
+		id: localDev.id,
+		organizationSlug: localDev.organizationSlug,
+		agentSlug: localDev.agentSlug
+	});
 	emit(innerCtx.flags, () => "", {
 		agent: {
 			id: agent.id,
@@ -8278,6 +8626,10 @@ var buildHandler$1 = (ctx, args) => protectedCommand(async (innerCtx) => {
 			name: agent.name
 		},
 		organization_id: agent.organizationId,
+		local_dev_installation: {
+			id: localDev.id,
+			organization_slug: localDev.organizationSlug
+		},
 		target_dir: resolved.targetDir,
 		template: resolved.templateId,
 		files_written: filesWritten
@@ -8366,11 +8718,20 @@ var buildHandler = (ctx, args) => protectedCommand(async (innerCtx) => {
 		}
 		chosenSlug = value;
 	}
-	const agent = await getAgentByOwnerAndSlug(innerCtx, (await getActiveOrganization(innerCtx)).slug, chosenSlug);
+	const activeOrg = await getActiveOrganization(innerCtx);
+	const agent = await getAgentByOwnerAndSlug(innerCtx, activeOrg.slug, chosenSlug);
 	if (!innerCtx.flags.json) log.step(`Linking ${targetDir} to ${agent.slug}`);
+	const localDev = await upsertLocalDevInstallation(innerCtx, {
+		creatorOrganizationSlug: activeOrg.slug,
+		agentTemplateSlug: agent.slug
+	});
 	const projectConfig = await writeProjectConfig(innerCtx, agent, {
 		root: targetDir,
 		force: true
+	}, {
+		localDevInstallationId: localDev.id,
+		organizationSlug: localDev.organizationSlug,
+		agentSlug: localDev.agentSlug
 	});
 	await ensureGitignore(targetDir);
 	const skillFiles = await writeSkillFiles(innerCtx, agent, projectConfig, {
@@ -8384,6 +8745,10 @@ var buildHandler = (ctx, args) => protectedCommand(async (innerCtx) => {
 			name: agent.name
 		},
 		organization_id: agent.organizationId,
+		local_dev_installation: {
+			id: localDev.id,
+			organization_slug: localDev.organizationSlug
+		},
 		target_dir: targetDir,
 		files_written: [
 			".stackbone/project.json",
@@ -8612,11 +8977,6 @@ var buildRootCommand = async () => {
 			"api-url": {
 				type: "string",
 				description: "Override the control plane URL."
-			},
-			"no-auto-login": {
-				type: "boolean",
-				description: "Refuse to start the device-code flow when no session exists.",
-				default: false
 			}
 		},
 		subCommands: {

package/migrations/0009_rename_runs_partial_index.sql

@@ -0,0 +1,22 @@
+-- 0004_rename_runs_partial_index.sql — clarify semantics of the is_playground partial index.
+-- ADR: docs/adr/2026-05-14-playground-runs-bill-like-real-invocations.md.
+--
+-- Migration 0003 created the partial index `runs_billable_workspace_started_idx`
+-- on `stackbone_platform.runs (workspace_id, started_at DESC NULLS LAST)
+-- WHERE is_playground = false`. Its name and accompanying comments framed the
+-- predicate as the "billable" set — that framing is wrong.
+--
+-- Playground runs DO bill: invoking from Studio consumes real LLM tokens, real
+-- DB queries and real compute, and the creator's organization is charged for
+-- it like any other invocation (otherwise a malicious client could mark all
+-- production traffic with `X-Stackbone-Playground: 1` and dodge billing). The
+-- predicate `WHERE is_playground = false` actually identifies the rows that
+-- count toward Trust Layer / public marketplace aggregations (p50 latency,
+-- success rate, median cost) — a slow demo run from Studio must not lower
+-- the public stats of an `agent_template`.
+--
+-- This migration renames the index so the next reader gets the semantics
+-- right. The index definition (table, columns, predicate) is unchanged.
+
+ALTER INDEX IF EXISTS stackbone_platform.runs_billable_workspace_started_idx
+  RENAME TO runs_public_metrics_workspace_started_idx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbone/cli",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.3",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {