@keystrokehq/cli 0.0.1

package/dist/projects-Cjb7sovS.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/projects/projects.command.ts
+function createProjectsCommand() {
+	return createTypedCommand({
+		name: "projects",
+		description: "List tracked Keystroke projects",
+		schema: JsonOptionSchema,
+		optionsConfig: { ...JSON_OPTION_CONFIG },
+		loadHandler: async () => (await import("./list.handler-CZ6G2x_G.mjs")).handleProjectsList,
+		subcommands: [createTypedCommand({
+			name: "list",
+			description: "List all tracked Keystroke projects",
+			schema: JsonOptionSchema,
+			optionsConfig: { ...JSON_OPTION_CONFIG },
+			loadHandler: async () => (await import("./list.handler-CZ6G2x_G.mjs")).handleProjectsList
+		}), createTypedCommand({
+			name: "clear-cache",
+			description: "Clear the stored projects cache (projects.json)",
+			schema: z.object({}),
+			optionsConfig: {},
+			loadHandler: async () => (await import("./clear-cache.handler-B9tqSoSM.mjs")).handleProjectsClearCache
+		})]
+	});
+}
+//#endregion
+export { createProjectsCommand };

package/dist/read-credential-keys-77a91T8M-KA0Iw0Z1.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+//#region ../../packages/workflow-builder/dist/read-credential-keys-77a91T8M.mjs
+function readCredentialKeysFromSchemaObject(schema) {
+	const properties = schema.properties;
+	return typeof properties === "object" && properties !== null && !Array.isArray(properties) ? Object.keys(properties).sort() : [];
+}
+//#endregion
+export { readCredentialKeysFromSchemaObject as t };

package/dist/register.handler-BPCdor1_.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, l as AUTH_HINT, m as isNetworkError, t as ui } from "./keystroke.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+//#region src/commands/integrations/register.handler.ts
+function exitWithError(ctx, message, opts) {
+	if (ctx.jsonMode) {
+		writeJson({
+			error: message,
+			...opts?.code ? { code: opts.code } : {},
+			...opts?.hint ? { hint: opts.hint } : {}
+		});
+		throwReportedCliExit(message);
+	}
+	ui.error(message);
+	if (opts?.hint) ui.hint(opts.hint);
+	throwReportedCliExit(message);
+}
+/**
+* Handle `keystroke integrations register <integrationId>`.
+*
+* Upserts a `workspace_provider_apps` row by calling
+* `POST /api/v1/admin/workspace-provider-apps` on the server.
+*/
+async function handleIntegrationsRegister(options, ctx) {
+	const integrationId = options.integrationId?.trim();
+	const { baseUrl, apiKey } = ctx;
+	if (!baseUrl || !apiKey) exitWithError(ctx, "Not authenticated.", {
+		code: "AUTH_ERROR",
+		hint: AUTH_HINT
+	});
+	if (!integrationId) exitWithError(ctx, "Usage: keystroke integrations register <integrationId>", {
+		code: "USAGE_ERROR",
+		hint: "Example: keystroke integrations register acmeCrm"
+	});
+	if (!options.clientAppCredentialSetId) exitWithError(ctx, "Missing --client-app <credentialSetId>. This is the internal credential set that holds clientId + clientSecret.", {
+		code: "USAGE_ERROR",
+		hint: `Example: keystroke integrations register ${integrationId} --client-app acmeClientApp`
+	});
+	const displayName = options.displayName ?? integrationId;
+	if (!ctx.jsonMode) ui.text(`Registering workspace provider app "${integrationId}"...`);
+	try {
+		const response = await fetch(`${baseUrl}/api/v1/admin/workspace-provider-apps`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				credentialSetId: integrationId,
+				clientAppCredentialSetId: options.clientAppCredentialSetId,
+				displayName
+			})
+		});
+		if (!response.ok) {
+			if (response.status === 401) exitWithError(ctx, "Not authenticated.", {
+				code: "AUTH_ERROR",
+				hint: AUTH_HINT
+			});
+			exitWithError(ctx, `Failed to register workspace integration: ${(await response.json().catch(() => ({}))).error ?? `Server returned HTTP ${response.status}`}`, { code: "REGISTER_FAILED" });
+		}
+		const data = await response.json();
+		if (ctx.jsonMode) {
+			writeJson({
+				status: data.created ? "created" : "updated",
+				workspaceProviderApp: data.workspaceProviderApp
+			});
+			return;
+		}
+		if (data.created) ui.success(`Registered workspace provider app for "${integrationId}".`);
+		else ui.success(`Updated workspace provider app for "${integrationId}".`);
+		ui.hint("Workspace-authored OAuth connect flows are not available yet. This registration stores the client app metadata for future support.");
+	} catch (error) {
+		if (error instanceof Error && error.name === "CliExitError") throw error;
+		if (isNetworkError(error)) exitWithError(ctx, `Could not reach the Keystroke server to register "${integrationId}".`, {
+			code: "NETWORK_ERROR",
+			hint: `Check that your local services are running and that the CLI is pointed at ${baseUrl}.`
+		});
+		exitWithError(ctx, `Failed to register workspace integration "${integrationId}".`, {
+			code: "REGISTER_FAILED",
+			hint: toErrorMessage(error)
+		});
+	}
+}
+//#endregion
+export { handleIntegrationsRegister };

