@stackbone/cli 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-09-14
+
+### Added
+
+- **`stackbone dev` records a write's echo and answers `isOwnEcho`.** A
+  connector call that names an `echoPath` has the value extracted from the
+  provider's response and recorded on its `connection` run step, and the
+  emulator plants the reader `isOwnEcho` queries on first dispatch, looking one
+  hour back across every workflow in the project. Three cases leave an
+  unresolved marker instead of a value, and reading one makes `isOwnEcho` throw
+  `echo_guard_unavailable` rather than answer a false "not ours": the path
+  resolved to nothing (missing, `null` and `''` are one case, because an empty
+  echo would match every later delivery whose value renders empty), the call
+  failed in a way that may still have landed (`execute_failed`, `timeout`, an
+  envelope-less `credential_error`), or the write ran with no workflow owner,
+  such as inside an agent turn's tool, which blinds every caller on that
+  connector. The runtime warns which write left the marker when it writes the
+  row. A call with no invocation context at all still writes to the provider
+  and records nothing, so it warns. Both halves need the `@stackbone/sdk`
+  released alongside this version: a project on an older SDK never sends
+  `echoPath`, and its `isOwnEcho` throws "No echo guard reader is bound".
+
+### Fixed
+
+- **`stackbone package --target self-host`: the agent no longer races the
+  control plane for the shared connect tables.** The two containers share one
+  Postgres and both declared `connection_grant`: db-core's migration with a
+  bare `CREATE TABLE`, the box's lazy boot DDL with
+  `CREATE TABLE IF NOT EXISTS`. Whichever arrived second lost, and a boot where
+  the box won killed the control plane's migration and surfaced as a
+  health-check timeout. The generated compose now sets
+  `STACKBONE_PLATFORM_SCHEMA_OWNER: control-plane` on the agent service and the
+  box stands down. Not overridable from `.env`: it is a fact about that compose
+  file, not a preference. `stackbone dev` and BYOC set nothing and keep creating
+  their own tables.
+
+- **A failed broker-context build is no longer cached for the life of the
+  process.** One Postgres hiccup on the first Connect request used to disable
+  Connect until the container restarted; the next request now rebuilds it.
+
 ## [0.4.1] - 2026-09-11
 
 ### Added

package/main.js

@@ -9720,9 +9720,11 @@ 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, idempotent }`. `principal` defaults to
-*                  `{ type: 'app' }`; `idempotent` is UNSET by default and only
-*                  an explicit `false` changes how a failure is retried.
+* @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({
@@ -9730,7 +9732,8 @@ async function callConnector(connector, operation, args, opts) {
 		operation,
 		...args !== void 0 ? { args } : {},
 		...opts?.principal !== void 0 ? { principal: opts.principal } : {},
-		...opts?.idempotent !== void 0 ? { idempotent: opts.idempotent } : {}
+		...opts?.idempotent !== void 0 ? { idempotent: opts.idempotent } : {},
+		...opts?.echoPath !== void 0 ? { echoPath: opts.echoPath } : {}
 	})).output;
 }
 var connectorHandle, connection;
@@ -14368,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();
@@ -15699,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.1";
+	STACKBONE_CLI_BUILD_VERSION = "0.5.0";
 	EMULATOR_CAPABILITY_ROUTES = {
 		"database.postgres_direct": "/api/db",
 		"rag.basic": "/api/rag",
@@ -32303,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",
@@ -32385,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,
@@ -32782,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: {
@@ -32852,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: [
 								{
@@ -33160,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",
@@ -33381,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",
@@ -33471,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.",
@@ -33564,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",
@@ -33985,8 +34011,8 @@ var init_supabase_connector = __esmMin((() => {
 		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: {
@@ -51808,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 {
@@ -51879,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 () => {
@@ -65943,6 +65994,7 @@ var init_load_project_runtime = __esmMin((() => {
 		let setActiveStepReader;
 		let approvalRequest;
 		let setConnectorInvoker;
+		let setEchoGuardReader;
 		let connectorInvoker;
 		let setActionInvoker;
 		let actionInvoker;
@@ -65958,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?.();
@@ -66015,6 +66068,7 @@ var init_load_project_runtime = __esmMin((() => {
 			setActiveStepReader,
 			approvalRequest,
 			setConnectorInvoker,
+			setEchoGuardReader,
 			connectorInvoker,
 			setActionInvoker,
 			actionInvoker,
@@ -66679,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;
@@ -66697,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(),
@@ -66712,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);
 	};
@@ -66795,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
@@ -66858,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;
 	};
@@ -66884,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;
@@ -71153,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.1";
+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,
@@ -76178,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
@@ -79028,7 +79186,9 @@ function renderOperation(op) {
 * 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, because PLA-1351's `echoPath` lands in exactly the same place.
+* 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbone/cli",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {