fvtt-world-cli 1.0.0 → 1.1.1

package/dist/index.js

@@ -10,7 +10,19 @@ import { readFileSync as readFileSync2 } from "node:fs";
 import { createHash as createHash2, randomBytes as randomBytes2, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
 
 // ../protocol/src/constants.js
-var PROTOCOL_VERSION = "3.0";
+var PROTOCOL_VERSION = "1.1.1";
+var PROTOCOL_COMPONENTS = Object.freeze({
+  MODULE: "module",
+  CLI_DAEMON: "cli-daemon",
+  UNKNOWN: "unknown"
+});
+var PROTOCOL_HANDSHAKES = Object.freeze({
+  CLI_DAEMON: "cli-daemon",
+  MODULE_DAEMON: "module-daemon",
+  COMMAND_REQUEST: "command-request",
+  DAEMON_REQUEST: "daemon-request",
+  UNKNOWN: "unknown"
+});
 var MODULE_ID = "fvtt-world-cli";
 var DEFAULT_DAEMON_URL = "ws://127.0.0.1:47833";
 var AUTH_FIRST_MESSAGE_TIMEOUT_MS = 5e3;
@@ -26,6 +38,9 @@ var BRIDGE_TAKEOVER_CLOSE_CODE = 4001;
 var BRIDGE_TAKEOVER_CLOSE_REASON = "Bridge session taken over by the same pairing";
 var BRIDGE_RELEASE_CLOSE_CODE = 4002;
 var BRIDGE_RELEASE_CLOSE_REASON = "Bridge released";
+var APPROVAL_AWAIT_PARK_CAP_MS = 25e3;
+var APPROVAL_RESULT_RETENTION_MS = 5 * 60 * 1e3;
+var POLICY_DISCOVERY_TIMEOUT_MS = 1500;
 var CLIENT_ID_MIN_LENGTH = 8;
 var CLIENT_ID_MAX_LENGTH = 64;
 var CLIENT_ID_PATTERN = "^[0-9a-fA-F-]+$";
@@ -87,6 +102,8 @@ var SCENE_THUMBNAIL_MAX_BYTES = 2 * 1024 * 1024;
 var SCENE_THUMBNAIL_RESPONSE_MAX_BYTES = 1024 * 1024;
 var TABLE_DRAW_MAX_COUNT = 100;
 var SETTING_VALUE_MAX_BYTES = 256 * 1024;
+var MACRO_EXECUTE_TIMEOUT_DEFAULT_MS = 3e4;
+var MACRO_EXECUTE_TIMEOUT_MAX_MS = 3e5;
 var SEARCH_MODES = Object.freeze(["name", "full"]);
 var SEARCH_SOURCES = Object.freeze(["world", "pack"]);
 var SEARCH_SNIPPET_FIELDS = Object.freeze(["text", "systemText", "name"]);
@@ -166,6 +183,7 @@ var ERROR_CODES = Object.freeze({
   COMPENDIUM_NOT_FOUND: "COMPENDIUM_NOT_FOUND",
   COMPENDIUM_ENTRY_NOT_FOUND: "COMPENDIUM_ENTRY_NOT_FOUND",
   IDEMPOTENCY_KEY_CONFLICT: "IDEMPOTENCY_KEY_CONFLICT",
+  IDEMPOTENCY_STORE_FULL: "IDEMPOTENCY_STORE_FULL",
   EFFECT_NOT_FOUND: "EFFECT_NOT_FOUND",
   PLAYLIST_NOT_FOUND: "PLAYLIST_NOT_FOUND",
   PLAYLIST_SOUND_NOT_FOUND: "PLAYLIST_SOUND_NOT_FOUND",
@@ -186,7 +204,11 @@ var ERROR_CODES = Object.freeze({
   SETTING_NOT_FOUND: "SETTING_NOT_FOUND",
   SETTING_READ_FAILED: "SETTING_READ_FAILED",
   SETTING_VALUE_NOT_SERIALIZABLE: "SETTING_VALUE_NOT_SERIALIZABLE",
+  SETTING_PROTECTED: "SETTING_PROTECTED",
+  SETTING_UNREGISTERED: "SETTING_UNREGISTERED",
+  MACRO_TIMEOUT: "MACRO_TIMEOUT",
   USER_NOT_FOUND: "USER_NOT_FOUND",
+  USER_SELF_PROTECTED: "USER_SELF_PROTECTED",
   SEARCH_INDEX_OVERFLOW: "SEARCH_INDEX_OVERFLOW",
   QUERY_TOO_BROAD: "QUERY_TOO_BROAD",
   UNSUPPORTED_OPERATION: "UNSUPPORTED_OPERATION",
@@ -199,11 +221,22 @@ var ERROR_CODES = Object.freeze({
   PAIRING_REQUIRED: "PAIRING_REQUIRED",
   PAIRING_NOT_FOUND: "PAIRING_NOT_FOUND",
   PAIRING_EXPIRED: "PAIRING_EXPIRED",
-  BRIDGE_BUSY: "BRIDGE_BUSY"
+  BRIDGE_BUSY: "BRIDGE_BUSY",
+  COMMAND_DENIED: "COMMAND_DENIED",
+  APPROVAL_PENDING: "APPROVAL_PENDING",
+  APPROVAL_DENIED: "APPROVAL_DENIED",
+  APPROVAL_TIMEOUT: "APPROVAL_TIMEOUT",
+  APPROVAL_CANCELLED: "APPROVAL_CANCELLED",
+  APPROVAL_QUEUE_FULL: "APPROVAL_QUEUE_FULL",
+  APPROVAL_UNKNOWN: "APPROVAL_UNKNOWN"
 });
 
 // ../protocol/src/schemas/shared.js
-var cmd = (paramsSchema, { mutation = false } = {}) => ({ mutation, paramsSchema });
+var cmd = (paramsSchema, { mutation = false, discovery = true } = {}) => ({
+  mutation,
+  ...discovery ? {} : { discovery: false },
+  paramsSchema
+});
 function mergeCommandFamilies(families) {
   const merged = {};
   for (const family of families) {
@@ -282,6 +315,9 @@ var tokenIncludeProperty = {
 var compendiumIncludeProperty = {
   include: { type: "array", items: { type: "string", enum: ["effects"] } }
 };
+var userIdsProperty = {
+  userIds: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 }
+};
 var idempotencyKeyProperty = {
   idempotencyKey: { type: "string", minLength: 1 }
 };
@@ -494,9 +530,96 @@ var userIdSchema = {
   properties: { userId: { type: "string", minLength: 1 } },
   additionalProperties: false
 };
+var userRoleSchema = { type: "integer", enum: [1, 2, 3, 4] };
+var userDataSchema = {
+  type: "object",
+  required: ["name"],
+  properties: {
+    name: { type: "string", minLength: 1 },
+    role: userRoleSchema,
+    color: { type: "string", minLength: 1 },
+    pronouns: { type: "string" },
+    avatar: nullableStringSchema,
+    character: nullableStringSchema,
+    flags: freeformObjectSchema
+  },
+  additionalProperties: false
+};
+var userPatchSchema = patchFrom(userDataSchema, { omit: ["role"] });
+var userPermissionsSchema = {
+  type: "object",
+  required: [],
+  properties: {},
+  additionalProperties: { type: ["boolean", "null"] },
+  minProperties: 1
+};
 var userCommands = {
   "user.list": cmd(nameFilteredListSchema),
-  "user.get": cmd(userIdSchema)
+  "user.get": cmd(userIdSchema),
+  "user.create": cmd(
+    {
+      type: "object",
+      required: ["data"],
+      properties: {
+        data: userDataSchema,
+        ...dryRunProperty,
+        ...idempotencyKeyProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "user.update": cmd(
+    {
+      type: "object",
+      required: ["userId", "patch"],
+      properties: {
+        userId: { type: "string", minLength: 1 },
+        patch: userPatchSchema,
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "user.delete": cmd(
+    {
+      type: "object",
+      required: ["userId"],
+      properties: {
+        userId: { type: "string", minLength: 1 },
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "user.role.set": cmd(
+    {
+      type: "object",
+      required: ["userId", "role"],
+      properties: {
+        userId: { type: "string", minLength: 1 },
+        role: userRoleSchema,
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "user.permissions.set": cmd(
+    {
+      type: "object",
+      required: ["userId", "permissions"],
+      properties: {
+        userId: { type: "string", minLength: 1 },
+        permissions: userPermissionsSchema,
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  )
 };
 
 // ../protocol/src/schemas/actor.js
@@ -873,6 +996,34 @@ var actorCompendiumImportCommands = {
   "actor.import-from-compendium": cmd(compendiumImportSchema(actorPatchSchema), { mutation: true })
 };
 
+// ../protocol/src/schemas/approval.js
+var approvalIdProperty = {
+  approvalId: { type: "string", minLength: 22, maxLength: 22, pattern: "^[A-Za-z0-9_-]{22}$" }
+};
+var approvalAwaitSchema = {
+  type: "object",
+  required: ["approvalId"],
+  properties: {
+    ...approvalIdProperty,
+    waitMs: { type: "integer", minimum: 0, maximum: APPROVAL_AWAIT_PARK_CAP_MS }
+  },
+  additionalProperties: false
+};
+var approvalCancelSchema = {
+  type: "object",
+  required: ["approvalId"],
+  properties: { ...approvalIdProperty },
+  additionalProperties: false
+};
+var APPROVAL_AWAIT_COMMAND = "approval.await";
+var APPROVAL_CANCEL_COMMAND = "approval.cancel";
+var POLICY_SNAPSHOT_COMMAND = "policy.snapshot";
+var approvalCommands = {
+  [APPROVAL_AWAIT_COMMAND]: cmd(approvalAwaitSchema, { discovery: false }),
+  [APPROVAL_CANCEL_COMMAND]: cmd(approvalCancelSchema, { discovery: false }),
+  [POLICY_SNAPSHOT_COMMAND]: cmd(emptyObjectSchema, { discovery: false })
+};
+
 // ../protocol/src/schemas/cards.js
 var cardBackSchema = {
   type: "object",
@@ -1266,6 +1417,15 @@ var chatCommands = {
       additionalProperties: false
     },
     { mutation: true }
+  ),
+  "chat.flush": cmd(
+    {
+      type: "object",
+      required: [],
+      properties: { ...dryRunProperty },
+      additionalProperties: false
+    },
+    { mutation: true }
   )
 };
 
@@ -1810,6 +1970,36 @@ var folderCommands = {
   "folder.delete": cmd(folderDeleteSchema, { mutation: true })
 };
 
+// ../protocol/src/schemas/game.js
+var gameCommands = {
+  "game.pause": cmd(
+    {
+      type: "object",
+      required: ["paused"],
+      properties: {
+        paused: { type: "boolean" },
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  )
+};
+
+// ../protocol/src/schemas/image.js
+var imageCommands = {
+  "image.show": cmd({
+    type: "object",
+    required: ["src"],
+    properties: {
+      src: { type: "string", minLength: 1 },
+      title: { type: "string", minLength: 1 },
+      ...userIdsProperty
+    },
+    additionalProperties: false
+  })
+};
+
 // ../protocol/src/schemas/item.js
 var itemCommands = {
   "item.list": cmd(nameFilteredListSchema),
@@ -2193,6 +2383,16 @@ var journalCommands = {
   "journal.import-from-compendium": cmd(compendiumImportSchema(journalDocumentPatchSchema), {
     mutation: true
   }),
+  "journal.show": cmd({
+    type: "object",
+    required: ["journalId"],
+    properties: {
+      journalId: { type: "string", minLength: 1 },
+      force: { type: "boolean" },
+      ...userIdsProperty
+    },
+    additionalProperties: false
+  }),
   "journal.ownership.set": cmd(
     ownershipSetSchema("journalId", {
       levelSchema: journalOwnershipLevelSchema,
@@ -2277,6 +2477,22 @@ var macroDataSchema = {
   additionalProperties: false
 };
 var macroPatchSchema = patchFrom(macroDataSchema);
+var macroExecuteArgsSchema = {
+  ...freeformObjectSchema,
+  propertyNames: { pattern: "^[A-Za-z_$][A-Za-z0-9_$]*$" }
+};
+var macroExecuteScopeSchema = {
+  type: "object",
+  required: [],
+  properties: {
+    actorId: { type: "string", minLength: 1 },
+    sceneId: { type: "string", minLength: 1 },
+    tokenId: { type: "string", minLength: 1 },
+    args: macroExecuteArgsSchema
+  },
+  additionalProperties: false,
+  minProperties: 1
+};
 var macroIdSchema = {
   type: "object",
   required: ["macroId"],
@@ -2346,6 +2562,20 @@ var macroCommands = {
     },
     { mutation: true }
   ),
+  "macro.execute": cmd(
+    {
+      type: "object",
+      required: ["macroId"],
+      properties: {
+        macroId: { type: "string", minLength: 1 },
+        scope: macroExecuteScopeSchema,
+        timeoutMs: { type: "integer", minimum: 1, maximum: MACRO_EXECUTE_TIMEOUT_MAX_MS },
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
   "macro.import-from-compendium": cmd(compendiumImportSchema(macroPatchSchema), { mutation: true }),
   "macro.ownership.set": cmd(ownershipSetSchema("macroId", { levelSchema: ownershipLevelSchema }), {
     mutation: true
@@ -2902,6 +3132,26 @@ var regionBehaviorPatchSchema = {
   additionalProperties: true,
   minProperties: 1
 };
+var executableBehaviorTypeSchema = { type: "string", enum: ["executeMacro"] };
+var executableBehaviorCreateSchema = {
+  type: "object",
+  required: ["type"],
+  properties: {
+    type: executableBehaviorTypeSchema,
+    ...regionBehaviorWriteProperties
+  },
+  additionalProperties: true
+};
+var executableBehaviorPatchSchema = {
+  type: "object",
+  required: [],
+  properties: {
+    type: executableBehaviorTypeSchema,
+    ...regionBehaviorWriteProperties
+  },
+  additionalProperties: true,
+  minProperties: 1
+};
 var sceneEmbeddedCommands = {
   "scene.token.list": cmd({
     type: "object",
@@ -3969,6 +4219,52 @@ var sceneEmbeddedCommands = {
       additionalProperties: false
     },
     { mutation: true }
+  ),
+  "scene.region.behavior.executable.create": cmd(
+    {
+      type: "object",
+      required: ["sceneId", "regionId", "data"],
+      properties: {
+        sceneId: { type: "string", minLength: 1 },
+        regionId: { type: "string", minLength: 1 },
+        data: executableBehaviorCreateSchema,
+        ...dryRunProperty,
+        ...idempotencyKeyProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "scene.region.behavior.executable.update": cmd(
+    {
+      type: "object",
+      required: ["sceneId", "regionId", "behaviorId", "patch"],
+      properties: {
+        sceneId: { type: "string", minLength: 1 },
+        regionId: { type: "string", minLength: 1 },
+        behaviorId: { type: "string", minLength: 1 },
+        patch: executableBehaviorPatchSchema,
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "scene.region.behavior.executable.clone": cmd(
+    {
+      type: "object",
+      required: ["sceneId", "regionId", "behaviorId"],
+      properties: {
+        sceneId: { type: "string", minLength: 1 },
+        regionId: { type: "string", minLength: 1 },
+        behaviorId: { type: "string", minLength: 1 },
+        patch: executableBehaviorPatchSchema,
+        ...dryRunProperty,
+        ...idempotencyKeyProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
   )
 };
 
@@ -4150,6 +4446,27 @@ var sceneCommands = {
     },
     { mutation: true }
   ),
+  "scene.activate": cmd(
+    {
+      type: "object",
+      required: ["sceneId"],
+      properties: {
+        sceneId: { type: "string", minLength: 1 },
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "scene.pull-users": cmd({
+    type: "object",
+    required: ["sceneId"],
+    properties: {
+      sceneId: { type: "string", minLength: 1 },
+      ...userIdsProperty
+    },
+    additionalProperties: false
+  }),
   "scene.ownership.set": cmd(ownershipSetSchema("sceneId", { levelSchema: ownershipLevelSchema }), {
     mutation: true
   })
@@ -4181,24 +4498,70 @@ var settingListSchema = {
   properties: { ...nameFilterProperty, ...paginationProperties },
   additionalProperties: false
 };
+var settingKeyProperties = {
+  namespace: { type: "string", minLength: 1 },
+  key: { type: "string", minLength: 1 }
+};
 var settingGetSchema = {
   type: "object",
   required: ["namespace", "key"],
+  properties: { ...settingKeyProperties },
+  additionalProperties: false
+};
+var settingWriteItemSchema = {
+  type: "object",
+  required: ["namespace", "key", "value"],
   properties: {
-    namespace: { type: "string", minLength: 1 },
-    key: { type: "string", minLength: 1 }
+    ...settingKeyProperties,
+    value: {}
   },
   additionalProperties: false
 };
 var settingCommands = {
   "setting.list": cmd(settingListSchema),
-  "setting.get": cmd(settingGetSchema)
+  "setting.get": cmd(settingGetSchema),
+  "setting.get-many": cmd({
+    type: "object",
+    required: ["ids"],
+    properties: { ...batchIdsProperty },
+    additionalProperties: false
+  }),
+  "setting.set": cmd(
+    {
+      type: "object",
+      required: ["namespace", "key", "value"],
+      properties: {
+        ...settingWriteItemSchema.properties,
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  ),
+  "setting.set-many": cmd(
+    {
+      type: "object",
+      required: ["items"],
+      properties: {
+        items: {
+          type: "array",
+          minItems: 1,
+          maxItems: BATCH_WRITE_MAX_ITEMS,
+          items: settingWriteItemSchema
+        },
+        ...dryRunProperty
+      },
+      additionalProperties: false
+    },
+    { mutation: true }
+  )
 };
 
 // ../protocol/src/schemas/system.js
 var systemCommands = {
   "system.ping": cmd(emptyObjectSchema),
-  "system.info": cmd(emptyObjectSchema)
+  "system.info": cmd(emptyObjectSchema),
+  "system.reload": cmd(emptyObjectSchema)
 };
 
 // ../protocol/src/schemas/table.js
@@ -4450,17 +4813,23 @@ var COMMAND_DEFINITIONS = deepFreeze(
     fileCommands,
     compendiumCommands,
     folderCommands,
+    gameCommands,
+    imageCommands,
     userCommands,
     settingCommands,
     actorCompendiumImportCommands,
     worldAuditCommands,
-    worldSearchCommands
+    worldSearchCommands,
+    approvalCommands
   ])
 );
 var COMMAND_NAMES = deepFreeze(Object.keys(COMMAND_DEFINITIONS));
 var WRITE_COMMANDS = deepFreeze(
   COMMAND_NAMES.filter((command) => COMMAND_DEFINITIONS[command].mutation === true)
 );
+var DISCOVERABLE_COMMAND_NAMES = deepFreeze(
+  COMMAND_NAMES.filter((command) => COMMAND_DEFINITIONS[command].discovery !== false)
+);
 var REQUEST_SCHEMA = {
   type: "object",
   required: ["protocolVersion", "type", "id", "command", "params"],
@@ -4808,6 +5177,370 @@ function getInvalidCommandError(command) {
   };
 }
 
+// ../protocol/src/generated/default-command-profile.js
+var DEFAULT_COMMAND_PROFILE = deepFreeze({
+  "system.ping": "allow",
+  "system.info": "allow",
+  "system.reload": "approve",
+  "scene.list": "allow",
+  "scene.get": "allow",
+  "scene.get-many": "allow",
+  "scene.update": "allow",
+  "scene.create": "allow",
+  "scene.delete": "approve",
+  "scene.clone": "allow",
+  "scene.import-from-compendium": "allow",
+  "scene.thumbnail.generate": "allow",
+  "scene.fog.reset": "approve",
+  "scene.activate": "allow",
+  "scene.pull-users": "allow",
+  "scene.ownership.set": "allow",
+  "scene.token.list": "allow",
+  "scene.token.get": "allow",
+  "scene.token.create": "allow",
+  "scene.token.update": "allow",
+  "scene.token.delete": "approve",
+  "scene.token.clone": "allow",
+  "scene.token.create-many": "allow",
+  "scene.token.update-many": "allow",
+  "scene.token.delete-many": "approve",
+  "scene.token.item.list": "allow",
+  "scene.token.item.get": "allow",
+  "scene.token.item.create": "allow",
+  "scene.token.item.update": "allow",
+  "scene.token.item.delete": "approve",
+  "scene.token.item.clone": "allow",
+  "scene.token.item.effect.list": "allow",
+  "scene.token.item.effect.get": "allow",
+  "scene.token.item.effect.create": "allow",
+  "scene.token.item.effect.update": "allow",
+  "scene.token.item.effect.delete": "approve",
+  "scene.token.item.effect.clone": "allow",
+  "scene.token.item.effect.create-many": "allow",
+  "scene.token.item.effect.update-many": "allow",
+  "scene.token.item.effect.delete-many": "approve",
+  "scene.token.effect.list": "allow",
+  "scene.token.effect.applied": "allow",
+  "scene.token.effect.get": "allow",
+  "scene.token.effect.create": "allow",
+  "scene.token.effect.update": "allow",
+  "scene.token.effect.delete": "approve",
+  "scene.token.effect.clone": "allow",
+  "scene.token.effect.create-many": "allow",
+  "scene.token.effect.update-many": "allow",
+  "scene.token.effect.delete-many": "approve",
+  "scene.tile.list": "allow",
+  "scene.tile.get": "allow",
+  "scene.tile.create": "allow",
+  "scene.tile.update": "allow",
+  "scene.tile.delete": "approve",
+  "scene.tile.clone": "allow",
+  "scene.tile.create-many": "allow",
+  "scene.tile.update-many": "allow",
+  "scene.tile.delete-many": "approve",
+  "scene.sound.list": "allow",
+  "scene.sound.get": "allow",
+  "scene.sound.create": "allow",
+  "scene.sound.update": "allow",
+  "scene.sound.delete": "approve",
+  "scene.sound.clone": "allow",
+  "scene.sound.create-many": "allow",
+  "scene.sound.update-many": "allow",
+  "scene.sound.delete-many": "approve",
+  "scene.wall.list": "allow",
+  "scene.wall.get": "allow",
+  "scene.wall.create": "allow",
+  "scene.wall.update": "allow",
+  "scene.wall.delete": "approve",
+  "scene.wall.clone": "allow",
+  "scene.wall.create-many": "allow",
+  "scene.wall.update-many": "allow",
+  "scene.wall.delete-many": "approve",
+  "scene.note.list": "allow",
+  "scene.note.get": "allow",
+  "scene.note.create": "allow",
+  "scene.note.update": "allow",
+  "scene.note.delete": "approve",
+  "scene.note.clone": "allow",
+  "scene.note.create-many": "allow",
+  "scene.note.update-many": "allow",
+  "scene.note.delete-many": "approve",
+  "scene.drawing.list": "allow",
+  "scene.drawing.get": "allow",
+  "scene.drawing.create": "allow",
+  "scene.drawing.update": "allow",
+  "scene.drawing.delete": "approve",
+  "scene.drawing.clone": "allow",
+  "scene.drawing.create-many": "allow",
+  "scene.drawing.update-many": "allow",
+  "scene.drawing.delete-many": "approve",
+  "scene.light.list": "allow",
+  "scene.light.get": "allow",
+  "scene.light.create": "allow",
+  "scene.light.update": "allow",
+  "scene.light.delete": "approve",
+  "scene.light.clone": "allow",
+  "scene.light.create-many": "allow",
+  "scene.light.update-many": "allow",
+  "scene.light.delete-many": "approve",
+  "scene.template.list": "allow",
+  "scene.template.get": "allow",
+  "scene.template.create": "allow",
+  "scene.template.update": "allow",
+  "scene.template.delete": "approve",
+  "scene.template.clone": "allow",
+  "scene.template.create-many": "allow",
+  "scene.template.update-many": "allow",
+  "scene.template.delete-many": "approve",
+  "scene.region.list": "allow",
+  "scene.region.get": "allow",
+  "scene.region.create": "allow",
+  "scene.region.update": "allow",
+  "scene.region.delete": "approve",
+  "scene.region.clone": "allow",
+  "scene.region.create-many": "allow",
+  "scene.region.update-many": "allow",
+  "scene.region.delete-many": "approve",
+  "scene.region.behavior.list": "allow",
+  "scene.region.behavior.get": "allow",
+  "scene.region.behavior.create": "allow",
+  "scene.region.behavior.update": "allow",
+  "scene.region.behavior.delete": "approve",
+  "scene.region.behavior.clone": "allow",
+  "scene.region.behavior.executable.create": "deny",
+  "scene.region.behavior.executable.update": "deny",
+  "scene.region.behavior.executable.clone": "deny",
+  "item.list": "allow",
+  "item.get": "allow",
+  "item.get-many": "allow",
+  "item.create": "allow",
+  "item.update": "allow",
+  "item.delete": "approve",
+  "item.clone": "allow",
+  "item.import-from-compendium": "allow",
+  "item.ownership.set": "allow",
+  "item.update-many": "allow",
+  "item.delete-many": "approve",
+  "item.effect.list": "allow",
+  "item.effect.get": "allow",
+  "item.effect.create": "allow",
+  "item.effect.update": "allow",
+  "item.effect.delete": "approve",
+  "item.effect.clone": "allow",
+  "item.effect.create-many": "allow",
+  "item.effect.update-many": "allow",
+  "item.effect.delete-many": "approve",
+  "journal.list": "allow",
+  "journal.get": "allow",
+  "journal.get-many": "allow",
+  "journal.create": "allow",
+  "journal.update": "allow",
+  "journal.delete": "approve",
+  "journal.clone": "allow",
+  "journal.import-from-compendium": "allow",
+  "journal.show": "allow",
+  "journal.ownership.set": "allow",
+  "journal.update-many": "allow",
+  "journal.delete-many": "approve",
+  "journal.category.list": "allow",
+  "journal.category.get": "allow",
+  "journal.category.create": "allow",
+  "journal.category.update": "allow",
+  "journal.category.delete": "approve",
+  "macro.list": "allow",
+  "macro.get": "allow",
+  "macro.get-many": "allow",
+  "macro.create": "allow",
+  "macro.update": "allow",
+  "macro.delete": "approve",
+  "macro.clone": "allow",
+  "macro.execute": "deny",
+  "macro.import-from-compendium": "allow",
+  "macro.ownership.set": "allow",
+  "playlist.list": "allow",
+  "playlist.get": "allow",
+  "playlist.get-many": "allow",
+  "playlist.create": "allow",
+  "playlist.update": "allow",
+  "playlist.delete": "approve",
+  "playlist.clone": "allow",
+  "playlist.import-from-compendium": "allow",
+  "playlist.ownership.set": "allow",
+  "playlist.sound.list": "allow",
+  "playlist.sound.get": "allow",
+  "playlist.sound.create": "allow",
+  "playlist.sound.update": "allow",
+  "playlist.sound.delete": "approve",
+  "playlist.sound.clone": "allow",
+  "playlist.play": "allow",
+  "playlist.stop": "allow",
+  "playlist.playNext": "allow",
+  "playlist.sound.play": "allow",
+  "playlist.sound.stop": "allow",
+  "table.list": "allow",
+  "table.get": "allow",
+  "table.get-many": "allow",
+  "table.create": "allow",
+  "table.update": "allow",
+  "table.delete": "approve",
+  "table.clone": "allow",
+  "table.import-from-compendium": "allow",
+  "table.draw": "allow",
+  "table.reset": "allow",
+  "table.ownership.set": "allow",
+  "table.result.list": "allow",
+  "table.result.get": "allow",
+  "table.result.create": "allow",
+  "table.result.update": "allow",
+  "table.result.delete": "approve",
+  "table.result.clone": "allow",
+  "combat.list": "allow",
+  "combat.get": "allow",
+  "combat.create": "allow",
+  "combat.update": "allow",
+  "combat.delete": "approve",
+  "combat.start": "allow",
+  "combat.activate": "allow",
+  "combat.next-turn": "allow",
+  "combat.previous-turn": "allow",
+  "combat.next-round": "allow",
+  "combat.previous-round": "allow",
+  "combat.reset-initiative": "allow",
+  "combat.roll-initiative": "allow",
+  "combat.set-initiative": "allow",
+  "combat.combatant.list": "allow",
+  "combat.combatant.get": "allow",
+  "combat.combatant.create": "allow",
+  "combat.combatant.update": "allow",
+  "combat.combatant.delete": "approve",
+  "combat.group.list": "allow",
+  "combat.group.get": "allow",
+  "combat.group.create": "allow",
+  "combat.group.update": "allow",
+  "combat.group.delete": "approve",
+  "cards.list": "allow",
+  "cards.get": "allow",
+  "cards.get-many": "allow",
+  "cards.create": "allow",
+  "cards.update": "allow",
+  "cards.clone": "allow",
+  "cards.import-from-compendium": "allow",
+  "cards.delete": "approve",
+  "cards.ownership.set": "allow",
+  "cards.shuffle": "allow",
+  "cards.reset": "allow",
+  "cards.deal": "allow",
+  "cards.draw": "allow",
+  "cards.pass": "allow",
+  "cards.card.list": "allow",
+  "cards.card.get": "allow",
+  "cards.card.create": "allow",
+  "cards.card.update": "allow",
+  "cards.card.clone": "allow",
+  "cards.card.delete": "approve",
+  "chat.list": "allow",
+  "chat.get": "allow",
+  "chat.create": "allow",
+  "chat.delete": "approve",
+  "chat.flush": "approve",
+  "actor.list": "allow",
+  "actor.get": "allow",
+  "actor.get-many": "allow",
+  "actor.create": "allow",
+  "actor.update": "allow",
+  "actor.delete": "approve",
+  "actor.clone": "allow",
+  "actor.ownership.set": "allow",
+  "actor.item.list": "allow",
+  "actor.item.create": "allow",
+  "actor.item.update": "allow",
+  "actor.item.get": "allow",
+  "actor.item.delete": "approve",
+  "actor.item.clone": "allow",
+  "actor.item.import-from-compendium": "allow",
+  "actor.update-many": "allow",
+  "actor.delete-many": "approve",
+  "actor.effect.list": "allow",
+  "actor.effect.applied": "allow",
+  "actor.effect.get": "allow",
+  "actor.effect.create": "allow",
+  "actor.effect.update": "allow",
+  "actor.effect.delete": "approve",
+  "actor.effect.clone": "allow",
+  "actor.effect.create-many": "allow",
+  "actor.effect.update-many": "allow",
+  "actor.effect.delete-many": "approve",
+  "actor.item.effect.list": "allow",
+  "actor.item.effect.get": "allow",
+  "actor.item.effect.create": "allow",
+  "actor.item.effect.update": "allow",
+  "actor.item.effect.delete": "approve",
+  "actor.item.effect.clone": "allow",
+  "actor.item.effect.create-many": "allow",
+  "actor.item.effect.update-many": "allow",
+  "actor.item.effect.delete-many": "approve",
+  "file.list": "allow",
+  "file.stat": "allow",
+  "file.read": "allow",
+  "file.mkdir": "allow",
+  "file.upload": "allow",
+  "file.delete": "approve",
+  "file.move": "approve",
+  "compendium.list": "allow",
+  "compendium.index": "allow",
+  "compendium.get": "allow",
+  "folder.list": "allow",
+  "folder.get": "allow",
+  "folder.create": "allow",
+  "folder.update": "allow",
+  "folder.delete": "approve",
+  "game.pause": "allow",
+  "image.show": "allow",
+  "user.list": "allow",
+  "user.get": "allow",
+  "user.create": "approve",
+  "user.update": "allow",
+  "user.delete": "approve",
+  "user.role.set": "deny",
+  "user.permissions.set": "deny",
+  "setting.list": "allow",
+  "setting.get": "allow",
+  "setting.get-many": "allow",
+  "setting.set": "deny",
+  "setting.set-many": "deny",
+  "actor.import-from-compendium": "allow",
+  "world.audit-files": "allow",
+  "world.search": "allow",
+  "approval.await": "allow",
+  "approval.cancel": "allow",
+  "policy.snapshot": "allow"
+});
+
+// ../protocol/src/command-risk.js
+var DESTRUCTIVE_VERBS = Object.freeze(["delete", "delete-many"]);
+var DESTRUCTIVE_COMMANDS = Object.freeze(["chat.flush", "file.move", "scene.fog.reset"]);
+var APPROVE_EXTRA_COMMANDS = Object.freeze(["system.reload", "user.create"]);
+var DENIED_BY_DEFAULT_COMMANDS = Object.freeze([
+  "macro.execute",
+  "setting.set",
+  "setting.set-many",
+  "user.role.set",
+  "user.permissions.set",
+  "scene.region.behavior.executable.create",
+  "scene.region.behavior.executable.update",
+  "scene.region.behavior.executable.clone"
+]);
+
+// ../protocol/src/policy.js
+var POLICY_BEHAVIORS = Object.freeze(["allow", "approve", "deny"]);
+var POLICY_EXEMPT_COMMANDS = Object.freeze([
+  "system.ping",
+  "system.info",
+  "approval.await",
+  "approval.cancel",
+  "policy.snapshot"
+]);
+
 // ../protocol/src/validation.js
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4906,6 +5639,18 @@ function validateObjectSchema(schema, value, path, errors) {
   if (typeof schema.minProperties === "number" && ownKeys.length < schema.minProperties) {
     errors.push(`${path} must contain at least ${schema.minProperties} properties`);
   }
+  if (isPlainObject(schema.propertyNames) && typeof schema.propertyNames.pattern === "string") {
+    const namePattern = compilePattern(schema.propertyNames.pattern);
+    for (const key of ownKeys) {
+      if (namePattern === null) {
+        errors.push(
+          `${path}.${key} cannot be validated: ${schema.propertyNames.pattern} is not a valid unicode-mode pattern`
+        );
+      } else if (!namePattern.test(key)) {
+        errors.push(`${path}.${key} is not an allowed property name`);
+      }
+    }
+  }
   for (const [key, propertyValue] of Object.entries(value)) {
     const propertySchema = properties[key];
     if (propertySchema) {
@@ -5106,13 +5851,68 @@ function createProtocolError({ code, message, details = {} }) {
     details
   };
 }
-function getProtocolVersionError(actualVersion) {
+var LEGACY_PROTOCOL_RELEASES = Object.freeze({ "3.0": "1.0.0" });
+var RELEASE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+function normalizeComparableProtocolVersion(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  if (Object.hasOwn(LEGACY_PROTOCOL_RELEASES, value)) {
+    return LEGACY_PROTOCOL_RELEASES[value];
+  }
+  return RELEASE_VERSION_PATTERN.test(value) ? value : null;
+}
+function compareReleaseVersions(left, right) {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+  for (let index = 0; index < leftParts.length; index += 1) {
+    if (leftParts[index] !== rightParts[index]) {
+      return leftParts[index] < rightParts[index] ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function isNamedComponent(component) {
+  return component === PROTOCOL_COMPONENTS.MODULE || component === PROTOCOL_COMPONENTS.CLI_DAEMON;
+}
+function resolveStaleness(actualVersion, peer, reporter) {
+  const actual = normalizeComparableProtocolVersion(actualVersion);
+  const expected = normalizeComparableProtocolVersion(PROTOCOL_VERSION);
+  if (actual === null || expected === null) {
+    return { staleComponent: PROTOCOL_COMPONENTS.UNKNOWN, comparable: false };
+  }
+  const order = compareReleaseVersions(actual, expected);
+  const older = order < 0 ? peer : order > 0 ? reporter : PROTOCOL_COMPONENTS.UNKNOWN;
+  return {
+    staleComponent: isNamedComponent(older) ? older : PROTOCOL_COMPONENTS.UNKNOWN,
+    comparable: true
+  };
+}
+function describeStaleness({ staleComponent, comparable }) {
+  if (staleComponent === PROTOCOL_COMPONENTS.MODULE) {
+    return "the Foundry module is the older component, so update the module in Foundry until both halves come from the same release, then reload the GM client";
+  }
+  if (staleComponent === PROTOCOL_COMPONENTS.CLI_DAEMON) {
+    return "the CLI and daemon are the older component, so update the fvtt-world-cli package until both halves come from the same release, then restart the daemon";
+  }
+  const cause = comparable ? "the older component is not identified here" : "these versions cannot be ordered, so the older component is unknown";
+  return `${cause}: bring the fvtt-world-cli package and the Foundry module to the same release, restart the daemon, and reload the GM client`;
+}
+function getProtocolVersionError(actualVersion, options = {}) {
+  const {
+    peer = PROTOCOL_COMPONENTS.UNKNOWN,
+    reporter = PROTOCOL_COMPONENTS.UNKNOWN,
+    handshake = PROTOCOL_HANDSHAKES.UNKNOWN
+  } = options;
+  const staleness = resolveStaleness(actualVersion, peer, reporter);
   return createProtocolError({
     code: ERROR_CODES.UNSUPPORTED_PROTOCOL_VERSION,
-    message: `Unsupported protocol version: ${actualVersion}`,
+    message: `Unsupported protocol version: ${actualVersion} (expected ${PROTOCOL_VERSION}); ${describeStaleness(staleness)}. Components from different releases are refused by design.`,
     details: {
       expectedVersion: PROTOCOL_VERSION,
-      actualVersion
+      actualVersion,
+      staleComponent: staleness.staleComponent,
+      handshake
     }
   });
 }
@@ -5345,6 +6145,26 @@ function resolveBridgeServeConfig({
 }
 
 // src/transport-util.ts
+var APPROVAL_ID_PATTERN = /^[A-Za-z0-9_-]{22}$/;
+var MAX_EPOCH_MS = 864e13;
+function readApprovalId(value) {
+  return typeof value === "string" && APPROVAL_ID_PATTERN.test(value) ? value : null;
+}
+function readPendingApprovalDetails(envelope) {
+  if (envelope.ok || envelope.error?.code !== ERROR_CODES.APPROVAL_PENDING) {
+    return null;
+  }
+  const details = envelope.error.details ?? {};
+  const approvalId = readApprovalId(details.approvalId);
+  const expiresAt = details.expiresAt;
+  if (approvalId === null || typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) {
+    return null;
+  }
+  if (Math.abs(expiresAt) > MAX_EPOCH_MS) {
+    return null;
+  }
+  return { approvalId, expiresAt };
+}
 var DaemonTransportError = class extends Error {
   code;
   details;
@@ -5370,6 +6190,21 @@ function normalizeIncomingData(data) {
 function isCommandResponseEnvelope(message, acceptedTypes) {
   return typeof message === "object" && message !== null && acceptedTypes.includes(message.type) && typeof message.id === "string" && typeof message.ok === "boolean";
 }
+function protocolVersionSkewError(message) {
+  if (typeof message !== "object" || message === null) {
+    return null;
+  }
+  const frame = message;
+  if (frame.type !== MESSAGE_TYPES.CLIENT_HELLO_ACK || typeof frame.protocolVersion !== "string" || frame.protocolVersion === PROTOCOL_VERSION) {
+    return null;
+  }
+  const error = getProtocolVersionError(frame.protocolVersion, {
+    peer: PROTOCOL_COMPONENTS.CLI_DAEMON,
+    reporter: PROTOCOL_COMPONENTS.CLI_DAEMON,
+    handshake: PROTOCOL_HANDSHAKES.CLI_DAEMON
+  });
+  return new DaemonTransportError(error.code, error.message, error.details);
+}
 function decodeTransportFrame(data) {
   const parsed = parseBridgeMessage(normalizeIncomingData(data));
   if (!parsed.ok) {
@@ -5382,6 +6217,10 @@ function decodeTransportFrame(data) {
       )
     };
   }
+  const skew = protocolVersionSkewError(parsed.value);
+  if (skew) {
+    return { ok: false, error: skew };
+  }
   const validation = validateTransportMessage(parsed.value);
   if (!validation.ok) {
     return {
@@ -5402,10 +6241,195 @@ function sendJson(socket, payload) {
   socket.send(JSON.stringify(payload));
 }
 
+// src/bridge/approval-link.ts
+var DEFAULT_MAX_ENTRIES = 1e3;
+function settlementForAwait(envelope) {
+  if (!envelope.ok) {
+    const approvalId2 = readApprovalId(envelope.error?.details?.approvalId);
+    return envelope.error?.code === ERROR_CODES.APPROVAL_UNKNOWN && approvalId2 ? { kind: "indeterminate", approvalId: approvalId2 } : { kind: "none" };
+  }
+  const report = envelope.result ?? {};
+  const approvalId = readApprovalId(report.approvalId);
+  if (!approvalId || report.status !== "resolved") {
+    return { kind: "none" };
+  }
+  if (report.outcome !== "approved") {
+    return { kind: "clear", approvalId };
+  }
+  const response = report.response;
+  return isCommandResponseEnvelope(response, [MESSAGE_TYPES.COMMAND_RESPONSE]) ? { kind: "promote", approvalId, response } : { kind: "indeterminate", approvalId };
+}
+function settlementForCancel(envelope) {
+  if (!envelope.ok) {
+    return { kind: "none" };
+  }
+  const report = envelope.result ?? {};
+  const approvalId = readApprovalId(report.approvalId);
+  if (!approvalId) {
+    return { kind: "none" };
+  }
+  if (report.status === "cancelled") {
+    return { kind: "clear", approvalId };
+  }
+  return report.status === "resolved" ? { kind: "none" } : { kind: "indeterminate", approvalId };
+}
+function readApprovalSettlement(command, envelope) {
+  if (command === APPROVAL_AWAIT_COMMAND) {
+    return settlementForAwait(envelope);
+  }
+  if (command === APPROVAL_CANCEL_COMMAND) {
+    return settlementForCancel(envelope);
+  }
+  return { kind: "none" };
+}
+var ApprovalIdempotencyLinks = class {
+  maxEntries;
+  retentionMs;
+  now;
+  links;
+  keysByApprovalId;
+  constructor({
+    maxEntries = DEFAULT_MAX_ENTRIES,
+    retentionMs = APPROVAL_RESULT_RETENTION_MS,
+    now = () => Date.now()
+  } = {}) {
+    this.maxEntries = maxEntries;
+    this.retentionMs = retentionMs;
+    this.now = now;
+    this.links = /* @__PURE__ */ new Map();
+    this.keysByApprovalId = /* @__PURE__ */ new Map();
+  }
+  record({
+    key,
+    fingerprint,
+    approvalId,
+    expiresAt,
+    pendingResponse
+  }) {
+    this.prune();
+    this.forget(key);
+    this.links.set(key, {
+      key,
+      kind: "link",
+      fingerprint,
+      approvalId,
+      pendingResponse,
+      expiresAt: expiresAt + this.retentionMs
+    });
+    this.keysByApprovalId.set(approvalId, key);
+  }
+  // The reservation is held for the pending request's whole lifetime, so a tombstone converts an
+  // existing entry instead of competing for capacity with newer keys. recordLostInFlight stays
+  // unconditional so that the boundary tick, where both expire at once, still retains the key.
+  reserve({
+    key,
+    fingerprint,
+    retainMs
+  }) {
+    this.prune();
+    const existing = this.links.get(key);
+    if (existing) {
+      return existing.kind === "reserved" && existing.fingerprint === fingerprint ? { ok: true } : { ok: false, reason: "conflict" };
+    }
+    if (this.links.size >= this.maxEntries) {
+      return { ok: false, reason: "full" };
+    }
+    this.links.set(key, {
+      key,
+      kind: "reserved",
+      fingerprint,
+      approvalId: null,
+      pendingResponse: null,
+      expiresAt: this.now() + retainMs
+    });
+    return { ok: true };
+  }
+  release(key) {
+    if (this.links.get(key)?.kind === "reserved") {
+      this.forget(key);
+    }
+  }
+  recordLostInFlight({ key, fingerprint, retainMs }) {
+    this.prune();
+    const existing = this.links.get(key);
+    if (existing && existing.kind !== "reserved") {
+      return false;
+    }
+    this.links.set(key, {
+      key,
+      kind: "lost",
+      fingerprint,
+      approvalId: null,
+      pendingResponse: null,
+      expiresAt: this.now() + retainMs
+    });
+    return true;
+  }
+  lookup(key, fingerprint) {
+    this.prune();
+    const link = this.links.get(key);
+    if (!link) {
+      return { status: "miss" };
+    }
+    if (link.kind === "reserved") {
+      return { status: "miss" };
+    }
+    if (link.fingerprint !== fingerprint) {
+      return { status: "conflict", approvalId: link.approvalId };
+    }
+    if (link.approvalId === null) {
+      return { status: "lost-in-flight" };
+    }
+    return link.pendingResponse ? { status: "pending", approvalId: link.approvalId, response: link.pendingResponse } : { status: "indeterminate", approvalId: link.approvalId };
+  }
+  settle(settlement) {
+    if (settlement.kind === "none") {
+      return null;
+    }
+    const key = this.keysByApprovalId.get(settlement.approvalId);
+    const link = key === void 0 ? void 0 : this.links.get(key);
+    if (!link) {
+      return null;
+    }
+    if (settlement.kind === "indeterminate") {
+      link.pendingResponse = null;
+      return null;
+    }
+    const promoted = settlement.kind === "promote" ? { key: link.key, fingerprint: link.fingerprint } : null;
+    this.forget(link.key);
+    return promoted;
+  }
+  prune() {
+    const now = this.now();
+    for (const [key, link] of this.links) {
+      if (link.expiresAt <= now) {
+        this.forget(key);
+      }
+    }
+  }
+  get size() {
+    return this.links.size;
+  }
+  clear() {
+    this.links.clear();
+    this.keysByApprovalId.clear();
+  }
+  forget(key) {
+    const link = this.links.get(key);
+    if (!link) {
+      return;
+    }
+    this.links.delete(key);
+    if (link.approvalId !== null && this.keysByApprovalId.get(link.approvalId) === key) {
+      this.keysByApprovalId.delete(link.approvalId);
+    }
+  }
+};
+
 // src/bridge/idempotency-cache.ts
 import { createHash } from "node:crypto";
 var DEFAULT_TTL_MS = 10 * 60 * 1e3;
-var DEFAULT_MAX_ENTRIES = 1e3;
+var DEFAULT_MAX_ENTRIES2 = 1e3;
 function stableStringify(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value) ?? "null";
@@ -5428,7 +6452,7 @@ var IdempotencyCache = class {
   entries;
   constructor({
     ttlMs = DEFAULT_TTL_MS,
-    maxEntries = DEFAULT_MAX_ENTRIES,
+    maxEntries = DEFAULT_MAX_ENTRIES2,
     now = () => Date.now()
   } = {}) {
     this.ttlMs = ttlMs;
@@ -5492,6 +6516,15 @@ var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
 function inFlightIndexKey(worldId, idempotencyKey) {
   return JSON.stringify([worldId, idempotencyKey]);
 }
+var UNDISCOVERABLE_COMMANDS = new Set(
+  COMMAND_NAMES.filter((name) => !DISCOVERABLE_COMMAND_NAMES.includes(name))
+);
+function withoutUndiscoverableCommands(session) {
+  return {
+    ...session,
+    commands: session.commands.filter((name) => !UNDISCOVERABLE_COMMANDS.has(name))
+  };
+}
 var BridgeSessionStore = class {
   activeBridgeSocket;
   activeSession;
@@ -5505,20 +6538,18 @@ var BridgeSessionStore = class {
   }
   registerBridge(socket, session) {
     const staleSocket = this.activeBridgeSocket && this.activeBridgeSocket !== socket ? this.activeBridgeSocket : null;
-    if (staleSocket) {
-      this.failPendingForBridge(staleSocket, "taken-over");
-    }
+    const lostKeyedRequests = staleSocket ? this.failPendingForBridge(staleSocket, "taken-over") : [];
     this.activeBridgeSocket = socket;
     this.activeSession = session;
     if (staleSocket) {
       staleSocket.close(BRIDGE_TAKEOVER_CLOSE_CODE, BRIDGE_TAKEOVER_CLOSE_REASON);
     }
-    return { ok: true };
+    return { ok: true, lostKeyedRequests };
   }
   getBridgeStatus() {
     return {
       connected: Boolean(this.activeBridgeSocket && this.activeSession),
-      session: this.activeSession
+      session: this.activeSession ? withoutUndiscoverableCommands(this.activeSession) : null
     };
   }
   hasActiveBridge() {
@@ -5597,7 +6628,7 @@ var BridgeSessionStore = class {
         id: request.id,
         error: createProtocolError({
           code: ERROR_CODES.BRIDGE_TIMEOUT,
-          message: `Timed out waiting for Foundry bridge response to ${request.command} after ${requestTimeoutMs}ms; the request was forwarded so it MAY have committed \u2014 verify world state before retrying (a same idempotencyKey retry can fetch the cached late success once it lands)`,
+          message: `Timed out waiting for Foundry bridge response to ${request.command} after ${requestTimeoutMs}ms; the request was forwarded so it MAY have committed \u2014 verify world state before retrying (a same idempotencyKey retry can fetch the cached late success once it lands, unless the bridge session carrying it ends first, after which that key is refused)`,
           details: {
             reason: "timeout",
             command: request.command,
@@ -5639,6 +6670,7 @@ var BridgeSessionStore = class {
       }
     }, requestTimeoutMs);
     this.pendingRequests.set(request.id, {
+      command: request.command,
       waiters: [{ clientSocket, requestId: request.id }],
       timeout,
       bridgeSocket: this.activeBridgeSocket,
@@ -5654,7 +6686,7 @@ var BridgeSessionStore = class {
   resolveResponse(response) {
     const pendingRequest = this.pendingRequests.get(response.id);
     if (!pendingRequest) {
-      return { matched: false, idempotency: null, worldId: null };
+      return { matched: false, command: null, idempotency: null, worldId: null };
     }
     clearTimeout(pendingRequest.timeout);
     this.forgetPending(response.id);
@@ -5663,17 +6695,18 @@ var BridgeSessionStore = class {
     }
     return {
       matched: true,
+      command: pendingRequest.command,
       idempotency: pendingRequest.idempotency ?? null,
       worldId: pendingRequest.worldId ?? null
     };
   }
   removeSocket(socket) {
     if (this.activeBridgeSocket === socket) {
-      this.failPendingForBridge(socket, "disconnected");
+      const lostKeyedRequests = this.failPendingForBridge(socket, "disconnected");
       this.activeBridgeSocket = null;
       this.activeSession = null;
       this.inFlightByKey.clear();
-      return;
+      return lostKeyedRequests;
     }
     for (const [requestId, pendingRequest] of this.pendingRequests.entries()) {
       const remainingWaiters = pendingRequest.waiters.filter((waiter) => waiter.clientSocket !== socket);
@@ -5687,19 +6720,31 @@ var BridgeSessionStore = class {
       clearTimeout(pendingRequest.timeout);
       this.forgetPending(requestId);
     }
+    return [];
   }
   failPendingForBridge(socket, reason) {
+    const lostKeyedRequests = [];
     for (const [requestId, pendingRequest] of this.pendingRequests.entries()) {
       if (pendingRequest.bridgeSocket !== socket) {
         continue;
       }
       clearTimeout(pendingRequest.timeout);
       this.forgetPending(requestId);
+      const keyed = pendingRequest.idempotency !== void 0 && pendingRequest.worldId !== void 0;
+      if (pendingRequest.idempotency && pendingRequest.worldId !== void 0) {
+        lostKeyedRequests.push({
+          worldId: pendingRequest.worldId,
+          key: pendingRequest.idempotency.key,
+          fingerprint: pendingRequest.idempotency.fingerprint
+        });
+      }
+      const cause = reason === "taken-over" ? "Authenticated Foundry bridge session was replaced by a newer socket from the same pairing while the request was pending" : "Authenticated Foundry bridge session disconnected while the request was pending";
+      const retryAdvice = keyed ? "verify world state before retrying, then send the command again under a FRESH idempotencyKey (reusing the same key is refused for the dedupe window on this daemon)" : "verify world state before retrying";
       const disconnectError = createErrorResponse({
         id: requestId,
         error: createProtocolError({
           code: ERROR_CODES.BRIDGE_DISCONNECTED,
-          message: reason === "taken-over" ? "Authenticated Foundry bridge session was replaced by a newer socket from the same pairing while the request was pending; it was already forwarded so it MAY have committed \u2014 verify world state before retrying" : "Authenticated Foundry bridge session disconnected while the request was pending; it was already forwarded so it MAY have committed \u2014 verify world state before retrying (this is NOT idempotency-key safe: the disconnect path caches nothing, so a keyed retry re-forwards)",
+          message: `${cause}; it was already forwarded so it MAY have committed \u2014 ${retryAdvice}`,
           details: { reason }
         })
       });
@@ -5707,6 +6752,7 @@ var BridgeSessionStore = class {
         sendJson(waiter.clientSocket, { ...disconnectError, id: waiter.requestId });
       }
     }
+    return lostKeyedRequests;
   }
   clearAllPending() {
     for (const pendingRequest of this.pendingRequests.values()) {
@@ -5721,6 +6767,22 @@ var BridgeSessionStore = class {
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
 var DEFAULT_IDEMPOTENCY_TTL_MS = 10 * 60 * 1e3;
 var ACCEPTED_BRIDGE_RESPONSE_TYPES = Object.freeze([MESSAGE_TYPES.COMMAND_RESPONSE]);
+var CLI_HELLO_ORIGIN = {
+  peer: PROTOCOL_COMPONENTS.CLI_DAEMON,
+  handshake: PROTOCOL_HANDSHAKES.CLI_DAEMON
+};
+var MODULE_HELLO_ORIGIN = {
+  peer: PROTOCOL_COMPONENTS.MODULE,
+  handshake: PROTOCOL_HANDSHAKES.MODULE_DAEMON
+};
+var CLI_COMMAND_ORIGIN = {
+  peer: PROTOCOL_COMPONENTS.CLI_DAEMON,
+  handshake: PROTOCOL_HANDSHAKES.COMMAND_REQUEST
+};
+var CLI_CONTROL_ORIGIN = {
+  peer: PROTOCOL_COMPONENTS.CLI_DAEMON,
+  handshake: PROTOCOL_HANDSHAKES.DAEMON_REQUEST
+};
 function createBridgeHelloAck({
   ok,
   error,
@@ -5770,6 +6832,16 @@ function equalSecret(left, right) {
 function daemonEnvelope(type, id, operation, ok, result, error) {
   return { protocolVersion: PROTOCOL_VERSION, type, id, operation, ok, ...ok ? { result } : { error } };
 }
+function idempotencyConflict(requestId, command, idempotencyKey, remedy, clause = "was already used for") {
+  return createErrorResponse({
+    id: requestId,
+    error: createProtocolError({
+      code: ERROR_CODES.IDEMPOTENCY_KEY_CONFLICT,
+      message: `Idempotency key "${idempotencyKey}" ${clause} a different ${command} request (same key, different command or params); use a fresh idempotencyKey for this new request, or ${remedy}`,
+      details: { command, idempotencyKey }
+    })
+  });
+}
 function publicPendingPairing(entry) {
   return {
     code: entry.code,
@@ -5801,6 +6873,7 @@ var BridgeDaemon = class {
   wsMaxPayloadBytes;
   sessionStore;
   idempotencyCache;
+  approvalLinks;
   cachedWorldId;
   server;
   connectionStates;
@@ -5814,6 +6887,7 @@ var BridgeDaemon = class {
     heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS,
     idempotencyTtlMs = DEFAULT_IDEMPOTENCY_TTL_MS,
     idempotencyCacheOptions = {},
+    approvalLinkOptions = {},
     uploadLimitBytes = DEFAULT_UPLOAD_SIZE_LIMIT_BYTES,
     logger = pino({ level: process.env.FVTT_WORLD_CLI_LOG_LEVEL ?? "warn" })
   } = {}) {
@@ -5844,6 +6918,7 @@ var BridgeDaemon = class {
       ...idempotencyCacheOptions,
       ttlMs: idempotencyCacheOptions.ttlMs ?? idempotencyTtlMs
     });
+    this.approvalLinks = new ApprovalIdempotencyLinks(approvalLinkOptions);
     this.cachedWorldId = null;
     this.server = null;
     this.connectionStates = /* @__PURE__ */ new WeakMap();
@@ -5902,7 +6977,7 @@ var BridgeDaemon = class {
           this.leaseExpiresAt = Date.now() + BRIDGE_LEASE_MS;
           this.activePairingId = null;
         }
-        this.sessionStore.removeSocket(socket);
+        this.tombstoneLostKeyedRequests(this.sessionStore.removeSocket(socket));
       });
     });
     await new Promise((resolve7, reject) => {
@@ -5951,6 +7026,7 @@ var BridgeDaemon = class {
       this.heartbeatTimer = null;
     }
     this.idempotencyCache.clear();
+    this.approvalLinks.clear();
     this.cachedWorldId = null;
     this.dropAwaitWaiters(() => true);
     this.sessionStore.clearAllPending();
@@ -5992,7 +7068,10 @@ var BridgeDaemon = class {
     const message = parsed.value;
     const validationResult = validateTransportMessage(message);
     if (!validationResult.ok) {
-      const protocolError = message.protocolVersion !== void 0 && message.protocolVersion !== PROTOCOL_VERSION ? getProtocolVersionError(String(message.protocolVersion)) : createProtocolError({
+      const rejection = (origin) => message.protocolVersion !== void 0 && message.protocolVersion !== PROTOCOL_VERSION ? getProtocolVersionError(String(message.protocolVersion), {
+        ...origin,
+        reporter: PROTOCOL_COMPONENTS.CLI_DAEMON
+      }) : createProtocolError({
         code: ERROR_CODES.INVALID_MESSAGE,
         message: "Invalid transport message",
         details: { errors: validationResult.errors }
@@ -6002,23 +7081,23 @@ var BridgeDaemon = class {
           protocolVersion: PROTOCOL_VERSION,
           type: MESSAGE_TYPES.CLIENT_HELLO_ACK,
           ok: false,
-          error: protocolError
+          error: rejection(CLI_HELLO_ORIGIN)
         });
       } else if (state.role === "unknown" && message.type === MESSAGE_TYPES.PAIRING_REQUEST) {
         sendJson(socket, {
           protocolVersion: PROTOCOL_VERSION,
           type: MESSAGE_TYPES.PAIRING_RESULT,
           ok: false,
-          error: protocolError
+          error: rejection(MODULE_HELLO_ORIGIN)
         });
       } else if (state.role === "unknown" && message.type === MESSAGE_TYPES.BRIDGE_HELLO) {
-        sendJson(socket, createBridgeHelloAck({ ok: false, error: protocolError }));
+        sendJson(socket, createBridgeHelloAck({ ok: false, error: rejection(MODULE_HELLO_ORIGIN) }));
       } else if (state.role === "cli" && message.type === MESSAGE_TYPES.COMMAND_REQUEST) {
         sendJson(
           socket,
           createErrorResponse({
             id: typeof message.id === "string" ? message.id : `invalid_${randomUUID2()}`,
-            error: protocolError
+            error: rejection(CLI_COMMAND_ORIGIN)
           })
         );
         return;
@@ -6027,7 +7106,14 @@ var BridgeDaemon = class {
         const operation = typeof message.operation === "string" && message.operation ? message.operation : "unknown";
         sendJson(
           socket,
-          daemonEnvelope(MESSAGE_TYPES.DAEMON_RESPONSE, id, operation, false, void 0, protocolError)
+          daemonEnvelope(
+            MESSAGE_TYPES.DAEMON_RESPONSE,
+            id,
+            operation,
+            false,
+            void 0,
+            rejection(CLI_CONTROL_ORIGIN)
+          )
         );
         return;
       }
@@ -6143,7 +7229,7 @@ var BridgeDaemon = class {
       state.role = "unknown";
       state.pairingId = null;
     }
-    this.sessionStore.removeSocket(socket);
+    this.tombstoneLostKeyedRequests(this.sessionStore.removeSocket(socket));
     socket.close(closeCode, closeReason);
   }
   stampPairingLastSeen(pairingId) {
@@ -6407,9 +7493,11 @@ var BridgeDaemon = class {
       const idempotencyScope = `${pairing.pairingId}:${pairing.origin}:${newSession.world.id}`;
       if (this.cachedWorldId !== null && this.cachedWorldId !== idempotencyScope) {
         this.idempotencyCache.clear();
+        this.approvalLinks.clear();
       }
       this.cachedWorldId = idempotencyScope;
-      this.sessionStore.registerBridge(socket, newSession);
+      const { lostKeyedRequests } = this.sessionStore.registerBridge(socket, newSession);
+      this.tombstoneLostKeyedRequests(lostKeyedRequests);
       sendJson(
         socket,
         createBridgeHelloAck({
@@ -6423,9 +7511,51 @@ var BridgeDaemon = class {
       this.logger.warn({ message }, "Ignoring non-response message from bridge socket");
       return;
     }
-    const { idempotency, worldId: matchedWorldId } = this.sessionStore.resolveResponse(message);
-    if (idempotency && message.ok === true && (socket === this.sessionStore.activeBridgeSocket || matchedWorldId !== null && matchedWorldId === this.cachedWorldId)) {
+    const { command, idempotency, worldId: matchedWorldId } = this.sessionStore.resolveResponse(message);
+    const inScope = socket === this.sessionStore.activeBridgeSocket || matchedWorldId !== null && matchedWorldId === this.cachedWorldId;
+    if (!inScope) {
+      return;
+    }
+    if (idempotency && message.ok === true) {
       this.idempotencyCache.storeIfAbsent(idempotency.key, idempotency.fingerprint, message);
+      this.approvalLinks.release(idempotency.key);
+      return;
+    }
+    if (idempotency) {
+      const pendingApproval = readPendingApprovalDetails(message);
+      if (pendingApproval) {
+        this.approvalLinks.record({
+          key: idempotency.key,
+          fingerprint: idempotency.fingerprint,
+          pendingResponse: message,
+          ...pendingApproval
+        });
+        return;
+      }
+      this.approvalLinks.release(idempotency.key);
+      return;
+    }
+    const settlement = readApprovalSettlement(command, message);
+    const promoted = this.approvalLinks.settle(settlement);
+    if (promoted && settlement.kind === "promote") {
+      this.idempotencyCache.storeIfAbsent(promoted.key, promoted.fingerprint, settlement.response);
+    }
+  }
+  tombstoneLostKeyedRequests(lostKeyedRequests) {
+    for (const lost of lostKeyedRequests) {
+      if (lost.worldId !== this.cachedWorldId) {
+        this.approvalLinks.release(lost.key);
+        continue;
+      }
+      if (this.idempotencyCache.lookup(lost.key, lost.fingerprint).status !== "miss") {
+        this.approvalLinks.release(lost.key);
+        continue;
+      }
+      this.approvalLinks.recordLostInFlight({
+        key: lost.key,
+        fingerprint: lost.fingerprint,
+        retainMs: this.idempotencyCache.ttlMs
+      });
     }
   }
   handleCliMessage(socket, state, message) {
@@ -6459,14 +7589,40 @@ var BridgeDaemon = class {
         return;
       }
       if (lookup.status === "conflict") {
+        sendJson(
+          socket,
+          idempotencyConflict(
+            requestId,
+            String(message.command),
+            idempotencyKey,
+            "resend the byte-identical original request to fetch its cached result"
+          )
+        );
+        return;
+      }
+      const link = this.approvalLinks.lookup(idempotencyKey, fingerprint);
+      if (link.status === "conflict") {
+        sendJson(
+          socket,
+          idempotencyConflict(
+            requestId,
+            String(message.command),
+            idempotencyKey,
+            link.approvalId === null ? "verify world state and use a fresh idempotencyKey" : "resend the byte-identical original request to keep waiting on the approval it already created"
+          )
+        );
+        return;
+      }
+      if (link.status === "lost-in-flight") {
         sendJson(
           socket,
           createErrorResponse({
             id: requestId,
             error: createProtocolError({
-              code: ERROR_CODES.IDEMPOTENCY_KEY_CONFLICT,
-              message: `Idempotency key "${idempotencyKey}" was already used for a different ${message.command} request (same key, different command or params); use a fresh idempotencyKey for this new request, or resend the byte-identical original request to fetch its cached result`,
+              code: ERROR_CODES.BRIDGE_DISCONNECTED,
+              message: `Idempotency key "${idempotencyKey}" belongs to a ${message.command} request that was already forwarded to Foundry when the bridge session ended, so this daemon never learned whether it ran: it may have changed the world, and it may already be waiting on a GM approval that is still actionable. Read the documents that request would have written before anything else, report what you found, and send the command again only under a fresh idempotencyKey.`,
               details: {
+                reason: "lost-in-flight",
                 command: message.command,
                 idempotencyKey
               }
@@ -6475,6 +7631,28 @@ var BridgeDaemon = class {
         );
         return;
       }
+      if (link.status === "pending") {
+        sendJson(socket, { ...link.response, id: requestId });
+        return;
+      }
+      if (link.status === "indeterminate") {
+        sendJson(
+          socket,
+          createErrorResponse({
+            id: requestId,
+            error: createProtocolError({
+              code: ERROR_CODES.APPROVAL_UNKNOWN,
+              message: `Idempotency key "${idempotencyKey}" belongs to a ${message.command} request whose GM approval ended without a readable outcome, so this daemon cannot say whether it ran: it may never have started, or it may have completed and changed the world. Read the documents that request would have written before anything else, report what you found, and send the command again only under a fresh idempotencyKey.`,
+              details: {
+                command: message.command,
+                idempotencyKey,
+                approvalId: link.approvalId
+              }
+            })
+          })
+        );
+        return;
+      }
       if (this.cachedWorldId !== null) {
         const inFlight = this.sessionStore.findInFlight(this.cachedWorldId, idempotencyKey);
         if (inFlight) {
@@ -6489,22 +7667,52 @@ var BridgeDaemon = class {
           } else {
             sendJson(
               socket,
-              createErrorResponse({
-                id: requestId,
-                error: createProtocolError({
-                  code: ERROR_CODES.IDEMPOTENCY_KEY_CONFLICT,
-                  message: `Idempotency key "${idempotencyKey}" is already in flight for a different ${message.command} request (same key, different command or params); use a fresh idempotencyKey for this new request, or resend the byte-identical original request to coalesce onto the in-flight one`,
-                  details: {
-                    command: message.command,
-                    idempotencyKey
-                  }
-                })
-              })
+              idempotencyConflict(
+                requestId,
+                String(message.command),
+                idempotencyKey,
+                "resend the byte-identical original request to coalesce onto the in-flight one",
+                "is already in flight for"
+              )
             );
             return;
           }
         }
       }
+      if (this.cachedWorldId !== null) {
+        const reserved = this.approvalLinks.reserve({
+          key: idempotencyKey,
+          fingerprint,
+          retainMs: this.requestTimeoutMs + this.idempotencyCache.ttlMs
+        });
+        if (!reserved.ok && reserved.reason === "conflict") {
+          sendJson(
+            socket,
+            idempotencyConflict(
+              requestId,
+              String(message.command),
+              idempotencyKey,
+              "resend the byte-identical original request to reuse the reservation it already holds",
+              "is still reserved for"
+            )
+          );
+          return;
+        }
+        if (!reserved.ok) {
+          sendJson(
+            socket,
+            createErrorResponse({
+              id: requestId,
+              error: createProtocolError({
+                code: ERROR_CODES.IDEMPOTENCY_STORE_FULL,
+                message: `This daemon is holding its maximum of ${this.approvalLinks.maxEntries} indeterminate idempotency keys, so it cannot guarantee that a ${message.command} request forwarded under key "${idempotencyKey}" would stay deduplicated if the bridge session ended mid-flight; nothing was forwarded and the world is unchanged. Retry once earlier keys settle or their dedupe window expires.`,
+                details: { command: message.command, idempotencyKey }
+              })
+            })
+          );
+          return;
+        }
+      }
       idempotency = { key: idempotencyKey, fingerprint };
     }
     const result = this.sessionStore.forwardRequest({
@@ -6516,6 +7724,9 @@ var BridgeDaemon = class {
       ...idempotency && this.cachedWorldId !== null ? { worldId: this.cachedWorldId } : {}
     });
     if (!result.ok) {
+      if (idempotency) {
+        this.approvalLinks.release(idempotency.key);
+      }
       sendJson(
         socket,
         createErrorResponse({
@@ -6585,7 +7796,8 @@ async function sendCommand({
   command,
   params = {},
   timeoutMs = DEFAULT_CLIENT_TIMEOUT_MS,
-  maxPayloadBytes = DEFAULT_WS_MAX_PAYLOAD_BYTES
+  maxPayloadBytes = DEFAULT_WS_MAX_PAYLOAD_BYTES,
+  signal
 }) {
   warnIfClientTimeoutUnsafe(timeoutMs);
   const built = buildValidatedRequest(command, params);
@@ -6613,11 +7825,32 @@ async function sendCommand({
     }, timeoutMs);
     function cleanup() {
       clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
       socket.removeAllListeners();
       if (socket.readyState === socket.OPEN || socket.readyState === socket.CONNECTING) {
         socket.close();
       }
     }
+    function onAbort() {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      socket.terminate();
+      reject(
+        new DaemonTransportError(
+          ERROR_CODES.DAEMON_UNAVAILABLE,
+          `Stopped waiting for the daemon response to ${command}`,
+          { reason: "closed", command }
+        )
+      );
+    }
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort);
     socket.once("open", () => {
       opened = true;
       socket.send(JSON.stringify(createClientHello({ credential: deviceCredential ?? "" })));
@@ -6739,6 +7972,13 @@ async function connectDaemonClient({
     });
     socket.once("message", (data) => {
       const parsed = parseBridgeMessage(normalizeIncomingData(data));
+      const skew = parsed.ok ? protocolVersionSkewError(parsed.value) : null;
+      if (skew) {
+        clearTimeout(timer);
+        reject(skew);
+        socket.close();
+        return;
+      }
       const validation = parsed.ok ? validateTransportMessage(parsed.value) : { ok: false };
       const message = parsed.ok && validation.ok ? parsed.value : null;
       if (!message || message.type !== MESSAGE_TYPES.CLIENT_HELLO_ACK || !message.ok) {
@@ -6820,7 +8060,7 @@ async function connectDaemonClient({
     );
   });
   return {
-    async send({ command, params = {}, timeoutMs: timeoutMs2 = DEFAULT_CLIENT_TIMEOUT_MS }) {
+    async send({ command, params = {}, timeoutMs: timeoutMs2 = DEFAULT_CLIENT_TIMEOUT_MS, signal }) {
       warnIfClientTimeoutUnsafe(timeoutMs2);
       if (closedError) {
         throw closedError;
@@ -6831,8 +8071,21 @@ async function connectDaemonClient({
       }
       const request = built.request;
       return await new Promise((resolve7, reject) => {
+        function onAbort() {
+          clearTimeout(timer);
+          pending.delete(request.id);
+          signal?.removeEventListener("abort", onAbort);
+          reject(
+            new DaemonTransportError(
+              ERROR_CODES.DAEMON_UNAVAILABLE,
+              `Stopped waiting for the daemon response to ${command}`,
+              { reason: "closed", command }
+            )
+          );
+        }
         const timer = setTimeout(() => {
           pending.delete(request.id);
+          signal?.removeEventListener("abort", onAbort);
           reject(
             new DaemonTransportError(
               ERROR_CODES.DAEMON_UNAVAILABLE,
@@ -6841,7 +8094,22 @@ async function connectDaemonClient({
             )
           );
         }, timeoutMs2);
-        pending.set(request.id, { resolve: resolve7, reject, timer });
+        if (signal?.aborted) {
+          onAbort();
+          return;
+        }
+        signal?.addEventListener("abort", onAbort);
+        pending.set(request.id, {
+          resolve: (envelope) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve7(envelope);
+          },
+          reject: (error) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(error);
+          },
+          timer
+        });
         socket.send(JSON.stringify(request));
       });
     },
@@ -7041,6 +8309,38 @@ function toTransportErrorEnvelope(error) {
     error instanceof Error ? error.message : String(error)
   );
 }
+var TRANSPORT_DETAIL_REASONS = /* @__PURE__ */ new Set([
+  "timeout",
+  "disconnected",
+  "invalid_json",
+  "unexpected_type",
+  "closed",
+  "connect_error"
+]);
+function normalizeTransportMessage(message) {
+  if (/ECONNREFUSED/.test(message)) {
+    return "Could not connect to the daemon (connection refused). Is `fvtt-world-cli bridge serve` running?";
+  }
+  if (/ETIMEDOUT/.test(message)) {
+    return "Could not connect to the daemon (connection timed out).";
+  }
+  if (/ENOTFOUND|EAI_AGAIN/.test(message)) {
+    return "Could not resolve the daemon host.";
+  }
+  if (/ECONNRESET/.test(message)) {
+    return "The daemon connection was reset.";
+  }
+  return message;
+}
+function renderProtocolError(error) {
+  const code = error?.code ?? "UNKNOWN_ERROR";
+  const message = normalizeTransportMessage(String(error?.message ?? "Unknown error"));
+  const reason = error?.details?.reason;
+  const showDetails = Boolean(error?.details) && !(typeof reason === "string" && TRANSPORT_DETAIL_REASONS.has(reason));
+  const details = showDetails ? `
+${JSON.stringify(error?.details, null, 2)}` : "";
+  return `${code}: ${message}${details}`;
+}
 function planLocalError(error) {
   if (error instanceof ExecConnectError) {
     return {
@@ -7125,7 +8425,7 @@ function planCliErrorOutput(error, jsonMode, options = {}) {
 }
 
 // src/program.ts
-import { Command as Command10, Option as Option13 } from "commander";
+import { Command as Command10, Option as Option16 } from "commander";
 
 // src/commands/actor.ts
 import { Option as Option3 } from "commander";
@@ -7267,6 +8567,49 @@ function parseOwnershipUsers(value) {
   }
   return object;
 }
+function parseJsonValue(value, label) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new InvalidArgumentError(
+      error instanceof Error ? `${label} must be a JSON literal \u2014 true, 42, "text", [..] or {..}, so a quoted string stays distinct from a boolean or a number: ${error.message}` : `${label} must be a JSON literal \u2014 true, 42, "text", [..] or {..}`
+    );
+  }
+}
+var USER_ROLES = [1, 2, 3, 4];
+function parseUserRole(value) {
+  const trimmed = value.trim();
+  const parsed = INTEGER_PATTERN.test(trimmed) ? Number(trimmed) : NaN;
+  if (!Number.isInteger(parsed) || !USER_ROLES.includes(parsed)) {
+    throw new InvalidArgumentError(
+      `Expected a user role (1=player, 2=trusted player, 3=assistant GM, 4=gamemaster), received ${value}`
+    );
+  }
+  return parsed;
+}
+function parseUserPermissions(value) {
+  const object = parseJsonObject(value, "--permissions-json");
+  const names = Object.keys(object);
+  if (names.length === 0) {
+    throw new InvalidArgumentError("--permissions-json must name at least one permission");
+  }
+  for (const name of names) {
+    const entry = object[name];
+    if (typeof entry !== "boolean" && entry !== null) {
+      throw new InvalidArgumentError(
+        `--permissions-json values must be true (grant), false (revoke) or null (drop the override so the role default applies); ${name} = ${JSON.stringify(entry)}`
+      );
+    }
+  }
+  return object;
+}
+function parseSettingItems(value, label) {
+  const items = parseJsonObjectArray(value, label);
+  if (items.length === 0) {
+    throw new InvalidArgumentError(`${label} must contain at least one setting item`);
+  }
+  return items;
+}
 function parseIdList(value) {
   const ids = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
   if (ids.length === 0) {
@@ -8438,6 +9781,120 @@ function createSceneRegionBehaviorCloneParams(options) {
     })
   };
 }
+var EXECUTABLE_BEHAVIOR_TYPE = "executeMacro";
+function nullableField(key, value, cleared) {
+  return cleared ? { [key]: null } : value !== void 0 ? { [key]: value } : {};
+}
+function buildUserFields(options) {
+  return {
+    ...stringField("color", options.color),
+    ...stringField("pronouns", options.pronouns),
+    ...nullableField("avatar", options.avatar, options.clearAvatar),
+    ...nullableField("character", options.character, options.clearCharacter),
+    ...optionalJsonObject(options.dataJson, "--data-json") ?? {},
+    ...optionalJsonObject(options.patchJson, "--patch-json") ?? {}
+  };
+}
+function createSettingSetParams(options) {
+  return { namespace: options.namespace, key: options.key, value: options.valueJson };
+}
+async function resolveSettingItems(options, dependencies) {
+  if (options.itemsStdin) {
+    if (dependencies.stdin.isTTY) {
+      throw new CommanderError2(
+        1,
+        "fvtt-world-cli.settingItemsNoStdin",
+        "--items-stdin requires the setting items piped on stdin as a JSON array; refusing to read from an interactive terminal."
+      );
+    }
+    return parseSettingItems(await text(dependencies.stdin), "--items-stdin");
+  }
+  if (options.itemsJson === void 0) {
+    throw new CommanderError2(
+      1,
+      "fvtt-world-cli.settingItemsRequired",
+      "setting set-many needs the items: pass --items-json with a JSON array of {namespace,key,value} objects, or --items-stdin to read that array from stdin."
+    );
+  }
+  return options.itemsJson;
+}
+function buildExecutableBehaviorFields(options) {
+  const system = {
+    ...stringField("uuid", options.macroUuid),
+    ...options.events ? { events: options.events } : {},
+    ...booleanField("everyone", options.everyone),
+    ...options.systemJson ? parseJsonObject(options.systemJson, "--system-json") : {}
+  };
+  return {
+    ...stringField("name", options.name),
+    ...booleanField("disabled", options.disabled),
+    ...Object.keys(system).length > 0 ? { system } : {}
+  };
+}
+function createExecutableBehaviorCreateParams(options) {
+  return {
+    sceneId: options.sceneId,
+    regionId: options.regionId,
+    data: {
+      type: EXECUTABLE_BEHAVIOR_TYPE,
+      ...buildExecutableBehaviorFields(options),
+      ...optionalJsonObject(options.dataJson, "--data-json") ?? {}
+    }
+  };
+}
+function createExecutableBehaviorUpdateParams(options) {
+  return {
+    sceneId: options.sceneId,
+    regionId: options.regionId,
+    behaviorId: options.behaviorId,
+    patch: assertNonEmptyPatch({
+      ...buildExecutableBehaviorFields(options),
+      ...optionalJsonObject(options.patchJson, "--patch-json") ?? {}
+    })
+  };
+}
+function createExecutableBehaviorCloneParams(options) {
+  return {
+    sceneId: options.sceneId,
+    regionId: options.regionId,
+    behaviorId: options.behaviorId,
+    ...optionalPatch({
+      ...buildExecutableBehaviorFields(options),
+      ...optionalJsonObject(options.patchJson, "--patch-json") ?? {}
+    })
+  };
+}
+function createMacroExecuteParams(options) {
+  const scope = {
+    ...stringField("actorId", options.actorId),
+    ...stringField("sceneId", options.sceneId),
+    ...stringField("tokenId", options.tokenId),
+    ...jsonObjectField("args", options.argsJson, "--args-json")
+  };
+  return {
+    macroId: options.macroId,
+    ...Object.keys(scope).length > 0 ? { scope } : {},
+    ...numberField("timeoutMs", options.macroTimeoutMs)
+  };
+}
+function createUserCreateParams(options) {
+  return {
+    data: {
+      name: options.name,
+      ...numberField("role", options.role),
+      ...buildUserFields(options)
+    }
+  };
+}
+function createUserUpdateParams(options) {
+  return {
+    userId: options.userId,
+    patch: assertNonEmptyPatch({
+      ...stringField("name", options.name),
+      ...buildUserFields(options)
+    })
+  };
+}
 function createFileUploadParams(options, uploadLimitBytes) {
   return {
     path: options.path,
@@ -8450,6 +9907,248 @@ function createFileUploadParams(options, uploadLimitBytes) {
 import { createInterface } from "node:readline";
 import { CommanderError as CommanderError3 } from "commander";
 
+// src/park-polling.ts
+var AWAIT_FLOOR_MARGIN_MS = 5e3;
+var AWAIT_EMPTY_POLL_DELAY_MS = 250;
+
+// src/approval-wait.ts
+var APPROVAL_AWAIT_CLIENT_TIMEOUT_FLOOR_MS = APPROVAL_AWAIT_PARK_CAP_MS + AWAIT_FLOOR_MARGIN_MS;
+var APPROVAL_EMPTY_POLL_DELAY_MS = AWAIT_EMPTY_POLL_DELAY_MS;
+var APPROVAL_RETRY_BASE_DELAY_MS = 500;
+var APPROVAL_RETRY_MAX_DELAY_MS = 5e3;
+var APPROVAL_RETRY_MARGIN_MS = 3e4;
+var TRANSIENT_TRANSPORT_CODES = /* @__PURE__ */ new Set([
+  ERROR_CODES.DAEMON_UNAVAILABLE,
+  ERROR_CODES.BRIDGE_NOT_READY,
+  ERROR_CODES.BRIDGE_DISCONNECTED,
+  ERROR_CODES.BRIDGE_TIMEOUT
+]);
+function readPendingApproval(response) {
+  const details = readPendingApprovalDetails(response);
+  if (!details) {
+    return null;
+  }
+  const command = response.error?.details?.command;
+  return { ...details, command: typeof command === "string" ? command : "unknown" };
+}
+function describeTransportFailure(envelope) {
+  return `${envelope.error?.code ?? ERROR_CODES.INTERNAL_ERROR}: ${envelope.error?.message ?? "unknown error"}`;
+}
+async function awaitApprovalOutcome({
+  pendingResponse,
+  send,
+  stderr,
+  timeoutMs,
+  reconnect,
+  onCancelRequested,
+  signalScope = process,
+  now = () => Date.now(),
+  sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms))
+}) {
+  const pending = readPendingApproval(pendingResponse);
+  if (!pending) {
+    return pendingResponse;
+  }
+  const { approvalId, expiresAt, command } = pending;
+  const responseId = pendingResponse.id;
+  const pollTimeoutMs = Math.max(timeoutMs ?? 0, APPROVAL_AWAIT_CLIENT_TIMEOUT_FLOOR_MS);
+  const cancelTimeoutMs = timeoutMs ?? DEFAULT_CLIENT_TIMEOUT_MS;
+  function terminal(code, message, details) {
+    return { ...localErrorEnvelope(code, message, details), id: responseId };
+  }
+  function indeterminate(message, details) {
+    return terminal(
+      ERROR_CODES.APPROVAL_UNKNOWN,
+      `${message} The outcome is indeterminate: command ${command} may never have started, may be running now, or may have completed and changed the world. Read the documents it would have written before anything else, report what you found, and if you decide to send it again, send it under a fresh idempotency key.`,
+      { approvalId, command, ...details }
+    );
+  }
+  function outcomeEnvelope(outcome) {
+    if (outcome === "denied") {
+      return terminal(
+        ERROR_CODES.APPROVAL_DENIED,
+        `The GM of this bridge denied command ${command}. It never ran and no world state changed: a denial is decided before execution starts, so nothing was partially applied. The verdict is terminal for this invocation and is not a transient failure to retry in a loop. Report the denial to the user; sending the same command again only makes sense once that human decision changes.`,
+        { approvalId, command }
+      );
+    }
+    if (outcome === "timeout") {
+      return terminal(
+        ERROR_CODES.APPROVAL_TIMEOUT,
+        `The approval for command ${command} expired before a GM decided it. It never ran and no world state changed: the expiry is decided before execution starts. The verdict is terminal for this invocation. Before sending the command again, check that a GM is present at the Foundry client holding this bridge and able to answer its approval window, and tell the user the decision is waiting on them.`,
+        { approvalId, command }
+      );
+    }
+    if (outcome === "cancelled") {
+      return terminal(
+        ERROR_CODES.APPROVAL_CANCELLED,
+        `The approval for command ${command} was cancelled before the GM decided it. The cancellation won the decision, so the command never ran and no world state changed. The verdict is terminal for this invocation, and sending the command again is safe: it asks the GM for a new approval.`,
+        { approvalId, command }
+      );
+    }
+    return indeterminate(
+      `The GM client reported an approval outcome this CLI does not understand (${outcome}).`,
+      { outcome }
+    );
+  }
+  function readAwaitResult(result) {
+    const report = result ?? {};
+    if (report.status === "pending") {
+      return { kind: "pending" };
+    }
+    if (report.status !== "resolved") {
+      return {
+        kind: "settled",
+        envelope: indeterminate("The GM client reported an approval status this CLI does not understand.", {
+          status: typeof report.status === "string" ? report.status : null
+        })
+      };
+    }
+    if (report.outcome !== "approved") {
+      return { kind: "settled", envelope: outcomeEnvelope(String(report.outcome)) };
+    }
+    if (!isCommandResponseEnvelope(report.response, [MESSAGE_TYPES.COMMAND_RESPONSE])) {
+      return {
+        kind: "settled",
+        envelope: indeterminate("The GM allowed the command, but its response was not delivered.", {
+          outcome: "approved"
+        })
+      };
+    }
+    return { kind: "settled", envelope: report.response };
+  }
+  async function pollOnce(signal, waitMs = APPROVAL_AWAIT_PARK_CAP_MS) {
+    let response;
+    try {
+      response = await send({
+        command: APPROVAL_AWAIT_COMMAND,
+        params: { approvalId, waitMs },
+        timeoutMs: pollTimeoutMs,
+        ...signal ? { signal } : {}
+      });
+    } catch (error) {
+      return { kind: "transport", envelope: toTransportErrorEnvelope(error), connectionLost: true };
+    }
+    if (response.ok) {
+      return readAwaitResult(response.result);
+    }
+    if (TRANSIENT_TRANSPORT_CODES.has(response.error?.code ?? "")) {
+      return { kind: "transport", envelope: response, connectionLost: false };
+    }
+    return { kind: "settled", envelope: response };
+  }
+  async function requestCancellation() {
+    let response;
+    try {
+      response = await send({
+        command: APPROVAL_CANCEL_COMMAND,
+        params: { approvalId },
+        timeoutMs: cancelTimeoutMs
+      });
+    } catch (error) {
+      return {
+        kind: "settled",
+        envelope: indeterminate(
+          `Cancellation of command ${command} could not be confirmed: the GM client could not be reached (${describeTransportFailure(toTransportErrorEnvelope(error))}).`,
+          { cancellation: "unconfirmed" }
+        )
+      };
+    }
+    if (!response.ok) {
+      return {
+        kind: "settled",
+        envelope: indeterminate(
+          `Cancellation of command ${command} could not be confirmed: the cancellation request itself failed (${describeTransportFailure(response)}).`,
+          { cancellation: "unconfirmed" }
+        )
+      };
+    }
+    const status = response.result?.status;
+    if (status === "cancelled") {
+      return { kind: "settled", envelope: outcomeEnvelope("cancelled") };
+    }
+    if (status === "resolved") {
+      const settled = await pollOnce(void 0, 0);
+      if (settled.kind === "settled") {
+        return settled;
+      }
+    }
+    return {
+      kind: "settled",
+      envelope: indeterminate(
+        `Cancellation of command ${command} could not be confirmed: the GM client answered "${String(status)}", so the decision had already left the cancellable state.`,
+        { cancellation: "unconfirmed", status: typeof status === "string" ? status : null }
+      )
+    };
+  }
+  stderr.write(
+    `Waiting for GM approval in Foundry (command ${command}, expires ${new Date(expiresAt).toISOString()}). Press Ctrl+C to request cancellation.
+`
+  );
+  let settleCancellation = () => {
+  };
+  const cancellation = new Promise((resolve7) => {
+    settleCancellation = resolve7;
+  });
+  let cancelling = false;
+  function onSignal() {
+    signalScope.off("SIGINT", onSignal);
+    if (cancelling) {
+      return;
+    }
+    cancelling = true;
+    onCancelRequested?.();
+    void requestCancellation().then(settleCancellation);
+  }
+  async function raceCancellation(work) {
+    return await Promise.race([work.then(() => null), cancellation]);
+  }
+  signalScope.on("SIGINT", onSignal);
+  let pollAbort = null;
+  try {
+    let retryDelayMs = APPROVAL_RETRY_BASE_DELAY_MS;
+    for (; ; ) {
+      pollAbort = new AbortController();
+      const step = await Promise.race([pollOnce(pollAbort.signal), cancellation]);
+      if (step.kind === "settled") {
+        return step.envelope;
+      }
+      if (step.kind === "pending") {
+        retryDelayMs = APPROVAL_RETRY_BASE_DELAY_MS;
+        const cancelled = await raceCancellation(sleep(APPROVAL_EMPTY_POLL_DELAY_MS));
+        if (cancelled) {
+          return cancelled.envelope;
+        }
+        continue;
+      }
+      if (now() > expiresAt + APPROVAL_RETRY_MARGIN_MS) {
+        return step.envelope;
+      }
+      const cancelledWhileWaiting = await raceCancellation(sleep(retryDelayMs));
+      if (cancelledWhileWaiting) {
+        return cancelledWhileWaiting.envelope;
+      }
+      retryDelayMs = Math.min(retryDelayMs * 2, APPROVAL_RETRY_MAX_DELAY_MS);
+      if (reconnect && step.connectionLost) {
+        let failure = null;
+        const cancelledWhileReconnecting = await raceCancellation(
+          reconnect().catch((error) => {
+            failure = error;
+          })
+        );
+        if (cancelledWhileReconnecting) {
+          return cancelledWhileReconnecting.envelope;
+        }
+        if (failure !== null && now() > expiresAt + APPROVAL_RETRY_MARGIN_MS) {
+          return toTransportErrorEnvelope(failure);
+        }
+      }
+    }
+  } finally {
+    pollAbort?.abort();
+    signalScope.off("SIGINT", onSignal);
+  }
+}
+
 // src/config-io.ts
 function getStoredConfig(dependencies) {
   const existing = dependencies.configStore.readConfig();
@@ -8514,6 +10213,15 @@ var OWNERSHIP_LEVEL_LABELS = {
   "2": "observer",
   "3": "owner"
 };
+function renderBroadcastLines(result) {
+  const requested = result?.userIds;
+  return [
+    `requested: ${Array.isArray(requested) ? requested.join(", ") || "(none)" : "every user"}`,
+    `reached: ${(result?.activeUserIds ?? []).join(", ") || "(nobody online)"}`,
+    `skipped (offline): ${(result?.inactiveUserIds ?? result?.skippedUserIds ?? []).join(", ") || "(none)"}`,
+    `dispatched: ${Boolean(result?.dispatched)} \u2014 a broadcast writes nothing, so there is no state to confirm afterwards`
+  ];
+}
 function renderCompendiumSourceLines(document) {
   return document?.compendiumSource ? [`compendiumSource: ${document.compendiumSource}`] : [];
 }
@@ -8955,6 +10663,15 @@ function renderCardsRecallLines(recall, { deleteScoped = true } = {}) {
 }
 
 // src/render/chat.ts
+function renderChatFlushResult(result) {
+  return result?.dryRun ? [
+    `[dry-run] would delete the entire chat log: ${result?.count ?? 0} message(s)`,
+    `remaining after the flush: 0`
+  ].join("\n") : [
+    `Flushed the chat log: deleted ${result?.deleted ?? 0} of ${result?.count ?? 0} message(s)`,
+    `remaining: ${result?.remaining ?? 0}`
+  ].join("\n");
+}
 function renderChatDetails(message) {
   const lines = [
     `id: ${message?.id}`,
@@ -9212,6 +10929,13 @@ function renderFolderDetails(folder) {
 }
 
 // src/render/journals.ts
+function renderJournalShowResult(result) {
+  return [
+    `Showed journal entry ${result?.journalId} to other users`,
+    `force: ${Boolean(result?.force)}`,
+    ...renderBroadcastLines(result)
+  ].join("\n");
+}
 function renderJournalDetails(journal) {
   const pages = Array.isArray(journal?.pages) ? journal.pages : [];
   const categories = Array.isArray(journal?.categories) ? journal.categories : [];
@@ -9297,6 +11021,36 @@ function renderJournalCategoryDetails(journalId, category) {
 }
 
 // src/render/macros.ts
+var CHAT_CAPTURE_NOTES = {
+  captured: "captured (every message the macro created while the bridge waited)",
+  partial: "partial (fewer messages than this macro was expected to create)",
+  "not-created": "not-created (the macro created no chat message while the bridge waited)",
+  unknown: "unknown (the macro may have created messages this call could not observe)"
+};
+function renderMacroExecuteResult(result) {
+  if (result?.dryRun) {
+    return [
+      `[dry-run] would execute macro ${result?.macroId}`,
+      `type: ${result?.type ?? "(unknown)"}`,
+      `canExecute: ${Boolean(result?.canExecute)}`,
+      `command length: ${result?.commandLength ?? 0} characters`
+    ].join("\n");
+  }
+  const lines = [
+    `Executed macro ${result?.macroId}`,
+    `type: ${result?.type ?? "(unknown)"}`,
+    `returned: ${JSON.stringify(result?.returned ?? null, null, 2)}`
+  ];
+  if (result?.returnedOmitted) {
+    lines.push(`returned omitted: ${result.returnedOmitted.code} \u2014 ${result.returnedOmitted.message}`);
+  }
+  lines.push(
+    `chat messages: ${(result?.chatMessageIds ?? []).join(", ") || "(none)"}`,
+    `chat capture: ${CHAT_CAPTURE_NOTES[result?.chatCapture] ?? CHAT_CAPTURE_NOTES.unknown}`,
+    "note: a macro that catches its own errors still returns null, so verify the effect with reads"
+  );
+  return lines.join("\n");
+}
 function renderMacroDetails(macro) {
   const lines = [
     `id: ${macro?.id}`,
@@ -9354,6 +11108,21 @@ function renderPlaylistSoundDetails(sound) {
 }
 
 // src/render/scenes.ts
+function renderSceneActivateResult(result) {
+  return [
+    `${result?.dryRun ? "[dry-run] would activate scene" : "Activated scene"} ${result?.sceneId}`,
+    `was active: ${Boolean(result?.wasActive)}`,
+    `changed: ${Boolean(result?.changed)}`
+  ].join("\n");
+}
+function renderScenePullUsersResult(result) {
+  return [
+    `Pulled users to scene ${result?.sceneId}`,
+    `pulled: ${(result?.userIds ?? []).join(", ") || "(nobody online)"}`,
+    `skipped (offline): ${(result?.skippedUserIds ?? []).join(", ") || "(none)"}`,
+    `dispatched: ${Boolean(result?.dispatched)} \u2014 a pull writes nothing, so there is no state to confirm afterwards`
+  ].join("\n");
+}
 function renderSceneDetails(scene) {
   const lines = [
     `id: ${scene?.id}`,
@@ -9575,6 +11344,45 @@ function renderSettingSummaryLine(setting) {
     ...setting?.valueRedacted ? ["value=REDACTED"] : []
   ].join("	");
 }
+function renderSettingValue(value) {
+  return JSON.stringify(value ?? null, null, 2);
+}
+function renderSettingWriteLines(row, dryRun) {
+  const verb = dryRun ? "would write" : row?.changed ? "wrote" : "left unchanged";
+  return [
+    `${verb}: ${row?.id ?? `${row?.namespace}.${row?.key}`} (scope: ${row?.scope ?? "?"})`,
+    `previous: ${renderSettingValue(row?.previous)}`,
+    `${dryRun ? "requested" : "value"}: ${renderSettingValue(row?.value)}`,
+    `changed: ${Boolean(row?.changed)} / validated: ${Boolean(row?.validated)}`,
+    ...row?.requiresReload ? ["requiresReload: true \u2014 Foundry acts on this only after `system reload` or a manual browser reload"] : ["requiresReload: false"]
+  ];
+}
+function renderSettingWriteResult(result) {
+  return renderSettingWriteLines(result, Boolean(result?.dryRun)).join("\n");
+}
+function renderSettingWriteOutcomes(result) {
+  const outcomes = result?.outcomes ?? [];
+  const dryRun = Boolean(result?.dryRun);
+  const lines = [
+    `${dryRun ? "Would write" : "Wrote"} settings (${outcomes.length}) \u2014 complete: ${Boolean(result?.complete)}`,
+    ...outcomes.flatMap(
+      (outcome) => outcome?.status === "updated" || outcome?.status === "unchanged" ? [
+        `[${outcome.index}] ${outcome.status}`,
+        ...renderSettingWriteLines(outcome, dryRun).map((line) => `  ${line}`)
+      ] : [`[${outcome?.index}] ${outcome?.status}	${outcome?.id ?? ""}`]
+    )
+  ];
+  if (result?.failure) {
+    lines.push(`failure: ${result.failure.code} \u2014 ${result.failure.message}`);
+  }
+  return lines.join("\n");
+}
+function renderSettingBatchRows(setting) {
+  return [
+    renderSettingSummaryLine(setting),
+    ...setting?.error ? [`  error: ${setting.error.code} \u2014 ${setting.error.message}`] : [`  value: ${renderSettingValue(setting?.value)}`]
+  ];
+}
 function renderSettingDetails(setting) {
   return [
     `setting: ${setting?.id ?? `${setting?.namespace}.${setting?.key}`}`,
@@ -9684,6 +11492,38 @@ function renderUserSummaryLine(user) {
     `char=${user?.character ?? "-"}`
   ].join("	");
 }
+function renderUserRoleSetResult(result) {
+  const dryRun = Boolean(result?.dryRun);
+  return [
+    `${dryRun ? "Would set" : "Set"} role for user ${result?.userId}`,
+    `role: ${result?.previousRole ?? "?"} \u2192 ${result?.role} (${result?.roleName ?? "?"})`,
+    `changed: ${Boolean(result?.changed)}`
+  ].join("\n");
+}
+function renderUserPermissionsSetResult(result) {
+  const dryRun = Boolean(result?.dryRun);
+  const overrides = Object.entries(result?.overrides ?? {});
+  const lines = [
+    `${dryRun ? "Would set" : "Set"} permission overrides for user ${result?.userId}`,
+    `role: ${result?.role ?? "?"}`
+  ];
+  if (dryRun) {
+    lines.push(
+      "requested:",
+      ...Object.entries(result?.requested ?? {}).map(
+        ([name, value]) => `  ${name}: ${value === null ? "drop the override (role default applies)" : String(value)}`
+      )
+    );
+  }
+  lines.push(
+    overrides.length ? "overrides:" : "overrides: (none \u2014 every permission follows the role default)",
+    ...overrides.map(([name, value]) => `  ${name}: ${String(value)}`)
+  );
+  lines.push(
+    result?.permissions ? `effective permissions: ${Object.entries(result.permissions).filter(([, granted]) => granted).map(([name]) => name).join(", ") || "(none)"}` : "effective permissions: not reported by this Foundry version"
+  );
+  return lines.join("\n");
+}
 function renderUserDetails(user) {
   return [
     `user: ${user?.name} [${user?.id}]`,
@@ -9779,6 +11619,28 @@ var RENDERERS = registerRenderers([
       `commands: ${(result.commands ?? []).join(", ")}`
     ].join("\n")
   ),
+  detailRenderer(
+    "game.pause",
+    (result) => [
+      `${result.dryRun ? "[dry-run] would set" : "Set"} the game to ${result.paused ? "PAUSED" : "RUNNING"} for every client`,
+      `previous: ${result.previousPaused ? "paused" : "running"}`,
+      `changed: ${Boolean(result.changed)}`
+    ].join("\n")
+  ),
+  detailRenderer(
+    "image.show",
+    (result) => [
+      `Showed image ${result.src}${result.title ? ` as "${result.title}"` : ""} to other users`,
+      ...renderBroadcastLines(result)
+    ].join("\n")
+  ),
+  detailRenderer(
+    "system.reload",
+    () => [
+      "Reload requested: the GM browser page reloads as soon as this response is flushed.",
+      "The bridge connection drops and reconnects on its own; retry the next command after a moment."
+    ].join("\n")
+  ),
   customRenderer("world.search", (result, offset) => {
     const results = result.results ?? [];
     const lines = results.length ? [
@@ -9852,6 +11714,8 @@ var RENDERERS = registerRenderers([
     heading: "Scenes",
     rows: (scene) => [`${scene.id}	${scene.name}`, ...batchOwnershipLines(scene)]
   }),
+  detailRenderer("scene.activate", (result) => renderSceneActivateResult(result)),
+  detailRenderer("scene.pull-users", (result) => renderScenePullUsersResult(result)),
   deleteRenderer("scene.delete", "scene", {
     suffix: (result) => result.wasActive ? " (was active)" : ""
   }),
@@ -9901,7 +11765,10 @@ var RENDERERS = registerRenderers([
     heading: "Users",
     row: (user) => renderUserSummaryLine(user)
   }),
-  detailRenderer("user.get", (result) => renderUserDetails(result.user)),
+  detailRenderer(["user.get", "user.create", "user.update"], (result) => renderUserDetails(result.user)),
+  deleteRenderer("user.delete", "user"),
+  detailRenderer("user.role.set", (result) => renderUserRoleSetResult(result)),
+  detailRenderer("user.permissions.set", (result) => renderUserPermissionsSetResult(result)),
   listRenderer("setting.list", {
     key: "settings",
     empty: "No registered settings found.",
@@ -9909,6 +11776,13 @@ var RENDERERS = registerRenderers([
     row: (setting) => renderSettingSummaryLine(setting)
   }),
   detailRenderer("setting.get", (result) => renderSettingDetails(result.setting)),
+  getManyRenderer("setting.get-many", {
+    key: "settings",
+    heading: "Settings",
+    rows: (setting) => renderSettingBatchRows(setting)
+  }),
+  detailRenderer("setting.set", (result) => renderSettingWriteResult(result)),
+  detailRenderer("setting.set-many", (result) => renderSettingWriteOutcomes(result)),
   detailRenderer("actor.ownership.set", (result) => renderOwnershipSetResult("actor", result.actor)),
   detailRenderer("item.ownership.set", (result) => renderOwnershipSetResult("item", result.item)),
   detailRenderer("scene.ownership.set", (result) => renderOwnershipSetResult("scene", result.scene)),
@@ -10188,6 +12062,7 @@ var RENDERERS = registerRenderers([
     }
   }),
   deleteRenderer("journal.delete", "journal"),
+  detailRenderer("journal.show", (result) => renderJournalShowResult(result)),
   listRenderer("journal.category.list", {
     key: "categories",
     empty: "No categories found.",
@@ -10233,6 +12108,7 @@ var RENDERERS = registerRenderers([
     rows: (m) => [`${m.id}	${m.name}	${m.type ?? ""}	${m.scope ?? ""}`, ...batchOwnershipLines(m)]
   }),
   deleteRenderer("macro.delete", "macro"),
+  detailRenderer("macro.execute", (result) => renderMacroExecuteResult(result)),
   listRenderer("playlist.list", {
     key: "playlists",
     empty: "No playlists found.",
@@ -10291,6 +12167,7 @@ var RENDERERS = registerRenderers([
   }),
   detailRenderer(["chat.get", "chat.create"], (result) => renderChatDetails(result.message)),
   deleteRenderer("chat.delete", "chat message"),
+  detailRenderer("chat.flush", (result) => renderChatFlushResult(result)),
   listRenderer("actor.list", {
     key: "actors",
     empty: "No actors found.",
@@ -10604,6 +12481,17 @@ var RENDERERS = registerRenderers([
     ],
     (result) => renderRegionBehaviorDetails(result.sceneId, result.regionId, result.behavior)
   ),
+  detailRenderer(
+    [
+      "scene.region.behavior.executable.create",
+      "scene.region.behavior.executable.update",
+      "scene.region.behavior.executable.clone"
+    ],
+    (result) => [
+      renderRegionBehaviorDetails(result.sceneId, result.regionId, result.behavior),
+      "note: this behavior RUNS A MACRO when the region fires; system.everyone true runs it in every connected client"
+    ].join("\n")
+  ),
   detailRenderer(
     "scene.region.behavior.delete",
     (result) => result.deleted ? `Deleted region behavior ${result.id} (scene: ${result.sceneId}, region: ${result.regionId})` : `Would delete region behavior ${result.id} (scene: ${result.sceneId}, region: ${result.regionId})`
@@ -10692,40 +12580,11 @@ function humanizeCommandResult(command, result, offset = 0) {
   const renderer = RENDERERS[command];
   return renderer ? renderer(result, offset) : JSON.stringify(result, null, 2);
 }
-
-// src/exec.ts
-var TRANSPORT_DETAIL_REASONS = /* @__PURE__ */ new Set([
-  "timeout",
-  "disconnected",
-  "invalid_json",
-  "unexpected_type",
-  "closed",
-  "connect_error"
-]);
-function normalizeTransportMessage(message) {
-  if (/ECONNREFUSED/.test(message)) {
-    return "Could not connect to the daemon (connection refused). Is `fvtt-world-cli bridge serve` running?";
-  }
-  if (/ETIMEDOUT/.test(message)) {
-    return "Could not connect to the daemon (connection timed out).";
-  }
-  if (/ENOTFOUND|EAI_AGAIN/.test(message)) {
-    return "Could not resolve the daemon host.";
-  }
-  if (/ECONNRESET/.test(message)) {
-    return "The daemon connection was reset.";
-  }
-  return message;
-}
-function renderProtocolError(error) {
-  const code = error?.code ?? "UNKNOWN_ERROR";
-  const message = normalizeTransportMessage(String(error?.message ?? "Unknown error"));
-  const reason = error?.details?.reason;
-  const showDetails = Boolean(error?.details) && !(typeof reason === "string" && TRANSPORT_DETAIL_REASONS.has(reason));
-  const details = showDetails ? `
-${JSON.stringify(error.details, null, 2)}` : "";
-  return `${code}: ${message}${details}`;
-}
+
+// src/exec.ts
+function isApprovalPending(response) {
+  return !response.ok && response.error?.code === ERROR_CODES.APPROVAL_PENDING;
+}
 async function executeRemoteCommand({
   commandName,
   params,
@@ -10752,6 +12611,22 @@ async function executeRemoteCommand({
   } catch (error) {
     response = toTransportErrorEnvelope(error);
   }
+  if (isApprovalPending(response)) {
+    response = await awaitApprovalOutcome({
+      pendingResponse: response,
+      send: ({ command: awaitCommand, params: awaitParams, timeoutMs: awaitTimeoutMs, signal }) => dependencies.sendCommand({
+        daemonUrl: clientConfig.daemonUrl,
+        deviceCredential: clientConfig.deviceCredential,
+        command: awaitCommand,
+        params: awaitParams,
+        ...clientMaxPayloadOption(dependencies),
+        timeoutMs: awaitTimeoutMs,
+        ...signal ? { signal } : {}
+      }),
+      stderr: dependencies.stderr,
+      ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+    });
+  }
   if (outputJson) {
     write(dependencies.stdout, `${JSON.stringify(response, null, 2)}
 `);
@@ -10774,7 +12649,8 @@ ${humanOutput}` : humanOutput;
     );
   }
 }
-async function processExecLine(client, rawLine, timeoutMs, dryRun) {
+async function processExecLine(session, rawLine, dryRun) {
+  const timeoutMs = session.timeoutMs;
   let parsedLine;
   try {
     parsedLine = JSON.parse(rawLine);
@@ -10818,16 +12694,30 @@ async function processExecLine(client, rawLine, timeoutMs, dryRun) {
     };
   }
   const requestParams = dryRun && isWriteCommand(obj.command) ? { ...params, dryRun: true } : params;
+  let envelope;
   try {
-    const envelope = await client.send({
+    envelope = await session.send({
       command: obj.command,
       params: requestParams,
       ...typeof timeoutMs === "number" ? { timeoutMs } : {}
     });
-    return { id: callerId, envelope };
   } catch (error) {
     return { id: callerId, envelope: toTransportErrorEnvelope(error) };
   }
+  if (!isApprovalPending(envelope)) {
+    return { id: callerId, envelope };
+  }
+  return {
+    id: callerId,
+    envelope: await awaitApprovalOutcome({
+      pendingResponse: envelope,
+      send: (request) => session.send(request),
+      reconnect: session.reconnect,
+      onCancelRequested: session.onCancelRequested,
+      stderr: session.stderr,
+      ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+    })
+  };
 }
 async function runExecBatch({
   command,
@@ -10846,17 +12736,33 @@ async function runExecBatch({
   const timeoutMs = typeof globalOptions.timeoutMs === "number" ? globalOptions.timeoutMs : void 0;
   const dryRun = Boolean(globalOptions.dryRun);
   const stopOnError = Boolean(command.opts().stopOnError);
+  const connectOptions = {
+    daemonUrl: clientConfig.daemonUrl,
+    deviceCredential: clientConfig.deviceCredential,
+    ...clientMaxPayloadOption(dependencies),
+    ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+  };
   let client;
   try {
-    client = await connectDaemonClient({
-      daemonUrl: clientConfig.daemonUrl,
-      deviceCredential: clientConfig.deviceCredential,
-      ...clientMaxPayloadOption(dependencies),
-      ...typeof timeoutMs === "number" ? { timeoutMs } : {}
-    });
+    client = await connectDaemonClient(connectOptions);
   } catch (error) {
     throw new ExecConnectError(toTransportErrorEnvelope(error));
   }
+  let cancelRequested = false;
+  const session = {
+    send: (request) => client.send(request),
+    reconnect: async () => {
+      const replaced = client;
+      client = await connectDaemonClient(connectOptions);
+      void replaced.close().catch(() => {
+      });
+    },
+    stderr: dependencies.stderr,
+    ...typeof timeoutMs === "number" ? { timeoutMs } : {},
+    onCancelRequested: () => {
+      cancelRequested = true;
+    }
+  };
   const rl = createInterface({ input: stdin, crlfDelay: Infinity });
   let anyFailed = false;
   let index = 0;
@@ -10867,7 +12773,7 @@ async function runExecBatch({
       if (rawLine.trim() === "") {
         continue;
       }
-      const { id, envelope } = await processExecLine(client, rawLine, timeoutMs, dryRun);
+      const { id, envelope } = await processExecLine(session, rawLine, dryRun);
       const outputLine = { ...envelope, index: currentIndex, ...id !== void 0 ? { id } : {} };
       write(dependencies.stdout, `${JSON.stringify(outputLine)}
 `);
@@ -10877,6 +12783,10 @@ async function runExecBatch({
           break;
         }
       }
+      if (cancelRequested) {
+        anyFailed = true;
+        break;
+      }
     }
   } finally {
     rl.close();
@@ -11090,6 +13000,73 @@ var REGION_BEHAVIOR_FIELDS = [
 function addRegionBehaviorFieldOptions(command, verb) {
   return addFieldOptions(command, verb, REGION_BEHAVIOR_FIELDS);
 }
+var EXECUTABLE_BEHAVIOR_FIELDS = [
+  ...REGION_BEHAVIOR_FIELDS,
+  {
+    flag: "--macro-uuid <uuid>",
+    help: {
+      create: "UUID of the world macro to run (e.g. Macro.abc123); a compendium macro is refused",
+      update: "UUID of the world macro to run instead",
+      clone: "UUID of the world macro the clone runs"
+    }
+  },
+  {
+    flag: "--events <list>",
+    help: {
+      create: "Comma-separated region events that run the macro (e.g. tokenEnter,tokenExit)",
+      update: "Comma-separated region events that run the macro",
+      clone: "Comma-separated region events for the clone"
+    },
+    parser: (value) => parseCsvList(value, "--events")
+  },
+  {
+    flag: "--everyone <everyone>",
+    help: {
+      create: "Run the macro on EVERY connected client instead of one elected executor (true|false)",
+      update: "Run the macro on EVERY connected client instead of one elected executor (true|false)",
+      clone: "Run the macro on EVERY connected client instead of one elected executor (true|false)"
+    },
+    parser: parseBoolean
+  }
+];
+function addExecutableBehaviorFieldOptions(command, verb) {
+  return addFieldOptions(command, verb, EXECUTABLE_BEHAVIOR_FIELDS);
+}
+var USER_FIELDS = [
+  {
+    flag: "--color <color>",
+    help: { create: "User color (e.g. #ff0000)", update: "New user color", clone: "User color override" }
+  },
+  {
+    flag: "--pronouns <pronouns>",
+    help: { create: "Pronouns shown to other players", update: "New pronouns", clone: "Pronouns override" }
+  },
+  {
+    flag: "--avatar <avatar>",
+    help: { create: "Avatar image path", update: "New avatar image path", clone: "Avatar override" }
+  },
+  {
+    flag: "--clear-avatar",
+    help: "Explicitly set avatar to null",
+    conflicts: "avatar"
+  },
+  {
+    flag: "--character <actorId>",
+    help: {
+      create: "Actor id of the assigned character",
+      update: "Actor id of the assigned character",
+      clone: "Assigned character override"
+    }
+  },
+  {
+    flag: "--clear-character",
+    help: "Explicitly unassign the character (character = null)",
+    conflicts: "character"
+  }
+];
+function addUserFieldOptions(command, verb) {
+  return addFieldOptions(command, verb, USER_FIELDS);
+}
 function effectFields(transferNote) {
   return [
     {
@@ -12384,8 +14361,7 @@ function createDaemonControlRunner(dependencies) {
 }
 
 // src/commands/auth.ts
-var AWAIT_CLIENT_TIMEOUT_FLOOR_MS = AUTH_AWAIT_PARK_CAP_MS + 5e3;
-var AWAIT_EMPTY_POLL_DELAY_MS = 250;
+var AWAIT_CLIENT_TIMEOUT_FLOOR_MS = AUTH_AWAIT_PARK_CAP_MS + AWAIT_FLOOR_MARGIN_MS;
 var INTERACTIVE_WAIT_GUIDANCE = "Waiting for a pairing request needs an interactive terminal. Use auth pending and auth approve --yes instead.";
 var PRUNE_INTERACTIVE_GUIDANCE = "Non-interactive pairing prune requires --yes";
 var PRUNE_JSON_GUIDANCE = "Pairing prune with --json requires --yes, because the confirmation prompt is never mixed into JSON output";
@@ -12723,10 +14699,12 @@ function syncInstalledSkillCopies(dependencies) {
   try {
     const sourceDirectory = resolveSkillSourceDirectory();
     if (!sourceDirectory) return;
+    let installedAnywhere = false;
     for (const root of knownSkillRoots(dependencies)) {
       try {
         const destination = join2(root, SKILL_NAME);
         const state = inspectInstalledSkill(destination, sourceDirectory);
+        if (state !== "missing") installedAnywhere = true;
         if (state === "pristine") {
           rmSync(destination, { recursive: true, force: true });
           cpSync(sourceDirectory, destination, { recursive: true });
@@ -12746,6 +14724,13 @@ function syncInstalledSkillCopies(dependencies) {
         continue;
       }
     }
+    if (!installedAnywhere) {
+      write(
+        dependencies.stderr,
+        `The ${SKILL_NAME} agent skill is not installed. If AI agents use this CLI, consider running \`fvtt-world-cli skill install\` to give them its operating manual.
+`
+      );
+    }
   } catch {
     return;
   }
@@ -13155,6 +15140,16 @@ function registerChat({ program, dependencies }) {
       dependencies
     });
   });
+  chat.command("flush").description(
+    "Delete the ENTIRE chat log (irreversible). --dry-run reports the message count without deleting anything"
+  ).action(async function flushChat() {
+    await executeRemoteCommand({
+      commandName: "chat.flush",
+      params: {},
+      command: this,
+      dependencies
+    });
+  });
   chat.command("delete").requiredOption("--message-id <messageId>", "Chat message id").action(async function deleteChat(options) {
     await executeRemoteCommand({
       commandName: "chat.delete",
@@ -13606,20 +15601,93 @@ function listDocEntries(docsDirectory) {
 }
 
 // src/commands/discovery.ts
+var POLICY_AVAILABILITY_CODES = /* @__PURE__ */ new Set([
+  ERROR_CODES.DAEMON_UNAVAILABLE,
+  ERROR_CODES.BRIDGE_NOT_READY,
+  ERROR_CODES.BRIDGE_DISCONNECTED
+]);
+function commandNameSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : []
+  );
+}
+async function discoverPolicy(command, dependencies) {
+  const clientConfig = getCommandConfig(command, dependencies);
+  let response;
+  try {
+    response = await dependencies.sendCommand({
+      daemonUrl: clientConfig.daemonUrl,
+      deviceCredential: clientConfig.deviceCredential,
+      command: POLICY_SNAPSHOT_COMMAND,
+      params: {},
+      ...clientMaxPayloadOption(dependencies),
+      timeoutMs: POLICY_DISCOVERY_TIMEOUT_MS
+    });
+  } catch (error) {
+    response = toTransportErrorEnvelope(error);
+  }
+  if (response.ok) {
+    const snapshot = response.result ?? {};
+    return {
+      status: "applied",
+      approve: commandNameSet(snapshot.approve),
+      deny: commandNameSet(snapshot.deny)
+    };
+  }
+  const code = response.error?.code ?? ERROR_CODES.INTERNAL_ERROR;
+  if (!POLICY_AVAILABILITY_CODES.has(code)) {
+    return { status: "failed", envelope: response };
+  }
+  return { status: "fallback", reason: code, detail: response.error?.message ?? "no reason reported" };
+}
 function registerDiscovery({ program, dependencies }) {
-  program.command("commands").description("List all protocol commands and whether each mutates world state").action(function listCommands() {
-    const payload = COMMAND_NAMES.map((name) => ({
-      command: name,
-      mutation: COMMAND_DEFINITIONS[name].mutation
-    }));
-    if (Boolean(this.optsWithGlobals().json)) {
-      write(dependencies.stdout, `${JSON.stringify(localSuccessEnvelope(payload), null, 2)}
+  program.command("commands").description("List discoverable protocol commands and whether each mutates world state").action(async function listCommands() {
+    const json = Boolean(this.optsWithGlobals().json);
+    const discovery = await discoverPolicy(this, dependencies);
+    if (discovery.status === "failed") {
+      const error = discovery.envelope.error;
+      if (json) {
+        write(dependencies.stdout, `${JSON.stringify(discovery.envelope, null, 2)}
+`);
+      } else {
+        write(dependencies.stderr, `${renderProtocolError(error)}
 `);
+      }
+      throw new CommanderError7(
+        exitCodeForErrorCode(error?.code),
+        "fvtt-world-cli.remoteError",
+        error?.message ?? "Reading the command policy failed"
+      );
+    }
+    const applied = discovery.status === "applied";
+    const payload = DISCOVERABLE_COMMAND_NAMES.filter((name) => !applied || !discovery.deny.has(name)).map(
+      (name) => ({
+        command: name,
+        mutation: COMMAND_DEFINITIONS[name].mutation,
+        ...applied && discovery.approve.has(name) ? { approval: true } : {}
+      })
+    );
+    const policy = applied ? { applied: true, source: "bridge" } : { applied: false, source: "static", reason: discovery.reason };
+    if (json) {
+      write(
+        dependencies.stdout,
+        `${JSON.stringify({ ...localSuccessEnvelope(payload), policy }, null, 2)}
+`
+      );
       return;
     }
+    if (!applied) {
+      write(
+        dependencies.stderr,
+        `warning: the command policy of the GM client holding the bridge could not be read (${discovery.reason}: ${discovery.detail}); this is the full static command registry, so denied commands are still listed and commands needing approval are not marked.
+`
+      );
+    }
     write(
       dependencies.stdout,
-      `${payload.map((entry) => `${entry.command}	${entry.mutation ? "write" : "read"}`).join("\n")}
+      `${payload.map(
+        (entry) => `${entry.command}	${entry.mutation ? "write" : "read"}${entry.approval ? "	approval" : ""}`
+      ).join("\n")}
 `
     );
   });
@@ -13891,6 +15959,56 @@ function registerFolder({ program, dependencies }) {
   });
 }
 
+// src/commands/game.ts
+function registerGame({ program, dependencies }) {
+  const game = program.command("game").description("Foundry game-state commands");
+  game.addHelpText(
+    "after",
+    "\nResult key (--json): .result.paused, .result.previousPaused and .result.changed (pause)."
+  );
+  game.command("pause").description("Pause or unpause the game for every connected client").requiredOption("--paused <paused>", "Target pause state (true|false)", parseBoolean).action(async function pauseGame(options) {
+    await executeRemoteCommand({
+      commandName: "game.pause",
+      params: { paused: options.paused },
+      command: this,
+      dependencies
+    });
+  });
+}
+
+// src/commands/image.ts
+function registerImage({ program, dependencies }) {
+  const image = program.command("image").description("Foundry image popout commands");
+  image.addHelpText(
+    "after",
+    [
+      "",
+      "Result key (--json): .result.src, .result.title, .result.userIds, .result.activeUserIds,",
+      ".result.inactiveUserIds and .result.dispatched (show).",
+      "",
+      "`--src` takes a path inside Foundry's managed `data` source (e.g. worlds/<worldId>/art/map.webp)",
+      "or an http(s) URL. A host filesystem path is refused. Showing an image is a broadcast, not a",
+      "mutation: nothing is written and nothing can be confirmed afterwards."
+    ].join("\n")
+  );
+  image.command("show").description("Pop an image out in other users' browsers").requiredOption("--src <src>", "Managed data-relative image path or http(s) URL").option("--title <title>", "Window title (default: derived by Foundry from the source)").option(
+    "--user-ids <list>",
+    "Comma-separated user ids to show it to (default: every user); offline users are reported as skipped",
+    (value) => parseCsvList(value, "--user-ids")
+  ).action(async function showImage(options) {
+    await executeRemoteCommand({
+      commandName: "image.show",
+      params: {
+        src: options.src,
+        ...options.title !== void 0 ? { title: options.title } : {},
+        ...options.userIds ? { userIds: options.userIds } : {}
+      },
+      command: this,
+      dependencies
+    });
+  });
+}
+
 // src/commands/item.ts
 function registerItem({ program, dependencies }) {
   const { registerOwnershipSet, registerCompendiumImport, registerBatchWriteCommands } = createSharedRegistrars(dependencies);
@@ -14228,6 +16346,27 @@ delete does NOT re-point pages (Foundry rewrites nothing either); it reports how
       dependencies
     });
   });
+  journal.command("show").description("Open a journal entry in other users' browsers (a broadcast, not a mutation)").requiredOption("--journal-id <journalId>", "Journal entry id").addOption(
+    new Option8(
+      "--force <force>",
+      "Push the entry even to users who cannot normally see it (true|false)"
+    ).argParser(parseBoolean)
+  ).option(
+    "--user-ids <list>",
+    "Comma-separated user ids to show it to (default: every user); offline users are reported as skipped",
+    (value) => parseCsvList(value, "--user-ids")
+  ).action(async function showJournal(options) {
+    await executeRemoteCommand({
+      commandName: "journal.show",
+      params: {
+        journalId: options.journalId,
+        ...booleanField("force", options.force),
+        ...options.userIds ? { userIds: options.userIds } : {}
+      },
+      command: this,
+      dependencies
+    });
+  });
   registerCompendiumImport(journal, {
     commandName: "journal.import-from-compendium",
     noun: "journal entry",
@@ -14236,6 +16375,7 @@ delete does NOT re-point pages (Foundry rewrites nothing either); it reports how
 }
 
 // src/commands/macro.ts
+import { Option as Option9 } from "commander";
 function registerMacro({ program, dependencies }) {
   const { registerOwnershipSet, registerCompendiumImport } = createSharedRegistrars(dependencies);
   const macro = program.command("macro").description("Foundry macro commands");
@@ -14317,6 +16457,19 @@ function registerMacro({ program, dependencies }) {
       dependencies
     });
   });
+  macro.command("execute").description("Run a macro in the GM client and wait for it to finish").requiredOption("--macro-id <macroId>", "Macro id").option("--actor-id <actorId>", "Actor the macro receives as its `actor`/speaker").option("--scene-id <sceneId>", "Scene the token belongs to (required with --token-id)").option("--token-id <tokenId>", "Token the macro receives as its `token` (needs --scene-id)").option("--args-json <json>", "Extra scope values as a JSON object, reachable as `scope` in the macro").addOption(
+    new Option9(
+      "--macro-timeout-ms <ms>",
+      `How long the GM client waits for the macro, in ms (default ${MACRO_EXECUTE_TIMEOUT_DEFAULT_MS}, max ${MACRO_EXECUTE_TIMEOUT_MAX_MS}). Raise the global --timeout-ms above it, or the CLI stops waiting before MACRO_TIMEOUT can be reported.`
+    ).argParser(parsePositiveInt)
+  ).action(async function executeMacroCommand(options) {
+    await executeRemoteCommand({
+      commandName: "macro.execute",
+      params: createMacroExecuteParams(options),
+      command: this,
+      dependencies
+    });
+  });
   registerCompendiumImport(macro, {
     commandName: "macro.import-from-compendium",
     noun: "macro",
@@ -14325,7 +16478,7 @@ function registerMacro({ program, dependencies }) {
 }
 
 // src/commands/playlist.ts
-import { Option as Option9 } from "commander";
+import { Option as Option10 } from "commander";
 function registerPlaylist({ program, dependencies }) {
   const { registerOwnershipSet, registerCompendiumImport } = createSharedRegistrars(dependencies);
   const playlist = program.command("playlist").description("Foundry playlist commands");
@@ -14422,7 +16575,7 @@ function registerPlaylist({ program, dependencies }) {
       dependencies
     });
   });
-  playlist.command("play-next").requiredOption("--playlist-id <playlistId>", "Playlist id").option("--sound-id <soundId>", "Current sound id to advance from").addOption(new Option9("--direction <direction>", "1 (forward) or -1 (backward)").argParser(parseNumber)).action(async function playNextPlaylistCommand(options) {
+  playlist.command("play-next").requiredOption("--playlist-id <playlistId>", "Playlist id").option("--sound-id <soundId>", "Current sound id to advance from").addOption(new Option10("--direction <direction>", "1 (forward) or -1 (backward)").argParser(parseNumber)).action(async function playNextPlaylistCommand(options) {
     await executeRemoteCommand({
       commandName: "playlist.playNext",
       params: {
@@ -14525,7 +16678,7 @@ function registerPlaylist({ program, dependencies }) {
 }
 
 // src/commands/scene.ts
-import { Option as Option10 } from "commander";
+import { Option as Option11 } from "commander";
 function registerScene({ program, dependencies }) {
   const { registerOwnershipSet, registerCompendiumImport, registerBatchWriteCommands } = createSharedRegistrars(dependencies);
   const scene = program.command("scene").description("Foundry scene commands");
@@ -14604,11 +16757,36 @@ function registerScene({ program, dependencies }) {
       dependencies
     });
   });
+  scene.command("activate").description("Make a scene the active one for the whole world (a no-op reports changed:false)").requiredOption("--scene-id <sceneId>", "Scene id").action(async function activateScene(options) {
+    await executeRemoteCommand({
+      commandName: "scene.activate",
+      params: { sceneId: options.sceneId },
+      command: this,
+      dependencies
+    });
+  });
+  scene.command("pull-users").description(
+    "Pull users' views to a scene (a broadcast, not a mutation: only currently ONLINE users are reachable and nothing can be confirmed afterwards)"
+  ).requiredOption("--scene-id <sceneId>", "Scene id").option(
+    "--user-ids <list>",
+    "Comma-separated user ids to pull (default: every online user); offline users are reported as skipped",
+    (value) => parseCsvList(value, "--user-ids")
+  ).action(async function pullUsersToScene(options) {
+    await executeRemoteCommand({
+      commandName: "scene.pull-users",
+      params: {
+        sceneId: options.sceneId,
+        ...options.userIds ? { userIds: options.userIds } : {}
+      },
+      command: this,
+      dependencies
+    });
+  });
   const sceneThumbnail = scene.command("thumbnail").description("Scene thumbnail commands");
   sceneThumbnail.command("generate").requiredOption("--scene-id <sceneId>", "Scene id").addOption(
-    new Option10("--width <width>", "Thumbnail width in px (16\u20131024, default 300)").argParser(parseNumber)
+    new Option11("--width <width>", "Thumbnail width in px (16\u20131024, default 300)").argParser(parseNumber)
   ).addOption(
-    new Option10("--height <height>", "Thumbnail height in px (16\u20131024, default 100)").argParser(parseNumber)
+    new Option11("--height <height>", "Thumbnail height in px (16\u20131024, default 100)").argParser(parseNumber)
   ).option(
     "--include-thumb",
     "Include the generated base64 data URL in the response (read it with --json; the SCENE stores the extracted asset path, reported as .thumbnail.storedPath)"
@@ -15023,7 +17201,7 @@ function registerScene({ program, dependencies }) {
   });
   registerBatchWriteCommands(sceneSound, { prefix: "scene.sound", noun: "sound" });
   const sceneWall = scene.command("wall").description("Scene-embedded wall commands");
-  addPaginationOptions(sceneWall.command("list").requiredOption("--scene-id <sceneId>", "Scene id")).addOption(new Option10("--door", "Return only doors and secret doors (door > 0)")).action(async function listSceneWalls(options) {
+  addPaginationOptions(sceneWall.command("list").requiredOption("--scene-id <sceneId>", "Scene id")).addOption(new Option11("--door", "Return only doors and secret doors (door > 0)")).action(async function listSceneWalls(options) {
     await executeRemoteCommand({
       commandName: "scene.wall.list",
       params: {
@@ -15351,7 +17529,7 @@ function registerScene({ program, dependencies }) {
   const sceneRegionBehavior = sceneRegion.command("behavior").description("Region-embedded behavior commands (what a region DOES when it fires)");
   sceneRegionBehavior.addHelpText(
     "after",
-    '\nResult key (--json): .result.behavior (single/write) / .result.behaviors[] (list), with .result.sceneId and .result.regionId alongside.\nA behavior name may legitimately be BLANK (Foundry then displays the localized type label): pass --name "" to author one; the CLI prints it as (blank).\n--type is CREATE-ONLY, so update/clone have no --type. If a --patch-json carries a `type` key it is refused even when it restates the current type: drop the key and resend (an unchanged type is a no-op for Foundry). Changing a behavior\'s type really is impossible \u2014 for that, create the new behavior and delete the old one.\nThe code-executing types executeScript and executeMacro are REFUSED whenever you supply them, and every patch on an existing one is refused too (even --disabled): use delete to remove such a behavior, or edit it in the Foundry UI.\nclone with NO patch flags IS allowed on any behavior \u2014 note that cloning a code-executing one mints a NEW self-arming auto-trigger, so audit the region afterwards.'
+    "\nResult key (--json): .result.behavior (single/write) / .result.behaviors[] (list), with .result.sceneId and .result.regionId alongside.\nA behavior name may legitimately be BLANK (Foundry then displays the localized type label): pass --name \"\" to author one; the CLI prints it as (blank).\n--type is CREATE-ONLY, so update/clone have no --type. If a --patch-json carries a `type` key it is refused even when it restates the current type: drop the key and resend (an unchanged type is a no-op for Foundry). On this family changing a behavior's type is impossible \u2014 for that, create the new behavior and delete the old one.\nThe code-executing types executeScript and executeMacro are REFUSED on THIS family whenever you supply them, and every patch on an existing one is refused too (even --disabled). executeScript is refused everywhere \u2014 it runs its source in every connected player's browser. For executeMacro use `scene region behavior executable`; delete removes either type.\nclone with NO patch flags IS allowed on any behavior \u2014 note that cloning a code-executing one mints a NEW self-arming auto-trigger, so audit the region afterwards."
   );
   addNameFilterOption(
     addPaginationOptions(
@@ -15422,6 +17600,44 @@ function registerScene({ program, dependencies }) {
       dependencies
     });
   });
+  const executableBehavior = sceneRegionBehavior.command("executable").description("Region behaviors that RUN A MACRO when the region fires");
+  executableBehavior.addHelpText(
+    "after",
+    "\nResult key (--json): .result.behavior, with .result.sceneId and .result.regionId alongside \u2014 the same shape the ordinary behavior verbs return.\nThese three verbs are the only route to an executeMacro behavior. The type is fixed: there is no --type, and the behavior cannot be turned into another type later.\n--macro-uuid must name a macro in THIS world (e.g. Macro.abc123); a compendium macro or a missing uuid is refused, so the behavior never arms a trigger that points at nothing.\n--events decides WHEN the macro runs (e.g. tokenEnter), and --everyone true runs it in EVERY connected client instead of one elected executor \u2014 read it as: every player's browser executes that macro.\nclone with no patch flags mints a second armed trigger on the same region; audit the region afterwards."
+  );
+  addExecutableBehaviorFieldOptions(
+    addIdempotencyKeyOption(executableBehavior.command("create")).description("Arm a region with an executeMacro behavior").requiredOption("--scene-id <sceneId>", "Scene id").requiredOption("--region-id <regionId>", "Region id"),
+    "create"
+  ).option("--data-json <json>", "Full/extra behavior data as a JSON object (merged last)").action(async function createExecutableBehavior(options) {
+    await executeRemoteCommand({
+      commandName: "scene.region.behavior.executable.create",
+      params: createExecutableBehaviorCreateParams(options),
+      command: this,
+      dependencies
+    });
+  });
+  addExecutableBehaviorFieldOptions(
+    executableBehavior.command("update").description("Edit an executeMacro behavior (the only route the ordinary update refuses)").requiredOption("--scene-id <sceneId>", "Scene id").requiredOption("--region-id <regionId>", "Region id").requiredOption("--behavior-id <behaviorId>", "Behavior id"),
+    "update"
+  ).option("--patch-json <json>", "Full/extra behavior patch as a JSON object (merged last)").action(async function updateExecutableBehavior(options) {
+    await executeRemoteCommand({
+      commandName: "scene.region.behavior.executable.update",
+      params: createExecutableBehaviorUpdateParams(options),
+      command: this,
+      dependencies
+    });
+  });
+  addExecutableBehaviorFieldOptions(
+    addIdempotencyKeyOption(executableBehavior.command("clone")).description("Copy an executeMacro behavior into a second armed trigger").requiredOption("--scene-id <sceneId>", "Scene id").requiredOption("--region-id <regionId>", "Region id").requiredOption("--behavior-id <behaviorId>", "Source behavior id"),
+    "clone"
+  ).option("--patch-json <json>", "Override fields for the clone as a JSON object (merged last)").action(async function cloneExecutableBehavior(options) {
+    await executeRemoteCommand({
+      commandName: "scene.region.behavior.executable.clone",
+      params: createExecutableBehaviorCloneParams(options),
+      command: this,
+      dependencies
+    });
+  });
   registerCompendiumImport(scene, {
     commandName: "scene.import-from-compendium",
     noun: "scene",
@@ -15522,19 +17738,27 @@ function registerScene({ program, dependencies }) {
 }
 
 // src/commands/setting.ts
+import { Option as Option12 } from "commander";
 function registerSetting({ program, dependencies }) {
-  const setting = program.command("setting").description("Foundry game settings (read-only)");
+  const setting = program.command("setting").description("Foundry game settings");
   setting.addHelpText(
     "after",
     [
       "",
-      "Result key (--json): .result.settings[] (list, metadata only) / .result.setting (get, metadata + value).",
+      "Result key (--json): .result.settings[] (list, metadata only; get-many, metadata + value) /",
+      ".result.setting (get, metadata + value). A write returns the row's fields directly on .result",
+      "(namespace, key, scope, previous, value, requiresReload, changed) \u2014 set-many returns .result.outcomes[].",
       "",
       "Only settings REGISTERED IN THIS SESSION are visible: a value still stored in the world by a",
       "disabled/uninstalled module has no registration and reports SETTING_NOT_FOUND.",
       "`--name` matches the namespace, the key, the raw registration name AND the localized label.",
       "Scope caveats: a `client`-scope value is this GM CLIENT's localStorage value, and a `user`-scope",
-      "value is resolved for the CURRENT GM USER \u2014 neither is ever another player's value."
+      "value is resolved for the CURRENT GM USER \u2014 neither is ever another player's value.",
+      "",
+      "`set`/`set-many` always refuse the `fvtt-world-cli` namespace, so the bridge's own",
+      "authorization settings stay beyond the CLI's reach. A write whose row reports",
+      "requiresReload:true needs `system reload`",
+      "(or a manual browser reload) before Foundry acts on it."
     ].join("\n")
   );
   addNameFilterOption(addPaginationOptions(setting.command("list"))).action(
@@ -15555,6 +17779,46 @@ function registerSetting({ program, dependencies }) {
       dependencies
     });
   });
+  setting.command("get-many").description(
+    "Read several settings in ONE call (an unknown id reports its own error, not the whole call)"
+  ).requiredOption(
+    "--ids <list>",
+    'Comma-separated setting ids in "namespace.key" form (e.g. core.chatBubbles,my-module.apiKey)',
+    parseIdList
+  ).action(async function getManySettings(options) {
+    await executeRemoteCommand({
+      commandName: "setting.get-many",
+      params: { ids: options.ids },
+      command: this,
+      dependencies
+    });
+  });
+  setting.command("set").description("Write one registered setting").requiredOption("--namespace <namespace>", 'Setting namespace (e.g. "core" or a module id)').requiredOption("--key <key>", "Setting key within the namespace").requiredOption(
+    "--value-json <json>",
+    'New value as a JSON literal \u2014 true, 42, "text", [..] or {..}; a quoted string stays distinct from a boolean or a number',
+    (value) => parseJsonValue(value, "--value-json")
+  ).action(async function setSetting(options) {
+    await executeRemoteCommand({
+      commandName: "setting.set",
+      params: createSettingSetParams(options),
+      command: this,
+      dependencies
+    });
+  });
+  setting.command("set-many").description("Write several settings in ONE call (stops at the first element Foundry refuses)").addOption(
+    new Option12(
+      "--items-json <json>",
+      'Setting writes as a JSON ARRAY of {"namespace","key","value"} objects'
+    ).argParser((value) => parseSettingItems(value, "--items-json"))
+  ).addOption(new Option12("--items-stdin", "Read that JSON array from stdin instead").conflicts("itemsJson")).action(async function setManySettings(options) {
+    const items = await resolveSettingItems(options, dependencies);
+    await executeRemoteCommand({
+      commandName: "setting.set-many",
+      params: { items },
+      command: this,
+      dependencies
+    });
+  });
 }
 
 // src/commands/skill.ts
@@ -15762,10 +18026,20 @@ function registerSystem({ program, dependencies }) {
       dependencies
     });
   });
+  system.command("reload").description(
+    "Reload the GM browser page. The bridge drops and reconnects on its own; pair it with a setting whose row reports requiresReload"
+  ).action(async function reload() {
+    await executeRemoteCommand({
+      commandName: "system.reload",
+      params: {},
+      command: this,
+      dependencies
+    });
+  });
 }
 
 // src/commands/table.ts
-import { Option as Option11 } from "commander";
+import { Option as Option13 } from "commander";
 function registerTable({ program, dependencies }) {
   const { registerOwnershipSet, registerCompendiumImport } = createSharedRegistrars(dependencies);
   const table = program.command("table").description("Foundry roll table commands");
@@ -15854,12 +18128,12 @@ Action verbs differ: \`table draw\` has NO .result.table \u2014 read .result.res
     "--idempotency-key <key>",
     "REQUIRED: client-supplied key so a retried draw returns the original result instead of drawing again. Reuse the SAME key across retries of one draw."
   ).addOption(
-    new Option11(
+    new Option13(
       "--count <n>",
       "Number of draw ITERATIONS, max 100 (>1 uses RollTable#drawMany); each iteration can return several rows, so results are not capped at this number"
     ).argParser(parsePositiveInt)
   ).addOption(
-    new Option11(
+    new Option13(
       "--roll-mode <mode>",
       "Chat visibility of the draw message (translated per Foundry version; default public)"
     ).choices([...TABLE_ROLL_MODES])
@@ -15929,7 +18203,7 @@ Result key (--json): ${TABLE_RESULT_KEY_HELP}.`);
   });
   addTableResultFieldOptions(
     tableResult.command("update").requiredOption("--table-id <tableId>", "Roll table id").requiredOption("--result-id <resultId>", "Result (row) id").addOption(
-      new Option11("--range <low,high>", "New two-integer ascending roll range, e.g. 1,3").argParser(
+      new Option13("--range <low,high>", "New two-integer ascending roll range, e.g. 1,3").argParser(
         parseResultRange
       )
     ),
@@ -15944,7 +18218,7 @@ Result key (--json): ${TABLE_RESULT_KEY_HELP}.`);
   });
   addTableResultFieldOptions(
     addIdempotencyKeyOption(tableResult.command("clone")).requiredOption("--table-id <tableId>", "Roll table id").requiredOption("--result-id <resultId>", "Source result (row) id").addOption(
-      new Option11("--range <low,high>", "Range override (two ascending integers), e.g. 4,6").argParser(
+      new Option13("--range <low,high>", "Range override (two ascending integers), e.g. 4,6").argParser(
         parseResultRange
       )
     ),
@@ -15973,9 +18247,23 @@ Result key (--json): ${TABLE_RESULT_KEY_HELP}.`);
 }
 
 // src/commands/user.ts
+import { Option as Option14 } from "commander";
 function registerUser({ program, dependencies }) {
-  const user = program.command("user").description("Foundry user commands (read-only)");
-  user.addHelpText("after", "\nResult key (--json): .result.user (get) / .result.users[] (list).");
+  const user = program.command("user").description("Foundry user commands");
+  user.addHelpText(
+    "after",
+    [
+      "",
+      "Result key (--json): .result.user (get, create, update) / .result.users[] (list). `delete`,",
+      "`role set` and `permissions set` return their fields directly on .result.",
+      "",
+      "No user command accepts a password: Foundry sends passwords in the clear and hashes them",
+      "server-side, so account credentials stay outside the bridge. Neither `role set` nor `delete`",
+      "accepts the GM user the bridge itself runs through \u2014 the agent cannot demote or remove its",
+      "own account.",
+      "Roles are integers: 1=player, 2=trusted player, 3=assistant GM, 4=gamemaster."
+    ].join("\n")
+  );
   addNameFilterOption(addPaginationOptions(user.command("list"))).action(async function listUsers(options) {
     await executeRemoteCommand({
       commandName: "user.list",
@@ -15992,10 +18280,71 @@ function registerUser({ program, dependencies }) {
       dependencies
     });
   });
+  addUserFieldOptions(
+    addIdempotencyKeyOption(user.command("create")).description("Create a player account (no password is set)").requiredOption("--name <name>", "User name").addOption(
+      new Option14(
+        "--role <role>",
+        "Role for the new user (1=player, 2=trusted player, 3=assistant GM, 4=gamemaster; default player)"
+      ).argParser(parseUserRole)
+    ),
+    "create"
+  ).option("--data-json <json>", "Extra user fields (e.g. flags) as a JSON object (merged last)").action(async function createUser(options) {
+    await executeRemoteCommand({
+      commandName: "user.create",
+      params: createUserCreateParams(options),
+      command: this,
+      dependencies
+    });
+  });
+  addUserFieldOptions(
+    user.command("update").description("Edit a user's presentation fields (the role has its own command)").requiredOption("--user-id <userId>", "User id").option("--name <name>", "New user name"),
+    "update"
+  ).option("--patch-json <json>", "Extra user patch fields (e.g. flags) as a JSON object (merged last)").action(async function updateUser(options) {
+    await executeRemoteCommand({
+      commandName: "user.update",
+      params: createUserUpdateParams(options),
+      command: this,
+      dependencies
+    });
+  });
+  user.command("delete").description("Delete a user account (refuses the bridge's own GM user)").requiredOption("--user-id <userId>", "User id").action(async function deleteUser(options) {
+    await executeRemoteCommand({
+      commandName: "user.delete",
+      params: { userId: options.userId },
+      command: this,
+      dependencies
+    });
+  });
+  const userRole = user.command("role").description("User role (which capabilities the role grants)");
+  userRole.command("set").description("Set a user's role (refuses the bridge's own GM user)").requiredOption("--user-id <userId>", "User id").requiredOption(
+    "--role <role>",
+    "New role (1=player, 2=trusted player, 3=assistant GM, 4=gamemaster)",
+    parseUserRole
+  ).action(async function setUserRole(options) {
+    await executeRemoteCommand({
+      commandName: "user.role.set",
+      params: { userId: options.userId, role: options.role },
+      command: this,
+      dependencies
+    });
+  });
+  const userPermissions = user.command("permissions").description("Per-user permission overrides on top of the role defaults");
+  userPermissions.command("set").description("Grant, revoke or drop per-user permission overrides").requiredOption("--user-id <userId>", "User id").requiredOption(
+    "--permissions-json <json>",
+    'Overrides as a JSON object, e.g. {"FILES_UPLOAD":true,"MACRO_SCRIPT":false,"BROADCAST_AUDIO":null} \u2014 true grants, false revokes, null drops the override so the role default applies again. Names are validated against the installed Foundry version.',
+    parseUserPermissions
+  ).action(async function setUserPermissions(options) {
+    await executeRemoteCommand({
+      commandName: "user.permissions.set",
+      params: { userId: options.userId, permissions: options.permissionsJson },
+      command: this,
+      dependencies
+    });
+  });
 }
 
 // src/commands/world.ts
-import { Option as Option12 } from "commander";
+import { Option as Option15 } from "commander";
 function registerWorld({ program, dependencies }) {
   const world = program.command("world").description("Foundry world-wide maintenance commands");
   world.addHelpText(
@@ -16037,7 +18386,7 @@ function registerWorld({ program, dependencies }) {
   });
   addPaginationOptions(
     world.command("search").description("Search world (and optionally compendium) documents through the bridge index").requiredOption("--query <query>", "Search query (2-256 characters; terms are AND-combined)").addOption(
-      new Option12(
+      new Option15(
         "--mode <mode>",
         'Fields to search: "name" (stored names only) or "full" (names + body text + the Actor/Item system walk, with snippets)'
       ).choices([...SEARCH_MODES]).default(SEARCH_MODES[0])
@@ -16046,7 +18395,7 @@ function registerWorld({ program, dependencies }) {
       `Comma-separated document types to search: ${SEARCH_INDEXED_TYPES.join(",")} (default: all)`,
       parseSearchTypeList
     ).option("--include-compendia", "Also search compendium pack entry NAMES (off by default)").addOption(
-      new Option12(
+      new Option15(
         "--source <source>",
         'Return only one section: "world", or "pack" (which requires --include-compendia)'
       ).choices([...SEARCH_SOURCES])
@@ -16077,7 +18426,7 @@ function createProgram(partialDependencies = {}) {
     "Preview a mutation without persisting it (validates, resolves the target, runs all guards). Ignored for read commands.",
     false
   ).addOption(
-    new Option13(
+    new Option16(
       "--timeout-ms <ms>",
       "Client wait for the daemon response, in ms (default 60000). Distinct from bridge serve --request-timeout-ms."
     ).argParser(parsePositiveInt)
@@ -16120,6 +18469,8 @@ function createProgram(partialDependencies = {}) {
   registerCompendium({ program, dependencies });
   registerFolder({ program, dependencies });
   registerFile({ program, dependencies });
+  registerGame({ program, dependencies });
+  registerImage({ program, dependencies });
   applyOutputRouting(program, dependencies);
   applyExitOverride(program);
   return program;