package/dist/requirements.handler-DPXdSks3.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+import { o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+import { a as readManifestsFromOutDir } from "./dist-BkJUoBiG.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { n as getProcessEnv } from "./env-91KwMKov.mjs";
+import { t as readCredentialEnvMap } from "./credential-env-map-CI8yWHVy.mjs";
+import { a as loadProjectDotenvFile, c as getTerminalContentWidth, o as manifestGroupKey, s as normalizeManifestScopeToServer, t as buildCredentialWorkflowConsumersByGroup, u as truncateWithEllipsis } from "./list-enrichment-y-cwizLr.mjs";
+import { t as groupCredentialRequirements } from "./credentials-OfVHOtG3.mjs";
+//#region src/commands/credentials/requirements/requirements-display.ts
+function dimLabel(label, width = 10) {
+	return style(label.padEnd(width), ANSI.dim);
+}
+function presenceIcon(p) {
+	switch (p) {
+		case "set": return style("✓", ANSI.green);
+		case "missing": return style("✗", ANSI.red);
+		default: return style("?", ANSI.dim);
+	}
+}
+function renderRequirementsBlocks(rows, serverChecked) {
+	const w = getTerminalContentWidth();
+	const indent = "  ";
+	let first = true;
+	let totalKeys = 0;
+	let serverMissing = 0;
+	let localSet = 0;
+	for (const r of rows) {
+		if (!first) ui.br();
+		first = false;
+		ui.text(style(r.credentialSetId, ANSI.bold));
+		ui.text(`${indent}${dimLabel("Scope")}${r.scope}`);
+		const wfDisplay = truncateWithEllipsis(r.workflows.length === 0 ? "—" : r.workflows.join(", "), Math.max(12, w - 14));
+		ui.text(`${indent}${dimLabel("Workflows")}${wfDisplay}`);
+		ui.text(`${indent}${dimLabel("Keys")}`);
+		for (const k of r.keys) {
+			totalKeys++;
+			if (k.server === "missing") serverMissing++;
+			if (k.local === "set") localSet++;
+			const envLabel = k.envVar === `KEYSTROKE_${k.key}` ? k.envVar : `${k.envVar} (${k.key})`;
+			if (serverChecked) ui.text(`${indent}  ${presenceIcon(k.server)} server  ${presenceIcon(k.local)} local  ${envLabel}`);
+			else ui.text(`${indent}  ${presenceIcon(k.local)} ${envLabel}`);
+		}
+	}
+	if (totalKeys > 0) {
+		ui.br();
+		if (serverChecked) if (serverMissing > 0) ui.warn(`Server: ${serverMissing} of ${totalKeys} key(s) missing.`);
+		else ui.success(`Server: all ${totalKeys} key(s) configured.`);
+		const localMissing = totalKeys - localSet;
+		if (localMissing > 0) ui.warn(`Local: ${localMissing} of ${totalKeys} env var(s) missing.`);
+		else ui.success(`Local: all ${totalKeys} env var(s) set.`);
+	}
+}
+//#endregion
+//#region src/commands/credentials/requirements/resolve-server-keys.ts
+/**
+* Returns true for HTTP responses that mean "credential set not configured"
+* (404 = not found, 422 = missing keys). Other errors (network, 500) should propagate.
+*/
+function isNotConfiguredError(error) {
+	if (typeof error === "object" && error !== null && "response" in error && typeof error.response?.status === "number") {
+		const status = error.response.status;
+		return status === 404 || status === 422;
+	}
+	return false;
+}
+/**
+* Tries `credentials.resolve` for each group. Returns per-key server status.
+* On network/auth errors returns null (server unreachable — caller should degrade gracefully).
+*/
+async function resolveServerKeyStatuses(client, groups) {
+	const results = [];
+	for (const group of groups) {
+		const scope = group.scope === "organization" || group.scope === "project" ? group.scope : void 0;
+		try {
+			const response = await client.credentials.resolve({
+				credentialSetId: group.credentialSetId,
+				keys: group.keys,
+				...scope && { scope }
+			});
+			const configuredKeys = new Set(Object.keys(response.credentials ?? {}));
+			const keys = /* @__PURE__ */ new Map();
+			for (const k of group.keys) keys.set(k, configuredKeys.has(k) ? "set" : "missing");
+			results.push({
+				credentialSetId: group.credentialSetId,
+				scope: group.scope,
+				keys
+			});
+		} catch (err) {
+			if (isNotConfiguredError(err)) {
+				const keys = /* @__PURE__ */ new Map();
+				for (const k of group.keys) keys.set(k, "missing");
+				results.push({
+					credentialSetId: group.credentialSetId,
+					scope: group.scope,
+					keys
+				});
+			} else return null;
+		}
+	}
+	return results;
+}
+//#endregion
+//#region src/commands/credentials/requirements/requirements.handler.ts
+function resolveEnvVarName(credentialSetId, key, envMap) {
+	return envMap?.[credentialSetId]?.[key] ?? `KEYSTROKE_${key}`;
+}
+function serverPresenceForKey(credentialSetId, scope, key, serverResults) {
+	if (!serverResults) return "unknown";
+	return serverResults.find((r) => r.credentialSetId === credentialSetId && r.scope === scope)?.keys.get(key) ?? "unknown";
+}
+async function handleCredentialsRequirements(options, ctx) {
+	const workflowsDir = await requireWorkflowsDir(options.path);
+	const manifests = await readManifestsFromOutDir(workflowsDir);
+	if (manifests.length === 0) {
+		ui.warn("No built manifests found. Run `keystroke workflows build` first.");
+		return;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const requirements = [];
+	for (const { manifest } of manifests) {
+		const groups = groupCredentialRequirements(manifest);
+		for (const group of groups) {
+			const key = `${group.credentialSetId}:${group.scope ?? "__default__"}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				requirements.push({
+					credentialSetId: group.credentialSetId,
+					scope: group.scope,
+					keys: group.keys
+				});
+			}
+		}
+	}
+	if (requirements.length === 0) {
+		ui.text("No credential requirements in workflow manifests.");
+		return;
+	}
+	requirements.sort((a, b) => {
+		const id = a.credentialSetId.localeCompare(b.credentialSetId);
+		if (id !== 0) return id;
+		return (a.scope ?? "").localeCompare(b.scope ?? "");
+	});
+	const credentialEnvMap = await readCredentialEnvMap(workflowsDir);
+	const projectDotenv = await loadProjectDotenvFile(workflowsDir);
+	const mergedEnv = {
+		...getProcessEnv(),
+		...projectDotenv
+	};
+	let serverResults = null;
+	if (ctx.client) {
+		serverResults = await resolveServerKeyStatuses(ctx.client, requirements);
+		if (!serverResults) ui.warn("Could not reach the server — showing local status only.");
+	}
+	const workflowConsumersByGroup = buildCredentialWorkflowConsumersByGroup(manifests);
+	function resolveKeyStatuses(credentialSetId, scope, keys) {
+		return keys.map((k) => {
+			const envVar = resolveEnvVarName(credentialSetId, k, credentialEnvMap);
+			const value = mergedEnv[envVar];
+			return {
+				key: k,
+				envVar,
+				local: value && value.trim().length > 0 ? "set" : "missing",
+				server: serverPresenceForKey(credentialSetId, scope, k, serverResults)
+			};
+		});
+	}
+	function workflowsForGroup(r) {
+		return workflowConsumersByGroup.get(manifestGroupKey({
+			credentialSetId: r.credentialSetId,
+			scope: r.scope,
+			keys: r.keys
+		})) ?? [];
+	}
+	if (ctx.jsonMode) {
+		writeJson(requirements.map((r) => ({
+			credentialSetId: r.credentialSetId,
+			scope: r.scope,
+			keys: resolveKeyStatuses(r.credentialSetId, r.scope, r.keys).map((ks) => ({
+				key: ks.key,
+				envVar: ks.envVar,
+				local: ks.local,
+				server: ks.server
+			})),
+			workflows: workflowsForGroup(r)
+		})));
+		return;
+	}
+	renderRequirementsBlocks(requirements.map((r) => ({
+		credentialSetId: r.credentialSetId,
+		scope: normalizeManifestScopeToServer(r.scope),
+		keys: resolveKeyStatuses(r.credentialSetId, r.scope, r.keys),
+		workflows: workflowsForGroup(r)
+	})), serverResults !== null);
+	ui.br();
+	if (!ctx.client) ui.hint("Not authenticated — run `keystroke auth` to also check server status.");
+	ui.hint("Set missing env vars, then run: keystroke credentials upload");
+}
+//#endregion
+export { handleCredentialsRequirements };

package/dist/resolve-project-DDJ29sCF.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { T as ProjectNotFoundError, t as ui } from "./keystroke.mjs";
+import { s as readStoredProjects } from "./dist-CUK7yBM0.mjs";
+import { n as findProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import path from "node:path";
+//#region src/lib/resolve-project.ts
+/**
+* Resolve the project root from an explicit `--path` flag or by
+* walking up from CWD looking for `keystroke.config.ts`.
+*
+* Returns `null` when no project is found.
+*/
+async function resolveWorkflowsDir(explicitPath) {
+	if (explicitPath) return path.resolve(explicitPath);
+	return findProjectRoot(process.cwd());
+}
+/**
+* Like `resolveWorkflowsDir` but throws a `ProjectNotFoundError`
+* when no project is found.
+*/
+async function requireWorkflowsDir(explicitPath) {
+	const dir = await resolveWorkflowsDir(explicitPath);
+	if (dir) return dir;
+	ui.warn("No keystroke.config.ts found in this directory or any parent directory.");
+	const stored = await readStoredProjects();
+	if (stored?.lastProject) {
+		ui.hint(`Last used project: ${stored.lastProject}`);
+		ui.hint(`  cd ${stored.lastProject}`);
+	}
+	ui.hint("Run `keystroke init` to initialize a project, or use --path.");
+	throw new ProjectNotFoundError("No keystroke.config.ts found");
+}
+//#endregion
+export { resolveWorkflowsDir as n, requireWorkflowsDir as t };

package/dist/rolldown-runtime-twds-ZHy-BWWzu8VG.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+//#region ../../packages/workflow-builder/dist/rolldown-runtime-twds-ZHy.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/run-polling-CAgFRdK3.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+//#region src/lib/run-polling.ts
+/**
+* run-polling.ts
+*
+* Shared utilities for polling workflow run completion status.
+* Used by `workflows try-deploy` polling and `workflows logs --follow`.
+*/
+const TERMINAL_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"expired"
+]);
+function sleep(durationMs) {
+	return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+//#endregion
+export { sleep as n, TERMINAL_STATUSES as t };

package/dist/runs-D9hNLb9A.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { i as writeJson, n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+import { z } from "zod";
+//#region src/commands/runs/inspect-display.ts
+function renderRunInspect(input) {
+	const { run, events, logs } = input;
+	ui.text(style(`  Run: ${run.id}`, `${ANSI.bold}${ANSI.cyan}`));
+	ui.text(`  Workflow: ${run.workflowName} (${run.authoredWorkflowId})`);
+	ui.text(`  Status: ${run.status}`);
+	ui.text(`  Deployment: ${run.deploymentId}`);
+	ui.text(`  Created: ${formatDate(run.createdAt)}`);
+	if (run.startedAt) ui.text(`  Started: ${formatDate(run.startedAt)}`);
+	if (run.completedAt) ui.text(`  Completed: ${formatDate(run.completedAt)}`);
+	ui.br();
+	ui.text(style("  Events", ANSI.bold));
+	const eventSummary = formatEventSummary(events);
+	ui.text(eventSummary || style("    (none)", ANSI.dim));
+	ui.br();
+	const pendingYields = formatPendingYields(events);
+	if (pendingYields) {
+		ui.text(style("  Pending Yields", ANSI.bold));
+		ui.text(pendingYields);
+		ui.br();
+	}
+	if (run.error) {
+		ui.text(style("  Error", ANSI.bold));
+		ui.text(`    ${formatUnknown(run.error)}`);
+		ui.br();
+	}
+	ui.text(style("  Recent Logs", ANSI.bold));
+	const logSummary = formatLogs(logs);
+	ui.text(logSummary || style("    (none)", ANSI.dim));
+}
+function renderAgentRunInspect(input) {
+	const { agentRun, events, childWorkflowRuns, latestSnapshot } = input;
+	ui.text(style(`  Agent Run: ${agentRun.id}`, `${ANSI.bold}${ANSI.cyan}`));
+	ui.text(`  Agent: ${agentRun.agentName}${agentRun.agentId ? ` (${agentRun.agentId})` : ""}`);
+	ui.text(`  Status: ${agentRun.status}`);
+	ui.text(`  Source: ${agentRun.source}`);
+	ui.text(`  Runtime: ${agentRun.runtime}`);
+	if (agentRun.workflowRunId) ui.text(`  Parent Workflow Run: ${agentRun.workflowRunId}`);
+	if (agentRun.correlationId) ui.text(`  Parent Correlation: ${agentRun.correlationId}`);
+	ui.text(`  Created: ${formatDate(agentRun.createdAt)}`);
+	if (agentRun.startedAt) ui.text(`  Started: ${formatDate(agentRun.startedAt)}`);
+	if (agentRun.completedAt) ui.text(`  Completed: ${formatDate(agentRun.completedAt)}`);
+	ui.br();
+	ui.text(style("  Pending Yields", ANSI.bold));
+	ui.text(formatAgentPendingYields(agentRun.yieldState) || style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Child Workflow Runs", ANSI.bold));
+	ui.text(formatChildWorkflowRuns(childWorkflowRuns) || style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Latest Snapshot", ANSI.bold));
+	ui.text(formatSnapshot(latestSnapshot) || style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Agent Events", ANSI.bold));
+	ui.text(formatAgentEvents(events) || style("    (none)", ANSI.dim));
+	if (agentRun.error) {
+		ui.br();
+		ui.text(style("  Error", ANSI.bold));
+		ui.text(`    ${formatUnknown(agentRun.error)}`);
+	}
+}
+function formatEventSummary(events) {
+	if (events.length === 0) return "";
+	const counts = /* @__PURE__ */ new Map();
+	for (const event of events) counts.set(event.eventType, (counts.get(event.eventType) ?? 0) + 1);
+	const summary = [...counts.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([type, count]) => `    ${type}: ${count}`).join("\n");
+	const latest = events[events.length - 1];
+	if (!latest) return summary;
+	return `${summary}\n\n    latest: ${latest.eventType} at ${formatDate(latest.createdAt)} (${latest.correlationId})`;
+}
+function formatPendingYields(events) {
+	const terminalChildCorrelations = new Set(events.filter((event) => event.eventType === "child_workflow_completed" || event.eventType === "child_workflow_failed").map((event) => event.correlationId));
+	const pending = events.filter((event) => isPendingYieldEvent(event, terminalChildCorrelations));
+	if (pending.length === 0) return "";
+	return pending.map((event) => {
+		const data = asRecord(event.eventData);
+		const kind = stringField(data, "kind") ?? stringField(data, "yieldKind") ?? "unknown";
+		const toolCallId = stringField(data, "toolCallId") ?? stringField(data, "tool_call_id");
+		const childRunId = stringField(data, "childRunId") ?? stringField(data, "child_run_id");
+		const parts = [`    - ${event.correlationId}`, `kind: ${kind}`];
+		if (toolCallId) parts.push(`tool_call: ${toolCallId}`);
+		if (childRunId) parts.push(`child_run: ${childRunId}`);
+		parts.push(`at: ${formatDate(event.createdAt)}`);
+		return parts.join(" | ");
+	}).join("\n");
+}
+function formatLogs(logs) {
+	if (logs.length === 0) return "";
+	return logs.map((log) => {
+		const correlation = log.correlationId ? ` <${log.correlationId}>` : "";
+		return `    ${formatDate(log.timestamp)} [${log.level}]${correlation} ${log.message}`;
+	}).join("\n");
+}
+function formatAgentPendingYields(yieldState) {
+	const pendingYield = asRecord(asRecord(yieldState).pendingYield);
+	if (Object.keys(pendingYield).length === 0) return "";
+	const kind = stringField(pendingYield, "kind") ?? "unknown";
+	const toolCallId = stringField(pendingYield, "toolCallId");
+	const childRunId = stringField(pendingYield, "childRunId");
+	const snapshotId = stringField(pendingYield, "snapshotId");
+	const hookToken = stringField(pendingYield, "hookToken");
+	const credSetId = stringField(pendingYield, "credSetId");
+	const yieldedAt = stringField(pendingYield, "yieldedAt");
+	const parts = [`    - kind: ${kind}`];
+	if (toolCallId) parts.push(`tool_call: ${toolCallId}`);
+	if (childRunId) parts.push(`child_run: ${childRunId}`);
+	if (snapshotId) parts.push(`snapshot: ${snapshotId}`);
+	if (hookToken) parts.push(`hook_token: ${hookToken}`);
+	if (credSetId) parts.push(`credential: ${credSetId}`);
+	if (yieldedAt) parts.push(`yielded_at: ${formatDate(yieldedAt)}`);
+	return parts.join(" | ");
+}
+function formatChildWorkflowRuns(childWorkflowRuns) {
+	if (childWorkflowRuns.length === 0) return "";
+	return childWorkflowRuns.map((run) => {
+		const parts = [
+			`    - ${run.id}`,
+			`${run.workflowName} (${run.authoredWorkflowId})`,
+			`status: ${run.status}`
+		];
+		if (run.parentToolCallId) parts.push(`tool_call: ${run.parentToolCallId}`);
+		if (run.parentIdempotencyKey) parts.push(`idempotency: ${run.parentIdempotencyKey}`);
+		return parts.join(" | ");
+	}).join("\n");
+}
+function formatSnapshot(snapshot) {
+	if (!snapshot) return "";
+	return `${[
+		`    ${snapshot.id}`,
+		`kind: ${snapshot.piSessionStateKind}`,
+		`reason: ${snapshot.triggerReason}`,
+		`version: ${snapshot.snapshotVersion}`,
+		`bytes: ${snapshot.byteSize}`,
+		`expires: ${formatDate(snapshot.expiresAt)}`
+	].join(" | ")}\n    replay: Path B conversation-log replay; native Pi restore is not active.`;
+}
+function formatAgentEvents(events) {
+	if (events.length === 0) return "";
+	return events.slice(-10).map((event) => {
+		const step = event.stepNumber === null ? "" : ` step:${event.stepNumber}`;
+		return `    ${formatDate(event.timestamp)}${step} ${event.eventType} (${event.id})`;
+	}).join("\n");
+}
+function isPendingYieldEvent(event, terminalChildCorrelations) {
+	if (event.eventType === "child_workflow_created") return !terminalChildCorrelations.has(event.correlationId);
+	const data = asRecord(event.eventData);
+	const status = stringField(data, "status");
+	const kind = stringField(data, "kind") ?? stringField(data, "yieldKind");
+	return status === "pending" && kind !== void 0;
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringField(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function formatUnknown(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+function formatDate(value) {
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? value : date.toISOString();
+}
+//#endregion
+//#region src/commands/runs/inspect.handler.ts
+async function handleRunsInspect(options, ctx) {
+	const client = requireClient(ctx);
+	try {
+		if (isAgentRunId(options.runId)) {
+			const inspect = await client.runs.getAgentRun(options.runId);
+			if (ctx.jsonMode) {
+				writeJson(inspect);
+				return;
+			}
+			renderAgentRunInspect(inspect);
+			return;
+		}
+		const [{ run }, { events }, logsResponse] = await Promise.all([
+			client.runs.getRun(options.runId),
+			client.runs.listEvents(options.runId),
+			options.logs > 0 ? client.runs.listLogs(options.runId, {
+				limit: options.logs,
+				offset: 0
+			}) : Promise.resolve({ logs: [] })
+		]);
+		if (ctx.jsonMode) {
+			writeJson({
+				run,
+				events,
+				logs: logsResponse.logs
+			});
+			return;
+		}
+		renderRunInspect({
+			run,
+			events,
+			logs: logsResponse.logs
+		});
+	} catch (error) {
+		const message = toErrorMessage(error);
+		throwReportedCliExit(`Failed to inspect run "${options.runId}": ${message}`, { cause: error });
+	}
+}
+function isAgentRunId(runId) {
+	return runId.startsWith("arun_");
+}
+//#endregion
+//#region src/commands/runs/runs.command.ts
+const RunsOptionsSchema = JsonOptionSchema;
+const RunsInspectOptionsSchema = JsonOptionSchema.extend({
+	runId: z.string().min(1),
+	logs: z.coerce.number().int().min(0).max(100).default(10)
+});
+const RUNS_OPTIONS_CONFIG = { ...JSON_OPTION_CONFIG };
+const RUNS_INSPECT_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	logs: {
+		flag: "--logs <n>",
+		description: "Number of recent logs to include (default: 10, use 0 to omit logs)"
+	}
+};
+function handleRunsHelp() {
+	ui.hint("Use `keystroke runs inspect <wrun_...>` to inspect a workflow run.");
+	ui.hint("Use `keystroke runs inspect <arun_...>` to inspect an agent run.");
+}
+function createRunsCommand() {
+	const cmd = createTypedCommand({
+		name: "runs",
+		description: "Inspect workflow and agent-tool runs",
+		schema: RunsOptionsSchema,
+		optionsConfig: RUNS_OPTIONS_CONFIG,
+		handler: handleRunsHelp,
+		subcommands: [createTypedCommand({
+			name: "inspect",
+			description: "Show status, events, and debugging links for a workflow or agent run",
+			schema: RunsInspectOptionsSchema,
+			optionsConfig: RUNS_INSPECT_OPTIONS_CONFIG,
+			argument: {
+				name: "runId",
+				description: "Workflow run id (wrun_...) or agent run id (arun_...)",
+				key: "runId"
+			},
+			handler: handleRunsInspect
+		})]
+	});
+	cmd.enablePositionalOptions();
+	cmd.passThroughOptions();
+	return cmd;
+}
+//#endregion
+export { createRunsCommand };