@runtypelabs/sdk 10.8.0 → 10.9.0

package/dist/index.cjs

@@ -2114,7 +2114,7 @@ function asRecord(value) {
 * Reading the structured fields FIRST is what makes the typed alias errors fire
 * for `createClient()` and the CLI, not just for `Runtype.agents`.
 */
-function parseRequestError$6(err) {
+function parseRequestError$7(err) {
 	if (!(err instanceof Error)) return {
 		status: null,
 		body: null
@@ -2149,7 +2149,7 @@ function asString$1(value, fallback) {
 * failure exactly as the transport threw it.
 */
 function toAliasError(err, agentId, alias) {
-	const { status, body } = parseRequestError$6(err);
+	const { status, body } = parseRequestError$7(err);
 	if (status === null) return null;
 	const error = body && typeof body.error === "string" ? body.error : void 0;
 	if (status === 412 && body && typeof body.expected === "number") return new AgentAliasRevisionMismatchError({
@@ -2339,6 +2339,174 @@ var AgentDeploymentsNamespace = class {
 	}
 };
 //#endregion
+//#region src/content-hash.ts
+/**
+* Canonical content-hash primitives shared by the `*.ensure()` config-as-code
+* surfaces (products, tools, skills, surfaces, products-ensure-fpo). Each of
+* those modules computes a SHA-256 content hash for its hash-first `/ensure`
+* wire protocol (see docs/adr/0003-agent-config-as-code-ensure.md) — the hash
+* output for any given definition is a WIRE CONTRACT with the server, so this
+* module must stay dependency-free (the SDK is published to npm and must not
+* import `@runtypelabs/shared`, a private package) and must not change its
+* normalization behavior without a matching server-side change.
+*
+* `isPlainObject` and `normalizeValue` here are mirrored from
+* `packages/shared/src/utils/*-content-hash.ts`. `normalizeValue` sorts object
+* keys and drops `null`/`undefined` entries recursively — this is the
+* canonical normalization used by products, tools, skills, surfaces, and the
+* whole-FPO hash.
+*
+* NOT every `*-ensure.ts` module uses this normalization: `flows-ensure.ts`
+* (`normalizeConfigForHash`/`normalizeStepForHash`) and `evals-ensure.ts`
+* (`normalizeForHash`) keep `null` values (they drop only `undefined`) and,
+* in the flow case, use a shallower array-recursion rule. Those are real
+* semantic divergences from this canonical normalizer, not incidental
+* duplication — changing either to reuse `normalizeValue` would alter the
+* content hash for definitions containing explicit `null`s and break the
+* wire contract with already-converged flows/evals. They stay local by
+* design; see the divergence comment at each site.
+*/
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Recursively normalizes a value for canonical hashing: object keys are
+* sorted, and `null`/`undefined` entries are dropped. Arrays preserve order
+* and have each item normalized in turn.
+*/
+function normalizeValue$1(value) {
+	if (Array.isArray(value)) return value.map((item) => normalizeValue$1(item));
+	if (isPlainObject$1(value)) {
+		const normalized = {};
+		for (const key of Object.keys(value).sort()) {
+			const entry = value[key];
+			if (entry === void 0 || entry === null) continue;
+			normalized[key] = normalizeValue$1(entry);
+		}
+		return normalized;
+	}
+	return value;
+}
+/** SHA-256 (hex) over an already-serialized (typically `JSON.stringify`'d) string. */
+async function sha256Hex(serialized) {
+	const encoded = new TextEncoder().encode(serialized);
+	const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
+	return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
+//#region src/collections-ensure.ts
+/** Canonical normalized form of a collection definition (slug excluded — identity). */
+function normalizeRecordCollectionDefinition(definition) {
+	return {
+		displayName: definition.displayName,
+		...definition.description ? { description: definition.description } : {},
+		...definition.icon ? { icon: definition.icon } : {},
+		...isPlainObject$1(definition.schema) ? { schema: normalizeValue$1(definition.schema) } : {},
+		validationMode: definition.validationMode || "off"
+	};
+}
+/** SHA-256 (hex) over the canonical normalized collection definition. */
+async function computeRecordCollectionContentHash(definition) {
+	return sha256Hex(JSON.stringify(normalizeRecordCollectionDefinition(definition)));
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+var CollectionEnsureConflictError = class extends Error {
+	constructor(body) {
+		super(body.error ?? `Collection ensure conflict: ${body.code}`);
+		this.name = "CollectionEnsureConflictError";
+		this.code = body.code;
+		this.lastModifiedSource = body.lastModifiedSource;
+		this.modifiedAt = body.modifiedAt;
+		this.currentHash = body.currentHash;
+	}
+};
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+var CollectionDriftError = class extends Error {
+	constructor(slug, plan) {
+		super(`Collection "${slug}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.collections.pull(slug) to absorb the remote edit into your repo, or re-run ensure to converge.`);
+		this.name = "CollectionDriftError";
+		this.plan = plan;
+	}
+};
+function toConflictError$8(err) {
+	if (!(err instanceof Error)) return null;
+	const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+	if (!match || match[1] !== "409") return null;
+	let body;
+	try {
+		body = JSON.parse(match[2]);
+	} catch {
+		return null;
+	}
+	if (!isPlainObject$1(body)) return null;
+	if (body.code !== "external_modification" && body.code !== "remote_changed") return null;
+	return new CollectionEnsureConflictError(body);
+}
+/** Per-transport memo of `{ slug + localHash → server contentHash }`, as in tools.ensure. */
+const serverHashMemo$9 = /* @__PURE__ */ new WeakMap();
+function memoFor$9(transport) {
+	let memo = serverHashMemo$9.get(transport);
+	if (!memo) {
+		memo = /* @__PURE__ */ new Map();
+		serverHashMemo$9.set(transport, memo);
+	}
+	return memo;
+}
+async function request$7(transport, body) {
+	try {
+		return await transport.post("/collections/ensure", body);
+	} catch (err) {
+		throw toConflictError$8(err) ?? err;
+	}
+}
+/**
+* Idempotently converge a collection definition. Probes with a content hash and
+* only ships the full definition when the server reports a miss. Never deletes
+* a collection and never touches records.
+*/
+async function ensureCollection(transport, definition, options = {}) {
+	const { dryRun, onConflict, expectedRemoteHash, expectNoChanges } = options;
+	const passthrough = {
+		...onConflict ? { onConflict } : {},
+		...expectedRemoteHash ? { expectedRemoteHash } : {}
+	};
+	if (dryRun || expectNoChanges) {
+		const plan = await request$7(transport, {
+			slug: definition.slug,
+			definition,
+			dryRun: true,
+			...passthrough
+		});
+		if (plan.result !== "plan") throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+		if (expectNoChanges && plan.changes !== "none") throw new CollectionDriftError(definition.slug, plan);
+		return plan;
+	}
+	const memo = memoFor$9(transport);
+	const localHash = await computeRecordCollectionContentHash(definition);
+	const memoKey = `${definition.slug} ${localHash}`;
+	const probe = await request$7(transport, {
+		slug: definition.slug,
+		contentHash: memo.get(memoKey) ?? localHash,
+		...passthrough
+	});
+	if (probe.result !== "definitionRequired") {
+		if (probe.result !== "plan") memo.set(memoKey, probe.contentHash);
+		return probe;
+	}
+	const converged = await request$7(transport, {
+		slug: definition.slug,
+		definition,
+		...passthrough
+	});
+	if (converged.result === "definitionRequired") throw new Error("Server reported definitionRequired for a full-definition request");
+	if (converged.result !== "plan") memo.set(memoKey, converged.contentHash);
+	return converged;
+}
+/** Pull the canonical definition and provenance for a collection by slug. */
+async function pullCollection(transport, slug) {
+	return transport.get(`/collections/${encodeURIComponent(slug)}/pull`);
+}
+//#endregion
 //#region src/generated-tool-gate.ts
 const TOOL_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]{1,63}$/;
 const DEFAULT_MAX_CODE_LENGTH = 12e3;
@@ -2667,6 +2835,239 @@ function normalizeDispatchRequest(request) {
 	};
 }
 //#endregion
+//#region src/schedules-ensure.ts
+function nonEmptyObject(value) {
+	if (!isPlainObject$1(value)) return void 0;
+	const normalized = normalizeValue$1(value);
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function canonicalRunAt(value) {
+	if (value === null || value === void 0 || value === "") return void 0;
+	const date = value instanceof Date ? value : new Date(value);
+	return Number.isNaN(date.getTime()) ? String(value) : date.toISOString();
+}
+/** Canonical normalized schedule content (name and target excluded — identity). */
+function normalizeScheduleContent(definition) {
+	const cron = nonEmptyString(definition.cron);
+	const timezone = nonEmptyString(definition.timezone);
+	const runAt = canonicalRunAt(definition.runAt);
+	const recordIds = Array.isArray(definition.recordIds) && definition.recordIds.length > 0 ? [...definition.recordIds] : void 0;
+	const recordType = nonEmptyString(definition.recordType);
+	const recordFilter = nonEmptyObject(definition.recordFilter);
+	const messages = Array.isArray(definition.messages) && definition.messages.length > 0 ? normalizeValue$1(definition.messages) : void 0;
+	const inputs = nonEmptyObject(definition.inputs);
+	const executionOptions = nonEmptyObject(definition.executionOptions);
+	return {
+		triggerType: definition.triggerType === "one_time" ? "one_time" : "recurring",
+		...cron !== void 0 ? { cron } : {},
+		...timezone !== void 0 ? { timezone } : {},
+		...runAt !== void 0 ? { runAt } : {},
+		...recordIds !== void 0 ? { recordIds } : {},
+		...recordType !== void 0 ? { recordType } : {},
+		...recordFilter !== void 0 ? { recordFilter } : {},
+		...messages !== void 0 ? { messages } : {},
+		...inputs !== void 0 ? { inputs } : {},
+		...executionOptions !== void 0 ? { executionOptions } : {},
+		...typeof definition.enabled === "boolean" ? { enabled: definition.enabled } : {}
+	};
+}
+/** SHA-256 (hex) over canonical schedule content, in the flat content shape. */
+async function computeScheduleContentHash(definition) {
+	return sha256Hex(JSON.stringify(normalizeScheduleContent(definition)));
+}
+/** The content hash of a `defineSchedule` definition. */
+async function computeScheduleDefinitionHash(definition) {
+	return computeScheduleContentHash({
+		triggerType: definition.trigger.type,
+		cron: definition.trigger.cron,
+		timezone: definition.trigger.timezone,
+		runAt: definition.trigger.runAt,
+		recordIds: definition.recordIds,
+		recordType: definition.recordType,
+		recordFilter: definition.recordFilter,
+		messages: definition.messages,
+		inputs: definition.inputs,
+		executionOptions: definition.executionOptions,
+		enabled: definition.enabled
+	});
+}
+const TARGET_KEYS = [
+	"flowId",
+	"agentId",
+	"flowName",
+	"agentName"
+];
+const DEFINE_SCHEDULE_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"target",
+	"trigger",
+	"recordIds",
+	"recordType",
+	"recordFilter",
+	"messages",
+	"inputs",
+	"executionOptions",
+	"enabled"
+]);
+/**
+* Pure-local declarative constructor for a standalone schedule. No I/O.
+* Validates structure; cron, timezone, record filter and plan limits are
+* checked server-side at ensure time.
+*
+* @example
+* ```typescript
+* const nightly = defineSchedule({
+*   name: 'Nightly digest',
+*   target: { flowName: 'Digest' },
+*   trigger: { type: 'recurring', cron: '0 2 * * *', timezone: 'UTC' },
+* })
+* ```
+*/
+function defineSchedule(input) {
+	if (!input || typeof input !== "object") throw new Error("defineSchedule requires a definition object");
+	if (typeof input.name !== "string" || input.name.length === 0) throw new Error("defineSchedule requires a non-empty string \"name\"");
+	if (!isPlainObject$1(input.target)) throw new Error("defineSchedule requires a \"target\" object");
+	const target = input.target;
+	const setKeys = TARGET_KEYS.filter((key) => target[key] !== void 0);
+	const extraKeys = Object.keys(target).filter((key) => !TARGET_KEYS.includes(key));
+	if (setKeys.length !== 1 || extraKeys.length > 0) throw new Error("defineSchedule \"target\" needs exactly one of flowId, agentId, flowName, agentName");
+	const trigger = input.trigger;
+	if (!isPlainObject$1(trigger) || trigger.type !== "recurring" && trigger.type !== "one_time") throw new Error("defineSchedule requires \"trigger.type\" to be \"recurring\" or \"one_time\"");
+	if (trigger.type === "recurring" && (!trigger.cron || !trigger.timezone)) throw new Error("defineSchedule: recurring triggers require \"cron\" and \"timezone\"");
+	if (trigger.type === "one_time" && !trigger.runAt) throw new Error("defineSchedule: one_time triggers require \"runAt\"");
+	const unknownKeys = Object.keys(input).filter((key) => !DEFINE_SCHEDULE_KEYS.has(key));
+	if (unknownKeys.length > 0) throw new Error(`defineSchedule: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are ${[...DEFINE_SCHEDULE_KEYS].join(", ")}.`);
+	return { ...input };
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+var ScheduleEnsureConflictError = class extends Error {
+	constructor(body) {
+		super(body.error ?? `Schedule ensure conflict: ${body.code}`);
+		this.name = "ScheduleEnsureConflictError";
+		this.code = body.code;
+		this.lastModifiedSource = body.lastModifiedSource;
+		this.modifiedAt = body.modifiedAt;
+		this.currentHash = body.currentHash;
+	}
+};
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+var ScheduleDriftError = class extends Error {
+	constructor(plan) {
+		super(`Schedule "${plan.scheduleId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run schedules.pull(name, target) to absorb the remote edit into your repo, or re-run ensure to converge.`);
+		this.name = "ScheduleDriftError";
+		this.plan = plan;
+	}
+};
+function errorStatusAndBody(err) {
+	if (!(err instanceof Error)) return {
+		status: null,
+		body: null
+	};
+	const typed = err;
+	if (typeof typed.statusCode === "number") return {
+		status: typed.statusCode,
+		body: typed.data
+	};
+	const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+	if (!match) return {
+		status: null,
+		body: null
+	};
+	try {
+		return {
+			status: Number(match[1]),
+			body: JSON.parse(match[2])
+		};
+	} catch {
+		return {
+			status: Number(match[1]),
+			body: null
+		};
+	}
+}
+function toConflictError$7(err) {
+	const { status, body } = errorStatusAndBody(err);
+	if (status !== 409 || !isPlainObject$1(body)) return null;
+	if (body.code !== "external_modification" && body.code !== "remote_changed") return null;
+	return new ScheduleEnsureConflictError(body);
+}
+const serverHashMemo$8 = /* @__PURE__ */ new WeakMap();
+function memoFor$8(client) {
+	let memo = serverHashMemo$8.get(client);
+	if (!memo) {
+		memo = /* @__PURE__ */ new Map();
+		serverHashMemo$8.set(client, memo);
+	}
+	return memo;
+}
+async function request$6(client, body) {
+	try {
+		return await client.post("/schedules/ensure", body);
+	} catch (err) {
+		const conflict = toConflictError$7(err);
+		if (conflict) throw conflict;
+		throw err;
+	}
+}
+/**
+* Idempotently converge a standalone schedule. Hash-first: probes with a
+* content hash and ships the full definition only on a miss. Never deletes.
+*/
+async function ensureSchedule(client, definition, options = {}) {
+	const { dryRun, onConflict, expectedRemoteHash, expectNoChanges } = options;
+	const identity = {
+		name: definition.name,
+		target: definition.target
+	};
+	const passthrough = {
+		...onConflict ? { onConflict } : {},
+		...expectedRemoteHash ? { expectedRemoteHash } : {}
+	};
+	if (dryRun || expectNoChanges) {
+		const plan = await request$6(client, {
+			...identity,
+			definition,
+			dryRun: true,
+			...passthrough
+		});
+		if (plan.result !== "plan") throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+		if (expectNoChanges && plan.changes !== "none") throw new ScheduleDriftError(plan);
+		return plan;
+	}
+	const memo = memoFor$8(client);
+	const localHash = await computeScheduleDefinitionHash(definition);
+	const memoKey = `${JSON.stringify(identity)} ${localHash}`;
+	if (!expectedRemoteHash) {
+		const probe = await request$6(client, {
+			...identity,
+			contentHash: memo.get(memoKey) ?? localHash,
+			...passthrough
+		});
+		if (probe.result !== "definitionRequired") {
+			if (probe.result !== "plan") memo.set(memoKey, probe.contentHash);
+			return probe;
+		}
+	}
+	const converged = await request$6(client, {
+		...identity,
+		definition,
+		...passthrough
+	});
+	if (converged.result === "definitionRequired") throw new Error("Server reported definitionRequired for a full-definition request");
+	if (converged.result !== "plan") memo.set(memoKey, converged.contentHash);
+	return converged;
+}
+/** Pull the canonical definition + provenance for a schedule by name and target. */
+async function pullSchedule(client, name, target) {
+	return client.get("/schedules/pull", {
+		name,
+		...target
+	});
+}
+//#endregion
 //#region src/offload-markers.ts
 const LEDGER_ARTIFACT_LINE_PREFIX = "Ledger artifact: ";
 const SPILL_MARKER_PATTERN = /\[Output saved to (art_[A-Za-z0-9_-]+) \(([\d,]+) chars?\); read_offloaded_output to view\]/;
@@ -4640,6 +5041,28 @@ var CollectionsEndpoint = class {
 	async typegen() {
 		return this.client.get("/collections/types.d.ts");
 	}
+	/**
+	* Idempotently converge a repo-declared collection (display fields, schema,
+	* validationMode) by slug. Hash-first; `dryRun` / `expectNoChanges` plan
+	* without writing. Never deletes a collection or touches records.
+	*
+	* @example
+	* ```typescript
+	* await client.collections.ensure({
+	*   slug: 'customers',
+	*   displayName: 'Customers',
+	*   schema: { type: 'object', properties: { status: { type: 'string' } } },
+	*   validationMode: 'warn',
+	* })
+	* ```
+	*/
+	async ensure(definition, options) {
+		return ensureCollection(this.client, definition, options);
+	}
+	/** Pull the canonical definition and provenance for a collection — the absorb-drift direction. */
+	async pull(slug) {
+		return pullCollection(this.client, slug);
+	}
 };
 /**
 * Agent API key REQUESTS — a device-authorization-style grant.
@@ -8172,6 +8595,21 @@ var SchedulesEndpoint = class {
 		return this.client.post("/schedules", data);
 	}
 	/**
+	* Idempotently converge a `defineSchedule` definition on a standalone flow or
+	* agent. Identity is name + target; the steady state is one hash probe. Never
+	* deletes, and an omitted `enabled` leaves a paused schedule paused.
+	*/
+	async ensure(definition, options = {}) {
+		return ensureSchedule(this.client, definition, options);
+	}
+	/**
+	* Pull the canonical definition + provenance for a schedule by name and
+	* target — the absorb-drift direction of `ensure`.
+	*/
+	async pull(name, target) {
+		return pullSchedule(this.client, name, target);
+	}
+	/**
 	* Update a schedule (partial update supported).
 	*/
 	async update(id, data) {
@@ -8560,6 +8998,17 @@ var ToolApprovalGrantsEndpoint = class {
 };
 //#endregion
 //#region src/detached-buffered-follow.ts
+/** The release fields a response body carries, dropping any it does not name. */
+function releaseFieldsOf(data) {
+	if (typeof data !== "object" || data === null) return {};
+	const record = data;
+	const resolution = record.agentTargetResolution;
+	return {
+		...typeof record.agentVersionId === "string" ? { agentVersionId: record.agentVersionId } : {},
+		...typeof record.alias === "string" ? { alias: record.alias } : {},
+		...resolution === "alias" || resolution === "version" || resolution === "legacy-live-row" ? { agentTargetResolution: resolution } : {}
+	};
+}
 function isDetachedToolOutputAck(data) {
 	if (typeof data !== "object" || data === null) return false;
 	const record = data;
@@ -8587,9 +9036,12 @@ function isLocalToolAwait(event) {
 * buffered continuation envelope a non-streaming local-tool loop expects.
 *
 * `after` is the last `seq` the loop had already consumed, so the replay
-* never re-delivers the await the outputs just answered.
+* never re-delivers the await the outputs just answered. Version fields from
+* earlier responses (`carried`) and the ack land on the envelope, since the
+* events stream never repeats them.
 */
-async function followDetachedResume(client, executionId, after) {
+async function followDetachedResume(client, ack, after, carried = {}) {
+	const { executionId } = ack;
 	const open = (cursor, signal) => client.requestStream(buildExecutionEventsPath(executionId, cursor ? { after: cursor } : {}), {
 		method: "GET",
 		...signal ? { signal } : {}
@@ -8647,65 +9099,12 @@ async function followDetachedResume(client, executionId, after) {
 		executionId,
 		events,
 		status,
-		...error ? { error } : {}
+		...error ? { error } : {},
+		...carried,
+		...releaseFieldsOf(ack)
 	};
 }
 //#endregion
-//#region src/content-hash.ts
-/**
-* Canonical content-hash primitives shared by the `*.ensure()` config-as-code
-* surfaces (products, tools, skills, surfaces, products-ensure-fpo). Each of
-* those modules computes a SHA-256 content hash for its hash-first `/ensure`
-* wire protocol (see docs/adr/0003-agent-config-as-code-ensure.md) — the hash
-* output for any given definition is a WIRE CONTRACT with the server, so this
-* module must stay dependency-free (the SDK is published to npm and must not
-* import `@runtypelabs/shared`, a private package) and must not change its
-* normalization behavior without a matching server-side change.
-*
-* `isPlainObject` and `normalizeValue` here are mirrored from
-* `packages/shared/src/utils/*-content-hash.ts`. `normalizeValue` sorts object
-* keys and drops `null`/`undefined` entries recursively — this is the
-* canonical normalization used by products, tools, skills, surfaces, and the
-* whole-FPO hash.
-*
-* NOT every `*-ensure.ts` module uses this normalization: `flows-ensure.ts`
-* (`normalizeConfigForHash`/`normalizeStepForHash`) and `evals-ensure.ts`
-* (`normalizeForHash`) keep `null` values (they drop only `undefined`) and,
-* in the flow case, use a shallower array-recursion rule. Those are real
-* semantic divergences from this canonical normalizer, not incidental
-* duplication — changing either to reuse `normalizeValue` would alter the
-* content hash for definitions containing explicit `null`s and break the
-* wire contract with already-converged flows/evals. They stay local by
-* design; see the divergence comment at each site.
-*/
-function isPlainObject$1(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/**
-* Recursively normalizes a value for canonical hashing: object keys are
-* sorted, and `null`/`undefined` entries are dropped. Arrays preserve order
-* and have each item normalized in turn.
-*/
-function normalizeValue$1(value) {
-	if (Array.isArray(value)) return value.map((item) => normalizeValue$1(item));
-	if (isPlainObject$1(value)) {
-		const normalized = {};
-		for (const key of Object.keys(value).sort()) {
-			const entry = value[key];
-			if (entry === void 0 || entry === null) continue;
-			normalized[key] = normalizeValue$1(entry);
-		}
-		return normalized;
-	}
-	return value;
-}
-/** SHA-256 (hex) over an already-serialized (typically `JSON.stringify`'d) string. */
-async function sha256Hex(serialized) {
-	const encoded = new TextEncoder().encode(serialized);
-	const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-	return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-//#endregion
 //#region src/evals-ensure.ts
 const CHECK_GRADER_KINDS = /* @__PURE__ */ new Set([
 	"contains",
@@ -9099,6 +9498,25 @@ async function computeEvalContentHash(definition) {
 	};
 	return sha256Hex(JSON.stringify(canonical));
 }
+/** A 409 from the eval ensure protocol (external_modification or remote_changed). */
+var EvalEnsureConflictError = class extends Error {
+	constructor(body) {
+		super(body.error ?? `Eval ensure conflict: ${body.code}`);
+		this.name = "EvalEnsureConflictError";
+		this.code = body.code;
+		this.lastModifiedSource = body.lastModifiedSource;
+		this.modifiedAt = body.modifiedAt;
+		this.currentHash = body.currentHash;
+	}
+};
+/** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
+var EvalDriftError = class extends Error {
+	constructor(plan) {
+		super(`Eval suite "${plan.suiteId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.evals.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`);
+		this.name = "EvalDriftError";
+		this.plan = plan;
+	}
+};
 /**
 * Per-client memo of `{ name + localHash → server contentHash }` so a hot
 * process pays the full-definition round trip once per boot (steady state
@@ -9106,44 +9524,75 @@ async function computeEvalContentHash(definition) {
 * hash, so a definition that changes within the process can never false-match a
 * stale server hash. Mirrors the flow ensure memo.
 */
-const serverHashMemo$6 = /* @__PURE__ */ new WeakMap();
-function memoFor$6(client) {
-	let memo = serverHashMemo$6.get(client);
+const serverHashMemo$7 = /* @__PURE__ */ new WeakMap();
+function memoFor$7(client) {
+	let memo = serverHashMemo$7.get(client);
 	if (!memo) {
 		memo = /* @__PURE__ */ new Map();
-		serverHashMemo$6.set(client, memo);
+		serverHashMemo$7.set(client, memo);
 	}
 	return memo;
 }
-/**
-* Idempotently converge an eval suite definition onto the platform. Hash-first:
-* probes with a content hash, and only ships the full definition when the
-* server reports a miss (`definitionRequired`). Upserts the suite + replaces
-* its cases; never executes the eval (use the `runtype eval` CLI / `/eval`
-* submit surface to run it).
-*
-* `virtual: true` definitions are ephemeral and have nothing durable to
-* converge — ensure rejects them. Run a virtual eval directly instead.
-*/
-async function ensureEval(client, definition) {
+function toEvalConflictError(err) {
+	if (!(err instanceof Error)) return null;
+	const match = err.message.match(/^API request failed: 409 .*? - ([\s\S]*)$/);
+	if (!match) return null;
+	let body;
+	try {
+		body = JSON.parse(match[1]);
+	} catch {
+		return null;
+	}
+	if (!isPlainObject$1(body)) return null;
+	if (body.code !== "external_modification" && body.code !== "remote_changed") return null;
+	return new EvalEnsureConflictError(body);
+}
+async function postEvalEnsure(client, body) {
+	try {
+		return await client.post("/eval/ensure", body);
+	} catch (err) {
+		throw toEvalConflictError(err) ?? err;
+	}
+}
+async function ensureEval(client, definition, options = {}) {
 	if (definition.virtual) throw new Error("Cannot ensure a virtual eval: virtual evals are ephemeral (nothing is persisted to converge). Remove `virtual: true` to converge a durable suite, or run it directly.");
-	const memo = memoFor$6(client);
+	const { dryRun, onConflict, expectedRemoteHash, expectNoChanges } = options;
+	const passthrough = {
+		...onConflict ? { onConflict } : {},
+		...expectedRemoteHash ? { expectedRemoteHash } : {}
+	};
+	if (dryRun || expectNoChanges) {
+		const plan = await postEvalEnsure(client, {
+			name: definition.name,
+			definition,
+			dryRun: true,
+			...passthrough
+		});
+		if (plan.result !== "plan") throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+		if (expectNoChanges && plan.changes !== "none") throw new EvalDriftError(plan);
+		return plan;
+	}
+	const memo = memoFor$7(client);
 	const localHash = await computeEvalContentHash(definition);
 	const memoKey = `${definition.name} ${localHash}`;
 	const contentHash = memo.get(memoKey) ?? localHash;
-	const probe = await client.post("/eval/ensure", {
+	const probe = await postEvalEnsure(client, {
 		name: definition.name,
-		contentHash
+		contentHash,
+		...passthrough
 	});
+	if (probe.result === "plan") throw new Error("Server returned a plan for a non-dryRun request");
 	if (probe.result !== "definitionRequired") {
 		memo.set(memoKey, probe.contentHash);
 		return probe;
 	}
-	const converged = await client.post("/eval/ensure", {
+	const converged = await postEvalEnsure(client, {
 		name: definition.name,
-		definition
+		definition,
+		...passthrough
 	});
 	if (converged.result === "definitionRequired") throw new Error("Server reported definitionRequired for a full-definition request");
+	if (converged.result === "plan") throw new Error("Server returned a plan for a non-dryRun request");
 	memo.set(memoKey, converged.contentHash);
 	return converged;
 }
@@ -9198,9 +9647,11 @@ function normalizeStepForHash(step) {
 }
 /** SHA-256 (hex) over the canonical normalized step list (steps only). */
 async function computeFlowContentHash(steps) {
-	const normalized = [...steps].sort((a, b) => {
-		return (isPlainObject$1(a) && typeof a.order === "number" ? a.order : 0) - (isPlainObject$1(b) && typeof b.order === "number" ? b.order : 0);
-	}).map(normalizeStepForHash);
+	const normalized = steps.map((step) => isPlainObject$1(step) ? step : {}).map((step, index) => ({
+		...step,
+		name: typeof step.name === "string" ? step.name : `Step ${index + 1}`,
+		order: typeof step.order === "number" ? step.order : index + 1
+	})).sort((a, b) => a.order - b.order).map(normalizeStepForHash);
 	return sha256Hex(JSON.stringify(normalized));
 }
 const DEFINE_FLOW_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
@@ -9219,8 +9670,8 @@ const DEFINE_FLOW_STEP_KEYS = /* @__PURE__ */ new Set([
 /**
 * Collect account-scoped `tool_…` references from a step config (inlined copy
 * of `collectNonPortableAgentToolRefs` in @runtypelabs/shared, applied to the
-* step's `config.tools` block and recursively to conditional branches). The
-* v1 ensure surface accepts portable tool references only.
+* step's `config.tools` block, `toolId` and `agentId`). The v1 ensure surface
+* accepts portable tool references only.
 */
 function collectStepNonPortableToolRefs(config, path) {
 	const found = [];
@@ -9254,12 +9705,73 @@ function collectStepNonPortableToolRefs(config, path) {
 	}
 	if (isAccountScoped(config.toolId)) found.push(`${path}.toolId`);
 	if (isRawId(config.agentId, "agent_")) found.push(`${path}.agentId`);
-	for (const branch of ["trueSteps", "falseSteps"]) {
-		const nested = config[branch];
-		if (!Array.isArray(nested)) continue;
-		nested.forEach((nestedStep, i) => {
-			if (isPlainObject$1(nestedStep) && isPlainObject$1(nestedStep.config)) found.push(...collectStepNonPortableToolRefs(nestedStep.config, `${path}.${branch}[${i}].config`));
+	return found;
+}
+const CONDITIONAL_BRANCH_STEP_KEYS = [
+	"trueSteps",
+	"falseSteps",
+	"true_steps",
+	"false_steps",
+	"otherwiseSteps"
+];
+/** Guards a hostile payload whose nesting is otherwise unbounded. */
+const MAX_REF_SITE_WALK_DEPTH = 100;
+/**
+* Collect account-scoped references at every flow step ref site (inlined copy of
+* `collectNonPortableFlowStepRefs` in @runtypelabs/shared): loop bodies, conditional
+* branches, inline flow-as-tool payloads and `errorHandling.fallbacks`.
+*/
+function collectFlowStepsNonPortableRefs(steps, basePath, depth = 0) {
+	if (!Array.isArray(steps) || depth > MAX_REF_SITE_WALK_DEPTH) return [];
+	const found = [];
+	steps.forEach((step, index) => {
+		if (!isPlainObject$1(step) || !isPlainObject$1(step.config)) return;
+		found.push(...collectStepConfigSiteRefs(step.type, step.config, `${basePath}[${index}].config`, depth));
+	});
+	return found;
+}
+function collectStepConfigSiteRefs(type, config, path, depth) {
+	const found = collectStepNonPortableToolRefs(config, path);
+	found.push(...collectToolBagFlowRefs(config.tools, `${path}.tools`, depth + 1));
+	const errorHandling = config.errorHandling;
+	if (isPlainObject$1(errorHandling) && Array.isArray(errorHandling.fallbacks)) errorHandling.fallbacks.forEach((fallback, i) => {
+		if (!isPlainObject$1(fallback)) return;
+		const fallbackPath = `${path}.errorHandling.fallbacks[${i}]`;
+		if (fallback.type === "flow") {
+			if (typeof fallback.flowId === "string" && fallback.flowId.startsWith("flow_")) found.push(`${fallbackPath}.flowId`);
+		} else if (fallback.type === "step" && isPlainObject$1(fallback.stepConfig)) {
+			found.push(...collectStepNonPortableToolRefs(fallback.stepConfig, `${fallbackPath}.stepConfig`));
+			found.push(...collectToolBagFlowRefs(fallback.stepConfig.tools, `${fallbackPath}.stepConfig.tools`, depth + 1));
+		}
+	});
+	if (type === "loop") found.push(...collectFlowStepsNonPortableRefs(config.steps, `${path}.steps`, depth + 1));
+	else if (type === "conditional") {
+		if (Array.isArray(config.branches)) config.branches.forEach((branch, i) => {
+			if (!isPlainObject$1(branch)) return;
+			found.push(...collectFlowStepsNonPortableRefs(branch.steps, `${path}.branches[${i}].steps`, depth + 1));
 		});
+		for (const key of CONDITIONAL_BRANCH_STEP_KEYS) found.push(...collectFlowStepsNonPortableRefs(config[key], `${path}.${key}`, depth + 1));
+	}
+	return found;
+}
+/** Descend the inline flow-as-tool and skill payloads a step's tool bag can carry. */
+function collectToolBagFlowRefs(tools, path, depth) {
+	if (!isPlainObject$1(tools) || depth > MAX_REF_SITE_WALK_DEPTH) return [];
+	const found = [];
+	const walkBag = (bag, bagPath, bagDepth) => {
+		if (bagDepth > MAX_REF_SITE_WALK_DEPTH) return;
+		bag.forEach((tool, i) => {
+			if (!isPlainObject$1(tool) || !isPlainObject$1(tool.config)) return;
+			const toolPath = `${bagPath}[${i}].config`;
+			const skill = tool.config.skill;
+			if (isPlainObject$1(skill) && Array.isArray(skill.resolvedTools)) walkBag(skill.resolvedTools, `${toolPath}.skill.resolvedTools`, bagDepth + 1);
+			const flow = tool.config.flow;
+			if (isPlainObject$1(flow) && Array.isArray(flow.steps)) found.push(...collectFlowStepsNonPortableRefs(flow.steps, `${toolPath}.flow.steps`, bagDepth + 1));
+		});
+	};
+	for (const key of ["runtimeTools", "inlineTools"]) {
+		const bag = tools[key];
+		if (Array.isArray(bag)) walkBag(bag, `${path}.${key}`, depth);
 	}
 	return found;
 }
@@ -9300,7 +9812,7 @@ function defineFlow(input) {
 		if (unknownStepKeys.length > 0) throw new Error(`defineFlow: steps[${index}] has unknown field(s): ${unknownStepKeys.join(", ")}. Allowed step fields are type, name, order, enabled, when, config. (Step ids are server artifacts and not part of a portable definition.)`);
 		const config = isPlainObject$1(step.config) ? step.config : void 0;
 		if (config) {
-			const nonPortable = collectStepNonPortableToolRefs(config, `steps[${index}].config`);
+			const nonPortable = collectStepConfigSiteRefs(step.type, config, `steps[${index}].config`, 0);
 			if (nonPortable.length > 0) throw new Error(`defineFlow: account-scoped reference(s) at ${nonPortable.join(", ")}. Definitions must be environment-portable — tool_…/agent_…/flow_… IDs belong to one account/environment. Use builtin:/platform:/mcp: references, or reference a saved resource by name — tool:<name>, agent:<name>, or flow:<name> instead.`);
 		}
 		return {
@@ -9354,7 +9866,7 @@ var FlowEnsureConflictError = class extends Error {
 /** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
 var FlowDriftError = class extends Error {
 	constructor(plan) {
-		super(`Flow "${plan.flowId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.flows.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`);
+		super(`Flow "${plan.flowId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${[...plan.changedKeys, ...plan.publishPending ? ["publish (pending)"] : []].join(", ") || "n/a"}). Run client.flows.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`);
 		this.name = "FlowDriftError";
 		this.plan = plan;
 	}
@@ -9363,7 +9875,7 @@ var FlowDriftError = class extends Error {
 * Best-effort extraction of `{ status, body }` from the generic request
 * error thrown by RuntypeClient ("API request failed: 409 Conflict - {…}").
 */
-function parseRequestError$5(err) {
+function parseRequestError$6(err) {
 	if (!(err instanceof Error)) return {
 		status: null,
 		body: null
@@ -9385,8 +9897,8 @@ function parseRequestError$5(err) {
 		};
 	}
 }
-function toConflictError$5(err) {
-	const { status, body } = parseRequestError$5(err);
+function toConflictError$6(err) {
+	const { status, body } = parseRequestError$6(err);
 	if (status !== 409 || !isPlainObject$1(body)) return null;
 	const code = body.code;
 	if (code !== "external_modification" && code !== "remote_changed") return null;
@@ -9402,23 +9914,23 @@ function toConflictError$5(err) {
 * so a stale server hash from the previous definition version can never be
 * probed (which would false-match and silently skip the update).
 */
-const serverHashMemo$5 = /* @__PURE__ */ new WeakMap();
-function memoFor$5(client) {
-	let memo = serverHashMemo$5.get(client);
+const serverHashMemo$6 = /* @__PURE__ */ new WeakMap();
+function memoFor$6(client) {
+	let memo = serverHashMemo$6.get(client);
 	if (!memo) {
 		memo = /* @__PURE__ */ new Map();
-		serverHashMemo$5.set(client, memo);
+		serverHashMemo$6.set(client, memo);
 	}
 	return memo;
 }
 function memoize$4(memo, memoKey, result) {
 	if (result.result !== "plan") memo.set(memoKey, result.contentHash);
 }
-async function request$4(client, body) {
+async function request$5(client, body) {
 	try {
 		return await client.post("/flows/ensure", body);
 	} catch (err) {
-		const conflict = toConflictError$5(err);
+		const conflict = toConflictError$6(err);
 		if (conflict) throw conflict;
 		throw err;
 	}
@@ -9443,37 +9955,37 @@ async function ensureFlow(client, definition, options = {}) {
 		steps: definition.steps
 	};
 	if (dryRun || expectNoChanges) {
-		const plan = await request$4(client, {
+		const plan = await request$5(client, {
 			name: definition.name,
 			definition: wireDefinition,
 			dryRun: true,
 			...passthrough
 		});
 		if (plan.result !== "plan") throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
-		if (expectNoChanges && plan.changes !== "none") throw new FlowDriftError(plan);
+		if (expectNoChanges && (plan.changes !== "none" || release === "publish" && plan.publishPending === true)) throw new FlowDriftError(plan);
 		return plan;
 	}
-	const memo = memoFor$5(client);
+	const memo = memoFor$6(client);
 	const localHash = await computeFlowContentHash(definition.steps);
 	const memoKey = `${definition.name} ${localHash}`;
 	const contentHash = memo.get(memoKey) ?? localHash;
-	const probe = await request$4(client, {
+	const probe = await request$5(client, {
 		name: definition.name,
 		contentHash,
 		...passthrough
 	});
 	if (probe.result !== "definitionRequired") {
 		memoize$4(memo, memoKey, probe);
-		return convergeInlineEvals(client, definition, probe);
+		return convergeInlineEvals(client, definition, probe, onConflict);
 	}
-	const converged = await request$4(client, {
+	const converged = await request$5(client, {
 		name: definition.name,
 		definition: wireDefinition,
 		...passthrough
 	});
 	if (converged.result === "definitionRequired") throw new Error("Server reported definitionRequired for a full-definition request");
 	memoize$4(memo, memoKey, converged);
-	return convergeInlineEvals(client, definition, converged);
+	return convergeInlineEvals(client, definition, converged, onConflict);
 }
 /**
 * After the flow itself converges on the real (non-plan) path, converge each
@@ -9486,10 +9998,10 @@ async function ensureFlow(client, definition, options = {}) {
 * unchanged (no empty `evals` array). The server's `/flows/ensure` surface is
 * never touched by eval semantics — they ride the eval endpoints only.
 */
-async function convergeInlineEvals(client, definition, result) {
+async function convergeInlineEvals(client, definition, result, onConflict) {
 	if (result.result === "plan" || !definition.evals?.length) return result;
 	const evals = [];
-	for (const evalDef of definition.evals) evals.push(await ensureEval(client, evalDef));
+	for (const evalDef of definition.evals) evals.push(await ensureEval(client, evalDef, onConflict ? { onConflict } : {}));
 	return {
 		...result,
 		evals
@@ -10220,9 +10732,11 @@ var RuntypeFlowBuilder = class {
 			}
 		};
 		let currentResponse;
+		let carriedRelease = {};
 		if (isStreaming) currentResponse = await client.dispatch(config);
 		else {
 			const data = await client.dispatchJson(config);
+			carriedRelease = releaseFieldsOf(data);
 			currentResponse = new Response(JSON.stringify(data), { headers: { "content-type": "application/json" } });
 		}
 		while (true) {
@@ -10257,7 +10771,11 @@ var RuntypeFlowBuilder = class {
 					}).catch(() => null));
 					else {
 						const data = await client.post("/dispatch/resume", resumeData);
-						const envelope = isDetachedToolOutputAck(data) ? await followDetachedResume(client, data.executionId, pausedResult.resumeCursor) : data;
+						carriedRelease = {
+							...carriedRelease,
+							...releaseFieldsOf(data)
+						};
+						const envelope = isDetachedToolOutputAck(data) ? await followDetachedResume(client, data, pausedResult.resumeCursor, carriedRelease) : data;
 						currentResponse = new Response(JSON.stringify(envelope), { headers: { "content-type": "application/json" } });
 					}
 				} catch (error) {
@@ -10719,24 +11237,8 @@ var EvalsNamespace = class {
 	run(config) {
 		return new EvalRunner(this.getClient, config);
 	}
-	/**
-	* Idempotently converge a `defineEval` suite definition onto the platform —
-	* the deploy-time, non-executing converge for code-colocated evals. Hash-first:
-	* the steady state is one tiny probe request. Upserts the eval suite + replaces
-	* its cases; never runs the eval.
-	*
-	* @example
-	* ```typescript
-	* const suite = defineEval({
-	*   target: { flow: 'support-triage' },
-	*   graders: [noError()],
-	*   cases: [{ name: 'billing', input: { variables: { message: 'I was double charged' } }, expect: [contains('finance')] }],
-	* })
-	* const result = await Runtype.evals.ensure(suite)
-	* ```
-	*/
-	async ensure(definition) {
-		return ensureEval(this.getClient(), definition);
+	async ensure(definition, options = {}) {
+		return ensureEval(this.getClient(), definition, options);
 	}
 	/**
 	* Pull the canonical definition + provenance for an eval suite by name — the
@@ -11003,7 +11505,7 @@ var SkillDriftError = class extends Error {
 * Best-effort extraction of `{ status, body }` from the generic request error
 * thrown by RuntypeClient ("API request failed: 409 Conflict - {…}").
 */
-function parseRequestError$4(err) {
+function parseRequestError$5(err) {
 	if (!(err instanceof Error)) return {
 		status: null,
 		body: null
@@ -11025,8 +11527,8 @@ function parseRequestError$4(err) {
 		};
 	}
 }
-function toConflictError$4(err) {
-	const { status, body } = parseRequestError$4(err);
+function toConflictError$5(err) {
+	const { status, body } = parseRequestError$5(err);
 	if (status !== 409 || !isPlainObject$1(body)) return null;
 	const code = body.code;
 	if (code !== "external_modification" && code !== "remote_changed") return null;
@@ -11038,23 +11540,23 @@ function toConflictError$4(err) {
 * within the process lifetime invalidates a stale server hash (which would
 * false-match and silently skip the update). Same scheme as flows/tools.ensure.
 */
-const serverHashMemo$4 = /* @__PURE__ */ new WeakMap();
-function memoFor$4(client) {
-	let memo = serverHashMemo$4.get(client);
+const serverHashMemo$5 = /* @__PURE__ */ new WeakMap();
+function memoFor$5(client) {
+	let memo = serverHashMemo$5.get(client);
 	if (!memo) {
 		memo = /* @__PURE__ */ new Map();
-		serverHashMemo$4.set(client, memo);
+		serverHashMemo$5.set(client, memo);
 	}
 	return memo;
 }
 function memoize$3(memo, memoKey, result) {
 	if (result.result !== "plan") memo.set(memoKey, result.contentHash);
 }
-async function request$3(client, body) {
+async function request$4(client, body) {
 	try {
 		return await client.post("/skills/ensure", body);
 	} catch (err) {
-		const conflict = toConflictError$4(err);
+		const conflict = toConflictError$5(err);
 		if (conflict) throw conflict;
 		throw err;
 	}
@@ -11066,14 +11568,15 @@ async function request$3(client, body) {
 * on every change; never deletes.
 */
 async function ensureSkill(client, definition, options = {}) {
-	const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
+	const { dryRun, onConflict, release, expectedRemoteHash, version, expectNoChanges } = options;
 	const passthrough = {
 		...onConflict ? { onConflict } : {},
 		...release ? { release } : {},
-		...expectedRemoteHash ? { expectedRemoteHash } : {}
+		...expectedRemoteHash ? { expectedRemoteHash } : {},
+		...version ? { version } : {}
 	};
 	if (dryRun || expectNoChanges) {
-		const plan = await request$3(client, {
+		const plan = await request$4(client, {
 			name: definition.name,
 			definition: manifestToWire(definition),
 			dryRun: true,
@@ -11083,11 +11586,11 @@ async function ensureSkill(client, definition, options = {}) {
 		if (expectNoChanges && plan.changes !== "none") throw new SkillDriftError(plan);
 		return plan;
 	}
-	const memo = memoFor$4(client);
+	const memo = memoFor$5(client);
 	const localHash = await computeSkillContentHash(definition);
 	const memoKey = `${definition.name} ${localHash}`;
 	const contentHash = memo.get(memoKey) ?? localHash;
-	const probe = await request$3(client, {
+	const probe = await request$4(client, {
 		name: definition.name,
 		contentHash,
 		...passthrough
@@ -11096,7 +11599,7 @@ async function ensureSkill(client, definition, options = {}) {
 		memoize$3(memo, memoKey, probe);
 		return probe;
 	}
-	const converged = await request$3(client, {
+	const converged = await request$4(client, {
 		name: definition.name,
 		definition: manifestToWire(definition),
 		...passthrough
@@ -11433,6 +11936,8 @@ const DEFINE_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
 	"icon",
 	...AGENT_CONFIG_KEYS
 ]);
+/** A minted tool typeid; `alwaysLoaded` also holds tool names, which may begin with `tool_`. */
+const TOOL_TYPEID_PATTERN = /^tool_[0-7][0-9a-hjkmnp-tv-z]{25}$/;
 /**
 * Collect account-scoped `tool_…` references (inlined copy of
 * `collectNonPortableAgentToolRefs` in @runtypelabs/shared). The v1 ensure
@@ -11459,6 +11964,9 @@ function collectNonPortableToolRefs(config) {
 	if (isPlainObject(tools.approval)) scanArray(tools.approval.require, "tools.approval.require");
 	if (isPlainObject(tools.subagentConfig)) scanArray(tools.subagentConfig.toolPool, "tools.subagentConfig.toolPool");
 	if (isPlainObject(tools.codeModeConfig)) scanArray(tools.codeModeConfig.toolPool, "tools.codeModeConfig.toolPool");
+	if (isPlainObject(tools.toolSearch) && Array.isArray(tools.toolSearch.alwaysLoaded)) tools.toolSearch.alwaysLoaded.forEach((ref, i) => {
+		if (typeof ref === "string" && TOOL_TYPEID_PATTERN.test(ref)) found.push(`tools.toolSearch.alwaysLoaded[${i}]`);
+	});
 	if (Array.isArray(tools.runtimeTools)) tools.runtimeTools.forEach((runtimeTool, i) => {
 		if (!isPlainObject(runtimeTool) || !isPlainObject(runtimeTool.config)) return;
 		const base = `tools.runtimeTools[${i}].config`;
@@ -11507,6 +12015,18 @@ function defineAgent(input) {
 		config
 	};
 }
+function planHasSkillBindingChanges(plan) {
+	return (plan.skillBindings ?? []).some((binding) => binding.action !== "unchanged");
+}
+/** Whether a dry run that asked for a deploy would move the alias or change its binding names. */
+function planHasDeploymentChanges(plan) {
+	return plan.deployment?.changed === true || plan.deployment?.bindingsChanged === true;
+}
+function deploymentChangeLabels(plan) {
+	const deployment = plan.deployment;
+	if (!deployment) return [];
+	return [...deployment.changed ? [`deploy:${deployment.alias} (pointer)`] : [], ...deployment.bindingsChanged ? [`deploy:${deployment.alias} (bindings)`] : []];
+}
 /** A 409 from the ensure protocol (external_modification or remote_changed). */
 var AgentEnsureConflictError = class extends Error {
 	constructor(body) {
@@ -11521,7 +12041,12 @@ var AgentEnsureConflictError = class extends Error {
 /** Thrown by `ensure(def, { expectNoChanges: true })` when drift is detected. */
 var AgentDriftError = class extends Error {
 	constructor(plan) {
-		super(`Agent "${plan.agentId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.agents.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`);
+		const skillChanges = (plan.skillBindings ?? []).filter((binding) => binding.action !== "unchanged").map((binding) => `skill:${binding.name} (${binding.action})`);
+		super(`Agent "${plan.agentId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${[
+			...plan.changedKeys,
+			...skillChanges,
+			...deploymentChangeLabels(plan)
+		].join(", ") || "n/a"}). Run client.agents.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`);
 		this.name = "AgentDriftError";
 		this.plan = plan;
 	}
@@ -11530,7 +12055,7 @@ var AgentDriftError = class extends Error {
 * Best-effort extraction of `{ status, body }` from the generic request
 * error thrown by RuntypeClient ("API request failed: 409 Conflict - {…}").
 */
-function parseRequestError$3(err) {
+function parseRequestError$4(err) {
 	if (!(err instanceof Error)) return {
 		status: null,
 		body: null
@@ -11552,8 +12077,8 @@ function parseRequestError$3(err) {
 		};
 	}
 }
-function toConflictError$3(err) {
-	const { status, body } = parseRequestError$3(err);
+function toConflictError$4(err) {
+	const { status, body } = parseRequestError$4(err);
 	if (status !== 409 || !isPlainObject(body)) return null;
 	const code = body.code;
 	if (code !== "external_modification" && code !== "remote_changed") return null;
@@ -11569,12 +12094,12 @@ function toConflictError$3(err) {
 * so a stale server hash from the previous definition version can never be
 * probed (which would false-match and silently skip the update).
 */
-const serverHashMemo$3 = /* @__PURE__ */ new WeakMap();
-function memoFor$3(client) {
-	let memo = serverHashMemo$3.get(client);
+const serverHashMemo$4 = /* @__PURE__ */ new WeakMap();
+function memoFor$4(client) {
+	let memo = serverHashMemo$4.get(client);
 	if (!memo) {
 		memo = /* @__PURE__ */ new Map();
-		serverHashMemo$3.set(client, memo);
+		serverHashMemo$4.set(client, memo);
 	}
 	return memo;
 }
@@ -11610,14 +12135,16 @@ var AgentsNamespace = class {
 	*/
 	async ensure(definition, options = {}) {
 		const client = this.getClient();
-		const { dryRun, onConflict, release, deploy, expectedRemoteHash, version, expectNoChanges } = options;
+		const { dryRun, onConflict, release, deploy, expectedRemoteHash, version, expectNoChanges, skills, capabilities } = options;
 		if (release !== void 0 && deploy !== void 0) throw new Error(ENSURE_RELEASE_DEPLOY_CONFLICT_MESSAGE);
 		const passthrough = {
 			...onConflict ? { onConflict } : {},
 			...release ? { release } : {},
 			...deploy ? { deploy } : {},
 			...expectedRemoteHash ? { expectedRemoteHash } : {},
-			...version ? { version } : {}
+			...version ? { version } : {},
+			...skills ? { skills } : {},
+			...capabilities ? { capabilities } : {}
 		};
 		if (dryRun || expectNoChanges) {
 			const plan = await this.request(client, {
@@ -11627,15 +12154,16 @@ var AgentsNamespace = class {
 				...passthrough
 			});
 			if (plan.result !== "plan") throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
-			if (expectNoChanges && plan.changes !== "none") throw new AgentDriftError(plan);
+			const deployRequested = release === "publish" || deploy !== void 0;
+			if (expectNoChanges && (plan.changes !== "none" || planHasSkillBindingChanges(plan) || deployRequested && planHasDeploymentChanges(plan))) throw new AgentDriftError(plan);
 			return plan;
 		}
-		const memo = memoFor$3(client);
+		const memo = memoFor$4(client);
 		const localHash = await computeAgentContentHash({
 			...definition,
 			config: definition.config
 		});
-		const memoKey = `${definition.name}\u0000${localHash}`;
+		const memoKey = `${definition.name}\u0000${localHash}${capabilities ? `\u0000${JSON.stringify(capabilities)}` : ""}`;
 		const contentHash = memo.get(memoKey) ?? localHash;
 		const probe = await this.request(client, {
 			name: definition.name,
@@ -11669,7 +12197,7 @@ var AgentsNamespace = class {
 		try {
 			return await client.post("/agents/ensure", body);
 		} catch (err) {
-			const conflict = toConflictError$3(err);
+			const conflict = toConflictError$4(err);
 			if (conflict) throw conflict;
 			throw err;
 		}
@@ -11798,7 +12326,7 @@ var ToolDriftError = class extends Error {
 * Best-effort extraction of `{ status, body }` from the generic request
 * error thrown by RuntypeClient ("API request failed: 409 Conflict - {…}").
 */
-function parseRequestError$2(err) {
+function parseRequestError$3(err) {
 	if (!(err instanceof Error)) return {
 		status: null,
 		body: null
@@ -11820,8 +12348,8 @@ function parseRequestError$2(err) {
 		};
 	}
 }
-function toConflictError$2(err) {
-	const { status, body } = parseRequestError$2(err);
+function toConflictError$3(err) {
+	const { status, body } = parseRequestError$3(err);
 	if (status !== 409 || !isPlainObject$1(body)) return null;
 	const code = body.code;
 	if (code !== "external_modification" && code !== "remote_changed") return null;
@@ -11833,23 +12361,23 @@ function toConflictError$2(err) {
 * within the process lifetime invalidates a stale server hash (which would
 * false-match and silently skip the update). Same scheme as flows.ensure.
 */
-const serverHashMemo$2 = /* @__PURE__ */ new WeakMap();
-function memoFor$2(client) {
-	let memo = serverHashMemo$2.get(client);
+const serverHashMemo$3 = /* @__PURE__ */ new WeakMap();
+function memoFor$3(client) {
+	let memo = serverHashMemo$3.get(client);
 	if (!memo) {
 		memo = /* @__PURE__ */ new Map();
-		serverHashMemo$2.set(client, memo);
+		serverHashMemo$3.set(client, memo);
 	}
 	return memo;
 }
 function memoize$2(memo, memoKey, result) {
 	if (result.result !== "plan") memo.set(memoKey, result.contentHash);
 }
-async function request$2(client, body) {
+async function request$3(client, body) {
 	try {
 		return await client.post("/tools/ensure", body);
 	} catch (err) {
-		const conflict = toConflictError$2(err);
+		const conflict = toConflictError$3(err);
 		if (conflict) throw conflict;
 		throw err;
 	}
@@ -11866,7 +12394,7 @@ async function ensureTool(client, definition, options = {}) {
 		...expectedRemoteHash ? { expectedRemoteHash } : {}
 	};
 	if (dryRun || expectNoChanges) {
-		const plan = await request$2(client, {
+		const plan = await request$3(client, {
 			name: definition.name,
 			definition,
 			dryRun: true,
@@ -11876,11 +12404,11 @@ async function ensureTool(client, definition, options = {}) {
 		if (expectNoChanges && plan.changes !== "none") throw new ToolDriftError(plan);
 		return plan;
 	}
-	const memo = memoFor$2(client);
+	const memo = memoFor$3(client);
 	const localHash = await computeToolContentHash(definition);
 	const memoKey = `${definition.name} ${localHash}`;
 	const contentHash = memo.get(memoKey) ?? localHash;
-	const probe = await request$2(client, {
+	const probe = await request$3(client, {
 		name: definition.name,
 		contentHash,
 		...passthrough
@@ -11889,7 +12417,7 @@ async function ensureTool(client, definition, options = {}) {
 		memoize$2(memo, memoKey, probe);
 		return probe;
 	}
-	const converged = await request$2(client, {
+	const converged = await request$3(client, {
 		name: definition.name,
 		definition,
 		...passthrough
@@ -11945,10 +12473,197 @@ var ToolsNamespace = class {
 	}
 };
 //#endregion
+//#region src/question-sets-ensure.ts
+/** Canonical form of a question set definition, without its slug. */
+function normalizeQuestionSetDefinition(definition) {
+	return normalizeValue$1({
+		name: definition.name,
+		description: definition.description,
+		questions: isPlainObject$1(definition.questions) ? definition.questions : {},
+		inputMapping: definition.inputMapping,
+		model: definition.model
+	});
+}
+/** SHA-256 (hex) over the canonical question set definition. */
+async function computeQuestionSetContentHash(definition) {
+	return sha256Hex(JSON.stringify(normalizeQuestionSetDefinition(definition)));
+}
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const DEFINE_QUESTION_SET_KEYS = /* @__PURE__ */ new Set([
+	"slug",
+	"name",
+	"description",
+	"questions",
+	"inputMapping",
+	"model"
+]);
+/**
+* Pure local constructor for a question set definition. Checks the structure
+* and rejects unknown fields; the server validates the questions at ensure time.
+*
+* @example
+* ```typescript
+* const triage = defineQuestionSet({
+*   slug: 'ticket-triage',
+*   name: 'Ticket triage',
+*   questions: { urgent: { type: 'boolean', instructions: 'Is the ticket urgent?' } },
+* })
+* ```
+*/
+function defineQuestionSet(input) {
+	if (!input || typeof input !== "object") throw new Error("defineQuestionSet requires a definition object");
+	if (typeof input.slug !== "string" || !SLUG_PATTERN.test(input.slug)) throw new Error("defineQuestionSet requires a \"slug\" of lowercase letters, digits, \"-\" and \"_\", up to 64 characters");
+	if (typeof input.name !== "string" || input.name.length === 0) throw new Error("defineQuestionSet requires a non-empty string \"name\"");
+	if (!isPlainObject$1(input.questions) || Object.keys(input.questions).length === 0) throw new Error("defineQuestionSet requires a non-empty \"questions\" object");
+	const unknownKeys = Object.keys(input).filter((key) => !DEFINE_QUESTION_SET_KEYS.has(key));
+	if (unknownKeys.length > 0) throw new Error(`defineQuestionSet: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are slug, name, description, questions, inputMapping and model.`);
+	return { ...input };
+}
+/** A 409 from the ensure protocol (external_modification or remote_changed). */
+var QuestionSetEnsureConflictError = class extends Error {
+	constructor(body) {
+		super(body.error ?? `Question set ensure conflict: ${body.code}`);
+		this.name = "QuestionSetEnsureConflictError";
+		this.code = body.code;
+		this.lastModifiedSource = body.lastModifiedSource;
+		this.modifiedAt = body.modifiedAt;
+		this.currentHash = body.currentHash;
+	}
+};
+/** Thrown by `ensure(def, { expectNoChanges: true })` when the remote differs. */
+var QuestionSetDriftError = class extends Error {
+	constructor(slug, plan) {
+		super(`Question set "${slug}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.questionSets.pull(slug) to absorb the remote edit, or re-run ensure to converge.`);
+		this.name = "QuestionSetDriftError";
+		this.plan = plan;
+	}
+};
+function toConflictError$2(err) {
+	if (!(err instanceof Error)) return null;
+	const match = err.message.match(/^API request failed: (409) .*? - ([\s\S]*)$/);
+	if (!match) return null;
+	let body;
+	try {
+		body = JSON.parse(match[2]);
+	} catch {
+		return null;
+	}
+	if (!isPlainObject$1(body)) return null;
+	if (body.code !== "external_modification" && body.code !== "remote_changed") return null;
+	return new QuestionSetEnsureConflictError(body);
+}
+const serverHashMemo$2 = /* @__PURE__ */ new WeakMap();
+function memoFor$2(client) {
+	let memo = serverHashMemo$2.get(client);
+	if (!memo) {
+		memo = /* @__PURE__ */ new Map();
+		serverHashMemo$2.set(client, memo);
+	}
+	return memo;
+}
+async function request$2(client, body) {
+	try {
+		return await client.post("/question-sets/ensure", body);
+	} catch (err) {
+		throw toConflictError$2(err) ?? err;
+	}
+}
+function toWireDefinition(definition) {
+	const { slug: _slug, ...rest } = definition;
+	return rest;
+}
+/**
+* Idempotently converge a question set onto the platform. Probes with a
+* content hash first and sends the full definition only on a miss. Appends a
+* version when the questions, input mapping or model change; never deletes.
+*/
+async function ensureQuestionSet(client, definition, options = {}) {
+	const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
+	const passthrough = {
+		...onConflict ? { onConflict } : {},
+		...release ? { release } : {},
+		...expectedRemoteHash ? { expectedRemoteHash } : {}
+	};
+	if (dryRun || expectNoChanges) {
+		const plan = await request$2(client, {
+			slug: definition.slug,
+			definition: toWireDefinition(definition),
+			dryRun: true,
+			...passthrough
+		});
+		if (plan.result !== "plan") throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+		if (expectNoChanges && plan.changes !== "none") throw new QuestionSetDriftError(definition.slug, plan);
+		return plan;
+	}
+	const memo = memoFor$2(client);
+	const localHash = await computeQuestionSetContentHash(definition);
+	const memoKey = `${definition.slug} ${localHash}`;
+	const probe = await request$2(client, {
+		slug: definition.slug,
+		contentHash: memo.get(memoKey) ?? localHash,
+		...passthrough
+	});
+	if (probe.result !== "definitionRequired") {
+		if (probe.result !== "plan") memo.set(memoKey, probe.contentHash);
+		return probe;
+	}
+	const converged = await request$2(client, {
+		slug: definition.slug,
+		definition: toWireDefinition(definition),
+		...passthrough
+	});
+	if (converged.result === "definitionRequired") throw new Error("Server reported definitionRequired for a full-definition request");
+	if (converged.result !== "plan") memo.set(memoKey, converged.contentHash);
+	return converged;
+}
+/** Pull the canonical definition and provenance for a question set by slug. */
+async function pullQuestionSet(client, slug) {
+	return client.get("/question-sets/pull", { slug });
+}
+//#endregion
+//#region src/question-sets-namespace.ts
+/** Question set config-as-code: `ensure` and `pull`. */
+var QuestionSetsNamespace = class {
+	constructor(getClient) {
+		this.getClient = getClient;
+	}
+	/**
+	* Converge a `defineQuestionSet` definition. The steady state is one hash
+	* probe. Pass `release: 'publish'` so flows and agents can resolve the
+	* latest version.
+	*
+	* @example
+	* ```typescript
+	* await Runtype.questionSets.ensure(triage, { release: 'publish' })
+	* await Runtype.questionSets.ensure(triage, { expectNoChanges: true })
+	* ```
+	*/
+	async ensure(definition, options = {}) {
+		return ensureQuestionSet(this.getClient(), definition, options);
+	}
+	/** Pull the live definition and provenance for a slug, to absorb a dashboard edit. */
+	async pull(slug) {
+		return pullQuestionSet(this.getClient(), slug);
+	}
+};
+//#endregion
 //#region src/products-ensure.ts
+/**
+* `spec` with its stack as a save stores it: without the server-set fields (`detected`, `declared`,
+* `hiddenAt`), which their own write paths set, and with `hidden` deduplicated.
+*/
+function asSavedStack(spec) {
+	if (!isPlainObject$1(spec.stack)) return spec;
+	const { detected: _detected, declared: _declared, hiddenAt: _hiddenAt, ...stack } = spec.stack;
+	if (Array.isArray(stack.hidden)) stack.hidden = [...new Set(stack.hidden)];
+	return {
+		...spec,
+		stack
+	};
+}
 /** Canonical normalized form of a product definition (name + canvas excluded). */
 function normalizeProductDefinition(definition) {
-	const spec = isPlainObject$1(definition.spec) ? normalizeValue$1(definition.spec) : {};
+	const spec = isPlainObject$1(definition.spec) ? normalizeValue$1(asSavedStack(definition.spec)) : {};
 	return {
 		...definition.description ? { description: definition.description } : {},
 		...definition.icon ? { icon: definition.icon } : {},
@@ -12018,7 +12733,7 @@ var ProductDriftError = class extends Error {
 * Best-effort extraction of `{ status, body }` from the generic request
 * error thrown by RuntypeClient ("API request failed: 409 Conflict - {…}").
 */
-function parseRequestError$1(err) {
+function parseRequestError$2(err) {
 	if (!(err instanceof Error)) return {
 		status: null,
 		body: null
@@ -12041,7 +12756,7 @@ function parseRequestError$1(err) {
 	}
 }
 function toConflictError$1(err) {
-	const { status, body } = parseRequestError$1(err);
+	const { status, body } = parseRequestError$2(err);
 	if (status !== 409 || !isPlainObject$1(body)) return null;
 	const code = body.code;
 	if (code !== "external_modification" && code !== "remote_changed") return null;
@@ -12163,20 +12878,85 @@ function defineFpo(fpo) {
 	if (!product || typeof product.name !== "string" || product.name.length === 0) throw new Error("defineFpo requires a non-empty \"product.name\" (the converge identity)");
 	return fpo;
 }
+const FPO_DRIFT_RESULTS = /* @__PURE__ */ new Set([
+	"created",
+	"updated",
+	"pruned",
+	"failed"
+]);
+/** Thrown by `ensureFpo(fpo, { expectNoChanges: true })` when the plan is not clean. */
+var FpoDriftError = class extends Error {
+	constructor(plan) {
+		const drifted = plan.entities.filter((entity) => FPO_DRIFT_RESULTS.has(entity.result)).map((entity) => `${entity.kind}:${entity.name} (${entity.result})`);
+		super(`Product "${plan.productId ?? "definition"}" drifted (${drifted.join(", ")}). Run client.products.pullFpo(name) to absorb the remote edit into your repo, or re-run ensureFpo to converge.`);
+		this.name = "FpoDriftError";
+		this.plan = plan;
+	}
+};
+function fpoPlanHasDrift(plan) {
+	return plan.entities.some((entity) => FPO_DRIFT_RESULTS.has(entity.result));
+}
+function parseRequestError$1(err) {
+	if (!(err instanceof Error)) return {
+		status: null,
+		body: null
+	};
+	const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+	if (!match) return {
+		status: null,
+		body: null
+	};
+	try {
+		return {
+			status: Number(match[1]),
+			body: JSON.parse(match[2])
+		};
+	} catch {
+		return {
+			status: Number(match[1]),
+			body: null
+		};
+	}
+}
+async function requestFpoEnsure(client, body) {
+	try {
+		return await client.post("/products/ensure-fpo", body);
+	} catch (err) {
+		const { status, body: errorBody } = parseRequestError$1(err);
+		if (status === 409 && isPlainObject$1(errorBody) && (errorBody.code === "external_modification" || errorBody.code === "remote_changed")) throw new ProductEnsureConflictError(errorBody);
+		throw err;
+	}
+}
 /**
-* Converge an entire FPO onto the platform. Ships the full FPO (no hash-only
-* probe in this release); the server fans out to the per-entity ensure services
-* and returns the whole-FPO hash + per-entity report. Non-atomic: inspect
-* `result.hasFailures` / `entities[].result` and re-run to self-heal.
+* Converge an entire FPO onto the platform. Ships the full FPO unless a
+* drafts-only `hashProbe` finds the live graph already matches; the server fans out to the
+* per-entity ensure services and returns the whole-FPO hash + per-entity report.
+* Non-atomic: inspect `result.hasFailures` / `entities[].result` and re-run to self-heal.
 */
 async function ensureFpo(client, fpo, options = {}) {
-	const { dryRun, onConflict, prune } = options;
-	return client.post("/products/ensure-fpo", {
+	const { dryRun, onConflict, prune, expectNoChanges, expectedRemoteHash, hashProbe, release } = options;
+	const plan = dryRun || expectNoChanges;
+	const guard = expectedRemoteHash ? { expectedRemoteHash } : {};
+	if (hashProbe && release === "none" && !plan && !prune) {
+		const probe = await requestFpoEnsure(client, {
+			name: (isPlainObject$1(fpo.product) ? fpo.product : {}).name,
+			contentHash: await computeFpoContentHash(fpo),
+			...guard,
+			release
+		});
+		if (probe.result !== "definitionRequired") return probe;
+	}
+	const result = await requestFpoEnsure(client, {
 		fpo,
-		...dryRun ? { dryRun: true } : {},
+		...plan ? { dryRun: true } : {},
 		...onConflict ? { onConflict } : {},
-		...prune ? { prune: true } : {}
+		...prune ? { prune: true } : {},
+		...guard,
+		...release ? { release } : {}
 	});
+	if (result.result === "definitionRequired") throw new Error("Server reported definitionRequired for a full-FPO request");
+	if (expectNoChanges && fpoPlanHasDrift(result)) throw new FpoDriftError(result);
+	return result;
 }
 /**
 * Reconstruct a self-contained FPO from the live product graph (resolved by
@@ -12351,8 +13131,8 @@ function defineSurface(input) {
 	if (typeof input.name !== "string" || input.name.length === 0) throw new Error("defineSurface requires a non-empty string \"name\"");
 	if (typeof input.type !== "string" || !SURFACE_DEFINITION_TYPES.has(input.type)) throw new Error(`defineSurface requires "type" to be one of: ${[...SURFACE_DEFINITION_TYPES].join(", ")}`);
 	if (input.behavior !== void 0 && !isPlainObject$1(input.behavior)) throw new Error("defineSurface \"behavior\" must be an object when provided");
-	if (input.inbound !== void 0 && !isPlainObject$1(input.inbound)) throw new Error("defineSurface \"inbound\" must be an object when provided");
-	if (input.outbound !== void 0 && !isPlainObject$1(input.outbound)) throw new Error("defineSurface \"outbound\" must be an object when provided");
+	if (input.inbound !== void 0 && input.inbound !== null && !isPlainObject$1(input.inbound)) throw new Error("defineSurface \"inbound\" must be an object or null when provided");
+	if (input.outbound !== void 0 && input.outbound !== null && !isPlainObject$1(input.outbound)) throw new Error("defineSurface \"outbound\" must be an object or null when provided");
 	if (input.status !== void 0 && ![
 		"draft",
 		"active",
@@ -12474,14 +13254,16 @@ async function ensureSurface(client, productId, definition, options = {}) {
 	const localHash = await computeSurfaceContentHash(definition);
 	const memoKey = `${productId} ${definition.name} ${localHash}`;
 	const contentHash = memo.get(memoKey) ?? localHash;
-	const probe = await request(client, productId, {
-		name: definition.name,
-		contentHash,
-		...passthrough
-	});
-	if (probe.result !== "definitionRequired") {
-		memoize(memo, memoKey, probe);
-		return probe;
+	if (!(definition.inbound !== void 0 || definition.outbound !== void 0)) {
+		const probe = await request(client, productId, {
+			name: definition.name,
+			contentHash,
+			...passthrough
+		});
+		if (probe.result !== "definitionRequired") {
+			memoize(memo, memoKey, probe);
+			return probe;
+		}
 	}
 	const converged = await request(client, productId, {
 		name: definition.name,
@@ -12494,8 +13276,8 @@ async function ensureSurface(client, productId, definition, options = {}) {
 }
 /**
 * Pull the canonical definition + provenance for a surface by name within a
-* product — the absorb-drift direction. The contentHash reflects the live
-* surface state.
+* product — the absorb-drift direction. Configured credentials come back as
+* `'<redacted>'`, which `ensure` accepts to keep the stored value.
 */
 async function pullSurface(client, productId, name) {
 	return client.get(`/products/${encodeURIComponent(productId)}/surfaces/pull`, { name });
@@ -13210,6 +13992,25 @@ var Runtype = class {
 		return new ToolsNamespace(() => this.getClient());
 	}
 	/**
+	* Question sets namespace - Question set config-as-code (define / ensure / pull)
+	*
+	* @example
+	* ```typescript
+	* import { defineQuestionSet, Runtype } from '@runtypelabs/sdk'
+	*
+	* const triage = defineQuestionSet({
+	*   slug: 'ticket-triage',
+	*   name: 'Ticket triage',
+	*   questions: { urgent: { type: 'boolean', instructions: 'Is the ticket urgent?' } },
+	* })
+	*
+	* await Runtype.questionSets.ensure(triage, { release: 'publish' })
+	* ```
+	*/
+	static get questionSets() {
+		return new QuestionSetsNamespace(() => this.getClient());
+	}
+	/**
 	* Products namespace - Product config-as-code (define / ensure / pull)
 	*
 	* Converges the top-level product record (description, icon, spec). Nested
@@ -13498,7 +14299,7 @@ function transformQueryParams(params) {
 }
 //#endregion
 //#region src/version.ts
-const SDK_VERSION = "10.8.0";
+const SDK_VERSION = "10.9.0";
 /**
 * Canonical client identity the API uses for attribution
 * (`detectActorSource` in apps/api/src/lib/audit-log.ts keys `'sdk'` off the
@@ -13709,9 +14510,11 @@ var RuntypeClient = class {
 			}
 		};
 		let currentResponse;
+		let carriedRelease = {};
 		if (isStreaming) currentResponse = await this.dispatch.executeStream(modifiedRequest);
 		else {
 			const data = await this.dispatch.execute(modifiedRequest);
+			carriedRelease = releaseFieldsOf(data);
 			currentResponse = new Response(JSON.stringify(data), { headers: { "content-type": "application/json" } });
 		}
 		while (true) {
@@ -13745,7 +14548,11 @@ var RuntypeClient = class {
 					if (isStreaming) currentResponse = await this.dispatch.resume(resumeData);
 					else {
 						const data = await this.dispatch.resume(resumeData);
-						const envelope = isDetachedToolOutputAck(data) ? await followDetachedResume(this, data.executionId, result.resumeCursor) : data;
+						carriedRelease = {
+							...carriedRelease,
+							...releaseFieldsOf(data)
+						};
+						const envelope = isDetachedToolOutputAck(data) ? await followDetachedResume(this, data, result.resumeCursor, carriedRelease) : data;
 						currentResponse = new Response(JSON.stringify(envelope), { headers: { "content-type": "application/json" } });
 					}
 				} catch (error) {
@@ -15708,6 +16515,8 @@ exports.ClientTokenDriftError = ClientTokenDriftError;
 exports.ClientTokenEnsureError = ClientTokenEnsureError;
 exports.ClientTokensEndpoint = ClientTokensEndpoint;
 exports.ClientTokensNamespace = ClientTokensNamespace;
+exports.CollectionDriftError = CollectionDriftError;
+exports.CollectionEnsureConflictError = CollectionEnsureConflictError;
 exports.CollectionsEndpoint = CollectionsEndpoint;
 exports.ContextTemplatesEndpoint = ContextTemplatesEndpoint;
 exports.ConversationsEndpoint = ConversationsEndpoint;
@@ -15717,7 +16526,9 @@ exports.DEFAULT_STALL_STOP_AFTER = DEFAULT_STALL_STOP_AFTER;
 exports.DispatchEndpoint = DispatchEndpoint;
 exports.ENSURE_RELEASE_DEPLOY_CONFLICT_MESSAGE = ENSURE_RELEASE_DEPLOY_CONFLICT_MESSAGE;
 exports.EvalBuilder = EvalBuilder;
+exports.EvalDriftError = EvalDriftError;
 exports.EvalEndpoint = EvalEndpoint;
+exports.EvalEnsureConflictError = EvalEnsureConflictError;
 exports.EvalRunner = EvalRunner;
 exports.EvalSuitesNamespace = EvalSuitesNamespace;
 exports.EvalsNamespace = EvalsNamespace;
@@ -15731,6 +16542,7 @@ exports.FlowStepsEndpoint = FlowStepsEndpoint;
 exports.FlowVersionsEndpoint = FlowVersionsEndpoint;
 exports.FlowsEndpoint = FlowsEndpoint;
 exports.FlowsNamespace = FlowsNamespace;
+exports.FpoDriftError = FpoDriftError;
 exports.IntegrationsEndpoint = IntegrationsEndpoint;
 exports.LEDGER_ARTIFACT_LINE_PREFIX = LEDGER_ARTIFACT_LINE_PREFIX;
 exports.LIVE_AGENT_ALIAS = LIVE_AGENT_ALIAS;
@@ -15742,6 +16554,9 @@ exports.ProductsNamespace = ProductsNamespace;
 exports.PromptsEndpoint = PromptsEndpoint;
 exports.PromptsNamespace = PromptsNamespace;
 exports.ProviderKeysEndpoint = ProviderKeysEndpoint;
+exports.QuestionSetDriftError = QuestionSetDriftError;
+exports.QuestionSetEnsureConflictError = QuestionSetEnsureConflictError;
+exports.QuestionSetsNamespace = QuestionSetsNamespace;
 exports.RUNTYPE_CLIENT_KIND = RUNTYPE_CLIENT_KIND;
 exports.RecordsEndpoint = RecordsEndpoint;
 exports.RunsNamespace = RunsNamespace;
@@ -15753,6 +16568,8 @@ exports.SDK_USER_AGENT = SDK_USER_AGENT;
 exports.SDK_VERSION = SDK_VERSION;
 exports.STEP_FIELD_REGISTRY = STEP_FIELD_REGISTRY;
 exports.STEP_TYPE_TO_METHOD = STEP_TYPE_TO_METHOD;
+exports.ScheduleDriftError = ScheduleDriftError;
+exports.ScheduleEnsureConflictError = ScheduleEnsureConflictError;
 exports.SchedulesEndpoint = SchedulesEndpoint;
 exports.SecretsEndpoint = SecretsEndpoint;
 exports.SkillDriftError = SkillDriftError;
@@ -15792,6 +16609,10 @@ exports.computeEvalContentHash = computeEvalContentHash;
 exports.computeFlowContentHash = computeFlowContentHash;
 exports.computeFpoContentHash = computeFpoContentHash;
 exports.computeProductContentHash = computeProductContentHash;
+exports.computeQuestionSetContentHash = computeQuestionSetContentHash;
+exports.computeRecordCollectionContentHash = computeRecordCollectionContentHash;
+exports.computeScheduleContentHash = computeScheduleContentHash;
+exports.computeScheduleDefinitionHash = computeScheduleDefinitionHash;
 exports.computeSkillContentHash = computeSkillContentHash;
 exports.computeSurfaceContentHash = computeSurfaceContentHash;
 exports.computeToolContentHash = computeToolContentHash;
@@ -15809,6 +16630,8 @@ exports.defineFlow = defineFlow;
 exports.defineFpo = defineFpo;
 exports.definePlaybook = definePlaybook;
 exports.defineProduct = defineProduct;
+exports.defineQuestionSet = defineQuestionSet;
+exports.defineSchedule = defineSchedule;
 exports.defineSkill = defineSkill;
 exports.defineSurface = defineSurface;
 exports.defineTool = defineTool;
@@ -15816,8 +16639,10 @@ exports.deployWorkflow = deployWorkflow;
 exports.ensureDefaultWorkflowHooks = ensureDefaultWorkflowHooks;
 exports.ensureEval = ensureEval;
 exports.ensureFpo = ensureFpo;
+exports.ensureSchedule = ensureSchedule;
 exports.evaluateGeneratedRuntimeToolProposal = evaluateGeneratedRuntimeToolProposal;
 exports.extractDeclaredToolResultChars = extractDeclaredToolResultChars;
+exports.fpoPlanHasDrift = fpoPlanHasDrift;
 exports.gameWorkflow = gameWorkflow;
 exports.getDefaultPlanPath = getDefaultPlanPath;
 exports.getLikelySupportingCandidatePaths = getLikelySupportingCandidatePaths;
@@ -15842,6 +16667,9 @@ exports.normalizeAgentDefinition = normalizeAgentDefinition;
 exports.normalizeCandidatePath = normalizeCandidatePath;
 exports.normalizeFpoDefinition = normalizeFpoDefinition;
 exports.normalizeProductDefinition = normalizeProductDefinition;
+exports.normalizeQuestionSetDefinition = normalizeQuestionSetDefinition;
+exports.normalizeRecordCollectionDefinition = normalizeRecordCollectionDefinition;
+exports.normalizeScheduleContent = normalizeScheduleContent;
 exports.normalizeSkillDefinition = normalizeSkillDefinition;
 exports.normalizeSurfaceDefinition = normalizeSurfaceDefinition;
 exports.normalizeToolDefinition = normalizeToolDefinition;
@@ -15857,6 +16685,7 @@ exports.promoteAgent = promoteAgent;
 exports.promotionIdempotencyKey = promotionIdempotencyKey;
 exports.pullEval = pullEval;
 exports.pullFpo = pullFpo;
+exports.pullSchedule = pullSchedule;
 exports.ranStep = ranStep;
 exports.regex = regex;
 exports.registerWorkflowHook = registerWorkflowHook;