@keystrokehq/cli 0.1.27 → 0.1.29

package/dist/{dist-C1QOfWMM.mjs → dist-C0_71CpG.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { n as __require, t as __commonJSMin } from "./chunk-DiodbrVj.mjs";
-import { Bn as credentialInputSchema, Cr as toJSONSchema, Gn as normalizeCredentialList, Gt as PromptResponseSchema, Kt as PublicModelsResponseSchema, W as DEFAULT_CLOUD_PLATFORM_ORIGIN, Yt as ROUTE_MANIFEST_REL_PATH, cr as custom, dr as literal, gr as preprocess, lr as discriminatedUnion, mr as object, nr as _enum, or as array, pr as number, rr as _function, sr as boolean$1, tr as ZodType, vr as string, yr as union } from "./dist-BOhrc_Nv.mjs";
-import "./dist-Re6HHSqz.mjs";
+import { Dr as union, Er as string, Gt as PromptResponseSchema, Kt as PublicModelsResponseSchema, Qn as normalizeCredentialList, Sr as object, W as DEFAULT_CLOUD_PLATFORM_ORIGIN, Yt as ROUTE_MANIFEST_REL_PATH, _r as discriminatedUnion, dr as _function, gr as custom, hr as boolean$1, jr as toJSONSchema, lr as ZodType, mr as array, nr as parseStoredRouteManifest, qn as credentialInputSchema, rr as requiredDisplayTextSchema, ur as _enum, wr as preprocess, xr as number, yr as literal } from "./dist-COhdZicI.mjs";
+import "./dist-9VWONIo1.mjs";
 import "./chunk-BZUGFHVS-CPWRFwK8.mjs";
 import "./chunk-DLL7UR66-BUYgzxnR.mjs";
 import "./chunk-TN7HHBQW-CSB_R-XD.mjs";
@@ -24,6 +24,7 @@ import { readdir, stat } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
+import ts from "typescript";
 import { boolean, doublePrecision, index, integer, jsonb, pgEnum, pgTable, primaryKey, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
 import { index as index$1, integer as integer$1, primaryKey as primaryKey$1, real, sqliteTable, text as text$1, uniqueIndex as uniqueIndex$1 } from "drizzle-orm/sqlite-core";
 import { sql } from "drizzle-orm";
@@ -337,6 +338,1527 @@ function hasAppLayout(dir) {
 	const dist = join(dir, "dist");
 	return existsSync(join(src, "agents")) || existsSync(join(src, "skills")) || existsSync(join(src, "files")) || existsSync(join(dist, "agents")) || existsSync(join(dist, ".keystroke", "assets.mjs"));
 }
+//#endregion
+//#region ../../packages/workflow-canvas/dist/index.mjs
+/** Root segment for statements in the workflow `run` body. */
+const RUN_BODY_SEGMENT = "run-body";
+/** Join path segments for hashing / debugging. */
+function formatCallSitePath(path) {
+	return path.join(">");
+}
+/**
+* Deterministic id for a durable call site from its structural path. The Phase 5
+* build transform must compute the same path + id for each invocation.
+*/
+function callSiteId(path) {
+	return createHash("sha256").update(formatCallSitePath(path)).digest("hex").slice(0, 16);
+}
+/** Id for an opaque code-block node at a structural location. */
+function codeBlockSiteId(path) {
+	return callSiteId([...path, "code-block"]);
+}
+/** Unwrap `await`/parenthesized wrappers down to the inner expression. */
+function unwrap(expr) {
+	let current = expr;
+	while (ts.isAwaitExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+/** Leftmost identifier text of a property-access / call chain (`a.b().c` → "a"). */
+function baseIdentifierText(expr) {
+	let current = expr;
+	while (true) {
+		if (ts.isPropertyAccessExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts.isCallExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (ts.isNonNullExpression(current) || ts.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return ts.isIdentifier(current) ? current.text : void 0;
+}
+/**
+* Classify an expression as a durable step invocation, or return null. Handles
+* the closed grammar: `x.run(...)`, `x.scope(...).run(...)`,
+* `x.run(...).scope(...)`, `x.prompt(...)`, `promptLlm(...)`, and
+* `ctx.sleep(...)` / `ctx.hook(...)`. Step identity is the structural
+* {@link callSiteId}; there is no user-authored step id.
+*/
+function classifyCall(expression, ctxParamName) {
+	const expr = unwrap(expression);
+	if (!ts.isCallExpression(expr)) return null;
+	const callee = expr.expression;
+	if (ts.isIdentifier(callee)) {
+		if (callee.text === "promptLlm") return {
+			key: "promptLlm",
+			callKind: "llm"
+		};
+		if (callee.text === "sleep") return {
+			key: "sleep",
+			callKind: "wait"
+		};
+		if (callee.text === "hook") return {
+			key: "hook",
+			callKind: "hook"
+		};
+		return null;
+	}
+	if (!ts.isPropertyAccessExpression(callee)) return null;
+	const method = callee.name.text;
+	const base = baseIdentifierText(callee.expression);
+	switch (method) {
+		case "run":
+			if (!base) return null;
+			return {
+				key: base,
+				callKind: "workflow-step",
+				importName: base
+			};
+		case "prompt":
+			if (!base) return null;
+			return {
+				key: base,
+				callKind: "agent",
+				importName: base
+			};
+		case "sleep":
+			if (base !== ctxParamName) return null;
+			return {
+				key: "sleep",
+				callKind: "wait"
+			};
+		case "hook":
+			if (base !== ctxParamName) return null;
+			return {
+				key: "hook",
+				callKind: "hook"
+			};
+		case "scope": return classifyCall(callee.expression, ctxParamName);
+		case "__site": return classifyCall(callee.expression, ctxParamName);
+		default: return null;
+	}
+}
+/** Detect `Promise.all([...])` and return its element expressions. */
+function asPromiseAll(expression) {
+	const expr = unwrap(expression);
+	if (!ts.isCallExpression(expr) || !ts.isPropertyAccessExpression(expr.expression)) return null;
+	const callee = expr.expression;
+	if (!ts.isIdentifier(callee.expression) || callee.expression.text !== "Promise" || callee.name.text !== "all") return null;
+	const [arg] = expr.arguments;
+	if (!arg || !ts.isArrayLiteralExpression(arg)) return null;
+	return [...arg.elements];
+}
+/**
+* `const approval = ctx.hook(...)` / `ctx.sleep(...)` without an immediate `await` on
+* the initializer — the durable step should appear at the later `await approval` site.
+*/
+function deferredHookSleepCall(initializer, ctxParamName) {
+	if (ts.isAwaitExpression(initializer)) return null;
+	const inner = unwrap(initializer);
+	if (!ts.isCallExpression(inner)) return null;
+	const step = classifyCall(initializer, ctxParamName);
+	if (!step || step.callKind !== "hook" && step.callKind !== "wait") return null;
+	return inner;
+}
+function isAwaitIdentifier(expression, varName) {
+	const inner = unwrap(expression);
+	return ts.isIdentifier(inner) && inner.text === varName;
+}
+/** Whether a statement is `await <varName>` (expr stmt or var decl initializer). */
+function statementAwaitingIdentifier(statement, varName) {
+	if (ts.isExpressionStatement(statement)) return isAwaitIdentifier(statement.expression, varName);
+	if (ts.isVariableStatement(statement)) {
+		for (const decl of statement.declarationList.declarations) if (decl.initializer && isAwaitIdentifier(decl.initializer, varName)) return true;
+	}
+	if (ts.isIfStatement(statement)) return statementAwaitingIdentifier(statement.thenStatement, varName) || (statement.elseStatement ? statementAwaitingIdentifier(statement.elseStatement, varName) : false);
+	if (ts.isBlock(statement)) return statement.statements.some((inner) => statementAwaitingIdentifier(inner, varName));
+	if (ts.isForStatement(statement) || ts.isForOfStatement(statement) || ts.isForInStatement(statement) || ts.isWhileStatement(statement) || ts.isDoStatement(statement)) return statementAwaitingIdentifier(statement.statement, varName);
+	if (ts.isTryStatement(statement)) return statementAwaitingIdentifier(statement.tryBlock, varName) || (statement.catchClause ? statementAwaitingIdentifier(statement.catchClause.block, varName) : false) || (statement.finallyBlock ? statementAwaitingIdentifier(statement.finallyBlock, varName) : false);
+	return false;
+}
+/**
+* Path of the first later statement in the same block that `await`s `varName`, or null
+* when the handle is never awaited (falls back to inline placement at the decl site).
+*/
+function findDeferredAwaitPath(statements, fromIndex, blockPath, varName) {
+	for (let index = fromIndex + 1; index < statements.length; index++) {
+		const statement = statements[index];
+		if (statementAwaitingIdentifier(statement, varName)) return [...blockPath, `stmt:${index}`];
+	}
+	return null;
+}
+/**
+* The single structural traversal shared by every consumer of {@link callSiteId}:
+* the graph producer's golden map ({@link computeCallSiteIds}), the contained-id
+* collector ({@link collectContainedCallSiteIds}), and — mirrored, not shared —
+* the graph builder itself. Assigning call paths in one place keeps the
+* cross-package `callSiteId` invariant from drifting: any construct handled here
+* (ternary prongs, deferred hook/sleep, loops, switch, try, `Promise.all`,
+* same-file helper expansion) is handled identically for the map and the set.
+*/
+function walkCallSites(root, basePath, options, visit) {
+	const state = {
+		ctxParamName: options.ctxParamName,
+		localFunctions: options.localFunctions,
+		callCounters: /* @__PURE__ */ new Map(),
+		walked: /* @__PURE__ */ new Set(),
+		visit
+	};
+	if (ts.isBlock(root)) walkStatements([...root.statements], basePath, state);
+	else if (ts.isStatement(root)) walkStatement(root, basePath, state);
+	else if (ts.isExpression(root)) walkExpression(root, basePath, state);
+	else ts.forEachChild(root, (child) => {
+		if (ts.isStatement(child)) walkStatement(child, basePath, state);
+		else if (ts.isExpression(child)) walkExpression(child, basePath, state);
+	});
+}
+function nextCallPath(state, basePath) {
+	const key = basePath.join(">");
+	const index = state.callCounters.get(key) ?? 0;
+	state.callCounters.set(key, index + 1);
+	return [...basePath, `call:${index}`];
+}
+function peekCallPath(state, basePath) {
+	const key = basePath.join(">");
+	const index = state.callCounters.get(key) ?? 0;
+	return [...basePath, `call:${index}`];
+}
+function reserveCallPath(state, callPath) {
+	const callSegment = callPath.at(-1);
+	if (!callSegment?.startsWith("call:")) return;
+	const index = Number.parseInt(callSegment.slice(5), 10);
+	if (Number.isNaN(index)) return;
+	const key = callPath.slice(0, -1).join(">");
+	const current = state.callCounters.get(key) ?? 0;
+	state.callCounters.set(key, Math.max(current, index + 1));
+}
+function walkStatements(statements, path, state) {
+	statements.forEach((statement, index) => {
+		walkStatement(statement, [...path, `stmt:${index}`], state, statements, index);
+	});
+}
+function walkStatement(statement, path, state, statements = [], statementIndex = 0) {
+	if (ts.isReturnStatement(statement)) {
+		if (statement.expression) walkExpression(statement.expression, path, state);
+		return;
+	}
+	if (ts.isExpressionStatement(statement)) {
+		walkExpression(statement.expression, path, state);
+		return;
+	}
+	if (ts.isVariableStatement(statement)) {
+		for (const decl of statement.declarationList.declarations) {
+			if (!decl.initializer) continue;
+			const deferredCall = deferredHookSleepCall(decl.initializer, state.ctxParamName);
+			if (deferredCall && ts.isIdentifier(decl.name) && statements.length > 0) {
+				const awaitPath = findDeferredAwaitPath(statements, statementIndex, path.slice(0, -1), decl.name.text);
+				if (awaitPath) {
+					const callPath = peekCallPath(state, awaitPath);
+					state.visit(deferredCall, callPath);
+					reserveCallPath(state, callPath);
+					continue;
+				}
+			}
+			walkExpression(decl.initializer, path, state);
+		}
+		return;
+	}
+	if (ts.isIfStatement(statement)) {
+		const conditions = [];
+		let elseBranch;
+		let current = statement;
+		while (current) {
+			conditions.push({
+				handle: `cond-${conditions.length}`,
+				branch: current.thenStatement
+			});
+			const next = current.elseStatement;
+			if (next && ts.isIfStatement(next)) {
+				current = next;
+				continue;
+			}
+			elseBranch = next;
+			current = void 0;
+		}
+		for (const { handle, branch } of conditions) walkStatement(branch, [...path, `if:${handle}`], state);
+		if (elseBranch) walkStatement(elseBranch, [...path, "if:else"], state);
+		return;
+	}
+	if (ts.isForStatement(statement) || ts.isForOfStatement(statement) || ts.isForInStatement(statement) || ts.isWhileStatement(statement) || ts.isDoStatement(statement)) {
+		walkStatement(statement.statement, [...path, "loop"], state);
+		return;
+	}
+	if (ts.isSwitchStatement(statement)) {
+		for (const [index, clause] of statement.caseBlock.clauses.entries()) {
+			const handle = ts.isCaseClause(clause) ? `case-${index}` : "default";
+			walkStatements([...clause.statements], [...path, `switch:${handle}`], state);
+		}
+		return;
+	}
+	if (ts.isBlock(statement)) {
+		walkStatements([...statement.statements], path, state);
+		return;
+	}
+	if (ts.isTryStatement(statement)) {
+		walkStatements([...statement.tryBlock.statements], [...path, "try"], state);
+		if (statement.catchClause?.block) walkStatements([...statement.catchClause.block.statements], [...path, "catch"], state);
+		if (statement.finallyBlock) walkStatements([...statement.finallyBlock.statements], [...path, "finally"], state);
+	}
+}
+function walkExpression(expression, path, state) {
+	const parallel = asPromiseAll(expression);
+	if (parallel) {
+		parallel.forEach((element, index) => {
+			walkExpression(element, [...path, `parallel:${index}`], state);
+		});
+		return;
+	}
+	if (classifyCall(expression, state.ctxParamName)) {
+		const node = unwrap(expression);
+		if (ts.isCallExpression(node)) state.visit(node, nextCallPath(state, path));
+		return;
+	}
+	if (ts.isConditionalExpression(expression)) {
+		walkExpression(expression.whenTrue, [...path, "cond:then"], state);
+		walkExpression(expression.whenFalse, [...path, "cond:else"], state);
+		return;
+	}
+	if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression)) {
+		const helperName = expression.expression.text;
+		const helperBody = state.localFunctions.get(helperName);
+		if (helperBody) {
+			if (state.walked.has(helperName)) return;
+			state.walked.add(helperName);
+			const helperPath = [`helper:${helperName}`];
+			if (ts.isBlock(helperBody)) walkStatements([...helperBody.statements], helperPath, state);
+			else if (ts.isExpression(helperBody)) walkExpression(helperBody, helperPath, state);
+			return;
+		}
+	}
+	ts.forEachChild(expression, (child) => {
+		if (ts.isExpression(child)) walkExpression(child, path, state);
+	});
+}
+/** Convenience: collect all callSiteIds reachable from `root`. */
+function collectCallSiteIds(root, basePath, options) {
+	const out = /* @__PURE__ */ new Set();
+	walkCallSites(root, basePath, options, (_call, callPath) => {
+		out.add(callSiteId(callPath));
+	});
+	return [...out];
+}
+/**
+* Collect durable call-site ids hidden inside an off-grammar subtree (a
+* `code-block` node's `containedCallSiteIds`). Uses the same {@link walkCallSites}
+* traversal as {@link computeCallSiteIds}, so the ids attributed to a code-block
+* always match the ids the build transform injects at those call sites.
+*/
+function collectContainedCallSiteIds(node, ctxParamName, localFunctions, basePath = [RUN_BODY_SEGMENT]) {
+	return collectCallSiteIds(node, basePath, {
+		ctxParamName,
+		localFunctions
+	});
+}
+/**
+* Index same-file helper functions by name (top-level `function foo()` and
+* `const foo = () => {}` / function-expression consts) so step detection can
+* descend into a local helper a workflow calls. Cross-file helpers are
+* intentionally absent (single-file boundary).
+*/
+function collectLocalFunctions(sourceFile) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name && statement.body) {
+			byName.set(statement.name.text, statement.body);
+			continue;
+		}
+		if (ts.isVariableStatement(statement)) {
+			for (const decl of statement.declarationList.declarations) if (ts.isIdentifier(decl.name) && decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) byName.set(decl.name.text, decl.initializer.body);
+		}
+	}
+	return byName;
+}
+/**
+* Count textual invocations of each same-file helper across the workflow `run`
+* body and every other same-file helper body. A helper invoked from more than
+* one call site cannot be inlined as distinct real step nodes: the build injects
+* one `callSiteId` per physical call site in the helper body, so every invocation
+* shares those ids and folds occurrences at runtime (like a loop). Rendering it as
+* one shared subgraph produces misleading cross-branch / self-loop edges, so a
+* multiply-invoked helper collapses to a per-call-site `code-block` instead.
+*/
+function sharedHelperNames(located, localFunctions) {
+	const counts = /* @__PURE__ */ new Map();
+	const tally = (root) => {
+		const visit = (node) => {
+			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+				const name = node.expression.text;
+				if (localFunctions.has(name)) counts.set(name, (counts.get(name) ?? 0) + 1);
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(root);
+	};
+	tally(located.body);
+	for (const body of localFunctions.values()) tally(body);
+	const shared = /* @__PURE__ */ new Set();
+	for (const [name, count] of counts) if (count >= 2) shared.add(name);
+	return shared;
+}
+/** Split camelCase identifiers into sentence case (`hasBreaking` → `Has breaking`). */
+function prettifyCamelCaseIdentifier(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/\s+/).map((word, index) => {
+		const lower = word.toLowerCase();
+		return index === 0 ? lower.charAt(0).toUpperCase() + lower.slice(1) : lower;
+	}).join(" ");
+}
+function unwrapParenthesized(expression) {
+	let current = expression;
+	while (ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+function identifierNameFromExpression(expression) {
+	const unwrapped = unwrapParenthesized(expression);
+	if (ts.isPropertyAccessExpression(unwrapped) || ts.isPropertyAccessChain(unwrapped)) return unwrapped.name.text;
+	if (ts.isIdentifier(unwrapped)) return unwrapped.text;
+}
+/**
+* Human-readable label for an `if`/`switch` condition. Member access and bare
+* identifiers prettify (`changes.hasBreaking` → `Has breaking`); everything
+* else falls back to normalized source text.
+*/
+function formatConditionLabel(expression, sourceFile) {
+	const identifierName = identifierNameFromExpression(expression);
+	if (identifierName) return prettifyCamelCaseIdentifier(identifierName);
+	return expression.getText(sourceFile).replace(/\s+/g, " ").trim();
+}
+/**
+* Find the input-object argument of a durable call. Descends through the
+* build-injected `.__site(...)` and user `.scope(...)` wrappers to the
+* `.run({...})` / `.prompt({...})` / `promptLlm({...})` call and returns its
+* first argument (the input object literal), or undefined.
+*/
+function extractStepInputArg(expression) {
+	return unwrapToCall(expression)?.arguments[0];
+}
+function combineField(base, path) {
+	if (base && path) return `${base}.${path}`;
+	return base ?? path;
+}
+/** Leftmost identifier + the dotted property path of a `a.b.c` chain (`{ base: "a", path: "b.c" }`). */
+function propertyAccessParts(expr) {
+	const parts = [];
+	let current = expr;
+	while (ts.isPropertyAccessExpression(current)) {
+		parts.unshift(current.name.text);
+		current = current.expression;
+	}
+	if (!ts.isIdentifier(current)) return null;
+	return {
+		base: current.text,
+		path: parts.join(".")
+	};
+}
+function referenceToken(source) {
+	return {
+		kind: "reference",
+		sourceNodeId: source.nodeId,
+		...source.field ? { field: source.field } : {}
+	};
+}
+function resolveIdentifier(name, scope) {
+	if (name === scope.inputParamName) return {
+		kind: "reference",
+		sourceNodeId: scope.entryNodeId
+	};
+	const source = scope.bindings.get(name);
+	if (source) return referenceToken(source);
+	return {
+		kind: "variable",
+		text: name
+	};
+}
+/** The callee's source name for a call expression (`buildPrompt`, `jobs.map`); never its args. */
+function calleeName(call, sourceFile) {
+	const callee = call.expression;
+	if (ts.isIdentifier(callee)) return callee.text;
+	if (ts.isPropertyAccessExpression(callee)) {
+		const parts = propertyAccessParts(callee);
+		if (parts) return `${parts.base}.${parts.path}`;
+	}
+	return callee.getText(sourceFile);
+}
+function resolvePropertyAccess(expr, scope, sourceFile) {
+	const parts = propertyAccessParts(expr);
+	if (!parts) return {
+		kind: "variable",
+		text: expr.getText(sourceFile)
+	};
+	if (parts.base === scope.inputParamName) return {
+		kind: "reference",
+		sourceNodeId: scope.entryNodeId,
+		field: parts.path
+	};
+	const source = scope.bindings.get(parts.base);
+	if (source) {
+		const field = combineField(source.field, parts.path);
+		return {
+			kind: "reference",
+			sourceNodeId: source.nodeId,
+			...field ? { field } : {}
+		};
+	}
+	return {
+		kind: "variable",
+		text: expr.getText(sourceFile)
+	};
+}
+/** Tokenize one value expression into a binding (literal text and/or upstream references). */
+function tokensFromExpression(expr, scope, sourceFile) {
+	const value = unwrap(expr);
+	if (ts.isStringLiteralLike(value)) return { tokens: [{
+		kind: "text",
+		text: value.text
+	}] };
+	if (ts.isNumericLiteral(value)) return { tokens: [{
+		kind: "text",
+		text: value.text
+	}] };
+	if (value.kind === ts.SyntaxKind.TrueKeyword) return { tokens: [{
+		kind: "text",
+		text: "true"
+	}] };
+	if (value.kind === ts.SyntaxKind.FalseKeyword) return { tokens: [{
+		kind: "text",
+		text: "false"
+	}] };
+	if (value.kind === ts.SyntaxKind.NullKeyword) return { tokens: [{
+		kind: "text",
+		text: "null"
+	}] };
+	if (ts.isIdentifier(value)) return { tokens: [resolveIdentifier(value.text, scope)] };
+	if (ts.isPropertyAccessExpression(value)) return { tokens: [resolvePropertyAccess(value, scope, sourceFile)] };
+	if (ts.isTemplateExpression(value)) {
+		const tokens = [];
+		if (value.head.text) tokens.push({
+			kind: "text",
+			text: value.head.text
+		});
+		for (const span of value.templateSpans) {
+			tokens.push(...tokensFromExpression(span.expression, scope, sourceFile).tokens);
+			if (span.literal.text) tokens.push({
+				kind: "text",
+				text: span.literal.text
+			});
+		}
+		return {
+			tokens,
+			...value.getText(sourceFile).includes("\n") ? { multiline: true } : {}
+		};
+	}
+	if (ts.isObjectLiteralExpression(value) || ts.isArrayLiteralExpression(value)) return {
+		tokens: [{
+			kind: "text",
+			text: value.getText(sourceFile)
+		}],
+		multiline: true
+	};
+	if (ts.isCallExpression(value)) return { tokens: [{
+		kind: "call",
+		name: calleeName(value, sourceFile)
+	}] };
+	return { tokens: [{
+		kind: "variable",
+		text: value.getText(sourceFile)
+	}] };
+}
+/**
+* Capture per-field call-site bindings from a step's input-object argument. Each
+* property becomes a {@link WorkflowCanvasRawBinding} (literal text and/or
+* references to upstream node outputs). Returns undefined when the argument isn't
+* an object literal (e.g. `a.run(payload)`), or has no bindable properties.
+*/
+function inputBindingsFromCall(expression, scope, sourceFile) {
+	const arg = extractStepInputArg(expression);
+	if (!arg || !ts.isObjectLiteralExpression(arg)) return;
+	const bindings = {};
+	for (const prop of arg.properties) {
+		if (ts.isShorthandPropertyAssignment(prop)) {
+			bindings[prop.name.text] = { tokens: [resolveIdentifier(prop.name.text, scope)] };
+			continue;
+		}
+		if (ts.isPropertyAssignment(prop)) {
+			const key = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+			if (!key) continue;
+			bindings[key] = tokensFromExpression(prop.initializer, scope, sourceFile);
+		}
+	}
+	return Object.keys(bindings).length > 0 ? bindings : void 0;
+}
+/**
+* Capture static `promptLlm(prompt, options)` config from an llm call site. Reads
+* literal `model`/`thinkingLevel` (strings) and `maxTokens`/`temperature` (numbers),
+* plus the PRESENCE of `system`/`outputSchema` (usually expressions, not literals).
+* Returns undefined when no options object literal or no recognizable fields.
+*/
+function llmOptionsFromCall(expression) {
+	const optionsArg = unwrapToCall(expression)?.arguments[1];
+	if (!optionsArg || !ts.isObjectLiteralExpression(optionsArg)) return;
+	const options = {};
+	for (const prop of optionsArg.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const key = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+		if (!key) continue;
+		const value = unwrap(prop.initializer);
+		switch (key) {
+			case "model":
+				if (ts.isStringLiteralLike(value)) options.model = value.text;
+				break;
+			case "thinkingLevel":
+				if (ts.isStringLiteralLike(value)) options.thinkingLevel = value.text;
+				break;
+			case "maxTokens":
+				if (ts.isNumericLiteral(value)) options.maxTokens = Number(value.text);
+				break;
+			case "temperature":
+				if (ts.isNumericLiteral(value)) options.temperature = Number(value.text);
+				break;
+			case "system":
+				options.hasSystemPrompt = true;
+				break;
+			case "outputSchema":
+				options.hasOutputSchema = true;
+				break;
+		}
+	}
+	return Object.keys(options).length > 0 ? options : void 0;
+}
+/** Descend wrapper calls (`.scope`/`.__site`) to the underlying durable call. */
+function unwrapToCall(expression) {
+	let expr = unwrap(expression);
+	while (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
+		const method = expr.expression.name.text;
+		if (method === "scope" || method === "__site") {
+			expr = unwrap(expr.expression.expression);
+			continue;
+		}
+		break;
+	}
+	return ts.isCallExpression(expr) ? expr : void 0;
+}
+/**
+* Tokenize a `promptLlm(prompt, options)` call's options object into per-field
+* bindings (model/system/outputSchema/maxTokens/…), the same token model used for
+* action inputs — so a `model: CLASSIFY_MODEL` renders as a variable chip and a
+* `system: dailySystem()` as a call chip, instead of being dropped. Returns
+* undefined when there's no options object literal.
+*/
+function llmOptionBindingsFromCall(expression, scope, sourceFile) {
+	const optionsArg = unwrapToCall(expression)?.arguments[1];
+	if (!optionsArg || !ts.isObjectLiteralExpression(optionsArg)) return;
+	const bindings = {};
+	for (const prop of optionsArg.properties) {
+		if (ts.isShorthandPropertyAssignment(prop)) {
+			bindings[prop.name.text] = { tokens: [resolveIdentifier(prop.name.text, scope)] };
+			continue;
+		}
+		if (ts.isPropertyAssignment(prop)) {
+			const key = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name) ? prop.name.text : void 0;
+			if (!key) continue;
+			bindings[key] = tokensFromExpression(prop.initializer, scope, sourceFile);
+		}
+	}
+	return Object.keys(bindings).length > 0 ? bindings : void 0;
+}
+/** Statically-evaluate a literal initializer to a scalar, or undefined if not literal. */
+function literalConstantValue(initializer) {
+	const value = unwrap(initializer);
+	if (ts.isStringLiteralLike(value)) return value.text;
+	if (ts.isNumericLiteral(value)) return Number(value.text);
+	if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(value.operand)) return -Number(value.operand.text);
+	if (value.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (value.kind === ts.SyntaxKind.FalseKeyword) return false;
+}
+/**
+* Collect top-level `const NAME = <literal scalar>` declarations from the workflow
+* source so the platform can resolve `variable` value tokens (e.g. a model pinned to
+* a named const) to their concrete value. Scalars only — computed or non-literal
+* consts (and anything function-local) are intentionally skipped.
+*/
+function collectTopLevelConstants(sourceFile) {
+	const constants = {};
+	for (const statement of sourceFile.statements) {
+		if (!ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
+		for (const decl of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(decl.name) || !decl.initializer) continue;
+			const value = literalConstantValue(decl.initializer);
+			if (value !== void 0) constants[decl.name.text] = value;
+		}
+	}
+	return constants;
+}
+/**
+* Record the producer outputs a variable declaration binds, so later call sites
+* can reference them. Handles `const x = await a.run()` (→ `x` = the node) and
+* `const { text } = await a.prompt()` (→ `text` = the node's `text` field).
+*/
+function recordDeclarationBinding(name, nodeId, scope) {
+	if (ts.isIdentifier(name)) {
+		scope.bindings.set(name.text, { nodeId });
+		return;
+	}
+	if (ts.isObjectBindingPattern(name)) for (const element of name.elements) {
+		if (!ts.isIdentifier(element.name)) continue;
+		const field = element.propertyName && ts.isIdentifier(element.propertyName) ? element.propertyName.text : element.name.text;
+		scope.bindings.set(element.name.text, {
+			nodeId,
+			field
+		});
+	}
+}
+const ENTRY_NODE_ID = "entry";
+const MAX_LABEL_LENGTH = 60;
+function truncate(text) {
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	return collapsed.length > MAX_LABEL_LENGTH ? `${collapsed.slice(0, MAX_LABEL_LENGTH - 1)}…` : collapsed;
+}
+/** First-party + integration packages live under this scope; `<app>` is the slug. */
+const APP_PACKAGE_SCOPE = "@keystrokehq/";
+function appSlugFromSpecifier(specifier) {
+	if (!specifier.startsWith(APP_PACKAGE_SCOPE)) return;
+	return specifier.slice(13).split("/")[0] || void 0;
+}
+function collectAppImportsBySymbol(sourceFile) {
+	const bySymbol = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const appSlug = appSlugFromSpecifier(statement.moduleSpecifier.text);
+		const clause = statement.importClause;
+		if (!appSlug || !clause) continue;
+		if (clause.name) bySymbol.set(clause.name.text, appSlug);
+		if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) bySymbol.set(element.name.text, appSlug);
+	}
+	return bySymbol;
+}
+function stepLabel(info) {
+	switch (info.callKind) {
+		case "wait": return "Sleep";
+		case "hook": return "Wait for signal";
+		case "llm": return info.key === "promptLlm" ? "LLM prompt" : info.key;
+		case "agent":
+		case "workflow-step": return info.key;
+	}
+}
+var GraphBuilder = class {
+	sourceFile;
+	resolveSlug;
+	nodes = [];
+	edges = [];
+	nodeIds = /* @__PURE__ */ new Set();
+	callCounters = /* @__PURE__ */ new Map();
+	structuralCount = 0;
+	edgeCount = 0;
+	exitId = null;
+	/** >0 while walking inside a branch (if/switch/loop/try), so a `return` there
+	* is modeled as its own local "Output" terminal instead of a long edge to the
+	* single shared exit (which reads as crossing the whole graph). */
+	inBranchDepth = 0;
+	/** True while inlining a helper called in VALUE position (`const x = await f()`),
+	* so a `return` inside it is a value handoff to the caller (its expression's
+	* frontier), NOT the workflow's terminal output. False for the run body and for
+	* helpers dispatched in tail position (`return f()`), whose returns ARE outputs. */
+	returnAsValue = false;
+	appImportsBySymbol;
+	localFunctions;
+	/** Same-file helpers invoked from >1 call site — collapsed to a code-block per site. */
+	sharedHelpers = /* @__PURE__ */ new Set();
+	/** First open endpoints per expanded helper (for deduped re-entry). */
+	helperEntryByName = /* @__PURE__ */ new Map();
+	helperExitByName = /* @__PURE__ */ new Map();
+	/** Lexical symbol table for resolving call-site value references to upstream nodes. */
+	bindingScope = {
+		bindings: /* @__PURE__ */ new Map(),
+		entryNodeId: ENTRY_NODE_ID
+	};
+	/** Hook/sleep handles created in a var decl but awaited later in the run body. */
+	pendingDeferredSteps = /* @__PURE__ */ new Map();
+	constructor(sourceFile, resolveSlug) {
+		this.sourceFile = sourceFile;
+		this.resolveSlug = resolveSlug;
+		this.appImportsBySymbol = collectAppImportsBySymbol(sourceFile);
+		this.localFunctions = collectLocalFunctions(sourceFile);
+	}
+	subtreeHasStep(node, ctxParamName, visiting = /* @__PURE__ */ new Set()) {
+		let found = false;
+		const visit = (current) => {
+			if (found) return;
+			if ((ts.isCallExpression(current) || ts.isAwaitExpression(current)) && classifyCall(current, ctxParamName)) {
+				found = true;
+				return;
+			}
+			if (ts.isCallExpression(current) && ts.isIdentifier(current.expression)) {
+				const helperBody = this.localFunctions.get(current.expression.text);
+				if (helperBody && !visiting.has(current.expression.text)) {
+					visiting.add(current.expression.text);
+					if (this.subtreeHasStep(helperBody, ctxParamName, visiting)) {
+						found = true;
+						return;
+					}
+				}
+			}
+			ts.forEachChild(current, visit);
+		};
+		visit(node);
+		return found;
+	}
+	/**
+	* Whether a helper called in VALUE position is safe to inline as real step nodes.
+	* Only straight-line helpers qualify — a block of variable/expression statements
+	* with at most a single trailing `return` (no `if`/`switch`/loop/`try`/`throw`),
+	* or a concise non-ternary expression body. Helpers with internal control flow or
+	* multiple returns are genuinely ambiguous as values (which `return` is "the"
+	* result?), so they collapse to a single `code-block` instead (run attribution is
+	* preserved via `containedCallSiteIds`). Helpers dispatched in tail position
+	* (`return f()`) are inlined regardless — there their returns ARE the output.
+	*/
+	isLinearValueHelper(helperBody) {
+		if (!ts.isBlock(helperBody)) return ts.isExpression(helperBody) && !ts.isConditionalExpression(helperBody);
+		let returnCount = 0;
+		const statements = helperBody.statements;
+		for (const [index, statement] of statements.entries()) {
+			if (ts.isVariableStatement(statement) || ts.isExpressionStatement(statement)) continue;
+			if (ts.isReturnStatement(statement)) {
+				returnCount += 1;
+				if (returnCount > 1 || index !== statements.length - 1) return false;
+				continue;
+			}
+			return false;
+		}
+		return true;
+	}
+	build(located) {
+		this.sharedHelpers = sharedHelperNames(located, this.localFunctions);
+		this.bindingScope = {
+			bindings: /* @__PURE__ */ new Map(),
+			entryNodeId: ENTRY_NODE_ID,
+			...located.inputParamName ? { inputParamName: located.inputParamName } : {}
+		};
+		const incoming = [{ nodeId: this.addNode("entry", { label: "Start" }, "entry") }];
+		const runPath = [RUN_BODY_SEGMENT];
+		const { body, ctxParamName } = located;
+		const open = ts.isBlock(body) ? this.walkStatements([...body.statements], incoming, ctxParamName, void 0, runPath) : this.walkConcise(body, incoming, ctxParamName, runPath);
+		if (open.length > 0) this.connect(open, this.getExit());
+		const constants = collectTopLevelConstants(this.sourceFile);
+		return {
+			nodes: this.nodes,
+			edges: this.edges,
+			...Object.keys(constants).length > 0 ? { constants } : {}
+		};
+	}
+	push(node) {
+		this.nodes.push(node);
+		this.nodeIds.add(node.id);
+		return node.id;
+	}
+	addNode(nodeType, data, id, parentId) {
+		const node = {
+			id,
+			nodeType,
+			data
+		};
+		if (parentId) node.parentId = parentId;
+		return this.push(node);
+	}
+	nextCallPath(basePath) {
+		const key = formatCallSitePath(basePath);
+		const index = this.callCounters.get(key) ?? 0;
+		this.callCounters.set(key, index + 1);
+		return [...basePath, `call:${index}`];
+	}
+	peekCallPath(basePath) {
+		const key = formatCallSitePath(basePath);
+		const index = this.callCounters.get(key) ?? 0;
+		return [...basePath, `call:${index}`];
+	}
+	/** Reserve a precomputed call index so a later materialization does not shift ids. */
+	reserveCallPath(callPath) {
+		const callSegment = callPath.at(-1);
+		if (!callSegment?.startsWith("call:")) return;
+		const index = Number.parseInt(callSegment.slice(5), 10);
+		if (Number.isNaN(index)) return;
+		const key = formatCallSitePath(callPath.slice(0, -1));
+		const current = this.callCounters.get(key) ?? 0;
+		this.callCounters.set(key, Math.max(current, index + 1));
+	}
+	addStructural(label, parentId) {
+		const id = `merge-${this.structuralCount++}`;
+		return this.addNode("merge", { label }, id, parentId);
+	}
+	addErrorNode(label, parentId) {
+		const id = `error-${this.structuralCount++}`;
+		return this.addNode("error", { label }, id, parentId);
+	}
+	/** A local terminal output node for an early `return` inside a branch. */
+	addOutputNode(parentId) {
+		const id = `output-${this.structuralCount++}`;
+		return this.addNode("exit", { label: "Output" }, id, parentId);
+	}
+	addDecision(label, outputs, parentId) {
+		const id = `decision-${this.structuralCount++}`;
+		return this.addNode("decision", {
+			label,
+			outputs
+		}, id, parentId);
+	}
+	addCodeBlock(label, path, parentId, containedCallSiteIds) {
+		const id = codeBlockSiteId(path);
+		if (this.nodeIds.has(id)) return id;
+		const data = {
+			label,
+			...containedCallSiteIds?.length ? { containedCallSiteIds } : {}
+		};
+		return this.addNode("code-block", data, id, parentId);
+	}
+	addStep(info, expression, callPath, parentId) {
+		const id = callSiteId(callPath);
+		if (this.nodeIds.has(id)) return id;
+		const data = {
+			label: stepLabel(info),
+			callKind: info.callKind
+		};
+		const appSlug = info.importName ? this.appImportsBySymbol.get(info.importName) : void 0;
+		if (appSlug) data.appSlug = appSlug;
+		if (info.importName && this.resolveSlug) {
+			const resolved = this.resolveSlug(info.importName, this.sourceFile);
+			if (resolved) {
+				data.slug = resolved.slug;
+				if (resolved.description) data.description = resolved.description;
+				if (resolved.name) data.label = resolved.name;
+			}
+		}
+		if (info.callKind === "llm") {
+			const llmOptions = llmOptionsFromCall(expression);
+			if (llmOptions) data.llmOptions = llmOptions;
+			const optionBindings = llmOptionBindingsFromCall(expression, this.bindingScope, this.sourceFile);
+			if (optionBindings) data.inputBindings = optionBindings;
+		} else if (info.callKind !== "wait" && info.callKind !== "hook") {
+			const inputBindings = inputBindingsFromCall(expression, this.bindingScope, this.sourceFile);
+			if (inputBindings) data.inputBindings = inputBindings;
+		}
+		return this.addNode("step", data, id, parentId);
+	}
+	addGroup(groupKind, label, parentId) {
+		const nodeType = groupKind === "loop" ? "loop" : "parallel";
+		const groupId = `${nodeType}-${this.structuralCount++}`;
+		const groupNode = {
+			id: groupId,
+			nodeType,
+			data: {
+				label,
+				groupKind
+			}
+		};
+		if (parentId) groupNode.parentId = parentId;
+		this.push(groupNode);
+		const groupStartId = `${groupId}-start`;
+		this.push({
+			id: groupStartId,
+			nodeType: "loop-start",
+			data: { label: "Start" },
+			parentId: groupId
+		});
+		return {
+			groupId,
+			groupStartId
+		};
+	}
+	getExit() {
+		if (this.exitId === null) this.exitId = this.addNode("exit", { label: "Output" }, "exit");
+		return this.exitId;
+	}
+	addEdge(source, target, endpoint) {
+		const edge = {
+			id: `edge-${this.edgeCount++}`,
+			source,
+			target
+		};
+		if (endpoint?.label) edge.label = endpoint.label;
+		if (endpoint?.sourceHandle) edge.sourceHandle = endpoint.sourceHandle;
+		if (endpoint?.branchKind) edge.data = { branchKind: endpoint.branchKind };
+		this.edges.push(edge);
+	}
+	connect(incoming, target) {
+		for (const endpoint of incoming) this.addEdge(endpoint.nodeId, target, endpoint);
+	}
+	walkHelperCall(helperName, helperBody, incoming, ctxParamName, parentId, visiting, tailPosition) {
+		const cachedExit = this.helperExitByName.get(helperName);
+		const cachedEntry = this.helperEntryByName.get(helperName);
+		if (cachedEntry && cachedExit) {
+			this.connect(incoming, cachedEntry);
+			return cachedExit.map((nodeId) => ({ nodeId }));
+		}
+		if (visiting.has(helperName)) return incoming;
+		visiting.add(helperName);
+		const helperPath = [`helper:${helperName}`];
+		const nodesBefore = this.nodes.length;
+		const previousReturnAsValue = this.returnAsValue;
+		this.returnAsValue = !tailPosition;
+		const result = ts.isBlock(helperBody) ? this.walkStatements([...helperBody.statements], incoming, ctxParamName, parentId, helperPath, visiting) : this.walkValue(helperBody, incoming, ctxParamName, parentId, helperPath, visiting);
+		this.returnAsValue = previousReturnAsValue;
+		const firstNewStep = this.nodes.slice(nodesBefore).find((n) => n.nodeType === "step");
+		if (firstNewStep) {
+			this.helperEntryByName.set(helperName, firstNewStep.id);
+			this.helperExitByName.set(helperName, result.map((endpoint) => endpoint.nodeId));
+		}
+		visiting.delete(helperName);
+		return result;
+	}
+	tryMaterializeDeferredAwait(expression, incoming, parentId) {
+		let current = expression;
+		while (ts.isAwaitExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
+		if (!ts.isIdentifier(current)) return null;
+		const pending = this.pendingDeferredSteps.get(current.text);
+		if (!pending) return null;
+		this.pendingDeferredSteps.delete(current.text);
+		const id = this.addStep(pending.step, pending.expression, pending.callPath, parentId);
+		this.reserveCallPath(pending.callPath);
+		this.connect(incoming, id);
+		return [{ nodeId: id }];
+	}
+	tryWalkLocalHelper(expression, incoming, ctxParamName, parentId, path, visiting, tailPosition) {
+		let current = expression;
+		while (ts.isAwaitExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
+		if (!ts.isCallExpression(current) || !ts.isIdentifier(current.expression)) return null;
+		const helperName = current.expression.text;
+		const helperBody = this.localFunctions.get(helperName);
+		if (!helperBody || !this.subtreeHasStep(helperBody, ctxParamName)) return null;
+		if (this.sharedHelpers.has(helperName)) return null;
+		if (!tailPosition && !this.isLinearValueHelper(helperBody)) return null;
+		return this.walkHelperCall(helperName, helperBody, incoming, ctxParamName, parentId, visiting, tailPosition);
+	}
+	walkStatements(statements, incoming, ctxParamName, parentId, path, visiting = /* @__PURE__ */ new Set()) {
+		let frontier = incoming;
+		for (const [index, statement] of statements.entries()) frontier = this.walkStatement(statement, frontier, ctxParamName, parentId, [...path, `stmt:${index}`], visiting, statements, index);
+		return frontier;
+	}
+	walkStatement(statement, incoming, ctxParamName, parentId, path, visiting = /* @__PURE__ */ new Set(), statements = [], statementIndex = 0) {
+		if (ts.isReturnStatement(statement)) return this.walkReturn(statement, incoming, ctxParamName, parentId, path, visiting);
+		if (ts.isThrowStatement(statement)) {
+			const id = this.addErrorNode("Error", parentId);
+			this.connect(incoming, id);
+			return [];
+		}
+		if (ts.isExpressionStatement(statement)) return this.walkValue(statement.expression, incoming, ctxParamName, parentId, path, visiting);
+		if (ts.isVariableStatement(statement)) {
+			let frontier = incoming;
+			for (const decl of statement.declarationList.declarations) {
+				if (!decl.initializer) continue;
+				const deferredCall = deferredHookSleepCall(decl.initializer, ctxParamName);
+				if (deferredCall && ts.isIdentifier(decl.name) && statements.length > 0) {
+					const awaitPath = findDeferredAwaitPath(statements, statementIndex, path.slice(0, -1), decl.name.text);
+					if (awaitPath) {
+						const step = classifyCall(decl.initializer, ctxParamName);
+						if (step) {
+							const callPath = this.peekCallPath(awaitPath);
+							this.pendingDeferredSteps.set(decl.name.text, {
+								step,
+								expression: deferredCall,
+								callPath
+							});
+							recordDeclarationBinding(decl.name, callSiteId(callPath), this.bindingScope);
+						}
+						continue;
+					}
+				}
+				const isStep = classifyCall(decl.initializer, ctxParamName) !== null;
+				frontier = this.walkValue(decl.initializer, frontier, ctxParamName, parentId, path, visiting);
+				if (isStep && frontier.length === 1) recordDeclarationBinding(decl.name, frontier[0].nodeId, this.bindingScope);
+			}
+			return frontier;
+		}
+		if (ts.isIfStatement(statement)) return this.walkIf(statement, incoming, ctxParamName, parentId, path, visiting);
+		if (ts.isForStatement(statement) || ts.isForOfStatement(statement) || ts.isForInStatement(statement) || ts.isWhileStatement(statement) || ts.isDoStatement(statement)) return this.walkLoop(statement, incoming, ctxParamName, parentId, path, visiting);
+		if (ts.isSwitchStatement(statement)) return this.walkSwitch(statement, incoming, ctxParamName, parentId, path, visiting);
+		if (ts.isBlock(statement)) return this.walkStatements([...statement.statements], incoming, ctxParamName, parentId, path, visiting);
+		if (ts.isTryStatement(statement)) return this.walkTry(statement, incoming, ctxParamName, parentId, path, visiting);
+		if (this.subtreeHasStep(statement, ctxParamName)) {
+			const contained = collectContainedCallSiteIds(statement, ctxParamName, this.localFunctions, path);
+			const id = this.addCodeBlock(truncate(statement.getText(this.sourceFile)), path, parentId, contained);
+			this.connect(incoming, id);
+			return [{ nodeId: id }];
+		}
+		return incoming;
+	}
+	walkValue(expression, incoming, ctxParamName, parentId, path, visiting = /* @__PURE__ */ new Set(), tailPosition = false) {
+		const helperWalk = this.tryWalkLocalHelper(expression, incoming, ctxParamName, parentId, path, visiting, tailPosition);
+		if (helperWalk) return helperWalk;
+		if (ts.isConditionalExpression(expression) && this.subtreeHasStep(expression, ctxParamName)) return this.walkConditional(expression, incoming, ctxParamName, parentId, path, visiting, tailPosition);
+		const parallel = asPromiseAll(expression);
+		if (parallel) return this.walkParallel(parallel, incoming, ctxParamName, parentId, path, visiting);
+		const deferredAwait = this.tryMaterializeDeferredAwait(expression, incoming, parentId);
+		if (deferredAwait) return deferredAwait;
+		const step = classifyCall(expression, ctxParamName);
+		if (step) {
+			const id = this.addStep(step, expression, this.nextCallPath(path), parentId);
+			this.connect(incoming, id);
+			return [{ nodeId: id }];
+		}
+		if (this.subtreeHasStep(expression, ctxParamName)) {
+			const contained = collectContainedCallSiteIds(expression, ctxParamName, this.localFunctions, path);
+			const id = this.addCodeBlock(truncate(expression.getText(this.sourceFile)), path, parentId, contained);
+			this.connect(incoming, id);
+			return [{ nodeId: id }];
+		}
+		return incoming;
+	}
+	walkConcise(expression, incoming, ctxParamName, path) {
+		const frontier = this.walkValue(expression, incoming, ctxParamName, void 0, path, void 0, true);
+		this.connect(frontier, this.getExit());
+		return [];
+	}
+	walkReturn(statement, incoming, ctxParamName, parentId, path, visiting) {
+		if (this.returnAsValue) return statement.expression ? this.walkValue(statement.expression, incoming, ctxParamName, parentId, path, visiting) : incoming;
+		let frontier = incoming;
+		if (statement.expression) frontier = this.walkValue(statement.expression, frontier, ctxParamName, parentId, path, visiting, true);
+		const target = this.inBranchDepth > 0 ? this.addOutputNode(parentId) : this.getExit();
+		this.connect(frontier, target);
+		return [];
+	}
+	walkParallel(elements, incoming, ctxParamName, parentId, path, visiting) {
+		const { groupId, groupStartId } = this.addGroup("parallel", "Parallel", parentId);
+		this.connect(incoming, groupId);
+		for (const [index, element] of elements.entries()) {
+			const branchPath = [...path, `parallel:${index}`];
+			if (!classifyCall(element, ctxParamName) && !this.subtreeHasStep(element, ctxParamName)) continue;
+			this.walkValue(element, [{
+				nodeId: groupStartId,
+				branchKind: "parallel-branch"
+			}], ctxParamName, groupId, branchPath, visiting);
+		}
+		return [{ nodeId: groupId }];
+	}
+	walkIf(statement, incoming, ctxParamName, parentId, path, visiting) {
+		this.inBranchDepth++;
+		const conditions = [];
+		let elseBranch;
+		let current = statement;
+		while (current) {
+			conditions.push({
+				handle: `cond-${conditions.length}`,
+				label: truncate(formatConditionLabel(current.expression, this.sourceFile)),
+				branch: current.thenStatement
+			});
+			const next = current.elseStatement;
+			if (next && ts.isIfStatement(next)) {
+				current = next;
+				continue;
+			}
+			elseBranch = next;
+			current = void 0;
+		}
+		const outputs = [...conditions.map(({ handle, label }) => ({
+			id: handle,
+			label
+		})), {
+			id: "else",
+			label: "Else"
+		}];
+		const decisionId = this.addDecision(truncate(formatConditionLabel(statement.expression, this.sourceFile)), outputs, parentId);
+		this.connect(incoming, decisionId);
+		const branchOpens = conditions.map(({ handle, branch }) => this.walkStatement(branch, [{
+			nodeId: decisionId,
+			branchKind: "then",
+			sourceHandle: handle
+		}], ctxParamName, parentId, [...path, `if:${handle}`], visiting));
+		const elseOpen = elseBranch ? this.walkStatement(elseBranch, [{
+			nodeId: decisionId,
+			branchKind: "else",
+			sourceHandle: "else"
+		}], ctxParamName, parentId, [...path, "if:else"], visiting) : [{
+			nodeId: decisionId,
+			branchKind: "else",
+			sourceHandle: "else"
+		}];
+		this.inBranchDepth--;
+		return this.mergeBranches([...branchOpens, elseOpen], parentId);
+	}
+	walkConditional(expression, incoming, ctxParamName, parentId, path, visiting, tailPosition) {
+		const label = truncate(formatConditionLabel(expression.condition, this.sourceFile));
+		const outputs = [{
+			id: "cond-0",
+			label
+		}, {
+			id: "else",
+			label: "Else"
+		}];
+		const decisionId = this.addDecision(label, outputs, parentId);
+		this.connect(incoming, decisionId);
+		const thenOpen = this.walkValue(expression.whenTrue, [{
+			nodeId: decisionId,
+			branchKind: "then",
+			sourceHandle: "cond-0"
+		}], ctxParamName, parentId, [...path, "cond:then"], visiting, tailPosition);
+		const elseOpen = this.walkValue(expression.whenFalse, [{
+			nodeId: decisionId,
+			branchKind: "else",
+			sourceHandle: "else"
+		}], ctxParamName, parentId, [...path, "cond:else"], visiting, tailPosition);
+		return this.mergeBranches([thenOpen, elseOpen], parentId);
+	}
+	walkLoop(statement, incoming, ctxParamName, parentId, path, visiting) {
+		this.inBranchDepth++;
+		const label = ts.isForOfStatement(statement) ? "For each item" : "Loop";
+		const { groupId, groupStartId } = this.addGroup("loop", label, parentId);
+		this.connect(incoming, groupId);
+		this.walkStatement(statement.statement, [{ nodeId: groupStartId }], ctxParamName, groupId, [...path, "loop"], visiting);
+		this.inBranchDepth--;
+		return [{ nodeId: groupId }];
+	}
+	walkSwitch(statement, incoming, ctxParamName, parentId, path, visiting) {
+		this.inBranchDepth++;
+		const clauses = statement.caseBlock.clauses;
+		const outputs = clauses.map((clause, index) => ts.isCaseClause(clause) ? {
+			id: `case-${index}`,
+			label: truncate(clause.expression.getText(this.sourceFile))
+		} : {
+			id: "default",
+			label: "default"
+		});
+		const decisionId = this.addDecision(truncate(formatConditionLabel(statement.expression, this.sourceFile)), outputs, parentId);
+		this.connect(incoming, decisionId);
+		const branches = clauses.map((clause, index) => {
+			const handle = ts.isCaseClause(clause) ? `case-${index}` : "default";
+			return this.walkStatements([...clause.statements], [{
+				nodeId: decisionId,
+				sourceHandle: outputs[index].id,
+				branchKind: ts.isCaseClause(clause) ? "then" : "else"
+			}], ctxParamName, parentId, [...path, `switch:${handle}`], visiting);
+		});
+		this.inBranchDepth--;
+		return this.mergeBranches(branches, parentId);
+	}
+	walkTry(statement, incoming, ctxParamName, parentId, path, visiting) {
+		this.inBranchDepth++;
+		const beforeTry = this.nodes.length;
+		const tryOpen = this.walkStatements([...statement.tryBlock.statements], incoming, ctxParamName, parentId, [...path, "try"], visiting);
+		const protectedEntry = this.nodes[beforeTry];
+		const protectedEntryId = protectedEntry?.id;
+		const protectedEntryIsStep = protectedEntry?.nodeType === "step";
+		let frontier = tryOpen;
+		const catchBlock = statement.catchClause?.block;
+		if (catchBlock && this.subtreeHasStep(catchBlock, ctxParamName)) if (protectedEntryId && protectedEntryIsStep) {
+			const errorOpen = this.walkStatements([...catchBlock.statements], [{
+				nodeId: protectedEntryId,
+				sourceHandle: "error",
+				branchKind: "error",
+				label: "on error"
+			}], ctxParamName, parentId, [...path, "catch"], visiting);
+			frontier = this.mergeBranches([tryOpen, errorOpen], parentId);
+		} else frontier = this.walkStatements([...catchBlock.statements], tryOpen, ctxParamName, parentId, [...path, "catch"], visiting);
+		if (statement.finallyBlock) frontier = this.walkStatements([...statement.finallyBlock.statements], frontier, ctxParamName, parentId, [...path, "finally"], visiting);
+		this.inBranchDepth--;
+		return frontier;
+	}
+	mergeBranches(branches, parentId) {
+		const open = branches.flat();
+		if (open.length === 0) return [];
+		const mergeId = this.addStructural("Merge", parentId);
+		this.connect(open, mergeId);
+		return [{ nodeId: mergeId }];
+	}
+};
+/** Build a workflow-canvas graph (entry → control flow → exit) from a located workflow. */
+function buildGraph(sourceFile, located, options) {
+	return new GraphBuilder(sourceFile, options?.resolveSlug).build(located);
+}
+function isDefineWorkflowCallee(expr) {
+	if (ts.isIdentifier(expr)) return expr.text === "defineWorkflow";
+	if (ts.isPropertyAccessExpression(expr)) return expr.name.text === "defineWorkflow";
+	return false;
+}
+function readRunParamCtxName(params) {
+	const ctxParam = params[1];
+	if (ctxParam && ts.isIdentifier(ctxParam.name)) return ctxParam.name.text;
+}
+function readRunParamInputName(params) {
+	const inputParam = params[0];
+	if (inputParam && ts.isIdentifier(inputParam.name)) return inputParam.name.text;
+}
+function readWorkflowObject(obj) {
+	let slug;
+	let body;
+	let ctxParamName;
+	let inputParamName;
+	for (const prop of obj.properties) {
+		const name = prop.name && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) ? prop.name.text : void 0;
+		if (name === "slug" && ts.isPropertyAssignment(prop) && ts.isStringLiteral(prop.initializer)) {
+			slug = prop.initializer.text;
+			continue;
+		}
+		if (name !== "run") continue;
+		if (ts.isMethodDeclaration(prop) && prop.body) {
+			body = prop.body;
+			inputParamName = readRunParamInputName(prop.parameters);
+			ctxParamName = readRunParamCtxName(prop.parameters);
+			continue;
+		}
+		if (ts.isPropertyAssignment(prop)) {
+			const init = prop.initializer;
+			if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+				body = init.body;
+				inputParamName = readRunParamInputName(init.parameters);
+				ctxParamName = readRunParamCtxName(init.parameters);
+			}
+		}
+	}
+	if (!body) return null;
+	return {
+		slug,
+		body,
+		inputParamName,
+		ctxParamName
+	};
+}
+/**
+* Find the `defineWorkflow({ ... })` call in a source file and extract its `run`
+* body. Returns null when the file has no recognizable workflow definition.
+*/
+function locateWorkflow(sourceFile) {
+	let located = null;
+	const visit = (node) => {
+		if (located) return;
+		if (ts.isCallExpression(node) && isDefineWorkflowCallee(node.expression)) {
+			const [arg] = node.arguments;
+			if (arg && ts.isObjectLiteralExpression(arg)) {
+				located = readWorkflowObject(arg);
+				if (located) return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return located;
+}
+/**
+* Maps each durable call site in a workflow `run` body to its deterministic
+* {@link callSiteId} — the SAME id the graph producer mints for the corresponding
+* step node. The Phase 5 build transform consumes this to inject the id into the
+* compiled call so the runtime emits `step:<callSiteId>#<occurrence>`, lining run
+* events and credential consumers up 1:1 with canvas nodes.
+*
+* Keyed by the outermost durable {@link ts.CallExpression} (after unwrapping
+* `await`/parens) — i.e. the node the transform rewrites: `x.run(i)`,
+* `x.scope(s).run(i)`, `x.run(i).scope(s)`, `promptLlm(i, opts)`,
+* `ctx.sleep(d)`, `ctx.hook(opts)`.
+*
+* Shares the {@link walkCallSites} traversal with the contained-id collector so
+* the structural `callSiteId` invariant cannot drift between the two.
+*/
+function computeCallSiteIds(sourceFile) {
+	const located = locateWorkflow(sourceFile);
+	const map = /* @__PURE__ */ new Map();
+	if (!located) return map;
+	walkCallSites(located.body, [RUN_BODY_SEGMENT], {
+		ctxParamName: located.ctxParamName,
+		localFunctions: collectLocalFunctions(sourceFile)
+	}, (call, callPath) => {
+		map.set(call, callSiteId(callPath));
+	});
+	return map;
+}
+/**
+* Static reliability checks over a single workflow (or would-be helper) source
+* file. ERRORS block a deploy (they produce an invisible/misleading canvas):
+* durable steps outside a workflow file, and steps nested as call arguments.
+* WARNINGS explain each degraded (opaque code-block) construct so the author can
+* opt into the supported grammar.
+*/
+function diagnoseWorkflowSource(source, fileName) {
+	const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const located = locateWorkflow(sourceFile);
+	if (!located) return crossFileStepDiagnostics(sourceFile, fileName);
+	const shared = sharedHelperNames(located, collectLocalFunctions(sourceFile));
+	return [
+		...nestedStepArgDiagnostics(sourceFile, fileName, located.ctxParamName),
+		...stepInputSpreadDiagnostics(sourceFile, fileName, located.ctxParamName),
+		...opaqueCodeBlockDiagnostics(sourceFile, located, fileName, shared)
+	];
+}
+function lineColumn(sourceFile, node) {
+	const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	return {
+		line: line + 1,
+		column: character + 1
+	};
+}
+function snippet(sourceFile, node) {
+	const text = node.getText(sourceFile).replace(/\s+/g, " ").trim();
+	return text.length > 80 ? `${text.slice(0, 79)}…` : text;
+}
+/** Imported identifier name → its module specifier (`@keystrokehq/gmail/actions`, `../actions/x`). */
+function collectImportsBySymbol(sourceFile) {
+	const bySymbol = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const specifier = statement.moduleSpecifier.text;
+		const clause = statement.importClause;
+		if (!clause) continue;
+		if (clause.name) bySymbol.set(clause.name.text, specifier);
+		if (clause.namedBindings) {
+			if (ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) bySymbol.set(element.name.text, specifier);
+			else if (ts.isNamespaceImport(clause.namedBindings)) bySymbol.set(clause.namedBindings.name.text, specifier);
+		}
+	}
+	return bySymbol;
+}
+/**
+* Durable steps come from either an integration package (`@keystrokehq/<app>/...`)
+* or the project's own actions/agents (imported by relative path). Third-party
+* packages (drizzle `db.run()`, etc.) use bare, non-`@keystrokehq` specifiers, so
+* excluding those avoids false positives while still catching real project steps.
+*/
+function isStepBearingSpecifier(specifier) {
+	if (!specifier) return false;
+	return specifier.startsWith("@keystrokehq/") || specifier.startsWith(".");
+}
+/** Whether `call` is the object of a `.scope(...)`/`.__site(...)` chain (an inner link). */
+function isChainedInnerCall(call) {
+	const parent = call.parent;
+	return ts.isPropertyAccessExpression(parent) && (parent.name.text === "scope" || parent.name.text === "__site") && parent.expression === call;
+}
+function forEachDurableRoot(sourceFile, ctxParamName, visit) {
+	const walk = (node) => {
+		if (ts.isCallExpression(node) && classifyCall(node, ctxParamName) && !isChainedInnerCall(node)) visit(node);
+		ts.forEachChild(node, walk);
+	};
+	walk(sourceFile);
+}
+function isFunctionLike(node) {
+	return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node);
+}
+/** Durable step calls in a file that is not a workflow — invisible + un-injected. */
+function crossFileStepDiagnostics(sourceFile, fileName) {
+	const importsBySymbol = collectImportsBySymbol(sourceFile);
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	forEachDurableRoot(sourceFile, void 0, (call) => {
+		const info = classifyCall(call, void 0);
+		if (!info) return;
+		if (!(info.callKind === "llm" || (info.callKind === "workflow-step" || info.callKind === "agent") && info.importName !== void 0 && isStepBearingSpecifier(importsBySymbol.get(info.importName)))) return;
+		const { line, column } = lineColumn(sourceFile, call);
+		const dedupe = `${line}:${column}`;
+		if (seen.has(dedupe)) return;
+		seen.add(dedupe);
+		out.push({
+			severity: "error",
+			code: "cross-file-step",
+			fileName,
+			line,
+			column,
+			message: `Durable step call \`${snippet(sourceFile, call)}\` is outside a workflow file. Steps only run and render on the canvas when they live in a \`defineWorkflow\` file (its \`run\` body or a same-file helper). This step is invisible to the canvas and cannot be attributed to runs. Move it into the workflow, or keep this module pure (return data; let the workflow call the step).`
+		});
+	});
+	return out;
+}
+/** Durable step calls nested as an argument to another call — the inner step is dropped. */
+function nestedStepArgDiagnostics(sourceFile, fileName, ctxParamName) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	forEachDurableRoot(sourceFile, ctxParamName, (call) => {
+		let node = call;
+		let parent = node.parent;
+		while (parent && !ts.isSourceFile(parent)) {
+			if (isFunctionLike(parent)) return;
+			if (ts.isCallExpression(parent) && parent.arguments.includes(node)) {
+				if (asPromiseAll(parent)) return;
+				const { line, column } = lineColumn(sourceFile, call);
+				const dedupe = `${line}:${column}`;
+				if (!seen.has(dedupe)) {
+					seen.add(dedupe);
+					out.push({
+						severity: "error",
+						code: "nested-step-arg",
+						fileName,
+						line,
+						column,
+						message: `Durable step call \`${snippet(sourceFile, call)}\` is nested as an argument to \`${snippet(sourceFile, parent.expression)}(…)\`. The nested step is dropped from the canvas (and un-attributable in runs). Assign it to a variable first, then pass the variable: \`const r = await step.run(…); other.run({ x: r });\`.`
+					});
+				}
+				return;
+			}
+			if (ts.isStatement(parent)) return;
+			node = parent;
+			parent = parent.parent;
+		}
+	});
+	return out;
+}
+/** Spread / computed keys in a step input object — silently missing from the inspector. */
+function stepInputSpreadDiagnostics(sourceFile, fileName, ctxParamName) {
+	const out = [];
+	forEachDurableRoot(sourceFile, ctxParamName, (call) => {
+		const arg = extractStepInputArg(call);
+		if (!arg || !ts.isObjectLiteralExpression(arg)) return;
+		for (const prop of arg.properties) {
+			const isSpread = ts.isSpreadAssignment(prop);
+			const isComputed = ts.isPropertyAssignment(prop) && ts.isComputedPropertyName(prop.name);
+			if (!isSpread && !isComputed) continue;
+			const { line, column } = lineColumn(sourceFile, prop);
+			out.push({
+				severity: "warning",
+				code: "step-input-spread",
+				fileName,
+				line,
+				column,
+				message: `${isSpread ? "Spread" : "Computed-key"} property \`${snippet(sourceFile, prop)}\` in a step input isn't shown in the step inspector. List the fields explicitly so each input renders as a value chip.`
+			});
+		}
+	});
+	return out;
+}
+function opaqueCodeBlockReason(label, shared) {
+	if (/\bPromise\.(race|allSettled|any)\b/.test(label)) return "Promise.race/allSettled/any isn't modeled as branches; it renders opaque.";
+	if (/\bPromise\.all\b/.test(label)) return "Promise.all over a computed array (e.g. `.map(...)`) can't be shown as parallel branches. Pass an array literal of explicit step calls, or use a for-of loop.";
+	if (/\.(map|forEach|filter|reduce|flatMap)\s*\(/.test(label)) return "Array-method iteration (`.map`/`.filter`/`.forEach`) containing steps renders as one opaque block. Use a for-of loop to render an explicit loop.";
+	const helperMatch = label.match(/(?:await\s+)?([A-Za-z0-9_$]+)\s*\(/);
+	if (helperMatch && shared.has(helperMatch[1])) return `Helper \`${helperMatch[1]}\` is called from more than one site, so each call renders as an opaque block (its steps share one id and can't be shown individually). Inline it, or call the steps directly in \`run()\`.`;
+	return "This construct is outside the supported grammar and renders as an opaque block; the steps inside it aren't shown individually.";
+}
+/** One warning per opaque code-block the producer emits, with an explicit reason. */
+function opaqueCodeBlockDiagnostics(sourceFile, located, fileName, shared) {
+	let graph;
+	try {
+		graph = buildGraph(sourceFile, located);
+	} catch {
+		return [];
+	}
+	return graph.nodes.filter((node) => node.nodeType === "code-block").map((node) => {
+		const label = node.data.label ?? "";
+		return {
+			severity: "warning",
+			code: "opaque-code-block",
+			fileName,
+			message: `Renders as an opaque code block: \`${label}\`. ${opaqueCodeBlockReason(label, shared)}`
+		};
+	});
+}
+/**
+* Deterministic deploy-time producer: parse a workflow's TypeScript source and
+* emit its control-flow skeleton (entry → steps/branches/loops → exit) as a
+* {@link WorkflowCanvasGraph}.
+*/
+function buildWorkflowCanvasGraph(source, options = {}) {
+	const sourceFile = ts.createSourceFile(options.fileName ?? "workflow.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const located = locateWorkflow(sourceFile);
+	if (!located) return null;
+	return buildGraph(sourceFile, located, { resolveSlug: options.resolveSlug });
+}
 const replaceEditSchema = object({
 	oldText: string().describe("Exact text to replace. Must be unique in the file and must not overlap other edits in this call."),
 	newText: string().describe("Replacement text")
@@ -1669,25 +3191,49 @@ const workflows = pgTable("workflows", {
 	id: text("id").primaryKey(),
 	projectId: text("project_id").notNull(),
 	slug: text("slug").notNull(),
-	name: text("name"),
-	description: text("description"),
+	name: text("name").notNull(),
+	description: text("description").notNull(),
 	moduleFile: text("module_file").notNull(),
 	subscribable: integer("subscribable").notNull(),
 	registeredAt: timestamp("registered_at", { withTimezone: true }).notNull(),
 	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
-	deletedAt: timestamp("deleted_at", { withTimezone: true })
+	deletedAt: timestamp("deleted_at", { withTimezone: true }),
+	runInputValues: jsonb("run_input_values").$type(),
+	canvasAnnotationsJson: jsonb("canvas_annotations_json").$type(),
+	canvasAnnotationsHash: text("canvas_annotations_hash"),
+	canvasAnnotationsModel: text("canvas_annotations_model"),
+	canvasAnnotationsStatus: text("canvas_annotations_status").$type().notNull().default("idle"),
+	canvasAnnotationsGeneratedAt: timestamp("canvas_annotations_generated_at", { withTimezone: true }),
+	overviewSummary: text("overview_summary"),
+	overviewPhasesJson: jsonb("overview_phases_json").$type(),
+	overviewHash: text("overview_hash"),
+	overviewModel: text("overview_model"),
+	overviewStatus: text("overview_status").$type().notNull().default("idle"),
+	overviewGeneratedAt: timestamp("overview_generated_at", { withTimezone: true })
 }, (table) => [uniqueIndex("workflows_project_id_slug_idx").on(table.projectId, table.slug)]);
 const workflowsSqlite = sqliteTable("workflows", {
 	id: text$1("id").primaryKey(),
 	projectId: text$1("project_id").notNull(),
 	slug: text$1("slug").notNull(),
-	name: text$1("name"),
-	description: text$1("description"),
+	name: text$1("name").notNull(),
+	description: text$1("description").notNull(),
 	moduleFile: text$1("module_file").notNull(),
 	subscribable: integer$1("subscribable", { mode: "boolean" }).notNull(),
 	registeredAt: integer$1("registered_at", { mode: "timestamp_ms" }).notNull(),
 	updatedAt: integer$1("updated_at", { mode: "timestamp_ms" }).notNull(),
-	deletedAt: integer$1("deleted_at", { mode: "timestamp_ms" })
+	deletedAt: integer$1("deleted_at", { mode: "timestamp_ms" }),
+	runInputValues: text$1("run_input_values", { mode: "json" }).$type(),
+	canvasAnnotationsJson: text$1("canvas_annotations_json", { mode: "json" }).$type(),
+	canvasAnnotationsHash: text$1("canvas_annotations_hash"),
+	canvasAnnotationsModel: text$1("canvas_annotations_model"),
+	canvasAnnotationsStatus: text$1("canvas_annotations_status").$type().notNull().default("idle"),
+	canvasAnnotationsGeneratedAt: integer$1("canvas_annotations_generated_at", { mode: "timestamp_ms" }),
+	overviewSummary: text$1("overview_summary"),
+	overviewPhasesJson: text$1("overview_phases_json", { mode: "json" }).$type(),
+	overviewHash: text$1("overview_hash"),
+	overviewModel: text$1("overview_model"),
+	overviewStatus: text$1("overview_status").$type().notNull().default("idle"),
+	overviewGeneratedAt: integer$1("overview_generated_at", { mode: "timestamp_ms" })
 }, (table) => [uniqueIndex$1("workflows_project_id_slug_idx").on(table.projectId, table.slug)]);
 const resourceActivity = pgTable("resource_activity", {
 	id: text("id").primaryKey(),
@@ -1831,15 +3377,29 @@ object({
 //#endregion
 //#region ../../packages/action/dist/index.mjs
 const zodSchema$3 = custom((v) => v instanceof ZodType, "must be a Zod schema");
-object({
+/** Runtime validation for an unbranded action definition. */
+const actionCoreSchema = object({
 	slug: string().trim().min(1),
-	name: string().optional(),
-	description: string().optional(),
+	name: requiredDisplayTextSchema,
+	description: requiredDisplayTextSchema,
 	input: zodSchema$3,
 	output: zodSchema$3,
 	credentials: array(credentialInputSchema).optional(),
 	run: _function()
 });
+const ACTION$1 = Symbol.for("keystroke.action");
+/**
+* Validates brand + shape via `actionCoreSchema` so discovery and guards reject
+* malformed definitions.
+*/
+function isAction(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!(ACTION$1 in value) || value[ACTION$1] !== true) return false;
+	return actionCoreSchema.safeParse(value).success;
+}
+function getActionCredentialRequirements(action) {
+	return action.credentials;
+}
 new AsyncLocalStorage();
 new AsyncLocalStorage();
 new AbortController().signal;
@@ -18982,8 +20542,8 @@ const zodSchema$2 = custom((v) => v instanceof ZodType, "must be a Zod schema");
 /** Runtime validation for an unbranded workflow definition. */
 const workflowCoreSchema = object({
 	slug: string().trim().min(1),
-	name: string().optional(),
-	description: string().optional(),
+	name: requiredDisplayTextSchema,
+	description: requiredDisplayTextSchema,
 	subscription: object({ mode: _enum(["system", "subscribable"]).optional() }).optional(),
 	input: zodSchema$2,
 	output: zodSchema$2,
@@ -18999,6 +20559,7 @@ function isWorkflow(value) {
 	if (!(WORKFLOW$1 in value) || value[WORKFLOW$1] !== true) return false;
 	return workflowCoreSchema.safeParse(value).success;
 }
+new AsyncLocalStorage();
 const storage = new AsyncLocalStorage();
 registerWorkflowRunGetter(() => {
 	const store = storage.getStore();
@@ -19808,11 +21369,12 @@ function normalizeLegacySlugFields$1(value) {
 	return next;
 }
 const slugField$1 = string().trim().min(1);
-const optionalTextField$1 = string().optional();
+const requiredTextField$1 = string().trim().min(1);
+const optionalTextField$1 = string().trim().min(1).optional();
 const baseSourceShape$1 = {
 	slug: slugField$1,
-	name: optionalTextField$1,
-	description: optionalTextField$1,
+	name: requiredTextField$1,
+	description: requiredTextField$1,
 	attach: _function()
 };
 /** Runtime validation for a trigger source (webhook | cron | poll). */
@@ -19887,11 +21449,9 @@ function attachmentSlugFromRecord(attachment) {
 	return slug;
 }
 function triggerMetaFromAttachment(attachment) {
-	const name = attachment.name ?? attachment.source.name;
-	const description = attachment.description ?? attachment.source.description;
 	return {
-		...name !== void 0 ? { name } : {},
-		...description !== void 0 ? { description } : {}
+		name: attachment.name ?? attachment.source.name,
+		description: attachment.description ?? attachment.source.description
 	};
 }
 /**
@@ -19920,6 +21480,8 @@ function isManifestAgent(value) {
 }
 function validateManifestAgent(value, filePath) {
 	if (!isManifestAgent(value)) throw new Error(`${filePath} must default-export defineAgent(...)`);
+	if (!value.name?.trim()) throw new Error(`${filePath} agent must include a non-empty name`);
+	if (!value.description?.trim()) throw new Error(`${filePath} agent must include a non-empty description`);
 	return value;
 }
 function normalizeWebhookEndpoint(endpoint) {
@@ -19978,6 +21540,30 @@ function actionSlug(tool) {
 	const record = tool;
 	return typeof record.slug === "string" ? record.slug : void 0;
 }
+function toolCredentialRequirements(tool) {
+	const record = tool;
+	if (isManifestAction(tool)) return getManifestActionCredentialRequirements(tool);
+	return "credentials" in record && Array.isArray(record.credentials) ? record.credentials : void 0;
+}
+/**
+* Credential requirements per tool slug — the agent's credential consumer key.
+* Powers the workflow-canvas credential overlay for agent nodes (which resolve
+* per tool, not per call site).
+*/
+function collectAgentToolRequirements(agent) {
+	const byTool = {};
+	for (const tool of agent.tools ?? []) {
+		const slug = actionSlug(tool);
+		const requirements = toolCredentialRequirements(tool);
+		if (!slug || !requirements?.length) continue;
+		byTool[slug] = normalizeCredentialList(requirements).map((requirement) => ({
+			key: requirement.key,
+			kind: requirement.kind,
+			...requirement.scope ? { scope: requirement.scope } : {}
+		}));
+	}
+	return byTool;
+}
 /** App-kind slugs required by the agent's tools (same as `credential_instances.app_slug`). */
 function collectAgentAppSlugs(agent) {
 	const slugs = /* @__PURE__ */ new Set();
@@ -20002,6 +21588,7 @@ function countAgentCredentials(agent) {
 }
 /** Single source of truth for the `kind: "agent"` route-manifest entry shape. */
 function agentManifestEntry(agent, options) {
+	const toolRequirements = collectAgentToolRequirements(agent);
 	return {
 		kind: "agent",
 		slug: agent.slug,
@@ -20013,7 +21600,69 @@ function agentManifestEntry(agent, options) {
 		toolCount: agent.tools?.length ?? 0,
 		credentialCount: countAgentCredentials(agent),
 		appSlugs: collectAgentAppSlugs(agent),
-		toolSlugs: collectAgentToolSlugs(agent)
+		toolSlugs: collectAgentToolSlugs(agent),
+		...Object.keys(toolRequirements).length ? { toolRequirements } : {}
+	};
+}
+function resolveActionFromModule(mod, filePath) {
+	if (isAction(mod.default)) return mod.default;
+	const named = Object.values(mod).filter(isAction);
+	if (named.length === 1) return named[0];
+	if (named.length > 1) throw new Error(`${filePath} exports multiple actions; use one action per file`);
+	throw new Error(`${filePath} must export defineAction(...) (default or single named export)`);
+}
+async function importActionDefinition(filePath, options) {
+	const appRoot = resolveAppRoot(filePath);
+	const href = pathToFileURL(filePath).href;
+	return runWithAppRoot(appRoot, async () => {
+		return resolveActionFromModule(await (options?.reload ? import(`${href}?keystroke=${Date.now()}`) : import(href)), filePath);
+	});
+}
+async function discoverActions(actionsDir, options) {
+	const files = await discoverModuleFileEntries(actionsDir, {
+		nestedEntry: "action",
+		duplicateLabel: "action module file"
+	});
+	const actions = [];
+	for (const { filePath, moduleFile } of files) {
+		const definition = await importActionDefinition(filePath, options);
+		const key = definition.slug.trim();
+		if (!key) throw new Error(`${filePath} action must define a non-empty slug`);
+		actions.push({
+			key,
+			filePath,
+			moduleFile,
+			definition
+		});
+	}
+	return actions;
+}
+/**
+* Reduce a definition's `.credentials` list to the deploy-time summaries the
+* workflow-canvas credential overlay needs (`key` / `kind` / pinned `scope`).
+* The Zod schema is intentionally dropped — only the resolution metadata ships.
+*/
+function credentialRequirementSummaries(list) {
+	if (!list?.length) return [];
+	return normalizeCredentialList(list).map((requirement) => ({
+		key: requirement.key,
+		kind: requirement.kind,
+		...requirement.scope ? { scope: requirement.scope } : {}
+	}));
+}
+/** Single source of truth for the `kind: "action"` route-manifest entry shape. */
+function actionManifestEntry(action, options) {
+	const requirements = credentialRequirementSummaries(getActionCredentialRequirements(action));
+	return {
+		kind: "action",
+		slug: action.slug,
+		moduleFile: options.moduleFile,
+		name: action.name,
+		description: action.description,
+		...options.appSlug ? { appSlug: options.appSlug } : {},
+		inputSchema: options.inputSchema,
+		outputSchema: options.outputSchema,
+		...requirements.length ? { requirements } : {}
 	};
 }
 function pollGroupId(discovered) {
@@ -20153,7 +21802,7 @@ function validateProjectModules(input) {
 	]);
 }
 const SKIP_DIRS = new Set([".git", "node_modules"]);
-function toPosix$1(path) {
+function toPosix$2(path) {
 	return path.split(sep).join("/");
 }
 function parseSkillFrontmatter(raw) {
@@ -20174,23 +21823,26 @@ function parseSkillFrontmatter(raw) {
 	return out;
 }
 function walkSkillFiles(root, dir, out) {
-	for (const name of readdirSync(dir).sort()) {
-		const absolute = join(dir, name);
+	for (const entry of readdirSync(dir).sort()) {
+		const absolute = join(dir, entry);
 		const stats = statSync(absolute);
 		if (stats.isDirectory()) {
-			if (SKIP_DIRS.has(name)) continue;
+			if (SKIP_DIRS.has(entry)) continue;
 			walkSkillFiles(root, absolute, out);
 			continue;
 		}
-		if (!stats.isFile() || name !== "SKILL.md") continue;
-		const moduleFile = toPosix$1(relative(root, absolute));
-		const slug = toPosix$1(relative(join(root, "src", "skills"), absolute)).replace(/\/?SKILL\.md$/, "");
+		if (!stats.isFile() || entry !== "SKILL.md") continue;
+		const moduleFile = toPosix$2(relative(root, absolute));
+		const slug = toPosix$2(relative(join(root, "src", "skills"), absolute)).replace(/\/?SKILL\.md$/, "");
 		if (!slug) continue;
 		const frontmatter = parseSkillFrontmatter(readFileSync(absolute, "utf8"));
+		const name = frontmatter.name?.trim();
+		const description = frontmatter.description?.trim();
+		if (!name || !description) throw new Error(`${moduleFile} skill frontmatter must include non-empty name and description`);
 		out.push({
 			slug,
-			name: frontmatter.name,
-			description: frontmatter.description,
+			name,
+			description,
 			moduleFile
 		});
 	}
@@ -20227,7 +21879,21 @@ function serializeRouteManifest(manifest) {
 				toolCount: entry.toolCount,
 				credentialCount: entry.credentialCount,
 				appSlugs: entry.appSlugs,
-				toolSlugs: entry.toolSlugs
+				toolSlugs: entry.toolSlugs,
+				...entry.toolRequirements ? { toolRequirements: entry.toolRequirements } : {}
+			});
+			break;
+		case "action":
+			entries.push({
+				kind: entry.kind,
+				slug: entry.slug,
+				moduleFile: entry.moduleFile,
+				...entry.appSlug !== void 0 ? { appSlug: entry.appSlug } : {},
+				name: entry.name,
+				description: entry.description,
+				inputSchema: entry.inputSchema,
+				outputSchema: entry.outputSchema,
+				...entry.requirements ? { requirements: entry.requirements } : {}
 			});
 			break;
 		case "workflow":
@@ -20238,7 +21904,12 @@ function serializeRouteManifest(manifest) {
 				description: entry.description,
 				subscribable: entry.subscribable,
 				moduleFile: entry.moduleFile,
-				requestSchema: schemaToJson(entry.request)
+				requestSchema: schemaToJson(entry.request),
+				responseSchema: schemaToJson(entry.response),
+				...entry.flowGraph ? {
+					flowGraph: entry.flowGraph,
+					flowGraphSourceHash: entry.flowGraphSourceHash
+				} : {}
 			});
 			break;
 		case "trigger-webhook":
@@ -20247,6 +21918,7 @@ function serializeRouteManifest(manifest) {
 				endpoint: entry.endpoint,
 				attachmentIds: entry.attachmentIds,
 				moduleFile: entry.moduleFile,
+				...entry.sourceHash ? { sourceHash: entry.sourceHash } : {},
 				attachmentSchemas: Object.fromEntries(Object.entries(entry.attachmentSchemas).map(([attachmentSlug, schemas]) => [attachmentSlug, {
 					requestSchema: schemaToJson(schemas.request),
 					...schemas.filter ? { filterSchema: schemaToJson(schemas.filter) } : {}
@@ -20260,9 +21932,10 @@ function serializeRouteManifest(manifest) {
 				attachmentId: entry.attachmentId,
 				attachmentIds: entry.attachmentIds,
 				moduleFile: entry.moduleFile,
+				...entry.sourceHash ? { sourceHash: entry.sourceHash } : {},
 				schedule: entry.schedule,
-				...entry.name !== void 0 ? { name: entry.name } : {},
-				...entry.description !== void 0 ? { description: entry.description } : {}
+				name: entry.name,
+				description: entry.description
 			});
 			break;
 		case "trigger-poll-group":
@@ -20313,6 +21986,8 @@ function isManifestWorkflow(value) {
 }
 function validateManifestWorkflow(value, filePath) {
 	if (!isManifestWorkflow(value)) throw new Error(`${filePath} must default-export defineWorkflow(...)`);
+	if (!value.name?.trim()) throw new Error(`${filePath} workflow must include a non-empty name`);
+	if (!value.description?.trim()) throw new Error(`${filePath} workflow must include a non-empty description`);
 	return value;
 }
 const TRIGGER_ATTACHMENT = Symbol.for("keystroke.triggerAttachment");
@@ -20331,11 +22006,12 @@ function normalizeLegacySlugFields(value) {
 	return next;
 }
 const slugField = string().trim().min(1);
-const optionalTextField = string().optional();
+const requiredTextField = string().trim().min(1);
+const optionalTextField = string().trim().min(1).optional();
 const baseSourceShape = {
 	slug: slugField,
-	name: optionalTextField,
-	description: optionalTextField,
+	name: requiredTextField,
+	description: requiredTextField,
 	attach: _function()
 };
 const triggerSourceSchema = preprocess(normalizeLegacySlugFields, discriminatedUnion("kind", [
@@ -20501,11 +22177,181 @@ async function discoverWorkflows(workflowsDir, options) {
 	}
 	return workflows;
 }
+function toPosix$1(path) {
+	return path.split("\\").join("/");
+}
+function buildSymbolImportMap(source, fileName) {
+	const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const map = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const specifier = statement.moduleSpecifier.text;
+		const clause = statement.importClause;
+		if (!clause) continue;
+		if (clause.name) map.set(clause.name.text, {
+			specifier,
+			exportName: "default"
+		});
+		if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) {
+			const exportName = (element.propertyName ?? element.name).text;
+			map.set(element.name.text, {
+				specifier,
+				exportName
+			});
+		}
+	}
+	return map;
+}
+function resolveRelativeModuleFile(projectRoot, workflowModuleFile, specifier) {
+	if (!specifier.startsWith(".")) return;
+	const workflowDir = dirname(join(projectRoot, workflowModuleFile));
+	const candidates = [
+		join(workflowDir, specifier),
+		`${join(workflowDir, specifier)}.ts`,
+		join(workflowDir, `${specifier}.ts`),
+		join(workflowDir, specifier, "index.ts")
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return toPosix$1(relative(projectRoot, candidate));
+}
+function toResolvedStepSlug(entry) {
+	return {
+		slug: entry.slug,
+		name: entry.name,
+		description: entry.description
+	};
+}
+/** Build a deploy-time slug resolver from a workflow file's imports + definition registry. */
+function createResolveSlugFn(projectRoot, workflowModuleFile, workflowSource, registryByModuleFile, integrationRegistry) {
+	const importMap = buildSymbolImportMap(workflowSource, workflowModuleFile);
+	return (importName) => {
+		const imported = importMap.get(importName);
+		if (!imported) return;
+		const { specifier, exportName } = imported;
+		if (specifier.startsWith(".")) {
+			const moduleFile = resolveRelativeModuleFile(projectRoot, workflowModuleFile, specifier);
+			if (!moduleFile) return;
+			const entry = registryByModuleFile.get(moduleFile);
+			return entry ? toResolvedStepSlug(entry) : void 0;
+		}
+		const entry = integrationRegistry?.get(`${specifier}#${exportName}`);
+		return entry ? toResolvedStepSlug(entry) : void 0;
+	};
+}
+function buildSlugRegistry(entries) {
+	return new Map(entries.map((entry) => [entry.moduleFile, entry]));
+}
+/** The framework package — never treated as an integration action source. */
+const FRAMEWORK_PACKAGE = "@keystrokehq/keystroke";
+/**
+* Map an integration import specifier to its app slug.
+*
+* `@keystrokehq/slackbot/actions` → `slackbot`, `@keystrokehq/github` → `github`.
+* Returns `undefined` for the framework package and any non-`@keystrokehq` scope.
+*/
+function integrationAppSlugFromSpecifier(specifier) {
+	if (specifier === FRAMEWORK_PACKAGE || specifier.startsWith(`${FRAMEWORK_PACKAGE}/`)) return;
+	return /^@keystrokehq\/([^/]+)(?:\/.*)?$/.exec(specifier)?.[1];
+}
+/**
+* The integration action subpath convention (`@keystrokehq/<app>/actions`). We only
+* import these — the real authoring convention — to avoid loading whole packages.
+*/
+function isIntegrationActionsSpecifier(specifier) {
+	return /^@keystrokehq\/[^/]+\/actions$/.test(specifier) && specifier !== FRAMEWORK_PACKAGE;
+}
+/** Map each integration `/actions` specifier imported by a file to the exports it uses. */
+function collectIntegrationImports(source, fileName) {
+	const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const bySpecifier = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const specifier = statement.moduleSpecifier.text;
+		if (!isIntegrationActionsSpecifier(specifier)) continue;
+		const usage = bySpecifier.get(specifier) ?? {
+			names: /* @__PURE__ */ new Set(),
+			importsAll: false
+		};
+		const clause = statement.importClause;
+		if (clause?.name) usage.names.add("default");
+		const bindings = clause?.namedBindings;
+		if (bindings) if (ts.isNamespaceImport(bindings)) usage.importsAll = true;
+		else for (const element of bindings.elements) usage.names.add(element.propertyName?.text ?? element.name.text);
+		bySpecifier.set(specifier, usage);
+	}
+	return bySpecifier;
+}
+/**
+* Discover actions imported from integration packages (`@keystrokehq/<app>/actions`)
+* by the project's workflow/agent source files.
+*
+* Each `/actions` subpath is resolved from the project's `node_modules`, dynamically
+* imported, and its action exports enumerated. Best-effort: a missing or broken
+* integration package never fails the manifest build — it is logged and skipped.
+*/
+async function discoverIntegrationActions(projectRoot, sourceFiles, options) {
+	const usageBySpecifier = /* @__PURE__ */ new Map();
+	for (const sourceFile of sourceFiles) {
+		let source;
+		try {
+			source = readFileSync(join(projectRoot, sourceFile), "utf8");
+		} catch {
+			continue;
+		}
+		for (const [specifier, usage] of collectIntegrationImports(source, sourceFile)) {
+			const existing = usageBySpecifier.get(specifier) ?? {
+				names: /* @__PURE__ */ new Set(),
+				importsAll: false
+			};
+			for (const name of usage.names) existing.names.add(name);
+			existing.importsAll = existing.importsAll || usage.importsAll;
+			usageBySpecifier.set(specifier, existing);
+		}
+	}
+	const entries = [];
+	const registry = /* @__PURE__ */ new Map();
+	const seenSlugs = new Set(options?.existingSlugs);
+	const require = createRequire(join(projectRoot, "package.json"));
+	for (const [specifier, usage] of usageBySpecifier) {
+		const appSlug = integrationAppSlugFromSpecifier(specifier);
+		if (!appSlug) continue;
+		try {
+			const resolvedPath = require.resolve(specifier);
+			const href = pathToFileURL(resolvedPath).href;
+			const mod = await runWithAppRoot(resolveAppRoot(resolvedPath), async () => await import(href));
+			for (const [exportName, value] of Object.entries(mod)) {
+				if (!isAction(value)) continue;
+				if (!usage.importsAll && !usage.names.has(exportName)) continue;
+				const definition = value;
+				registry.set(`${specifier}#${exportName}`, {
+					slug: definition.slug,
+					name: definition.name,
+					description: definition.description
+				});
+				if (seenSlugs.has(definition.slug)) continue;
+				seenSlugs.add(definition.slug);
+				entries.push(actionManifestEntry(definition, {
+					moduleFile: specifier,
+					appSlug,
+					inputSchema: schemaToJson(definition.input),
+					outputSchema: schemaToJson(definition.output)
+				}));
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`[manifest] skipped integration actions for ${specifier}: ${message}`);
+		}
+	}
+	return {
+		entries,
+		registry
+	};
+}
 function resolveDistModuleDirs(projectRoot) {
 	const distBase = join(projectRoot, "dist");
 	if (!existsSync(distBase)) throw new Error(`Build output missing at ${distBase}. Run keystroke build before emitting the route manifest.`);
 	return {
 		agentsDir: join(distBase, "agents"),
+		actionsDir: join(distBase, "actions"),
 		workflowsDir: join(distBase, "workflows"),
 		triggersDir: join(distBase, "triggers")
 	};
@@ -20521,6 +22367,33 @@ function hashFileContents(absPath) {
 	}
 }
 /**
+* Run the deploy-time AST producer over a workflow's source file to attach its
+* control-flow skeleton + a content hash (for staleness). Best-effort: skips
+* when the resolved moduleFile is not a readable `.ts` source (e.g. dist-only
+* builds) or the source has no recognizable workflow, and never fails the build.
+*/
+function produceWorkflowFlowGraph(projectRoot, moduleFile, options) {
+	if (!moduleFile.endsWith(".ts")) return;
+	const absolute = join(projectRoot, moduleFile);
+	if (!existsSync(absolute)) return;
+	try {
+		const source = readFileSync(absolute, "utf8");
+		const flowGraph = buildWorkflowCanvasGraph(source, {
+			fileName: moduleFile,
+			resolveSlug: options?.slugRegistry ? createResolveSlugFn(projectRoot, moduleFile, source, options.slugRegistry, options.integrationRegistry) : void 0
+		});
+		if (!flowGraph) return;
+		return {
+			flowGraph,
+			flowGraphSourceHash: createHash("sha256").update(source).digest("hex")
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[manifest] skipped workflow flow graph for ${moduleFile}: ${message}`);
+		return;
+	}
+}
+/**
 * Resolve manifest moduleFile values to project-root-relative source paths.
 *
 * Discovery runs over compiled `dist/` modules, so the raw moduleFile is a
@@ -20581,6 +22454,7 @@ async function buildStoredRouteManifestForProject(projectRoot, options) {
 		const dirs = resolveDistModuleDirs(projectRoot);
 		const sourcePaths = new SourceModuleFileResolver(projectRoot);
 		const manifest = [{ kind: "health" }];
+		const slugRegistryEntries = [];
 		const agentEntries = await discoverAgentEntries(dirs.agentsDir, reload);
 		const workflows = await discoverWorkflows(dirs.workflowsDir, reload);
 		const attachments = await discoverTriggerAttachments(dirs.triggersDir, reload);
@@ -20594,22 +22468,72 @@ async function buildStoredRouteManifestForProject(projectRoot, options) {
 			agent: await importAgentDefinition(entry.filePath, reload)
 		})));
 		await validateAgentModelIds(loadedAgents.map(({ agent }) => agent.model));
+		const resolvedAgents = [];
 		for (const { entry, agent } of loadedAgents) {
 			const moduleFile = await sourcePaths.resolve("agents", "agent", dirs.agentsDir, entry.filePath);
-			manifest.push(agentManifestEntry(agent, { moduleFile }));
+			resolvedAgents.push({
+				agent,
+				moduleFile
+			});
+			slugRegistryEntries.push({
+				slug: agent.slug,
+				name: agent.name,
+				description: agent.description,
+				moduleFile
+			});
+		}
+		const actions = await discoverActions(dirs.actionsDir, reload);
+		const resolvedActions = [];
+		for (const action of actions) {
+			const moduleFile = await sourcePaths.resolve("actions", "action", dirs.actionsDir, action.filePath);
+			resolvedActions.push({
+				action,
+				moduleFile
+			});
+			slugRegistryEntries.push({
+				slug: action.definition.slug,
+				name: action.definition.name,
+				description: action.definition.description,
+				moduleFile
+			});
 		}
+		const resolvedWorkflows = [];
 		for (const workflow of workflows) {
 			const moduleFile = await sourcePaths.resolve("workflows", "workflow", dirs.workflowsDir, workflow.filePath);
-			manifest.push({
-				kind: "workflow",
+			resolvedWorkflows.push({
+				workflow,
+				moduleFile
+			});
+			slugRegistryEntries.push({
 				slug: workflow.definition.slug,
 				name: workflow.definition.name,
 				description: workflow.definition.description,
-				subscribable: workflow.definition.subscription?.mode === "subscribable",
-				moduleFile,
-				request: workflow.definition.input
+				moduleFile
 			});
 		}
+		const slugRegistry = buildSlugRegistry(slugRegistryEntries);
+		const integration = await discoverIntegrationActions(projectRoot, [...resolvedWorkflows.map(({ moduleFile }) => moduleFile), ...resolvedAgents.map(({ moduleFile }) => moduleFile)], { existingSlugs: new Set(slugRegistryEntries.map((entry) => entry.slug)) });
+		for (const { agent, moduleFile } of resolvedAgents) manifest.push(agentManifestEntry(agent, { moduleFile }));
+		for (const { action, moduleFile } of resolvedActions) manifest.push(actionManifestEntry(action.definition, {
+			moduleFile,
+			inputSchema: schemaToJson(action.definition.input),
+			outputSchema: schemaToJson(action.definition.output)
+		}));
+		for (const entry of integration.entries) manifest.push(entry);
+		for (const { workflow, moduleFile } of resolvedWorkflows) manifest.push({
+			kind: "workflow",
+			slug: workflow.definition.slug,
+			name: workflow.definition.name,
+			description: workflow.definition.description,
+			subscribable: workflow.definition.subscription?.mode === "subscribable",
+			moduleFile,
+			request: workflow.definition.input,
+			response: workflow.definition.output,
+			...produceWorkflowFlowGraph(projectRoot, moduleFile, {
+				slugRegistry,
+				integrationRegistry: integration.registry
+			})
+		});
 		const discoveredBySlug = new Map(attachments.map((attachment) => [attachment.slug, attachment]));
 		const cronByTriggerSlug = /* @__PURE__ */ new Map();
 		const pollByGroupId = /* @__PURE__ */ new Map();
@@ -20674,9 +22598,9 @@ async function buildStoredRouteManifestForProject(projectRoot, options) {
 				discovered,
 				options: { attachmentSlug: discovered.slug }
 			}];
-			const attachmentMeta = Object.fromEntries(bindings.flatMap(({ discovered: row }) => {
+			const attachmentMeta = Object.fromEntries(bindings.map(({ discovered: row }) => {
 				const meta = triggerMetaFromAttachment(row.attachment);
-				return Object.keys(meta).length > 0 ? [[row.slug, meta]] : [];
+				return [row.slug, meta];
 			}));
 			manifest.push({
 				kind: "trigger-webhook",
@@ -20686,16 +22610,16 @@ async function buildStoredRouteManifestForProject(projectRoot, options) {
 				...sourceHash ? { sourceHash } : {},
 				request: webhookMatchSchemaForBindings(bindings),
 				attachmentSchemas: webhookManifestAttachmentSchemasFromBindings(bindings),
-				...Object.keys(attachmentMeta).length > 0 ? { attachmentMeta } : {},
+				attachmentMeta,
 				response: PromptResponseSchema
 			});
 		}
-		return buildStoredRouteManifestFromContext({
+		return parseStoredRouteManifest(buildStoredRouteManifestFromContext({
 			manifest,
 			options: {},
 			projectRoot,
 			skills: discoverSkillManifestEntries(projectRoot)
-		});
+		}));
 	} finally {
 		if (previousRoot === void 0) delete process.env.KEYSTROKE_ROOT;
 		else process.env.KEYSTROKE_ROOT = previousRoot;
@@ -20706,6 +22630,6 @@ async function emitStoredRouteManifestForProject(projectRoot) {
 	persistStoredRouteManifest(projectRoot, await buildStoredRouteManifestForProject(projectRoot));
 }
 //#endregion
-export { validatePollGroups as A, attachmentSlugFromRecord as B, pollRouteFromSourceSlug as C, validateAttachmentTargets as D, toStoredRouteManifest as E, webhookManifestAttachmentSchemasFromBindings as F, readKeystrokeIgnoreDirective as G, discoverEntries as H, webhookMatchSchemaForBindings as I, walkTypeScriptFiles as J, shouldSkipKeystrokeModuleFile as K, webhookRouteFromEndpoint as L, validateTriggerAttachments as M, validateUniqueAttachmentSlugs as N, validateImportedTriggerAttachment as O, validateUniqueTriggerSourceSlugs as P, workflowKeyForAttachment as R, pollGroupRouteFromId as S, serializeRouteManifest as T, discoverModuleFileEntries as U, packAssetDirs as V, entryIdFromFile as W, importAgentDefinition as _, buildStoredRouteManifestForProject as a, persistStoredRouteManifest as b, collectAgentAppSlugs as c, discoverAgentEntries as d, discoverSkillManifestEntries as f, emitStoredRouteManifestForProject as g, discoverWorkflows as h, buildPollGroups as i, validateProjectModules as j, validateImportedWorkflowDefinition as k, collectAgentToolSlugs as l, discoverWorkflowEntries as m, agentManifestEntry as n, buildStoredRouteManifestFromContext as o, discoverTriggerAttachments as p, validateUniqueModuleKeys as q, agentRouteFromKey as r, buildWebhookBindingsByRoute as s, agentKeyForAttachment as t, countAgentCredentials as u, importTriggerAttachments as v, schemaToJson as w, pollGroupId as x, importWorkflowDefinition as y, workflowRouteFromKey as z };
+export { validatePollGroups as A, attachmentSlugFromRecord as B, pollRouteFromSourceSlug as C, validateAttachmentTargets as D, toStoredRouteManifest as E, webhookManifestAttachmentSchemasFromBindings as F, packAssetDirs as G, computeCallSiteIds as H, webhookMatchSchemaForBindings as I, entryIdFromFile as J, discoverEntries as K, webhookRouteFromEndpoint as L, validateTriggerAttachments as M, validateUniqueAttachmentSlugs as N, validateImportedTriggerAttachment as O, validateUniqueTriggerSourceSlugs as P, walkTypeScriptFiles as Q, workflowKeyForAttachment as R, pollGroupRouteFromId as S, serializeRouteManifest as T, diagnoseWorkflowSource as U, classifyCall as V, locateWorkflow as W, shouldSkipKeystrokeModuleFile as X, readKeystrokeIgnoreDirective as Y, validateUniqueModuleKeys as Z, importAgentDefinition as _, buildStoredRouteManifestForProject as a, persistStoredRouteManifest as b, collectAgentAppSlugs as c, discoverAgentEntries as d, discoverSkillManifestEntries as f, emitStoredRouteManifestForProject as g, discoverWorkflows as h, buildPollGroups as i, validateProjectModules as j, validateImportedWorkflowDefinition as k, collectAgentToolSlugs as l, discoverWorkflowEntries as m, agentManifestEntry as n, buildStoredRouteManifestFromContext as o, discoverTriggerAttachments as p, discoverModuleFileEntries as q, agentRouteFromKey as r, buildWebhookBindingsByRoute as s, agentKeyForAttachment as t, countAgentCredentials as u, importTriggerAttachments as v, schemaToJson as w, pollGroupId as x, importWorkflowDefinition as y, workflowRouteFromKey as z };
 
-//# sourceMappingURL=dist-C1QOfWMM.mjs.map
+//# sourceMappingURL=dist-C0_71CpG.mjs.map