@stackbone/cli 0.4.0 → 0.5.0

package/main.js

@@ -1427,7 +1427,9 @@ var init_errors$1 = __esmMin((() => {
 		"connector_installation_required",
 		"principal_required",
 		"access_denied",
-		"invalid_grant"
+		"invalid_grant",
+		"precondition_failed",
+		"cardinality_mismatch"
 	];
 	BROKER_ERROR_CODES = z.enum([...CONNECTOR_EXECUTION_ERROR_CODES, ...BROKER_SPECIFIC_ERROR_CODES]);
 	z.object({
@@ -1460,6 +1462,19 @@ var init_errors$1 = __esmMin((() => {
 		connector_installation_required: false,
 		/** The refresh token is dead. Needs a fresh authorization, not another try. */
 		invalid_grant: false,
+		/**
+		* A write carrying a precondition matched no rows: somebody moved the row
+		* between the read and the write, so the write was NOT applied (PLA-1403).
+		*
+		* Terminal, and this one is the whole point rather than a classification
+		* detail. The condition is a fact about the provider's current state, so the
+		* identical call refuses identically; and a retry is precisely the wrong move,
+		* because the value the caller is guarding on is the stale one. What has to
+		* happen next is a fresh read, which only the caller can do.
+		*/
+		precondition_failed: false,
+		/** A narrower target is needed; repeating the same write exceeds the same limit. */
+		cardinality_mismatch: false,
 		/** Transport, or the provider answering 5xx. */
 		execute_failed: true,
 		/** The deadline passed. The next attempt may fit inside it. */
@@ -1479,7 +1494,6 @@ var init_errors$1 = __esmMin((() => {
 		no_token: true,
 		user_authorization_required: true
 	};
-	Object.entries(BROKER_ERROR_RETRYABILITY).filter(([, retryable]) => !retryable).map(([code]) => code);
 	REASON_ALIASES = { app_not_installed: "connector_installation_required" };
 }));
 //#endregion
@@ -1969,7 +1983,19 @@ var init_connect_surface = __esmMin((() => {
 		error: z.object({
 			/** The broker taxonomy code, e.g. `not_found`, `no_token`, `execute_failed`. */
 			code: z.string(),
-			message: z.string()
+			message: z.string(),
+			/**
+			* The broker's own retry classification, decided one code at a time and
+			* overridable per site. It has to cross the wire (PLA-1349): the workflow
+			* engine re-runs a failed step unless the error is fatal, and the SDK cannot
+			* mark it fatal from a code alone without keeping a second copy of the
+			* taxonomy that would drift from the broker's.
+			*
+			* Optional because an older box may not send it, and an absent value means
+			* "not classified" rather than "retryable" — the SDK leaves such a failure
+			* retryable, which is the safe direction for a transient outage.
+			*/
+			retryable: z.boolean().optional()
 		})
 	});
 	connectEvictResponseSchema = z.object({
@@ -9694,14 +9720,20 @@ var init_connector_invoker = __esmMin((() => {
 * @param connector The connect connector id registered in Studio.
 * @param operation The operation / tool id to run on that connector.
 * @param args      The operation arguments (path/query/body params). Defaults `{}`.
-* @param opts      Optional `{ principal }` — defaults to `{ type: 'app' }`.
+* @param opts      Optional `{ principal, idempotent, echoPath }`. `principal`
+*                  defaults to `{ type: 'app' }`; `idempotent` is UNSET by
+*                  default and only an explicit `false` changes how a failure is
+*                  retried; `echoPath` records what this write returned so a
+*                  later delivery of it can be recognised as our own.
 */
 async function callConnector(connector, operation, args, opts) {
 	return (await getConnectorInvoker().invoke({
 		connector,
 		operation,
 		...args !== void 0 ? { args } : {},
-		...opts?.principal !== void 0 ? { principal: opts.principal } : {}
+		...opts?.principal !== void 0 ? { principal: opts.principal } : {},
+		...opts?.idempotent !== void 0 ? { idempotent: opts.idempotent } : {},
+		...opts?.echoPath !== void 0 ? { echoPath: opts.echoPath } : {}
 	})).output;
 }
 var connectorHandle, connection;
@@ -14339,6 +14371,29 @@ var createInvocationsStore = (opts) => {
 			]);
 			return rows[0]?.id ?? null;
 		},
+		async findEchoRecord(input) {
+			assertOpen();
+			const args = [
+				input.connector,
+				input.value,
+				input.windowMs
+			];
+			let markerScope = "";
+			if (input.workflowName !== null) {
+				args.push(input.workflowName);
+				markerScope = ` AND (input->>'workflowName' = $${args.length} OR input->>'workflowName' IS NULL)`;
+			}
+			const { rows } = await readPool.query(`SELECT bool_or(input->>'echo' = $2) AS matched,
+                bool_or(input->>'echoUnresolved' = 'true'${markerScope}) AS unresolved
+           FROM stackbone_platform.run_steps
+          WHERE type = 'connection'
+            AND input->>'connector' = $1
+            AND created_at > now() - ($3::bigint * interval '1 millisecond')`, args);
+			return {
+				matched: rows[0]?.matched === true,
+				unresolved: rows[0]?.unresolved === true
+			};
+		},
 		async annotatePromptUse(input) {
 			if (!isUuid(input.runId)) return;
 			assertOpen();
@@ -15221,7 +15276,8 @@ var createTriggerSubscriptionsStore = (opts) => {
 			assertOpen();
 			await pool.query(`UPDATE stackbone_platform.trigger_deliveries
             SET status = 'rejected', issues = $3::jsonb, updated_at = now()
-          WHERE subscription_id = $1::uuid AND provider_item_id = $2`, [
+          WHERE subscription_id = $1::uuid AND provider_item_id = $2
+            AND status IN ('claimed', 'starting')`, [
 				subscriptionId,
 				providerItemId,
 				JSON.stringify(issues)
@@ -15669,7 +15725,7 @@ var emulatorCors = (allowlist) => cors({
 var STACKBONE_CLI_BUILD_VERSION, EMULATOR_CAPABILITY_ROUTES, EMULATOR_CAPABILITIES, buildContractResponse;
 var init_contract = __esmMin((() => {
 	init_src$19();
-	STACKBONE_CLI_BUILD_VERSION = "0.4.0";
+	STACKBONE_CLI_BUILD_VERSION = "0.5.0";
 	EMULATOR_CAPABILITY_ROUTES = {
 		"database.postgres_direct": "/api/db",
 		"rag.basic": "/api/rag",
@@ -30692,6 +30748,8 @@ var init_types$1 = __esmMin((() => {
 		description: z.string().optional(),
 		parameters: z.array(operationParameterSchema).optional(),
 		requestBodySchema: z.unknown().optional(),
+		/** Original Swagger body parameter name; allows body values alongside query filters. */
+		bodyArgName: z.string().optional(),
 		responseSchema: z.unknown().optional(),
 		/**
 		* This operation's body is BYTES, not JSON. The executor then resolves the
@@ -31615,7 +31673,9 @@ var init_types = __esmMin((() => {
 			/** A policy denial on a VALID key: no credential eviction, no retry loop. */
 			accessDenied: z.array(z.string()).default([]),
 			/** A data conflict on a write (unique / FK violation): terminal, handleable. */
-			conflict: z.array(z.string()).default([])
+			conflict: z.array(z.string()).default([]),
+			/** The provider rejected a write that exceeded its requested row limit. */
+			cardinalityMismatch: z.array(z.string()).optional()
 		}).optional(),
 		/**
 		* The query parameter that carries "which columns to return" on this
@@ -32269,8 +32329,8 @@ var init_github_connector = __esmMin((() => {
 		triggers: [{
 			id: "commit-pushed",
 			displayName: "New commit by date",
-			description: "Starts one run per commit whose committer date is newer than this link’s cursor. This follows commit dates, not push times: pushing an older local commit or merging existing commits without changing their committer dates can leave them undetected. A poll reads up to 10,000 commits; a larger window can skip its oldest commits. CAUTION: a workflow that writes a file to the watched branch can create a commit that re-triggers itself. Each new commit has a new SHA, so deduplication cannot stop the loop. Guard inside the workflow body: identify commits your workflow created and return without writing, or write to a separate branch that this link does not watch. A trigger mapping cannot skip an event.",
-			docs: "Watches commits on the selected branch, or the repository’s default branch when Branch is blank. Starts one run per commit whose committer date is newer than the saved cursor.\n\nThe cursor starts at the time you turn the link on. Push time is not recorded: commits created earlier and pushed later, including existing commits added by a fast-forward merge, can be skipped. Rebasing or squashing can assign new committer dates.\n\nEach poll reads up to 10,000 commits. If more commits match, the oldest may be skipped.\n\nCAUTION: a workflow that writes a file to the watched branch can create a commit that re-triggers itself. Each new commit has a new SHA, so deduplication cannot stop the loop. Guard inside the workflow body: identify commits your workflow created and return without writing, or write to a separate branch that this link does not watch. A trigger mapping cannot skip an event.",
+			description: "Starts one run per commit whose committer date is newer than this link’s cursor. This follows commit dates, not push times: pushing an older local commit or merging existing commits without changing their committer dates can leave them undetected. A poll reads up to 10,000 commits; a larger window can skip its oldest commits. CAUTION: a workflow that writes a file to the watched branch can create a commit that re-triggers itself. Each new commit has a new SHA, so deduplication cannot stop the loop. THIS CONNECTOR EXPOSES NO WRITE OPERATION, so the `isOwnEcho` guard has nothing to compare against and the workaround is the branch: write to a separate branch that this link does not watch. A trigger mapping cannot skip an event.",
+			docs: "Watches commits on the selected branch, or the repository’s default branch when Branch is blank. Starts one run per commit whose committer date is newer than the saved cursor.\n\nThe cursor starts at the time you turn the link on. Push time is not recorded: commits created earlier and pushed later, including existing commits added by a fast-forward merge, can be skipped. Rebasing or squashing can assign new committer dates.\n\nEach poll reads up to 10,000 commits. If more commits match, the oldest may be skipped.\n\nCAUTION: a workflow that writes a file to the watched branch can create a commit that re-triggers itself. Each new commit has a new SHA, so deduplication cannot stop the loop. This connector exposes no write operation, so the `isOwnEcho` guard has nothing to compare against, and the workaround is the branch: write to a separate branch that this link does not watch. A trigger mapping cannot skip an event.",
 			sampleData: {
 				sha: "11589d462dc2b29714240e03ce310e7b15aa94c3",
 				url: "https://github.com/stackbone/stackbone/commit/11589d462dc2b29714240e03ce310e7b15aa94c3",
@@ -32351,8 +32411,8 @@ var init_github_connector = __esmMin((() => {
 		}, {
 			id: "issue-updated",
 			displayName: "Issue updated",
-			description: "Fires on every change to an issue in the repository after the link was turned on, following `updated_at`. CLOSED ISSUES ARE INCLUDED — the link asks for `state=all`, so resolving an issue is a change you receive. PULL REQUESTS ARRIVE HERE TOO: GitHub models every pull request as an issue and this endpoint returns both, and only a `pullRequest` object on the payload tells them apart — it is absent on a real issue. A newly opened issue arrives as well, with `createdAt` equal to `updatedAt`. CAUTION: a workflow that writes back to the issue it received — a comment, a label, a close — bumps `updated_at` and re-triggers itself, and the delivery journal cannot stop it. GitHub sends nothing that says who made a change (`author` is who OPENED the issue), so the guard is for your workflow to remember the `updated_at` its own write returned and skip a delivery carrying that value. A trigger mapping cannot skip an item; every delivered event starts a run.",
-			docs: "Starts a run on every change to an issue in the repository, from the moment the link is turned on. Closed issues count: resolving one is a change you receive. Pull requests arrive here too, because GitHub models each one as an issue. A `pullRequest` object on the event is what tells them apart, and it is absent on a real issue. A newly opened issue arrives as well, with `createdAt` equal to `updatedAt`.\n\nCAUTION: a workflow that writes back to the issue it received (a comment, a label, a close) bumps `updatedAt` and starts itself again. Nothing on the platform stops that loop, and GitHub sends no field saying who made a change (`author` is whoever opened the issue). Have your workflow remember the `updatedAt` its own write returned, and skip a delivery carrying that value. A mapping cannot skip an event: every delivery starts a run.",
+			description: "Fires on every change to an issue in the repository after the link was turned on, following `updated_at`. CLOSED ISSUES ARE INCLUDED — the link asks for `state=all`, so resolving an issue is a change you receive. PULL REQUESTS ARRIVE HERE TOO: GitHub models every pull request as an issue and this endpoint returns both, and only a `pullRequest` object on the payload tells them apart — it is absent on a real issue. A newly opened issue arrives as well, with `createdAt` equal to `updatedAt`. CAUTION: a workflow that writes back to the issue it received — a comment, a label, a close — bumps `updated_at` and re-triggers itself, and the delivery journal cannot stop it. GitHub sends nothing that says who made a change (`author` is who OPENED the issue), and THIS CONNECTOR EXPOSES NO WRITE OPERATION, so the `isOwnEcho` guard has nothing to compare against: whatever wrote the issue did not go through here. Until a write lands on this connector the workaround is outside it. A trigger mapping cannot skip an item; every delivered event starts a run.",
+			docs: "Starts a run on every change to an issue in the repository, from the moment the link is turned on. Closed issues count: resolving one is a change you receive. Pull requests arrive here too, because GitHub models each one as an issue. A `pullRequest` object on the event is what tells them apart, and it is absent on a real issue. A newly opened issue arrives as well, with `createdAt` equal to `updatedAt`.\n\nCAUTION: a workflow that writes back to the issue it received (a comment, a label, a close) bumps `updatedAt` and starts itself again. Nothing on the platform stops that loop, and GitHub sends no field saying who made a change (`author` is whoever opened the issue). This connector exposes no write operation, so the `isOwnEcho` guard has nothing to compare against: whatever wrote the issue did not go through here. Until a write lands on this connector, the workaround is outside it. A mapping cannot skip an event: every delivery starts a run.",
 			sampleData: {
 				issueId: 5320382826,
 				number: 14317,
@@ -32748,7 +32808,7 @@ var init_google_drive_connector = __esmMin((() => {
 						post: {
 							operationId: "drive.files.create",
 							summary: "Create a folder, or a file with metadata but no content",
-							description: "Metadata only — this sends JSON, never bytes. A folder is `mimeType: \"application/vnd.google-apps.folder\"`. To create a file WITH content use `drive.files.upload`, which sends the bytes from object storage against Google's upload host; this operation creates the file empty. If a workflow of yours also watches the destination folder, ask for `modifiedTime` in `fields` — otherwise the response carries no version and nothing can tell your own file from one a person dropped in.",
+							description: "Metadata only — this sends JSON, never bytes. A folder is `mimeType: \"application/vnd.google-apps.folder\"`. To create a file WITH content use `drive.files.upload`, which sends the bytes from object storage against Google's upload host; this operation creates the file empty. If a workflow of yours also watches the destination folder, ask for `id` in `fields` and declare `echoPath: 'id'` on the call, then open that workflow with `isOwnEcho('google-drive', event.fileId)`. The trigger keys on the file ID, so the ID is the value to compare — a `modifiedTime` echo would never match it.",
 							"x-stackbone-version-path": "modifiedTime",
 							parameters: [FIELDS_PARAM, SUPPORTS_ALL_DRIVES_PARAM],
 							requestBody: {
@@ -32818,7 +32878,7 @@ var init_google_drive_connector = __esmMin((() => {
 						patch: {
 							operationId: "drive.files.update",
 							summary: "Rename a file, move it between folders, or set its metadata",
-							description: "The move is the two QUERY parameters, not the body: `addParents` and `removeParents`. `name` goes in the JSON body. Both in one call is how a file gets named and filed at once. If a workflow of yours also watches this folder, ask for `modifiedTime` in `fields` — otherwise the response carries no version and nothing can tell your own change from somebody else's.",
+							description: "The move is the two QUERY parameters, not the body: `addParents` and `removeParents`. `name` goes in the JSON body. Both in one call is how a file gets named and filed at once. This one does NOT re-trigger `file-added-to-folder`: that trigger fires once per file, so an edit to a file it already delivered starts nothing. The self-write loop to guard is the one the CREATE and UPLOAD operations open, not this one.",
 							"x-stackbone-version-path": "modifiedTime",
 							parameters: [
 								{
@@ -33126,8 +33186,8 @@ var init_google_drive_connector = __esmMin((() => {
 		triggers: [{
 			id: "file-added-to-folder",
 			displayName: "File added to folder",
-			description: "Starts a run the first time a file in one Drive folder arrives or changes — once per file, so later edits to a file already delivered start nothing. Watches the folder itself, not its subfolders. CAUTION: a file this connector uploads to the watched folder can re-trigger the workflow. Each upload creates a new file id, so deduplication cannot stop the loop. Guard inside the workflow body: identify files your workflow uploaded and return without writing, or use separate input and output folders. A trigger mapping cannot skip an event.",
-			docs: "Starts a run the first time a file in one Drive folder arrives or changes. Once per file: a later edit to a file already delivered starts nothing. It watches the folder itself, not its subfolders.\n\nCAUTION: a file this connector uploads to the watched folder can re-trigger the workflow. Each upload creates a new file id, so deduplication cannot stop the loop. Guard inside the workflow body: identify files your workflow uploaded and return without writing, or use separate input and output folders. A trigger mapping cannot skip an event.",
+			description: "Starts a run the first time a file in one Drive folder arrives or changes — once per file, so later edits to a file already delivered start nothing. Watches the folder itself, not its subfolders. CAUTION: a file this connector uploads to the watched folder can re-trigger the workflow. Each upload creates a new file id, so deduplication cannot stop the loop. Guard INSIDE THE WORKFLOW BODY with `isOwnEcho`, for a file the workflow creates by calling `drive.files.create` or `drive.files.upload` ITSELF: pass `fields: 'id'` and `echoPath: 'id'` on that call, then open the workflow with `if (await isOwnEcho('google-drive', event.fileId)) return;`. NAME `fields` FOR WHATEVER THE ECHO PATH POINTS AT, because Drive answers a partial response by default and a path onto a field it left out resolves to nothing, which makes the guard throw rather than answer. THE `drive.file-write` OUTPUT WRITER CANNOT CARRY AN ECHO PATH, so a workflow that files its output through it is not covered and still needs separate input and output folders. A trigger mapping cannot skip an event.",
+			docs: "Starts a run the first time a file in one Drive folder arrives or changes. Once per file: a later edit to a file already delivered starts nothing. It watches the folder itself, not its subfolders.\n\nCAUTION: a file this connector uploads to the watched folder starts the workflow again. Each upload creates a new file id, so deduplication cannot stop the loop. Guard inside the workflow body with `isOwnEcho`, for a file the workflow creates by calling Drive's own `create` or `upload` operation itself: pass `fields: 'id'` and `echoPath: 'id'` on that call, then open the workflow with `if (await isOwnEcho('google-drive', event.fileId)) return;`. Name `fields` for whatever the echo path points at, because Drive answers a partial response by default, and a path onto a field it left out resolves to nothing, which makes the guard throw rather than answer. The `drive.file-write` output writer cannot carry an echo path, so a workflow that files its output through it is not covered and still needs separate input and output folders. A mapping cannot skip an event: every delivery starts a run.",
 			sampleData: {
 				fileId: "1a2B3cD4eF5gH6iJ7kL8mN9oP",
 				name: "Weekly sync 2026-08-25.pdf",
@@ -33347,8 +33407,8 @@ var init_linear_connector = __esmMin((() => {
 			{
 				id: "issue-created",
 				displayName: "Issue created",
-				description: "Fires once per issue created in the workspace after the link was turned on, following `createdAt`. CAUTION: a workflow that creates an issue in this workspace can re-trigger itself. Each new issue has a new id, so deduplication cannot stop the loop. Guard inside the workflow body: mark issues you create in their title or description, and return without writing when an incoming issue carries that marker. A trigger mapping cannot skip an event.",
-				docs: "Starts one run per issue created in the workspace, from the moment the link is turned on.\n\nCAUTION: a workflow that creates an issue in this workspace can re-trigger itself. Each new issue has a new id, so deduplication cannot stop the loop. Guard inside the workflow body: mark issues you create in their title or description, and return without writing when an incoming issue carries that marker. A trigger mapping cannot skip an event.",
+				description: "Fires once per issue created in the workspace after the link was turned on, following `createdAt`. CAUTION: a workflow that creates an issue in this workspace can re-trigger itself. Each new issue has a new id, so deduplication cannot stop the loop. Guard INSIDE THE WORKFLOW BODY with `isOwnEcho`: have the `issueCreate` mutation select `issue { id }`, declare `echoPath: 'data.issueCreate.issue.id'` on the write, then open the workflow with `if (await isOwnEcho('linear', event.issueId)) return;`. It compares the id your own write returned against the one delivered. The connector id you pass is the one you passed to `connection()`. A trigger mapping cannot skip an event.",
+				docs: "Starts one run per issue created in the workspace, from the moment the link is turned on.\n\nCAUTION: a workflow that creates an issue in this workspace starts itself again. Each new issue has a new id, so deduplication cannot stop the loop. Guard inside the workflow body with `isOwnEcho`. The `issueCreate` mutation has to select `issue { id }`, because the guard can only record a value the response carries. Declare `echoPath: 'data.issueCreate.issue.id'` on the write, then open the workflow with `if (await isOwnEcho('linear', event.issueId)) return;`. That compares the id your own write returned against the one you were handed. The connector id you pass to `isOwnEcho` is the same one you passed to `connection()`. A mapping cannot skip an event: every delivery starts a run.",
 				sampleData: {
 					issueId: "a1b2c3d4-0000-0000-0000-000000000000",
 					identifier: "PLA-812",
@@ -33437,8 +33497,8 @@ var init_linear_connector = __esmMin((() => {
 			{
 				id: "comment-created",
 				displayName: "Comment created",
-				description: "Fires once per comment posted on any issue in the workspace after the link was turned on, following `createdAt`. CAUTION: a workflow that replies by posting a comment in this workspace can re-trigger itself. Each new comment has a new id, so deduplication cannot stop the loop. Guard inside the workflow body: mark comments you post in their body, and return without writing when an incoming comment carries that marker. A trigger mapping cannot skip an event.",
-				docs: "Starts one run per comment posted on any issue in the workspace, from the moment the link is turned on.\n\nCAUTION: a workflow that replies by posting a comment in this workspace can re-trigger itself. Each new comment has a new id, so deduplication cannot stop the loop. Guard inside the workflow body: mark comments you post in their body, and return without writing when an incoming comment carries that marker. A trigger mapping cannot skip an event.",
+				description: "Fires once per comment posted on any issue in the workspace after the link was turned on, following `createdAt`. CAUTION: a workflow that replies by posting a comment in this workspace can re-trigger itself. Each new comment has a new id, so deduplication cannot stop the loop. Guard INSIDE THE WORKFLOW BODY with `isOwnEcho`: have the `commentCreate` mutation select `comment { id }`, declare `echoPath: 'data.commentCreate.comment.id'` on the write, then open the workflow with `if (await isOwnEcho('linear', event.commentId)) return;`. It compares the id your own write returned against the one delivered. A trigger mapping cannot skip an event.",
+				docs: "Starts one run per comment posted on any issue in the workspace, from the moment the link is turned on.\n\nCAUTION: a workflow that replies by posting a comment in this workspace starts itself again. Each new comment has a new id, so deduplication cannot stop the loop. Guard inside the workflow body with `isOwnEcho`. The `commentCreate` mutation has to select `comment { id }`, because the guard can only record a value the response carries. Declare `echoPath: 'data.commentCreate.comment.id'` on the write, then open the workflow with `if (await isOwnEcho('linear', event.commentId)) return;`. That compares the id your own write returned against the one you were handed. A mapping cannot skip an event: every delivery starts a run.",
 				sampleData: {
 					commentId: "e5f6a7b8-0000-0000-0000-000000000000",
 					body: "Shipped on `next`, closing.",
@@ -33530,8 +33590,8 @@ var init_linear_connector = __esmMin((() => {
 			{
 				id: "issue-updated",
 				displayName: "Issue updated",
-				description: "Fires on every change to an issue in the workspace after the link was turned on, following `updatedAt`. A newly created issue arrives here too — compare `createdAt` with `updatedAt` to tell a birth from an edit. `lastActor` / `lastBotActor` carry the actor of the issue's NEWEST HISTORY ENTRY — a `User` when a personal API key made the change, a bot when an OAuth app did. That is the best available signal for who caused a change, not a guarantee that it is: either can arrive null, and an `updatedAt` bump that minted no history entry leaves the previous change's actor in place. CAUTION: a workflow that writes back to the issue it received bumps `updatedAt` and re-triggers itself, and the delivery journal cannot stop it. Guard INSIDE THE WORKFLOW BODY — return without writing when `lastActor` is your own account, and decide deliberately what to do when it is absent rather than dereferencing it. A trigger mapping cannot skip an item; every delivered event starts a run. Write-back can also overwrite a human edit made since the event was read: issueUpdate exposes no version or expected-value precondition. Write only fields reserved for the workflow; reading again before writing does not make the update atomic. Archiving is not delivered, because an archived issue stops matching.",
-				docs: "Starts a run on every change to an issue in the workspace, from the moment the link is turned on. A newly created issue arrives here too, so compare `createdAt` with `updatedAt` to tell a birth from an edit. Archiving is not delivered, because an archived issue stops matching.\n\n`lastActor` and `lastBotActor` carry whoever made the newest change: `lastActor` when a personal API key did it, `lastBotActor` when an OAuth app did. Treat them as the best signal available rather than a guarantee. Either can arrive null, and a change that minted no history entry leaves the previous actor in place.\n\nCAUTION: a workflow that writes back to the issue it received bumps `updatedAt` and starts itself again. Nothing on the platform stops that loop. Guard inside the workflow body: return without writing when `lastActor` is your own account, and decide what to do when it is absent instead of reading through it. A mapping cannot skip an event: every delivery starts a run.\n\nWrite-back can also overwrite a human edit made since the event was read. `issueUpdate` exposes no version or expected-value precondition. Write only fields reserved for the workflow; reading again before writing does not make the update atomic.",
+				description: "Fires on every change to an issue in the workspace after the link was turned on, following `updatedAt`. A newly created issue arrives here too — compare `createdAt` with `updatedAt` to tell a birth from an edit. `lastActor` / `lastBotActor` carry the actor of the issue's NEWEST HISTORY ENTRY — a `User` when a personal API key made the change, a bot when an OAuth app did. Use them to answer who touched this, for instance to ignore every bot's edits; they are not a self-write guard, because either can arrive null and an `updatedAt` bump that minted no history entry leaves the previous change's actor in place. CAUTION: a workflow that writes back to the issue it received bumps `updatedAt` and re-triggers itself, and the delivery journal cannot stop it. Guard INSIDE THE WORKFLOW BODY with `isOwnEcho`: declare `echoPath: 'data.issueUpdate.issue.updatedAt'` on the write, then open the workflow with `if (await isOwnEcho('linear', event.updatedAt)) return;`. It compares the value your own write returned against the one delivered, so it does not depend on an actor field being fresh. A trigger mapping cannot skip an item; every delivered event starts a run. Write-back can also overwrite a human edit made since the event was read: issueUpdate exposes no version or expected-value precondition. Write only fields reserved for the workflow; reading again before writing does not make the update atomic. Archiving is not delivered, because an archived issue stops matching.",
+				docs: "Starts a run on every change to an issue in the workspace, from the moment the link is turned on. A newly created issue arrives here too, so compare `createdAt` with `updatedAt` to tell a birth from an edit. Archiving is not delivered, because an archived issue stops matching.\n\n`lastActor` and `lastBotActor` carry whoever made the newest change: `lastActor` when a personal API key did it, `lastBotActor` when an OAuth app did. They answer who touched this, which is useful on its own, for instance to ignore edits made by bots. They are not the self-write guard: either can arrive null, and a change that minted no history entry leaves the previous actor in place.\n\nCAUTION: a workflow that writes back to the issue it received bumps `updatedAt` and starts itself again. Nothing on the platform stops that loop. Guard inside the workflow body with `isOwnEcho`. Declare where your write reports the new version, `echoPath: 'data.issueUpdate.issue.updatedAt'`, then open the workflow with `if (await isOwnEcho('linear', event.updatedAt)) return;`. That compares the value your own write returned against the one you were handed, so it holds whether or not an actor field is fresh. A mapping cannot skip an event: every delivery starts a run.\n\nWrite-back can also overwrite a human edit made since the event was read. `issueUpdate` exposes no version or expected-value precondition. Write only fields reserved for the workflow; reading again before writing does not make the update atomic.",
 				sampleData: {
 					issueId: "a1b2c3d4-0000-0000-0000-000000000000",
 					identifier: "PLA-812",
@@ -33944,14 +34004,15 @@ var init_supabase_connector = __esmMin((() => {
 				"42"
 			],
 			accessDenied: ["42501"],
-			conflict: ["23"]
+			conflict: ["23"],
+			cardinalityMismatch: ["PGRST124"]
 		},
 		scopes: [],
 		triggers: [{
 			id: "row-inserted",
 			displayName: "Row inserted or changed",
-			description: "Starts a run for each row that appears past the cursor column, delivered as { table, row }. THE CURSOR COLUMN DECIDES WHAT \"APPEARS\" MEANS. Left at the default `id`, or set to any column written once and never touched again such as `created_at`, this is insert-only: one run per new row, and an edit to an existing row is never delivered. Set to a column your database bumps on every write, such as `updated_at`, this is change detection: EVERY UPDATE TO A ROW STARTS A NEW RUN. CAUTION: on a moving column a workflow that writes back to the row it received bumps that column and re-triggers itself, and the delivery journal cannot stop it — guard INSIDE THE WORKFLOW BODY. The table must expose a unique, non-null `id` column for delivery identity. Rows whose cursor value is NULL are ignored. Rows are read in ascending cursor order: a row that becomes visible after the cursor advances, with a value EQUAL TO OR LOWER THAN the highest seen, is not delivered. Choose values that increase as changes become visible; this also applies to timestamp and date columns. A trigger mapping cannot skip an item; every delivered row starts a run.",
-			docs: "Starts a run for each row that appears past the cursor column, delivered as `{ table, row }`.\n\nThe cursor column decides what \"appears\" means, and it is the only choice that matters here. Left at the default `id`, or set to a column written once and never touched again such as `created_at`, this is insert-only: one run per new row, and an edit to an existing row is never delivered. Set to a column your database bumps on every write, such as `updated_at`, it becomes change detection, and every update to a row starts a new run.\n\nThe table must expose a unique, non-null `id` column for delivery identity. Rows whose cursor value is NULL are ignored.\n\nRows are read in ascending cursor order. A row that becomes visible after the cursor advances, with a value equal to or lower than the highest already seen, is not delivered. Choose values that increase as changes become visible; this also applies to timestamp and date columns.\n\nCAUTION: on a moving column, a workflow that writes back to the row it received bumps that column and starts itself again. Nothing on the platform stops that loop, so guard inside the workflow body. A mapping cannot skip an event: every delivered row starts a run.",
+			description: "Starts a run for each row that appears past the cursor column, delivered as { table, row }. THE CURSOR COLUMN DECIDES WHAT \"APPEARS\" MEANS. Left at the default `id`, or set to any column written once and never touched again such as `created_at`, this is insert-only: one run per new row, and an edit to an existing row is never delivered. Set to a column your database bumps on every write, such as `updated_at`, this is change detection: EVERY UPDATE TO A ROW STARTS A NEW RUN. CAUTION: a workflow that writes to this table can re-trigger itself, and the delivery journal cannot stop it: on a moving column a write-back bumps that column, and on the default column a workflow that answers each row by inserting another mints a new id. Guard INSIDE THE WORKFLOW BODY with `isOwnEcho`, and MATCH THE VALUE TO THE CURSOR COLUMN. Insert-only, compare the new row's id: `echoPath: '0.id'` on the write against `event.row.id`. Change detection, compare the cursor column itself: `echoPath: '0.updated_at'` against `event.row.updated_at`, with your own column name in place of `updated_at`. COMPARING THE ID ON A MOVING COLUMN IS WRONG — a row's id never changes, so the guard would read every later delivery of that row as your own echo for the whole window and swallow a human's edit with it. The write must also ask for `Prefer: return=representation`: without it PostgREST answers no body, the echo path resolves to nothing, and the guard throws instead of guarding. The table must expose a unique, non-null `id` column for delivery identity. Rows whose cursor value is NULL are ignored. Rows are read in ascending cursor order: a row that becomes visible after the cursor advances, with a value EQUAL TO OR LOWER THAN the highest seen, is not delivered. Choose values that increase as changes become visible; this also applies to timestamp and date columns. A trigger mapping cannot skip an item; every delivered row starts a run.",
+			docs: "Starts a run for each row that appears past the cursor column, delivered as `{ table, row }`.\n\nThe cursor column decides what \"appears\" means, and it is the only choice that matters here. Left at the default `id`, or set to a column written once and never touched again such as `created_at`, this is insert-only: one run per new row, and an edit to an existing row is never delivered. Set to a column your database bumps on every write, such as `updated_at`, it becomes change detection, and every update to a row starts a new run.\n\nThe table must expose a unique, non-null `id` column for delivery identity. Rows whose cursor value is NULL are ignored.\n\nRows are read in ascending cursor order. A row that becomes visible after the cursor advances, with a value equal to or lower than the highest already seen, is not delivered. Choose values that increase as changes become visible; this also applies to timestamp and date columns.\n\nCAUTION: a workflow that writes to this table starts itself again, and nothing on the platform stops that loop: on a moving column a write-back bumps that column, and on the default column a workflow that answers each row by inserting another row mints a new id. Guard inside the workflow body with `isOwnEcho`, and match the value you compare to the cursor column. Insert-only: compare the `id` the delivery carried, with `echoPath: '0.id'` on the write. Change detection: compare the cursor column the delivery carried, with `echoPath: '0.updated_at'` on the write, putting your own column name in place of `updated_at`. Comparing the id on a moving column is wrong, because a row's id never changes, so the guard would read every later delivery of that row as your own echo for the whole window and swallow a human's edit with it. The write also has to ask for `Prefer: return=representation`: without it PostgREST answers no body, the echo path resolves to nothing, and the guard throws instead of guarding. A mapping cannot skip an event: every delivered row starts a run.",
 			sampleData: {
 				table: "todos",
 				row: {
@@ -34465,6 +34526,7 @@ function buildOperation(rawPath, resolvedPath, method, operation, pathLevelParam
 	const parameters = [];
 	const seen = /* @__PURE__ */ new Set();
 	let bodyParamSchema;
+	let bodyArgName;
 	for (let i = rawParameters.length - 1; i >= 0; i--) {
 		const raw = derefParameter(rawParameters[i], root);
 		if (raw === void 0) {
@@ -34474,7 +34536,10 @@ function buildOperation(rawPath, resolvedPath, method, operation, pathLevelParam
 		if (isRecord$2(raw) && source === "swagger") {
 			const location = asString$1(raw["in"]);
 			if (location === "body") {
-				if (bodyParamSchema === void 0 && raw["schema"] !== void 0) bodyParamSchema = raw["schema"];
+				if (bodyParamSchema === void 0 && raw["schema"] !== void 0) {
+					bodyParamSchema = raw["schema"];
+					bodyArgName = asString$1(raw["name"]);
+				}
 				continue;
 			}
 			if (location === "formData") {
@@ -34507,6 +34572,7 @@ function buildOperation(rawPath, resolvedPath, method, operation, pathLevelParam
 		...description !== void 0 ? { description } : {},
 		...parameters.length > 0 ? { parameters } : {},
 		...requestBodySchema !== void 0 ? { requestBodySchema } : {},
+		...bodyArgName !== void 0 ? { bodyArgName } : {},
 		...responseSchema !== void 0 ? { responseSchema } : {},
 		...rawBody ? { rawBody } : {},
 		...rawResponse !== void 0 ? { rawResponse } : {},
@@ -36148,17 +36214,18 @@ function narrows(value, narrowingOperators) {
 	return !(operator === "is" && NEGATED_IS.has(rest.toLowerCase()));
 }
 /**
-* Should this call be refused as an unfiltered delete?
+* Should this call be refused as an unfiltered DELETE or PATCH?
 *
 * Returns the refusal — `invalid_args`, not retryable, naming the columns that
-* would narrow it — or `null` when the call may proceed. Applies to DELETE
-* only: a read with no filter is a legitimate "select everything", and an
-* unfiltered PATCH, while sweeping, writes the caller's own values rather than
-* destroying data it never saw.
+* would narrow it — or `null` when the call may proceed. DELETE and PATCH
+* both affect existing rows. Reads and inserts keep their existing behavior.
+* Only declared query arguments count; values inside the named body do not.
 */
 function unfilteredDeleteError(def, operation, args) {
 	const guard = def.unfilteredDeleteGuard;
-	if (guard === void 0 || operation.method.toUpperCase() !== "DELETE") return null;
+	const method = operation.method.toUpperCase();
+	if (guard === void 0 || method !== "DELETE" && method !== "PATCH") return null;
+	const effect = method === "PATCH" ? "update" : "remove";
 	const nonFilter = new Set(guard.nonFilterParams);
 	const filterParams = (operation.parameters ?? []).filter((param) => param.in === "query" && !nonFilter.has(param.name)).map((param) => param.name);
 	const present = filterParams.filter((name) => {
@@ -36169,9 +36236,9 @@ function unfilteredDeleteError(def, operation, args) {
 	if (narrowingOperators === void 0) {
 		if (present.length > 0) return null;
 	} else if (present.some((name) => narrows(args[name], narrowingOperators))) return null;
-	if (narrowingOperators !== void 0 && present.length > 0) return refusal(operation, `no filter it carries narrows which rows go, so it would remove every row in the table.`, `Filters read: ${present.join(", ")}. Narrow it with one of: ${narrowingOperators.join(", ")}.`);
-	if (filterParams.length === 0) return refusal(operation, "a delete with no row filter would remove every row in the table.", "The operation declares no filterable parameter, so nothing could narrow it.");
-	return refusal(operation, "a delete with no row filter would remove every row in the table.", `Add at least one column filter: ${filterParams.join(", ")}.`);
+	if (narrowingOperators !== void 0 && present.length > 0) return refusal(operation, `no filter it carries narrows which rows go, so it would ${effect} every row in the table.`, `Filters read: ${present.join(", ")}. Narrow it with one of: ${narrowingOperators.join(", ")}.`);
+	if (filterParams.length === 0) return refusal(operation, `a ${method.toLowerCase()} with no row filter would ${effect} every row in the table.`, "The operation declares no filterable parameter, so nothing could narrow it.");
+	return refusal(operation, `a ${method.toLowerCase()} with no row filter would ${effect} every row in the table.`, `Add at least one column filter: ${filterParams.join(", ")}.`);
 }
 /** The one refusal shape, so every path names the operation the same way. */
 function refusal(operation, reason, remedy) {
@@ -36261,6 +36328,7 @@ function classifyProviderError(def, status, body, operationId) {
 	if (matched !== null && provider !== null) {
 		const said = providerSaid(provider);
 		switch (matched) {
+			case "cardinalityMismatch": return makeBrokerError("cardinality_mismatch", `operation "${operationId}" exceeded the provider's requested row limit: ${said}`);
 			case "invalidArgs": return makeBrokerError("invalid_args", `operation "${operationId}" was refused by the provider as a bad request: ${said}`);
 			case "accessDenied": return makeBrokerError("access_denied", `operation "${operationId}" was denied by the provider's own policy — the credential is valid, the policy said no: ${said}`, false);
 			case "conflict": return makeBrokerError("execute_failed", `operation "${operationId}" hit a constraint conflict: ${said}`, false);
@@ -36295,7 +36363,8 @@ function longestMatch(classes, code) {
 	const lists = [
 		["invalidArgs", classes.invalidArgs],
 		["accessDenied", classes.accessDenied],
-		["conflict", classes.conflict]
+		["conflict", classes.conflict],
+		["cardinalityMismatch", classes.cardinalityMismatch ?? []]
 	];
 	for (const [kind, prefixes] of lists) for (const prefix of prefixes) if (code.startsWith(prefix) && (best === null || prefix.length > best.prefix.length)) best = {
 		prefix,
@@ -36578,14 +36647,66 @@ async function runOperation(def, operation, args, token, http, timeoutMs, opts =
 		headerValue: responseHeader(response, continuation.urlHeader)
 	}) : void 0;
 	const output = response.ok && wantsRawResponse(operation, args) ? await storeRawResponse(operation, args, response, opts) : await parseResponse(response);
+	const matchedRows = matchedRowTotal(response);
 	return {
 		status: response.status,
 		ok: response.ok,
 		output,
+		...matchedRows !== void 0 ? { matchedRows } : {},
 		...continuationUrl !== void 0 ? { continuationUrl } : {}
 	};
 }
 /**
+* The TOTAL out of a `Content-Range` response header — how many rows the call
+* matched — or `undefined` when the provider did not count.
+*
+* `Content-Range` is `<first>-<last>/<total>`, and either half may be `*`. The
+* range says which rows came back in THIS response and the total says how many
+* exist; only the total answers "did my filter hit anything", because a write
+* that asks for no representation returns no rows either way. Measured against
+* PostgREST v12.2.3: a matched update answers `0-0/1`, one that matched nothing
+* answers a star range over a zero total, and one that asked for no count
+* answers a star over a star (`docs/investigations/pla-1345/README-live.md`).
+*
+* A `*` total is dropped rather than read as zero. That distinction is the guard
+* on the whole feature: see `matchedRows`.
+*/
+function matchedRowTotal(response) {
+	const total = responseHeader(response, "Content-Range")?.split("/")[1];
+	if (total === void 0 || total === "*") return void 0;
+	const parsed = Number(total);
+	return Number.isInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+/**
+* Did a write carrying a precondition match nothing (PLA-1403)?
+*
+* Returns the terminal refusal, or `null` when the call may be reported as the
+* success it looks like. A conditional write sends the value it read as part of
+* the row filter, so a row somebody else moved matches nothing and is left
+* alone — the protection working. Without this the caller cannot tell, because
+* `execute` returns `{ ok: true, output }` and the count never leaves the
+* broker.
+*
+* TWO conditions, and both are load-bearing:
+*
+*   * The method changes EXISTING rows: `PATCH` and `DELETE`, the same pair
+*     `unfilteredDeleteError` guards. A `GET` that matches nothing is a correct
+*     answer to a question and must stay a success — the one case this must
+*     never break. `POST` is out because an insert matches nothing by
+*     definition, and `PUT` is out because PostgREST upserts on it: a PUT that
+*     matches nothing CREATES the row, so zero matched is not a refusal there.
+*     Unmeasured on our side, which is the second reason to leave it out.
+*   * The provider reported a total of exactly zero, which it only does when the
+*     caller asked for the count. Asking IS the declaration, so a write that did
+*     not ask keeps the behaviour it has always had. An empty body is NOT the
+*     trigger.
+*/
+function unmatchedWriteError(operation, matchedRows, operationId) {
+	const method = operation.method.toUpperCase();
+	if (matchedRows !== 0 || method !== "PATCH" && method !== "DELETE") return null;
+	return makeBrokerError("precondition_failed", `operation "${operationId}" matched no rows, so it changed nothing — the row moved since it was read. Re-read it and decide.`);
+}
+/**
 * Render a parsed operation-call body to a short single-line string for an error
 * message. Shared by the action executor (here) and the inbound-trigger poll
 * context, so the two never drift. `empty` is returned for null/undefined (the
@@ -36599,13 +36720,36 @@ function formatOperationBody(output, opts = {}) {
 	return max > 0 && text.length > max ? `${text.slice(0, max)}…` : text;
 }
 /**
+* Fallback classification after provider-specific body codes (PLA-1321).
+* Known input, access and resource refusals are terminal. Unclassified statuses
+* retain the existing unknown-outcome policy, including 409: conflict vocabulary
+* is outside this slice. The caller's idempotency option still governs that path.
+*/
+function brokerCodeForProviderStatus(status) {
+	switch (status) {
+		case 400:
+		case 405:
+		case 422: return "invalid_args";
+		case 403: return "access_denied";
+		case 404:
+		case 410: return "not_found";
+		default: return "execute_failed";
+	}
+}
+/**
 * Build the JSON request body for an OpenAPI operation. When the operation
-* declares a request body, every payload key that is NOT a declared path/query/
+* names a Swagger body argument containing an object, send that object directly.
+* Otherwise, every payload key that is NOT a declared path/query/
 * header param becomes the body. Sets `content-type` when a body is produced.
 * Returns `undefined` for body-less operations (e.g. GET).
 */
 function buildRequestBody(operation, args, headers) {
 	if (operation.requestBodySchema === void 0) return void 0;
+	const namedBody = operation.bodyArgName === void 0 ? void 0 : args[operation.bodyArgName];
+	if (namedBody !== null && typeof namedBody === "object") {
+		headers["content-type"] = "application/json";
+		return JSON.stringify(namedBody);
+	}
 	const consumed = /* @__PURE__ */ new Set();
 	for (const param of operation.parameters ?? []) if (param.in === "path" || param.in === "query" || param.in === "header") consumed.add(param.name);
 	for (const arg of brokerConsumedArgs(operation)) consumed.add(arg.name);
@@ -36786,6 +36930,41 @@ function fail(error) {
 		error
 	};
 }
+/**
+* A PROVIDER ROUND-TRIP that failed with an outcome nobody here can determine,
+* classified against the caller's own idempotency assertion (PLA-1349).
+*
+* `execute_failed` and `timeout` are the two retryable codes in
+* `BROKER_ERROR_RETRYABILITY`, and that default is right: a transport failure or
+* a gateway 5xx usually did not land. But they are also the only two where it
+* MIGHT have — the provider committed and the response was lost, or the deadline
+* fired after the write was accepted and the abort only closed the socket. A
+* durable step is retried whole, so retrying one of these re-sends the write and
+* one run creates two objects.
+*
+* Which of the two it is cannot be read off the code, the status or the connector
+* definition: `commentCreate` and `listComments` fail identically, and an
+* operation the provider deduplicates only deduplicates when the CALLER minted
+* the key. So the caller states it and this decides accordingly:
+*
+* - `false` → `retryable: false`. The SDK turns that into `fatal: true`, the
+*   engine stops the step on its first failure, and a human reconciles. Same
+*   trade the World already made for a dispatch past `httpTimeoutMs`.
+* - `true`, or NOT STATED → the code's own default, untouched. Passing
+*   `undefined` as the override is byte-identical to omitting the argument, which
+*   is what keeps an unstated option a true no-op.
+*
+* ONLY these two codes go through here. A code that was already terminal stays
+* terminal with no second decision, and a retryable code whose outcome is KNOWN —
+* a 401 the provider refused before doing anything, a stale-spec refusal, a 429
+* a rate limiter answered in front of the operation, a 408 for a request the
+* provider never received whole — keeps its retry, because there is nothing to
+* reconcile. Callers pass `undefined` for those rather than the assertion; see
+* the provider non-2xx exit.
+*/
+function unknownOutcome(code, message, idempotent) {
+	return makeBrokerError(code, message, idempotent === false ? false : void 0);
+}
 function messageOf$6(err) {
 	return err instanceof Error ? err.message : String(err);
 }
@@ -36840,7 +37019,7 @@ var init_connect_action_executor = __esmMin((() => {
 			this.resumableStallTimeoutMs = deps.resumableStallTimeoutMs ?? 45e3;
 		}
 		async execute(input) {
-			const { orgId, runId, connectConnectorId, connectOperationId, payload } = input;
+			const { orgId, runId, connectConnectorId, connectOperationId, payload, idempotent } = input;
 			const runDef = runId !== void 0 ? await this.deps.runConnectors?.resolve(runId, orgId, connectConnectorId) ?? null : null;
 			const record = await this.deps.connectorRows?.resolve(orgId, connectConnectorId) ?? null;
 			let def;
@@ -36903,13 +37082,13 @@ var init_connect_action_executor = __esmMin((() => {
 					if (followUp === void 0) return this.missingFromSpec(specEntry, cached, `operation "${connectOperationId}" continues as "${declared.operationId}", which is not on connector "${connectConnectorId}"`);
 					if (declared.operationId === operation.operationId) return fail(makeBrokerError("invalid_args", `operation "${connectOperationId}" declares itself as its own continuation; a two-phase call needs a second, different operation`));
 				}
-				return this.runOpenApi(def, operation, payload, tokenResponse, caller, specEntry, cached, followUp);
+				return this.runOpenApi(def, operation, payload, tokenResponse, caller, specEntry, cached, followUp, idempotent);
 			}
 			const tool = findTool(introspection.tools, connectOperationId);
 			if (tool === void 0) return this.missingFromSpec(specEntry, cached, `tool "${connectOperationId}" not found on connector "${connectConnectorId}"`);
-			return this.runMcp(def, tool, payload, tokenResponse, caller);
+			return this.runMcp(def, tool, payload, tokenResponse, caller, idempotent);
 		}
-		async runOpenApi(def, operation, payload, token, caller, specEntry, cached, followUp) {
+		async runOpenApi(def, operation, payload, token, caller, specEntry, cached, followUp, idempotent) {
 			const args = isRecord$1(payload) ? payload : {};
 			for (const phase of followUp === void 0 ? [operation] : [operation, followUp]) {
 				const refused = unfilteredDeleteError(def, phase, args);
@@ -36933,11 +37112,12 @@ var init_connect_action_executor = __esmMin((() => {
 					});
 				}
 			} catch (err) {
-				if (err instanceof ActionTimeoutError) return fail(makeBrokerError("timeout", `operation "${reported.operationId}" timed out`));
-				if (isTransferStalled(err)) return fail(makeBrokerError("timeout", `operation "${reported.operationId}" stalled mid-transfer: ${messageOf$6(err)}`));
-				if (err instanceof ContinuationError) return fail(makeBrokerError(err.code, err.message, err.retryable));
-				if (err instanceof RawBodyError || err instanceof RawResponseError) return fail(makeBrokerError(err.code, err.message));
-				return fail(makeBrokerError("execute_failed", messageOf$6(err)));
+				if (err instanceof ActionTimeoutError) return fail(unknownOutcome("timeout", `operation "${reported.operationId}" timed out`, idempotent));
+				if (isTransferStalled(err)) return fail(unknownOutcome("timeout", `operation "${reported.operationId}" stalled mid-transfer: ${messageOf$6(err)}`, idempotent));
+				if (err instanceof ContinuationError) return fail(makeBrokerError(err.code, err.message, idempotent === false ? false : err.retryable));
+				if (err instanceof RawResponseError) return fail(makeBrokerError(err.code, err.message, idempotent === false ? false : void 0));
+				if (err instanceof RawBodyError) return fail(makeBrokerError(err.code, err.message));
+				return fail(unknownOutcome("execute_failed", messageOf$6(err), idempotent));
 			}
 			const classified = classifyProviderError(def, result.status, result.output, reported.operationId);
 			if (classified?.code === "access_denied") return fail(classified);
@@ -36948,8 +37128,13 @@ var init_connect_action_executor = __esmMin((() => {
 				const body = formatOperationBody(result.output);
 				if (specEntry !== null && cached?.servedFromCache() === true && isStaleSpecError(def, result.output)) return this.onStaleSpec(specEntry, `operation "${reported.operationId}" failed with status ${result.status} against a stale spec${body ? `: ${body}` : ""}`);
 				if (classified !== null) return fail(classified);
-				return fail(makeBrokerError("execute_failed", `operation "${reported.operationId}" failed with status ${result.status}${body ? `: ${body}` : ""}`));
+				const code = brokerCodeForProviderStatus(result.status);
+				const message = `operation "${reported.operationId}" failed with status ${result.status}${body ? `: ${body}` : ""}`;
+				if (code !== "execute_failed") return fail(makeBrokerError(code, message));
+				return fail(unknownOutcome("execute_failed", message, result.status === 429 || result.status === 408 ? void 0 : idempotent));
 			}
+			const unmatched = unmatchedWriteError(operation, result.matchedRows, reported.operationId);
+			if (unmatched !== null) return fail(unmatched);
 			return {
 				ok: true,
 				output: result.output
@@ -36974,7 +37159,7 @@ var init_connect_action_executor = __esmMin((() => {
 				...this.deps.maxRawResponseBytes !== void 0 ? { maxRawResponseBytes: this.deps.maxRawResponseBytes } : {}
 			};
 		}
-		async runMcp(def, tool, payload, token, caller) {
+		async runMcp(def, tool, payload, token, caller, idempotent) {
 			if (this.deps.mcp === void 0) return fail(makeBrokerError("execute_failed", `connector "${def.id}" is an MCP connector but no MCP caller was wired`));
 			let output;
 			try {
@@ -36985,9 +37170,9 @@ var init_connect_action_executor = __esmMin((() => {
 					token: token.token
 				}), this.timeoutMs);
 			} catch (err) {
-				if (err instanceof ActionTimeoutError) return fail(makeBrokerError("timeout", `tool "${tool.name}" timed out`));
+				if (err instanceof ActionTimeoutError) return fail(unknownOutcome("timeout", `tool "${tool.name}" timed out`, idempotent));
 				if (statusOf(err) === 401) return this.on401(def, caller, `tool "${tool.name}" returned 401`);
-				return fail(makeBrokerError("execute_failed", messageOf$6(err)));
+				return fail(unknownOutcome("execute_failed", messageOf$6(err), idempotent));
 			}
 			return {
 				ok: true,
@@ -51649,8 +51834,27 @@ var CONNECT_DDL = `
 * Ensure the connect tables exist in the emulator Postgres. Idempotent. Exported
 * so the workspace-server can run it once at boot (and the spec can run it before
 * exercising the routes) instead of paying the DDL on every request.
-*/
-var ensureConnectTables = async (connectionString) => {
+*
+* A NO-OP WHEN THE CONTROL PLANE OWNS THE SCHEMA (PLA-1286). In the self-host
+* topology the box and the control plane share ONE Postgres, and both declare
+* `connection_grant`: db-core's `0008_connect.sql` with a bare `CREATE TABLE`,
+* this module with `CREATE TABLE IF NOT EXISTS`. Only one of the two survives
+* arriving second — the migration dies on `relation already exists`, the control
+* plane restarts, and the self-host smoke reports it as a health-check timeout.
+*
+* The DDL here runs LAZILY, on the first request that builds the broker context,
+* so which of the two lands first is a coin flip decided by traffic. Probing the
+* database for a control plane cannot settle it: the box answers healthy seconds
+* before the control plane has written anything at all, so the probe would come
+* back empty and create the table anyway. So the topology DECLARES the owner
+* instead of the box guessing it, and a declared owner is the same answer on
+* every boot.
+*
+* `stackbone dev` and BYOC set nothing, have no control plane on their database,
+* and keep creating their own tables exactly as before.
+*/
+var ensureConnectTables = async (connectionString, opts = {}) => {
+	if ((opts.schemaOwner ?? process.env["STACKBONE_PLATFORM_SCHEMA_OWNER"]) === "control-plane") return;
 	const client = new Client({ connectionString });
 	await client.connect();
 	try {
@@ -51720,47 +51924,53 @@ var deriveBase64Key = (raw) => createHash("sha256").update(raw).digest().toStrin
 var makeContextFactory = (opts) => {
 	let cached;
 	const get = () => {
-		if (!cached) cached = (async () => {
-			await ensureConnectTables(opts.connectionString);
-			const cipher = await createSecretCipher(deriveBase64Key(opts.encryptionKey ?? DEV_CONNECT_ENCRYPTION_KEY));
-			const sql = postgres(opts.connectionString, {
-				max: 4,
-				onnotice: () => void 0
-			});
-			const db = drizzle(sql);
-			const store = new DrizzleBrokerStore(db, cipher);
-			const cache = createInMemoryTokenCache();
-			const specCache = createBoxSpecCache(opts.redisUrl);
-			const bindings = createInMemoryBindingStore();
-			const exchanger = new DefaultOAuthExchanger();
-			const brokerCallbackBaseUrl = opts.brokerCallbackBaseUrl ?? "http://127.0.0.1:4242/api/connect/callback";
-			const service = new ConnectService({
-				store,
-				exchanger,
-				cache,
-				bindings,
-				oauth: {
-					brokerCallbackUrl: brokerCallbackBaseUrl,
-					stateSecret: deriveBase64Key(opts.encryptionKey ?? DEV_CONNECT_ENCRYPTION_KEY)
-				}
+		if (!cached) {
+			const building = (async () => {
+				await ensureConnectTables(opts.connectionString);
+				const cipher = await createSecretCipher(deriveBase64Key(opts.encryptionKey ?? DEV_CONNECT_ENCRYPTION_KEY));
+				const sql = postgres(opts.connectionString, {
+					max: 4,
+					onnotice: () => void 0
+				});
+				const db = drizzle(sql);
+				const store = new DrizzleBrokerStore(db, cipher);
+				const cache = createInMemoryTokenCache();
+				const specCache = createBoxSpecCache(opts.redisUrl);
+				const bindings = createInMemoryBindingStore();
+				const exchanger = new DefaultOAuthExchanger();
+				const brokerCallbackBaseUrl = opts.brokerCallbackBaseUrl ?? "http://127.0.0.1:4242/api/connect/callback";
+				const service = new ConnectService({
+					store,
+					exchanger,
+					cache,
+					bindings,
+					oauth: {
+						brokerCallbackUrl: brokerCallbackBaseUrl,
+						stateSecret: deriveBase64Key(opts.encryptionKey ?? DEV_CONNECT_ENCRYPTION_KEY)
+					}
+				});
+				return {
+					db,
+					audit: opts.audit,
+					sql,
+					cipher,
+					store,
+					service,
+					bindings,
+					exchanger,
+					specCache: specCache.cache,
+					brokerCallbackBaseUrl,
+					async close() {
+						await sql.end({ timeout: 5 }).catch(() => void 0);
+						await specCache.close();
+					}
+				};
+			})();
+			cached = building;
+			building.catch(() => {
+				if (cached === building) cached = void 0;
 			});
-			return {
-				db,
-				audit: opts.audit,
-				sql,
-				cipher,
-				store,
-				service,
-				bindings,
-				exchanger,
-				specCache: specCache.cache,
-				brokerCallbackBaseUrl,
-				async close() {
-					await sql.end({ timeout: 5 }).catch(() => void 0);
-					await specCache.close();
-				}
-			};
-		})();
+		}
 		return cached;
 	};
 	const close = async () => {
@@ -51785,11 +51995,12 @@ var init_broker_refusal = __esmMin((() => {
 			case "access_denied": return 401;
 			case "invalid_args": return 400;
 			case "invalid_grant": return 400;
+			case "precondition_failed":
+			case "cardinality_mismatch": return 409;
 			case "credential_error":
 			case "execute_failed":
 			case "timeout":
 			case "invalid_output": return 502;
-			default: return 502;
 		}
 	};
 	brokerRefusal = (err) => {
@@ -53105,7 +53316,8 @@ var init_support = __esmMin((() => {
 		args: z.record(z.string(), z.unknown()).default({}),
 		principal: principalSchema.default({ type: "app" }),
 		installationId: z.string().min(1).optional(),
-		runId: z.string().min(1).optional()
+		runId: z.string().min(1).optional(),
+		idempotent: z.boolean().optional()
 	});
 	requireBrokerSignature = (secret) => async (c, next) => {
 		if (!verifyTokenRequestSignature(c, secret)) return c.json({
@@ -53123,13 +53335,15 @@ var init_support = __esmMin((() => {
 			ok: false,
 			error: {
 				code: error.code,
-				message: error.message
+				message: error.message,
+				...error.retryable !== void 0 ? { retryable: error.retryable } : {}
 			}
 		};
 		switch (statusForBrokerCode(error.code)) {
 			case 400: return c.json(body, 400);
 			case 401: return c.json(body, 401);
 			case 404: return c.json(body, 404);
+			case 409: return c.json(body, 409);
 			default: return c.json(body, 502);
 		}
 	};
@@ -53269,13 +53483,14 @@ var createConnectTokenRouter = (opts, sharedContext) => {
 		security: HMAC_ROUTE_SECURITY,
 		middleware: [requireBrokerSignature(opts.hmacSecret)],
 		summary: "Run one connector operation",
-		description: "Mints the credential, applies it in the connector’s declared placement, calls the operation and hands back ONLY its output. Nothing about the credential — not the token, not its placement — crosses this boundary, which is the whole reason a workflow step calls the box instead of the provider.\n\n`operation` names an operation id (OpenAPI) or a tool (MCP) as `GET /api/connect/connectors/{connectorId}/operations` reports it. `runId` is the one field that changes WHICH connector answers: a run wired to a stand-in reaches the stand-in and never leaves the box, which is how an eval exercises a send without sending anything.\n\nA refusal comes back in TWO shapes on the same statuses: `{ ok: false, error }` when the executor completed and the provider or the broker said no, and the box’s `{ code, message }` envelope when the request never got that far.",
+		description: "Mints the credential, applies it in the connector’s declared placement, calls the operation and hands back ONLY its output. Nothing about the credential — not the token, not its placement — crosses this boundary, which is the whole reason a workflow step calls the box instead of the provider.\n\n`operation` names an operation id (OpenAPI) or a tool (MCP) as `GET /api/connect/connectors/{connectorId}/operations` reports it. `runId` is the one field that changes WHICH connector answers: a run wired to a stand-in reaches the stand-in and never leaves the box, which is how an eval exercises a send without sending anything.\n\nA refusal comes back in TWO shapes on the same statuses: `{ ok: false, error }` when the executor completed and the provider or the broker said no, including a broker error thrown before execution completes. Signature and payload validation failures use the box’s `{ code, message }` envelope.",
 		request: { body: jsonBody(named("ConnectExecuteRequest", executeRequestSchema), "The connector, the operation, and the args to run it with.") },
 		responses: {
 			200: jsonResponse(named("ConnectExecuteSuccess", connectExecuteSuccessSchema), "The operation’s own output, passed through untouched."),
 			400: executeRefusal("The body failed its schema (`invalid_payload`), or the broker refused the arguments (`invalid_args`, `invalid_grant`)."),
 			401: executeRefusal("The signature is missing or wrong (`access_denied`), or the connector has no usable authorization (`no_token`, `user_authorization_required`, `principal_required`)."),
 			404: executeRefusal("No such connector on this box, or no such operation on it (`not_found`, `connector_installation_required`)."),
+			409: executeRefusal("The provider refused a guarded write: no rows matched (`precondition_failed`), or the requested row limit was exceeded (`cardinality_mismatch`). Terminal: change the guard or narrow the target before retrying."),
 			502: executeRefusal("The provider call failed (`execute_failed`, `timeout`, `credential_error`, `invalid_output`). Upstream, not the box.")
 		}
 	}), async (c) => {
@@ -53291,7 +53506,8 @@ var createConnectTokenRouter = (opts, sharedContext) => {
 				connectConnectorId: request.connector,
 				connectOperationId: request.operation,
 				payload: request.args,
-				...request.runId !== void 0 ? { runId: request.runId } : {}
+				...request.runId !== void 0 ? { runId: request.runId } : {},
+				...request.idempotent !== void 0 ? { idempotent: request.idempotent } : {}
 			});
 			if (result.ok) return c.json({
 				ok: true,
@@ -53299,7 +53515,8 @@ var createConnectTokenRouter = (opts, sharedContext) => {
 			}, 200);
 			return answerExecuteFailure(c, result.error);
 		} catch (err) {
-			return answerBrokerRefusal(c, err);
+			if (isBrokerError(err)) return answerExecuteFailure(c, err);
+			throw err;
 		}
 	});
 	app.openapi(createRoute({
@@ -65380,6 +65597,30 @@ var init_serial_execution_coordinator = __esmMin((() => {
 	createSerialExecutionCoordinator = (gate) => {
 		const held = /* @__PURE__ */ new Map();
 		return {
+			async beginStart(workflowName) {
+				const owner = held.get(workflowName);
+				if (!owner) return null;
+				const abandon = () => {
+					if (held.get(workflowName) === owner) held.delete(workflowName);
+				};
+				try {
+					if (!await gate.markAttempt(workflowName, owner.token)) {
+						abandon();
+						return null;
+					}
+				} catch (err) {
+					abandon();
+					throw err;
+				}
+				return {
+					noteStarted(runId) {
+						if (held.get(workflowName) === owner) owner.runId = runId;
+					},
+					acknowledge: () => gate.acknowledge(workflowName, owner.token),
+					requeue: (trigger) => gate.requeue(workflowName, trigger, owner.token),
+					abandon
+				};
+			},
 			async tryAdmit(workflowName, trigger) {
 				const verdict = await gate.tryAdmit(workflowName, trigger);
 				if (verdict.admitted) {
@@ -65420,26 +65661,34 @@ var init_serial_execution_coordinator = __esmMin((() => {
 				held.delete(workflowName);
 			},
 			async requeue(workflowName, trigger) {
-				await gate.requeue(workflowName, trigger);
+				const owner = held.get(workflowName);
+				if (owner) await gate.requeue(workflowName, trigger, owner.token);
 			}
 		};
 	};
 	createSerialSweepSupport = (deps) => {
 		const startAdmitted = async (name, trigger) => {
+			const attempt = await deps.coordinator.beginStart(name);
+			if (!attempt) return;
 			let started;
 			try {
 				started = await deps.startNext(name, trigger);
 			} catch (err) {
 				try {
-					await deps.coordinator.requeue(name, trigger);
+					await attempt.requeue(trigger);
 				} catch (requeueErr) {
 					console.warn(`[serial-execution] could not re-enqueue an unstarted trigger for "${name}": ${requeueErr instanceof Error ? requeueErr.message : String(requeueErr)}`);
 				}
-				deps.coordinator.abandon(name);
-				console.warn(`[serial-execution] failed to start admitted trigger for "${name}", re-enqueued it and released its lock: ${err instanceof Error ? err.message : String(err)}`);
+				attempt.abandon();
+				console.warn(`[serial-execution] failed to start admitted trigger for "${name}": ${err instanceof Error ? err.message : String(err)}`);
 				return;
 			}
-			deps.coordinator.noteStarted(name, started?.worldRunId);
+			attempt.noteStarted(started?.worldRunId);
+			try {
+				await attempt.acknowledge();
+			} catch (err) {
+				console.warn(`[serial-execution] could not acknowledge started trigger for "${name}": ${err instanceof Error ? err.message : String(err)}`);
+			}
 			await deps.clearWaiting?.(name, trigger.pendingId);
 		};
 		return {
@@ -65745,6 +65994,7 @@ var init_load_project_runtime = __esmMin((() => {
 		let setActiveStepReader;
 		let approvalRequest;
 		let setConnectorInvoker;
+		let setEchoGuardReader;
 		let connectorInvoker;
 		let setActionInvoker;
 		let actionInvoker;
@@ -65760,6 +66010,7 @@ var init_load_project_runtime = __esmMin((() => {
 			setApprovalRecorder = sdk.setApprovalRecorder;
 			setActiveStepReader = sdk.setActiveStepReader;
 			setConnectorInvoker = sdk.setConnectorInvoker;
+			setEchoGuardReader = sdk.setEchoGuardReader;
 			connectorInvoker = sdk.createConnectInvoker?.();
 			setActionInvoker = sdk.setActionInvoker;
 			actionInvoker = sdk.createActionInvoker?.();
@@ -65817,6 +66068,7 @@ var init_load_project_runtime = __esmMin((() => {
 			setActiveStepReader,
 			approvalRequest,
 			setConnectorInvoker,
+			setEchoGuardReader,
 			connectorInvoker,
 			setActionInvoker,
 			actionInvoker,
@@ -66481,11 +66733,49 @@ var init_runtime_approval_plants = __esmMin((() => {
 }));
 //#endregion
 //#region ../../libs/runtime/workspace-runtime/src/lib/workflow/runtime-connector-plants.ts
-var plantConnectorInvoker, plantActionInvoker;
+var owningWorkflow, echoOwner, unresolvedEcho, resolveEcho, echoRecordError, plantConnectorInvoker, plantActionInvoker, ECHO_WINDOW_MS, renderEcho, echoGuardUnavailable, plantEchoGuard;
 var init_runtime_connector_plants = __esmMin((() => {
+	init_src$4();
+	init_src$13();
 	init_call_ordinal();
 	init_monotonic_span();
 	init_project_runtime();
+	owningWorkflow = () => {
+		const owner = getExecutionOwner();
+		return owner?.kind === "workflow" ? owner.name : void 0;
+	};
+	echoOwner = () => {
+		const workflowName = owningWorkflow();
+		return workflowName !== void 0 ? { workflowName } : {};
+	};
+	unresolvedEcho = (echoPath) => ({
+		echoPath,
+		echo: null,
+		echoUnresolved: true,
+		...echoOwner()
+	});
+	resolveEcho = (echoPath, output, label) => {
+		const owner = echoOwner();
+		const echo = getPath(output, echoPath);
+		if (echo !== void 0 && echo !== null && echo !== "") return {
+			echoPath,
+			echo,
+			...owner
+		};
+		console.warn(`[connector] ${label}: echoPath "${echoPath}" resolved to nothing (missing, null or empty) in the response, so the run step records no echo value and the self-write guard cannot answer for this call`);
+		return {
+			echoPath,
+			echo: null,
+			echoUnresolved: true,
+			...owner
+		};
+	};
+	echoRecordError = (label, cause) => {
+		const error = /* @__PURE__ */ new Error(`[connector] ${label}: the provider call succeeded but its echo record could not be written (${cause instanceof Error ? cause.message : String(cause)}), so nothing can recognise this write when the trigger delivers it back. The step stops here.`);
+		error.code = "echo_record_failed";
+		error.fatal = true;
+		return error;
+	};
 	plantConnectorInvoker = (rt, ctx) => {
 		if (!rt.setConnectorInvoker || !rt.connectorInvoker) return;
 		const baseInvoker = rt.connectorInvoker;
@@ -66499,14 +66789,15 @@ var init_runtime_connector_plants = __esmMin((() => {
 				const span = startSpan();
 				const ordinal = stepInfo ? nextConnOrdinal(runId ?? "", stepInfo.stepId, stepInfo.attempt) : 0;
 				const externalStepId = stepInfo ? `${stepInfo.stepId}::conn::${ordinal}` : randomUUID();
-				const record = (status, extra) => {
-					if (!runId) return;
+				const label = `${args.connector}/${args.operation}`;
+				const writeRow = (status, extra, echo) => {
+					if (!runId) return void 0;
 					const { completedAt, durationMs } = closeSpan(span);
-					recordActivityStep({
+					return recordActivityStep({
 						runId,
 						externalStepId,
 						type: "connection",
-						name: `${args.connector}/${args.operation}`,
+						name: label,
 						status,
 						startedAt: span.startedAt.toISOString(),
 						completedAt: completedAt.toISOString(),
@@ -66514,26 +66805,52 @@ var init_runtime_connector_plants = __esmMin((() => {
 						input: {
 							connector: args.connector,
 							operation: args.operation,
-							args: args.args
+							args: args.args,
+							...echo ?? {}
 						},
 						...extra,
 						enclosingExternalStepId: stepInfo?.stepId ?? null
-					}).catch((err) => {
+					});
+				};
+				const forget = (write) => {
+					write?.catch((err) => {
 						console.warn(`[connector] run-step write failed for run ${runId}: ${err instanceof Error ? err.message : String(err)}`);
 					});
 				};
+				let result;
 				try {
-					const result = await baseInvoker.invoke(args);
-					record("completed", { output: result.output });
-					return result;
+					result = await baseInvoker.invoke(args);
 				} catch (err) {
 					const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
-					record("failed", { error: {
+					const echo = typeof args.echoPath === "string" ? unresolvedEcho(args.echoPath) : void 0;
+					if (echo) console.warn(`[connector] ${label}: the call failed after naming an echoPath, so it may have landed with nothing recorded — the run step keeps an unresolved marker and the self-write guard will refuse rather than answer for this connector`);
+					const write = writeRow("failed", { error: {
 						message: err instanceof Error ? err.message : String(err),
 						...typeof code === "string" ? { code } : {}
-					} });
+					} }, echo);
+					if (echo) await write?.catch((cause) => {
+						console.warn(`[connector] ${label}: could not record the unresolved echo marker: ${cause instanceof Error ? cause.message : String(cause)}`);
+					});
+					else forget(write);
 					throw err;
 				}
+				if (typeof args.echoPath !== "string") {
+					forget(writeRow("completed", { output: result.output }));
+					return result;
+				}
+				const echo = resolveEcho(args.echoPath, result.output, label);
+				const write = writeRow("completed", { output: result.output }, echo);
+				if (write === void 0) console.warn(`[connector] ${label}: this call named an echoPath but runs with no invocation context, so no run step records its echo and the self-write guard cannot recognise the delivery this write causes`);
+				if (write !== void 0) {
+					let rowId;
+					try {
+						rowId = await write;
+					} catch (cause) {
+						throw echoRecordError(label, cause);
+					}
+					if (rowId === null) throw echoRecordError(label, /* @__PURE__ */ new Error(`the store wrote no row for run ${runId}`));
+				}
+				return result;
 			} });
 		} else rt.setConnectorInvoker(baseInvoker);
 	};
@@ -66597,6 +66914,34 @@ var init_runtime_connector_plants = __esmMin((() => {
 			}
 		} });
 	};
+	ECHO_WINDOW_MS = 3600 * 1e3;
+	renderEcho = (value) => String(value);
+	echoGuardUnavailable = (connector, workflowName) => {
+		const scope = workflowName ? `this workflow ("${workflowName}"), or a caller with no workflow owner,` : "some caller on this connector";
+		const error = /* @__PURE__ */ new Error(`isOwnEcho("${connector}"): a write by ${scope} inside the last hour named an echoPath that resolved to nothing, so the value it produced was never recorded. The guard cannot tell your own write from somebody else's change. Find the echoPath that resolved to nothing — the runtime warned which one when it wrote the row.`);
+		error.code = "echo_guard_unavailable";
+		return error;
+	};
+	plantEchoGuard = (rt, ctx) => {
+		if (!rt.setEchoGuardReader) return;
+		const findEchoRecord = ctx.invocations?.findEchoRecord?.bind(ctx.invocations);
+		if (!findEchoRecord) {
+			rt.setEchoGuardReader(void 0);
+			return;
+		}
+		rt.setEchoGuardReader({ isOwnEcho: async ({ connector, value }) => {
+			const workflowName = owningWorkflow();
+			const { matched, unresolved } = await findEchoRecord({
+				connector,
+				value: renderEcho(value),
+				workflowName: workflowName ?? null,
+				windowMs: ECHO_WINDOW_MS
+			});
+			if (matched) return true;
+			if (unresolved) throw echoGuardUnavailable(connector, workflowName);
+			return false;
+		} });
+	};
 }));
 //#endregion
 //#region ../../libs/runtime/workspace-runtime/src/lib/workflow/runtime-sdk-plants.ts
@@ -66660,6 +67005,7 @@ var init_runtime_sdk_plants = __esmMin((() => {
 		plantPromptUseReporter(rt, ctx);
 		plantApprovalRecorder(rt, ctx);
 		plantConnectorInvoker(rt, ctx);
+		plantEchoGuard(rt, ctx);
 		plantActionInvoker(rt, ctx);
 		return rt;
 	};
@@ -66686,6 +67032,7 @@ var init_runtime_loader = __esmMin((() => {
 			rt.setPromptUseReporter?.(void 0);
 			rt.setApprovalRecorder?.(void 0);
 			rt.setConnectorInvoker?.(void 0);
+			rt.setEchoGuardReader?.(void 0);
 			rt.setActionInvoker?.(void 0);
 			rt.setActiveStepReader?.(void 0);
 			planted = void 0;
@@ -67254,9 +67601,12 @@ var init_event_forwarder = __esmMin((() => {
 		* the row `claimed` while the attempt went ahead; a later swallowed `markStarted`
 		* would then leave a `claimed` row with a real run behind it, the sweep would
 		* release it, and the customer's workflow would run a second time. Failing here
-		* is instead the ordinary transient path the start and resume catches already
-		* take: nothing was attempted, so release the claim (best-effort) and bubble —
-		* the tick does not advance its cursor and the next one retries the item.
+		* instead bubbles without releasing: a failed marker cannot establish ownership,
+		* and deleting by pair could erase another writer's delivery. The tick holds its
+		* cursor. If the row remains `claimed`, recovery waits for the takeover window
+		* and consumes takeover budget, even for a transient marker failure. An applied
+		* update whose response is lost instead leaves `starting` without an attempt;
+		* this slice cannot resolve that unknown outcome (PLA-1395 investigation).
 		*
 		* Written at most once: a resume that misses falls through to the start below.
 		*/
@@ -67265,13 +67615,7 @@ var init_event_forwarder = __esmMin((() => {
 		*  one must give up where it stands. */
 		const markAttempt = async () => {
 			if (attemptMarked) return true;
-			let matched;
-			try {
-				matched = await deps.deliveries.markStarting(subscription.id, event.id);
-			} catch (err) {
-				await bestEffort(() => deps.deliveries.release(subscription.id, event.id), "release");
-				throw err;
-			}
+			const matched = await deps.deliveries.markStarting(subscription.id, event.id);
 			attemptMarked = matched;
 			return matched;
 		};
@@ -70958,7 +71302,7 @@ var calls_workflow_ts_default = "import { z } from \"zod\";\nimport { streamDeep
 var plain_workflow_ts_default = "import { z } from \"zod\";\n\n/**\n * Workflow \"{{name}}\" — a durable pipeline.\n *\n * Each `\"use step\"` is a durable checkpoint: kill the runtime mid-run and it\n * resumes from the last completed step instead of replaying everything.\n */\n\n// THE contract — sibling exports next to the bare workflow function. The build\n// harvests these (by convention) into the manifest + a live validator. The\n// parameter type is DERIVED from `inputSchema` and the RETURN type from\n// `outputSchema` (both `z.infer`), so neither side can drift from the contract\n// the build harvests. Without the return annotation the schema is published to\n// Studio and the generated types and never compared to what the body returns\n// (PLA-1272).\nexport const inputSchema = z.object({\n  message: z.string().describe(\"The input to process\"),\n});\n\nexport const outputSchema = z.object({\n  message: z.string(),\n  processed: z.boolean(),\n});\n\ntype {{Name}}Input = z.infer<typeof inputSchema>;\n\nexport async function {{export}}(input: {{Name}}Input): Promise<z.infer<typeof outputSchema>> {\n  \"use workflow\";\n\n  const result = await processMessage(input); // step 1 — durable checkpoint\n  return result;\n}\n\nasync function processMessage(input: {{Name}}Input) {\n  \"use step\";\n  // Replace this with the deterministic work of your step (DB write, HTTP call,\n  // an LLM call, …). Returning a value records it as the step's checkpoint.\n  return { message: input.message, processed: true };\n}\n";
 //#endregion
 //#region src/services/scaffold/template-loader.ts
-var SDK_TEMPLATE_VERSION = "0.4.0";
+var SDK_TEMPLATE_VERSION = "0.5.0";
 var PREFIX = "./templates/";
 var templates = new Map(Object.entries(/* @__PURE__ */ Object.assign({
 	"./templates/deep-agents/index.ts.tmpl": index_ts_default,
@@ -75983,6 +76327,15 @@ ${objectStore}
       # MinIO addresses buckets by path. A managed bucket that only answers to the
       # bucket-as-subdomain form (AWS S3, Railway Buckets) needs this set to false.
       STACKBONE_S3_FORCE_PATH_STYLE: \${STACKBONE_S3_FORCE_PATH_STYLE:-true}
+      # PLA-1286 — WHO OWNS THE PLATFORM SCHEMA IN THE DATABASE BELOW. This is the
+      # only topology where the agent and the control plane share one Postgres,
+      # and both of them declare \`connection_grant\`: the control plane through
+      # its db-core migrations, the agent through its own boot DDL. The control
+      # plane's statement is a bare CREATE TABLE and dies if the table is already
+      # there, so the agent stands down here and lets the migrations create them.
+      # Not overridable from .env on purpose: it is a fact about this compose file,
+      # not a preference, and a box that shares no database never sees this line.
+      STACKBONE_PLATFORM_SCHEMA_OWNER: control-plane
 ${sharedIdentity}
       # REPLACES the agent's built-in origin allowlist — it does not add to it. The
       # dashboard is a different ORIGIN from the agent (different port), so its
@@ -78802,6 +79155,7 @@ var generateConnectorTypes = (models) => {
 		HEADER,
 		"",
 		...AUGMENTED_MODULES.map((mod) => `import ${JSON.stringify(mod)};`),
+		`import type { CallConnectorOptions } from ${JSON.stringify(AUGMENTED_MODULES[0])};`,
 		"",
 		augmentations.join("\n"),
 		""
@@ -78817,15 +79171,32 @@ function renderConnectorEntry(model) {
 	].join("\n");
 }
 /**
-* One `      <op>(args: <type>): Promise<<out>>;` line (indent level 3) — or the
-* THREE overload lines a `'when-requested'` raw response takes, because one
-* signature there has two reachable outcomes.
+* One `      <op>(args: <type>, opts?: CallConnectorOptions): Promise<<out>>;` line
+* (indent level 3) — or the THREE overload lines a `'when-requested'` raw response
+* takes, because one signature there has two reachable outcomes.
 */
 function renderOperation(op) {
 	if (takesEitherOutcome(op)) return renderEitherOutcome(op);
-	return `      ${propertyKey(op.name)}(${renderParam(op)}): Promise<${renderReturn(op)}>;`;
+	return `      ${propertyKey(op.name)}(${renderParam(op)}${OPTS_PARAM}): Promise<${renderReturn(op)}>;`;
 }
 /**
+* The second parameter every generated signature carries (PLA-1349).
+*
+* `connection(id).<op>(args, opts)` has always forwarded a second argument at run
+* time (`call-connector.ts`), and no generated signature declared it — so
+* `idempotent` was reachable only through the untyped `.call(...)`, which is not
+* the path a creator is steered to. Typed as the whole options object rather than
+* one field, which is what carried PLA-1351's `echoPath` in with no change here:
+* the option landed on `CallConnectorOptions` and every generated signature already
+* accepted it.
+*
+* It is ALWAYS second, and `renderParam` is what guarantees that: an operation
+* with nothing to put in `args` still prints `args?: undefined` ahead of this. The
+* proxy is `(args?, opts?)` for every operation, so a signature that let `opts`
+* come first would hand the caller's options to the provider as arguments.
+*/
+var OPTS_PARAM = ", opts?: CallConnectorOptions";
+/**
 * Does ONE signature of this operation have two reachable outcomes?
 *
 * Only `'when-requested'`, and only while the switch is actually IN its arguments
@@ -78865,7 +79236,7 @@ function takesEitherOutcome(op) {
 function renderEitherOutcome(op) {
 	const receipt = printType(rawResponseReceiptJsonSchema(), 3);
 	const response = op.outputSchema === void 0 ? "unknown" : printType(op.outputSchema, 3);
-	const signature = (presence, out) => `      ${propertyKey(op.name)}(args: ${printType(withKeyPresence(op.argsSchema, presence), 3)}): Promise<${out}>;`;
+	const signature = (presence, out) => `      ${propertyKey(op.name)}(args: ${printType(withKeyPresence(op.argsSchema, presence), 3)}${OPTS_PARAM}): Promise<${out}>;`;
 	return [
 		signature("required", receipt),
 		signature("forbidden", response),
@@ -78881,6 +79252,8 @@ function renderEitherOutcome(op) {
 */
 function withKeyPresence(schema, presence) {
 	if (!isObject(schema)) return schema;
+	const union = schema["anyOf"] ?? schema["oneOf"];
+	if (Array.isArray(union)) return { anyOf: union.map((branch) => withKeyPresence(branch, presence)) };
 	const properties = { ...isObject(schema["properties"]) ? schema["properties"] : {} };
 	const required = new Set(Array.isArray(schema["required"]) ? schema["required"].filter((k) => typeof k === "string") : []);
 	if (presence === "required") required.add(RAW_RESPONSE_KEY_ARG);
@@ -78896,7 +79269,7 @@ function withKeyPresence(schema, presence) {
 }
 /** `args: <type>` for an operation with arguments, and nothing for one without. */
 function renderParam(op) {
-	return schemaHasProperties(op.argsSchema) ? `args: ${printType(op.argsSchema, 3)}` : "";
+	return schemaHasProperties(op.argsSchema) ? `args: ${printType(op.argsSchema, 3)}` : "args?: undefined";
 }
 /**
 * What the operation ACTUALLY answers (PLA-1203).
@@ -79142,8 +79515,9 @@ function answeredResponseSchema(op, byId) {
 * BROKER-consumed arguments into ONE flat args object schema — exactly how the
 * broker executor reads the payload (`args[param.name]` for path/query, the
 * broker's own keys off the raw flags, the rest as the JSON body). A non-object
-* request body (rare) is dropped from the flat shape; the dynamic form still sends
-* it.
+* request body (rare) is dropped from the flat shape. Swagger's named body is
+* also offered as an optional argument for writes whose column names overlap
+* query filters.
 *
 * The three sources are merged in the order the executor reads them, and the
 * broker's come LAST because they are the only ones it will not put on the wire.
@@ -79167,19 +79541,44 @@ function operationArgsSchema(op, trustBodyRequired) {
 		Object.assign(properties, bodyProperties);
 		if (trustBodyRequired && Array.isArray(body["required"])) required.push(...body["required"].filter((k) => typeof k === "string" && !isServerGenerated(bodyProperties[k])));
 	}
+	const bodyRequired = [...required];
+	const sharedRequired = [];
+	const consumedNames = /* @__PURE__ */ new Set();
+	if (op.bodyArgName !== void 0 && isObject(body)) {
+		const namedBody = { ...body };
+		if (!trustBodyRequired) delete namedBody["required"];
+		else if (Array.isArray(body["required"]) && isObject(body["properties"])) {
+			const bodyProperties = body["properties"];
+			namedBody["required"] = body["required"].filter((key) => typeof key === "string" && !isServerGenerated(bodyProperties[key]));
+		}
+		properties[op.bodyArgName] = namedBody;
+	}
 	for (const param of op.parameters ?? []) {
 		properties[param.name] = param.schema ?? {};
-		if (param.required) required.push(param.name);
+		consumedNames.add(param.name);
+		if (param.required) {
+			required.push(param.name);
+			sharedRequired.push(param.name);
+		}
 	}
 	for (const arg of brokerConsumedArgs(op)) {
 		properties[arg.name] = arg.schema;
-		if (arg.required) required.push(arg.name);
+		consumedNames.add(arg.name);
+		if (arg.required) {
+			required.push(arg.name);
+			sharedRequired.push(arg.name);
+		}
 	}
-	return {
+	const flat = {
 		type: "object",
 		properties,
 		...required.length > 0 ? { required: [...new Set(required)] } : {}
 	};
+	if (op.bodyArgName === void 0 || bodyRequired.length === 0 || consumedNames.has(op.bodyArgName)) return flat;
+	return { anyOf: [flat, {
+		...flat,
+		required: [...new Set([...sharedRequired, op.bodyArgName])]
+	}] };
 }
 /**
 * Whether a body property is one the SERVER produces rather than one the caller
@@ -79202,11 +79601,17 @@ function isServerGenerated(property) {
 }
 /** Whether an object schema declares ONE named property. */
 function schemaHasProperty(schema, name) {
-	return isObject(schema) && isObject(schema["properties"]) && name in schema["properties"];
+	if (!isObject(schema)) return false;
+	const union = schema["anyOf"] ?? schema["oneOf"];
+	if (Array.isArray(union)) return union.some((branch) => schemaHasProperty(branch, name));
+	return isObject(schema["properties"]) && name in schema["properties"];
 }
 /** Whether an object schema declares at least one property (else the op takes no args). */
 function schemaHasProperties(schema) {
-	return isObject(schema) && isObject(schema["properties"]) && Object.keys(schema["properties"]).length > 0;
+	if (!isObject(schema)) return false;
+	const union = schema["anyOf"] ?? schema["oneOf"];
+	if (Array.isArray(union)) return union.some(schemaHasProperties);
+	return isObject(schema["properties"]) && Object.keys(schema["properties"]).length > 0;
 }
 /**
 * Print a TypeScript type literal for a JSON Schema node. Handles the subset
@@ -81823,6 +82228,64 @@ var createDevCommand = (ctx) => defineCommand({
 	})(args)
 });
 //#endregion
+//#region ../../libs/shared/format/src/lib/coding-agent-prompt.ts
+/**
+* The pasteable prompt, and nothing around it, with no "open your coding agent"
+* preamble. Each surface draws its own instruction: the CLI as a `note`, the
+* web as the label above a copy button.
+*
+* `null` is the empty workspace, which is what the web always passes: the
+* browser cannot see which piece the reader picked at `init`'s own prompt. That
+* costs nothing, because `stackbone-coder` detects the workspace on disk by
+* itself and adds to it rather than re-scaffolding.
+*/
+function codingAgentPrompt(piece) {
+	if (!piece) return "Use the stackbone-coder skill to build my first piece in this workspace: interview me about what it should do, then wire it up.";
+	return `Use the stackbone-coder skill. The "${piece.name}" ${piece.kind} is already scaffolded in this workspace, so skip the scaffolding: interview me about what it should do, then wire it up.`;
+}
+//#endregion
+//#region ../../libs/shared/format/src/lib/coding-agents.ts
+var CODING_AGENT_LABELS = [
+	{
+		id: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		id: "cursor",
+		label: "Cursor"
+	},
+	{
+		id: "github-copilot",
+		label: "GitHub Copilot (VS Code)"
+	},
+	{
+		id: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		id: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		id: "cline",
+		label: "Cline"
+	},
+	{
+		id: "codex",
+		label: "Codex CLI"
+	}
+];
+/**
+* Throws rather than falling back to the id: a registry row whose label is
+* missing here is a mistake to fix at build time, not a menu entry reading
+* `github-copilot`.
+*/
+var codingAgentLabel = (id) => {
+	const found = CODING_AGENT_LABELS.find((agent) => agent.id === id);
+	if (!found) throw new Error(`no label for coding agent "${id}"`);
+	return found.label;
+};
+//#endregion
 //#region src/services/coding-agents/registry.ts
 /**
 * The one place that knows which coding agents Stackbone supports and what
@@ -81831,6 +82294,10 @@ var createDevCommand = (ctx) => defineCommand({
 * that pre-ticks the menu, and the MCP config writer — so adding an agent is a
 * row here and nothing else.
 *
+* The one thing a row does NOT own is its label: that is in `@stackbone/format`,
+* because the browser renders the same list and cannot import this file — it
+* resolves paths against `homedir()` and reads `process.platform`.
+*
 * The four DIFFERENT MCP entry shapes below are the reason this is data rather
 * than a switch. There is no convention: `mcpServers` vs `servers`, `url` vs
 * `httpUrl` vs `serverUrl`, `http` vs `streamableHttp`, JSON vs TOML. Each was
@@ -81870,7 +82337,7 @@ var CODEX_MCP = {
 var CODING_AGENTS = [
 	{
 		id: "claude-code",
-		label: "Claude Code",
+		label: codingAgentLabel("claude-code"),
 		skillsId: "claude-code",
 		skillsDir: ".claude",
 		detect: [".claude", "~/.claude"],
@@ -81884,7 +82351,7 @@ var CODING_AGENTS = [
 	},
 	{
 		id: "cursor",
-		label: "Cursor",
+		label: codingAgentLabel("cursor"),
 		skillsId: "cursor",
 		skillsDir: ".agents",
 		detect: [".cursor", "~/.cursor"],
@@ -81898,7 +82365,7 @@ var CODING_AGENTS = [
 	},
 	{
 		id: "github-copilot",
-		label: "GitHub Copilot (VS Code)",
+		label: codingAgentLabel("github-copilot"),
 		skillsId: "github-copilot",
 		skillsDir: ".agents",
 		detect: [".vscode"],
@@ -81912,7 +82379,7 @@ var CODING_AGENTS = [
 	},
 	{
 		id: "gemini-cli",
-		label: "Gemini CLI",
+		label: codingAgentLabel("gemini-cli"),
 		skillsId: "gemini-cli",
 		skillsDir: ".agents",
 		detect: [".gemini", "~/.gemini"],
@@ -81926,7 +82393,7 @@ var CODING_AGENTS = [
 	},
 	{
 		id: "windsurf",
-		label: "Windsurf",
+		label: codingAgentLabel("windsurf"),
 		skillsId: "windsurf",
 		skillsDir: ".windsurf",
 		detect: [".windsurf", "~/.codeium"],
@@ -81944,7 +82411,7 @@ var CODING_AGENTS = [
 	},
 	{
 		id: "cline",
-		label: "Cline",
+		label: codingAgentLabel("cline"),
 		skillsId: "cline",
 		skillsDir: ".agents",
 		detect: [
@@ -81965,7 +82432,7 @@ var CODING_AGENTS = [
 	},
 	{
 		id: "codex",
-		label: "Codex CLI",
+		label: codingAgentLabel("codex"),
 		skillsId: "codex",
 		skillsDir: ".agents",
 		detect: [".codex", "~/.codex"],
@@ -82642,22 +83109,6 @@ var createHitlCommand = defineGroup({
 	}
 });
 //#endregion
-//#region ../../libs/shared/format/src/lib/coding-agent-prompt.ts
-/**
-* The pasteable prompt, and nothing around it, with no "open your coding agent"
-* preamble. Each surface draws its own instruction: the CLI as a `note`, the
-* web as the label above a copy button.
-*
-* `null` is the empty workspace, which is what the web always passes: the
-* browser cannot see which piece the reader picked at `init`'s own prompt. That
-* costs nothing, because `stackbone-coder` detects the workspace on disk by
-* itself and adds to it rather than re-scaffolding.
-*/
-function codingAgentPrompt(piece) {
-	if (!piece) return "Use the stackbone-coder skill to build my first piece in this workspace: interview me about what it should do, then wire it up.";
-	return `Use the stackbone-coder skill. The "${piece.name}" ${piece.kind} is already scaffolded in this workspace, so skip the scaffolding: interview me about what it should do, then wire it up.`;
-}
-//#endregion
 //#region src/core/npm-exec.ts
 var execFileAsync = promisify(execFile);
 var NEEDS_SHELL = process.platform === "win32";